В чём разница между == и === в JavaScript?

В чём разница между == и === в JavaScript?

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

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

=== проверяет равенство значений И их типов без выполнения каких-либо преобразований.

console.log(5 === 5);           // true — одинаковые значения и тип
console.log(5 === "5");         // false — значения совпадают, но типы разные
console.log(true === 1);        // false — boolean vs number
console.log(null === undefined); // false — разные типы
console.log(0 === false);       // false — number vs boolean
console.log("" === 0);         // false — string vs number

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

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

console.log(5 == "5");          // true — строка преобразуется в число
console.log(true == 1);         // true — boolean преобразуется в число
console.log(null == undefined); // true — специальное правило
console.log(0 == false);        // true — false преобразуется в 0
console.log("" == 0);          // true — пустая строка преобразуется в 0
console.log(" " == 0);         // true — строка пробела преобразуется в 0

Таблица сравнений == vs ===

Правила преобразования типов при ==

Когда используется ==, JavaScript применяет сложные и часто неинтуитивные правила преобразования:

// Преобразование строк в числа
console.log("10" == 10);    // true
console.log("10" == "10");  // true

// Преобразование boolean в число
console.log(true == 1);     // true
console.log(false == 0);    // true

// null и undefined имеют специальное правило
console.log(null == null);      // true
console.log(undefined == undefined); // true
console.log(null == undefined); // true — уникальный случай

// Объекты и массивы
console.log([1] == 1);      // true
console.log([1] == "1");    // true
console.log([] == 0);       // true
console.log([] == "");      // true

Опасные случаи с ==

// Эти результаты могут вызвать bugs
console.log(0 == "");       // true
console.log(0 == "0");      // true
console.log(" " == 0);      // true
console.log(null == 0);     // false — НО null == false; true!
console.log(undefined == 0); // false

// Самый странный случай
console.log(false == "");   // true
console.log(false == "0");  // true
console.log(false == []);   // true

Когда использовать каждый оператор

Всегда используй === — это правило номер один в современном JavaScript:

// ✅ ПРАВИЛЬНО — используй === везде
if (user.id === 5) {
  // ...
}

const isActive = status === 'active';
const isEmpty = array.length === 0;

if (value === null) {
  // Проверка именно на null, не на undefined или 0
}

// ❌ НЕПРАВИЛЬНО — избегай ==
if (user.id == 5) {
  // Может вызвать неожиданное поведение
}

if (value == null) {
  // Проверяет одновременно null и undefined
}

Правильная проверка на null/undefined

// Если нужно проверить ИМЕННО null
if (value === null) {
  console.log('Значение null');
}

// Если нужно проверить ИМЕННО undefined
if (value === undefined) {
  console.log('Значение undefined');
}

// Если нужно проверить null ИЛИ undefined
if (value === null || value === undefined) {
  console.log('Значение null или undefined');
}

// Или более современный способ (nullish coalescing)
const result = value ?? 'значение по умолчанию';

Почему === лучше

1. Предсказуемость — не нужно помнить все странные правила преобразования
2. Производительность — === работает быстрее, так как не выполняет преобразования
3. Безопасность — исключает класс ошибок, связанных с неожиданным приведением типов
4. Читаемость — явное сравнение типов делает код понятнее

Рекомендации от профессионалов

// ESLint правило для запрета ==
// Добавь в .eslintrc.json:
{
  "rules": {
    "eqeqeq": ["error", "always"]
  }
}

// Это гарантирует, что в коде будет использоваться только ===

Итог

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

Одно из основных правил чистого и надёжного JavaScript кода: используй === везде, где это возможно.