Операторы == и === используются в JavaScript (и некоторых других языках) для сравнения значений, но они работают по-разному:

1. == — оператор нестрогого сравнения (abstract equality)

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

Основные правила работы ==:

• Если один из операндов — объект, а другой — примитив, то объект будет преобразован в примитив (вызовется valueOf() или toString()).

• Если один операнд — число, а другой — строка, строка будет приведена к числу.

• Если один операнд — логическое значение (true или false), оно будет приведено к числу: true → 1, false → 0.

• null и undefined равны друг другу, но не равны ничему другому.

• NaN не равен ничему, включая самого себя.

• Символы (Symbol) не приводятся к примитивам при сравнении, и любое сравнение с == возвращает false, кроме случая с самим собой.

Примеры:

0 == false // true → false приводится к 0

'0' == 0 // true → строка '0' становится числом 0

null == undefined // true → это исключение в спецификации

' \t\n' == 0 // true → пробельная строка становится 0

[] == false // true → [] → '' → 0, false → 0

[1] == 1 // true → [1] → '1' → 1

[1,2] == '1,2' // true → массив → строка

[] == '' // true → [] → '' (toString)

{} == '[object Object]' // false → объект не приводит себя к строке явно

2. === — оператор строгого сравнения (strict equality)

Оператор === не приводит типы. Он возвращает true только если оба операнда одного типа и имеют одинаковое значение.

Правила работы ===:

• Если типы различаются — возвращается false.

• Если типы одинаковые — возвращается результат сравнения по значению:

  • Числа сравниваются по значению, за исключением NaN, который никогда не равен даже самому себе.

  • Строки сравниваются посимвольно.

  • Объекты сравниваются по ссылке: два объекта равны только если они указывают на одну и ту же область в памяти.

  • null и undefined не равны друг другу.

  • Булевы значения сравниваются напрямую.

  • Символы (Symbol) сравниваются по идентичности.

Примеры:

0 === false // false → разные типы: number vs boolean

'0' === 0 // false → string vs number

null === undefined // false → разные типы

[] === false // false → массив vs boolean

[1] === 1 // false → объект vs number

'hello' === 'hello' // true → строки одинаковы

[] === [] // false → разные объекты (разные ссылки)

obj === obj // true → сравнение по ссылке

NaN === NaN // false → специфика IEEE-754

3. Типы приведения, которые происходят при ==

Для полного понимания поведения ==, стоит рассмотреть, как именно работает приведение типов. Вот некоторые шаги, которые JavaScript предпринимает:

• Если типы совпадают, просто выполняется обычное сравнение.

• Если одно значение — null, а другое — undefined, возвращается true.

• Если один — число, а другой — строка, строка приводится к числу.

• Если один — логическое значение, оно преобразуется в число.

• Если один — объект, а другой — строка, число или символ, объект приводится к примитиву с помощью ToPrimitive.

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

const obj = {

toString() {

return '42';

},

valueOf() {

return 100;

}

};

obj == 42 // true → valueOf вернул 100, но toString вернул '42', сравнивается со строкой

4. Сравнение объектов

Сравнение объектов через == и === всегда работает по ссылке, а не по содержимому.

const a = { x: 1 };

const b = { x: 1 };

a == b // false → разные ссылки

a === b // false → те же ссылки

const c = a;

a === c // true → одна и та же ссылка

5. Поведение с массивами

Массивы в JavaScript — это объекты. При сравнении с примитивом они сначала приводятся к строке (результат метода toString()), а затем сравниваются:

\[1\] == '1' // true → \[1\] → '1', строки равны

\[1,2\] == '1,2' // true → \[1,2\] → '1,2', строки равны

\[\] == '' // true → \[\] → '', строки равны

\[\] == 0 // true → \[\] → '' → 0

А вот сравнение массивов между собой:

\[\] === \[\] // false → разные ссылки

\[1,2\] === \[1,2\]// false → разные объекты

6. Особое поведение null и undefined

Это одно из немногих исключений, где == возвращает true, несмотря на разные типы.

null == undefined // true

null === undefined // false

null == 0 // false

undefined == 0 // false

7. Сравнение с NaN

С NaN нужно быть особенно внимательным:

NaN == NaN // false

NaN === NaN // false

isNaN(NaN) // true

Object.is(NaN, NaN) // true → новый способ сравнения с ES6

NaN — единственное значение в JavaScript, которое не равно самому себе.

8. Когда использовать ==, а когда ===

Хотя этот вопрос можно считать субъективным и зависящим от предпочтений, в большинстве современных проектов рекомендуется всегда использовать ===, чтобы избежать неожиданных результатов из-за приведения типов. Использование == обычно требует точного понимания механизма приведения и часто приводит к багам.

9. Техническое сравнение — спецификация ECMAScript

• \== использует алгоритм Abstract Equality Comparison.

• \=== использует алгоритм Strict Equality Comparison.

• Эти алгоритмы определены в спецификации ECMAScript (ECMA-262) и подробно описывают поведение шаг за шагом.

Если кратко: == пытается быть «умным» и угадывать, чего вы хотите, а === требует, чтобы вы были точны.