ສາຍລະບົບຈຳນວນ JavaScript

ພາສາຈີສະຕິດມີພຽງປະເພດຈຳນວນດຽວ.

ການຂຽນຈຳນວນສາມາດມີບາງບໍ່ມີຄວາມພິການ.

ພາສາຈີສະຕິດ

书写 JavaScript 数值既可以带小数点，也可以不带：

ຄວາມທີ່ພາບ

var x = 3.14;    // 带小数点的数值
var y = 3;       // 不带小数点的数值

ທົດລອງເອງ

超大或超小的数可通过科学计数法来写：

ຄວາມທີ່ພາບ

var x = 123e5;    // 12300000
var y = 123e-5;   // 0.00123

ທົດລອງເອງ

JavaScript 数值始终是 64 位的浮点数

ທັງໝົດຄຳສັບຂອງ JavaScript ຈະເປັນຈຳນວນບາງຄັ້ງ 64 ບຸນທີ່ຈະຖືກບັນທຶກ.

ຈຳນວນຂອງ JavaScript ບໍ່ມີຄວາມສະຫຼາດສະເຫຼີມທີ່ຈະຖືກບັນທຶກຢູ່ເທິງຄວາມສະຫຼາດດັບວິທະຍາສາກົນ IEEE 754.

ຮູບແບບນີ້ບໍ່ມີຄວາມສະຫຼາດຫຼາຍຫຼາຍຫາ 64 ບຸນ ດັ່ງນັ້ນ 0 ຫາ 51 ບຸນບໍ່ມີຄວາມສະຫຼາດຈຳນວນ (ບາງຢ່າງ), 52 ຫາ 62 ບຸນບໍ່ມີຄວາມສະຫ�າດອັດຕາ, 63 ບຸນບໍ່ມີຄວາມສະຫ�າດສັນຍາ:

ຄູ່ມວນ (ອັດຕາສະເຫຼີມ/ການຕອບສະເຫຼີມ) ອັດຕາ ສັນຍາ
52 bits(0 - 51) 11 bits (52 - 62) 1 bit (63)

ຄວາມສະຫຼາດ

ຈຳນວນທີ່ບໍ່ນຳໃຊ້ອັດຕາລະບົບ ຫຼືຄຳສັບວິທະຍາສາກົນຈະຖືກບັນທຶກຄວາມສະຫຼາດຫຼາຍຫຼາຍຫາ 15 ບຸນ.

ຄວາມທີ່ພາບ

var x = 999999999999999;   // x ຈະເປັນ 999999999999999
var y = 9999999999999999;  // y ຈະເປັນ 10000000000000000

ທົດລອງເອງ

ຈຳນວນສະລິບສູງສຸດແມ່ນ 17 ບຸນ ແຕ່ການທົດສະນະຈຳນວນບາງຄັ້ງຈະບໍ່ສະຫຼາດຄວາມສະຫຼາດ 100%:

ຄວາມທີ່ພາບ

var x = 0.2 + 0.1;         // x ຈະເປັນ 0.30000000000000004

ທົດລອງເອງ

ການນຳໃຊ້ການສົມທຽບທົດສະນະ ແລະການແບ່ງປະກອບຈະຊ່ວຍເຫຼືອບັນຫາທີ່ມີຫຼັງຈາກນັ້ນ:

ຄວາມທີ່ພາບ

var x = (0.2 * 10 + 0.1 * 10) / 10;       // x ຈະເປັນ 0.3

ທົດລອງເອງ

ຈຳນວນ ແລະ ຄຳສັບການສົມທຽບ

ຄໍາເຕືອນ !!

ການສົມທຽບ ແລະ ການກ່ຽວຂ້ອງຂອງ JavaScript ທົດສະນະ +.

ຈຳນວນໃຊ້ການສົມທຽບ. ຄຳສັບໃຊ້ການກ່ຽວຂ້ອງ.

ຖ້າທີ່ທ່ານຈະສົມທຽບຈຳນວນສອງອັນຫຼັງຈາກນັ້ນຈະເປັນຈຳນວນ:

ຄວາມທີ່ພາບ

var x = 10;
var y = 20;
var z = x + y;           // z ຈະເປັນ 30 (ຈຳນວນ)

ທົດລອງເອງ

ຖ້າທີ່ທ່ານຈະສົມທຽບຄຳສັບສອງອັນຫຼັງຈາກນັ້ນຈະເປັນການກ່ຽວຂ້ອງຄຳສັບ:

ຄວາມທີ່ພາບ

var x = "10";
var y = "20";
var z = x + y;           // z 将是 1020（字符串）

ທົດລອງເອງ

ຖ້າທີ່ທ່ານຈະການສົມທຽບຈຳນວນກັບຄຳສັບຫຼັງຈາກນັ້ນຈະເປັນການກ່ຽວຂ້ອງຈາກຄຳສັບ:

ຄວາມທີ່ພາບ

var x = 10;
var y = "20";
var z = x + y;           // z ຈະເປັນ 1020 (ການກ່ຽວຂ້ອງຈາກຄຳສັບ)

ທົດລອງເອງ

如果您对一个字符串和一个数字相加，结果也是字符串级联：

ຄວາມທີ່ພາບ

var x = "10";
var y = 20;
var z = x + y;           // z 将是 1020（字符串）

ທົດລອງເອງ

常见的错误是认为结果应该是 30：

ຄວາມທີ່ພາບ

var x = 10;
var y = 20;
var z = "The result is: " + x + y;

ທົດລອງເອງ

常见的错误是认为结果应该是 102030：

ຄວາມທີ່ພາບ

var x = 10;
var y = 20;
var z = "30";
var result = x + y + z;

ທົດລອງເອງ

JavaScript 从左向右进行编译。

因为 x 和 y 都是数，10 + 20 将被相加。

因为 z 是字符串，30 + "30" 被级联。

数字字符串

JavaScript 字符串可以拥有数字内容：

var x = 100;         // x 是数字
var y = "100";       // y 是字符串

在所有数字运算中，JavaScript 会尝试将字符串转换为数字：

该例如此运行：

var x = "100";
var y = "10";
var z = x / y;       // z 将是 10

ທົດລອງເອງ

该例也将如此运行：

var x = "100";
var y = "10";
var z = x * y;       // z 将是 1000

ທົດລອງເອງ

该例如此运行：

var x = "100";
var y = "10";
var z = x - y;      // z 将是 90

ທົດລອງເອງ

但是该例不会如上例般运行：

var x = "100";
var y = "10";
var z = x + y;       // z 不会是 110（而是 10010）

ທົດລອງເອງ

在最后一个例子中，JavaScript 用 + 运算符对字符串进行了级联。

NaN - 非数值

NaN 属于 JavaScript 保留词，指示某个数不是合法数。

尝试用一个非数字字符串进行除法会得到 NaN（Not a Number）：

ຄວາມທີ່ພາບ

var x = 100 / "Apple";  // x 将是 NaN（Not a Number）

ທົດລອງເອງ

不过，假如字符串包含数值，则结果将是数：

ຄວາມທີ່ພາບ

var x = 100 / "10";     // x 将是 10

ທົດລອງເອງ

您可使用全局 JavaScript 函数 isNaN() 来确定某个值是否是数：

ຄວາມທີ່ພາບ

var x = 100 / "Apple";
isNaN(x);               // 返回 true，因为 x 不是数

ທົດລອງເອງ

ຕ້ອງຫັນຫຼາຍ NaN。ຖ້າທ່ານໃຊ້ວິທະຍາດຳເນີນການທຳນາຍວິທະຍາດຳເນີນ NaNຊຶ່ງຜົນຄືນຈະເປັນ NaN：

ຄວາມທີ່ພາບ

var x = NaN;
var y = 5;
var z = x + y;         // z ຈະເປັນ NaN

ທົດລອງເອງ

ຜົນຄືນອາດເປັນການຕິດຕໍ່ຂອງສາຍ

ຄວາມທີ່ພາບ

var x = NaN;
var y = "5";
var z = x + y;         // z ຈະເປັນ NaN5

ທົດລອງເອງ

NaN ຈະເປັນວິທະຍາtypeof NaN ກັບຄືນ number：

ຄວາມທີ່ພາບ

typeof NaN;             // ກັບຄືນ "number"

ທົດລອງເອງ

Infinity

Infinity ຫຼື -Infinity）ຈະເປັນວິທະຍາທີ່ JavaScript ກັບຄືນໃນການທຳນາຍວິທະຍາຫຼາຍກວ່າຄວາມສາມາດທີ່ສູງສຸດ

ຄວາມທີ່ພາບ

var myNumber = 2;
while (myNumber != Infinity) {          // ດຳເນີນຈົນກວ່າ Infinity
    myNumber = myNumber * myNumber;
}

ທົດລອງເອງ

ການແບ່ງຕະຫຼາດ 0 (ບໍ່ມີ) ຈະເປັນວິທະຍາ Infinity：

ຄວາມທີ່ພາບ

var x =  2 / 0;          // x ຈະເປັນ Infinity
var y = -2 / 0;          // y ຈະເປັນ -Infinity

ທົດລອງເອງ

Infinity ຈະເປັນວິທະຍາ:typeOf Infinity ກັບຄືນ number。

ຄວາມທີ່ພາບ

typeof Infinity;        // ກັບຄືນ "number"

ທົດລອງເອງ

ສິບຫຼາຍ

JavaScript ຈະອະທິບາຍວິທະຍາທີ່ມີການວາງວຽງຫຼັງການການການການການປະກາດສິບຫຼາຍ 0x ຄຳການປະກາດວິທະຍາສະເພາະຈະຖືກອະທິບາຍວ່າສິບຫຼາຍ

ຄວາມທີ່ພາບ

var x = 0xFF;             // x ຈະເປັນ 255。

ທົດລອງເອງ

ບໍ່ຕ້ອງໃຊ້ການວາງວຽງຫຼັງການການການປະກາດວິທະຍາ (ອີງຕາມ 07)

ບາງສະບັນຍາວິທະຍາ JavaScript ຈະອະທິບາຍວິທະຍາທີ່ມີການວາງວຽງຫຼັງການການສະແດງສະຫຼາກ

ໂດຍຜົນຕໍາແໜ່ງວິທະຍາ JavaScript ສະແດງວິທະຍາໃຫ້ເປັນສາມມາດສິບຫຼາຍ

ບໍ່ວ່າທ່ານສາມາດໃຊ້ toString() ວິທະຍາການທີ່ອອກວິທະຍາໃຫ້ເປັນສາມມາດສິບຫົກຫຼືສິບສອງຫຼືສິບສອງສາມ

ຄວາມທີ່ພາບ

var myNumber = 128;
myNumber.toString(16);     // ກັບຄືນ 80
myNumber.toString(8);      // ກັບຄືນ 200
myNumber.toString(2);      // ກັບຄືນ 10000000

ທົດລອງເອງ

ວິທະຍາສາມາດເປັນບັນດາວິທະຍາອອກໄປ

ທຳມະດາວິທະຍາ JavaScript ແມ່ນໄດ້ສ້າງຈາກຄຳຂອງວິທະຍາສະເພາະ: var x = 123

ແຕ່ກໍ່ສາມາດກໍານົດຢູ່ບໍ່? new ກໍານົດວ່າເປັນວັດຖຸ: var y = new Number(123)

ຄວາມທີ່ພາບ

var x = 123;
var y = new Number(123);
// typeof x ແມ່ນ number
// typeof y ແມ່ນ object

ທົດລອງເອງ

ບໍ່ຕ້ອງສ້າງວັດຖຸສະເພາະນັ້ນ. ນັ້ນຈະຫຼຸດຄວາມໄວຂອງການດຳເນີນ.

new ຄຳປະກອບສະເພາະຈະເຮັດໃຫ້ວິທະຍາສາດຂອງຈາກການຂຽນກະທັກປົກກະຕິຈະຈະເປັນສິ່ງທີ່ບໍ່ສາມາດຄາດຄະເນດ້ວຍ.

ເມື່ອໃຊ້ == ຫຼັງຈາກການໃຊ້ຜູ້ບັນທຶກ, ຈຳນວນທີ່ສະເໝີ ຈະເບິ່ງຄືກັນ:

ຄວາມທີ່ພາບ

var x = 500;             
var y = new Number(500);
// (x == y) ແມ່ນ true, ຍ້ອນ x ແລະ y ແມ່ນມີຄຸນຄ່າທີ່ສະເໝີ

ທົດລອງເອງ

ເມື່ອໃຊ້ === ຫຼັງຈາກການໃຊ້ຜູ້ບັນທຶກ ຈຳນວນທີ່ສະເໝີ ຈະປ່ຽນເປັນບໍ່ສະເໝີ, ຍ້ອນ: === ຜູ້ບັນທຶກຕ້ອງມີຮູບແບບ ແລະ ຄຸນຄ່າທີ່ສະເໝີ.

ຄວາມທີ່ພາບ

var x = 500;             
var y = new Number(500);
// (x === y) ແມ່ນ false, ຍ້ອນ x ແລະ y ແມ່ນມີຮູບແບບທີ່ແຕກຕ່າງກັນ

ທົດລອງເອງ

ແມ່ນບໍ່ດີ. ວັດຖຸບໍ່ສາມາດປະກອບກັນ:

ຄວາມທີ່ພາບ

var x = new Number(500);             
var y = new Number(500);
// (x == y) ແມ່ນ false, ຍ້ອນວ່າວັດຖຸບໍ່ສາມາດປະກອບກັນ

ທົດລອງເອງ

ວັດຖຸ JavaScript ບໍ່ສາມາດປະກອບກັນ.