Разница в производительности JavaScript между двойными равными (==) и тройными равными (===)

Ответ 1

Строгое сравнение (===) всегда будет немного быстрее, но разница обычно незначительна.

Конечно, имеет смысл предпочесть ===, если вы точно знаете, что вам не нужно принуждение типа при сравнении. Он всегда будет по крайней мере так же быстро, как ==.

Ответ 2

• Если сравниваемые типы одинаковы, они идентичны. То есть они используют тот же самый алгоритм.

• Если типы разные, тогда производительность не имеет значения. Либо вам нужно принуждение к типу, либо нет. Если вам это не нужно, не используйте ==, потому что полученный результат может быть неожиданным.

Ответ 3

Изменить: для справки здесь по спецификации доктором Акселем Раушмайером http://www.2ality.com/2011/06/javascript-equality.html Действительно отличная запись.

=== (Строгое равенство): учитывает только значения, имеющие одинаковый тип.

• undefined === undefined, null === null,
• NaN === ничего, включая себя,
• Примитив [Number | String | Boolean] === примитивное значение равно,
• to self (+0 === -0)
• Два объекта [Array | Object | Function] === Только сам (тот же самый точный объект)

== (равное равенство)

• Если оба значения имеют один и тот же тип: сравните с ===.
• undefined == null
• число и строка: строка = > число и сравнение
• boolean и non-boolean = > не-boolean для номера и сравнения
• строка или число = > объект: конвертировать объект в примитив и сравнение.

Во всех современных средах Javascript они реализованы совершенно по-другому. Простыми словами, == проверяет alikeness посредством преобразования данных переменных в примитивы (строка, число, логическое значение). === тесты для строгого сходства, что означает тот же объект или примитивное значение без преобразования.

Если вы это сделаете objOne == objTwo что на самом деле происходит [[EQUALS]].call(objOne.valueOf(), objTwo.valueOf())

Разрешение значения Of может быть несколько задействовано, перепрыгивая между функциями, открытыми в JS и внутренним движком. Достаточно сказать, что сравнение всегда будет состоять из двух значений, принудительных к примитивному, или ошибка будет выброшена.

Изменить: EQUALS на самом деле пытается STRICT_EQUALS сначала, который вытесняет оставшуюся часть процесса.

Интересный бит здесь заключается в том, что valueOf (и его партнер toString) являются переопределяемыми. Запустите этот кусок кода в Chrome (я думаю, что любой веб-кит, не уверенный, что АО и 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.

Ответ 4

Из-за производительности я думаю, что === имеет лучшую производительность, потому что === более строгая, чем ==,

например. попробуйте выполнить следующие действия в консоли Chrome.

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

== должен проверять больше, чем ===

Ответ 5

Из некоторых неосновательных тестов == выглядит чуть быстрее, чем ===.

Вкратце, я имею в виду, что я вижу разницу в несколько миллисекунд на основе многих миллионов тестов. Вы не можете нуждаться в усилении производительности, а не использовать то, что наиболее правильно для этой задачи.

EDIT: на самом деле, похоже, зависит от того, что вы сравниваете, и от реализации браузера. Другими словами, не беспокойтесь об этом.