Object.is() - метод для точного сравнения значений в JavaScript

Object.is() сравнивает два значения и возвращает true или false.

На первый взгляд он похож на ===, но работает чуть точнее в двух особых случаях:

NaN
+0 и -0

Синтаксис

Object.is(value1, value2)

Метод принимает два значения и возвращает результат сравнения.

Что делает Object.is()

Если значения считаются одинаковыми, метод вернёт true.

console.log(Object.is(10, 10));         // true
console.log(Object.is("js", "js"));     // true
console.log(Object.is(true, true));     // true
console.log(Object.is(10, 20));         // false

Что возвращает Object.is()

Object.is() всегда возвращает булево значение:

true, если значения считаются одинаковыми
false, если значения разные

console.log(Object.is("a", "a")); // true
console.log(Object.is("a", "b")); // false

Object.is() и ===

В большинстве обычных случаев результат у Object.is() и === будет одинаковым.

console.log(Object.is(5, 5)); // true
console.log(5 === 5);         // true

console.log(Object.is("a", "b")); // false
console.log("a" === "b");         // false

Но есть два важных исключения.

NaN и Object.is()

Через === значение NaN не равно даже самому себе:

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

А вот Object.is() считает их одинаковыми:

console.log(Object.is(NaN, NaN)); // true

Это один из главных случаев, ради которых и вспоминают этот метод.

+0 и -0

Через === значения +0 и -0 считаются равными:

console.log(+0 === -0); // true

А Object.is() различает их:

console.log(Object.is(+0, -0)); // false
console.log(Object.is(0, -0));  // false
console.log(Object.is(0, 0));   // true

Это второй важный нюанс метода.

С объектами сравнение по ссылке

Object.is() не делает глубокого сравнения объектов.

Он, как и ===, сравнивает ссылки.

const a = { name: "Anna" };
const b = { name: "Anna" };
const c = a;

console.log(Object.is(a, b)); // false
console.log(Object.is(a, c)); // true

На вид a и b одинаковые, но это разные объекты в памяти.

С массивами то же самое

Для массивов правило такое же: сравнивается ссылка, а не содержимое.

console.log(Object.is([1, 2], [1, 2])); // false

const arr = [1, 2];

console.log(Object.is(arr, arr)); // true

Object.is() и ==

== делает неявные преобразования типов.

Object.is() никаких таких преобразований не делает.

console.log(1 == "1");            // true
console.log(Object.is(1, "1"));   // false

Поэтому Object.is() намного строже и предсказуемее.

Когда это полезно

Object.is() удобно использовать, когда:

нужно корректно сравнить NaN
важно отличать +0 и -0
нужен более точный вариант сравнения, чем ===

Пример:

const value = NaN;

if (Object.is(value, NaN)) {
  console.log("Это NaN");
}

Когда обычного === достаточно

В большинстве бытовых проверок обычного === вполне хватает.

console.log(userId === 10);

Поэтому Object.is() нужен не везде, а в более точных и специальных случаях.

Object.is() не меняет значения

Метод ничего не изменяет и просто возвращает результат сравнения.

const a = 1;
const b = 1;

console.log(Object.is(a, b)); // true
console.log(a); // 1
console.log(b); // 1

Частые ошибки

Думать, что Object.is() делает глубокую проверку объектов

console.log(Object.is({ a: 1 }, { a: 1 })); // false

Метод сравнивает ссылки, а не структуру объекта.

Считать, что Object.is() полностью совпадает с ===

console.log(Object.is(NaN, NaN)); // true
console.log(NaN === NaN);         // false

На NaN и +0 / -0 результаты отличаются.

Использовать Object.is() там, где нужен == с приведением типов

console.log(Object.is(1, "1")); // false

Метод не приводит типы автоматически.

Быстрая памятка

Object.is() сравнивает два значения и возвращает true или false
в большинстве случаев он похож на ===
Object.is(NaN, NaN) даёт true
Object.is(+0, -0) даёт false
объекты и массивы сравниваются по ссылке

Коротко

Object.is() - это более точный способ сравнить два значения в JavaScript. Главное, что стоит запомнить: он почти как ===, но правильно отличает NaN и +0 / -0.