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

Операторы сравнения <, >, <= и >= возвращают значение типа boolean: true или false. С ними всё как в школе: 3 < 5 верно, а 5 >= 7 нет. С равенством интереснее. Его в JavaScript проверяют двумя операторами, и на одних и тех же значениях они могут ответить по-разному:

console.log(3 < 5); // true
console.log(5 >= 7); // false
console.log(5 === 5); // true
console.log("5" === 5); // false
console.log("5" == 5); // true

Последние две строки сравнивают строку "5" с числом 5. Оператор === отвечает «не равны», а == отвечает «равны».

Чтобы понять, почему так, представьте кассу в обменном пункте. Значения разных типов похожи на деньги в разных валютах: строка "5" — это пять рублей, а число 5 — пять долларов. Сравнить их можно двумя способами, и для каждого в JavaScript есть свой оператор.

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

Оператор === называют строгим равенством. Он похож на строгого кассира, который сравнивает и валюту, и сумму. Пять рублей для него не равны пяти долларам, хотя цифра одна.

Правило такое: === даёт true, только когда у значений один тип и одно значение. Для двух чисел это обычное равенство: 2 + 2 === 4 даёт true.

Что из этого следует:

• строка и число — разные типы, поэтому "5" === 5 даёт false;
• по той же причине null === undefined тоже false;
• оператор !== отвечает наоборот: "5" !== 5 даёт true.

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

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

Курс обмена у == свой. Строку и boolean он превращает в число:

• строка "5" становится числом 5;
• пустая строка становится 0;
• true становится 1, а false становится 0.

console.log(0 == "", true == 1); // true true
console.log(null == undefined, null === undefined); // true false
console.log(null == 0); // false

Давайте разберём программу по строкам:

1. 0 == "" даёт true, потому что пустая строка превратилась в 0; true == 1 даёт true, потому что true стал 1.
2. null == undefined даёт true, а строгое null === undefined даёт false.
3. null == 0 даёт false, хотя null и ноль оба похожи на «ничего».

Для null и undefined действует отдельное правило: через == они равны друг другу и больше ничему. Поэтому null == 0 даёт false. Оператор != — отрицание ==: "5" != 5 даёт false.

Здесь аналогия с обменником перестаёт работать. У настоящего обменника один курс для всех, а у == для каждой пары типов своё правило, и null в обмене не участвует вовсе.

Особый случай: NaN

Ещё один особый случай — NaN. Это значение не равно ничему, даже самому себе: и NaN === NaN, и NaN == NaN дают false. Поэтому узнать, лежит ли в переменной NaN, через сравнение нельзя.

Какой оператор выбрать

Правила приведения в == трудно держать в голове, поэтому в коде сравнивают через === и !==. Тогда строка никогда не окажется равна числу.

Разницу между == и === часто спрашивают на собеседовании. Хороший ответ состоит из трёх частей:

• === сравнивает тип и значение и ничего не превращает;
• == при разных типах сначала приводит значения к одному типу, обычно к числу;
• поэтому в коде пишут === и !==, а результаты == часто предсказывают неверно.

Частая ошибка

Пустую строку сравнивают с нулём через ==, чтобы проверить, ввёл ли человек число 0:

const input = "";
console.log(input == 0); // ✗

Программа печатает true, хотя в строке нет ни одной цифры: == превратил "" в 0. По той же причине false == 0 тоже даёт true. Строгое сравнение input === 0 даёт false, потому что строка не равна числу.

Главное

• === даёт true, только когда совпадают и тип, и значение; !== отвечает наоборот.
• == при разных типах сначала приводит значения к одному типу: "5" == 5 и 0 == "" дают true.
• null и undefined через == равны только друг другу, а NaN не равен даже себе.
• В коде сравнивают через === и !==.