JavaScript: == vs === Оператор

Введение Операторы сравнения используются в логических операторах, чтобы определить, равны ли две переменные или объекты по некоторым уже установленным или определенным пользователем критериям. Если две переменные или объекты считаются равными, оператор возвращает истину и ложь, если это не так. Операторы сравнения в JavaScript: * <- меньше *> - больше * <= - меньше или равно *> = - больше или равно * == и === - равно (оператор свободного и строгого равенства) * ! = и! ==

Вступление

Операторы сравнения используются в логических операторов для определения , равны ли некоторые уже установленных или определенных пользовательских критериев две переменные или объекты. Если две переменные или объекты считаются равными, оператор возвращает true и false если это не так.

Операторы сравнения в JavaScript:

  • < - меньше чем
  • > - больше чем
  • <= - меньше или равно чем
  • >= - больше или равно
  • == и === - равно (оператор свободного и строгого равенства)
  • != и !== - не равно (оператор слабого и строгого неравенства)

JavaScript интересен тем, что у него есть два визуально очень похожих, но на практике очень разных оператора сравнения на равенство: == и === .

В этой статье мы объясним различия между операторами свободного и строгого равенства и рассмотрим некоторые примеры их использования.

Свободный оператор равенства в JavaScript (==)

Двойное равенство в JavaScript проверяет отсутствие равенства . Это позволяет механизму JavaScript попытаться привести эти выражения к общему типу. Это означает, что выражения не обязательно должны быть одного типа.

Процесс преобразования значения из одного типа в другой называется приведением типа . Приведение типов может быть явным и неявным .

Явное приведение типов, как следует из названия, явно выполняется в коде программистом с использованием встроенных методов, предоставляемых JavaScript ( Number() , String() , Boolean() ...).

Например:

 // This would result in x being a number 42 
 let x = Number("42"); 
 
 // Similarly,this would result in y being cast to the boolean value false 
 let y = Boolean(0); 

С другой стороны, неявное приведение типов выполняется JavaScript неявно. Этот тип приведения обычно используется, когда мы используем операторы для разных типов, но может быть разумно "сопоставлен" одним из них, например:

 // x is going to be cast to the string "1". 
 let x = 1 + ""; 

Чтобы объяснить этот пример, давайте посмотрим на него с точки зрения движка JavaScript:

Выражение должно быть вычислено и присвоено x . Первое число - 1 , кроме него + Это подразумевает целочисленное сложение со следующим числом. Однако там есть пустая строка "" . Это не может быть преобразовано в число. Однако мы также можем объединять строки с помощью + , поэтому давайте сопоставим их как строки и выполним объединение. Наконец, результат возвращается и присваивается x .

Подводя итог, движок JavaScript пытается преобразовать оба значения в тип, поддерживающий
+ , который в данном случае является строкой.

 /* In this case, the JS engine deduces that both the operands and the result have to be cast to an integer because it's the only type that has a defined subtraction operation (-) */ 
 
 let y = "5" - "2"; 
 
 // Because booleans don't have a + operation, the JS engine converts both true values into 1's 
 
 let z = true + true; 

Теперь именно этот тип принуждения == для проверки равенства. Давайте рассмотрим несколько примеров использования оператора свободного равенства в Node REPL:

 > 42 == "42" 
 true 
 > "42" == '42' 
 true 

42 , "42" и '42' сопоставляются с одним и тем же типом данных и все примерно равны, возвращая true при сравнении.

Логические значения следуют тому же принципу:

 > true == 1 
 true 
 > true + true == 2 
 true 
 > false == 0 
 true 
 > false + true == 1 
 true 

true равна 1 а false равна 0 . Мы можем неявно преобразовать их в целые числа, добавив их.

Наконец, вот пример (нечитаемого), но синтаксически корректного сравнения:

 > ("42" == '42') + (42 == "42") == 2 
 true 

"42" == '42' оценивается как true , так же как 42 == "42" . Следовательно, эта сторона выражения также оценивается как true + true , которая неявно преобразуется в 1+1 . Очевидно, что == 2 , поэтому выражение возвращает true .

Сравнение ложных значений в JavaScript

Ложное значение - это переменная, значение которой false . В JavaScript существует семь ложных значений: false , 0 , "" , [] , null , undefined , NaN .

Когда дело доходит до использования оператора двойного равенства для ложных значений, существует несколько простых правил:

  • false , 0 и "" эквивалентны
  • undefined и null возвращают true по сравнению с собой или друг с другом, и false по сравнению с чем-либо еще
  • NaN по сравнению с чем-либо (даже с другим NaN ) возвращает false

Итак, все это будет true :

 > false == 0; 
 true 
 > false == ""; 
 true 
 > 0 == ""; 
 true 
 > undefined == null; 
 true 
 > undefined == undefined; 
 true 
 > null == null; 
 true 
 > [] == false; 
 true 
 > [] == 0; 
 true 

Хотя все это было бы false :

 > undefined == false; 
 false 
 > 0 == null; 
 false 
 > null == true 
 false 
 > NaN == false; 
 false 
 > NaN == NaN; 
 false 

Оператор строгого равенства в JavaScript (===)

Тройное равенство в JavaScript означает строгое равенство . Это означает, что, в отличие от оператора свободного равенства, о котором мы говорили ранее, неявное преобразование отсутствует. Это означает, что вывод не будет true если тип и значения двух выражений не совпадают. Они больше не совпадают по типу.

Теперь давайте посмотрим на несколько примеров операторов строгого равенства:

 > true === true 
 true 
 > true === 1 
 false 
 > false === 0 
 false 

Этот пример возвращает true в первом случае, потому что и тип (логический), и значение ( true ) равны. В двух других случаях возвращается false , потому что, хотя значения одинаковы, типы не совпадают. Мы сравниваем логическое значение с целым числом.

 > 42 === 42 
 true 
 > 42 === "42" 
 false 

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

Заключение

В этой статье мы объяснили разницу между оператором свободного равенства и оператором строгого равенства в JavaScript .
Мы также объяснили, что такое приведение типов , а также концепцию явного и неявного приведения типов.

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

Используя оператор строгого равенства, вы проверяете и тип, и значение, и поэтому можете быть уверены, что всегда выполняете проверку на истинное равенство.

comments powered by Disqus