JavaScript - производительность операторов === vs ==

для js оператор === вернет истину, если он используется для строковых типов, и строки содержат точно такие же символы. Для объектов он сравнивает ссылки на объекты, а не содержимое.

Из стандарта ECMA:

11.9.6 Алгоритм сравнения строгого равенства Сравнение x === y, где x и y являются значениями, дает истинное или ложное значение. Такое сравнение выполняется следующим образом:

1. Если Тип (x) отличается от Типа (y), вернуть false.
2. Если Type (x) - Undefined, вернуть true.
3. Если Type (x) равен Null, вернуть true.
4. Если Type (x) - Number, то файл. Если x равен NaN, вернуть false. б. Если y равно NaN, вернуть false. c. Если x имеет то же числовое значение, что и y, вернуть true. d. Если x равно +0, а y равно -0, вернуть истину. е. Если x равен -0, а y равен +0, вернуть истину. f. Вернуть false.
5. Если Type (x) равен String, то верните true, если x и y являются одной и той же последовательностью символов (одинаковой длины и одинаковых символов в соответствующих позициях); в противном случае верните false.
6. Если Type (x) имеет значение Boolean, вернуть true, если x и y оба истинны или оба ложны;

Я считаю, что лучше всего будет ответить с легко проверяемыми доказательствами.

Эти операции настолько малы, что их сложно проверить на производительность.

• == 1648 верно
• === 1629 верно
• контрольный тест 1575 верно

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

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

Обновления 2019 г.

2019-04-09 Firefox с улучшенным тестом:

• == 1383 верно
• === 1167 верно
• контрольный тест 429 верно

2019-04-09 Chrome с улучшенным тестом:

• == 249 верно
• === 248 верно
• контрольный тест 248 верно

2019-04-09 Edge с улучшенным тестом:

• == 22510 верно
• === 20315 верно
• контрольный тест 4968 верно

С годами браузеры стали умнее, и, похоже, мой первоначальный тест столкнулся с классными оптимизациями в Chrome и Firefox, что сделало его бесполезным. Я усложнил оптимизацию теста и увеличил количество запусков, чтобы снова получить значимые результаты. Похоже, что === по-прежнему работает быстрее. Вероятно, это все еще бесполезная трата времени.

var testString = "42";
var testString2 = "43";
var testString3 = "42";
var testNumber = 42;
var testNumber2 = 43;
var testNumber3 = 42;

var testObject = {};
var testObject2 = {};
var testObject3 = testObject;


var start = Date.now();
var result = null;
for(var i = 0; i < 200000000; i++){
	result = 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString2 || testNumber == testNumber2 || testObject == testObject2 || 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3 && 
	testString == testString3 && testNumber == testNumber3 && testObject == testObject3
}

console.log("==", Date.now() - start, result);

var start = Date.now();
var result = null;
for(var i = 0; i < 200000000; i++){
	result =
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString2 || testNumber === testNumber2 || testObject === testObject2 || 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3 && 
	testString === testString3 && testNumber === testNumber3 && testObject === testObject3
}
console.log("===", Date.now() - start, result);
var start = Date.now();
var alwaysTrue = true;
var alwaysFalse = false;
for(var i = 0; i < 200000000; i++){
	result = 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysFalse || alwaysFalse || alwaysFalse || 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue && 
	alwaysTrue && alwaysTrue && alwaysTrue
}
console.log("control test", Date.now() - start, result);

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

Во-вторых, во многих случаях == и === будут выполнять точно такие же действия. Когда типы двух операндов одинаковы (например, две строки или два числа), в спецификации ECMAScript есть точно такие же шаги для двух операторов. Поэтому, если вы наблюдаете разницу в производительности между двумя операторами для операндов одного и того же типа в одном браузере или в другой среде, нет ни гарантии, ни даже вероятности того, что вы увидите аналогичную разницу в другом браузере.

В случае typeof, как упоминалось в вашем вопросе, два операнда гарантированно будут одного типа (строки), и оба оператора будут делать одно и то же, поэтому единственные причины отдать предпочтение одному оператору над другим стилистические.

Сообщество JS в целом заняло довольно жесткую позицию в этом вопросе: похоже, что консенсус состоит в том, что «никогда не используйте == и !=, если вам не нужно принуждение типов», что, на мой взгляд, слишком догматично.

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

Это язык сценариев. Производительность этих операторов не должна иметь настолько большого значения, что вам следует об этом беспокоиться, потому что есть множество других вещей, которые потребляют гораздо больше энергии, например, тот факт, что он работает на виртуальной машине, - это слабая типизация, работает с HTML DOM внутри браузера ...

Кроме того, оба оператора делают разные вещи, поэтому в любом случае нельзя будет взаимозаменять один с другим.

Тем не менее, я думаю (но не тестировал), что === быстрее. Причина в том, что ему нужно только сравнить тип, и если он совпадает, сравнить необработанные данные. Оператор == попытается преобразовать один тип в другой, если они не совпадают. В большинстве случаев это будет более дорогостоящая операция.

И это к счастью, потому что в большинстве случаев === - лучший вариант. :)

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

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

Используйте ===, если у вас нет веских причин не делать этого (вероятно, нет).