JavaScript只有一种数值类型，number（数字）包括“整数”和带小数的十进制数。此处“整数”之所以加引号是因为和其他语言不同，JavaScript没有真正意义上的整数。
JavaScript 中的“整数”就是没有小数的十进制数。所以 42.0 即等同于“整数”42。
与大部分现代编程语言(包括几乎所有的脚本语言)一样，JavaScript 中的数字类型是基 于 IEEE 754 标准来实现的，该标准通常也被称为“浮点数”。JavaScript 使用的是“双精 度”格式(即 64 位二进制)。

数字的语法

JavaScript 中的数字常量一般用十进制表示。例如:

  1. var a = 42;
  2. var b = 42.3;

数字前面的 0 可以省略: 

  1. var a = 0.42;
  2. var b = .42;

小数点后小数部分最后面的 0 也可以省略:

  1. var a = 42.0;
  2. var b = 42.;

特别大和特别小的数字默认用指数格式显示，与 toExponential() 函数的输出结果相同。 例如:

  1. var a = 5E10;
  2. a;                  // 50000000000
  3. a.toExponential();  // "5e+10"
  4. var b = a * a;
  5. b;                  // 2.5e+21
  6. var c = 1 / a;
  7. c;                  // 2e-11

由于数字值可以使用 Number 对象进行封装(参见第 3 章)，因此数字值可以调用 Number.prototype 中的方法，例如:
tofixed(..) 方法可指定小数部分的显示位数:

  1. var a = 42.59;
  2. a.toFixed( 0 ); // "43"
  3. a.toFixed( 1 ); // "42.6"
  4. a.toFixed( 2 ); // "42.59"
  5. a.toFixed( 3 ); // "42.590"
  6. a.toFixed( 4 ); // "42.5900"

注意，上例中的输出结果实际上是给定数字的字符串形式，如果指定的小数部分的显示位数多于实际位数就用 0 补齐。
toPrecision(..) 方法用来指定有效数位的显示位数:

  1. var a = 42.59;
  2. a.toPrecision( 1 ); // "4e+1"
  3. a.toPrecision( 2 ); // "43"
  4. a.toPrecision( 3 ); // "42.6"
  5. a.toPrecision( 4 ); // "42.59"
  6. a.toPrecision( 5 ); // "42.590"
  7. a.toPrecision( 6 ); // "42.5900"

上面的方法不仅适用于数字变量，也适用于数字常量。不过对于 . 运算符需要给予特别注 意，因为它是一个有效的数字字符，会被优先识别为数字常量的一部分，然后才是对象属性访问运算符。

  1. // 无效语法:
  2. 42.toFixed( 3 ); // SyntaxError
  3. // 下面的语法都有效: 
  4. (42).toFixed( 3 ); // "42.000" 
  5. 0.42.toFixed( 3 ); // "0.420" 
  6. 42..toFixed( 3 ); // "42.000"

42.tofixed(3) 是无效语法，因为 . 被视为常量 42. 的一部分(如前所述)，所以没有 . 属性访问运算符来调用 tofixed 方法。
42..tofixed(3) 则没有问题，因为第一个 . 被视为 number 的一部分，第二个 . 是属性访问运算符。
下面的语法也是有效的(请注意其中的空格):

  1. 42 .toFixed(3); // "42.000"

还可以用指数形式来表示较大的数字，如:

  1. var onethousand = 1E3; // 即 1 * 10^3 
  2. var onemilliononehundredthousand = 1.1E6; // 即 1.1 * 10^6

数字常量还可以用其他格式来表示，如二进制、八进制和十六进制。
当前的 JavaScript 版本都支持这些格式:

  1. 0xf3; // 243的十六进制 
  2. 0Xf3; // 同上
  3. 0363; // 243的八进制

考虑到代码的易读性，不推荐使用 0O363 格式，因为 0 和大写字母 O 在一起容易混淆。建议尽量使用小写的 0x、 0b 和 0o。

较小的数值

二进制浮点数最大的问题（不仅 JavaScript，所有遵循 IEEE 754 规范的语言都是如此），会出现如下情况：

  1. 0.1 + 0.2 === 0.3; // false

二进制浮点数中的 0.1 和 0.2 并不是十分精确，它们相加的结果并非刚好等于 0.3，而是一个比较接近的数字 0.30000000000000004，所以条件判断结果为 false。
在处理带有小数的数字时需要特别注意。很多(也许是绝大多数)程序只需要处理整数， 最大不超过百万或者万亿，此时使用 JavaScript 的数字类型是绝对安全的。
那么应该怎样来判断 0.1 + 0.2 和 0.3 是否相等呢?
最常见的方法是设置一个误差范围值，通常称为“机器精度”(machine epsilon)，对JavaScript 的数字来说，这个值通常是 2^-52 (2.220446049250313e-16)。
从 ES6 开始，该值定义在 Number.EPSILON 中，我们可以直接拿来用，也可以为 ES6 之前的版本写 polyfill:

  1. if (!Number.EPSILON) {
  2.     Number.EPSILON = Math.pow(2,-52);
  3. }

可以使用 Number.EPSILON 来比较两个数字是否相等（在指定的误差范围内）：

  1. function numbersCloseEnoughToEqual(n1,n2) {
  2.   return Math.abs( n1 - n2 ) < Number.EPSILON;
  3. }
  4. var a = 0.1 + 0.2;
  5. var b = 0.3;
  6. numbersCloseEnoughToEqual( a, b );    // true
  7. numbersCloseEnoughToEqual( 0.0000001, 0.0000002 );  // false

能够呈现的最大浮点数大约是 1.798e+308(这是一个相当大的数字)，它定义在中。最小浮点数定义在 能够呈现的最大浮点数大约是 1.798e+308(这是一个相当大的数字)，它定义中 中。最小浮点数定义在 。最小浮点数定义在 ，它不是负数，但无限接近于 0 !

整数的安全范围

数字的呈现方式决定了“整数”的安全值范围远远小于Number.MAX_VALUE
能够被“安全”呈现的最大整数是2^53 - 1，即9007199254740991，在ES6中被定义为 Number.MAX_SAFE_INTEGER。 最 小 整 数 是 -9007199254740991， 在 ES6 中 被 定 义 为 Number. MIN_SAFE_INTEGER。
有时候需要处理一些比较大的数字，如数据库中的 64 位 ID 等。由于js的数字类型无法精确呈现 64 位数值，所以必须将它们保存(转换)为字符串。
大数值操作并不常见(它们的比较操作可以通过字符串来实现)。如果确实需要对大数值进行数学运算，目前还是需要借助相关的工具库。将来js也许会加入对大数值的支持。

整数检测

要检测一个值是否是整数，可以使用 ES6 中的Number.isInteger(..) 方法: 

  1. Number.isInteger( 42 );     // true
  2. Number.isInteger( 42.000 ); // true
  3. Number.isInteger( 42.3 );   // false

也可以为 ES6 之前的版本 polyfill Number.isInteger(..) 方法:

  1. if (!Number.isInteger) {
  2.   Number.isInteger = function(num) {
  3.     return typeof num == "number" && num % 1 == 0;
  4.   };
  5. }

检测一个值是否是安全的整数，可以使用 ES6 中的Number.isSafeInteger(..)方法:

  1. Number.isSafeInteger( Number.MAX_SAFE_INTEGER );    // true
  2. Number.isSafeInteger( Math.pow( 2, 53 ) );    // false
  3. Number.isSafeInteger( Math.pow( 2, 53 ) - 1 );    // true

可以为 ES6 之前的版本 polyfill Number.isSafeInteger(..) 方法:

  1. if (!Number.isSafeInteger) {
  2.   Number.isSafeInteger = function(num) {
  3.     return Number.isInteger( num ) && Math.abs( num ) <= Number.MAX_SAFE_INTEGER;
  4.     }; 
  5. }

32 位有符号整数

虽然整数最大能够达到 53 位，但是有些数字操作(如数位操作)只适用于 32 位数字， 所以这些操作中数字的安全范围就要小很多，变成从 Math.pow(-2,31)(-2147483648， 约-21 亿)到 Math.pow(2,31)-1(2147483647，约 21 亿)。
a | 0可以将变量a中的数值转换为32位有符号整数，因为数位运算符|只适用于32位 整数(它只关心 32 位以内的值，其他的数位将被忽略)。因此与 0 进行操作即可截取 a 中 的 32 位数位。
注：某些特殊的值并不是 32 位安全范围的，如 NaN和 Infinity，此时会对它们执行虚拟操作(abstract operation)ToInt32，以便转换为符合数位运算符要求的 +0 值。