JavaScript အကောင်းဆုံးအလေ့အကျင့်များ
ကမ္ဘာလုံးဆိုင်ရာပြောင်းလွဲမှုများကို ရှောင် ပါ၊ ရှောင်ပါ new၊ ရှောင် ==ပါ၊ ရှောင်ပါ။eval()
Global Variables များကို ရှောင်ပါ။
ကမ္ဘာလုံးဆိုင်ရာကိန်းရှင်များအသုံးပြုမှုကို လျှော့ချပါ။
၎င်းတွင် ဒေတာအမျိုးအစားများ၊ အရာဝတ္ထုများနှင့် လုပ်ဆောင်ချက်များ အားလုံးပါဝင်သည်။
ကမ္ဘာလုံးဆိုင်ရာ ကိန်းရှင်များနှင့် လုပ်ဆောင်ချက်များကို အခြားသော script များဖြင့် အစားထိုးနိုင်ပါသည်။
၎င်းအစား local variables များကိုသုံးပါ၊ နှင့် ပိတ် နည်းကိုအသုံးပြုနည်းကို လေ့လာ ပါ။
Local Variables များကို အမြဲကြေငြာပါ။
လုပ်ဆောင်ချက်တစ်ခုတွင် အသုံးပြုသည့် variable အားလုံးကို local variables အဖြစ် ကြေညာသင့်သည်။
ဒေသဆိုင်ရာ ကိန်းရှင်များ ကို
သော့ချက်စကားလုံး သို့မဟုတ် သော့ချက်စကားလုံး သို့မဟုတ် သော့ချက်စကားလုံး ဖြင့် ကြေညာ ရမည် ၊ မဟုတ်ပါက ၎င်းတို့သည် ကမ္ဘာလုံးဆိုင်ရာ ကိန်းရှင်များ ဖြစ်လာမည်ဖြစ်သည်။varletconst
တင်းကျပ်သောမုဒ်သည် မကြေငြာထားသော ကိန်းရှင်များကို ခွင့်မပြုပါ။
ထိပ်တန်းကြေငြာချက်များ
ကြေငြာချက်အားလုံးကို script သို့မဟုတ် function တစ်ခုစီ၏ထိပ်တွင်ထည့်ရန် coding လေ့ကျင့်ခြင်းသည် ကောင်းမွန်ပါသည်။
၎င်းသည်-
- သန့်ရှင်းသောကုဒ်ကိုပေးပါ။
- Local variable များကို ရှာဖွေရန် တစ်ခုတည်းသော နေရာကို ပေးပါ။
- မလိုလားအပ်သော (အဓိပ္ပာယ်သက်ရောက်) ကမ္ဘာလုံးဆိုင်ရာ ပြောင်းလွဲချက်များကို ရှောင်ရှားရန် ပိုမိုလွယ်ကူစေသည်။
- မလိုလားအပ်သော ပြန်လည်ကြေငြာမှုများ ဖြစ်နိုင်ချေကို လျှော့ချပါ။
// Declare at the beginning
let firstName, lastName, price, discount, fullPrice;
// Use later
firstName = "John";
lastName = "Doe";
price = 19.90;
discount = 0.10;
fullPrice = price - discount;
၎င်းသည် loop variable များအတွက်လည်း သက်ဆိုင်သည်-
for (let i = 0; i < 5; i++)
{
Variables များကို စတင်ပါ။
ကိန်းရှင်များကို သင်ကြေညာသောအခါတွင် ကိန်းရှင်များကို စတင်ရန် ကုဒ်ရေးနည်းကောင်းတစ်ခုဖြစ်သည်။
၎င်းသည်-
- သန့်ရှင်းသောကုဒ်ကိုပေးပါ။
- ကိန်းရှင်များကို အစပြုရန် တစ်ခုတည်းသော နေရာကို ပေးပါ။
- သတ်မှတ်မထားသော တန်ဖိုးများကို ရှောင်ကြဉ်ပါ။
// Declare and initiate at the beginning
let firstName = "",
let lastName = "",
let price = 0,
let discount = 0,
let fullPrice = 0,
const myArray = [],
const myObject = {};
ကိန်းရှင်များကို အစပြုခြင်းသည် ရည်ရွယ်ထားသော အသုံးပြုမှု (နှင့် ရည်ရွယ်ထားသော ဒေတာအမျိုးအစား) ကို ပေးဆောင်သည်။
အရာဝတ္ထုများကို const ဖြင့်ကြေငြာပါ။
အရာဝတ္ထုများကို const ဖြင့်ကြေငြာခြင်းသည် မတော်တဆအမျိုးအစားပြောင်းလဲမှုကို တားဆီးနိုင်သည်-
ဥပမာ
let car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat"; // Changes object to string
const car = {type:"Fiat", model:"500", color:"white"};
car = "Fiat"; // Not possible
Array များကို const ဖြင့်ကြေငြာပါ။
array များကို const ဖြင့်ကြေငြာခြင်းသည် မတော်တဆအမျိုးအစားပြောင်းလဲမှုကို တားဆီးနိုင်သည်-
ဥပမာ
let cars = ["Saab", "Volvo", "BMW"];
cars = 3; // Changes array to number
const cars = ["Saab", "Volvo", "BMW"];
cars = 3; // Not possible
အရာဝတ္ထုအသစ်()ကို မသုံးပါနှင့်
- အ စားသုံး
""ပါ။new String() - အ စားသုံး
0ပါ။new Number() - အ စားသုံး
falseပါ။new Boolean() - အ စားသုံး
{}ပါ။new Object() - အ စားသုံး
[]ပါ။new Array() - အ စားသုံး
/()/ပါ။new RegExp() - အ စားသုံး
function (){}ပါ။new Function()
ဥပမာ
let x1 = ""; // new primitive string
let x2 = 0; // new primitive number
let x3 = false; // new primitive boolean
const x4 = {}; // new object
const x5 = []; // new array object
const x6 = /()/; // new regexp object
const x7 = function(){}; // new function object
အလိုအလျောက် အမျိုးအစားပြောင်းခြင်းကို သတိပြုပါ။
JavaScript ကို ဖြည်းညှင်းစွာ ရိုက်သည်။
ကိန်းရှင်တစ်ခုတွင် ဒေတာအမျိုးအစားအားလုံး ပါဝင်နိုင်သည်။
ကိန်းရှင်တစ်ခုသည် ၎င်း၏ဒေတာအမျိုးအစားကို ပြောင်းလဲနိုင်သည်-
ဥပမာ
let x = "Hello"; // typeof x is a string
x = 5; // changes typeof x to a number
NaNနံပါတ်များသည် စာကြောင်းများ သို့မဟုတ် (နံပါတ်မဟုတ်) သို့ မတော်တဆ ပြောင်းသွားနိုင်သည်ကို သတိပြုပါ ။
သင်္ချာဆိုင်ရာ လုပ်ဆောင်ချက်များကို လုပ်ဆောင်သောအခါ၊ JavaScript သည် နံပါတ်များကို စာကြောင်းများအဖြစ် ပြောင်းလဲနိုင်သည်-
ဥပမာ
let x = 5 + 7; // x.valueOf() is 12, typeof x is a number
let x = 5 + "7"; // x.valueOf() is 57, typeof x is a string
let x = "5" + 7; // x.valueOf() is 57, typeof x is a string
let x = 5 - 7; // x.valueOf() is -2, typeof x is a number
let x = 5 - "7"; // x.valueOf() is -2, typeof x is a number
let x = "5" - 7; // x.valueOf() is -2, typeof x is a number
let x = 5 - "x"; // x.valueOf() is NaN, typeof x is a number
စာကြောင်းတစ်ကြောင်းမှ ကြိုးတစ်ချောင်းကို နုတ်ခြင်း၊ အမှားတစ်ခု မထုတ်ပေးသော်လည်း ပြန်ပေးသည် NaN(နံပါတ်မဟုတ်ပါ)။
ဥပမာ
"Hello" - "Dolly" // returns NaN
=== နှိုင်းယှဉ်မှုကို အသုံးပြုပါ။
နှိုင်းယှဉ်မှုအော်ပရေတာ သည် ==နှိုင်းယှဉ်ခြင်းမပြုမီ (တူညီသောအမျိုးအစားများသို့) အမြဲပြောင်းသည်။
အော် ===ပရေတာသည် တန်ဖိုးများနှင့် အမျိုးအစားကို နှိုင်းယှဉ်ခိုင်းသည်-
ဥပမာ
0 == ""; // true
1 == "1"; // true
1 == true; // true
0 === ""; // false
1 === "1"; // false
1 === true;
// false
Parameter Defaults ကိုသုံးပါ။
လွဲမှားနေသော အကြောင်းပြချက်တစ်ခုဖြင့် လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်ပါက၊ ပျောက်ဆုံးနေသော အကြောင်းပြချက်၏တန်ဖိုးကို သတ်မှတ်ထားသည်
undefined။
သတ်မှတ်မထားသော တန်ဖိုးများသည် သင့်ကုဒ်ကို ချိုးဖျက်နိုင်သည်။ ငြင်းခုံမှုများတွင် ပုံသေတန်ဖိုးများကို သတ်မှတ်ခြင်းသည် ကောင်းသောအကျင့်တစ်ခုဖြစ်သည်။
ဥပမာ
function myFunction(x, y) {
if (y === undefined) {
y = 0;
}
}
ECMAScript 2015 သည် လုပ်ဆောင်ချက် အဓိပ္ပါယ်ဖွင့်ဆိုချက်တွင် မူရင်းဘောင်များကို ခွင့်ပြုသည်-
function (a=1, b=1) { /*function code*/ }
Function Parameters တွင် လုပ်ဆောင်ချက်ပါရာမီတာများနှင့် အကြောင်းပြချက်များအကြောင်း ပိုမိုဖတ်ရှုပါ။
သင့်ခလုတ်များကို ပုံသေများဖြင့် အဆုံးသတ်ပါ။
switchသင့် ထုတ်ပြန်ချက်များကို အမြဲတမ်းတစ်ခုနှင့် အဆုံးသတ်ပါ default။ မလိုအပ်ဘူးလို့ ထင်နေရင်တောင်။
ဥပမာ
switch (new Date().getDay()) {
case 0:
day = "Sunday";
break;
case 1:
day = "Monday";
break;
case 2:
day = "Tuesday";
break;
case 3:
day = "Wednesday";
break;
case 4:
day = "Thursday";
break;
case 5:
day = "Friday";
break;
case 6:
day = "Saturday";
break;
default:
day =
"Unknown";
}
အရာဝတ္ထုများအဖြစ် နံပါတ်၊ စာကြောင်းနှင့် Boolean ကို ရှောင်ကြဉ်ပါ။
နံပါတ်များ၊ စာကြောင်းများ သို့မဟုတ် ဘူလီယံများကို မူလတန်ဖိုးများအဖြစ် အမြဲတမ်း ဆက်ဆံပါ။ အရာဝတ္ထုများကဲ့သို့မဟုတ်ပေ။
ဤအမျိုးအစားများကို အရာဝတ္ထုများအဖြစ် ကြေညာခြင်း၊ လည်ပတ်မှုအရှိန်ကို နှေးကွေးစေပြီး ဆိုးရွားသော ဘေးထွက်ဆိုးကျိုးများကို ဖြစ်ပေါ်စေသည်-
ဥပမာ
let x = "John";
let y = new String("John");
(x === y) // is false because x is a string and y is an object.
သို့မဟုတ် ပိုဆိုးသည်-
ဥပမာ
let x = new String("John");
let y = new String("John");
(x == y) // is false because you cannot compare objects.
eval() ကို ရှောင်ပါ
စာသားကို eval()ကုဒ်အဖြစ် လုပ်ဆောင်ရန် လုပ်ဆောင်ချက်ကို အသုံးပြုသည်။ ကိစ္စတိုင်းလိုလိုတွင်၊ ၎င်းကိုအသုံးပြုရန်မလိုအပ်ပါ။
၎င်းသည် မတရားကုဒ်ကို လုပ်ဆောင်ရန် ခွင့်ပြုသောကြောင့်၊ ၎င်းသည် လုံခြုံရေးပြဿနာကိုလည်း ကိုယ်စားပြုသည်။