Равенство (==)

Оператор **равенства (==)** проверяет, равны ли два его операнда, возвращая логический результат. В отличие от оператора строгого равенства, он пытается преобразовать и сравнить операнды, имеющие разные типы.

Попробуйте

console.log(1 == 1);
// Expected output: true

console.log("hello" == "hello");
// Expected output: true

console.log("1" == 1);
// Expected output: true

console.log(0 == false);
// Expected output: true

Синтаксис

x == y

Описание

Операторы равенства (== и !=) предоставляют семантику IsLooselyEqual (нестрогое равенство). Это можно кратко изложить следующим образом:

1. Если операнды имеют одинаковый тип, они сравниваются следующим образом:
   • Object: возвращается true, только если оба операнда ссылаются на один и тот же объект.
   • String: возвращается true, только если оба операнда имеют одинаковые символы в том же порядке.
   • Number: возвращается true, только если оба операнда имеют одинаковое значение. +0 и -0 считаются одинаковыми значениями. Если любой операнд равен NaN, возвращается false; таким образом, NaN никогда не равен NaN.
   • Boolean: возвращается true, только если оба операнда являются true или оба являются false.
   • BigInt: возвращается true, только если оба операнда имеют одинаковое значение.
   • Symbol: возвращается true, только если оба операнда ссылаются на один и тот же символ.
2. Если один из операндов равен null или undefined, другой также должен быть null или undefined, чтобы вернуть true. В противном случае возвращается false.
3. Если один из операндов является объектом, а другой — примитивным значением, преобразуйте объект в примитив.
4. На этом шаге оба операнда преобразуются в примитивы (один из String, Number, Boolean, Symbol и BigInt). Остальная часть преобразования выполняется индивидуально:
   • Если они имеют одинаковый тип, сравните их, используя шаг 1.
   • Если один из операндов является Symbol, а другой — нет, возвращается false.
   • Если один из операндов является Boolean, а другой — нет, преобразуйте логическое значение в число: true преобразуется в 1, а false преобразуется в 0. Затем снова сравните два операнда нестрого.
   • Number в String: преобразуйте строку в число. Сбой преобразования приводит к NaN, что гарантирует, что равенство будет false.
   • Number в BigInt: сравнение по их математическому значению. Если число равно ±Infinity или NaN, возвращается false.
   • String в BigInt: преобразуйте строку в BigInt, используя тот же алгоритм, что и конструктор BigInt(). Если преобразование не удастся, возвращается false.

Нестрогое равенство симметрично: A == B всегда имеет идентичную семантику с B == A для любых значений A и B (за исключением порядка примененных преобразований).

Наиболее заметное различие между этим оператором и оператором строгого равенства (===) заключается в том, что оператор строгого равенства не пытается выполнять преобразование типов. Вместо этого оператор строгого равенства всегда считает операнды разных типов неравными. По сути, оператор строгого равенства выполняет только шаг 1, а затем возвращает false для всех остальных случаев.

Существует «умышленное нарушение» вышеуказанного алгоритма: если один из операндов равен document.all, он рассматривается как undefined. Это означает, что document.all == null является true, но document.all === undefined || document.all === null является false.

Примеры

Сравнение без преобразования типов

1 == 1; // true
"hello" == "hello"; // true

Сравнение с преобразованием типов

"1" == 1; // true
1 == "1"; // true
0 == false; // true
0 == null; // false
0 == undefined; // false
0 == !!null; // true, look at Logical NOT operator
0 == !!undefined; // true, look at Logical NOT operator
null == undefined; // true

const number1 = new Number(3);
const number2 = new Number(3);
number1 == 3; // true
number1 == number2; // false

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

const object1 = {
  key: "value",
};

const object2 = {
  key: "value",
};

console.log(object1 == object2); // false
console.log(object1 == object1); // true

Сравнение строк и объектов String

Обратите внимание, что строки, созданные с помощью new String(), являются объектами. Если вы сравните один из них со строковым литералом, объект String будет преобразован в строковый литерал, и содержимое будет сравниваться. Однако, если оба операнда являются объектами String, то они сравниваются как объекты и должны ссылаться на один и тот же объект, чтобы сравнение было успешным:

const string1 = "hello";
const string2 = String("hello");
const string3 = new String("hello");
const string4 = new String("hello");

console.log(string1 == string2); // true
console.log(string1 == string3); // true
console.log(string2 == string3); // true
console.log(string3 == string4); // false
console.log(string4 == string4); // true

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

const d = new Date("1995-12-17T03:24:00");
const s = d.toString(); // for example: "Sun Dec 17 1995 03:24:00 GMT-0800 (Pacific Standard Time)"
console.log(d == s); // true

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

const a = [1, 2, 3];
const b = "1,2,3";
a == b; // true, `a` converts to string

const c = [true, 0.5, "hey"];
const d = c.toString(); // "true,0.5,hey"
c == d; // true

Спецификации

Совместимость с браузерами

Смотрите также

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