Выполнение сравнения с использованием оператора нестрогого равенства может привести к очень загадочным результатам.

Это может быть одна из самых загадочных и раздражающих вещей в JavaScript. Тайна в основном исчезает, как только вы понимаете, что правила, которые использует JavaScript, на самом деле довольно просты.

В JavaScript есть два типа операторов равенства:

  • оператор нестрогого равенства, также известный как оператор равенстваили "=="
  • оператор строгого равенства, также известный как оператор идентификации или "==="

Оператор строгого равенства возвращает true только если оба операнда являются одним и тем же объектом.

Когда оба операнда одного типа, == и === работают одинаково.

Рассмотрим два фрагмента кода ниже.

Когда я сравниваю операнды одного типа, которые являются разными объектами, === возвращает false (строка 11).

После того, как я переназначил переменной obj2 то же значение, на которое ссылается obj1, === вернул true (строка 17).

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

Теперь давайте посмотрим на сравнение строгого и нестрогого равенства с примитивами.

Опять же, когда оба операнда одного типа, == и === работают одинаково.

Все идет нормально. Вы можете спросить себя: «Зачем я это читаю? Мне все достаточно ясно». Совершенно справедливо!

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

Давайте рассмотрим некоторые из этих примеров более внимательно.

console.log('2' === 2); выходы false

Но

console.log('2' == 2); выходы true

Как это могло быть?

Когда я сравниваю строку с числом, используя оператор строгого равенства, я получаю false. Что правильно.

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

Когда JavaScript сравнивает два значения разных типов с помощью ==, он сначала пытается преобразовать их в один и тот же тип и только потом сравнивает.

При сравнении строки с числом он сначала преобразует строку в число, а затем сравнивает ее с числовым операндом.

Рассмотрим этот пример, где один из операндов является логическим значением:

console.log(1 === true);  // false
console.log(1 == true);  // true

Логический операнд сначала преобразуется в число и только потом сравнивается.

Числовой эквивалент false — 0, а числовой эквивалент true — 1.

Итак, эта линия

console.log(1 == true); // true

типа имеет смысл. true сначала преобразуется в 1, поэтому я получаю 1 == 1, который оценивается как true.

Чтобы избежать подобных странных результатов, лучше не сравнивать значения разных типов с помощью ==.

Если только у вас нет уважительной причины.

Следующее лучшее, что вы можете сделать, это всегда использовать ===.

Если вы должны или просто решили использовать нестрогий оператор равенства, вам могут помочь следующие правила:

  • Если строка сравнивается с числом с помощью==, строка преобразуется в число, а затем сравнивается
  • Если логическое значение представляет собой другое значение, используя==, логическое значение преобразуется в число, а затем сравнивается
  • Если объект сравнивается с примитивом, объект приводится к примитивному значению с помощью методов valueOf() и toString(), а затем сравнивается
  • Если undefined сравнить с null с помощью оператора нестрогого равенства, результат будет истинным.

Самая важная разница между == и ===, которую нужно помнить:

оператор строгого равенства (===) не пытается привести свои операнды к одному и тому же типу

Что касается ===, операнды равны только тогда, когда они ссылаются на один и тот же объект. Операнды разных типов всегда считаются разными.

Спасибо за чтение!