Чем отличается двойное равно от тройного js

Операторы сравнения в 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.

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

В программировании часто нужно сравнивать переменные между собой. Если мы хотим знать равны ли переменные друг другу или какая из двух переменных больше, то сделать это можно с помощью операторов сравнения. Создадим две переменные x и y.

const x = 100;
const y = 100;

Оператор равно (===) / (==)

Для сравнения на строгое равенство используется тройное равно (===), а на нестрогое равенство — двойное равно (==). Как узнать, что эти две переменные равны? Запускаем следующий код в консоли и получаем ответ в качестве булевого значения (true / false). Если вернулось true, значит значение переменной x равно значению переменной y.

console.log(x === y ); // true

В этом случае для сравнения мы использовали оператор строгого равенства, поскольку у обоих переменных одинаковый тип данных — number. Но что произойдет, если у сравниваемых переменных будет разный тип данных. Число, заключенное в кавычки — это строка. Несмотря на то, что у них одинаковые значения, мы получим false. Разные типы данных нельзя сравнивать между собой.

const x = 100; // number (число)
const y = ‘100’; // string (строка)

console.log(x === y ); // false

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

const x = 100; // number
const y = ‘100’; // string

console.log(x == y ); // true

const x = 100; // number
const y = 100; // number

console.log(x == y ); // true

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

Оператор не равно (!==)

Оператор строгого не равно (!==) сравнивает переменные по типу и значению, оператор нестрогого не равно (!=) сравнивает только по значению, игнорируя типы (работает по аналогии с (==) и крайне нежелателен к использованию). В примере ниже, мы ожидаемо получаем false, поскольку утверждение, что x не равно y, неверно.

const x = 50; // number (число)
const y = 50; // number (число)

console.log(x !== y ); // false

При сравнении разных типов данных, данное утверждение становится верным.

const x = 50; // number (число)
const y = ’50’; // string (строка)

console.log(x !== y ); // true

Оператор больше чем (>)

Утверждение, что x больше, чем y верно и возвращает нам true.

const x = 60;
const y = 50;

console.log(x > y); // true

Оператор больше или равно (>=)

А утверждение, что x больше или равен y, неверно.

const x = 40;
const y = 50;

console.log(x >= y); // false

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

Сравнение массивов

Логика сравнения ссылочных типов данных (массивов и объектов) существенно отличается.

В область памяти переменной с массивом или объектом записывается не значение, а ссылка (адрес) на эту переменную. Поэтому когда мы сравниваем два абсолютно одинаковых массива, то получаем false. Они уже по своей сути не могут быть равны, ведь ссылки на них разные. Ссылочный тип данных содержит указатель на объект, а не сам объект.

Оператор равно ===

const x = [1,2,3];
const y = [1,2,3];

console.log(x === y ); // false

Необычность ситуации с ссылочным типом данных состоит в том, что при иных обстоятельствах, одинаковые массивы могут быть равны. Что имеется в виду? Мы создали переменную x и присвоили ей массив, затем в переменную y передали значение переменной x. Теперь обе переменные содержат одинаковые значения, что подтверждает возвращаемое true. Чем же эта ситуация отличается от предыдущей? Все дело в том, что в переменную x мы записали адрес на массив и передали его в переменную y. Таким образом обе переменные имеют одинаковый адрес и ссылаются на один и тот же объект, а значит они равны между собой. В первом же случае массивы были одинаковые, но адреса (ссылки) — разные. При сравнивании объектов, механизм будет точно такой же.

const x = [3,4,5];
const y = x;
console.log(y); // [3,4,5]

console.log(x === y ); // true

Создано 22.01.2021 10:10:56

Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

1. Кнопка:
   Она выглядит вот так:
2. Текстовая ссылка:
   Она выглядит вот так: Как создать свой сайт
3. BB-код ссылки для форумов (например, можете поставить её в подписи):

Комментарии ( 0 ):

Для добавления комментариев надо войти в систему.
Если Вы ещё не зарегистрированы на сайте, то сначала зарегистрируйтесь.

Copyright © 2010-2023 Русаков Михаил Юрьевич. Все права защищены.

18) Разница между =, == и ===

Равным (=) является оператор присваивания, который устанавливает переменную слева от = в значение выражения, которое находится справа. Этот оператор назначает lvalue для rvalue.

Например, написание а = 10 хорошо. Если мы напишем 10 = 10, «a» = 10 или «a» = «a», это приведет к ошибке ссылки.

В этом уроке вы узнаете:

• Что такое = в JavaScript?
• Что такое == в JavaScript?
• Что такое === в JavaScript?
• Зачем использовать = в JavaScript?
• Зачем использовать == в JavaScript?
• Как === Работает Точно?
• Пример =
• Пример ==
• Пример ===
• = Vs == VS === в JavaScript

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

Двойное равенство (==) – это оператор сравнения, который преобразует операнды одного типа перед сравнением.

Таким образом, когда вы сравниваете строку с числом, JavaScript преобразует любую строку в число. Пустая строка всегда конвертируется в ноль. Строка без числового значения преобразуется в NaN (не число), что возвращает false.

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

=== (Triple equals) – это оператор сравнения строгого равенства в JavaScript, который возвращает false для значений, которые не относятся к аналогичному типу. Этот оператор выполняет приведение типов на равенство. Если мы сравним 2 с «2», используя ===, то он вернет ложное значение.

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

Вот важные применения = в JavaScript:

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

Основной оператор присваивания =, который присваивает значение одного операнда другому. То есть a = b присваивает значение b a.

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

Вот важные применения == в JavaScript:

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

Как === Работает Точно?

• Строгое равенство === проверяет, что два значения одинаковы или нет.
• Значения неявно преобразуются в какое-то другое значение перед сравнением.
• Если значения переменных имеют разные типы, то значения считаются неравными.
• Если переменные имеют одинаковый тип, не являются числовыми и имеют одинаковое значение, они считаются равными.
• Наконец, если оба значения переменных являются числами, они считаются равными, если оба не являются NaN (не числом) и имеют одинаковое значение.

Пример =

В приведенной ниже программе есть две переменные «a» и «b». Мы добавляем и печатаем их значения, используя третью переменную «c». Сумма значений переменных «a» и «b» равна 7. Поэтому на выходе получается 7.

   
JavaScript Operators
 
a = 2, b = 5, calculate c = a + b, and display c:





    

Вывод:

a = 2, b = 5, вычислите c = a + b и отобразите c:

Пример ==

В приведенной ниже программе мы объявили одну переменную «a», имеющую значение 10. Наконец, оператор a == 20 возвращает false, поскольку значение a равно 10.

Вывод:

Пример ===

В приведенной ниже программе значение переменной x равно 10. Она сравнивается с 10, записанным в двойных кавычках, который рассматривается как строка, и, следовательно, значения не являются строго одинаковыми. Вывод программы неверен.

Вывод:

= Vs == VS === в JavaScript

Вот важные различия между =, == и ===

знак равно	==	===
= в JavaScript используется для присвоения значений переменной.	== в JavaScript используется для сравнения двух переменных, но игнорирует тип данных переменной.	=== используется для сравнения двух переменных, но этот оператор также проверяет тип данных и сравнивает два значения.
Это называется оператором присваивания	Это называется оператором сравнения	Он также называется оператором сравнения
Оператор присваивания может оценить присвоенное значение	Проверяет равенство двух операндов без учета их типа.	Сравнивает равенство двух операндов с их типами.
Это не возвращает истину или ложь	Верните true, если два операнда равны. Он вернет false, если два операнда не равны.	Он возвращает true, только если значения и типы данных одинаковы для двух переменных.
= просто присвоить одно значение переменной другому.	== сделать коррекцию типа на основе значений переменных.	=== принимает во внимание тип переменной.
== не будет сравнивать значение переменных вообще.	== проверяет равенство только после выполнения необходимых разговоров.	Если два значения переменных не похожи, то === не будет выполнять никакого преобразования.

ОСНОВНЫЕ РАЗЛИЧИЯ:

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

Отличия == и === в JavaScript

В JavaScript есть два похожих оператора: == и ===. Если не знать их отличия, это может обернуться кучей ошибок. Так что решил раскрыть эту тему. Чем именно отличаются == и ===, как они работают, почему так происходит, и как избежать ошибок.

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

abc == undefined; // true, если abc = undefined | null abc === undefined; // true - только если abc = undefined!

abc == false; // true, если abc = false | 0 | '' | [] abc === false; // true, только если abc = false!

Ведь путать false и 0 (или », или []) — вряд ли очень хорошо.

5 === 5; // true true === true; // true 'abc' === 'abc'; // true

А теперь интересный пример.

5 == 5; // true 5 === 5; // true new Number(5) == 5; // true new Number(5) === 5; // false!

Почему так происходит? Да, любое число — это объект класса Number. Но можно представить число как цифру — некоторой константой. Она единожды объявлена, и всегда идентична сама себе. Но в то же время объявляя новый объект класса Number — он равен ей по значению, но не идентичен (так как это два совершенно разных объекта класса Number).

Arrays / Objects

А вот для массивов и объектов оба оператора работают одинаково, сравнивая на идентичность:

var a = <>; a == <>; // false a === <>; // false a == a; // true a === a; // true

Для сравнения массивов и объектов можно написать специальную функцию:

function isEq(a, b) < if(a == b) return true; for(var i in a)< if(!isEq(a[i], b[i])) return false; >for(var i in b) < if(!isEq(a[i], b[i])) return false; >return true; >

Немножко неаккуратно, два цикла, да и про hasOwnProperty забыли; ну да сойдёт.

This

Есть ещё один подводный камень. Это передача в this.

(function()< this == 5; // true this === 5; // false >).call(5);

Вот такой вот момент. Стоит о нём не забывать.

Итого.

Ну а теперь представим, что мы пишем свой суперфреймворк, активно юзаем там оператор === вместо == просто потому что он красивее, и некто находит у нас несколько багов.

func(new Number(5)); (function()< func(this); >).call(5);

Кажется, что такие примеры нежизнеспособны? Пожалуйста!

$.each([1, 2, 3, 4, 5], function()< func(this); >);

Ну или захотелось расширить цифру.

var Five = new Number(5); Five.a = 2; // захотелось расширить, а просто 5 не расширяется // здесь как-то используем. func(Five);

На этом всё, надеюсь кому-то будет полезно. Спасибо за внимание.

UPD. Спасибо за ссылку vermilion1, JS Гарден.

• равенство
• идентичность