JavaScript:

Автор оригинала: Mila Lukic.

Вступление

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

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

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

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

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

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

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

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

Принуждение к явным типом является, поскольку его имя подразумевает, выполнено явно в коде программиста, используя встроенные методы, которые предоставляет 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:

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

Подводя итоги, двигатель 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;

Теперь это именно этот тип принуждения, что == Оператор использует для проверки равенства. Давайте перейдем на несколько примеров использования оператора «Свободного равенства», в UDE REPL:

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

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

Логины следуют тому же принципу:

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

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

Наконец, вот пример (нечитаемый), но синтаксически действительное сравнение:

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

"42" оценивается как правда , а также 42 Отказ Эта сторона выражения также также оценивается до правда + правда , который неявно преобразуется в 1 + 1 Отказ Это очевидно, == к 2 поэтому выражение возвращается правда Отказ

Ложное сравнение ценности в JavaScript

А Falsy Значение – это переменная, которая оценивает на ложь Отказ В JavaScript есть семь Falsy Значения – ложь , 0 , "" , [] , null , undefined , Нан Отказ

Есть пара простых правил, когда речь идет об использовании оператора Double Equals на Falsy значения:

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

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

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

Пока это все будет ложь :

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

Строгий оператор равенства в JavaScript (===)

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

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

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

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

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

Здесь и число, и значение равно в первом примере, что приводит к правда , хотя значение и тип несоответствия во втором примере, что приводит к ложь Отказ

Заключение

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

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

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