JavaScript предоставляет три оператора сравнения величин:

  • равенство ("двойное равно") использует ==,
  • строгое равенство (или "тройное равно" или "идентично") использует ===,
  • и Object.is (новшество из ECMAScript 6).

Выбор оператора зависит от типа сравнения, которое необходимо произвести.

В общих чертах, двойное равно перед сравнением величин производит приведение типов; тройное равно сравнивает величины без приведения (если величины разных типов, вернет false, даже не сравнивая); ну и Object.is ведет себя так же, как и тройное равно, но со специальной обработкой для NaN, -0 и +0, возвращая false при сравнении  -0 и +0, и true для операции Object.is(NaN, NaN). (В то время как двойное или тройное равенство вернут false согласно стандарту IEEE 754.) Следует отметить, что все эти различия в сравнениях применимы лишь для примитивов. Для любых не примитивных объектов x и y, которые имеют одинаковые структуры, но представляют собой два отдельных объекта (переменные x и y не ссылаются на один и тот же объект), все операторы сравнения вернут false.

Сравнение с использованием ==

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

В следующей таблице  приведены результаты сравнения оператора равенства для различных значений:

  Операнд B
    Undefined Null Number String Boolean Object
Операнд A

Undefined

true true false false false false
Null true true false false false false
Number false false A === B A === ToNumber(B) A === ToNumber(B) A == ToPrimitive(B)
String false false ToNumber(A) === B A === B ToNumber(A) === ToNumber(B) A == ToPrimitive(B)
Boolean false false ToNumber(A) === B ToNumber(A) === ToNumber(B) A === B ToNumber(A) == ToPrimitive(B)
Object false false ToPrimitive(A) == B ToPrimitive(A) == B ToPrimitive(A) == ToNumber(B) A === B

В таблице выше, ToNumber(A) пытается перед сравнением привести свой аргумент к числу. Такое поведение эквивалентно +A (унарный оператор +).  Если ToPrimitive(A) получает объект в качестве аргумента, то производятся попытки привести его к примитиву, вызывая на нем методы A.toString и A.valueOf.

Традиционно (и в соответствии с ECMAScript), ни один из объектов не равен undefined или null.  Но большинство браузеров позволяет определенному классу объектов (в частности, объектам document.all для любой страницы) эмулировать значение undefined.  Оператор равенства вернёт значение true для null == A и undefined == A, тогда, и только тогда, когда объект эмулирует значение undefined. Во всех остальных случаях объект не может быть равен undefined или null.

var num = 0;
var obj = new String("0");
var str = "0";
var b = false;

console.log(num == num); // true
console.log(obj == obj); // true
console.log(str == str); // true

console.log(num == obj); // true
console.log(num == str); // true
console.log(obj == str); // true
console.log(null == undefined); // true

// оба false, кроме очень редких случаев
console.log(obj == null);
console.log(obj == undefined);

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

Строгое равенство с использованием ===

Строгое равно проверяет на равенство две величины, при этом тип каждой из величин перед сравнением не изменяется (не приводится). Если значения имеют различающиеся типы, то они не могут быть равными. С другой стороны все не числовые переменные, принадлежащие одному типу, считаются равными между собой, если содержат одинаковые величины. Ну и, наконец, числовые переменные считаются равными, если они имеют одинаковые значения, либо одна из низ +0, а вторая -0. В то же время, если хотя бы одна из числовых переменных содержит значение NaN, выражение вернет false.

var num = 0;
var obj = new String("0");
var str = "0";
var b = false;

console.log(num === num); // true
console.log(obj === obj); // true
console.log(str === str); // true

console.log(num === obj); // false
console.log(num === str); // false
console.log(obj === str); // false
console.log(null === undefined); // false
console.log(obj === null); // false
console.log(obj === undefined); // false

Практически всегда для сравнения следует использовать оператор строгого равенства. Для всех значений, за исключением числовых используется очевидная семантика: величина равна только сама себе. Как было сказано выше для числовых типов можно выделить два особых случая. Во-первых, сравнение +0 и -0. Знак для нуля введен для упрощения некоторых вычислений с плавающей запятой, однако, с точки зрения математики, разницы между +0 и -0 не существует, поэтому оператор строгого равенства считает их равными. Во-вторых, сравнение величин NaN. NaN (Not a number) представляет из себя значение не определенной величины, которое применяется для не четко определенных математических задач (например +∞ + -∞). Для оператора строго равенства NaN не равен ни одной из величин, в том числе и самому себе (единственный случай, когда (x!==x) вернет true).

Равенство одинаковых величин

Равенство одинаковых величин определяет функциональную идентичность во всех контекстах сравниваемых величин. (Данный способ сравнения основывается на принципе подстановки Барбары Лисков.) Рассмотрим пример попытки изменения неизменяемого (immutable) свойства:

// Добавление неизменяемого свойства NEGATIVE_ZERO (отрицательный ноль) в конструктор Number.
Object.defineProperty(Number, "NEGATIVE_ZERO",
                      { value: -0, writable: false, configurable: false, enumerable: false });

function attemptMutation(v)
{
  Object.defineProperty(Number, "NEGATIVE_ZERO", { value: v });
}

При попытке изменения неизменяемого свойства, вызов Object.defineProperty выбросит исключение, однако, если новое свойство равняется старому, изменений не произойдет и исключение не будет выброшено. Если v содержит -0, изменений не произойдет, а значит, код отработает без выброса исключений. Однако, если же v содержит +0, Number.NEGATIVE_ZERO утратит свою неизменяемую величину. Именно для сравнения нового и текущего неизменяемых свойств используется сравнение одинаковых величин, представленное методом Object.is.

Спецификации для равенства, строгого равенства и равенства одинаковых величин

В стандарте ES5, сравнение выполняемое оператором == описывается в секции 11.9.3, The Abstract Equality Algorithm. Описание оператора === находится в секции 11.9.6, The Strict Equality Algorithm. В секции 9.12, The SameValue Algorithm ES5  описывает операцию сравнение одинаковых величин для внутреннего движка  JS. Строгое равенство и равенство одинаковых величин, практически одинаковы, за исключением обработки числовых типов. ES6 предлагает использовать алгоритм сравнения одинаковых величин через вызов Object.is.

Как понимать все эти способы сравнения?

До выхода редакции ES6 считалось, что оператор строгого равенства просто "улучшенная" версия оператора нестрогого равенства. Например, некоторые считали, что == просто улучшенная версия === потому, что первый оператор делает всё то же, что и второй, плюс приведение типов своих операндов. То есть 6 == "6". (Или же наоборот: оператор нестрогого равенства базовый, а оператор строгого равенства просто его улучшенная версия, ведь он добавляет ещё одно условие - требует, чтобы оба операнда были одного и того же типа. Какой вариант ближе вам, зависит только от вашей точки зрения на вещи.)

Но эти точки зрения уже нельзя применить к новому методу сравнения Object.is из новой редакции ES6. Нельзя сказать, что Object.is более или менее строже существующих равенств, или что это нечто среднее. Ниже в таблице показаны основные различия операторов сравнения. Object.is интересен тем, что различает -0 и +0, а также умеет сравнивать два нечисла NaN.

Сравнительная таблица операторов сравнения
x y == === Object.is
undefined undefined true true true
null null true true true
true true true true true
false false true true true
"foo" "foo" true true true
{ foo: "bar" } x true true true
0 0 true true true
+0 -0 true true false
0 false true false false
"" false true false false
"" 0 true false false
"0" 0 true false false
"17" 17 true false false
[1,2] "1,2" true false false
new String("foo") "foo" true false false
null undefined true false false
null false false false false
undefined false false false false
{ foo: "bar" } { foo: "bar" } false false false
new String("foo") new String("foo") false false false
0 null false false false
0 NaN false false false
"foo" NaN false false false
NaN NaN false false true

Когда же использовать Object.is ?

Особенность обработки Object.is нулей будет полезна в метапрограммировании, когда необходимо присвоить противоположное значение свойству через дескриптор Object.defineProperty. Если ваши задачи этого не требуют, то лучше воздержаться от использования Object.is, отдав предпочтение ===. Даже если в коде необходимо сравнивать два NaN, обычно проще всего использовать существующий метод isNaN, чтобы последующие вычисления не влияли на сравнение нулей с разными знаками.

Вот примеры операторов и методов, которые могут сделать различия между  -0 и +0 более явными, что непременно отразиться в вашем коде:

- (унарный минус)

Очевидно, что применение унарного минуса к нулю даст -0. Но, иногда, это происходит совершенно незаметно. К примеру:

let stoppingForce = obj.mass * -obj.velocity

Если значением obj.velocity будет 0, то результатом выражения будет -0, что в итоге отразится в переменной stoppingForce.

Math.atan2
Math.ceil
Math.pow
Math.round
Есть вероятность, что данные методы могут возвратить -0, даже если его не передавали явно одним из параметров. Например, если методом Math.pow возвести -Infinity в любую отрицательную степень. Ознакомьтесь с подробным описанием данных методов.
Math.floor
Math.max
Math.min
Math.sin
Math.sqrt
Math.tan
В некоторых случаях можно получить результат, равный -0, если вышеперечисленным методам одним из параметров передать -0. Например, Math.min(-0, +0) вернёт -0. Ознакомьтесь с подробным описанием данных методов.
~
<<
>>
Каждый из этих операторов использует внутренний алгоритм ToInt32. В нём нет места для отрицательного нуля, потому значение -0 не переживёт подобной операции. То есть и Object.is(~~(-0), -0), и Object.is(-0 << 2 >> 2, -0) возвратят false.

Из вышеперечисленного ясно, что использование Object.is иногда может быть проблемным. Естественно, если вам необходимо чётко различать -0 и +0, то этот метод именно то, что нужно.

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

Метки документа и участники

 Внесли вклад в эту страницу: Zarwlar, Saviloff, Witadol
 Обновлялась последний раз: Zarwlar,