Question

JavaScript 数据类型中有几个特殊的值需要开发人员特别注意和小心使用。

2.4.1　不是值的值

undefined 类型只有一个值，即 undefined 。null 类型也只有一个值，即 null 。它们的名称既是类型也是值。

undefined 和 null 常被用来表示“空的”值或“不是值”的值。二者之间有一些细微的差别。例如：

· null 指空值（empty value）

· undefined 指没有值（missing value）

或者：

· undefined 指从未赋值

· null 指曾赋过值，但是目前没有值

null 是一个特殊关键字，不是标识符，我们不能将其当作变量来使用和赋值。然而 undefined 却是一个标识符，可以被当作变量来使用和赋值。

2.4.2　undefined

在非严格模式下，我们可以为全局标识符 undefined 赋值（这样的设计实在是欠考虑！）：

function foo() {
  undefined = 2; // 非常糟糕的做法！
}

foo();

function foo() {
  "use strict";
  undefined = 2; // TypeError!
}

foo();

在非严格和严格两种模式下，我们可以声明一个名为 undefined 的局部变量。再次强调最好不要这样做！

function foo() {
  "use strict";
  var undefined = 2;
  console.log( undefined ); // 2
}

foo();

永远不要重新定义 undefined 。

void 运算符

undefined 是一个内置标识符（除非被重新定义，见前面的介绍），它的值为 undefined ，通过 void 运算符即可得到该值。

表达式 void 没有返回值，因此返回结果是 undefined 。void 并不改变表达式的结果，只是让表达式不返回值：

var a = 42;

console.log( void a, a ); // undefined 42

按惯例我们用 void 0 来获得 undefined （这主要源自 C 语言，当然使用 void true 或其他 void 表达式也是可以的）。void 0 、void 1 和 undefined 之间并没有实质上的区别。

void 运算符在其他地方也能派上用场，比如不让表达式返回任何结果（即使其有副作用）。

例如：

function doSomething() {
  // 注： APP.ready 由程序自己定义
  if (!APP.ready) {
    // 稍后再试
    return void setTimeout( doSomething,100 );
  }

  var result;

  // 其他
  return result;
}

// 现在可以了吗？
if (doSomething()) {
  // 立即执行下一个任务
}

这里 setTimeout(..) 函数返回一个数值（计时器间隔的唯一标识符，用来取消计时），但是为了确保 if 语句不产生误报（false positive），我们要 void 掉它。

很多开发人员喜欢分开操作，效果都一样，只是没有使用 void 运算符：

if (!APP.ready) {
  // 稍后再试
  setTimeout( doSomething,100 );
  return;
}

总之，如果要将代码中的值（如表达式的返回值）设为 undefined ，就可以使用 void 。这种做法并不多见，但在某些情况下却很有用。

2.4.3　特殊的数字

数字类型中有几个特殊的值，下面将详细介绍。

1. 不是数字的数字

如果数学运算的操作数不是数字类型（或者无法解析为常规的十进制或十六进制数字），就无法返回一个有效的数字，这种情况下返回值为 NaN 。

NaN 意指“不是一个数字”（not a number），这个名字容易引起误会，后面将会提到。将它理解为“无效数值”“失败数值”或者“坏数值”可能更准确些。

例如：

var a = 2 / "foo";    // NaN

typeof a === "number";  // true

换句话说，“不是数字的数字”仍然是数字类型。这种说法可能有点绕。

NaN 是一个“警戒值”（sentinel value，有特殊用途的常规值），用于指出数字类型中的错误情况，即“执行数学运算没有成功，这是失败后返回的结果”。

有人也许认为如果要检查变量的值是否为 NaN ，可以直接和 NaN 进行比较，就像比较 null 和 undefined 那样。实则不然。

var a = 2 / "foo";

a == NaN;   // false
a === NaN;  // false

NaN 是一个特殊值，它和自身不相等，是唯一一个非自反（自反，reflexive，即 x === x 不成立）的值。而 NaN != NaN 为 true ，很奇怪吧？

既然我们无法对 NaN 进行比较（结果永远为 false ），那应该怎样来判断它呢？

var a = 2 / "foo";

isNaN( a ); // true

很简单，可以使用内建的全局工具函数 isNaN(..) 来判断一个值是否是 NaN 。

然而操作起来并非这么容易。isNaN(..) 有一个严重的缺陷，它的检查方式过于死板，就是“检查参数是否不是 NaN ，也不是数字”。但是这样做的结果并不太准确：

var a = 2 / "foo";
var b = "foo";

a; // NaN
b; "foo"

window.isNaN( a ); // true
window.isNaN( b ); // true——晕！

很明显 "foo" 不是一个数字 ，但是它也不是 NaN 。这个 bug 自 JavaScript 问世以来就一直存在，至今已超过 19 年。

从 ES6 开始我们可以使用工具函数 Number.isNaN(..) 。ES6 之前的浏览器的 polyfill 如下：

if (!Number.isNaN) {
  Number.isNaN = function(n) {
    return (
      typeof n === "number" &&
      window.isNaN( n )
    );
  };
}

var a = 2 / "foo";
var b = "foo";

Number.isNaN( a ); // true
Number.isNaN( b ); // false——好！

实际上还有一个更简单的方法，即利用 NaN 不等于自身这个特点。NaN 是 JavaScript 中唯一 一个不等于自身的值。

于是我们可以这样：

if (!Number.isNaN) {
  Number.isNaN = function(n) {
    return n !== n;
  };
}

很多 JavaScript 程序都可能存在 NaN 方面的问题，所以我们应该尽量使用 Number.isNaN(..) 这样可靠的方法，无论是系统内置还是 polyfill。

如果你仍在代码中使用 isNaN(..) ，那么你的程序迟早会出现 bug。

2. 无穷数

熟悉传统编译型语言（如 C）的开发人员可能都遇到过编译错误（compiler error）或者运行时错误（runtime exception），例如“除以 0”：

var a = 1 / 0;

然而在 JavaScript 中上例的结果为 Infinity （即 Number.POSITIVE_INfiNITY ）。同样：

var a = 1 / 0;  // Infinity
var b = -1 / 0; // -Infinity

如果除法运算中的一个操作数为负 数，则结果为 -Infinity （即 Number.NEGATIVE_INfiNITY ）。

JavaScript 使用有限数字表示法（finite numeric representation，即之前介绍过的 IEEE 754 浮点数），所以和纯粹的数学运算不同，JavaScript 的运算结果有可能溢出，此时结果为 Infinity 或者 -Infinity 。

例如：

var a = Number.MAX_VALUE;   // 1.7976931348623157e+308
a + a;            // Infinity
a + Math.pow( 2, 970 );   // Infinity
a + Math.pow( 2, 969 );   // 1.7976931348623157e+308

规范规定，如果数学运算（如加法）的结果超出处理范围，则由 IEEE 754 规范中的“就近取整”（round-to-nearest）模式来决定最后的结果。例如，相对于 Infinity ，Number.MAX_VALUE + Math.pow(2, 969) 与 Number.MAX_VALUE 更为接近，因此它被“向下取整”（round down）；而 Number.MAX_VALUE + Math.pow(2, 970) 与 Infinity 更为接近，所以它被“向上取整”（round up）。

这个问题想多了容易头疼，还是就此打住吧。

计算结果一旦溢出为无穷数 （infinity）就无法再得到有穷数。换句话说，就是你可以从有穷走向无穷，但无法从无穷回到有穷。

有人也许会问：“那么无穷除以无穷会得到什么结果呢？”我们的第一反应可能会是“1”或者“无穷”，可惜都不是。因为从数学运算和 JavaScript 语言的角度来说，Infinity/Infinity 是一个未定义操作，结果为 NaN 。

那么有穷正数除以 Infinity 呢？很简单，结果是 0 。有穷负数除以 Infinity 呢？这里留个悬念，后面将作介绍。

3. 零值

这部分内容对于习惯数学思维的读者可能会带来困惑，JavaScript 有一个常规的 0 （也叫作 +0 ）和一个 -0 。在解释为什么会有 -0 之前，我们先来看看 JavaScript 是如何来处理它的。

-0 除了可以用作常量以外，也可以是某些数学运算的返回值。例如：

var a = 0 / -3; // -0
var b = 0 * -3; // -0

加法和减法运算不会得到负零（negative zero）。

负零在开发调试控制台中通常显示为 -0 ，但在一些老版本的浏览器中仍然会显示为 0 。

根据规范，对负零进行字符串化会返回 "0" ：

var a = 0 / -3;

// 至少在某些浏览器的控制台中显示是正确的
a;              // -0

// 但是规范定义的返回结果是这样！
a.toString();         // "0"
a + "";           // "0"
String( a );        // "0"

// JSON也如此，很奇怪
JSON.stringify( a );   // "0"

有意思的是，如果反过来将其从字符串转换为数字，得到的结果是准确的：

+"-0";        // -0
Number( "-0" );   // -0
JSON.parse( "-0" ); // -0

JSON.stringify(-0) 返回 "0" ，而 JSON.parse("-0") 返回 -0 。

负零转换为字符串的结果令人费解，它的比较操作也是如此：

var a = 0;
var b = 0 / -3;

a == b;   // true
-0 == 0;  // true

a === b;  // true
-0 === 0;   // true

0 > -0;   // false
a > b;    // false

要区分 -0 和 0 ，不能仅仅依赖开发调试窗口的显示结果，还需要做一些特殊处理：

function isNegZero(n) {
  n = Number( n );
  return (n === 0) && (1 / n === -Infinity);
}

isNegZero( -0 );    // true
isNegZero( 0 / -3 );  // true
isNegZero( 0 );     // false

抛开学术上的繁枝褥节不论，我们为什么需要负零呢？

有些应用程序中的数据需要以级数形式来表示（比如动画帧的移动速度），数字的符号位（sign）用来代表其他信息（比如移动的方向）。此时如果一个值为 0 的变量失去了它的符号位，它的方向信息就会丢失。所以保留 0 值的符号位可以防止这类情况发生。

2.4.4　特殊等式

如前所述，NaN 和 -0 在相等比较时的表现有些特别。由于 NaN 和自身不相等，所以必须使用 ES6 中的 Number.isNaN(..) （或者 polyfill）。而 -0 等于 0 （对于 === 也是如此，参见第 4 章），因此我们必须使用 isNegZero(..) 这样的工具函数。

ES6 中新加入了一个工具方法 Object.is(..) 来判断两个值是否绝对相等，可以用来处理上述所有的特殊情况：

var a = 2 / "foo";
var b = -3 * 0;

Object.is( a, NaN );  // true
Object.is( b, -0 );   // true

Object.is( b, 0 );    // false

对于 ES6 之前的版本，Object.is(..) 有一个简单的 polyfill：

if (!Object.is) {
  Object.is = function(v1, v2) {
    // 判断是否是-0
    if (v1 === 0 && v2 === 0) {
      return 1 / v1 === 1 / v2;
    }
    // 判断是否是NaN
    if (v1 !== v1) {
      return v2 !== v2;
    }
    // 其他情况
    return v1 === v2;
  };
}

能使用 == 和 === （参见第 4 章）时就尽量不要使用 Object.is(..) ，因为前者效率更高、更为通用。Object.is(..) 主要用来处理那些特殊的相等比较。