Question

JavaScript 只有一种数值类型：number （数字），包括“整数”和带小数的十进制数。此处“整数”之所以加引号是因为和其他语言不同，JavaScript 没有真正意义上的整数，这也是它一直以来为人诟病的地方。这种情况在将来或许会有所改观，但目前只有数字类型。

JavaScript 中的“整数”就是没有小数的十进制数。所以 42.0 即等同于“整数”42 。

与大部分现代编程语言（包括几乎所有的脚本语言）一样，JavaScript 中的数字类型是基于 IEEE 754 标准来实现的，该标准通常也被称为“浮点数”。JavaScript 使用的是“双精度”格式（即 64 位二进制）。

网上的很多文章详细介绍了二进制浮点数在内存中的存储方式，以及不同方式各自的考量。要想正确使用 JavaScript 中的数字类型，并非一定要了解数位（bit）在内存中的存储方式，所以本书对此不多作介绍，有兴趣的读者可以参见 IEEE 754 的相关细节。

2.3.1　数字的语法

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

var a = 42;
var b = 42.3;

数字前面的 0 可以省略：

var a = 0.42;
var b = .42;

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

var a = 42.0;
var b = 42.;

42. 这种写法没问题，只是不常见，但从代码的可读性考虑，不建议这样写。

默认情况下大部分数字都以十进制显示，小数部分最后面的 0 被省略，如：

var a = 42.300;
var b = 42.0;

a; // 42.3
b; // 42

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

var a = 5E10;
a;          // 50000000000
a.toExponential();  // "5e+10"

var b = a * a;
b;          // 2.5e+21

var c = 1 / a;
c;          // 2e-11

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

var a = 42.59;

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

请注意，上例中的输出结果实际上是给定数字的字符串形式，如果指定的小数部分的显示位数多于实际位数就用 0 补齐。

toPrecision(..) 方法用来指定有效数位 的显示位数：

var a = 42.59;

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

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

// 无效语法：
42.toFixed( 3 );  // SyntaxError

// 下面的语法都有效：
(42).toFixed( 3 );  // "42.000"
0.42.toFixed( 3 );  // "0.420"
42..toFixed( 3 );   // "42.000"

42.tofixed(3) 是无效语法，因为 . 被视为常量 42. 的一部分（如前所述），所以没有 . 属性访问运算符来调用 tofixed 方法。

42..tofixed(3) 则没有问题，因为第一个 . 被视为 number 的一部分，第二个 . 是属性访问运算符。只是这样看着奇怪，实际情况中也很少见。在基本类型值上直接调用的方法并不多见，不过这并不代表不好 或不对 。

一些工具库扩展了 Number.prototype 的内置方法（参见第 3 章）以提供更多的数值操作，比如用 10..makeItRain() 方法来实现十秒钟金钱雨动画等效果。

下面的语法也是有效的（请注意其中的空格）：

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

然而对数字常量而言，这样的语法很容易引起误会，不建议使用。

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

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

数字常量还可以用其他格式来表示，如二进制、八进制和十六进制。

当前的 JavaScript 版本都支持这些格式：

0xf3; // 243的十六进制
0Xf3; // 同上

0363; // 243的八进制

从 ES6 开始，严格模式（strict mode）不再支持 0363 八进制格式（新格式如下）。0363 格式在非严格模式（non-strict mode）中仍然受支持，但是考虑到将来的兼容性，最好不要再使用（我们现在使用的应该是严格模式）。

ES6 支持以下新格式：

0o363;    // 243的八进制
0O363;    // 同上

0b11110011; // 243的二进制
0B11110011; // 同上

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

2.3.2　较小的数值

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

0.1 + 0.2 === 0.3; // false

从数学角度来说，上面的条件判断应该为 true ，可结果为什么是 false 呢？

简单来说，二进制浮点数中的 0.1 和 0.2 并不是十分精确，它们相加的结果并非刚好等于 0.3 ，而是一个比较接近的数字 0.30000000000000004 ，所以条件判断结果为 false 。

有人认为，JavaScript 应该采用一种可以精确呈现数字的实现方式。一直以来出现过很多替代方案，只是都没能成为标准，以后大概也不会。这个问题看似简单，实则不然，否则早就解决了。

问题是，如果一些数字无法做到完全精确，是否意味着数字类型毫无用处呢？答案当然是否定的。

在处理带有小数的数字时需要特别注意。很多（也许是绝大多数）程序只需要处理整数，最大不超过百万或者万亿，此时使用 JavaScript 的数字类型是绝对安全的。

那么应该怎样来判断 0.1 + 0.2 和 0.3 是否相等呢？

最常见的方法是设置一个误差范围值，通常称为“机器精度”（machine epsilon），对 JavaScript 的数字来说，这个值通常是 2^-52 (2.220446049250313e-16) 。

从 ES6 开始，该值定义在 Number.EPSILON 中，我们可以直接拿来用，也可以为 ES6 之前的版本写 polyfill：

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

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

function numbersCloseEnoughToEqual(n1,n2) {
  return Math.abs( n1 - n2 ) < Number.EPSILON;
}

var a = 0.1 + 0.2;
var b = 0.3;

numbersCloseEnoughToEqual( a, b );          // true
numbersCloseEnoughToEqual( 0.0000001, 0.0000002 );  // false

能够呈现的最大浮点数大约是 1.798e+308 （这是一个相当大的数字），它定义在 Number.MAX_VALUE 中。最小浮点数定义在 Number.MIN_VALUE 中，大约是 5e-324 ，它不是负数，但无限接近于 0 ！

2.3.3　整数的安全范围

数字的呈现方式决定了“整数”的安全值范围远远小于 Number.MAX_VALUE 。

能够被“安全”呈现的最大整数是 2^53 - 1 ，即 9007199254740991 ，在 ES6 中被定义为 Number.MAX_SAFE_INTEGER 。最小整数是 -9007199254740991 ，在 ES6 中被定义为 Number.MIN_SAFE_INTEGER 。

有时 JavaScript 程序需要处理一些比较大的数 字，如数据库中的 64 位 ID 等。由于 JavaScript 的数字类型无法精确呈现 64 位数值，所以必须将它们保存（转换）为字符串。

好在大数值操作并不常见（它们的比较操作可以通过字符串来实现）。如果确实需要对大数值进行数学运算，目前还是需要借助相关的工具库。将来 JavaScript 也许会加入对大数值的支持。

2.3.4　整数检测

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

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

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

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

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

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

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

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

2.3.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 （参见第 4 章），以便转换为符合数位运算符要求的 +0 值。