МИНИ-СЕРИЯ JAVASCRIPT
Свободное и строгое равенство в JavaScript
В этом уроке мы быстро рассмотрим операторы строгого (===) и свободного (==) равенства в JavaScript и поймем, как они соотносятся друг с другом.
Вы можете подумать, насколько сложно сравнить два значения. Что ж, здесь, в JavaScript, это кровавое месиво. В JavaScript есть два способа сравнить два значения. Либо мы можем проверить два значения для подобия, либо проверить, являются ли два значения строго равными во всех отношениях.
● Строгое равенство
Операция Строгое равенство - это то, к чему мы привыкли. Вместо обычного оператора ==
(двойное равно) мы используем оператор ===
(тройное равно) для выполнения строгой проверки равенства. В этой операции A === B
и A
, и B
должны быть одного типа, иначе результат всегда будет false
, поскольку два значения разных типов данных не могут быть равными ни в одном юниверсе. Если оба имеют одинаковый тип данных, сравниваются их значения.
В приведенном выше примере мы сравнили два значения вместе с помощью оператора строгого равенства (===
). Эти значения могут быть простыми строками и логическими значениями примитивных типов данных или абстрактными / сложными типами данных, такими как массивы и объекты. Это дает следующий результат.
Здесь есть о чем поговорить, так что давайте разберемся с концепцией за раз.
- Все сравнения на строгое равенство между двумя несовместимыми типами данных вернут
false
. Так что даже не думайте сравнивать объекты с массивами и строку с числами. NaN
- это особый случай в JavaScript, поскольку это единственное значение в JavaScript, которое не равно самому себе. Поэтому даже не думайте сравниватьn === NaN
, чтобы проверить, является лиn
NaN
, поскольку он всегда возвращаетfalse
. Вместо этого используйте глобальную функциюisNaN(n)
. Интересный факт:typeof NaN
возвращает"number"
, поэтомуNaN
является глобальным значением типаnumber
и указывает не-число.- Поскольку
null
иundefined
являются глобально определенными примитивами, они равны сами себе, однако они не будут равны друг другу, поскольку принадлежат к разным типам данных. Infinity
- это глобально определенное значение типаnumber
, обозначающее математическую бесконечность. Он равен самому себе, поскольку это неNaN
.- Вызов
Symbol()
всегда возвращает уникальноеsymbol
значение. Следовательно,Symbol() === Symbol()
всегда возвращаетfalse
. - Непримитивные значения, такие как Массив, Объект или Функции, не равны друг другу, кроме самих себя.
- Оператор
!==
является отрицанием оператора===
.
💡 Если вам не нравится, как JavaScript обрабатывает
NaN
, и вы хотите, чтобыNaN === NaN
возвращалtrue
, используйте методObject.is()
. Эта функция выполняет строгую проверку равенства между двумя аргументами, за исключением некоторых случаев. Он не только возвращаетtrue
, когда оба аргумента равныNaN
, но и возвращаетfalse
для сравнения+0
и-0
. Этот метод был представлен в ES6.
● Свободное / абстрактное равенство
Проверка Свободное равенство или Абстрактное равенство - это проверка сходства двух значений, которая выполняется с использованием ==
(double equals ) оператор. Этот оператор сравнивает, похожи ли два значения. Таким образом, снимаются некоторые ограничения, накладываемые Строгое равенство.
Как и в предыдущем примере, мы сравниваем два значения JavaScript вместе, но теперь с помощью оператора свободного равенства (===
). Это дает следующий результат.
Итак, по сравнению со строгим равенством, здесь нет ни одного значения, которое изменилось бы здесь, когда мы заменили оператор ===
(тройное равно) оператором ==
(двойное равно) в предыдущем программа (кроме null == undefined
). Это потому, что до сих пор мы сравнивали только значения одного типа данных. Как мы знаем, для того, чтобы строгое равенство возвращало true
, оба значения должны начинаться с одного и того же типа данных. Однако это не относится к свободному равенству.
Когда JavaScript обнаруживает значения одного и того же типа данных в операции свободное равенство, он проверяет, равны ли их значения, как и при проверке строгого равенства. Однако, когда значения разных типов данных сравниваются с использованием свободного равенства, JavaScript сначала неявно привел один или оба из них к одному и тому же типу данных и выполняет операцию строгого равенства.
Например, как мы видим в приведенных выше результатах, [] == 0
возвращает true
, поскольку значение массива (LHS) приводится к числу посредством последовательности операций, и в конце получается 0
. Следовательно, 0 === 0
возвращает истину. Очевидным кандидатом является 0 == "0"
, в котором "0"
(RHS) будет преобразовано в число, поэтому 0
и 0 === 0
вернут true
.
Как JavaScript решает, какое значение преобразовать в какой тип данных, зависит от типа и значений обоих операндов. Поэтому всегда рекомендуется использовать строгое равенство при сравнении двух значений, поскольку эти правила и преобразования невозможно запомнить. Так что есть большая вероятность, что вы что-то пропустите и совершите ошибку на миллион долларов.
Вы можете понять некоторые принципы свободного равенства из документа MDN, но я бы порекомендовал вам прочитать эту статью, в которой описывается, как работает процесс принуждения.
💡 Мотивация такого поведения может быть связана с тем, что типы данных значений действительно не имеют большого значения в JavaScript, и это дает пользователю гибкость для выполнения разумных операций с аналогичными (единомышленниками) значениями.
Теперь, когда мы видим, что JavaScript выполняет приведение операндов, когда это кажется необходимым, давайте выполним некоторые математические операции с операндами единомышленников и посмотрим, согласованно ли это поведение.
Как видно из приведенных выше результатов, операция +
с операндом string
всегда будет приводить к приведению другого операнда к string
, а затем эти два значения будут объединены. Это связано с тем, что +
- это не только арифметический оператор сложения, но и оператор конкатенации строк, так как в "hello" + " world"
получается "hello world"
строковое значение.
Однако это не относится к -
, *
и /
арифметическим операциям или +
операциям со значениями, отличными от string
. Когда два значения операнда подвергаются этим операциям, одно или оба из них преобразуются в значения number
. Поскольку эти правила ведения боевых действий также сложно запомнить, постарайтесь избегать подобных операций.