4、特殊数值

不是值的值

undefined 类型只有一个值，即 undefined。null 类型也只有一个值，即 null。它们的名称既是类型也是值。
undefined 和 null 常被用来表示“空的”值或“不是值”的值。二者之间有一些细微的差别。例如:
• null 指空值(empty value)
• undefined 指没有值(missing value)
或者:
• undefined 指从未赋值
• null 指曾赋过值，但是目前没有值
null 是一个特殊关键字，不是标识符，不能将其当作变量来使用和赋值。然而undefined 却是一个标识符，可以被当作变量来使用和赋值。

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();

一般情况下用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。这种做法并不多见，但在某些情况下却很有用。

特殊的数字

不是数字的数字

如果数学运算的操作数不是数字类型(或者无法解析为常规的十进制或十六进制数字)， 就无法返回一个有效的数字，这种情况下返回值为 NaN。
NaN 意指“不是一个数字”(not a number)。将它理解为“无效数值”“失败数值”或者“坏数值”可能更准确。
例如:

var a = 2 / "foo";      // NaN
typeof a === "number";  // true

“不是数字的数字”仍然是数字类型。
NaN 是一个“警戒值”(sentinel value，有特殊用途的常规值)，用于指出数字类型中的错误情况，即“执行数学运算没有成功，这是失败后返回的结果”。
NaN是一个特殊值，它和自身不相等，是唯一一个非自反(自反，reflexive，即x === x不成立)的值。而 NaN != NaN 为 true。
那应该怎样来判断NaN呢？

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

从 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;
  };
}

很多 js 程序都可能存在 NaN 方面的问题，所以我们应该尽量使用 Number.isNaN(..) 这样可靠的方法，无论是系统内置还是 polyfill。
如果你仍在代码中使用 isNaN(..)，那么你的程序迟早会出现 bug，应该尽快更换掉。

无穷数

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

var a = 1 / 0;

然而在 js 中上例的结果为 Infinity(即 Number.POSITIVE_INfiNITY)。同样:

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

如果除法运算中的一个操作数为负数，则结果为 -Infinity(即 Number.NEGATIVE_ INf iNITY)。
js 使用有限数字表示法(finite numeric representation)，所以和纯粹的数学运算不同，js 的运算结果有可能溢出，此时结果为 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” 或者“无穷”，可惜都不是。因为从数学运算和 js 语言的角度来说，Infinity/ Infinity 是一个未定义操作，结果为 NaN。
那么有穷正数除以 Infinity 呢?很简单，结果是 0。有穷负数除以 Infinity 为-0。

零值

js 有一个常规的 0(也叫作 +0)和一个 -0。
-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 值的符号位可以防止这类情况发生。

特殊等式

NaN 和 -0 在相等比较时的表现有些特别。由于 NaN 和自身不相等，所以必须使 用 ES6 中的Number.isNaN(..)(或者 polyfill)。而 -0 等于 0(对于 === 也是如此)，因此我们必须使用 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;
  };
}

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