== vs === в JavaScript: сравнение и приведение типов простыми словами

Один из самых частых вопросов новичков: в чём разница между == и === в JavaScript и когда какой оператор использовать? Неправильное сравнение ведёт к багам, особенно на границе типов (строки/числа, null/undefined, объекты). В статье — практическое руководство с примерами, анти‑паттернами и коротким чек‑листом.

Почему вообще два оператора равенства?

== — «нестрогое» равенство. Перед сравнением движок приводит операнды к общему типу. === — «строгое» равенство: значения сравниваются без приведения типов. Для объектов обе операции проверяют ссылку, а не содержимое.

console.log(2 == '2');      // true (строка приводится к числу)
console.log(2 === '2');     // false (разные типы)
console.log(true == 1);     // true
console.log(true === 1);    // false

Рекомендация по умолчанию: используйте === и !==. Исключения — осознанные и редкие.

Короткие правила, которые экономят время

• Почти всегда используйте === и !==.
• == уместен в одном практичном приёме: value == null проверяет сразу null или undefined.
• С объектами сравнивайте ссылки (===) или делайте явную проверку полей.
• Для NaN используйте Number.isNaN или Object.is, а не ===.

Опасные места с неявным приведением (==)

Вот примеры, из‑за которых баги прячутся годами:

console.log('' == 0);            // true
console.log('0' == 0);           // true
console.log(false == 0);         // true
console.log([] == 0);            // true (массив -> '' -> 0)
console.log([0] == 0);           // true
console.log('\n\t' == 0);       // true (пробелы -> '' -> 0)
console.log(null == undefined);  // true (особое правило)

Эти преобразования редко желательны. Если вы ожидаете число — приводите к числу явно и отдельно валидируйте.

null и undefined: особые правила

null и undefined равны друг другу только при == и не равны ничему другому. При сравнении <, >, <=, >= они ведут себя по‑разному:

console.log(null >= 0);    // true (null -> 0)
console.log(null > 0);     // false
console.log(undefined > 0); // false (undefined -> NaN)
console.log(undefined == 0); // false

// Удобный паттерн: проверить на «не задано»
const v = undefined;
if (v == null) {            // true, если null или undefined
  console.log('значение отсутствует');
}

Объекты и ссылки: почему {} === {} даёт false

Сравнение объектов — это сравнение ссылок. Два одинаковых литерала — разные объекты, следовательно, не равны.

console.log({} === {});         // false
const a = {}; const b = a;
console.log(a === b);           // true (одна ссылка)

// Даты: сравнивайте по числовому значению времени
const d1 = new Date('2025-01-01');
const d2 = new Date('2025-01-01');
console.log(d1.getTime() === d2.getTime()); // true

Если нужно сравнить содержимое простых объектов «поверхностно», можно сделать небольшой хелпер:

const isShallowEqual = (a, b) => {
  if (a === b) return true;
  if (a && b && typeof a === 'object' && typeof b === 'object') {
    const ka = Object.keys(a);
    const kb = Object.keys(b);
    if (ka.length !== kb.length) return false;
    return ka.every(k => Object.is(a[k], b[k]));
  }
  return false;
};

Глубокая проверка равенства — отдельная задача: рекурсия, сравнение массивов, карт, сетов, дат и т. д.

NaN, -0 и Object.is

NaN — единственное число, которое не равно самому себе. Также 0 и -0 равны по ===, хотя математически отличимы. Для таких случаев есть Object.is.

console.log(NaN === NaN);        // false
console.log(Number.isNaN(NaN));  // true (верный способ)
console.log(Object.is(0, -0));   // false
console.log(Object.is(NaN, NaN)); // true

Строки vs числа и сортировка

Операторы <, > для строк сравнивают лексикографически, а не как числа:

console.log('12' < '2'); // true (сравнение по символам)
console.log(12 < 2);     // false (численно)

// Сортировка чисел
[10, 2, 1].sort();              // [1, 10, 2] — строковая сортировка
[10, 2, 1].sort((a, b) => a - b); // [1, 2, 10] — числовая

Если получаете числа из инпутов/URL, приводите их явно и проверяйте корректность:

const input = ' 42 ';
const num = Number(input.trim());
if (Number.isFinite(num)) {
  console.log(num >= 18 ? 'ok' : 'too young');
} else {
  console.log('Некорректное число');
}

BigInt и сравнение

BigInt позволяет безопасно работать с большими целыми. Сравнение имеет нюансы:

console.log(1n == 1);      // true (нестрогое сравнение)
console.log(1n === 1);     // false (разные типы)
console.log(9007199254740993n > 9007199254740992); // true
// Смешивать BigInt и Number в арифметике нельзя:
// 1n + 1 // TypeError

В нестрогих сравнениях BigInt и Number могут быть равны при одинаковом целочисленном значении, но в строгих — никогда.

Практические рецепты

• Проверка «не задано» (null или undefined):

  if (value == null) {...}

• Явно приводите тип ввода:

  const n = Number(s); if (!Number.isFinite(n)) throw new Error('bad');

• Строки сравнивайте одним регистром:

  a.localeCompare(b, 'ru', { sensitivity: 'base' })

• Дата vs дата:

  +date1 === +date2

  или

  date1.getTime() === date2.getTime()

• Проверка пустого объекта:

  Object.keys(obj).length === 0

• NaN:

  Number.isNaN(x)

  , не

  x === NaN

Частые ошибки и как их избежать

• Использовать == без необходимости — ловушка. Предпочитайте ===.
• Сравнивать объекты/массивы «по содержимому» через === — получите false. Нужна отдельная проверка.
• Сортировать числа без компаратора — приведёт к строковой сортировке.
• Сравнивать строки как числа — приводите к Number заранее.
• Забывать про NaN и -0 — используйте Number.isNaN и при необходимости Object.is.

Куда двигаться дальше

Если хотите системно прокачать основы, практиковаться на задачах и закрепить понимание типов данных, приведений и сравнений, посмотрите подробную программу и бесплатные уроки: Прокачать основы JavaScript на практическом курсе «с Нуля до Гуру 2.0». Курс помогает выстроить правильные привычки и избежать типичных ошибок уже на старте.

Итог: используйте строгие сравнения по умолчанию, приводите типы явно, держите под рукой правила для null/undefined и NaN — и большинство «магических» багов просто исчезнут.