ပုံမှန် JavaScript အင်တာဗျူး လုပ်ဆောင်စရာ ၅ ခု- ခွဲခြမ်းစိတ်ဖြာမှုနှင့် ဖြေရှင်းချက်များ

ဘာသာပြန်သူထံမှ သင့်အတွက် ဆောင်းပါးတစ်ပုဒ် ထုတ်ဝေခဲ့သည်။ ယေဘူယျ JavaScript လုပ်ဆောင်စရာများအကြောင်း ပြောဆိုနေသူ Maria Antonietta Pernaအင်တာဗျူးများအတွင်း developer လျှောက်ထားသူများကို အများဆုံးပေးလေ့ရှိသည်။ ဆောင်းပါးသည် ပရိုဂရမ်အသစ်များအတွက် ပထမဆုံးအနေနှင့် အသုံးဝင်ပါလိမ့်မည်။

နည်းပညာကုမ္ပဏီများတွင် အင်တာဗျူးများသည် ဟိုးလေးတကျော်ဖြစ်ခဲ့သည်။ ဒါက အံ့သြစရာတော့ မဖြစ်သင့်ပါဘူး - အင်တာဗျူးတစ်ခုကို အောင်မြင်စွာဖြတ်သန်းခြင်းက သင့်အား အလုပ်ကောင်းတစ်ခုရရန် အခွင့်အလမ်းပေးသည်။ ဒါပေမယ့် ရှုပ်ထွေးတဲ့ ပြဿနာတွေကို မကြာခဏ ဖြေရှင်းဖို့ လိုအပ်တာကြောင့် ဒါက သိပ်မရိုးရှင်းပါဘူး။

ထို့အပြင်၊ အများစုမှာ၊ ဤအလုပ်အများစုသည် လျှောက်ထားသူလုပ်ဆောင်မည့်အလုပ်နှင့် မသက်ဆိုင်သော်လည်း ၎င်းတို့ကို ဖြေရှင်းရန် လိုအပ်နေသေးသည်။ တစ်ခါတစ်ရံတွင် Google သို့မဟုတ် အခြားအရင်းအမြစ်ကို မစစ်ဆေးဘဲ ၎င်းကို ဘုတ်ပေါ်တွင် ပြုလုပ်ရမည်ဖြစ်သည်။ ဟုတ်တယ်၊ အခြေအနေတွေက တဖြည်းဖြည်း ပြောင်းလဲလာပြီး ကုမ္ပဏီတချို့က အဲဒီလို အင်တာဗျူးတွေကို စွန့်လွှတ်လိုက်ပေမယ့် အလုပ်ရှင်တော်တော်များများက ဒီအစဉ်အလာကို လိုက်နာနေကြဆဲပါ။ ဤဆောင်းပါးသည် အလုပ်ရှာဖွေသူများအတွက် အလုပ်များအဖြစ် မကြာခဏအသုံးပြုလေ့ရှိသော ပုံမှန် JavaScript လုပ်ဆောင်ချက်များကို ခွဲခြမ်းစိတ်ဖြာခြင်းအတွက် ရည်ရွယ်ပါသည်။

ငါတို့မင်းကိုသတိပေးတယ် "Habr" ၏စာဖတ်သူအားလုံးအတွက် - "Habr" ပရိုမိုးရှင်းကုဒ်ကို အသုံးပြု၍ မည်သည့် Skillbox သင်တန်းတွင်စာရင်းသွင်းသည့်အခါ 10 ရူဘယ်လျှော့စျေး။

Skillbox မှ အကြံပြုထားသည်- လက်တွေ့သင်တန်း "မိုဘိုင်း Developer PRO".

အဓိကကတော့ အင်တာဗျူးအတွက် သေချာပြင်ဆင်ထားဖို့ပါပဲ။

ဟုတ်ကဲ့၊ အလုပ်တွေကို မစခင် ယေဘူယျ အင်တာဗျူး ပြင်ဆင်မှု အကြံပြုချက်တချို့ကို ကြည့်ကြရအောင်။

အဓိကကတော့ ကြိုတင်ပြင်ဆင်ထားဖို့ပါပဲ။ အယ်လဂိုရီသမ်များနှင့် ဒေတာဖွဲ့စည်းပုံများကို သင်မည်မျှ ကောင်းစွာမှတ်မိကြောင်း စမ်းသပ်ပြီး သင်နှင့် သိပ်မရင်းနှီးသော နယ်ပယ်များတွင် သင့်အသိပညာကို မြှင့်တင်ပါ။ အင်တာဗျူးများအတွက် ကြိုတင်ပြင်ဆင်ရန် ကူညီပေးနိုင်သည့် အွန်လိုင်းပလက်ဖောင်းများစွာရှိသည်။ ငါတို့အကြံပေးတယ်။ geeksforgeeks, ဖောင်တိန်, Interviewing.io и CodeSignal.

ဆုံးဖြတ်ချက်ကို အသံကျယ်ကျယ်ပြောဖို့ သင်ယူရကျိုးနပ်ပါတယ်။ လျှောက်ထားသူများအား သင်ဘာလုပ်သည်ကို ပြောပြရန် အကြံပြုလိုသည်မှာ ဘုတ်ပေါ်တွင် ရေးရုံမျှမက (သို့မဟုတ် ကွန်ပျူတာထဲသို့ ကုဒ်ကို တိတ်တဆိတ် ရိုက်ထည့်ပါ)။ ဤနည်းအားဖြင့်၊ သင်သည် ကုဒ်တွင် အမှားလုပ်မိသော်လည်း အဖြေသည် ယေဘူယျအားဖြင့် မှန်ကန်ပါက၊ သင်သည် သင်၏ အောင်မြင်မှု အခွင့်အလမ်းကို တိုးစေနိုင်သည်။

မဖြေရှင်းခင်မှာ ပြဿနာကို နားလည်ဖို့ လိုပါတယ်။ အချို့ကိစ္စများတွင် သင်သည် အလုပ်တစ်ခုကို အပေါ်ယံနားလည်ပြီး မှားယွင်းသောလမ်းကြောင်းကို ရောက်သွားနိုင်သည်။ အင်တာဗျူးသူထံ ရှင်းလင်းပြတ်သားသော မေးခွန်းအချို့ကို မေးသင့်သည်။

PC မှာမဟုတ်ဘဲ လက်နဲ့ ကုဒ်ရေးတတ်ဖို့ လေ့ကျင့်ဖို့ လိုပါတယ်။ အင်တာဗျူးများအတွင်း လျှောက်ထားသူအား အရိပ်အမြွက် သို့မဟုတ် အလိုအလျောက်ဖော်မတ်ချခြင်း မရှိသည့် အမှတ်အသားတစ်ခုနှင့် whiteboard ကို ပေးထားသည်။ အဖြေကိုရှာသောအခါ၊ သင်၏ကုဒ်ကို စာရွက်တစ်ရွက်ပေါ်တွင် သို့မဟုတ် ဘုတ်ပေါ်တွင် တိုက်ရိုက်ချရေးသင့်သည်။ အရာရာတိုင်းကို ခေါင်းထဲမှာ သိမ်းထားရင် အရေးကြီးတဲ့အရာတစ်ခုကို မေ့သွားနိုင်ပါတယ်။

JavaScript တွင် နမူနာပုံစံ လုပ်ဆောင်စရာများ

ဤအလုပ်များထဲမှ အချို့သည် သင့်အတွက် ရင်းနှီးပြီးသားဖြစ်ကောင်းဖြစ်နိုင်သည်။ သင် အလားတူ တစ်ခုခုကို ဖြေရှင်းရန် အင်တာဗျူးများ ရှိခဲ့ဖူးသည် သို့မဟုတ် JavaScript ကို သင်ယူနေစဉ် ၎င်းတို့ကို လေ့ကျင့်ခဲ့သည်။ ကဲ၊ အခု အဲဒါတွေကို ပြန်ပြီး ဖြေရှင်းရမယ့် အချိန်ရောက်ပြီ၊ လုပ်ငန်းစဉ်ရဲ့ အသေးစိတ် ရှင်းပြချက်ပါ။

Palindrome

palindrome ဆိုသည်မှာ ပုံမှန် ဦးတည်ချက်နှင့် ဆန့်ကျင်ဘက် ဦးတည်ချက် နှစ်ခုလုံး အတိအကျတူညီစွာ ဖတ်နိုင်သော စာလုံးများ၊ ဝါကျ သို့မဟုတ် အစီအစဥ် တစ်ခုဖြစ်သည်။ ဥပမာအားဖြင့်၊ "အန်နာ" သည် ပလင်ဒရုန်းဖြစ်သော်လည်း "စားပွဲ" နှင့် "ဂျွန်" မဟုတ်ပါ။

ဇာတ်စင်

ကြိုးတစ်ချောင်းပေးသည်; string သည် palindrome ဖြစ်ပြီး မဟုတ်ပါက false ကို အမှန်ပြန်ပို့နိုင်စေမည့် function ကို ရေးရန်လိုအပ်သည်။ ဤကိစ္စတွင်၊ သင်သည် နေရာလွတ်များနှင့် ပုဒ်ဖြတ်အမှတ်အသားများကို ထည့်သွင်းစဉ်းစားရန် လိုအပ်သည်။

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('')
}

ပထမအဆင့်မှာ input string မှ စာလုံးများကို စာလုံးအသေးသို့ ပြောင်းရန်ဖြစ်သည်။ ၎င်းသည် ပရိုဂရမ်သည် ဇာတ်ကောင်များကို ၎င်းတို့ကိုယ်တိုင် နှိုင်းယှဉ်မည်မဟုတ်ဘဲ ဖြစ်ရပ်မှန် သို့မဟုတ် အခြားမည်သည့်အရာမှ မဟုတ်ဘဲ အာမခံချက်ဖြစ်သည်။

ဒုတိယအဆင့်ကတော့ မျဉ်းကြောင်းပြန်ပြောင်းဖို့ပါ။ ဒါကလုပ်ဖို့မခက်ပါဘူး- .split() method (String library) ကို အသုံးပြု၍ ၎င်းကို array တစ်ခုအဖြစ်သို့ ပြောင်းရန်လိုအပ်ပါသည်။ ထို့နောက် ကျွန်ုပ်တို့သည် .reverse() (Array library) ကို အသုံးပြု၍ array ကို ပြောင်းပြန်လှန်သည်။ နောက်ဆုံးအဆင့်မှာ reverse array ကို .join() (Array library) သုံးပြီး string တစ်ခုသို့ ပြောင်းရန်ဖြစ်သည်။

ယခုသင်လုပ်ရန်လိုအပ်သည်မှာ “ပြောင်းပြန်” စာကြောင်းကို မူရင်းစာကြောင်းနှင့် နှိုင်းယှဉ်ကာ ရလဒ်အမှန် သို့မဟုတ် အမှားကို ပြန်ပေးခြင်းဖြစ်သည်။

FizzBuzz

အင်တာဗျူးများတွင် ရေပန်းအစားဆုံး အလုပ်များထဲမှ တစ်ခု။

ဇာတ်စင်

နံပါတ်များကို 1 မှ n မှ ကွန်ဆိုးလ်သို့ ပရင့်ထုတ်သည့် လုပ်ဆောင်ချက်ကို ရေးသားရန် လိုအပ်ပြီး n သည် ကန့်သတ်ချက်တစ်ခုအဖြစ် လုပ်ဆောင်သည့် ကိန်းပြည့်ဖြစ်ပြီး အောက်ပါအခြေအနေများဖြင့် လုပ်ဆောင်သည်-

• 3 ၏မြှောက်ကိန်းအစား fizz ကိုထုတ်ပေးပါ။
• 5 ၏ အမြှောက်ကိန်းများအစား buzz ထုတ်ပေးခြင်း၊
• 3 နှင့် 5 နှစ်ခုလုံး၏ မြှောက်ကိန်းများအစား fizzbuzz အထွက်။

နမူနာ

Fizzbuzz(5)

ရလဒ်

// ၂၀၀၈
// ၂၀၀၈
// ဖရိုဖရဲ
// ၂၀၀၈
// buzz

အလုပ်တစ်ခုကို ခွဲခြမ်းစိတ်ဖြာကြည့်ရအောင်

ဤနေရာတွင် အဓိကအချက်မှာ 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 statements ၏ အစီအစဥ်ကို အာရုံစိုက်သင့်သည်- နှစ်ထပ်အခြေအနေ (&&) ဖြင့် စတင်ပြီး ဂဏန်းများစွာကို ရှာမတွေ့နိုင်သော ကိစ္စဖြင့် အဆုံးသတ်ပါသည်။ ရလဒ်အနေဖြင့် ကျွန်ုပ်တို့သည် ရွေးချယ်မှုအားလုံးကို အကျုံးဝင်သည်။

Anagram

ဤသည်မှာ နံပါတ်တူသော အခြားစကားလုံးများ၏ စာလုံးအားလုံးပါရှိသော စကားလုံးတစ်လုံးအတွက် အမည်ဖြစ်သည်၊ သို့သော် မတူညီသောအစီအစဥ်တစ်ခုဖြစ်သည်။

ဇာတ်စင်

string နှစ်ခုသည် anagrams ဟုတ်မဟုတ် စစ်ဆေးသည့် လုပ်ဆောင်ချက်ကို ရေးရန် လိုအပ်ပြီး ကိစ္စသည် အရေးမကြီးပါ။ ဇာတ်ကောင်များကိုသာ ရေတွက်သည်။ ကွက်လပ်များ သို့မဟုတ် ပုဒ်ဖြတ်အမှတ်အသားများကို ထည့်သွင်းစဉ်းစားမည်မဟုတ်ပါ။

anagram('finder'၊ 'Friend') —> မှန်သည်။
anagram('hello', 'bye') —> မှားသည်။

အလုပ်တစ်ခုကို ခွဲခြမ်းစိတ်ဖြာကြည့်ရအောင်

ဤနေရာတွင် ထည့်သွင်းစဉ်းစားရန် အရေးကြီးသောအချက်မှာ စာတစ်ကြောင်းစီရှိ အဝင်လိုင်းနှစ်ခုရှိ စာလုံးတစ်လုံးစီနှင့် ၎င်းတို့၏နံပါတ်များကို စစ်ဆေးရန် လိုအပ်ပါသည်။

finder —> f: 1 friend —> f: 1
i: 1 r: 1
n: 1 i: 1
d: 1 e: 1
e: 1 n: 1
r: 1 ဃ: 1

Anagram ဒေတာကို သိမ်းဆည်းရန်အတွက် JavaScript object literal ကဲ့သို့သော ဖွဲ့စည်းပုံကို ရွေးချယ်သင့်သည်။ ဤကိစ္စတွင် အဓိကအချက်မှာ စာလုံး၏အက္ခရာဖြစ်ပြီး၊ တန်ဖိုးသည် လက်ရှိစာကြောင်းရှိ ၎င်း၏ထပ်တလဲလဲအရေအတွက်ဖြစ်သည်။

အခြားအခြေအနေများ ရှိပါသည်-

• နှိုင်းယှဥ်တဲ့အခါ စာလုံးတွေရဲ့ ဖြစ်ရပ်ကို ထည့်သွင်းစဉ်းစားဖို့ လိုပါတယ်။ ကျွန်ုပ်တို့သည် ကြိုးနှစ်ချောင်းလုံးကို စာလုံးအသေး သို့မဟုတ် အကြီးအဖြစ်သို့ ပြောင်းပေးရုံသာဖြစ်သည်။
• ကျွန်ုပ်တို့သည် နှိုင်းယှဉ်မှုမှမဟုတ်သော ဇာတ်ကောင်အားလုံးကို ဖယ်ထုတ်ထားသည်။ လက်တွဲဖို့ အကောင်းဆုံးပါ။ ပုံမှန်အသုံးအနှုန်းများ.

ဆုံးဖြတ်ချက်

// 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() အပေါ်က snippet ထဲမှာ။ ဤနည်းလမ်းသည် အရာဝတ္တုတွင်ပေါ်လာသော အမည်များ သို့မဟုတ် သော့များပါရှိသော array တစ်ခုကို ပြန်ပေးသည်။ ဤကိစ္စတွင်၊ array သည်ဤကဲ့သို့ဖြစ်လိမ့်မည်။

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

ဤနည်းဖြင့် ကျွန်ုပ်တို့သည် အစုလိုက် အကွက်လိုက်လုပ်စရာမလိုဘဲ အရာဝတ္ထု၏ ဂုဏ်သတ္တိများကို ရရှိနိုင်သည်။ ပြဿနာတစ်ခုတွင်၊ စာကြောင်းနှစ်ခုစလုံးတွင် တူညီသောစာလုံးအရေအတွက်ရှိမရှိ စစ်ဆေးရန် ဤနည်းလမ်းကို .length ပိုင်ဆိုင်မှုဖြင့် သင်အသုံးပြုနိုင်သည် - ၎င်းသည် anagrams ၏ အရေးကြီးသောအင်္ဂါရပ်တစ်ခုဖြစ်သည်။

သရများကို ရှာဖွေပါ။

အင်တာဗျူးတွေမှာ ပေါ်လာတတ်တဲ့ ရိုးရှင်းတဲ့ အလုပ်တစ်ခုပါ။

ဇာတ်စင်

အငြင်းအခုံအဖြစ် string တစ်ခုယူသော လုပ်ဆောင်ချက်တစ်ခုကို ရေးသားပြီး string တွင်ပါရှိသော သရအရေအတွက်ကို ပြန်ပေးရန်လိုအပ်သည်။
သရဟူသည် “က”၊“င”၊“ငါ”၊“အို”၊“ယူ”။

ဥပမာ:

findVowels('hello') //—> ၂
findVowels('why') // —> 0

ဆုံးဖြတ်ချက်

ဤသည်မှာ အရိုးရှင်းဆုံး ရွေးချယ်မှုဖြစ်သည်-

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() method ကိုအသုံးပြုခြင်းကို ဂရုပြုရန် အရေးကြီးပါသည်။ ၎င်းကို strings နှင့် array နှစ်ခုလုံးအတွက် ရနိုင်သည်။ array တစ်ခုတွင် အချို့သောတန်ဖိုးများပါရှိမရှိ ဆုံးဖြတ်ရန် ၎င်းကိုအသုံးပြုသင့်သည်။ array တွင် သတ်မှတ်ထားသောတန်ဖိုးများပါဝင်နေပါက ဤနည်းလမ်းသည် အမှန်အတိုင်းပြန်ဖြစ်မည်ဖြစ်ပြီး၊ မဟုတ်ပါက false ပြန်လာမည်ဖြစ်သည်။

ပြဿနာအတွက် တိုတောင်းသော အဖြေတစ်ခု ရှိပါသည်။

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

၎င်းသည် .match() နည်းလမ်းကို အသုံးပြုပြီး ထိရောက်သော ရှာဖွေမှုကို အကောင်အထည်ဖော်ရန် ခွင့်ပြုသည်။ သတ်မှတ်ထားသော စာကြောင်းအတွင်း နည်းလမ်းတစ်ခုအနေဖြင့် ပုံမှန်ဖော်ပြချက်ကို တွေ့ရှိပါက၊ ပြန်ပေးသည့်တန်ဖိုးသည် ကိုက်ညီသော ဇာတ်ကောင်များ၏ အခင်းအကျင်းတစ်ခုဖြစ်သည်။ ကိုက်ညီမှုမရှိပါက၊ .match() သည် null ဖြစ်သွားသည်။

ဖီဘိုနာချီ

အဆင့်အမျိုးမျိုးရှိ အင်တာဗျူးများတွင် တွေ့နိုင်သော ဂန္တဝင်အလုပ်တစ်ခု။ Fibonacci sequence သည် နောက်ဆက်တွဲတစ်ခုစီသည် ယခင်နှစ်ခု၏ပေါင်းလဒ်ဖြစ်ပြီး နောက်ဆက်တွဲတစ်ခုစီသည် ကိန်းဂဏန်းများအတွဲလိုက်ဖြစ်ကြောင်း မှတ်သားထိုက်သည်။ ဒီတော့ ပထမဂဏန်းဆယ်လုံးက ဒီအတိုင်းကြည့်ပါ- 0၊ 1၊ 1၊ 2၊ 3၊ 5၊ 8၊ 13၊ 21၊ 34။

ဇာတ်စင်

n သည် function အတွက် argument အဖြစ်ဖြတ်သန်းသော နံပါတ်ဖြင့် အချို့သော sequence တွင် nth record ကိုပြန်ပေးသည့် function ကိုရေးရန်လိုအပ်သည်။

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]
}

ရလဒ်အခင်းအကျင်းတွင်၊ ပထမနံပါတ်နှစ်ခုကို အစီအစဥ်တွင် ထည့်သွင်းထားသောကြောင့် အတွဲလိုက်ပါဝင်မှုတစ်ခုစီသည် ယခင်နံပါတ်နှစ်ခု၏ပေါင်းလဒ်ဖြစ်သောကြောင့် ဖြစ်သည်။ အစပိုင်းတွင် နောက်နံပါတ်ကိုရယူရန် နံပါတ်နှစ်ခုကို မယူနိုင်သောကြောင့် loop သည် ၎င်းတို့ကို အလိုအလျောက်ထုတ်ပေးနိုင်မည်မဟုတ်ပါ။ သို့သော် ကျွန်ုပ်တို့သိသည့်အတိုင်း၊ ပထမနံပါတ်နှစ်ခုသည် အမြဲတမ်း 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 ဖြစ်သောအခါ ကျွန်ုပ်တို့ ရပ်တန့်သွားသည်။

ကောက်ချက်

ဖြစ်နိုင်ချေများသည်မှာ၊ သင်သည် frontend သို့မဟုတ် JavaScript developer အလုပ် (အထူးသဖြင့် အငယ်တန်းအဆင့်တွင်ရှိလျှင်) အင်တာဗျူးခံရပါက ဤအလုပ်များထဲမှ တစ်ခုခုကို သင်ကြုံတွေ့ဖူးပြီးဖြစ်သည်။ သို့သော် ၎င်းတို့ကို သင်မတွေ့မိပါက၊ ၎င်းတို့သည် အနာဂတ်တွင် အသုံးဝင်နိုင်သည် - အနည်းဆုံး အထွေထွေ ဖွံ့ဖြိုးတိုးတက်မှုအတွက်။

Skillbox မှ အကြံပြုထားသည်-

• အသုံးချ အွန်လိုင်းသင်တန်း "Python Data Analyst".
• အွန်လိုင်းသင်တန်း "Profession Frontend Developer".
• လက်တွေ့ တစ်နှစ်သင်တန်း "PHP developer 0 မှ PRO".

source: www.habr.com