Участвует ли неявное преобразование типов при сравнении через == или ===

Краткий ответ

Нет, неявное преобразование типов происходит только при использовании оператора свободного равенства (==), но не происходит при использовании оператора строгого равенства (===). Это ключевое различие между двумя операторами в JavaScript, и оно напрямую влияет на предсказуемость кода и является причиной, почему === настоятельно рекомендуется к использованию.

---

Подробное объяснение

Оператор строгого равенства (===)

Этот оператор сравнивает два значения без какого-либо преобразования типов. Он проверяет:

1. Совпадение типов (typeof). Если типы разные, сравнение сразу возвращает false.
2. Совпадение значений (для примитивов) или ссылки на один и тот же объект в памяти (для объектов, включая массивы и функции).

console.log(5 === 5);        // true (одинаковый тип number, одинаковое значение)
console.log(5 === '5');      // false (разные типы: number vs string, преобразование НЕ применяется)
console.log(true === 1);     // false (разные типы: boolean vs number)
console.log(null === undefined); // false (разные типы: null vs undefined)
console.log({} === {});      // false (два разных объекта в памяти)

При === неявного преобразования типов НЕТ. Сравнение "как есть".

Оператор свободного равенства (==)

Этот оператор перед сравнением выполняет неявное преобразование типов (Type Coercion), чтобы привести операнды к общему типу. Алгоритм сложный и описан в спецификации ECMAScript, но логику можно свести к нескольким правилам.

console.log(5 == 5);         // true
console.log(5 == '5');       // true! Строка '5' неявно преобразуется в число 5.
console.log(true == 1);      // true! Boolean true преобразуется в число 1.
console.log(null == undefined); // true! Особое правило языка.
console.log('' == false);    // true! И пустая строка, и false преобразуются к 0.
console.log([] == false);    // true! Массив преобразуется в строку '', затем в число 0.

Алгоритм преобразований == (упрощённо)

Когда типы операндов разные, JavaScript применяет следующие правила по порядку:

1. Если один операнд null, а другой undefined, возвращает true.

   null == undefined // true
   

2. Если один операнд — число, а другой — строка, строка преобразуется в число.

   10 == '10' // '10' -> 10, затем 10 == 10 → true
   

3. Если один из операндов — boolean, он сначала преобразуется в число (true → 1, false → 0), а затем применяются остальные правила.

   true == '1' // true -> 1, затем 1 == '1' -> '1' -> 1, 1 == 1 → true
   

4. Если один операнд — объект (включая массив или функцию), а другой — примитив, то объект преобразуется к примитиву. Обычно это делается через вызов методов valueOf() и toString().

   [5] == 5 // [5].toString() -> '5', затем '5' -> 5, 5 == 5 → true
   

Пример сложного преобразования:

[] == ![] // true
// 1. ![] вычисляется. ! (логическое НЕ) преобразует массив в boolean.
//    [] — это truthy значение, поэтому ![] -> false.
// 2. Теперь сравнение: [] == false.
// 3. Правило для boolean: false преобразуется в число 0. Сравнение: [] == 0.
// 4. Правило для объекта (массива) и числа: массив преобразуется в примитив.
//    [].toString() возвращает пустую строку ''.
// 5. Теперь сравнение: '' == 0.
// 6. Правило для строки и числа: '' преобразуется в число 0.
// 7. Итог: 0 == 0 → true.

Почему рекомендуется всегда использовать ===?

• Предсказуемость: Код ведёт себя интуитивно понятно. Сравниваются именно те значения и типы, которые вы видите.
• Надёжность: Исключает целый класс трудноуловимых ошибок, связанных с неочевидным преобразованием.
• Производительность: Незначительно, но быстрее, так как не требует выполнения алгоритма преобразования.
• Соглашения и линтеры: Практически все руководства по стилю (ESLint с правилом eqeqeq) требуют использования строгого равенства.

Вывод

• === (строгое равенство): Не участвует в неявном преобразовании типов. Сравнивает и тип, и значение "как есть". Это безопасный и предпочтительный выбор в 99.9% случаев.
• == (свободное равенство): Участвует в неявном преобразовании типов по сложному алгоритму. Может приводить к неожиданным результатам, поэтому его использование должно быть крайне осознанным и, как правило, ограничиваться проверкой null == undefined.