កិច្ចការសម្ភាសន៍ JavaScript ធម្មតាចំនួន 5៖ ការវិភាគ និងដំណោះស្រាយ

ពីអ្នកបកប្រែ៖ បានបោះពុម្ពអត្ថបទសម្រាប់អ្នក Maria Antonietta Perna ដែលនិយាយអំពីកិច្ចការ JavaScript ទូទៅភាគច្រើនត្រូវបានផ្តល់ជូនអ្នកបង្កើតកម្មវិធីក្នុងអំឡុងពេលសម្ភាសន៍។ អត្ថបទនេះនឹងមានប្រយោជន៍ ជាដំបូងនៃការទាំងអស់សម្រាប់អ្នកសរសេរកម្មវិធីថ្មីថ្មោង។

សំភាសន៍នៅក្រុមហ៊ុនបច្ចេកវិជ្ជា ត្រូវបានគេនិយាយយូរមកហើយ។ នេះមិនគួរភ្ញាក់ផ្អើលទេ - ការឆ្លងកាត់ការសម្ភាសន៍ដោយជោគជ័យផ្តល់ឱ្យអ្នកនូវឱកាសដើម្បីទទួលបានការងារល្អ។ ប៉ុន្តែ​នេះ​មិន​សាមញ្ញ​ទេ ព្រោះ​បញ្ហា​ស្មុគស្មាញ​ច្រើន​តែ​ត្រូវ​ដោះស្រាយ។

លើសពីនេះទៅទៀត ភាគច្រើនជាញឹកញាប់ ការងារទាំងនេះភាគច្រើនមិនទាក់ទងនឹងការងារដែលអ្នកដាក់ពាក្យនឹងអនុវត្តនោះទេ ប៉ុន្តែពួកគេនៅតែត្រូវដោះស្រាយ។ ពេលខ្លះអ្នកត្រូវធ្វើវានៅលើក្តារ ដោយមិនចាំបាច់ពិនិត្យជាមួយ Google ឬប្រភពផ្សេងទៀតទេ។ បាទ ស្ថានភាពកំពុងផ្លាស់ប្តូរបន្តិចម្តងៗ ហើយក្រុមហ៊ុនមួយចំនួនបានបោះបង់ចោលការសម្ភាសន៍បែបនេះ ប៉ុន្តែនិយោជកជាច្រើននៅតែប្រកាន់ខ្ជាប់នូវប្រពៃណីនេះ។ អត្ថបទនេះត្រូវបានឧទ្ទិសដល់ការវិភាគនៃកិច្ចការ JavaScript ធម្មតាដែលជារឿយៗត្រូវបានប្រើជាភារកិច្ចសម្រាប់អ្នកស្វែងរកការងារ។

យើងរំលឹក៖ សម្រាប់អ្នកអានទាំងអស់នៃ "Habr" - ការបញ្ចុះតម្លៃ 10 rubles នៅពេលចុះឈ្មោះក្នុងវគ្គសិក្សា Skillbox ណាមួយដោយប្រើលេខកូដផ្សព្វផ្សាយ "Habr" ។

Skillbox ណែនាំ៖ វគ្គសិក្សាជាក់ស្តែង "អ្នកអភិវឌ្ឍន៍ចល័ត PRO".

រឿងចំបងគឺត្រូវរៀបចំឱ្យបានហ្មត់ចត់សម្រាប់ការសម្ភាសន៍របស់អ្នក។

បាទ / ចាស មុននឹងយើងចាប់ផ្តើមមើលភារកិច្ច សូមក្រឡេកមើលការណែនាំទូទៅមួយចំនួនក្នុងការរៀបចំសំភាសន៍។

រឿងចំបងគឺត្រូវរៀបចំជាមុន។ សាកល្បងថាតើអ្នកចងចាំក្បួនដោះស្រាយ និងរចនាសម្ព័ន្ធទិន្នន័យបានល្អប៉ុណ្ណា ហើយកែលម្អចំណេះដឹងរបស់អ្នកនៅក្នុងផ្នែកដែលអ្នកមិនសូវស្គាល់។ មានវេទិកាអនឡាញជាច្រើនដែលអាចជួយអ្នករៀបចំសម្រាប់ការសម្ភាសន៍។ យើងណែនាំ geeksforgeeks, ព្រុំ, Interviewing.io и កូដស៊ីលីក.

វាមានតម្លៃរៀននិយាយការសម្រេចចិត្តឱ្យខ្លាំងៗ។ វាគឺជាទីប្រឹក្សាដើម្បីប្រាប់បេក្ខជនអំពីអ្វីដែលអ្នកធ្វើ ហើយមិនត្រឹមតែសរសេរនៅលើក្តារនោះទេ (ឬវាយកូដទៅក្នុងកុំព្យូទ័រក៏ស្ងាត់ដែរ)។ វិធីនេះ ប្រសិនបើអ្នកធ្វើខុសក្នុងកូដ ប៉ុន្តែដំណោះស្រាយជាទូទៅត្រឹមត្រូវ អ្នកអាចបង្កើនឱកាសជោគជ័យ។

អ្នកត្រូវយល់ពីបញ្ហាមុនពេលអ្នកចាប់ផ្តើមដោះស្រាយវា។ ក្នុង​ករណី​ខ្លះ អ្នក​អាច​នឹង​យល់​កិច្ចការ​មួយ​ដោយ​ស្រពិចស្រពិល ហើយ​បន្ទាប់​មក​ចុះ​ទៅ​ផ្លូវ​ខុស។ វាអាចមានតម្លៃក្នុងការសួរសំណួរច្បាស់លាស់មួយចំនួនទៅកាន់អ្នកសម្ភាសន៍។

អ្នកត្រូវហាត់សរសេរកូដដោយដៃ មិនមែននៅលើកុំព្យូទ័រទេ។ វាកើតឡើងថាក្នុងអំឡុងពេលសម្ភាសន៍ បេក្ខជនត្រូវបានផ្តល់សញ្ញាសម្គាល់ និងក្តារខៀន ដែលមិនមានការណែនាំ ឬការធ្វើទ្រង់ទ្រាយដោយស្វ័យប្រវត្តិ។ នៅពេលស្វែងរកដំណោះស្រាយ វាមានតម្លៃសរសេរកូដរបស់អ្នកនៅលើក្រដាសមួយ ឬដោយផ្ទាល់នៅលើក្តារ។ ប្រសិនបើអ្នករក្សាអ្វីៗគ្រប់យ៉ាងនៅក្នុងក្បាលរបស់អ្នក អ្នកអាចភ្លេចអ្វីមួយដែលសំខាន់។

ភារកិច្ចគំរូនៅក្នុង JavaScript

កិច្ចការទាំងនេះមួយចំនួនប្រហែលជាធ្លាប់ស្គាល់អ្នករួចហើយ។ អ្នកធ្លាប់មានការសម្ភាសន៍ដែលអ្នកត្រូវដោះស្រាយអ្វីមួយស្រដៀងគ្នា ឬអនុវត្តលើពួកគេពេលកំពុងរៀន JavaScript។ មែនហើយ ឥឡូវនេះ វាដល់ពេលដែលត្រូវដោះស្រាយពួកគេម្តងទៀត ហើយជាមួយនឹងការពន្យល់លម្អិតអំពីដំណើរការនេះ។

ប៉ាលីនដ្រូម

Palindrome គឺជាពាក្យ ប្រយោគ ឬលំដាប់នៃតួអក្សរដែលត្រូវបានអានដូចគ្នាទាំងក្នុងទិសដៅធម្មតា និងក្នុងទិសដៅផ្ទុយ។ ឧទាហរណ៍ "អាណា" គឺជា palindrome ប៉ុន្តែ "តុ" និង "ចន" មិនមែនទេ។

ដំណាក់កាល

បានផ្តល់ឱ្យខ្សែមួយ; អ្នក​ត្រូវ​សរសេរ​អនុគមន៍​មួយ​ដែល​អនុញ្ញាត​ឱ្យ​អ្នក​ត្រឡប់​ពិត​ប្រសិន​បើ​ខ្សែ​អក្សរ​គឺ​ជា​ palindrome ហើយ​មិន​ពិត​ប្រសិន​បើ​មិនមែន។ ក្នុងករណីនេះ អ្នកត្រូវគិតគូរពីចន្លោះ និងសញ្ញាវណ្ណយុត្តិ។

palindrome('racecar') === ពិត
palindrome('តារាង') === មិនពិត

ចូរយើងវិភាគកិច្ចការ

គំនិតសំខាន់នៅទីនេះគឺការបញ្ច្រាសខ្សែ។ ប្រសិនបើខ្សែអក្សរ "បញ្ច្រាស" គឺដូចគ្នាបេះបិទទាំងស្រុងទៅនឹងអក្សរដើម នោះយើងបានទទួល palindrome ហើយមុខងារគួរតែត្រឡប់ពិត។ បើមិនដូច្នោះទេមិនពិត។

ការសម្រេចចិត្ត

នេះគឺជាកូដដែលដោះស្រាយ palindrome ។

const palindrome = str => {
  // turn the string to lowercase
  str = str.toLowerCase()
  // reverse input string and return the result of the
  // comparisong
  return str === str.split('').reverse().join('')
}

ជំហានដំបូងគឺត្រូវបំប្លែងតួអក្សរក្នុងខ្សែអក្សរបញ្ចូលទៅជាអក្សរតូច។ នេះ​ជាការ​ធានា​ថា​កម្មវិធី​នឹង​ប្រៀបធៀប​តួអង្គ​ខ្លួនឯង​មិនមែន​ជា​ករណី​ឬ​អ្វី​ផ្សេងទៀត​ទេ។

ជំហានទីពីរគឺត្រូវបញ្ច្រាសបន្ទាត់។ វាមិនពិបាកធ្វើទេ៖ អ្នកត្រូវបំប្លែងវាទៅជាអារេដោយប្រើវិធីសាស្ត្រ .split() (String library)។ បន្ទាប់មកយើងបញ្ច្រាសអារេដោយប្រើ .reverse() (បណ្ណាល័យអារេ)។ ជំហានចុងក្រោយគឺត្រូវបំប្លែងអារេបញ្ច្រាសទៅជាខ្សែអក្សរដោយប្រើ .join() (បណ្ណាល័យអារេ)។

ឥឡូវនេះអ្វីដែលអ្នកត្រូវធ្វើគឺប្រៀបធៀបខ្សែអក្សរ "បញ្ច្រាស" ជាមួយខ្សែអក្សរដើម ត្រឡប់លទ្ធផលពិតឬមិនពិត។

FizzBuzz

កិច្ចការដ៏ពេញនិយមបំផុតមួយនៅក្នុងការសម្ភាសន៍។

ដំណាក់កាល

អ្នកត្រូវសរសេរមុខងារដែលបោះពុម្ពលេខពី 1 ដល់ n ទៅកាន់កុងសូល ដែល n ជាចំនួនគត់ដែលមុខងារយកជាប៉ារ៉ាម៉ែត្រដោយមានលក្ខខណ្ឌដូចខាងក្រោមៈ

• លទ្ធផល fizz ជំនួសឱ្យការគុណនៃ 3;
• លទ្ធផល buzz ជំនួសឱ្យលេខដែលគុណនឹង 5;
• លទ្ធផល fizzbuzz ជំនួសឱ្យលេខដែលមានគុណទាំង 3 និង 5 ។

ឧទាហរណ៍:

Fizzbuzz(5)

លទ្ធផល

// ឆ្នាំ ២០០៨
// ឆ្នាំ ២០០៨
// ហ្វីស
// ឆ្នាំ ២០០៨
// ការភ្ញាក់ផ្អើល

ចូរយើងវិភាគកិច្ចការ

រឿងសំខាន់នៅទីនេះគឺជាវិធីមួយដើម្បីស្វែងរកពហុគុណដោយប្រើ JavaScript ។ វា​អាច​ត្រូវ​បាន​អនុវត្ត​ដោយ​ប្រើ​ប្រតិបត្តិករ​ម៉ូឌុល​ឬ​លេខ​ដែល​នៅ​សល់ -% ដែល​អនុញ្ញាត​ឱ្យ​អ្នក​បង្ហាញ​ចំនួន​ដែល​នៅ​សល់​ពេល​ចែក​លេខ​ពីរ។ ប្រសិនបើនៅសល់គឺ 0 វាមានន័យថាលេខទីមួយគឺជាពហុគុណនៃទីពីរ។

12% 5 // 2 --> 12 មិនមែនជាពហុគុណនៃ 5
12% 3 // 0 -> 12 គឺជាពហុគុណនៃ 3

ដូច្នេះ ប្រសិនបើអ្នកចែក 12 គុណនឹង 5 អ្នកទទួលបាន 2 ជាមួយនឹងនៅសល់នៃ 2។ ប្រសិនបើអ្នកចែក 12 គុណនឹង 3 អ្នកទទួលបាន 4 ជាមួយនឹងនៅសល់នៃ 0។ ក្នុងករណីទីមួយ 12 មិនមែនជាផលគុណនៃ 5 ទេ ទីពីរ , 12 គឺជាពហុគុណនៃ 3 ។

ការសម្រេចចិត្ត

ដំណោះ​ស្រាយ​ដ៏​ល្អ​បំផុត​នឹង​ជា​កូដ​ដូច​ខាង​ក្រោម៖

const fizzBuzz = num => {
  for(let i = 1; i <= num; i++) {
    // check if the number is a multiple of 3 and 5
    if(i % 3 === 0 && i % 5 === 0) {
      console.log('fizzbuzz')
    } // check if the number is a multiple of 3
      else if(i % 3 === 0) {
      console.log('fizz')
    } // check if the number is a multiple of 5
      else if(i % 5 === 0) {
      console.log('buzz')
    } else {
      console.log(i)
    }
  }
}

មុខងារអនុវត្តការត្រួតពិនិត្យចាំបាច់ដោយប្រើសេចក្តីថ្លែងការណ៍តាមលក្ខខណ្ឌ និងបង្កើតលទ្ធផលដែលត្រូវការដោយអ្នកប្រើប្រាស់។ នៅក្នុងបញ្ហា វាគឺមានតម្លៃក្នុងការយកចិត្តទុកដាក់លើលំដាប់នៃសេចក្តីថ្លែងការណ៍ if...else៖ ចាប់ផ្តើមដោយលក្ខខណ្ឌទ្វេ (&&) ហើយបញ្ចប់ដោយករណីដែលលេខច្រើនមិនអាចត្រូវបានរកឃើញ។ ជាលទ្ធផលយើងគ្របដណ្តប់ជម្រើសទាំងអស់។

អាណាក្រាម

នេះគឺជាឈ្មោះសម្រាប់ពាក្យដែលមានអក្សរទាំងអស់នៃពាក្យផ្សេងទៀតនៅក្នុងលេខដូចគ្នា ប៉ុន្តែនៅក្នុងលំដាប់ផ្សេងគ្នា។

ដំណាក់កាល

យើង​ត្រូវ​សរសេរ​មុខងារ​ដែល​ពិនិត្យ​មើល​ថា​តើ​ខ្សែ​ពីរ​ជា​អាណាក្រាម​ឬ​អត់​ ហើយ​ករណី​មិន​មាន​បញ្ហា​ទេ។ មានតែតួអក្សរប៉ុណ្ណោះដែលត្រូវបានរាប់; ចន្លោះ ឬសញ្ញាវណ្ណយុត្តិមិនត្រូវបានគេយកមកពិចារណាទេ។

anagram('finder', 'មិត្ត') —> ពិត
anagram('ជំរាបសួរ', 'លា') —> មិនពិត

ចូរយើងវិភាគកិច្ចការ

រឿងសំខាន់ដែលត្រូវពិចារណានៅទីនេះ គឺអ្នកត្រូវពិនិត្យមើលអក្សរនីមួយៗក្នុងបន្ទាត់បញ្ចូលពីរ និងលេខរបស់វាក្នុងបន្ទាត់នីមួយៗ។

អ្នកស្វែងរក —> f: 1 friend —> f: 1
ខ្ញុំ: 1 r: 1
n: 1 i: 1
d: 1 អ៊ី: 1
e: 1 n: 1
r: 1 ឃ: 1

ដើម្បីរក្សាទុកទិន្នន័យអាណាក្រាម អ្នកគួរតែជ្រើសរើសរចនាសម្ព័ន្ធដូចជាវត្ថុ JavaScript ជាដើម។ គន្លឹះក្នុងករណីនេះគឺជាតួអក្សរនៃអក្សរតម្លៃគឺជាចំនួនពាក្យដដែលៗរបស់វានៅក្នុងបន្ទាត់បច្ចុប្បន្ន។

មានលក្ខខណ្ឌផ្សេងទៀត៖

• អ្នកត្រូវប្រាកដថាករណីនៃអក្សរមិនត្រូវបានយកមកពិចារណានៅពេលប្រៀបធៀប។ យើងគ្រាន់តែបំប្លែងខ្សែទាំងពីរទៅជាអក្សរតូច ឬធំ។
• យើងដកតួអក្សរដែលមិនមែនជាតួអក្សរទាំងអស់ចេញពីការប្រៀបធៀប។ ល្អបំផុតដើម្បីធ្វើការជាមួយ កន្សោមធម្មតា។.

ការសម្រេចចិត្ត

// helper function that builds the
// object to store the data
const buildCharObject = str => {
  const charObj = {}
  for(let char of str.replace(/[^w]/g).toLowerCase()) {
    // if the object has already a key value pair
    // equal to the value being looped over,
    // increase the value by 1, otherwise add
    // the letter being looped over as key and 1 as its value
    charObj[char] = charObj[char] + 1 || 1
  }
  return charObj
}
 
// main function
const anagram = (strA, strB) => {
  // build the object that holds strA data
  const aCharObject = buildCharObject(strA)
  // build the object that holds strB data
  const bCharObject = buildCharObject(strB)
 
  // compare number of keys in the two objects
  // (anagrams must have the same number of letters)
  if(Object.keys(aCharObject).length !== Object.keys(bCharObject).length) {
    return false
  }
  // if both objects have the same number of keys
  // we can be sure that at least both strings
  // have the same number of characters
  // now we can compare the two objects to see if both
  // have the same letters in the same amount
  for(let char in aCharObject) {
    if(aCharObject[char] !== bCharObject[char]) {
      return false
    }
  }
  // if both the above checks succeed,
  // you have an anagram: return true
  return true
}

យកចិត្តទុកដាក់ចំពោះការប្រើប្រាស់ Object.keys() នៅក្នុងអត្ថបទខាងលើ។ វិធី​សា​ស្រ្ត​នេះ​ត្រឡប់​អារេ​ដែល​មាន​ឈ្មោះ ឬ​គ្រាប់ចុច​ក្នុង​លំដាប់​ដូចគ្នា​ដែល​ពួកវា​បង្ហាញ​ក្នុង​វត្ថុ។ ក្នុងករណីនេះអារេនឹងមានដូចនេះ៖

['f', 'i', 'n', 'd', 'e', ​​'r']

វិធីនេះយើងទទួលបានលក្ខណៈសម្បត្តិរបស់វត្ថុដោយមិនចាំបាច់ធ្វើរង្វិលជុំច្រើន។ ក្នុង​បញ្ហា អ្នក​អាច​ប្រើ​វិធី​នេះ​ជាមួយ​លក្ខណសម្បត្តិ .length ដើម្បី​ពិនិត្យ​មើល​ថា​តើ​ខ្សែអក្សរ​ទាំងពីរ​មាន​ចំនួន​តួ​អក្សរ​ដូចគ្នា​ដែរ​ឬ​អត់ - នេះគឺជា​លក្ខណៈ​សំខាន់​របស់​អាណាក្រាម។

ស្វែងរកស្រៈ

កិច្ចការដ៏សាមញ្ញមួយ ដែលតែងតែកើតឡើងនៅក្នុងការសម្ភាសន៍។

ដំណាក់កាល

អ្នក​ត្រូវ​សរសេរ​អនុគមន៍​ដែល​យក​ខ្សែអក្សរ​ជា​អាគុយម៉ង់ ហើយ​ត្រឡប់​ចំនួន​ស្រៈ​ដែល​មាន​ក្នុង​ខ្សែអក្សរ។
ស្រៈគឺ "a", "e", "i", "o", "u" ។

ឧទាហរណ៍:

findVowels('សួស្តី') // —> ២
findVowels('why') // —> ០

ការសម្រេចចិត្ត

នេះជាជម្រើសដ៏សាមញ្ញបំផុត៖

const findVowels = str => {
  let count = 0
  const vowels = ['a', 'e', 'i', 'o', 'u']
  for(let char of str.toLowerCase()) {
    if(vowels.includes(char)) {
      count++
    }
  }
  return count
}

វាមានសារៈសំខាន់ណាស់ក្នុងការយកចិត្តទុកដាក់លើការប្រើប្រាស់វិធីសាស្ត្រ .includes() ។ វាអាចប្រើបានសម្រាប់ទាំងខ្សែអក្សរ និងអារេ។ វាគួរតែត្រូវបានប្រើដើម្បីកំណត់ថាតើអារេមួយមានតម្លៃជាក់លាក់ឬអត់។ វិធី​សា​ស្រ្ត​នេះ​ត្រឡប់​ពិត​ប្រសិន​បើ​អារេ​មាន​តម្លៃ​ដែល​បាន​បញ្ជាក់​និង​មិន​ពិត​ប្រសិន​បើ​វា​មិន​មាន​។

មានដំណោះស្រាយខ្លីជាងចំពោះបញ្ហា៖

const findVowels = str => {
  const matched = str.match(/[aeiou]/gi)
  return matched ? matches.length : 0
}

វាប្រើវិធីសាស្ត្រ .match() ដែលអនុញ្ញាតឱ្យអ្នកអនុវត្តការស្វែងរកប្រកបដោយប្រសិទ្ធភាព។ ប្រសិនបើកន្សោមធម្មតាជាអាគុយម៉ង់វិធីសាស្រ្តត្រូវបានរកឃើញនៅខាងក្នុងខ្សែអក្សរដែលបានបញ្ជាក់នោះតម្លៃត្រឡប់គឺជាអារេនៃតួអក្សរដែលត្រូវគ្នា។ ជាការប្រសើរណាស់ ប្រសិនបើមិនមានការផ្គូផ្គងទេនោះ .match() ត្រឡប់ជា null ។

ហ្វីបូណាស៊ី

កិច្ចការបុរាណដែលអាចត្រូវបានរកឃើញនៅក្នុងការសម្ភាសន៍នៅកម្រិតផ្សេងៗ។ គួររំលឹកឡើងវិញថា លំដាប់ Fibonacci គឺជាស៊េរីនៃលេខ ដែលលេខបន្តបន្ទាប់នីមួយៗ គឺជាផលបូកនៃលេខពីរមុន។ ដូច្នេះលេខដប់ដំបូងមើលទៅដូចនេះ: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ។

ដំណាក់កាល

អ្នក​ត្រូវ​សរសេរ​អនុគមន៍​ដែល​ត្រឡប់​កំណត់ត្រា​ទី n ក្នុង​លំដាប់​ជាក់លាក់​មួយ ដោយ n ជា​លេខ​ដែល​ត្រូវ​បាន​បញ្ជូន​ជា​អាគុយម៉ង់​ទៅ​អនុគមន៍។

fibonacci (3) // —> ២

កិច្ចការនេះពាក់ព័ន្ធនឹងការដើរកាត់រង្វិលជុំចំនួនដងដែលបានបញ្ជាក់នៅក្នុងអាគុយម៉ង់ ត្រឡប់តម្លៃនៅទីតាំងសមស្រប។ វិធីនៃការបង្កបញ្ហានេះតម្រូវឱ្យប្រើរង្វិលជុំ។ ប្រសិនបើអ្នកប្រើការហៅឡើងវិញជំនួសវិញ វាអាចផ្គាប់ចិត្តអ្នកសម្ភាសន៍ និងផ្តល់ឱ្យអ្នកនូវចំណុចបន្ថែមមួយចំនួន។

ការសម្រេចចិត្ត

const fibonacci = num => {
  // store the Fibonacci sequence you're going
  // to generate inside an array and
  // initialize the array with the first two
  // numbers of the sequence
  const result = [0, 1]
 
  for(let i = 2; i <= num; i++) {
    // push the sum of the two numbers
    // preceding the position of i in the result array
    // at the end of the result array
    const prevNum1 = result[i - 1]
    const prevNum2 = result[i - 2]
    result.push(prevNum1 + prevNum2)
  }
  // return the last value in the result array
  return result[num]
}

នៅក្នុងអារេលទ្ធផល លេខពីរដំបូងមាននៅក្នុងស៊េរី ពីព្រោះធាតុនីមួយៗនៅក្នុងលំដាប់គឺជាផលបូកនៃលេខពីរមុន។ នៅដើមដំបូងមិនមានលេខពីរដែលអាចយកដើម្បីទទួលបានលេខបន្ទាប់ទេ ដូច្នេះរង្វិលជុំមិនអាចបង្កើតពួកវាដោយស្វ័យប្រវត្តិបានទេ។ ប៉ុន្តែដូចដែលយើងដឹងស្រាប់ លេខពីរដំបូងតែងតែជា 0 និង 1។ ដូច្នេះហើយ អ្នកអាចចាប់ផ្តើមអារេលទ្ធផលដោយដៃ។

ចំពោះការនិយាយឡើងវិញ អ្វីៗគឺសាមញ្ញ និងស្មុគស្មាញជាងក្នុងពេលតែមួយ៖

const fibonacci = num => {
  // if num is either 0 or 1 return num
  if(num < 2) {
    return num
  }
  // recursion here
  return fibonacci(num - 1) + fibonacci(num - 2)
}

យើងបន្តហៅ fibonacci() ដោយឆ្លងកាត់លេខតូច និងតូចជាងជាអាគុយម៉ង់។ យើងឈប់នៅពេលដែលអាគុយម៉ង់ដែលបានអនុម័តគឺ 0 ឬ 1 ។

សេចក្តីសន្និដ្ឋាន

ភាគច្រើន អ្នកបានជួបប្រទះនឹងកិច្ចការទាំងនេះរួចហើយ ប្រសិនបើអ្នកត្រូវបានសម្ភាសន៍សម្រាប់ការងារផ្នែកខាងមុខ ឬអ្នកអភិវឌ្ឍន៍ JavaScript (ជាពិសេសប្រសិនបើវានៅកម្រិតតូច)។ ប៉ុន្តែប្រសិនបើអ្នកមិនបានជួបពួកវាទេ ពួកវាអាចមានប្រយោជន៍នៅពេលអនាគត យ៉ាងហោចណាស់សម្រាប់ការអភិវឌ្ឍន៍ទូទៅ។

Skillbox ណែនាំ៖

• បានអនុវត្តវគ្គសិក្សាតាមអ៊ីនធឺណិត "អ្នកវិភាគទិន្នន័យ Python".
• វគ្គសិក្សាតាមអ៊ីនធឺណិត "អ្នកអភិវឌ្ឍន៍មុខជំនាញ".
• វគ្គសិក្សាជាក់ស្តែងឆ្នាំ "អ្នកអភិវឌ្ឍន៍ PHP ពី 0 ដល់ PRO".

ប្រភព: www.habr.com