为什么在JavaScript中，'==='比'=='更快？

Question

请查看以下测试：

• == vs ====

• == vs ===

- Thanh Nguyen

---

因为它不涉及类型转换，所以能更快地判断条件是真还是假。 - elclanrs

您发布的链接并不完全支持您的说法。结果显示，在大多数浏览器中，它们之间的差异相对较小，有些显示'=='比'==='更快，而有些则显示'==='比'=='更快。 - bcorso

因为只需花费最小的努力来询问，而不是搜索，所以更容易在http://stackoverflow.com上找到以下问题的答案：

• JavaScript中运算符性能vs
• 在JavaScript比较中使用哪个等号运算符是否重要？
• 在远程JavaScript文件中使用“ vs”和“ < ”，哪一个更快？
• 哪个JavaScript等式运算符（“ == ”或“ ===”）更快？
• JavaScript中“&&”和“||”的区别是什么？

- random

与问题无关，但是JS在不同浏览器上的性能表现如此不一致。不仅如此，它经常违背常识，例如正则表达式比逐个字符解析字符串更快，大多数情况下是因为一些本地方法是用C语言编写的，因此执行更快。这非常烦人。 - plalx

性能差异微不足道，浏览器的实现方式也不同。这些测试无法反映真实世界的应用程序。我只在有意义的情况下使用 == 和 ===。 - elclanrs

Answer 1

以下是与 === 相关的 JavaScript 内容:

1. 如果 x 的类型与 y 不同，返回 false。
2. 如果 x 的类型是 Undefined，返回 true。
3. 如果 x 的类型是 Null，返回 true。
4. 如果 x 的类型是 Number，则
   1. 如果 x 是 NaN，则返回 false。
   2. 如果 y 是 NaN，则返回 false。
   3. 如果 x 的 Number 值与 y 相同，则返回 true。
   4. 如果 x 是 +0 且 y 是 −0，则返回 true。
   5. 如果 x 是 −0 且 y 是 +0，则返回 true。
   6. 返回 false。
5. 如果 x 的类型是 String，则仅当 x 和 y 是完全相同的字符序列（长度相同且对应位置上的字符相同）时返回 true；否则返回 false。
6. 如果 x 的类型是 Boolean，则仅当 x 和 y 都为 true 或都为 false 时返回 true；否则返回 false。
7. 如果 x 和 y 引用同一个对象，则返回 true。否则返回 false。

以下是与 == 相关的 JavaScript 内容:

1. 如果 x 的类型与 y 相同，则
   1. 如果 x 的类型是 Undefined，则返回 true。
   2. 如果 x 的类型是 Null，则返回 true。
   3. 如果 x 的类型是 Number，则
      1. 如果 x 是 NaN，则返回 false。
      2. 如果 y 是 NaN，则返回 false。
      3. 如果 x 的 Number 值与 y 相同，则返回 true。
      4. 如果 x 是 +0 且 y 是 −0，则返回 true。
      5. 如果 x 是 −0 且 y 是 +0，则返回 true。
      6. 返回 false。
   4. 如果x的类型是字符串，则当x和y的字符序列完全相同时返回true（长度相同且对应位置的字符相同）。否则，返回false。
   5. 如果x的类型是布尔值，则当x和y都为true或都为false时返回true。否则，返回false。
   6. 如果x和y引用同一对象，则返回true。否则，返回false。
   7. 如果x为null且y为undefined，则返回true。
   8. 如果x为undefined且y为null，则返回true。
   9. 如果x的类型是数字且y的类型是字符串，则返回比较结果x == ToNumber(y)。
   10. 如果x的类型是字符串且y的类型是数字，则返回比较结果ToNumber(x) == y。
   11. 如果x的类型是布尔值，则返回比较结果ToNumber(x) == y。
   12. 如果y的类型是布尔值，则返回比较结果x == ToNumber(y)。
   13. 如果x的类型是字符串或数字，且y的类型是对象，则返回比较结果x == ToPrimitive(y)。
   14. 如果x的类型是对象，且y的类型是字符串或数字，则返回比较结果ToPrimitive(x) == y。
   15. 返回false。

   请注意，如果Type(x)等于Type(y)，那么这两个运算符执行的操作是相同的。然而，如果它们不相等，那么==可能需要进行各种转换，而===仅返回false。

   对于您提供的链接，要比较的类型实际上是相同的，因此这两个运算符应执行相同的操作。差异在于基于实现细节 - 因为它们执行不同的操作，所以它们可以针对不同的优化。理论上，由于===执行的操作更少，人们会认为它总是更快，但至少在某些Firefox版本的基准测试中似乎并非如此。

   然而，如果类型不同，情况就不同了。执行"hi" === {}时，您将获得大约6600万次操作/秒，但对于"hi" == {}，您仅有约400万次操作/秒。

- Claudiu

---

我不认为这是问题的所在。 - Deepak Ingole

“对于 == 和 ===，如果类型不同，则需要许多额外的步骤。”并非一定如此。 - user2736012

@captain，请问有什么问题吗？ - plalx

@plalx 的问题是关于性能的。 - Deepak Ingole

船长，我认为规范已经自我解释了==为什么比===更慢。 - plalx

Answer 2

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中，===比==更快。

这里有一个很好的参考：链接。

- Deepak Ingole

Answer 3

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

- JKor