官方中文版原文链接

感谢社区中各位的大力支持，译者再次奉上一点点福利：阿里云产品券，享受所有官网优惠，并抽取幸运大奖：点击这里领取

array，string，和number是任何程序的最基础构建块，但是JavaScript在这些类型上有一些要么使你惊喜要么使你惊讶的独特性质。

让我们来看几种JS内建的值类型，并探讨一下我们如何才能更加全面地理解并正确地利用它们的行为。

Array

和其他强制类型的语言相比，JavaScript的array只是值的容器，而这些值可以是任何类型：string或者number或者object，甚至是另一个array（这也是你得到多维数组的方法）。

var a = [ 1, "2", [3] ];

a.length;       // 3
a[0] === 1;     // true
a[2][0] === 3;  // true

你不需要预先指定array的大小，你可以仅声明它们并加入你觉得合适的值：

var a = [ ];

a.length;   // 0

a[0] = 1;
a[1] = "2";
a[2] = [ 3 ];

a.length;   // 3

警告： 在一个array值上使用delete将会从这个array上移除一个值槽，但就算你移除了最后一个元素，它也 不会 更新length属性，所以多加小心！我们会在第五章讨论delete操作符的更多细节。

要小心创建“稀散”的array（留下或创建空的/丢失的值槽）：

var a = [ ];

a[0] = 1;
// 这里没有设置值槽`a[1]`
a[2] = [ 3 ];

a[1];       // undefined

a.length;   // 3

虽然这可以工作，但你留下的“空值槽”可能会导致一些令人困惑的行为。虽然这样的值槽看起来拥有undefined值，但是它不会像被明确设置（a[1] = undefined）的值槽那样动作。更多信息可以参见第三章的“Array”。

array是被数字索引的（正如你认为的那样），但微妙的是它们也是对象，可以在它们上面添加string键/属性（但是这些属性不会计算在array的length中）：

var a = [ ];

a[0] = 1;
a["foobar"] = 2;

a.length;       // 1
a["foobar"];    // 2
a.foobar;       // 2

然而，一个需要小心的坑是，如果一个可以被强制转换为10进制number的string值被用作键的话，它会认为你想使用number索引而不是一个string键！

var a = [ ];

a["13"] = 42;

a.length; // 14

一般来说，向array添加string键/属性不是一个好主意。最好使用object来持有键/属性形式的值，而将array专用于严格地数字索引的值。

类Array

偶尔你需要将一个类array值（一个数字索引的值的集合）转换为一个真正的array，通常你可以对这些值的集合调用数组的工具函数（比如indexOf(..)，concat(..)，forEach(..)等等）。

举个例子，各种DOM查询操作会返回一个DOM元素的列表，对于我们转换的目的来说，这些列表不是真正的array但是也足够类似array。另一个常见的例子是，函数为了像列表一样访问它的参数值，而暴露了arugumens对象（类array，在ES6中被废弃了）。

一个进行这种转换的很常见的方法是对这个值借用slice(..)工具：

function foo() {
    var arr = Array.prototype.slice.call( arguments );
    arr.push( "bam" );
    console.log( arr );
}

foo( "bar", "baz" ); // ["bar","baz","bam"]

如果slice()没有用其他额外的参数调用，就像上面的代码段那样，它的参数的默认值会使它具有复制这个array（或者，在这个例子中，是一个类array）的效果。

在ES6中，还有一种称为Array.from(..)的内建工具可以执行相同的任务：

...
var arr = Array.from( arguments );
...

注意： Array.from(..)拥有几种其他强大的能力，我们将在本系列的 ES6与未来 中涵盖它的细节。

String

一个很常见的想法是，string实质上只是字符的array。虽然内部的实现可能是也可能不是array，但重要的是要理解JavaScript的string与字符的array确实不一样。它们的相似性几乎只是表面上的。

举个例子，让我们考虑这两个值：

var a = "foo";
var b = ["f","o","o"];

String确实与array有很肤浅的相似性 -- 也就是上面说的，类array -- 举例来说，它们都有一个length属性，一个indexOf(..)方法（在ES5中仅有array版本），和一个concat(..)方法：

a.length;                           // 3
b.length;                           // 3

a.indexOf( "o" );                   // 1
b.indexOf( "o" );                   // 1

var c = a.concat( "bar" );          // "foobar"
var d = b.concat( ["b","a","r"] );  // ["f","o","o","b","a","r"]

a === c;                            // false
b === d;                            // false

a;                                  // "foo"
b;                                  // ["f","o","o"]

那么，它们基本上都仅仅是“字符的数组”，对吧？ 不确切：

a[1] = "O";
b[1] = "O";

a; // "foo"
b; // ["f","O","o"]

JavaScript的string是不可变的，而array是相当可变的。另外，在JavaScript中用位置访问字符的a[1]形式不总是广泛合法的。老版本的IE就不允许这种语法（但是它们现在允许了）。相反，正确的 方式是a.charAt(1)。

string不可变性的进一步的后果是，string上没有一个方法是可以原地修改它的内容的，而是创建并返回一个新的string。与之相对的是，许多改变array内容的方法实际上 是 原地修改的。

c = a.toUpperCase();
a === c;    // false
a;          // "foo"
c;          // "FOO"

b.push( "!" );
b;          // ["f","O","o","!"]

另外，许多array方法在处理string时非常有用，虽然这些方法不属于string，但我们可以对我们的string“借用”非变化的array方法：

a.join;         // undefined
a.map;          // undefined

var c = Array.prototype.join.call( a, "-" );
var d = Array.prototype.map.call( a, function(v){
    return v.toUpperCase() + ".";
} ).join( "" );

c;              // "f-o-o"
d;              // "F.O.O."

让我们来看另一个例子：翻转一个string（顺带一提，这是一个JavaScript面试中常见的细小问题！）。array拥有一个原地的reverse()修改器方法，但是string没有：

a.reverse;      // undefined

b.reverse();    // ["!","o","O","f"]
b;              // ["!","o","O","f"]

不幸的是，这种“借用”array修改器不起作用，因为string是不可变的，因此它不能被原地修改：

Array.prototype.reverse.call( a );
// 仍然返回一个“foo”的String对象包装器（见第三章） :(

另一种迂回的做法（也是黑科技）是，将string转换为一个array，实施我们想做的操作，然后将它转回string。

var c = a
    // 将`a`切分成一个字符的数组
    .split( "" )
    // 翻转字符的数组
    .reverse()
    // 将字符的数组连接回一个字符串
    .join( "" );

c; // "oof"

如果你觉得这很难看，没错。不管怎样，对于简单的string它 好用，所以如果你需要某些快速但是“脏”的东西，像这样的方式经常能满足你。

警告： 小心！这种方法对含有复杂（unicode）字符（星号，多字节字符等）的string 不起作用。你需要支持unicode的更精巧的工具库来准确地处理这种操作。在这个问题上可以咨询Mathias Bynens的作品：Esrever（https://github.com/mathiasbynens/esrever）。

另外一种考虑这个问题的方式是：如果你更经常地将你的“string”基本上作为 字符的数组 来执行一些任务的话，也许就将它们作为array而不是作为string存储更好。你可能会因此省去很多每次都将string转换为array的麻烦。无论何时你确实需要string的表现形式的话，你总是可以调用 字符的 array的join("")方法。

Number

JavaScript只有一种数字类型：number。这种类型包含“整数”值和小数值。我说“整数”时加了引号，因为JS的一个长久以来为人诟病的原因是，和其他语言不同，JS没有真正的整数。这可能在未来某个时候会改变，但是目前，我们只有number可用。

所以，在JS中，一个“整数”只是一个没有小数部分的小数值。也就是说，42.0和42一样是“整数”。

像大多数现代计算机语言，以及几乎所有的脚本语言一样，JavaScript的number的实现基于“IEEE 754”标准，通常被称为“浮点”。JavaScript明确地使用了这个标准的“双精度”（也就是“64位二进制”）格式。

在网络上有许多了不起的文章都在介绍二进制浮点数如何在内存中存储的细节，以及选择这些做法的意义。因为对于理解如何在JS中正确使用number来说，理解内存中的位模式不是必须的，所以我们将这个话题作为练习留给那些想要进一步挖掘IEEE 754的细节的读者。

数字的语法

在JavaScript中字面数字一般用10进制小数表达。例如：

var a = 42;
var b = 42.3;

小数的整数部分如果是0，是可选的：

var a = 0.42;
var b = .42;

相似地，一个小数在.之后的小数部分如果是0，是可选的：

var a = 42.0;
var b = 42.;

警告： 42.是极不常见的，如果你正在努力避免别人阅读你的代码时感到困惑，它可能不是一个好主意。但不管怎样，它是合法的。

默认情况下，大多数number将会以10进制小数的形式输出，并去掉末尾小数部分的0。所以：

var a = 42.300;
var b = 42.0;

a; // 42.3
b; // 42

非常大或非常小的number将默认以指数形式输出，与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值可以用Number对象包装器封装（见第三章），number值可以访问内建在Number.prototype上的方法（见第三章）。举个例子，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"

要注意的是，它的输出实际上是一个number的string表现形式，而且如果你指定的位数多于值持有的小数位数时，会在右侧补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"

你不必非得使用持有这个值的变量来访问这些方法；你可以直接在number的字面上访问这些方法。但你不得不小心.操作符。因为.是一个合法数字字符，如果可能的话，它会首先被翻译为number字面的一部分，而不是被翻译为属性访问操作符。

// 不合法的语法：
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的一部分，而第二个.是属性操作符。但它可能看起来很古怪，而且确实在实际的JavaScript代码中很少会看到这样的东西。实际上，在任何基本类型上直接访问方法是十分不常见的。但是不常见并不意味着 坏 或者 错。

注意： 有一些库扩展了内建的Number.prototype（见第三章），使用number或在number上提供了额外的操作，所以在这些情况下，像使用10..makeItRain()来设定一个10秒钟的下钱雨的动画，或者其他诸如此类的傻事是完全合法的。

在技术上讲，这也是合法的（注意那个空格）：

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

但是，尤其是对number字面量来说，这是特别使人糊涂的代码风格，而且除了使其他开发者（和未来的你）糊涂以外没有任何用处。避免它。

number还可以使用科学计数法的形式指定，这在表示很大的number时很常见，比如：

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

number字面量还可以使用其他进制表达，比如二进制，八进制，和十六进制。

这些格式是可以在当前版本的JavaScript中使用的：

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

0363; // 八进制的: 243

注意： 从ES6 + strict模式开始，不再允许0363这样的的八进制形式（新的形式参见后面的讨论）。0363在非strict模式下依然是允许的，但是不管怎样你应当停止使用它，来拥抱未来（而且因为你现在应当在使用strict模式了！）。

至于ES6，下面的新形式也是合法的：

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

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

请为你的开发者同胞们做件好事：绝不要使用0O363形式。把0放在大写的O旁边就是在制造困惑。保持使用小写的谓词0x，0b，和0o。

小数值

使用二进制浮点数的最出名（臭名昭著）的副作用是（记住，这是对 所有 使用IEEE 754的语言都成立的——不是许多人认为/假装 仅 在JavaScript中存在的问题）：

0.1 + 0.2 === 0.3; // false

从数学的意义上，我们知道这个语句应当为true。为什么它是false？

简单地说，0.1和0.2的二进制表示形式是不精确的，所以它们相加时，结果不是精确地0.3。而是 非常 接近的值：0.30000000000000004，但是如果你的比较失败了，“接近”是无关紧要的。

注意： JavaScript应当切换到可以精确表达所有值的一个不同的number实现吗？有些人认为应该。多年以来有许多选项出现过。但是没有一个被采纳，而且也许永远也不会。它看起来就像挥挥手然后说“已经改好那个bug了!”那么简单，但根本不是那么回事儿。如果真有这么简单，它绝对就在很久以前被改掉了。

现在的问题是，如果一些number不能被 信任 为精确的，这不是意味着我们根本不能使用number吗？ 当然不是。

在一些应用程序中你需要多加小心，特别是在对付小数的时候。还有许多（也许是大多数？）应用程序只处理整数，而且，最大只处理到几百万到几万亿。这些应用程序使用JS中的数字操作是，而且将总是，非常安全 的。

要是我们 确实 需要比较两个number，就像0.1 + 0.2与0.3，而且知道这个简单的相等测试将会失败呢？

可以接受的最常见的做法是使用一个很小的“错误舍入”值作为比较的 容差。这个很小的值经常被称为“机械极小值（machine epsilon）”，对于JavaScript来说这种number通常为2^-52（2.220446049250313e-16）。

在ES6中，使用这个容差值预定义了Number.EPSILON，所以你将会想要使用它，你也可以在前ES6中安全地填补这个定义：

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

我们可以使用这个Number.EPSILON来比较两个number的“等价性”（带有错误舍入的容差）：

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！

安全整数范围

由于number的表示方式，对完全是number的“整数”而言有一个“安全”的值的范围，而且它要比Number.MAX_VALUE小得多。

可以“安全地”被表示的最大整数（也就是说，可以保证被表示的值是实际可以无误地表示的）是2^53 - 1，也就是9007199254740991，如果你插入一些数字分隔符，可以看到它刚好超过9万亿。所以对于number能表示的上限来说它确实是够TM大的。

在ES6中这个值实际上是自动预定义的，它是Number.MAX_SAFE_INTEGER。意料之中的是，还有一个最小值，-9007199254740991，它在ES6中定义为Number.MIN_SAFE_INTEGER。

JS程序面临处理这样大的数字的主要情况是，处理数据库中的64位ID等等。64位数字不能使用number类型准确表达，所以在JavaScript中必须使用string表现形式存储（和传递）。

谢天谢地，在这样的大IDnumber值上的数字操作（除了比较，它使用string也没问题）并不很常见。但是如果你 确实 需要在这些非常大的值上实施数学操作，目前来讲你需要使用一个 大数字 工具。在未来版本的JavaScript中，大数字也许会得到官方支持。

测试整数

测试一个值是否是整数，你可以使用ES6定义的Number.isInteger(..)：

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

可以为前ES6填补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浏览器填补Number.isSafeInteger(..)：

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

32位（有符号）整数

虽然整数可以安全地最大达到约9万亿（53比特），但有一些数字操作（比如位操作符）是仅仅为32位number定义的，所以对于被这样使用的number来说，“安全范围”一定会小得多。

这个范围是从Math.pow(-2,31)（-2147483648，大约-21亿）到Math.pow(2,31)-1（2147483647，大约+21亿）。

要强制a中的number值是32位有符号整数，使用a | 0。这可以工作是因为|位操作符仅仅对32位值起作用（意味着它可以只关注32位，而其他的位将被丢掉）。而且，和0进行“或”的位操作实质上是什么也不做。

注意： 特定的特殊值（我们将在下一节讨论），比如NaN和Infinity不是“32位安全”的，当这些值被传入位操作符时将会通过一个抽象操作ToInt32（见第四章）并为了位操作而简单地变成+0值。

特殊值

在各种类型中散布着一些特殊值，需要 警惕 的JS开发者小心，并正确使用。

不是值的值

对于undefined类型来说，有且仅有一个值：undefined。对于null类型来说，有且仅有一个值：null。所以对它们而言，这些文字既是它们的类型也是它们的值。

undefined和null作为“空”值或者“没有”值，经常被认为是可以互换的。另一些开发者偏好于使用微妙的区别将它们区分开。举例来讲：

• null是一个空值
• undefined是一个丢失的值

或者：

• undefined还没有值
• null曾经有过值但现在没有

不管你选择如何“定义”和使用这两个值，null是一个特殊的关键字，不是一个标识符，因此你不能将它作为一个变量对待来给它赋值（为什么你要给它赋值呢？！）。然而，undefined（不幸地）是 一个标识符。噢。

Undefined

在非strict模式下，给在全局上提供的undefined标识符赋一个值实际上是可能的（虽然这是一个非常不好的做法！）：

function foo() {
    undefined = 2; // 非常差劲儿的主意！
}

foo();

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

foo();

但是，在非strict模式和strict模式下，你可以创建一个名叫undefined局部变量。但这又是一个很差劲儿的主意！

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

foo();

朋友永远不让朋友覆盖undefined。

void操作符

虽然undefined是一个持有内建的值undefined的内建标识符（除非被修改——见上面的讨论！），另一个得到这个值的方法是void操作符。

表达式void __会“躲开”任何值，所以这个表达式的结果总是值undefined。它不会修改任何已经存在的值；只是确保不会有值从操作符表达式中返回来。

var a = 42;

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

从惯例上讲（大约是从C语言编程中发展而来），要通过使用void来独立表现值undefined，你可以使用void 0（虽然，很明显，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(..)函数返回一个数字值（时间间隔定时器的唯一标识符，用于取消它自己），但是我们想void它，这样我们函数的返回值不会在if语句上给出一个成立的误报。

许多开发者宁愿将这些动作分开，这样的效用相同但不使用void操作符：

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

一般来说，如果有那么一个地方，有一个值存在（来自某个表达式）而你发现这个值如果是undefined才有用，就使用void操作符。这可能在你的程序中不是非常常见，但如果在一些稀有的情况下你需要它，它就十分有用。

特殊的数字

number类型包含几种特殊值。我们将会仔细考察每一种。

不是数字的数字

如果你不使用同为number（或者可以被翻译为10进制或16进制的普通number的值）的两个操作数进行任何算数操作，那么操作的结果将失败而产生一个不合法的number，在这种情况下你将得到NaN值。

NaN在字面上代表“不是一个number(Not a Number)”，但是正如我们即将看到的，这种文字描述十分失败而且容易误导人。将NaN考虑为“不合法数字”，“失败的数字”，甚至是“坏掉的数字”都要比“不是一个数字”准确得多。

举例来说：

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

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

换句话说：“‘不是一个数字’的类型是‘数字’”！为这使人糊涂的名字和语义欢呼吧。

NaN是一种“哨兵值”（一个被赋予了特殊意义的普通的值），它代表number集合内的一种特殊的错误情况。这种错误情况实质上是：“我试着进行数学操作但是失败了，而这就是失败的number结果。”

那么，如果你有一个值存在某个变量中，而且你想要测试它是否是这个特殊的失败数字NaN，你也许认为你可以直接将它与NaN本身比较，就像你能对其它的值做的那样，比如null和undefined。不是这样。

var a = 2 / "foo";

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

NaN是一个非常特殊的值，它从来不会等于另一个NaN值（也就是，它从来不等于它自己）。实际上，它是唯一一个不具有反射性的值（没有恒等性x === x）。所以，NaN !== NaN。有点奇怪，对吧？

那么，如果不能与NaN进行比较（因为这种比较将总是失败），我们该如何测试它呢？

var a = 2 / "foo";

isNaN( a ); // true

够简单的吧？我们使用称为isNaN(..)的内建全局工具，它告诉我们这个值是否是NaN。问题解决了！

别高兴得太早。

isNaN(..)工具有一个重大缺陷。它似乎过于按照字面的意思（“不是一个数字”）去理解NaN的含义了——它的工作基本上是：“测试这个传进来的东西是否不是一个number或者是一个number”。但这不是十分准确。

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

a; // NaN
b; // "foo"

window.isNaN( a ); // true
window.isNaN( b ); // true -- 噢!

很明显，"foo"根本 不是一个number，但它也绝不是一个NaN值！这个bug从最开始的时候就存在于JS中了（存在超过19年的坑）。

在ES6中，终于提供了一个替代它的工具：Number.isNaN(..)。有一个简单的填补，可以让你即使是在前ES6的浏览器中安全地检查NaN值：

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与它自己不相等这个特殊的事实，我们可以更简单地实现Number.isNaN(..)的填补。在整个语言中NaN是唯一一个这样的值；其他的值都总是 等于它自己。

所以：

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

怪吧？但是好用！

不管有意还是无意，在许多真实世界的JS程序中NaN可能是一个现实的问题。使用Number.isNaN(..)（或者它的填补）这样的可靠测试来正确地识别它们是一个非常好的主意。

如果你正在程序中仅使用isNaN(..)，悲惨的现实是你的程序 有bug，即便是你还没有被它咬到！

无穷

来自于像C这样的传统编译型语言的开发者，可能习惯于看到编译器错误或者是运行时异常，比如对这样一个操作给出的“除数为0”：

var a = 1 / 0;

然而在JS中，这个操作是明确定义的，而且它的结果是值Infinity（也就是Number.POSITIVE_INFINITY）。意料之中的是：

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

如你所见，-Infinity（也就是Number.NEGATIVE_INFINITY）是从任一个被除数为负（不是两个都是负数！）的除0操作得来的。

JS使用有限的数字表现形式（IEEE 754 浮点，我们早先讨论过），所以和单纯的数学相比，它看起来甚至在做加法和减法这样的操作时都有可能溢出，这样的情况下你将会得到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“就近舍入”模式将会指明结果应该是什么。所以粗略的意义上，Number.MAX_VALUE + Math.pow( 2, 969 )比起Infinity更接近于Number.MAX_VALUE，所以它“向下舍入”，而Number.MAX_VALUE + Math.pow( 2, 970 )距离Infinity更近，所以它“向上舍入”。

如果你对此考虑的太多，它会使你头疼的。所以别想了。我是认真的，停！

一旦你溢出了任意一个 无限值，那么，就没有回头路了。换句最有诗意的话说，你可以从有限迈向无限，但不能从无限回归有限。

“无限除以无限等于什么”，这简直是一个哲学问题。我们幼稚的大脑可能会说“1”或“无限”。事实表明它们都不对。在数学上和在JavaScript中，Infinity / Infinity不是一个有定义的操作。在JS中，它的结果为NaN。

一个有限的正number除以Infinity呢？简单！0。那一个有限的负number处理Infinity呢？接着往下读！

零

虽然这可能使有数学头脑的读者困惑，JavaScript拥有普通的零0（也称为正零+0） 和 一个负零-0。在我们讲解为什么-0存在之前，我们应该考察JS如何处理它，因为它可能十分令人困惑。

除了使用字面量-0指定，负的零还可以从特定的数学操作中得出。比如：

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

加法和减法无法得出负零。

在开发者控制台中考察一个负的零，经常显示为-0，然而直到最近这才是一个常见情况，所以一些你可能遇到的老版本浏览器也许依然将它报告为0。

但是根据语言规范，如果你试着将一个负零转换为字符串，它将总会被报告为"0"。

var a = 0 / -3;

// 至少（有些浏览器）控制台是对的
a;                          // -0

// 但是语言规范坚持要向你撒谎！
a.toString();               // "0"
a + "";                     // "0"
String( a );                // "0"

// 奇怪的是，就连JSON也加入了骗局之中
JSON.stringify( a );        // "0"

有趣的是，反向操作（从string到number）不会撒谎：

+"-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

那么，除了学院派的细节以外，我们为什么需要一个负零呢？

在一些应用程序中，开发者使用值的大小来表示一部分信息（比如动画中每一帧的速度），而这个number的符号来表示另一部分信息（比如移动的方向）。

在这些应用程序中，举例来说，如果一个变量的值变成了0，而它丢失了符号，那么你就丢失了它是从哪个方向移动到0的信息。保留零的符号避免了潜在的意外信息丢失。

特殊等价

正如我们上面看到的，当使用等价性比较时，值NaN和值-0拥有特殊的行为。NaN永远不会和自己相等，所以你不得不使用ES6的Number.isNaN(..)（或者它的填补）。相似地，-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(..)填补：

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(..)很大程度上是为这些特殊的等价情况准备的。

值与引用

在其他许多语言中，根据你使用的语法，值可以通过值拷贝，也可以通过引用拷贝来赋予/传递。

比如，在C++中如果你想要把一个number变量传递进一个函数，并使这个变量的值被更新，你可以用int& myNum这样的东西来声明函数参数，当你传入一个变量x时，myNum将是一个 指向x的引用；引用就像一个特殊形式的指针，你得到的是一个指向另一个变量的指针（像一个 别名（alias）） 。如果你没有声明一个引用参数，被传入的值将 总是 被拷贝的，就算它是一个复杂的对象。

在JavaScript中，没有指针，并且引用的工作方式有一点儿不同。你不能拥有一个从一个JS变量到另一个JS变量的引用。这是完全不可能的。

JS中的引用指向一个（共享的） 值，所以如果你有10个不同的引用，它们都总是同一个共享值的不同引用；它们没有一个是另一个的引用/指针。

另外，在JavaScript中，没有语法上的提示可以控制值和引用的赋值/传递。取而代之的是，值的 类型 用来 唯一 控制值是通过值拷贝，还是引用拷贝来赋予。

让我们来展示一下：

var a = 2;
var b = a; // `b`总是`a`中的值的拷贝
b++;
a; // 2
b; // 3

var c = [1,2,3];
var d = c; // `d`是共享值`[1,2,3]`的引用
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

简单值（也叫基本标量） 总是 通过值拷贝来赋予/传递：null，undefined，string，number， boolean，以及ES6的symbol。

复合值——object（包括array，和所有的对象包装器——见第三章）和function——总是 在赋值或传递时创建一个引用的拷贝。

在上面的代码段中，因为2是一个基本标量，a持有一个这个值的初始拷贝，而b被赋予了这个值的另一个拷贝。当改变b时，你根本没有在改变a中的值。

但 c和d两个都 是同一个共享的值[1,2,3]的分离的引用。重要的是，c和d对值[1,2,3]的“拥有”程度上是一样的——它们只是同一个值的对等引用。所以，不管使用哪一个引用去修改（.push(4)）实际上共享的array值本身，影响的仅仅是这一个共享值，而且这两个引用将会指向新修改的值[1,2,3,4]。

因为引用指向的是值本身而不是变量，你不能使用一个引用来改变另一个引用所指向的值：

var a = [1,2,3];
var b = a;
a; // [1,2,3]
b; // [1,2,3]

// 稍后
b = [4,5,6];
a; // [1,2,3]
b; // [4,5,6]

当我们做赋值操作b = [4,5,6]时，我们做的事情绝对不会对a所指向的 位置（[1,2,3]）造成任何影响。如果那可能的话，b就会是a的指针而不是这个array的引用 —— 但是这样的能力在JS中是不存在的！

这样的困惑最常见于函数参数：

function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // 稍后
    x = [4,5,6];
    x.push( 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [1,2,3,4]  不是  [4,5,6,7]

当我们传入参数a时，它将一份a引用的拷贝赋值给x。x和a是指向相同的[1,2,3]的不同引用。现在，在函数内部，我们可以使用这个引用来改变值本身（push(4)）。但是当我们进行赋值操作x = [4,5,6]时，不可能影响原来的引用a所指向的东西——它仍然指向（已经被修改了的）值[1,2,3,4]。

没有办法可以使用x引用来改变a指向哪里。我们只能修改a和x共通指向的那个共享值的内容。

要想改变a来使它拥有内容为[4,5,6,7]的值，你不能创建一个新的array并赋值——你必须修改现存的array值：

function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // 稍后
    x.length = 0; // 原地清空既存的数组
    x.push( 4, 5, 6, 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [4,5,6,7]  不是  [1,2,3,4]

正如你看到的，x.length = 0和x.push(4,5,6,7)没有创建一个新的array，但是修改了现存的共享array。所以理所当然地，a引用了新的内容[4,5,6,7]。

记住：你不能直接控制/覆盖值拷贝和引用拷贝的行为 —— 这些语义是完全由当前值的类型来控制的。

为了实质上地通过值拷贝传递一个复合值（比如一个array），你需要手动制造一个它的拷贝，使被传递的引用不指向原来的值。比如：

foo( a.slice() );

不带参数的slice(..)方法默认地为这个array制造一个全新的（浅）拷贝。所以，我们传入的引用仅指向拷贝的array，这样foo(..)不会影响a的内容。

反之 —— 传递一个基本标量值，使它的值的变化可见，就像引用那样 —— 你不得不将这个值包装在另一个可以通过引用拷贝来传递的复合值中（object，array，等等）：

function foo(wrapper) {
    wrapper.a = 42;
}

var obj = {
    a: 2
};

foo( obj );

obj.a; // 42

这里，obj作为基本标量属性a的包装。当传递给foo(..)时，一个obj引用的拷贝被传入并设置给wrapper参数。我们现在可以使用wrapper引用来访问这个共享的对象，并更新它的值。在函数完成时，obj.a将被更新为值42。

你可能会遇到这样的情况，如果你想要传入一个像2这样的基本标量值的引用，你可以将这个值包装在它的Number对象包装器中（见第三章）。

这个Number对象的引用的拷贝 将 会被传递给函数是事实，但不幸的是，和你可能期望的不同，拥有一个共享独享的引用不会给你修改这个共享的基本值的能力：

function foo(x) {
    x = x + 1;
    x; // 3
}

var a = 2;
var b = new Number( a ); // 或等价的 `Object(a)`

foo( b );
console.log( b ); // 2, 不是 3

这里的问题是，底层的基本标量值是 不可变的（String和Boolean也一样）。如果一个Number对象持有一个基本标量值2，那么这个Number对象就永远不能再持有另一个值；你只能用一个不同的值创建一个全新的Number对象。

当x用于表达式x + 1时，底层的基本标量值2被自动地从Number对象中开箱（抽出），所以x = x + 1这一行很微妙地将x从一个共享的Number对象的引用，改变为仅持有加法操作2 + 1的结果3的基本标量值。因此，外面的b仍然引用原来的未被改变/不可变的，持有2的Number对象。

你 可以 在Number对象上添加属性（只是不要改变它内部的基本值），所以你可间接地通过这些额外的属性交换信息。

不过，这可不太常见；对大多数开发者来说这可能不是一个好的做法。

与其这样使用Number包装器对象，使用早先的代码段中那样的手动对象包装器（obj）要好得多。这不是说像Number这样包装好的对象包装器没有用处——而是说在大多数情况下，你可能应该优先使用基本标量值的形式。

引用十分强大，但是有时候它们碍你的事儿，而有时你会在它们不存在时需要它们。你唯一可以用来控制引用与值拷贝的东西是值本身的类型，所以你必须通过你选用的值的类型来间接地影响赋值/传递行为。

复习

在JavaScript中，array仅仅是数字索引的集合，可以容纳任何类型的值。string是某种“类array”，但它们有着不同的行为，如果你想要将它们作为array对待的话，必须要小心。JavaScript中的数字既包括“整数”也包括浮点数。

几种特殊值被定义在基本类型内部。

null类型只有一个值null，undefined类型同样地只有undefined值。对于任何没有值存在的变量或属性，undefined基本上是默认值。void操作符允许你从任意另一个值中创建undefined值。

number包含几种特殊值，比如NaN（意为“不是一个数字”，但称为“非法数字”更合适）；+Infinity和-Infinity； 还有-0。

简单基本标量（string，number等）通过值拷贝进行赋值/传递，而复合值（object等）通过引用拷贝进行赋值/传递。引用与其他语言中的引用/指针不同 —— 它们从不指向其他的变量/引用，而仅指向底层的值。