Тройное равенство в javascript

Операторы сравнения в JavaScript: тройной знак равенства и двойной знак равенства

Вы видели двойные и тройные знаки равенства в JavaScript. Но что они? Если коротко: == преобразует тип, а === не преобразует тип.

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

Тройной знак равенства (===) не выполняет приведение типов. Он проверяет, имеют ли сравниваемые переменные одинаковое значение и тип.

Рассмотрим несколько примеров:

Пример 1

const foo = "test" const bar = "test" console.log(foo == bar) //true console.log(foo === bar) //true

Значение и тип у foo и bar одинаковые. Поэтому результат для обоих — true.

Пример 2

const number = 1234 const stringNumber = '1234' console.log(number == stringNumber) //true console.log(number === stringNumber) //false

Значения number и stringNumber выглядят одинаковыми. Но number имеет тип Number, а stringNumber имеет тип string. Даже если значения переменных одинаковы, тип не совпадает. Поэтому оператор == возвращает значение true. Но при проверке значения и типа значение равно false.

Пример 3

console.log(0 == false) //true console.log(0 === false) //false

Значение 0 при проверке с false является тем же. 0 и false имеют одинаковое значение для JavaScript. Но при проверке с помощью тройного оператора значение ложно, потому что 0 имеет тип number, а false – boolean.

Пример 4

const str = "" console.log(str == false) //true console.log(str === false) //false

Значение пустой строки и false – это в JavaScript то же самое. Следовательно, == возвращает значение true. Но тип переменных отличается, поэтому === возвращает значение false.

Когда использовать ==, а когда ===?

Если есть сомнения, используйте ===. Это избавит вас от большого количества потенциальных ошибок.

Если не нужен контроль входящих данных, используйте ==. Например, если API принимает от клиента «true» и true, используйте ==.

Эта таблица показывает, насколько сложно сравнение в JavaScript.

Источник

Зачем использовать тройное равенство в JavaScript?

«Определение, эквивалентны ли 2 переменные, является одним из наиболее важных операций в программировании» — Nicholas Zakas.

Другими словами, в вашем скрипте вы можете написать так:

Или, если вы хотите писать хорошие скрипты, делайте так:

Разница между этими двумя примерами в том, что во втором примере используется тройное сравнение, которое по-другому называют «строгое равенство» или «тождественное равенство».

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

В чем разница?

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

Каждое значение JavaScript имеется свой специальный тип. Типы бывают: число, строка, булевый тип, функция, и объект. Поэтому, если вы попытаетесь сравнить строку с числом, браузер попытается конвертировать строки в число до того, как произойдет сравнение. Аналогично, если сравнение true и false с числом, true и false будут конвертированы в число 1 и 0 соответственно.

Это может привести к неожиданным результатам. Приведем несколько примеров:

console.log(99 == "99"); // true console.log(0 == false); // true

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

console.log(' \n\n\n' == 0); // true console.log(' ' == 0); // true

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

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

Это означает, что использование тройного равенство во всех случаях выше вернуло бы правильный результат:

console.log(99 === "99"); // false console.log(0 === false); // false console.log(' \n\n\n' === 0); // false console.log(' ' === 0); // false

Что насчет неравенства?

При выполнении оператора не-равно к выражению, применяются те же правила. Только на этот раз, нужно использовать двойные равно против одного.

Вот несколько примеров с использованием оператора !=.

console.log(99 != "99"); // false console.log(0 != false); // false console.log(' \n\n\n' != 0); // false console.log(' ' != 0); // false

Заметьте, что везде вернулась обращенное значение true, т.к. произошло приведение типов.

Если мы изменим двойное равенство на тройное, мы получим правильные результаты:

console.log(99 !== "99"); // true console.log(0 !== false); // true console.log(' \n\n\n' !== 0); // true console.log(' ' !== 0); // true

Заключение

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

Вот, что говорит Zakas о тройном равенстве: «. Это помогает поддерживать целостность данных типа во всем коде».

Подписываемся на рассылку!

Источник

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

Если вы читаете этот блог, вы, вероятно, изучаете JavaScript — и это замечательно. Двойное и тройное равно (== и ===) в JavaScript часто заставляют новичков ломать голову. Но пусть вас это не пугает: когда вы узнаете, как работают эти операторы, вы поймете, что такие особенности делают JS еще красивее.

Что такое == и === в JavaScript?

Операторы == и === используются для сравнения и определения степени равенства или идентичности сравниваемых объектов.

И двойное, и тройное равно возвращают true, если сравниваемые объекты равны, а в противном случае возвращают false. Разница между ними в том, что эти операторы используют разные критерии для определения степени равенства.

Учитывая это, давайте на примерах разберемся, чем == отличается от ===.

Как работает оператор == в JavaScript

Двойное равно (==) часто называют «нестрогим равенством», потому что этот оператор выполняет приведение типов перед сравнением.

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

Давайте разберемся с помощью примера.

const a = 100; const b = '100'; console.log(a == b) // true

Здесь у нас есть две переменные, a и b . Тип переменной a — число, а тип переменной b — строка.

Когда мы сравниваем эти две переменные с помощью двойного равенства, мы получаем на выходе true.

Это происходит потому, что перед сравнением переменная a приводится к строковому типу.

После преобразования значения обеих переменных сравниваются. Если они одинаковы, мы получим true, в противном случае — false. В нашем случае это true.

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

Правила приведения типов

Рассмотренный пример довольно прост, не так ли? Давайте попробуем еще один, а после разберем правила приведения типов.

const a = true; const b = 'true'; console.log(a == b)

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

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

Итак, вот правила для приведения типов в JavaScript:

1. Если один из операндов является строкой, то второй операнд будет преобразован в строку.
2. Если один из операндов является числом, другой операнд будет преобразован в число.
3. Если один из операндов является булевым значением, он будет преобразован в число (true станет 1, а false — 0).
4. Если один из операндов является объектом, а другой — примитивным значением, то перед сравнением объект будет преобразован в примитивное значение.
5. Если один из операндов равен null или undefined, то, чтобы при сравнении вернулось true, второй тоже должен быть null или undefined. В противном случае возвращается false.

Теперь, ознакомившись с правилом из пункта 3, вы знаете, почему в приведенном выше примере наш ответ был false.

Значение переменной a (true) перед сравнением преобразуется в число. После этого мы сравниваем 1 и «true» — и получаем false, потому что переменные содержат разные значения.

Как работает оператор === в JavaScript

Тройное равно (===), также называемое «строгим равенством», работает аналогично двойному равно. Но есть важное отличие: при использовании === типы операндов не приводятся перед сравнением.

При сравнении переменных сначала проверяется, отличаются ли их типы. Если да, то возвращается false. Если типы совпадают, то проверяется значение. Если значения одинаковы и не являются числами, возвращается true.

Наконец, если оба операнда — числа и не NaN, и у них одинаковое значение, то возвращается true. В противном случае — false.

Давайте разберемся в этом с помощью примера:

const a = 100; const b = '100'; console.log(a === b);

Мы взяли тот же пример, что и выше, но при сравнении использовали не двойное, а тройное равенство.

Итак, возможно, вы уже угадали ответ. Да, это false, а почему? Потому что тип переменной a — число, а тип переменной b — строка.

При сравнении тройное равенство сначала проверяет типы операндов, а в данном примере эти типы различаются. Поэтому возвращается false.

Давайте рассмотрим другой пример:

const a = true; const b = 1; console.log(a === b);

Здесь у нас тоже две переменные, a и b . Тип переменной a — boolean, а тип переменной b — число. Если мы будем их сравнивать с помощью строго равенства, оно вернет false — потому что, опять же, переменные имеют разные типы.

Заключение

Операторы == и === в JavaScript — это операторы сравнения, которые мы используем, чтобы определить, равны или нет два значения.

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

Оператор === выполняет строгое сравнение, без приведения типов. При использовании тройного равно сравниваются и типы, и значения.

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

Источник