双等于（==）和三等于（===）之间的JavaScript性能差异

Question

在JavaScript中，使用double equals（ == ）与使用triple equals（ === ）之间是否存在性能差异？

示例： if (foo == bar) vs if (foo === bar)

Answer 1

• 如果比较的类型相同，则它们是相同的 。 也就是说他们使用完全相同的算法 。

• 如果类型不同 ，那么性能就无关紧要了。 要么你需要类型强制，要么你不需要。 如果您不需要它，请不要使用==因为您获得的结果可能是意外的。

Answer 2

严格比较（ === ）总是稍微快一些，但差异通常可以忽略不计 。

如果您确定在比较中不需要类型强制，那么首选===肯定是有道理的。 它总是至少和==一样快。

Answer 3

编辑：供参考，这是由 Axel Rauschmayer博士的规范解释http://www.2ality.com/2011/06/javascript-equality.html非常好写。

=== （严格平等）：仅考虑具有相同类型的相等值。

1. undefined === undefined，null === null，
2. NaN ===没有包括它自己，
3. Primitive [Number | String | Boolean] ===原始值相等，
4. 自我（+0 === -0）
5. 两个对象[Array | Object | Function] ===只有self（同一个确切的实体）

== （宽容平等）

1. 如果两个值具有相同的类型：与===比较。
2. undefined == null
3. number和string：string => number and compare
4. boolean和non-boolean =>非布尔数字和比较
5. string或number =>一个对象：将对象转换为原始和比较。

在所有现代Javascript环境中，它们的实现完全不同。 简单来说， ==通过将给定变量转换为基元（字符串，数字，布尔值）来测试相似性。 ===测试严格相同性，这意味着完全相同的Object或原始值而不进行转换。

如果你做objOne == objTwo ，实际发生的是[[EQUALS]].call(objOne.valueOf(), objTwo.valueOf())

valueOf的分辨率可能会有所涉及，在JS中暴露的函数和内部引擎之间反弹。 可以说，比较将始终以两个强制转换为原始值或错误的方式结束。

编辑： EQUALS实际上首先尝试STRICT_EQUALS ，它会抢占进程的其余部分。

这里有趣的是，valueOf（和它的伙伴toString）是可以覆盖的。 在Chrome中运行这段代码（我认为任何webkit，不确定JSC和V8是否共享这个小窍门）。 它会打击你的思想：

var actions = [];
var overload = {
  valueOf: function(){
    var caller = arguments.callee.caller;
    actions.push({
      operation: caller.name,
      left: caller.arguments[0] === this ? "unknown" : this,
      right: caller.arguments[0]
    });
    return Object.prototype.toString.call(this);
  }
};
overload.toString = overload.valueOf;
overload == 10;
overload === 10;
overload * 10;
10 / overload;
overload in window;
-overload;
+overload;
overload < 5;
overload > 5;
[][overload];
overload == overload;
console.log(actions);

输出：

[ { operation: 'EQUALS',
    left: overload,
    right: 10 },
  { operation: 'MUL',
    left: overload,
    right: 10 },
  { operation: 'DIV',
    left: 'unknown',
    right: overload },
  { operation: 'IN',
    left: overload,
    right: DOMWindow },
  { operation: 'UNARY_MINUS',
    left: overload,
    right: undefined },
  { operation: 'TO_NUMBER',
    left: overload,
    right: undefined },
  { operation: 'COMPARE',
    left: overload,
    right: 5 },
  { operation: 'COMPARE',
    left: 'unknown',
    right: overload },
  { operation: 'ToString',
    left: 'unknown',
    right: overload } ]

==和===之间差异的本质通过===未显示在该列表中来说明。 它完全跳过JavascriptLand的旅程。 比较性能时，这种冒险是昂贵的。

但是，您需要考虑引擎优化。 对于大多数对象，引擎将能够删除大部分步骤并保留在NativeLand中并获得几乎相同的性能。 但这不是一种保证，如果有什么东西阻止引擎能够使用优化，代码中的一些花哨或覆盖内置或无数问题，那么你会立即看到性能结果。 ===强迫它。

===只是Javascript中唯一不可变的东西。

Answer 4

由于性能，我认为===有更好的性能，因为===比==更严格，

例如，在Chrome控制台中尝试以下操作。

> 1 == '1'
  true
> 1 === '1'
  false

==必须检查比===更多的东西

Answer 5

从一些脆弱的测试来看， ==似乎比===略快。

稍微说，我的意思是我可以看到数百万次测试的内部差异几毫秒。 您不可能需要性能提升，而不是使用最适合手头任务的任何东西。

编辑：实际上，似乎依赖于/您正在比较和浏览器实现。 换句话说，不要担心。

Answer 6

这取决于被比较的项目。 由于“===”比“==”更严格，因此它应该比“==”更快地返回false。 但是，如果两个项严格相等，“===”应该比“==”花费更多的时间，因为它必须检查更多属性是否相等。