看下面一段代码，为什么结果是这样的。其中的隐式类型转换到底是根据什么规则来的。

true == 1  // true
1 == true  // true
'1' == true // true
2 == true // false
'true' == true  // false

抽象相等比较 “==”

比较运算x==y, 其中x和 y是值，产生true或者false。这样的比较按如下方式进行：

  1. 若Type(x)与Type(y)相同， 则
    1. 若Type(x)为Undefined， 返回true。
    2. 若Type(x)为Null， 返回true。
    3. 若Type(x)为Number， 则
      1. 若x为NaN， 返回false。
      2. 若y为NaN， 返回false。
      3. 若x与y为相等数值， 返回true。
      4. 若x 为 +0 且 y为−0， 返回true。
      5. 若x 为 −0 且 y为+0， 返回true。
      6. 返回false。
    4. 若Type(x)为String, 则当x和y为完全相同的字符序列（长度相等且相同字符在相同位置）时返回true。 否则， 返回false。
    5. 若Type(x)为Boolean, 当x和y为同为true或者同为false时返回true。 否则， 返回false。
    6. 当x和y为引用同一对象时返回true。否则，返回false。
  2. 若x为null且y为undefined， 返回true。
  3. 若x为undefined且y为null， 返回true。
  4. 若Type(x) 为 Number 且 Type(y)为String， 返回comparison x == ToNumber(y)的结果。
  5. 若Type(x) 为 String 且 Type(y)为Number，
  6. 返回比较ToNumber(x) == y的结果。
  7. 若Type(x)为Boolean， 返回比较ToNumber(x) == y的结果。
  8. 若Type(y)为Boolean， 返回比较x == ToNumber(y)的结果。
  9. 若Type(x)为String或Number，且Type(y)为Object，返回比较x == ToPrimitive(y)的结果。
  10. 若Type(x)为Object且Type(y)为String或Number， 返回比较ToPrimitive(x) == y的结果。
  11. 返回false。

 按以上相等的定义：

  • 字符串比较可以按这种方式强制执行: "" + a == "" + b 。
  • 数值比较可以按这种方式强制执行: +a == +b 。
  • 布尔值比较可以按这种方式强制执行: !a == !b 。

 等值比较操作保证以下不变：

  • A != B 等价于 !(A==B) 。
  • A == B 等价于 B == A ，除了A与B的执行顺序。

 相等运算符不总是传递的。例如，两个不同的String对象，都表示相同的字符串值； == 运算符认为每个String对象都与字符串值相等，但是两个字符串对象互不相等。例如：

  • new String("a") == "a" 和 "a" == new String("a") 皆为true。
  • new String("a") == new String("a") 为false。

字符串比较使用的方式是简单地检测字符编码单元序列是否相同。不会做更复杂的、基于语义的字符或者字符串相等的定义以及Unicode规范中定义的collating order。所以Unicode标准中认为相等的String值可能被检测为不等。实际上这一算法认为两个字符串已经是经过规范化的形式。

隐式类型转换ToPrimitive

在上面的内容里面出现了一个我们不太常见的类型转换：ToPrimitive。这其实是个拆装箱操作。这个方法ToPrimitive 运算符接受一个值，和一个可选的 期望类型 作参数。ToPrimitive 运算符把其值参数转换为非对象类型。如果对象有能力被转换为不止一种原语类型，可以使用可选的 期望类型 来暗示那个类型。根据下表完成转换：

输入类型结果
Undefined结果等于输入的参数（不转换）
Null结果等于输入的参数（不转换）
Boolean结果等于输入的参数（不转换）
Number结果等于输入的参数（不转换）
String结果等于输入的参数（不转换）
Object返回该对象的默认值。对象的默认值由把期望类型传入作为hint参数调用对象的内部方法[[DefaultValue]]得到，[[DefaultValue]]见下文.
toPrimitive

[[DefaultValue]]

当用字符串 hint 调用 O 的 [[DefaultValue]] 内部方法，采用以下步骤：

  1. 令 toString 为用参数 “toString” 调用对象 O 的 [[Get]] 内部方法的结果。
  2. 如果 IsCallable(toString) 是 true，则
    1. 令 str 为用 O 作为 this 值，空参数列表调用 toString 的 [[Call]] 内部方法的结果。
    2. 如果 str 是原始值，返回 str。
  3. 令 valueOf 为用参数 “valueOf” 调用对象 O 的 [[Get]] 内部方法的结果。
  4. 如果 IsCallable(valueOf) 是 true，则
    1. 令 val 为用 O 作为 this 值，空参数列表调用 valueOf 的 [[Call]] 内部方法的结果。
    2. 如果 val 是原始值，返回 val。
  5. 抛出一个 TypeError 异常。

 当用数字 hint 调用 O 的 [[DefaultValue]] 内部方法，采用以下步骤：

  1. 令 valueOf 为用参数 “valueOf” 调用对象 O 的 [[Get]] 内部方法的结果。
  2. 如果 IsCallable(valueOf) 是 true，则
    1. 令 val 为用 O 作为 this 值，空参数列表调用 valueOf 的 [[Call]] 内部方法的结果。
    2. 如果 val 是原始值，返回 val。
  3. 令 toString 为用参数 “toString” 调用对象 O 的 [[Get]] 内部方法的结果。
  4. 如果 IsCallable(toString) 是 true，则
    1. 令 str 为用 O 作为 this 值，空参数列表调用 toString 的 [[Call]] 内部方法的结果。
    2. 如果 str 是原始值，返回 str。
  5. 抛出一个 TypeError 异常。

 当不用 hint 调用 O 的 [[DefaultValue]] 内部方法时，除非O 是 Date 对象的情况下把 hint 当作字符串一样解释它的行为，除此之外把 hint 当作数字一样解释它的行为。

上面说明的 [[DefaultValue]] 在原生对象中只能返回原始值。如果一个宿主对象实现了它自身的 [[DefaultValue]] 内部方法，那么必须确保其 [[DefaultValue]] 内部方法只能返回原始值。

末

配上上面两个知识点，搞个思考题：

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

输出什么，为什么？

avatar
  Subscribe  
提醒