В чем разница между и

В чем разница между == и ===?

@VladD Да, мне тоже любопытно. Много специалистов JavaScript, например Douglas Crockford, считают, что это было ошибка. Кажется, что дизайнер JavaScript, как и дизайнеры PHP, думал что будет легче для программистов если язык преобразывает типы автоматическим образом. А мне кажется наоборот, что надо про типы думать больше, когда неожиданно преобразываются.

4 июл 2015 в 15:41
А сие точно не дубль?
14 сен 2016 в 14:43
@nick_n_a, это скорее оригинал 🙂
14 сен 2016 в 14:43
ассоциация: stackoverflow.com/q/359494/14227417
21 дек 2020 в 14:11

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Операторы === и !== являются операторами строгого сравнения. Значит, если операнды имеют разные типы, то не являются равными. Например:

1 === "1" // возвращает false 1 !== "1" // возвращает true null === undefined // возвращает false

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

1 == "1" // возвращает true 1 != "1" // возвращает false null == undefined // возвращает true

Интересно заметить, что в отличие от === , оператор == не является транзитивным:

"0" == 0 // true 0 == "" // true "0" == ""// false

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

Даже я не помню мелкие детали оператора == , так что посмотрим в спецификации, пункт 11.9.3:

Алгоритм сравнения абстрактного равенства

Если Type(x) такой же, что и Type(y), то
1. Если Type(x) – Undefined, вернуть true.
2. Если Type(x) – Null, вернуть true.
3. Если Type(x) – Number, то
  1. Если x – NaN, вернуть false.
  2. Если y – NaN, вернуть false.
  3. Если x имеет такое же числовое значение, что и y, вернуть true.
  4. Если x равно +0 и y равно −0, вернуть true.
  5. Если x равно −0 и y равно +0, вернуть true.
  6. Вернуть false.
  Сравнение отпаривателя и утюга: ключевые факторы, которые следует учитывать
  
  UAportal узнал, какие основные параметры следует учитывать при выборе между утюгом и отпаривателем. Важно углубиться в эти характеристики, чтобы понять, на что следует обратить внимание.
  
  Эффективность
  
  Отпариватель использует пару высокой температуры для быстрого разглаживания складок на одежде, в то время как утюг работает за счет нагрева металлической пластины. Пара отпаривателя проникает в ткань гораздо лучше, чем горячая поверхность утюга, что делает его идеальным для деликатных тканей и больших изделий, таких как шторы и скатерти.
  
  С отпаривателем нет нужды в гладильной доске, и его можно легко использовать на висящих вещах. А утюг может потребовать более осторожного обращения, особенно при работе с большими изделиями, такими как шторы.
  
  Универсальность
  
  Отпариватель может эффективно разглаживать складки на многих типах тканей, включая нежный шелк и шерсть, а также плотные материалы, такие как обивка и шторы. А вот утюг может нуждаться в других температурных режимах при работе с деликатными тканями.
  
  Хранение и портативность
  
  Легкая конструкция и портативность отпаривателей делают их практичным выбором для путешествий. Хотя современные утюги становятся все более компактными, они все еще нуждаются в устойчивой гладильной поверхности.
  
  Напомним, ранее мы писали о том, как гладить вещи вдвое быстрее с помощью фольги.
  
  Хотите получать самые актуальные новости о войне и событиях в Украине – подписывайтесь на наш Телеграмм-канал !
  
  В чем разница между == и equals в Java?
  
  Т.к метод equals() не переопределен, то данный метод сравнивает ссылки, так же как и оператор == . Это можно увидеть, если взглянуть исходный код метода equals класса Object :
```
public boolean equals(Object obj)
```
  А если equals() переопределен, возьмем, например, класс Integer :
```
public boolean equals(Object obj) < if (obj instanceof Integer) < return value == ((Integer)obj).intValue(); >return false; > 
```
```
Integer a = new Integer(6); Integer b = new Integer(6); System.out.println(a == b); // false т.к. это разные объекты с разными ссылками System.out.println(a.equals(b)); // true, т.к equals() переопределен и сравниваются уже не ссылки 
```
  Чтобы сравнивать классы, нужно переопределить метод equals() (а тогда следует переопределить и hashCode() ).
  
  Отслеживать
  ответ дан 2 июл 2018 в 20:17
  2,280 2 2 золотых знака 17 17 серебряных знаков 31 31 бронзовый знак
  
  Метод equals() в сравнении с операцией ==
  
  Метод equals сравнивает символы из объекта типа String , а операция == — две ссылки на объекты, определяя ссылаются ли они на один и тот же экземпляр.
  
  В примере отображено два разных объекта типа String , которые могут содержать одинаковые символы, но ссылки на эти объекты при сравнении не будут равнозначны:
```
// метод equals() в сравнении с операцией == public class EqualsNotEqualTo < public static void main(String[] args) < String s1 = "Сравнение"; String s2 = new String(s1); System.out.println(s1 + " равно " + s2 + " ->" + s1.equals(s2)); System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2)); > > 
```
  Переменная s1 ссылается на экземпляр класса String , созданный присваиванием ей строкового литерала «Сравнение» . А объект, на который ссылается переменная s2 , создается с использованием переменной s1 в качестве инициализатора.
  
  Таким образом, содержимое обоих объектов типа String одинаково, но это разные объекты. Следовательно, переменные s1 и s2 ссылаются не на один и тот же объект, поэтому они не равны, в сравнении операции == .
  
  Результат:
```
Сравнение равно Сравнение -> true Сравнение == Сравнение -> false 
```
  Отличия == и === в 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 Гарден.
  - равенство
  - идентичность
  Похожие публикации:

В чем разница между и