JavaScript Array Method [ 1 ]

javascript-basic

JavaScript Array Method [ 1 ]

JavaScript ရဲ့ Array မှာအသုံးအများဆုံး Method များဖြစ်ကြတဲ့ filter(), map(), reduce(), sort() တို့ရဲ့ သဘောသဘာဝနဲ့ လက်တွေ့အသုံးပြုပုံ၊ ခြားနားချက်တွေကိုအသေးစိတ်ရှင်းလင်းပေးသွားမှာဖြစ်ပါတယ်။

အကြောင်းအရာထဲက ကုဒ်တွေကို တိုက်ရိုက်ကူးယူစမ်းသပ်နိုင်ပါတယ်။

ဒီ Method အားလုံးဟာ looping သဘောတရားအတိုင်းအလုပ်လုပ်ကြတာဖြစ်ပါတယ်။ ကုဒ်တွေရဲ့အလုပ်လုပ်ပုံနဲ့ သဘောတရားကိုမြင်သာအောင် လက်တွေ့လုပ်ဆောင်ချက်လေးတွေနဲ့ တစ်ကဏ္ဍခြင်း ချည်းကပ်ကြည့်ပါမယ်။

Over View

TESTMETHODS
Test 1filter()
Test 2map()
Test 3sort()
Test 4reduce()
Test 5sort()
Test 6sort()
Test 7reduce()
Test 8applying Method Chaining wtih map() filter()
//Some data we can work with
const inventors = [ 
      { first: 'Albert', last: 'Einstein', year: 1879, passed: 1955 },
      { first: 'Isaac', last: 'Newton', year: 1643, passed: 1727 },
      { first: 'Galileo', last: 'Galilei', year: 1564, passed: 1642 },
      { first: 'Marie', last: 'Curie', year: 1867, passed: 1934 },
      { first: 'Johannes', last: 'Kepler', year: 1571, passed: 1630 },
      { first: 'Nicolaus', last: 'Copernicus', year: 1473, passed: 1543 },
      { first: 'Max', last: 'Planck', year: 1858, passed: 1947 },
      { first: 'Katherine', last: 'Blodgett', year: 1898, passed: 1979 },
      { first: 'Ada', last: 'Lovelace', year: 1815, passed: 1852 },
      { first: 'Sarah E.', last: 'Goode', year: 1855, passed: 1905 },
      { first: 'Lise', last: 'Meitner', year: 1878, passed: 1968 },
      { first: 'Hanna', last: 'Hammarström', year: 1829, passed: 1909 }
    ];

Object Array တစ်ခုကိုတည်ဆောက်လိုက်ခြင်းဖြစ်ပါတယ်။ Array ထဲမှာ ပုဂ္ဂိုလ်တစ်ဦးချင်းရဲ့ အမည်၊ မွေးနှစ်၊ ကွယ်လွယ်နှစ်များကို object များအနေနဲ့ထည့်သွင်းသတ်မှတ်ထားခြင်းဖြစ်ပါတယ်။


filter( )

  • TEST 1 - ပထမဆုံး 1500 ပတ်ဝန်းကျင်မှာ မွေးဖွားခဲ့သူများစရင်းကိုထုတ်ကြည့်ချင်ပါတယ်...
const fifteen = inventors.filter(function(inventor){
        return inventor.year > 1500 && inventor.year <1600
      });

console.table(fifteen);

filter() Method ကိုအသုံးပြုပြီး ထုတ်ယူထားတာပါ။ filter() ရဲ့ argument အနေနဲ့လိုအပ်တဲ့လုပ်ငန်းတွေလုပ်ဆောင်ဖို့ function ကိုပေးရပါတယ််။ ၎င်း function ရဲ့ inventor parameter ထဲကို inventors variable ထဲမှာရှိတဲ့တန်ဖိုးတွေတစ်ခုချင်းစီ loop လုပ်ယူသိမ်းဆည်းပြီး အလုပ်လုပ်ပေးပါတယ်။ ဒီနေရာမှာ filter() ရဲ့ထူးခြားချက်လေး တစ်ခုကိုမှတ်သားသင့်ပါတယ်။ filter() ဟာ အမြဲတန်း true တန်ဖိုးတွေကိုပဲ return ပြန်တာပါ။ ဒါကြောင့် နမူနာကုဒ်မှာ if statement နဲ့ စစ်နေစရာမလိုတော့ဘဲ true ဖြစ်တဲ့တန်ဖိုးတွေကိုပဲ အလိုလိုပြန်ပေးသွားတာဖြစ်ပါတယ်။ console.table နဲ့ရလဒ်ကိုထုတ်ထားလို့ browser's dev tool ထဲမှာကြည့်ရင် ရလဒ်တွေကို table ပုံစံအနေနဲ့ဖော်ပြပေးနေမှာဖြစ်ပါတယ်။ (တစ်ချို့ browser တွေမှာ refresh တစ်ကြိမ်ပေးမှ table ပြတာမျိုးရှိပါတယ််) arrowFunction ကိုသုံးပြီးလည်းခုလို ရေးသားနိုင်ပါတယ်။

const fifteen = inventors.filter(inventor => (inventor.year >= 1500 && inventor.year < 1600));

map( )

  • TEST 2 - တီထွင်သူတွေရဲ့နာမည်များကို ထုတ်ယူပါမယ်...
const fullNames = inventors.map(inventor =>`${inventor.first} 
  ${inventor.last}`);

console.table(fullNames);

ArrowFunction ကိုပဲသုံးထားပါတယ်။ ဒီတစ်ကြိမ်တော့ တီထွင်သူတစ်ဦးချင်းစီရဲ့နာမည်များကို ထုတ်ယူထားပါတယ်။ map() ကတော့ true ဖြစ်ဖြစ် false ဖြစ်ဖြစ်ခွဲခြားမနေပဲ ကျွန်တော်တို့ ထုတ်ယူထားတဲ့ element နဲ့ကိုက်ညီတဲ့ တန်ဖိုးကိုအတိအကျအပိုအလိုမရှိ return လုပ်ပါတယ်။ အပေါ်က filter() နဲ့ထုတ်ယူးထားတဲ့ ရလဒ်ကိုကြည့်ကြည့်ပါ။ စစ်ထုတ်လို့ ကိုက်ညီတဲ့ element ကိုသာမက၎င်းနဲ့ တစ်ဆက်တည်းရှိတဲ့ တန်ဖိုးတွေကိုပါပေးထားတာကိုတွေ့ရမှပါ။ map() ကတော့ ကိုက်ညီတဲ့ တန်ဖိုးကိုပဲပေးပါတယ်။ inventors ထဲကနာမည်တွေကို ယူရာမှာ ${inventor.first} နဲ့ string template ရေးသားနည်းကိုသုံးထားပါတယ်။ concatenate operator နဲ့လည်းရပါတယ်။ ဒီလိုရေးရမှာပါ "inventor.first" + + "inventor.last"


sort( )

  • TEST 3 - မွေးနှစ်အလိုက် အသက်အကြီးဆုံးကစပြီးထုတ်ကြည့်ပါမယ်...

    const birth = inventors.sort(function(a, b){
          if(a.year > b.year){
            return 1;
          }else if(a.year < b.year){
            return -1;
          }
        });
    
        console.table(birth);
    

    sort() Method ကိုအသုံးပြုပြီး အကြီးကနေအငယ်ကိုအစဉ်လိုက် ထုတ်သွားတာပါ။ sort() ကိုမြင်ပြီဆိုရင် ခေါင်းကြီးရပါပြီ။ ပုံမှန်တိုင်းသုံးရင်ရိုးစင်းပေမဲ့ ငယ်ရာကအကြီးကိုစီတာတို့၊ ကြီးရာကအငယ်ကိုစီတာတို့လို ကိစ္စတွေကိုင်တွယ်တဲ့အခါ စလေ့လာသူတစ်ချို့အတွက် နားလည်သယောင်ခံတက်လို့ပါ။ သဘောတရားပိုင်းအရ ရှုပ်ထွေးလှတာတော့မဟုတ်ဘူး။ ဒီနေရာမှာ ကျွန်တော့်အနေနဲ့ အလုပ်လုပ်ပုံသဘောတရား ရှင်းပြပေးပါမယ်။ sort() ရဲ့ argument အနေနဲ့ပေးထားတဲ့ function ကို compareFunction လို့ခေါ်ပါတယ်။၎င်းမှာ နှိုင်းယှဉ်ဖို့ parameter နှစ်ခုလက်ခံပါတယ်။ ပထမဆုံးသိထားရမှာက နှိုင်းယှဉ်မှုတွေလုပ်တဲ့အခါ compareFunction မှာ negative ဒါမှမဟုတ် positive ဆိုတဲ့ ရလဒ်နှစ်ခုအပေါ်မှာမူတည်ပြီးတော့လုပ်ဆောင်တာပါ။ နှုင်းယှဥ်ရလဒ်မှာ negative ရှိရင် first parameter ကိုစီလိုက်ပါတယ်။ second parameter ကတော့မပြောင်းပါဘူး။ နောက်ထပ်တန်ဖိုးတစ်ခုနဲ့ဆက်နှိုင်းယှဉ်ပါတယ်။ နှိုင်းယှဉ်ရလဒ် positive ထွက်ရင် second parameter ကို အရင်စီပါတယ်။ပြီးမှ first parameter ကိုစီပါတယ်။ negative လည်းမဟုတ် positive လည်းမဟုတ်ဘဲရလဒ် zero (0) လည်းရှိပါတယ်။ 0 ဆိုရင်တော့ ဘာတန်ဖိုးမှ မပြောင်းလဲပဲ ဒီတိုင်းပြန်ပေးပါတယ်။ " အနုတ်ဆို first parameter အရင်စီပြီး၊ အပါင်းဆိုရင် second parameter ကိုအရင်စီတယ်လို့ ယေဘူယျမှတ်နိုင်ပါတယ် " အပေါ်က ကုဒ်ကိုကြည့်ပါ။ year တွေကိုနှိုင်းယှဉ်းထားပါတယ်။ a က b ထက်ကြီးရင် တန်ဖိုး 1 (positive) ပြန်မယ်လို့သတ်မှတ်ထားပါတယ်။ positive ဖြစ်လို့ second parameter ဖြစ်တဲ့ b ကအရင်စီပါမယ်။ဒါက ကုဒ်ရဲ့အလုပ်လုပ်ပုံ သဘောသဘာဝ ဖြစ်ပါတယ်။ ကျန်တဲ့ 50 ကိုကျွန်တော်တို့ကိုယ်တိုင်ဆုံးဖြတ်ချက်ချရမှာပါ။ အခု positive ဖြစ်လို့ b ကိုအရင်စီပါတယ်(အသက်ကို ရေတွက်တဲ့နေရာမှာ ခုနှစ်ငယ်သူက အကြီးဖြစ်ပါတယ်၊ မေ့နေမှာစိုးလို့ : 😅)။ ဒီနေရာမှာ a က b ထက်ကြီးရမယ်လို့ပြောထားပါတယ် a.year > b.year ။ ဆိုတော့ a ကအကြီးဖြစ်ပြီးတော့၊ b ကအငယ်ဖြစ်တယ်ဆိုတာခွဲခြားသိနိုင်ပါတယ်။ Array function နဲ့ အခုလိုရေးသားနိုင်ပါတယ်။ ternary operator နဲ့တွဲသုံးလိုက်လို့ တိုတောင်းကျစ်လစ်တဲ့ ရေးဟန်ရပါတယ်။

const ordered = inventors.sort((a, b) => a.year > b.year ? 1 : -1);

reduce( )

  • TEST 4 - ပုဂ္ဂိုလ်အားလုံးရဲ့ နေထိုင်ခဲ့တဲ့ စုစုပေါင်းနှစ်အရေအတွက်ကို ထုတ်ကြည့်ပါမယ်...
var totalYears =0;
for(life = 0; life < inventors.length; life++){
        all += inventors[life].passed - inventors[life].year;
      }

      console.log(totalYears);

for loop ကိုသုံးပြီး တစ်ခုချင်းစီကို loop ပတ်ကာ တန်ဖိုးတွေကို variable တစ်ခုထဲ ထပ်ဆင့်ထည့်သွာတာပါ။ variable ဟာ global ဖြစ်တာကြောင့် နေရာစုံက ရယူအသုံးပြုနိုင်ပါတယ်။ ဒီနေရာမှာ reduce() ကိုသုံးပြီး ခုလိုရေးသားနိုင်ပါတယ်။

const totalYears = inventors.reduce((total, inventor) => {
      return total + (inventor.passed - inventor.year);
    }, 0);

console.log(totalYears);

ရလဒ်ကအတူတူပါပဲ။ reduce မှာ Function parater နှစ်ခုပါဝင်ပါတယ်။ first parameter ကို accumulative parameter လို့ခေါ်ပါတယ်။ တန်ဖိုးတွေကိုထပ်ဆင့်စုဆောင်းသွားတာဖြစ်ပါတယ်။ မြင်အောင်ကြည့်ချင်ရင် += operator သဘောမျိုးပါ။ second parameter ကတော့ current value ဖြစ်ပါပြီး first parameter ထဲကိုပေါင်းထည့်သွားမှာဖြစ်ပါတယ်။ reduce() ရဲ့ second argument မှာ initial value (0) ပါရှိတာကိုသတိထားကြည့်ပါ။ initial value ကြောင့် အဆင့်ဆင့်ပေါင်းထည့်သွားတဲ့တန်ဖိုးတွေဟာ မှန်ကန်မှုရှိမှာဖြစ်ပါတယ်။ နောက်ပြီးသူက accumulative parameter ထဲကတန်ဖိုးဟာ ဘာလိုအမျိုးအစား ဖြစ်တယ်ဆိုတာကိုပါသတ်မှတ်ပါတယ်။ အခု initialတန်ဖိုးဟာ 0 ဖြစ်တဲ့အတွက် number type ဖြစ်ပါတယ်။

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


  • TEST 5 - ပုဂ္ဂိုလ်တစ်ဦးခြင်းစီရဲ့ အသက်အလိုက် ကြီးစဉ်ငယ်စီပါမယ်။

    const oldest = inventors.sort(function(a, b) {
        const lastInventor = a.passed - a.year;
        const nextInventor = b.passed - b.year;
        return lastInventor > nextInventor ? -1 : 1;
      });
    
      console.table(oldest);
    

    တစ်ဆင့်ချင်း ကြည့်ကြည့်ပါ။ လုပ်ဆောင်ချက်အသစ်မပါဝင်ပါဘူး။ sort() နဲ့ စီထားပါတယ်။ တစ်ဦးချင်းနေထိုင်ခဲ့တဲ့ သက်တန်းကိုရဖို့ နှုတ်ပါတယ်။ ရလာတဲ့အသက်တွေကို နှိုင်းယှဉ်လိုက်တာပါပဲ။ နှိုင်းယှဉ်ပုံကိုတော့ အပေါ်မှာပြောရှင်းပြခဲ့ပြီးပါပြီ။ parameter a ဖြစ်တဲ့ lastInventor က b ဖြစ်တဲ့ nextInventor ကြီးရင် negative ပြန်မယ်လို့ပြောထားပါတယ်။ ဆိုတော့ အကြီးဖြစ်တဲ့ a ပြန်တယ်။ ဒါပါပဲ။


  • TEST 6 - နာမည်တွေကို alphabetically အလိုက် ABC အစဉ်လိုက်စီပါမယ်...

အောက်ကကုဒ်ကို code editor ထဲကော်ပီကူးလိုက်ပါ

const people = [
      'Bernhard, Sandra', 'Bethea, Erin', 'Becker, Carl', 'Bentsen, Lloyd', 'Beckett, Samuel', 'Blake, William', 'Berger, Ric', 'Beddoes, Mick', 'Beethoven, Ludwig',
      'Belloc, Hilaire', 'Begin, Menachem', 'Bellow, Saul', 'Benchley, Robert', 'Blair, Robert', 'Benenson, Peter', 'Benjamin, Walter', 'Berlin, Irving',
      'Benn, Tony', 'Benson, Leana', 'Bent, Silas', 'Berle, Milton', 'Berry, Halle', 'Biko, Steve', 'Beck, Glenn', 'Bergman, Ingmar', 'Black, Elk', 'Berio, Luciano',
      'Berne, Eric', 'Berra, Yogi', 'Berry, Wendell', 'Bevan, Aneurin', 'Ben-Gurion, David', 'Bevel, Ken', 'Biden, Joseph', 'Bennington, Chester', 'Bierce, Ambrose',
      'Billings, Josh', 'Birrell, Augustine', 'Blair, Tony', 'Beecher, Henry', 'Biondo, Frank'
    ];

people variable ထဲမှာ နာမည်တွေကို array ပုံစံနဲ့ထည့်ထားတာပါ။ ပေးထားတဲ့နာမည်တွေကို string ထဲမှာ comma နဲ့ပေးထားပါတယ်။ alphabetically စီရန်အတွက်အောက်မှာ ဖော်ပြထားပါတယ်။

const alpha = people.sort((lastOne, nextOne) => {
  const [aLast, aFirst] = lastOne.split(', ');
  const [bLast, bFirst] = nextOne.split(', ');

  return aLast > bLast ? 1 : -1;
 });

console.log(alpha);

sort() နဲ့ array ထဲက string တွေကို looping ပတ်ပြီး နှိုင်းယှဉ်ထားပါတယ်။ lastOne.split(',') က string Method split() ကိုသုံးပြီး array string ရဲ့ comma ပါတဲ့နေရာကနေခွဲထုတ်လိုက်တာပါ။ split() က array return ပြန်ပါတယ်။ အလုပ်လုပ်ပုံတစ်ဆင့်ချင်းကြည့်ချင်ရင် console.log ကိုသုံးပြီး လိုသလိုကြည့်ရှုစမ်းသပ်နိုင်ပါတယ်။ split() လုပ်လို့ရလာတဲ့ တန်ဖိုးကို DestructiveMethod သုံးပြီး သိမ်းဆည်းထားတာပါ။ ပုံမှန်အတိုင်းဆိုရင် ဒီလိုသိမ်းမှာပါ

const allName = lastOne.split(', ');
const aLast = allName[0];
const aFirst = allName[1];

array ထဲသိမ်းထားတဲ့ string တန်ဖိုးတစ်ခုခြင်းစီကိုထောက်ပြီး variable ထဲထည့်လိုက်တာပါ။ ဒီနေရာမှာ တန်ဖိုးတွေကို တစ်ခုချင်းမသိမ်းတော့ဘဲ ArrayDestructive Method ကိုသုံးလိုက်တာပါ။ အတူတူပါပဲ။ sorting စီတာကတော့ ရှေ့ကအတိုင်းပါပဲ။ ဒီတစ်ခါလည်းကြီးတဲ့ first parameter ကိုနောက်ကိုပို့လိုက်တာပါ။


  • TEST 7 - ဒီတစ်ခါမှာတော့ တန်ဖိုးတွေကို သူအမျိုးစားလိုက်ပေါင်းချင်ပါတယ်...
 const data = ['car', 'car', 'truck', 'truck', 'bike', 'walk', 'car', 'van', 'bike', 'walk', 'car', 'van', 'car', 'truck', 'pogostick'];

ရေးထားတဲ့ကုဒ်မှာ တန်ဖိုးတွေကို data array ထဲသိမ်းဆည်းထားပါတယ်။ လက်ရှိတန်ဖိုးမှာ အမျိုးအစားအမည်တူတွေရှိပြီး ပြန့်ကျဲနေပါတယ်။ အမျိုးအစားအမည်အလိုက် ပါဝင်တဲ့အရေအတွက်ကိုစုစုပေါင်းကို ထုတ်ကြည့်မှာပါ။ ကုဒ်ကိုကြည့်ရင်ရှင်းသွားပါလိမ့်မယ်။

const transportation = data.reduce(function(obj, item) {
      if (!obj[item]) {
        obj[item] = 0;
      }
      obj[item]++;
      return obj;
    }, {});

    console.log(transportation);

console.log မှာရလဒ်ကိုထုတ်ကြည့်ထားပါတယ်။ အလုပ်လုပ်သွားတာကဒီလိုပါ ကျွန်တော်တို့ loop ပတ်ပြီး first parameter ဖြစ်တဲ့ accumulative parameter ထဲကိုဝင်လာမဲ့ တန်ဖိုးအမျိုးအစားဟာ object type ဖြစ်တယ်လို့ initialize လုပ်ပြီးသတ်မှတ်လိုက်ပါတယ်။ ပြီးတဲ့နောက် ၎င်း object ထဲကို obj[item]++ နဲ့တန်ဖိုးတွေပေါင်းထည့်လိုက်တာပါ။ ပထမဆုံးအလုပ်လုပ်ချိန်မှာ object ထဲမှာ ဘာအမျိုးအမည်မှ မရှိသေးသလို ဘာတန်ဖိုးမှလည်းမရှိသေးပါဘူး။ if statement ကိုသုံးပြီးတန်ဖိုးမရှိချိန်မှာ လုပ်ဆောင်ရမယ့်အရာကို ရေးထားပါတယ်။ ၎င်းက object ရှိ၊ မရှိ စစ်တာအပြင် ဝင်လာတဲ့ ပထမအမည်ကိုပါ တန်ဖိုး zero assign လုပ်ပေးလိုက်တာ သတိပြုပါ။ နောက်တစ်ဆင့်မှာယင်း assign တန်ဖိုး 0 ကို 1 တိုးပေးသွားပါတယ်။ 1 တိုးပေးတဲ့အလုပ်ကို လုပ်ကိုသွားတဲ့ obj[item]++ ကုဒ်ဟာ flexible ဖြစ်တဲ့ကုဒ်ပါ။ ဝင်လာတဲ့အမည်နဲ့ တူညီတဲ့အမည် object ထဲမှာရှိနေရင် ၎င်းအမည်ပေါ်မှာ တန်ဖိုးတစ်တိုး ပေါင်းသွားတာပါ။ အတန်အသင့်စမ်းသပ်ဖူးသားသူကတော့ မြင်ယုံနဲ့နားလည်မှာပါ။ ဒီလုပ်ဆောင်ချက်ကို for loop နဲ့လည်းခုလိုရေးသားနိုင်ပါတယ်။

var transportation = {};
    for (i = 0; i < data.length; i++){
      if(!transportation[data[i]]){
        transportation[data[i]] = 0;
      }
      transportation[data[i]]++;
    }

console.log(transportation);

  • TEST 8 - FC ပါတဲ့စာသားတွေကို ထုတ်ကြည့်ခြင်း (Final)
 <div class="category">
    <a href="">Arsenal fc</a>
    <a href="">fc Bayern</a>
    <a href="">Leed united</a>
    <a href="">Man united</a>
    <a href="">Cheaslea fc</a>
</div>

HTML ထဲမှာအပေါ်ကကုဒ်တွေကို ကောပီကူးလိုက်ပါ

const clubs = document.querySelector('.category');
      const list = Array.from(clubs.querySelectorAll('a'));
      const fc = list
                      .map(cate => cate.textContent)
                      .filter(fc => fc.includes('fc'));

console.log(fc);

querySelector('.category') နဲ့ HTML element ကို select လုပ်ယူထားပါတယ်။ နောက်တစ်ဆင့်မှာ querySelectorAll('a') နဲ့ a link ပါတဲ့ element အားလုံးကို select လုပ်ယူလိုက်ပါတယ်။ clubs variable ကနေတစ်ဆင့် select လုပ်ထားတာသတိပြုပါ။ document ကနေတစ်ခါတည်း select လုပ်လည်းရပါတယ်။ document.querySelectorAll('.category .a'); ဆိုပြီးတော့ပါ။ အမှတ်တမဲ့ သတိမထားမိတက်တာလေးထည့်ပြောတာပါ။ ရလာတာကို list variable ထဲမှာထည့်ထားပါတယ်။ Array.from() statement မပါဘဲ console မှာထုတ်ကြည့်ရင် NodeList ဖြစ်နေတာတွေ့ရမှာပါ။ NodeList ဖြစ်နေလို့ loop ပတ်ဖို့အတွက် Array.from() statement နဲ့ array ပြောင်းလိုက်တာပါ။NodeList အနေနဲ့ loop ပတ်ချင်လည်း ရပါတယ် foreach() Method ရှိပါတယ်။ NoteList ကို array ပြောင်းတဲ့နေရာမှာနောက်တစ်နည်းအနေနဲ့ SpreadMethod ကိုလည်းသုံးနိုင်ပါသေးတယ်။ ဒီလိုရေးရမှာပါ။

const list = [...clubs.querySelectorAll('a')];

နောက်တစ်ဆင့်မှာ map() နဲ့ a link ထဲက စာသားကို textContent နဲ့ရယူထားပါတယ်။ တစ်ဆက်တည်း ရယူထားတဲ့စာသားကို filter() သုံးပြီး includes() နဲ့ fc စာသားစစ်ထုတ်လိုက်ပါတယ်။ map() ရလဒ်ပေါ်မှာ filter() ကိုဆက်ပြီးလုပ်သွားတာဖြစ်ပါတယ်။ Method Chaining လို့ခေါ်ပါတယ်။

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

👉 Array Methods [ 2 ]

🌱 Happy Coding ...

 
Share this
Proudly part of