JS探秘——那些你理解存在偏差的问题

Javascript的连续赋值运算

var a = {n:1};  
a.x = a = {n:2};  
alert(a.x); // --> undefined 

看 jQuery 源码 时发现的这种写法。 以上第二句 a.x = a = {n:2} 是一个连续赋值表达式。 这个连续赋值表达式在引擎内部究竟发生了什么？是如何解释的？

加一个变量 b，指向 a。

var a = {n:1};  
var b = a; // 持有a，以回查  
a.x = a = {n:2};  
alert(a.x);// --> undefined  
alert(b.x);// --> [object Object] 

实际执行过程：从右到左，a 先被赋值为 {n:2}，随后 a.x 被赋值 {n:2}。第一步 a = {n:2} 的 a 指向的是新的对象 {n:2}， 第二步 a.x = {n:2} 中的 a 是 {a:1}。如下所示

             a.x  =  a  = {n:2}
              │      │
      {n:1}<──┘      └─>{n:2}

为什么 ++[[]][+[]]+[+[]] = 10？

++[[]][+[]]+[+[]]，它相等于：

++[[]][+[]]
+
[+[]]

在 JavaScript 里，+ 会把一些字符转化成数字，如 +"" === 0、+[] === 0，因此，我们可以简化一下(++ 比 + 有更高的优先级)：

++[[]][0]
+
[0]

因为 [[]][0] 的意思是：获取 [[]] 的第一个元素，这就得出了下面的结果：

• [[]][0] 返回内部数组 ([])。根据语言规范，我们说 [[]][0] === [] 是不正确的，但让我们把这个内部数组称作 A，以避免错误的写法。
• ++[[]][0] == A + 1， 因为 ++ 的意思是”加一”。
• ++[[]][0] === +(A + 1)；换句话说，你得到的永远是个数值( +1 并不一定得到的是个数值，但 ++ 一定是)。

我们可以把这一堆代码简化的更清晰。让我们把 A 换回成 [] :

+([] + 1)
+
[0]

在 JavaScript 里，这也是正确的：[] + 1 === "1"，因为 [] == "" (这相当于一个空的数组的内部元素连接)，于是：

+([] + 1) === +("” + 1)，并且 
+("” + 1) === +("1")，并且 
+("1") === 1 

让我们再次简化一下：

1
+
[0]

同样，在 Javascript 里，这是正确的：[0] == "0"，因为这是相当于一个有一个元素的数组的内部元素的连接。 各元素会使用，分隔。 当只有一个元素时，你可以推论出这个过程的结果就是它自身的第一个元素。

所以，最终我们得到 (数字 + 字符串 = 字符串)：

1
+
"0"
=== "10" // 耶！

[1,2] + [3,4]=="1,23,4"

JavaScript 的 + 运算符有两个目的：

1. 将两个数相加
2. 将两个字符串连接

规范并没有定义 + 运算符在数组上的行为，所以javascript 首先 把数组转换成字符串，然后在字符串上进行 + 运算。

如果想连接两个数组，可以使用数组的 concat 方法：

[1, 2].concat([3, 4]) // [1, 2, 3, 4]

{}+{}等于多少?

结果为：NaN

这个问题的原因是，JavaScript 把第一个 {} 解释成了一个空的代码块（code block）并忽略了它。 NaN 其实是表达式 +{} 计算的结果 (+ 加号以及第二个 {})。 你在这里看到的 + 加号并不是二元运算符「加法」，而是一个一元运算符，作用是将它后面的操作数转换成数字，和 Number() 函数完全一样。例如:

> +"3.65"
3.65

以下的表达式是它的等价形式:

+{}
Number({})
Number({}.toString())  // {}.valueOf() isn’t primitive
Number("[object Object]")
NaN

为什么第一个 {} 会被解析成代码块（code block）呢？ 因为整个输入被解析成了一个语句：如果左大括号出现在一条语句的开头，则这个左大括号会被解析成一个代码块的开始。 所以，你也可以通过强制把输入解析成一个表达式来修复这样的计算结果: （译注：我们期待它是个表达式，结果却被解析成了语句）

> ({} + {})
'[object Object][object Object]'

{} === {}，结果为false

每个对象都有自己唯一的标识符，因此通过字面量或构造函数创建的对象和任何其他对象都不相等，我们可以通过 === 进行比较。

{} === {} //false

对象是通过引用来比较的，只有两个对象有相同的标识，才认为这个对象是相等的。

var obj = {};
 obj === obj //true

原始值没有内部标识，原始值是按值比较的： 比较两个原始值的依据是他们的内容，如果两个原始值的内容相同，这认为这两个原始值相同。

"abc" === "abc" //true

原始值和它们的包装类型

原始值类型 boolean, number 以及 string 都有自己对应的包装类型 Boolean, Number 和 String。 包装类型的实例都是对象值，两种类型之间的转换也很简单：

• 转换为包装类型：new String("abc")
• 转换为原始类型：new String("abc").valueOf()

原始值类型以及它们相应的包装器类型有很多不同点，例如：

 typeof "abc" //'string'
 typeof new String("abc") //'object'
 "abc" instanceof String //false
 new String("abc") instanceof String //true
 "abc" === new String("abc") //false

包装类型的实例是一个对象，因此和 JavaScript 和对象一样，包装类型也无法进行值的比较（只能比较引用）。

 var a = new String("abc");
 var b = new String("abc");
 a == b //false（虽然 a 和 b 有相同的内容，但是依然返回 false）
 a == a //true

5.toFixed(3)，报错SyntaxError: Unexpected token ILLEGAL

原始值没有自己的方法

包装对象类型很少被直接使用，但它们的原型对象定义了许多其对应的原始值也可以调用的方法。 例如，String.prototype 是包装类型 String 的原型对象。 它的所有方法都可以使用在字符串原始值上。 包装类型的方法 String.prototype.indexOf 在字符串原始值上也有，它们并不是两个拥有相同名称的方法，而的的确确就是同一个方法：

 "abc".charAt === String.prototype.charAt
true

在数字的包装类型 Number 的原型对象有 toFixed 方法，即 Number.prototype.toFixed，但是当我们写如下代码时却发生错误：

 5.toFixed(3)
SyntaxError: Unexpected token ILLEGAL

此错误是解析错误（SyntaxError），5 后面跟着一个点号（.），这个点被当作了小数点，而小数点后面应该是一个数，以下代码可以正常运行：

 (5).toFixed(3)
"5.000"
 5..toFixed(3)
"5.000"