为什么 === 比 JavaScript 中的 == 快

javascript必须为===做的事情：

1. 如果 Type(x( 与 Type(y( 不同，则返回 false。
2. 如果 Type(x( 是"未定义"，则返回 true。
3. 如果 Type(x( 为 Null，则返回 true。
4. 如果 Type(x( 是数字，则
   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. 返回假。
5. 如果 Type(x( 是 String，则如果 x 和 y 是完全相同的字符序列(长度相同，对应位置的字符相同(，则返回 true;否则返回 false。
6. 如果 Type(x( 是布尔值，如果 x 和 y 都为真或都为假，则返回 true;否则，返回 false。
7. 如果 x 和 y 引用同一对象，则返回 true。否则，返回 false。

这是它必须为==做的事情：

1. 如果 Type(x( 与 Type(y( 相同，则
   1. 如果 Type(x( 是"未定义"，则返回 true。
   2. 如果 Type(x( 为 Null，则返回 true。
   3. 如果 Type(x( 是数字，则
      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. 返回假。
   4. 如果 Type(x( 是字符串，则如果 x 和 y 是完全相同的字符序列(相同的长度和相应位置的相同字符(，则返回 true。否则，返回 false。
   5. 如果 Type(x( 是布尔值，如果 x 和 y 都为真或都为假，则返回 true。否则，返回 false。
   6. 如果 x 和 y 引用同一对象，则返回 true。否则，返回 false。
2. 如果 x 为空且 y 未定义，则返回 true。
3. 如果 x 未定义且 y 为空，则返回 true。
4. 如果 Type(x( 是 Number 且 Type(y( 是 String，则返回比较结果 x == ToNumber(y(。
5. 如果 Type(x( 是字符串，Type(y( 是数字，返回比较结果 ToNumber(x( == y。
6. 如果 Type(x( 是布尔值，则返回比较结果 ToNumber(x( == y。
7. 如果 Type(y( 是布尔值，则返回比较结果 x == ToNumber(y(。
8. 如果 Type(x( 是字符串或数字，Type(y( 是对象，返回比较结果 x == ToPrimitive(y(。
9. 如果 Type(x( 是对象，Type(y( 是字符串或数字，返回比较 ToPrimitive(x( == y 的结果。
10. 返回假。

请注意，如果Type(x)等于 Type(y)则运算符执行相同的操作。但是，如果不是，则==可能必须进行各种转换，而===只返回 false。

对于您提供的链接，正在比较的类型实际上是相同的，因此两个运算符的性能应该大致相同。此处的差异将基于实现细节 - 由于它们执行不同的事情，因此可以针对不同的方式进行优化。从理论上讲，由于===做得更少，人们会认为它总是更快，但对于某些版本的 Firefox 来说，情况似乎并非如此，至少如果这些基准测试是准确的。

但是，如果类型不同，请查看差异。当做"hi" === {}你会得到~6600万次操作/秒，但"hi" == {}你只有~400万次操作/秒。

JavaScript 是一种弱类型语言，因此它会尽可能应用类型强制。

等于运算符

// These are true
new Number(10) == 10; // Number.toString() is converted
                      // back to a number
10 == '10';           // Strings gets converted to Number
10 == '+10 ';         // More string madness
10 == '010';          // And more 
isNaN(null) == false; // null converts to 0
                      // which of course is not NaN

严格相等运算符

它的工作方式与普通相等运算符类似，只是严格相等运算符不会在其操作数之间执行类型强制

""           ===   "0"           // false
0            ===   ""            // false
0            ===   "0"           // false
false        ===   "false"       // false
false        ===   "0"           // false
false        ===   undefined     // false
false        ===   null          // false
null         ===   undefined     // false
" 't'r'n"    ===   0             // false

上面的结果要清晰得多，并允许早期破坏代码。这在一定程度上强化了代码，并在操作数类型不同的情况下提高了性能。

所以 === 比 Javascript 中的 == 快

这是很好的参考

=== 比较值和类型是否相同。
== 比较值是否相同，但它也会在比较中进行类型转换。这些类型转换使 == 比 === 慢。