JavaScript နံပါတ်များ
JavaScript တွင် နံပါတ်တစ်မျိုးတည်းသာရှိသည်။ ဂဏန်းများကို ဒဿမများဖြင့် သို့မဟုတ် မပါဘဲ ရေးသားနိုင်သည်။
ဥပမာ
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
အပိုကြီး သို့မဟုတ် အပိုအသေးနံပါတ်များကို သိပ္ပံနည်းကျ (ထပ်ကိန်း) အမှတ်အသားဖြင့် ရေးသားနိုင်သည်-
ဥပမာ
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
JavaScript နံပါတ်များသည် အမြဲတမ်း 64-bit Floating Point ဖြစ်သည်။
အခြားသော ပရိုဂရမ်းမင်းဘာသာစကားများစွာနှင့်မတူဘဲ၊ JavaScript သည် ကိန်းပြည့်များ၊ အတို၊ အတို၊ အရှည်၊ floating-point စသည်တို့ကဲ့သို့ မတူညီသောနံပါတ်အမျိုးအစားများကို မသတ်မှတ်ထားပေ။
JavaScript နံပါတ်များကို နိုင်ငံတကာ IEEE 754 စံနှုန်းအတိုင်း နှစ်ဆတိကျသော floating point နံပါတ်များအဖြစ် အမြဲသိမ်းဆည်းထားသည်။
ဤဖော်မတ်သည် နံပါတ်များ (အပိုင်းကိန်း) ကို ဘစ် 0 မှ 51 အတွင်း သိမ်းဆည်းထားရာ၊ ဘစ် 52 မှ 62 အတွင်းရှိ ထပ်ကိန်းနှင့် ဘစ် 63 တွင် သင်္ကေတကို သိမ်းဆည်းသည့် ဤဖော်မတ်သည် နံပါတ်များကို 64 ဘစ်တွင် သိမ်းဆည်းထားသည်။
| တန်ဖိုး (အပိုင်းအစ/Mantissa) | ထပ်ညွှန်း | ဆိုင်းဘုတ် |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
ကိန်းပြည့် တိကျမှု
ကိန်းပြည့်များ (အပိုင်းအခြား သို့မဟုတ် ထပ်ကိန်းအမှတ်အသားမပါသော ဂဏန်းများ) သည် ဂဏန်း 15 လုံးအထိ တိကျပါသည်။
ဥပမာ
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
အများဆုံး ဒဿမ အရေအတွက်သည် 17 ဖြစ်သည်။
Floating Precision
Floating Point ဂဏန်းသင်္ချာသည် အမြဲတမ်း 100% တိကျသည်မဟုတ်ပါ-
let x = 0.2 + 0.1;
အထက်ဖော်ပြပါပြဿနာကိုဖြေရှင်းရန်၊ ၎င်းသည် များပြားခြင်းနှင့် ပိုင်းခြားရန် ကူညီပေးသည်-
let x = (0.2 * 10 + 0.1 * 10) / 10;
နံပါတ်များနှင့် စာကြောင်းများ ပေါင်းထည့်ခြင်း။
သတိပေးချက် !!
JavaScript သည် ပေါင်းထည့်ခြင်းနှင့် ပေါင်းစပ်ခြင်းအတွက် + အော်ပရေတာကို အသုံးပြုသည်။
နံပါတ်များထည့်ထားသည်။ ကြိုးများကို ပေါင်းစပ်ထားသည်။
ဂဏန်းနှစ်လုံးထည့်ရင် ရလဒ်က နံပါတ်တစ်ခု ဖြစ်လိမ့်မယ်-
ဥပမာ
let x = 10;
let y = 20;
let z = x + y;
ကြိုးနှစ်ချောင်းထည့်ပါက၊ ရလဒ်သည် စာကြောင်းပေါင်းစပ်ခြင်းဖြစ်လိမ့်မည်-
ဥပမာ
let x = "10";
let y = "20";
let z = x + y;
အကယ်၍ သင်သည် နံပါတ်တစ်ခုနှင့် စာကြောင်းတစ်ခုကို ပေါင်းထည့်ပါက၊ ရလဒ်သည် string ပေါင်းစပ်မှုဖြစ်လိမ့်မည်-
ဥပမာ
let x = 10;
let y = "20";
let z = x + y;
ကြိုးတစ်ချောင်းနှင့် နံပါတ်တစ်ခုကို ပေါင်းထည့်ပါက၊ ရလဒ်သည် စာကြောင်းတစ်ကြောင်း ပေါင်းစပ်ခြင်းဖြစ်လိမ့်မည်-
ဥပမာ
let x = "10";
let y = 20;
let z = x + y;
ဘုံအမှားတစ်ခုသည် ဤရလဒ်ကို 30 ဖြစ်ရန် မျှော်လင့်ထားခြင်းဖြစ်သည်။
ဥပမာ
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
ဘုံအမှားတစ်ခုသည် ဤရလဒ်ကို 102030 ဖြစ်ရန် မျှော်လင့်ခြင်းဖြစ်သည်-
ဥပမာ
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
JavaScript စကားပြန်သည် ဘယ်မှညာသို့ အလုပ်လုပ်သည်။
ပထမ 10 + 20 ကို x နှင့် y သည် နံပါတ်နှစ်ခုလုံးဖြစ်သောကြောင့် ပေါင်းထည့်သည်။
z သည် string တစ်ခုဖြစ်သောကြောင့် 30 + "30" ကို ပေါင်းစပ်ထားသည်။
ဂဏန်းကြိုးများ
JavaScript လိုင်းများတွင် ကိန်းဂဏာန်း အကြောင်းအရာများ ရှိနိုင်သည်-
let x = 100; // x is a number
let y = "100"; // y is a
string
JavaScript သည် ဂဏန်းလုပ်ဆောင်မှုအားလုံးတွင် strings များကို နံပါတ်များသို့ ပြောင်းရန် ကြိုးစားပါမည်-
၎င်းသည် အလုပ်လုပ်မည်-
let x = "100";
let y = "10";
let z = x / y;
၎င်းသည်လည်း လုပ်ဆောင်နိုင်လိမ့်မည်-
let x = "100";
let y = "10";
let z = x * y;
ပြီးတော့ ဒါက အလုပ်ဖြစ်မှာပါ
let x = "100";
let y = "10";
let z = x - y;
ဒါပေမယ့် ဒါက အလုပ်မဖြစ်ဘူး-
let x = "100";
let y = "10";
let z = x + y;
နောက်ဆုံးဥပမာတွင် JavaScript သည် strings များကိုပေါင်းစပ်ရန် + operator ကိုအသုံးပြုသည်။
NaN - နံပါတ်မဟုတ်ပါ။
NaN နံပါတ်သည် တရားဝင်နံပါတ်မဟုတ်ကြောင်း ဖော်ပြသော JavaScript သီးသန့်စကားလုံးဖြစ်သည်။
ဂဏန်းမဟုတ်သော စာကြောင်းဖြင့် ဂဏန်းသင်္ချာဖြင့် ဂဏန်းသင်္ချာပြုလုပ်ရန် ကြိုးစားခြင်းသည် NaN(နံပါတ်မဟုတ်ပါ) ရလဒ်ဖြစ်လိမ့်မည်-
ဥပမာ
let x = 100 / "Apple";
သို့သော်၊ စာကြောင်းတွင် ကိန်းဂဏာန်းတန်ဖိုးတစ်ခုပါရှိလျှင် ရလဒ်သည် နံပါတ်တစ်ခု ဖြစ်လိမ့်မည်-
ဥပမာ
let x = 100 / "10";
isNaN()
တန်ဖိုးသည် နံပါတ်မဟုတ်ကြောင်း သိရှိရန် global JavaScript လုပ်ဆောင်ချက်ကို သင်အသုံးပြုနိုင်ပါသည် ။
ဥပမာ
let x = 100 / "Apple";
isNaN(x);
သတိထားပါ NaN။ NaNသင်္ချာဆိုင်ရာ လုပ်ဆောင်ချက်တစ်ခုတွင် သင်အသုံးပြု ပါက ရလဒ်သည်လည်း NaN:
ဥပမာ
let x = NaN;
let y = 5;
let z = x + y;
သို့မဟုတ် ရလဒ်သည် NaN5 ကဲ့သို့ ပေါင်းစပ်ခြင်း ဖြစ်နိုင်သည်-
ဥပမာ
let x = NaN;
let y = "5";
let z = x + y;
NaNနံပါတ်တစ် ခု typeof NaNဖြစ်ပါသည်number
ဥပမာ
typeof NaN;
အဆုံးမရှိ
Infinity(သို့မဟုတ် -Infinity) သည် ဖြစ်နိုင်ချေအကြီးဆုံးနံပါတ်အပြင်ဘက်တွင် ဂဏန်းတစ်ခုကို တွက်ချက်ပါက JavaScript ၏တန်ဖိုးသည် ပြန်ပေးမည်ဖြစ်သည်။
ဥပမာ
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
0 (သုည) ဖြင့် ခွဲထုတ်သည် Infinity:
ဥပမာ
let x = 2 / 0;
let y = -2 / 0;
Infinityနံပါတ်တစ်ခုဖြစ်သည်- typeof Infinityပြန်လာသည် number။
ဥပမာ
typeof Infinity;
ဆဋ္ဌမကိန်းဂဏန်း
JavaScript သည် ဂဏန်းကိန်းသေများကို 0x ၏ ရှေ့တွင် ထားလျှင် hexadecimal အဖြစ် ဘာသာပြန်ပေးသည်။
ဥပမာ
let x = 0xFF;
သုည (၀၇) ကဲ့သို့ ရှေ့ဆုံးမှ ဂဏန်းကို ဘယ်တော့မှ မရေးပါနှင့်။
အချို့သော JavaScript ဗားရှင်းများသည် ဂဏန်းများကို ရှေ့ဆုံး သုညဖြင့် ရေးပါက အဋ္ဌမမြောက်ဟု အဓိပ္ပာယ်ဖွင့်ဆိုကြသည်။
မူရင်းအားဖြင့်၊ JavaScript သည် နံပါတ်များကို အခြေခံ 10 ဒဿမများအဖြစ် ပြသသည်။
ဒါပေမယ့် base 2
ကနေ base 36toString() အထိ နံပါတ်တွေကို ထုတ်ဖို့ နည်းလမ်းကို အသုံးပြုနိုင်ပါတယ် ။
Hexadecimal သည် အခြေခံ 16 ဖြစ်သည်။ ဒဿမသည် အခြေ 10 ဖြစ်သည်။ Octal သည် base 8 ဖြစ်သည်။ Binary သည် အခြေခံ 2 ဖြစ်သည်။
ဥပမာ
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
အရာဝတ္ထုများအဖြစ် JavaScript နံပါတ်များ
ပုံမှန်အားဖြင့် JavaScript နံပါတ်များသည် အက္ခရာများမှ ဖန်တီးထားသော မူလတန်ဖိုးများဖြစ်သည်-
let x = 123;
သို့သော် နံပါတ်များကို အဓိကစကားလုံးဖြင့် အရာဝတ္ထုများအဖြစ် သတ်မှတ်နိုင်သည် new။
let y = new Number(123);
ဥပမာ
let x = 123;
let y = new Number(123);
နံပါတ်အရာဝတ္ထုများကို မဖန်တီးပါနှင့်။
သော့ချက်စကားလုံး သည် newကုဒ်ကို ရှုပ်ထွေးစေပြီး လုပ်ဆောင်မှုအရှိန်ကို နှေးကွေးစေသည်။
နံပါတ်အရာဝတ္ထုများသည် မျှော်လင့်မထားသောရလဒ်များကို ထုတ်ပေးနိုင်သည်-
အော်ပရေတာ အသုံးပြုသောအခါ ==၊ x နှင့် y သည် ညီမျှသည် ။
let x = 500;
let y = new Number(500);
အော်ပရေတာ အသုံးပြုသောအခါ ===၊ x နှင့် y သည် မညီ ပါ။
let x = 500;
let y = new Number(500);
(x==y)နှင့် အကြား ခြားနားချက်ကို မှတ်သားပါ (x===y)။
(x == y) မှန်လား မှားလား?
let x = new Number(500);
let y = new Number(500);
(x === y) မှန်လား မှားလား?
let x = new Number(500);
let y = new Number(500);
Comparing two JavaScript objects always returns false.
Complete JavaScript Number Reference
For a complete Number reference, visit our:
Complete JavaScript Number Reference.
The reference contains descriptions and examples of all Number properties and methods.