Как сравниваются примитивы?

Сравнение примитивов в JavaScript

В JavaScript примитивы сравниваются по значению (by value), в отличие от объектов, которые сравниваются по ссылке (by reference). Это фундаментальное различие в поведении операторов сравнения == и ===.

Типы примитивов

К примитивным типам относятся:

• string
• number
• boolean
• null
• undefined
• symbol (ES6)
• bigint (ES2020)

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

Оператор строгого сравнения проверяет равенство типов и значений. Если типы разные, сравнение сразу возвращает false.

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

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

Оператор нестрогого сравнения выполняет преобразование типов (type coercion) перед сравнением значений. Это часто приводит к неочевидным результатам:

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

Особые случаи и подводные камни

Сравнение NaN

NaN (Not-a-Number) уникален тем, что не равен даже самому себе:

console.log(NaN === NaN);       // false
console.log(NaN == NaN);        // false

// Для проверки на NaN используйте:
console.log(isNaN(NaN));        // true
console.log(Number.isNaN(NaN)); // true (более надежный метод ES6)

Сравнение null и undefined

console.log(null === null);           // true
console.log(undefined === undefined); // true
console.log(null == undefined);       // true
console.log(null === undefined);      // false

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

При сравнении строки с числом происходит преобразование строки в число:

console.log('10' == 10);        // true
console.log('10e2' == 1000);    // true
console.log('0xFF' == 255);     // true

Сравнение с булевыми значениями

console.log(true == 1);         // true
console.log(false == 0);        // true
console.log(true == '1');       // true
console.log(false == '');       // true
console.log(false == []);       // true (объект преобразуется)

Сравнение BigInt

BigInt можно сравнивать только с другими BigInt:

console.log(10n === 10n);       // true
console.log(10n == 10n);        // true
console.log(10n == 10);         // true (нестрогое сравнение)
console.log(10n === 10);        // false (разные типы)

Особенности Symbol

Каждый Symbol уникален, даже если создан с одинаковым описанием:

const sym1 = Symbol('test');
const sym2 = Symbol('test');

console.log(sym1 === sym2);     // false
console.log(sym1 === sym1);     // true

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

1. Всегда используйте строгое сравнение (===) за исключением случаев, когда вам нужно нестрогое сравнение
2. Помните о специальных случаях сравнения: NaN !== NaN, null == undefined
3. Для сложных преобразований используйте явное приведение типов:

const num = Number('123');
const str = String(456);

1. При сравнении строк учитывайте регистр:

console.log('Hello' === 'hello'); // false
console.log('Hello'.toLowerCase() === 'hello'); // true

Производительность

Сравнение примитивов выполняется быстрее, чем сравнение объектов, так как не требует обхода свойств объектов и работает напрямую со значениями в памяти.

Понимание различий между сравнением примитивов и объектов критически важно для написания корректного JavaScript-кода и предотвращения трудноуловимых ошибок.