Чем отличается == от === в JavaScript? Когда использовать каждый оператор?

Основное различие: строгое и нестрогое сравнение

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

Другими словами:

• === — спросит: "Это одно и то же значение и одного ли они типа?"
• == — спросит: "Можно ли как-то сделать так, чтобы эти значения стали равны?"

Как работает === (строгое равенство)

Оператор === не выполняет никаких преобразований типов. Если типы операндов разные, он сразу возвращает false. Если типы совпадают, он сравнивает значения.

// Примеры с ===
console.log(5 === 5);      // true (число и число, значения равны)
console.log(5 === "5");    // false (разные типы: число vs строка)
console.log(0 === false);  // false (разные типы: число vs boolean)
console.log(null === null); // true (оба null)
console.log(undefined === undefined); // true (оба undefined)
console.log(null === undefined); // false (разные типы)
console.log(NaN === NaN);  // false! (NaN не равен самому себе — особенность JS)

Как работает == (нестрогое равенство)

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

1. Сравнение числа и строки: строка преобразуется в число.
2. Сравнение boolean с чем-либо: true становится 1, false становится 0.
3. Сравнение null и undefined: они равны только друг другу (и сами себе).
4. Сравнение объектов: объекты преобразуются в примитивы через valueOf или toString.

// Примеры с ==
console.log(5 == "5");        // true (строка "5" стала числом 5)
console.log(0 == false);      // true (false стал числом 0)
console.log(1 == true);       // true (true стал числом 1)
console.log("" == false);     // true (пустая строка -> 0, false -> 0)
console.log(null == undefined); // true (специальное правило)
console.log(null == 0);       // false (null не преобразуется в 0!)
console.log([] == false);     // true (пустой массив -> "" -> 0, false -> 0)

Почему это проблема?

Неявное преобразование типов в == может привести к трудноуловимым багам. Например:

// Опасный пример
let value = "0";
if (value == false) {
    console.log("Это выполнится!"); // Строка "0" == false -> true!
}

// Безопасный вариант
if (value === false) {
    console.log("Это НЕ выполнится"); // Разные типы
}

Когда что использовать?

Правило большого пальца: всегда используйте ===, если у вас нет специальной причины использовать ==. На практике === нужен в 99% случаев.

Исключения, когда == может быть полезен:

• Проверка на null или undefined: if (value == null) — это то же самое, что if (value === null || value === undefined).
• Некоторые библиотеки (например, jQuery) используют == для проверки наличия элемента.

Важно: Многие линтеры (например, ESLint) и руководства по стилю (например, Airbnb) запрещают использование == и требуют только ===. Это хорошая привычка — использовать строгое равенство.

Наглядная таблица

Сравнение        |  ==   |  ===
-----------------|-------|-------
5 == "5"         | true  | false
0 == false       | true  | false
"" == false      | true  | false
null == undefined| true  | false
null == 0        | false | false
NaN == NaN       | false | false

Запомните главное: === — это безопасный выбор, который защищает вас от неожиданного поведения. Используйте его по умолчанию.

if (value != null) { ... } // Плохо

if (value !== null && value !== undefined) { ... } // Хорошо
// или короче:
if (value != null) { ... } // Единственный случай, когда == оправдан

console.log(0.1 + 0.2 === 0.3); // false! (0.30000000000000004)