Операторы сравнения

=== и ==, сравнение строк, null и undefined — все подводные камни.

JSОператоры сравнения: ===, ==, truthy/falsy

=== строгое

Тип и значение должны совпадать

1 === 1✓ true

1 === "1"✗ false

null === undefined✗ false

0 === false✗ false

NaN === NaN✗ false

== нестрогое

Приводит типы перед сравнением

1 == "1"✓ truecoercion

0 == false✓ true

null == undefined✓ true

"" == false✓ true

null == 0✗ falsespecial!

Правило: всегда используй ===

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

Язык примеров:

Шаг 1 из 1Практика

Строгое === vs нестрогое ==

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

Сравнивает и значение, и тип. Приведения типов не происходит.

javascript

1 === 1         // true
1 === "1"       // false (разные типы)
0 === false     // false
null === undefined // false
NaN === NaN     // false (NaN ≠ NaN всегда!)

// Объекты сравниваются по ссылке:
{} === {}           // false (два разных объекта в памяти)
[] === []            // false
const a = [1,2,3];
const b = a;
a === b              // true (одна и та же ссылка)

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

Пытается привести операнды к одному типу перед сравнением:

javascript

1 == "1"         // true  ("1" → 1)
0 == false       // true  (false → 0)
0 == ""          // true  ("" → 0)
0 == "0"         // true  ("0" → 0)
"" == false      // true  (оба → 0)
null == undefined // true  (особый случай)
null == 0        // false (null не конвертируется)
null == false    // false

Правило: всегда используй === и !==. Единственное допустимое исключение:

javascript

// Проверить на null ИЛИ undefined одновременно:
if (value == null) {  // true когда value = null или undefined
  // эквивалентно: value === null || value === undefined
}

Сравнение строк

javascript

// Лексикографическое (по Unicode)
"a" < "b"    // true
"B" < "a"    // true (!) заглавные < строчных в Unicode
"abc" < "abd" // true (сравнение посимвольно)
"2" > "10"   // true (!) "2" > "1" лексикографически

// Для правильного сравнения строк — localeCompare:
"Я".localeCompare("А")  // 1 (Я после А)
["Яблоко", "Арбуз", "Банан"].sort((a, b) => a.localeCompare("ru"))

JavaScript

// Сравнение с NaN

NaN === NaN  // false
NaN !== NaN  // true
NaN > 0      // false
NaN < 0      // false
NaN == NaN   // false

// Единственный правильный способ проверить на NaN:
Number.isNaN(NaN)    // true
Number.isNaN(42)     // false
Number.isNaN("NaN")  // false (строка — не NaN)
isNaN("NaN")         // true  (глобальная isNaN приводит к числу)

// Безопасная функция для работы с числами:
function safeDiv(a, b) {
  if (b === 0) return null;
  const result = a / b;
  return Number.isFinite(result) ? result : null;
}

safeDiv(10, 2)  // 5
safeDiv(10, 0)  // null
safeDiv(0, 0)   // null

Что вернёт `"10" > "9"`?

Преобразование типов Условное ветвление: if и ?