სხვისი კოდის კითხვა

რას ისწავლი

• რატომ არის კოდის კითხვა ისეთივე მნიშვნელოვანი, როგორც წერა
• ხუთი ხერხი უცნობი კოდის გასაგებად
• როგორ აქცევს კარგი სახელი კოდს თვითახსნადად

კითხვა უფრო ხშირია, ვიდრე წერა

ნამდვილ სამუშაოზე პროგრამისტი იშვიათად იწყებს ცარიელი ფაილიდან. ჩვეულებრივ, ის უკვე არსებულ პროგრამას ამატებს ფუნქციას, ასწორებს სხვის მიერ დაწერილ შეცდომას ან ამოწმებს კოლეგის კოდს. გამოცდილი პროგრამისტები ამბობენ, რომ კოდს ათჯერ მეტს კითხულობენ, ვიდრე წერენ. ამიტომ უცნობი კოდის სწრაფად გაგება ცალკე, ძალიან ღირებული უნარია.

ხუთი ხერხი

ავიღოთ ფუნქცია, რომლის სახელიც არაფერს ამბობს:

function mystery(word) {
  let result = "";
  for (let i = word.length - 1; i >= 0; i--) {
    result += word[i];
  }
  return result;
}

1. დაიწყე შეტანითა და გამოტანით. რას იღებს ფუნქცია? ერთ სიტყვას. რას აბრუნებს? result-ს, რომელიც ცარიელი სტრიქონიდან იწყება და ციკლში იზრდება. ესე იგი, ფუნქცია ტექსტიდან ახალ ტექსტს აწყობს.

2. წაიკითხე სახელები და ჩანაწერები. ციკლი იწყება word.length - 1-დან, ანუ ბოლო ინდექსიდან, და მიდის i---ით ნულამდე. ციკლი სიტყვას ბოლოდან თავისკენ გადის.

3. შეასრულე ხელით პატარა მაგალითზე. mystery("კატა"): i = 3 → „ა“, i = 2 → „ატ“, i = 1 → „ატა“, i = 0 → „ატაკ“. სიტყვა შემობრუნდა!

4. გაუშვი და შეამოწმე ჰიპოთეზა. mystery("კოდი") უნდა დააბრუნოს „იდოკ“. თუ ასეა, გაგება სწორია.

5. დაარქვი სწორი სახელი. ახლა, როცა იცი, რას აკეთებს, ფუნქციას reverseWord უნდა ერქვას. შემდეგ ვინც ამ კოდს წაიკითხავს, მისთვის მიკვლევა აღარ იქნება საჭირო.

ექსპერიმენტი

კოდის გაგების ერთ-ერთი საუკეთესო გზაა მისი „შეჩხრეკა“: შეცვალე რამე და ნახე, რა მოხდა. რა მოხდება, თუ i >= 0-ს i > 0-ით შეცვლი? შემობრუნებულ სიტყვას პირველი ასო დააკლდება. ყოველი ასეთი ექსპერიმენტი გიჩვენებს, რისთვის არის საჭირო ესა თუ ის ხაზი. ჩასვი console.log-ებიც ციკლში, რომ ყოველი ნაბიჯი ნახო.

მხოლოდ ერთი წესი: ექსპერიმენტი ასლზე ან ისეთ ადგილას გააკეთე, სადაც არაფერს გააფუჭებ, და ბოლოს ყველაფერი დააბრუნე.

სახელები: კოდი, რომელიც თავს ხსნის

ამ თავის მთავარი გაკვეთილი შენი კოდისთვისაც მოქმედებს. შეადარე:

function f(a) {
  let x = 0;
  for (const y of a) {
    if (y >= 60) x++;
  }
  return x;
}

function countPassed(scores) {
  let passed = 0;
  for (const score of scores) {
    if (score >= 60) passed++;
  }
  return passed;
}

ორივე ერთსა და იმავეს აკეთებს. მეორე მაშინვე იკითხება, პირველს კი ხუთი ხერხი სჭირდება. როცა წერ, ყოველთვის იფიქრე შემდეგ მკითხველზე, თუნდაც ეს ერთი თვის შემდეგ შენ იყო.

სცადე თავად

ეს ფუნქცია რაღაცას ამოწმებს. გაუშვი, ნახე შედეგები და გამოიცანი, რას აკეთებს. მერე დაარქვი მას სწორი სახელი.

ხშირი შეცდომები

• ხაზ-ხაზ კითხვა თავიდან ბოლომდე, მიზნის გარეშე. ჯერ გაიგე, რას იღებს და რას აბრუნებს. დეტალები მერე.
• ვარაუდის შეუმოწმებლობა. „ალბათ ასე მუშაობს“ ჰიპოთეზაა. გაუშვი და შეამოწმე.
• ცუდი სახელის დატოვება. თუ ფუნქციის გაგებას დრო დასჭირდა, დაარქვი მას სახელი, რომელიც შემდეგ მკითხველს ამ დროს დაუზოგავს.

function isPalindrome(word) {
  for (let left = 0; left < word.length / 2; left++) {
    if (word[left] !== word[word.length - 1 - left]) {
      return false;
    }
  }
  return true;
}

console.log(isPalindrome("ანა"));
console.log(isPalindrome("კატა"));
console.log(isPalindrome("არა"));

მინი-ქვიზი

შეჯამება

• პროგრამისტი კოდს უფრო ხშირად კითხულობს, ვიდრე წერს.
• უცნობი კოდი: შეტანა და გამოტანა → სახელები → ხელით მიკვლევა → გაშვება → კარგი სახელი.
• ექსპერიმენტი და console.log გიჩვენებს, რისთვისაა საჭირო თითოეული ხაზი.
• წერე ისე, რომ შენი კოდის კითხვა სხვას ადვილად შეეძლოს.