မာတိကာ[ဖျောက်][ရှိုး]
- 1. သင်၏အခြေခံအသိပညာကို မြှင့်တင်ပါ။
- 2. object-oriented နည်းဗျူဟာကို အသုံးပြုပါ။
- 3. ၎င်းတို့သည် သေးငယ်သော်လည်း လုပ်ဆောင်ချက်များကို အသုံးပြုပါ။
- 4. == အစား === ကိုသုံးပါ။
- 5. JSLint ကိုသုံးပါ။
- 6. Script များကို သင့်စာမျက်နှာ၏အောက်ခြေတွင် ထားရှိသင့်သည်။
- 7. ကြိုးတစ်ချောင်းဖန်တီးရန် အလျင်မြန်ဆုံးနည်းလမ်း
- 8. သင့်ကုဒ်တွင် မှတ်ချက်တစ်ခုထည့်ပါ။
- 9. Template Literals ကို အသုံးပြုပါ။
- 10. Iterators နှင့် … of Loops အတွက်
- 11. Object() အသစ်အစား {} ကိုသုံးပါ
- 12. သင့်ကုဒ်တွင် let and const ထည့်စဉ်းစားပါ။
- 13. eval() သည် အကြံကောင်းတစ်ခုမဟုတ်ပါ။
- 14. Spread Operator သည် အဆင်ပြေပါသည်။
- 15. စောင့်ပြီး ထပ်တူလုပ်ပါ။
- 16. Javascript တွင် include() method ကိုသုံးပါ။
- 17. Splice သုံးပြီး array တစ်ခုမှ အရာများကို ဖယ်ရှားပါ။
- 18. Arrow Function ကိုအသုံးပြုပါ။
- 19. Destructuring ဖြင့်၊ သင်သည် ပြောင်းလဲနိုင်သောတန်ဖိုးများကို အမြန်သတ်မှတ်နိုင်သည်။
- 20. ပရောဂျက်များစွာလုပ်ပါ။
- ကောက်ချက်
အကယ်၍ သင်သည် ဝဘ်ဖွံ့ဖြိုးတိုးတက်မှုကို စိတ်ဝင်စားဖူးပါက၊ JavaScript ကို သင်တွေ့နိုင်မည်ဖြစ်သည်။ object-oriented programming language သည် JavaScript ဖြစ်သည်။ ဆော့ဖ်ဝဲရေးသားသူများသည် ဝဘ်စာမျက်နှာများ၏ client-side (ရှေ့ဆုံး) ကို တက်ကြွပြီး အပြန်အလှန်အကျိုးပြုစေရန် ၎င်းကို အသုံးပြုသည်။
HTML နှင့် CSS တို့ဖြင့် ဝဘ်စာမျက်နှာများနှင့် ဝဘ်အက်ပ်များကို ဖန်တီးရန်လည်း အသုံးပြုပါသည်။ ယနေ့ခေတ် အင်တာနက်ပေါ်တွင် JavaScript ကုဒ်မပါသော ဝဘ်စာမျက်နှာ မရှိပါ။ ၎င်းသည် ဆော့ဖ်ဝဲရေးသားသူ၏ အလုပ်၏ ရှုပ်ထွေးပွေလီသော ရှုထောင့်တစ်ခု ဖြစ်လာသည်။
အမှန်တော့ ဒါဟာ တဖြည်းဖြည်း တိုးလာနေပါတယ်။ ဝဘ်စာမျက်နှာများအတွက် လုပ်ဆောင်နိုင်စွမ်းကို ပံ့ပိုးပေးသည့်အတွက် JavaScript ကို အကောင်းဆုံးအသိအမှတ်ပြုထားသော်လည်း ၎င်းကို JavaScript မဟုတ်သော ပတ်ဝန်းကျင်များတွင်လည်း အသုံးပြုပါသည်။ Node.js၊ Apache Couch-DB နှင့် Adobe Acrobat တို့သည် ဤနည်းပညာများ၏ နမူနာများဖြစ်သည်။ JavaScript ကိုအသုံးပြုရန်အတွက်၊ ခေတ်မီဝဘ်ဘရောက်ဆာအများစုတွင် in-built JavaScript execution engine ပါရှိသည်။ သင်အောင်မြင်သော ဝဘ်ဆော့ဖ်ဝဲရေးသားသူဖြစ်လိုပါက၊ သင်သည် JavaScript ကို ကိုင်တွယ်ရမည်ဖြစ်ပါသည်။
ဒီနေ့ ဒါမှမဟုတ် မနက်ဖြန်မှာ ကိုင်တွယ်ရမယ်။ အဘယ်ကြောင့် JavaScript ကို အချိန်မီ မလေ့လာရသနည်း၊ သို့မှသာ အချိန်ကျလာသောအခါတွင် သင်သည် ပြင်ဆင်နိုင်မည်ဖြစ်သည်။
ဒါက ဒီ session မှာ သင်ယူရမယ့် အရာပါ။ သင်၏ JavaScript ကို ပေါ်လွင်စေခြင်းဖြင့် သင်၏ ဝဘ် developer များထက် ခြေတစ်လှမ်းသာအောင် မည်သို့နေရမည်ကို ရှင်းပြထားသည်။
စကြပါစို့
1. သင်၏အခြေခံအသိပညာကို မြှင့်တင်ပါ။
ငယ်ငယ်ကတည်း က မင်းကြားခဲ့ရတဲ့ အခြေခံ အတွေးအမြင်နဲ့ စကားစပြောမယ်။ အခြေခံများကို လေ့လာပြီး လက်တွေ့အသုံးချပါ။ အကြိမ်များစွာ၊ သင်သည် ကုဒ်ဖြင့် လော့ဂျစ်ကို အသုံးပြုနေသော်လည်း၊ array တစ်ခုကို လှီးဖြတ်ခြင်းကဲ့သို့ ၎င်းအတွက် built-in လုပ်ဆောင်ချက်ရှိနေပြီဖြစ်သည်ကို မေ့သွားလိမ့်မည်။ JavaScript ကုဒ်ကို သင်အသုံးပြုသောအခါတွင် အမှားအယွင်းတစ်ခုရနိုင်ပြီး ရလဒ်အနေဖြင့် အပိုဝန်ဆောင်မှုများစွာ အလုပ်မလုပ်တော့ပါ။
၎င်းသည် အူမကြီးတစ်ခုတည်း သို့မဟုတ် ပြောင်းပြန်ကော်မာများကြောင့် ဖြစ်နိုင်သည်။ ဤအရာများသည် အခြေခံသဘောတရားများကို နားလည်မှုမရှိခြင်းကြောင့် ဖြစ်ပေါ်လာခြင်းဖြစ်သည်။ ပရိုဂရမ်တစ်ခုတည်းတွင် အကြိမ်များစွာ၊ for, which, do while ကဲ့သို့သော အခြေခံ loop တစ်ခု။ Loops သည် အခြေခံအကျဆုံး ပရိုဂရမ်တည်ဆောက်ပုံများထဲမှ တစ်ခုဖြစ်သည်။
အကယ်၍ သင်သည် looping နှင့် အခြားသော အခြေခံအချက်များနှင့် မရင်းနှီးပါက ကုဒ်လုပ်ရန် အလွန်ခက်ခဲပြီး ကုမ္ပဏီတစ်ခုတွင် အလုပ်လုပ်ရန်ပင် အခွင့်အရေးရှိသည်။ ဖြေရှင်းချက်၏ ရှုပ်ထွေးသောယုတ္တိနှင့် ဂုဏ်သတင်းကို ဖော်ဆောင်ရန်အတွက် ၎င်းတို့သည် ခိုင်မာသောအခြေခံအုတ်မြစ်ကို ပံ့ပိုးပေးသောကြောင့် သင်၏အခြေခံအခြေခံများကို လေ့လာသုံးသပ်ခြင်းသည် အရေးကြီးပါသည်။
2. object-oriented နည်းဗျူဟာကို အသုံးပြုပါ။
Object-oriented method သည် ယနေ့ခေတ်တွင် လူသိအများဆုံး programming နည်းလမ်းဖြစ်သည်။ C++ ဖြင့် စတင်ခဲ့သော အရာဝတ္ထု-ဦးတည်သည့် ချဉ်းကပ်မှုသည် ထိုအချိန်မှစ၍ အလွန်ရေပန်းစားလာခဲ့သည်။ ယနေ့ခေတ်တွင် ပင်မဘာသာစကားအားလုံးကို ဖန်တီးရန်အတွက် object-oriented programming ကိုသာ အသုံးပြုပါသည်။ Object-oriented Strategy သည် တိကျသော အရာဝတ္တုတစ်ခုအပေါ် အာရုံစိုက်ထားသည့် တစ်ခုဖြစ်သည်။
ထိုအရာသည် အခြေခံကျသော အရာတစ်ခု ဖြစ်လာသည်။ ထို့နောက် အခြေခံအဖြစ် စာမျက်နှာသို့ အရည်အချင်းများနှင့် လုပ်ဆောင်ချက်များကို ပေါင်းထည့်ရန် ဤအရာဝတ္တုကို အသုံးပြုသည်။ လုပ်ဆောင်ချက် သို့မဟုတ် အရာဝတ္တုများမပါဘဲ အပေါ်မှအောက်ခြေအထိ ကုဒ်ဖန်တီးခြင်း၏ ရိုးရာနည်းလမ်းကိုလည်း သင်အသုံးပြုနိုင်ပါသည်။ ဒါက ကျယ်ပြန့်လွန်းပြီး ဘယ်တော့မှ မကြိုးစားသင့်ပါဘူး။ ကုဒ်ကို တီထွင်သောအခါတွင်၊ ကျွန်ုပ်တို့သည် လုပ်ဆောင်နိုင်သော ချဉ်းကပ်နည်းကို အသုံးပြုသင့်ပြီး လုပ်ဆောင်ချက်များကို အသုံးပြုပါက အရာဝတ္ထုများကို အသုံးပြုသင့်သည်။
ထို့ကြောင့်၊ အစတွင်၊ သင်၏ကျယ်ပြန့်သောကုဒ်ကို အရာဝတ္ထု-ဆန်သောကုဒ်သို့ ပြောင်းရန် ကြိုးစားပြီး သင်၏ကုဒ်ကို အရာဝတ္ထုဆန်သောပုံစံဖြင့် အမြဲရေးပါ။ အခြားသူများ၏ကုဒ်ကို သင်လေ့လာသောအခါ၊ သင်သည် အရာဝတ္ထုကို ဦးတည်သည့် နည်းပညာများကို အမြဲမပြတ်ကြည့်ရှုနေလိမ့်မည်။ JavaScript ကို ကျွမ်းကျင်ချင်ရင် အဲဒါကို လက်သင့်ခံရင် အကောင်းဆုံးပါပဲ။
3. ၎င်းတို့သည် သေးငယ်သော်လည်း လုပ်ဆောင်ချက်များကို အသုံးပြုပါ။
လုပ်ငန်းဆောင်တာ ချဉ်းကပ်မှုဖြင့် ပရိုဂရမ်ရေးဆွဲခြင်းသည် သွားရမည့် အံ့ဖွယ်နည်းလမ်းဖြစ်သည်။ အဘယ်ကြောင့်? ၎င်းသည် သင့်ဆော့ဖ်ဝဲလ်အား အတူတကွလုပ်ဆောင်သည့် module များအဖြစ် ခွဲခြားထားသော်လည်း တစ်ခုနှင့်တစ်ခု ကွဲပြားနေဆဲဖြစ်သည်။ နားလည်အောင် ဥပမာပေးပါရစေ။
ကိန်းပြည့်များ၏ Root Mean Square ကို လုပ်ဆောင်ချက်တစ်ခု အသုံးပြု၍ တွက်ချက်နိုင်သည်။ ထိုသို့ပြုလုပ်ရန်၊ သင်သည် ကိန်းပြည့်များကို နှစ်ထပ်၊ ၎င်းတို့၏ ဆိုလိုရင်းကို တွက်ချက်ပြီး ဆိုလိုရင်း၏ နှစ်ထပ်ကိန်းကို တွက်ချက်ရပါမည်။ လုပ်ငန်းစဉ်မှာ အဆင့်သုံးဆင့်ရှိပါတယ်။ ရလဒ်အနေနဲ့ လုပ်ဆောင်ချက်သုံးခုကို အသုံးချနိုင်ပါတယ်။ ဒါပေမယ့် သင်မြင်တဲ့အတိုင်းပဲ၊ ဒီလုပ်ဆောင်ချက်တွေအားလုံးဟာ အပြန်အလှန်ချိတ်ဆက်နေပါတယ်။ တစ်ခု၏ output ကို အခြားတစ်ခုသို့ ပေးပို့ပြီး အဆုံးစွန်သော ရလဒ်ကို ရရှိသည်။
လုပ်ဆောင်ချက်သုံးခုအစား RMS အများအပြားကို အခြေခံ၍ တွက်ချက်ရန် တစ်ခုလိုအပ်သည်ဟု ဟန်ဆောင်ကြပါစို့။ နောက်ဆုံးဖြေရှင်းချက်သည် သင်မြင်သည့်အတိုင်း မမှန်ပါ။ ဤကဲ့သို့သော ကြီးမားသော ဖြစ်ရပ်တစ်ခုတွင် အမှားအယွင်းများ ရှိခဲ့သည်ကို ဆုံးဖြတ်ရန် သင့်အတွက် အလွန်ခက်ခဲပါလိမ့်မည်။
အခြားတစ်ဖက်တွင် သေးငယ်သောလုပ်ဆောင်ချက်သုံးမျိုးရှိခြင်းက သင့်အား လျင်မြန်စွာခွဲခြမ်းစိတ်ဖြာနိုင်စေမည်ဖြစ်သည်။ ရလဒ်အနေဖြင့်၊ လုပ်ဆောင်ချက်များသည် ကျိုးနွံသော်လည်း၊ ကွဲပြားသောကုဒ် module များကို သတ်မှတ်ရန် ၎င်းတို့ကို အသုံးပြုပါ။ ဤနည်းပညာသည် သင့်အား မှော်ပညာကဲ့သို့သော JavaScript ကျွမ်းကျင်သူဖြစ်လာစေရန် ကူညီပေးပါမည်။
အခု၊ JavaScript coding အကြံပြုချက်အချို့ကို ကြည့်ကြရအောင်။
4. == အစား === ကိုသုံးပါ။
JavaScript တွင် တန်းတူညီမျှမှု အော်ပရေတာ နှစ်မျိုးရှိသည်- တင်းကျပ်သော တန်းတူညီမျှမှု အော်ပရေတာများ === နှင့် !== နှင့် တင်းကျပ်သော တန်းတူညီမျှမှု အော်ပရေတာများ == နှင့် !=။ နှိုင်းယှဥ်သောအခါ၊ တိကျသောတန်းတူညီမျှမှုကို အမြဲတမ်းအသုံးချရန် အကောင်းဆုံးအလေ့အကျင့်အဖြစ် မှတ်ယူသည်။ == နှင့် != တို့နှင့် အလုပ်လုပ်သောအခါ၊ ကွဲပြားသောအမျိုးအစားများနှင့် ဆက်ဆံရာတွင် ပြဿနာများကြုံတွေ့ရလိမ့်မည်။
တန်ဖိုးအမျိုးအစားများ၊ သင်နှိုင်းယှဉ်နေသည်မှာ မတူညီသောအခါတွင်၊ တင်းကျပ်မှုမရှိသော အော်ပရေတာများသည် မမျှော်လင့်ထားသောရလဒ်များကို ဖြစ်ပေါ်စေနိုင်ပြီး ၎င်းတို့၏တန်ဖိုးများကို အတင်းအကျပ် ဖိအားပေးရန် ကြိုးစားမည်ဖြစ်သည်။
5. JSLint ကိုသုံးပါ။
Douglas Crockford သည် အမှားရှာပြင်သည့် JSLint ကို ဖန်တီးခဲ့သည်။ သင်၏ script ကို ဘောက်စ်ထဲသို့ ရိုးရှင်းစွာထည့်ပါ၊ ချွတ်ယွင်းချက် သို့မဟုတ် ချို့ယွင်းချက်များအတွက် ၎င်းကို လျင်မြန်စွာ စကင်န်ဖတ်ပါမည်။
JSLint သည် JavaScript အရင်းအမြစ်ဖိုင်ကို စစ်ဆေးသည်။ ပြဿနာတစ်ခုကို ရှာဖွေတွေ့ရှိပါက ပြဿနာ၏ ဖော်ပြချက်နှင့် အရင်းအမြစ်အတွင်း အနီးစပ်ဆုံး အနေအထားကို ပေးပို့ပါသည်။ ပြဿနာသည် အမြဲလိုလို တူညီသောအမှားတစ်ခုမဟုတ်သော်လည်း ၎င်းသည် မကြာခဏဖြစ်လေ့ရှိသည်။
JSLint သည် ပုံသဏ္ဍာန်စံနှုန်းများနှင့် ဖွဲ့စည်းတည်ဆောက်ပုံဆိုင်ရာ ပြဿနာများကို ဆန်းစစ်သည်။ သင့်ဆော့ဖ်ဝဲသည် တိကျသည်ဟု မဆိုလိုပါ။ ပြဿနာများကို ရှာဖွေရာတွင် အထောက်အကူဖြစ်စေရန် အခြားမျက်လုံးတစ်စုံကို ပေါင်းထည့်လိုက်ရုံပင်။ Script တစ်ခုတွင် သင် လက်မှတ်မထိုးမီ၊ သင်သည် အမှားအယွင်းတစ်စုံတစ်ရာ မကျူးလွန်မိကြောင်း သေချာစေရန် JSLint မှတစ်ဆင့် ၎င်းကို လုပ်ဆောင်ပါ။
6. Script များကို သင့်စာမျက်နှာ၏အောက်ခြေတွင် ထားရှိသင့်သည်။
အသုံးပြုသူ၏ အဓိကရည်ရွယ်ချက်မှာ စာမျက်နှာကို တတ်နိုင်သမျှ လျှင်မြန်စွာ တင်နိုင်ရန်ဖြစ်သည်။ ဖိုင်အပြည့်အစုံကို မတင်မချင်း ဘရောင်ဇာသည် ဇာတ်ညွှန်းတစ်ခုကို ဆက်လက်ဖွင့်၍မရပါ။ ရလဒ်အနေဖြင့်၊ အသုံးပြုသူသည် မည်သည့်တိုးတက်မှုကိုမြင်တွေ့ရန် ကြာရှည်စောင့်ဆိုင်းရမည်ဖြစ်ပါသည်။
သင့်တွင် လုပ်ဆောင်နိုင်စွမ်းကို ပေးစွမ်းရန်သာ အသုံးပြုသည့် JS ဖိုင်များရှိပါက (ဥပမာ၊ ခလုတ်တစ်ခုကို နှိပ်လိုက်သည်နှင့်) ၎င်းတို့ကို စာမျက်နှာ၏အောက်ခြေတွင်၊ အပိတ်ကိုယ်ထည်တဂ်ရှေ့တွင် ထားလိုက်ပါ။ ဤသည်မှာ သံသယဖြစ်ဖွယ် အကောင်းဆုံး အလေ့အကျင့်ဖြစ်သည်။
7. ကြိုးတစ်ချောင်းဖန်တီးရန် အလျင်မြန်ဆုံးနည်းလမ်း
array သို့မဟုတ် object တစ်ခုအား လှည့်ပတ်ရန် လိုအပ်သောအခါ၊ loop statement အတွက် သင်၏ trusty ကို အမြဲတမ်း မသုံးပါနှင့်။ လက်ထဲတွင်ရှိသော အလုပ်အတွက် အလျင်မြန်ဆုံး ဖြေရှင်းချက်ရရန် သင့်စိတ်ကူးကို အသုံးပြုပါ။ ငါ မင်းကို နံပါတ်တွေ ယူလာမှာ မဟုတ်ဘူး၊ မင်းငါ့ကိုယုံဖို့ပဲလိုလိမ့်မယ် (ဒါမှမဟုတ် ကိုယ့်ကိုကိုယ်စမ်းသပ်)။
ဤသည်မှာ အမြန်ဆုံးနည်းပညာဖြစ်သည်။
8. သင့်ကုဒ်တွင် မှတ်ချက်တစ်ခုထည့်ပါ။
အစပိုင်းတွင် အဓိပ္ပါယ်မဲ့ပုံပေါ်နိုင်သော်လည်း သင့်ကုဒ်ကို တတ်နိုင်သမျှ မကြာခဏ မှတ်ချက်ပေးသင့်သည်ဟု ကျွန်ုပ်ပြောသောအခါ ယုံကြည်ပါ။ လအတန်ကြာမှ ပရောဂျက်ကို ပြန်လာပြီး သင့်မူလတွေးခေါ်မှု လုပ်ငန်းစဉ်ကို မမှတ်မိတော့ရင် ဘာဖြစ်မလဲ။
သင့်လုပ်ဖော်ကိုင်ဖက်တစ်ဦးမှ သင့်ကုဒ်ကို အပ်ဒိတ်လုပ်ရလျှင်ကော။ သင့်ကုဒ်၏ အရေးကြီးသော နယ်ပယ်များကို အမြဲတမ်း မှတ်ချက်ပေးရပါမည်။
9. Template Literals ကို အသုံးပြုပါ။
ကိုးကားနှစ်ထပ် သို့မဟုတ် တစ်ခုတည်းဖြင့် ဖန်တီးထားသော စာကြောင်းများ၏ ကန့်သတ်ချက်များမှာ များပြားသည်။ ၎င်းတို့နှင့် လုပ်ဆောင်ရာတွင် ပိုမိုလွယ်ကူစေရန်၊ သင့်စာကြောင်းအချို့ကို နမူနာပုံစံစာလုံးများဖြင့် အစားထိုးရန် သင်ရွေးချယ်နိုင်ပါသည်။
အားသာချက်များစွာရှိသည့် တန်းပလိတ်စာလုံးများကို တည်ဆောက်ရန်အတွက် backtick အက္ခရာ (') ကို အသုံးပြုသည်။ အသုံးအနှုန်းများကို သိမ်းဆည်းရန် သို့မဟုတ် စာကြောင်းပေါင်းများစွာကို တည်ဆောက်ရန် ၎င်းတို့ကို သင်အသုံးပြုနိုင်သည်။
တစ်ချက် သို့မဟုတ် နှစ်ချက်ကိုးကားများဖြင့် တည်ဆောက်ထားသည့် သမားရိုးကျ ပကတိစာကြောင်းနှင့် မတူဘဲ၊ ကျွန်ုပ်တို့သည် ကျွန်ုပ်တို့၏ နမူနာပုံစံပုံစံမှ ထပ်ခါတလဲလဲ ဝင်ထွက်နေရန် မလိုအပ်ပါ။ ၎င်းသည် စာရိုက်ရာတွင် အမှားအယွင်းဖြစ်နိုင်ခြေကို နည်းပါးစေပြီး သန့်ရှင်းသောကုဒ်ကို ရေးနိုင်စေပါသည်။
10. Iterators နှင့် … of Loops အတွက်
Iterators များသည် နောက်ထပ်တန်ဖိုးများကျန်ရှိမရှိပေါ် မူတည်၍ နောက်ထပ်တန်ဖိုးများကျန်ရှိမရှိအပေါ် မူတည်၍ နောက်ထပ်တန်ဖိုးများကို သိမ်းဆည်းထားသည့် အရာတစ်ခုကို ပြန်ပေးမည့် နောက်() နည်းလမ်းကို အကောင်အထည်ဖော်သည့် JavaScript ရှိ အရာဝတ္ထုများဖြစ်သည်။ ဆိုလိုသည်မှာ အကယ်၍ သင်သည် iterator ပရိုတိုကောကို အကောင်အထည်ဖော်ပါက၊ သင်သည် သင်၏ကိုယ်ပိုင် iterator အရာဝတ္ထုများကို တည်ဆောက်နိုင်သည်။
JavaScript၊ String၊ Array၊ Map စသည်ဖြင့် အချို့သော built-in iterator များရှိပါသည်။ ၎င်းတို့ကို ဖြတ်၍ ထပ်ဆင့်ပြန်ဆိုရန် … of loops အတွက် သင်သုံးနိုင်သည်။ သာမန် loops များနှင့် နှိုင်းယှဉ်ပါက၊ ၎င်းသည် ပိုမိုတိကျပြီး အမှားအယွင်းနည်းပါသည်။ for… of loop ကို အသုံးပြု၍ array ၏ အရှည် သို့မဟုတ် လက်ရှိ အညွှန်းကို ခြေရာခံရန် မလိုအပ်ပါ။ nested loops များကို ဒီဇိုင်းဆွဲသည့်အခါ၊ ၎င်းသည် ကုဒ်ကို ရိုးရှင်းစေရန် ကူညီပေးနိုင်ပါသည်။
11. Object() အသစ်အစား {} ကိုသုံးပါ
JavaScript တွင် သင်သည် နည်းလမ်းအမျိုးမျိုးဖြင့် အရာဝတ္ထုများကို ဖန်တီးနိုင်သည်။ ပြထားသည့်အတိုင်း constructor အသစ်ကိုအသုံးပြုခြင်းသည် ပို၍သမရိုးကျနည်းလမ်းဖြစ်သည်။ အခြားတစ်ဖက်တွင်မူ ဤနည်းဗျူဟာကို "ညံ့ဖျင်းသောအလေ့အကျင့်" အဖြစ် မှတ်သားထားသည်။
အပျက်အစီးမဟုတ်ပေမယ့် စကားလုံးနည်းနည်းနဲ့ ထူးခြားပါတယ်။ object literal technique ကိုသုံးမယ့်အစား ကျွန်တော် အဆိုပြုပါတယ်။
12. သင့်ကုဒ်တွင် let and const ထည့်စဉ်းစားပါ။
ကျွန်ုပ်တို့သည် ၎င်းတို့၏ကိုယ်ပိုင်ပိတ်ဆို့ခြင်းအတွက် အတိုင်းအတာရှိသော ဒေသန္တရပြောင်းလွဲချက်များကို ပြုလုပ်ရန် let keyword ကို အသုံးပြုနိုင်ပါသည်။ ပြောင်းလဲ၍မရသော ဒေသန္တရ ပိတ်ဆို့ထားသော ကိန်းရှင်များကို တည်ဆောက်ရန်အတွက် const သော့ချက်စကားလုံးကို အသုံးပြုနိုင်သည်။
variable များကိုကြေငြာသည့်အခါ၊ အသုံးချနိုင်သည့်အခါတွင် let and const သော့ချက်စာလုံးများကို အသုံးပြုရန် စဉ်းစားသင့်သည်။ const သော့ချက်စကားလုံးသည် ပြန်လည်တာဝန်ပေးမှုကိုသာ ပိတ်ထားကြောင်း သတိရပါ။ ၎င်းသည် ကိန်းရှင်ကို မပြောင်းလဲစေပါ။
13. eval() သည် အကြံကောင်းတစ်ခုမဟုတ်ပါ။
မသိသေးသူများအတွက် eval() method သည် JavaScript ၏ compiler သို့ ဝင်ရောက်ခွင့်ပေးသည်။ အခြေခံအားဖြင့်၊ ၎င်းကို input () အဖြစ်ပံ့ပိုးပေးခြင်းဖြင့် string တစ်ခု၏ရလဒ်ကို execute ရန် eval ကိုသုံးနိုင်သည်။
၎င်းသည် သင်၏ script ကို သိသိသာသာ နှေးကွေးစေရုံသာမက၊ ၎င်းသည် လွန်သွားသော စာသားအား အလွန်အမင်း အခွင့်အာဏာ ပေးသောကြောင့် ၎င်းသည် သိသာထင်ရှားသော လုံခြုံရေးဆိုင်ရာ စိုးရိမ်မှုကို ပေးပါသည်။ ကုန်ကျစရိတ်အားလုံး ရှောင်ပါ။
14. Spread Operator သည် အဆင်ပြေပါသည်။
array တစ်ခုရှိ ပစ္စည်းများအားလုံးကို တစ်ခုချင်းဒြပ်စင်များအဖြစ် အခြားလုပ်ဆောင်ချက်တစ်ခုသို့ ပေးပို့ရန် လိုအပ်ပါသလား သို့မဟုတ် တန်ဖိုးအားလုံးကို array တစ်ခုမှ အခြားတစ်ခုသို့ ထားရန်လိုအပ်ပါသလား။ ဤသည်မှာ ဖြန့်ကြက်အော်ပရေတာ (…) က ကျွန်ုပ်တို့ကို အောင်မြင်နိုင်စေသည် ။ ဒါက ဥပမာတစ်ခုပါ။
15. စောင့်ပြီး ထပ်တူလုပ်ပါ။
ပြတ်သားစွာ သို့မဟုတ် သွယ်ဝိုက်၍ဖြစ်စေ အမြဲတမ်း ကတိတစ်ခုပြန်ပေးသည့် async သော့ချက်စကားလုံးကို အသုံးပြု၍ အညီအမျှ လုပ်ဆောင်ချက်များကို ဖန်တီးပါ။
ပြန်လာသောကတိများ ပြီးဆုံးသည်အထိ လုပ်ဆောင်မှုကို ရပ်တန့်ရန် စောင့်နေသောသော့ချက်စကားလုံးကို အပြိုင်အဆိုင်လုပ်ဆောင်မှုများတွင် အသုံးပြုနိုင်သည်။ သင်၏ async လုပ်ဆောင်မှုအပြင်၊ ကုဒ်သည် ပုံမှန်အတိုင်း ဆက်လက်လည်ပတ်နေပါမည်။
16. Javascript တွင် include() method ကိုသုံးပါ။
JavaScript တွင် ပါဝင်သော() လုပ်ဆောင်ချက်သည် စာကြောင်းတစ်ခုတွင် ပံ့ပိုးပေးထားသော ဇာတ်ကောင်များ ပါဝင်ခြင်း ရှိ၊ မရှိ သို့မဟုတ် array တစ်ခုတွင် သတ်မှတ်ထားသော ဒြပ်စင်များ ပါဝင်ခြင်း ရှိမရှိ ဆုံးဖြတ်ပေးသည်။
string သို့မဟုတ် element ကိုရှာဖွေတွေ့ရှိပါက ဤနည်းလမ်းသည် မှန်ပါသည်။ မဟုတ်ရင် false ပြန်ပေးတယ်။ Strings တွင်ပါရှိသော() လုပ်ဆောင်ချက်သည် စာလုံးအကြီးအသေးသာဖြစ်ကြောင်း မှတ်သားထိုက်ပါသည်။ မည်သည်ဖြစ်စေ စာကြောင်းတစ်ခုနှင့် ကိုက်ညီလိုပါက၊ ပစ်မှတ်စာသားကို ဦးစွာ စာလုံးအသေးဖြင့် စာလုံးအသေးလုပ်ပါ။
17. Splice သုံးပြီး array တစ်ခုမှ အရာများကို ဖယ်ရှားပါ။
array တစ်ခုမှ အရာတစ်ခုကို ဖယ်ရှားရန် developer များသည် delete function ကို အသုံးပြုသည်ကို တွေ့ဖူးပါသည်။ အရာဝတ္တုကို ဖျက်ခြင်းထက်၊ ဖျက်ပစ်သည့်နည်းလမ်းက ၎င်းအား သတ်မှတ်မထားသော ဖြင့် အစားထိုးသောကြောင့် ၎င်းသည် မှားယွင်းနေပါသည်။
JavaScript ရှိ ၎င်း၏တန်ဖိုးပေါ် မူတည်၍ array မှဒြပ်စင်တစ်ခုကို ဖယ်ရှားရန် အလွယ်ကူဆုံးနည်းလမ်းမှာ array ရှိ တန်ဖိုး၏ အညွှန်းကိန်းနံပါတ်ကို ရယူရန် indexOf() လုပ်ဆောင်ချက်ကို အသုံးပြုပြီး၊ ထို့နောက် အဆိုပါ အညွှန်းတန်ဖိုးကို splice() method ဖြင့် ဖျက်ပါ ။
18. Arrow Function ကိုအသုံးပြုပါ။
Arrow လုပ်ဆောင်ချက်များသည် JavaScript သို့ ယခုလေးတင်ထည့်သွင်းထားသည့် နောက်ထပ်အရေးကြီးသောအင်္ဂါရပ်များဖြစ်သည်။
သူတို့မှာ အားသာချက်တွေ ရှိတယ်။ အစပိုင်းတွင်၊ ၎င်းတို့သည် JavaScript ၏ လုပ်ဆောင်မှုဆိုင်ရာ အစိတ်အပိုင်းများကို အမြင်အာရုံပို၍ ဆွဲဆောင်နိုင်ပြီး ရေးသားရလွယ်ကူစေသည်။ သို့သော်၊ မြှားလုပ်ဆောင်ချက်များကို အသုံးပြုခြင်းသည် ၎င်းကို ပိုမိုရှင်းလင်းပြတ်သားစေပြီး ပိုတိုစေသည်။
19. Destructuring ဖြင့်၊ သင်သည် ပြောင်းလဲနိုင်သောတန်ဖိုးများကို အမြန်သတ်မှတ်နိုင်သည်။
ဤပို့စ်တွင် အစောပိုင်းက JavaScript တွင် ပျံ့နှံ့နေသော အော်ပရေတာအကြောင်း လေ့လာခဲ့သည်။ Destructuring သည် arrays အတွင်းပါရှိသော data များကို unpack လုပ်ပြီး ဖျက်စီးခြင်း နှင့် ဆင်တူသည်။
ထူးခြားချက်မှာ အဆိုပါ unpacked တန်ဖိုးများကို ကွဲပြားသော ကိန်းရှင်များထံ သတ်မှတ်ပေးနိုင်ပါသည်။ အခင်းအကျင်းတစ်ခုဖန်တီးသောအခါ အထားအသိုသည် [] ဖြတ်လမ်းနှင့် တူညီသည်။ သို့သော်လည်း ဤအချိန်တွင် assignment operator ၏ ဘယ်ဘက်ခြမ်းတွင် ကွင်းစကွင်းပိတ်များကို ထားရှိထားပါသည်။ ဒါက ဥပမာတစ်ခုပါ။
20. ပရောဂျက်များစွာလုပ်ပါ။
အရည်အချင်းရှိသူတိုင်းသည် တသမတ်တည်း လေ့ကျင့်မှုလိုအပ်သည်၊ ထို့ကြောင့် သင်၏စွမ်းရည်များကို မြှင့်တင်ရန်နှင့် ပရိုဂရမ်းမင်းပုံစံအမျိုးမျိုးဖြင့် ကျွမ်းကျင်မှုရရှိရန် ပရောဂျက်အမျိုးမျိုးကို တည်ဆောက်ရန် ကြိုးစားပါ။
ပရောဂျက်များကို လုပ်ဆောင်နေစဉ်တွင် လိုအပ်သော ကျွမ်းကျင်မှုများကို ပံ့ပိုးပေးမည့် စိန်ခေါ်မှုများနှင့် အမှားအယွင်းများစွာကို တွေ့ကြုံရမည်ဖြစ်သည်။ ထို့ကြောင့် ပရောဂျက်များကို အကောင်အထည်ဖော်ရန် ကြိုးစားပါ၊ သင့်အား ကူညီရန် အင်တာနက်ပေါ်တွင် အကြံဥာဏ်များနှင့် ဥပမာများစွာရှိသည်။ ကုဒ်ကို ဆက်လက်ဖန်တီးပါ၊ သင်၏စွမ်းရည်များ တိုးတက်လာပါမည်။
ကောက်ချက်
JavaScript ကဲ့သို့ ကွန်ပြူတာဘာသာစကားကို လေ့လာရန် ခက်ခဲနိုင်သည်။ အကယ်၍ သင်သည် ပရိုဂရမ်မာကောင်းတစ်ဦးဖြစ်ရန်နှင့် သင့်ပထမဆုံးအလုပ်ရရှိရန် အလေးအနက်ထားနေပါက၊ ဤ JavaScript သင်ယူမှုဗျူဟာများသည် သင့်သင်ယူမှုလုပ်ငန်းစဉ်ကို အရှိန်မြှင့်ရန် ကူညီပေးနိုင်ပါသည်။
ကုဒ်ရေးနည်းကို ပုံမှန်လေ့ကျင့်ပါ၊ အိုင်ဒီယာအသစ်များကို လေ့လာနေစဉ်တွင် စေ့စေ့စပ်စပ်မှတ်စုများ မှတ်သားထားပြီး သင့်အတွက်ရနိုင်သော ကိရိယာအားလုံးကို အသုံးပြုပါ။ ထို့ထက်၊ ထိုနေရာမှထွက်ပြီး ပျော်ရွှင်နေစဉ် ကုဒ်ရေးခြင်းကို စတင်ပါ။
တစ်ဦးစာပြန်ရန် Leave