Какое равенство строгое?

Равенство строгое и нестрогое в JavaScript

В JavaScript существует два оператора сравнения на равенство: строгое равенство (===) и нестрогое равенство (==).

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

Этот оператор проверяет, равны ли два значения и имеют ли они один и тот же тип. Никакого преобразования типов не выполняется.

console.log(5 === 5);          // true, одинаковые числа
console.log('5' === '5');      // true, одинаковые строки
console.log(5 === '5');        // false, разный тип (number vs string)
console.log(true === 1);       // false, разный тип (boolean vs number)
console.log(null === undefined); // false, разные типы
console.log(NaN === NaN);      // false, особый случай для NaN

Ключевые особенности строгого равенства:

• Сравнение происходит без приведения типов
• Чаще всего является предпочтительным выбором, так как поведение более предсказуемо
• Рекомендуется в большинстве руководств по стилю кода (например, ESLint правилом eqeqeq)
• Помогает избежать неявных ошибок, связанных с автоматическим преобразованием типов

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

Этот оператор сначала пытается привести значения к одному типу, а затем сравнивает их. Это называется "приведение типов" (type coercion).

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

Почему строгое равенство обычно лучше

1. Предсказуемость кода — вы точно знаете, что сравниваете
2. Избегание скрытых багов — не происходит неявных преобразований
3. Читаемость — другие разработчики сразу видят, что сравнение строгое
4. Производительность — в некоторых случаях работает быстрее, так как не требует преобразования типов

// Потенциально проблемный код с нестрогим равенством
const userInput = '0';
const validValues = [0, 1, 2];

// Неявное преобразование может привести к неожиданным результатам
console.log(userInput == 0);        // true
console.log(validValues.includes(parseInt(userInput))); // Лучший подход

Особые случаи и исключения

Даже при использовании строгого равенства есть нюансы:

// Особые случаи
console.log(+0 === -0);             // true
console.log(Object.is(+0, -0));     // false - для точного сравнения

// Сравнение объектов
const obj1 = {name: 'John'};
const obj2 = {name: 'John'};
const obj3 = obj1;

console.log(obj1 === obj2);         // false, разные ссылки
console.log(obj1 === obj3);         // true, одна и та же ссылка

// Значение NaN
console.log(NaN === NaN);           // false
console.log(Number.isNaN(NaN));     // true - правильный способ проверки

Практические рекомендации

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

• Когда вам осознанно нужно сравнение с приведением типов
• При работе с устаревшим кодом, который использует ==

В современном JavaScript с ESLint и статическим анализом кода можно настроить правило "eqeqeq": ["error", "always"], которое будет предупреждать об использовании нестрогого равенства.

Итог

Строгое равенство — это оператор ===, который сравнивает значения без приведения типов. Он обеспечивает более надежное и предсказуемое сравнение, что делает код менее подверженным ошибкам и более понятным для других разработчиков. В большинстве проектов его использование считается лучшей практикой.