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

Ссылка: Учебное пособие по Javascript: операторы сравнения

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

Процитирую превосходную JavaScript: хорошие стороны Дугласа Крокфорда:

JavaScript has two sets of equality operators: === and !==, and their evil twins == and !=. The good ones work the way you would expect. If the two operands are of the same type and have the same value, then === produces true and !== produces false. The evil twins do the right thing when the operands are of the same type, but if they are of different types, they attempt to coerce the values. the rules by which they do that are complicated and unmemorable. These are some of the interesting cases:

'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true

The lack of transitivity is alarming. My advice is to never use the evil twins. Instead, always use === and !==. All of the comparisons just shown produce false with the === operator.

Обновлять:

Хороший момент был поднят @Casebash в комментариях и в @Phillipe Laybaert'sотвечать относительно объектов. Что касается объектов, == и === действуют согласованно друг с другом (за исключением особых случаев).

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

Особый случай - это когда вы сравниваете примитив с объектом, который оценивается как тот же примитив, из-за его метода toString или valueOf. Например, рассмотрим сравнение строкового примитива со строковым объектом, созданным с помощью конструктора String.

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

Здесь оператор == проверяет значения двух объектов и возвращает true, но === видит, что они не одного типа, и возвращает false. Какой из них правильный? Это действительно зависит от того, что вы пытаетесь сравнить. Мой совет - полностью обойти этот вопрос и просто не использовать конструктор String для создания строковых объектов из строковых литералов.

Справка
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

Использование оператора == (Равенство)

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Использование оператора === (Личность)

true === 1; //false
"2" === 2;  //false

Это связано с тем, что оператор равенства == выполняет приведение типов означает, что интерпретатор неявно пытается преобразовать значения перед сравнением.

С другой стороны, Оператор идентификации === не выполняет приведение типов и, следовательно, не преобразует значения при сравнении, и, следовательно, быстрее (согласно тесту Этот тест JS), поскольку он пропускает один шаг.

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

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

Возьмем 2 варианта a и b.

Для "а == б" для оценки истинности a и b должны быть такое же значение.

В случае "а === б" a и b должны быть такое же значение, а также того же типа, чтобы он оценивался как истина.

Возьмем следующий пример

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

В итоге; использование оператора == может быть истинным в ситуациях, когда вы этого не хотите, поэтому использование оператора === будет более безопасным.

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

В типичном скрипте разницы в производительности не будет. Более важным может быть тот факт, что тысяча "===" на 1 KB тяжелее тысячи "==" :) Профилировщики JavaScript может сказать вам, есть ли разница в производительности в вашем случае.

Но лично я бы сделал то, что предлагает JSLint. Эта рекомендация существует не из-за проблем с производительностью, а потому, что приведение типов означает, что ('\t\r\n' == 0) верен.

Я тестировал это в Firefox с помощью Firebug, используя такой код:

console.time("testEquality");
var n = 0;
while (true) {
  n++;
  if (n == 100000)
    break;
}
console.timeEnd("testEquality");

а также

console.time("testTypeEquality");
var n = 0;
while (true) {
  n++;
  if (n === 100000)
    break;
}
console.timeEnd("testTypeEquality");

Мои результаты (проверены по пять раз и усреднены):

==: 115.2
===: 114.4

Поэтому я бы сказал, что мизерная разница (это более 100000 итераций, помните) незначительна. Производительность не повод заняться ===. Безопасность типов (ну, насколько безопасно, как вы собираетесь получить в JavaScript), и качество кода.

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

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

Что довольно скоро становится проблемой. Лучший пример того, почему неявное преобразование является «злом», можно взять из этого кода в MFC / C++, который на самом деле будет компилироваться из-за неявного преобразования из CString в HANDLE, который является типом typedef указателя ...

CString x;
delete x;

Что, очевидно, во время выполнения делает очень undefined ...

Google для неявных преобразований в C++ и STL, чтобы получить некоторые аргументы против этого ...

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

Итак, возьмем следующий код:

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Тут то же самое:

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Или даже:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Такое поведение не всегда очевидно. В этой истории есть нечто большее, чем равенство и принадлежность к одному типу.

Правило такое:

Для типов значений (чисел):
a === b возвращает истину, если a и b имеют одинаковое значение и относятся к одному типу.

Для справочных типов:
a === b возвращает истину, если a и b ссылаются на один и тот же объект.

Для струнных:
a === b возвращает истину, если a и b являются строками и содержат одни и те же символы.

Струны: особый случай ...

Строки не являются типами значений, но в Javascript они ведут себя как типы значений, поэтому они будут «равными», когда символы в строке одинаковы и имеют одинаковую длину (как объяснено в третьем правиле)

Теперь становится интересно:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

Но как насчет этого ?:

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Я думал, что строки ведут себя как типы значений? Ну, это зависит от того, кого вы спросите ... В этом случае a и b не одного типа. a относится к типу Object, а b - к типу string. Просто помните, что создание строкового объекта с помощью конструктора String создает нечто типа Object, которое ведет себя как строка большую часть времени.

Позвольте мне добавить этот совет:

Если сомневаетесь, прочтите Технические характеристики!

ECMA-262 - это спецификация языка сценариев, диалектом которого является JavaScript. Конечно, на практике поведение наиболее важных браузеров имеет большее значение, чем эзотерическое определение того, как что-то должно обрабатываться. Но полезно понять, почему новая строка ("а")! == "а".

Пожалуйста, позвольте мне объяснить, как читать спецификацию, чтобы прояснить этот вопрос. Я вижу, что в этой очень старой теме никто не дал ответа на очень странный эффект. Итак, если вы можете прочитать спецификацию, это очень поможет вам в вашей профессии. Это приобретенный навык. Итак, продолжим.

Поиск в файле PDF по запросу === приводит меня к странице 56 спецификации: 11.9.4. Оператор строгого равенства (===), и, пройдя через спецификацию, я нахожу:

11.9.6 The Strict Equality Comparison Algorithm
The comparison x === y, where x and y are values, produces true or false. Such a comparison is performed as follows:
  1. If Type(x) is different from Type(y), return false.
  2. If Type(x) is Undefined, return true.
  3. If Type(x) is Null, return true.
  4. If Type(x) is not Number, go to step 11.
  5. If x is NaN, return false.
  6. If y is NaN, return false.
  7. If x is the same number value as y, return true.
  8. If x is +0 and y is −0, return true.
  9. If x is −0 and y is +0, return true.
  10. Return false.
  11. If Type(x) is String, then return true if x and y are exactly the same sequence of characters (same length and same characters in corresponding positions); otherwise, return false.
  12. If Type(x) is Boolean, return true if x and y are both true or both false; otherwise, return false.
  13. Return true if x and y refer to the same object or if they refer to objects joined to each other (see 13.1.2). Otherwise, return false.

Интересен шаг 11. Да, строки рассматриваются как типы значений. Но это не объясняет, почему новая строка ("а")! == "а". У нас есть браузер, не соответствующий ECMA-262?

Не так быстро!

Проверим типы операндов. Попробуйте сами, обернув их в тип(). Я обнаружил, что новая строка ("а") - это объект, и используется шаг 1: вернуть ложный, если типы разные.

Если вам интересно, почему новая строка ("а") не возвращает строку, как насчет упражнения по чтению спецификации? Повеселись!

Айдиакапи написал об этом в комментарии ниже:

From the specification

11.2.2 The new Operator:

If Type(constructor) is not Object, throw a TypeError exception.

With other words, if String wouldn't be of type Object it couldn't be used with the new operator.

новый всегда возвращает объект, даже для конструкторов Нить. Увы! Семантика значений для строк (см. Шаг 11) теряется.

И, наконец, это означает: новая строка ("а")! == "а".

=== проверяет, что одинаковые стороны равны как в тип, так и в ценить.

Пример:

'1' === 1 // will return "false" because `string` is not a `number`

Типичный пример:

0 == ''  // will be "true", but it's very common to want this check to be "false"

Другой распространенный пример:

null == undefined // returns "true", but in most cases a distinction is necessary

Во многих случаях проверка нетипизированный была бы удобна, потому что вам все равно, будет ли значение undefined, null, 0 или "".

В JavaScript это означает одно и то же значение и тип.

Например,

4 == "4" // will return true

но

4 === "4" // will return false 

В PHP и JavaScript это оператор строгого равенства. Это означает, что он будет сравнивать как тип, так и значения.

Значит равенство без приведения типов приведение типов означает, что JavaScript не преобразует автоматически любые другие типы данных в строковые типы данных

0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 

С основная ссылка на javascript

=== Returns true if the operands are strictly equal (see above) with no type conversion.

Оператор === проверяет значения, а также типы переменных на равенство.

Оператор == просто проверяет значение переменных на равенство.

Это строгий контрольный тест.

Это хорошо, особенно если вы проверяете от 0 до false и null.

Например, если у вас есть:

$a = 0;

Потом:

$a==0; 
$a==NULL;
$a==false;

Все вернет истину, и вы можете этого не захотеть. Предположим, у вас есть функция, которая может возвращать 0-й индекс массива или false в случае ошибки. Если вы проверите с "==" false, вы можете получить запутанный результат.

Итак, с тем же, что и выше, но со строгим тестом:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

Оператор сравнения равенства == сбивает с толку, и его следует избегать.

Если вы живете с ИМЕТЬ, запомните следующие 3 вещи:

1. Это не транзитивно: (а == б) и (б == в) не приводят к (а == в)
2. Он является взаимоисключающим по отношению к своему отрицанию: (а == б) и (а! = б) всегда содержат противоположные логические значения со всеми a и b.
3. В случае сомнений выучите наизусть следующую таблицу истинности:

ТАБЛИЦА ИСТИНЫ РАВНОГО ОПЕРАТОРА В JAVASCRIPT

• Каждая строка в таблице представляет собой набор из 3 взаимно «равных» значений, что означает, что любые 2 значения среди них равны с использованием знака равенства == *

** СТРАННО: обратите внимание, что любые два значения в первом столбце не равны в этом смысле. **

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

JSLint иногда дает вам нереальные причины для внесения изменений. === имеет точно такую ​​же производительность, что и ==, если типы уже совпадают.

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

Итак, ИМХО, JSLint можно использовать для написания нового кода, но следует избегать бесполезной чрезмерной оптимизации любой ценой.

Это означает, что нет причин менять == на === в чеке, подобном if (a == 'test'), если вы точно знаете, что a может быть только String.

Такое изменение большого количества кода тратит время разработчиков и рецензентов и ни к чему не приводит.

Как правило, я бы обычно использовал === вместо == (и !== вместо !=).

Причины объяснены в ответах выше, а также Дуглас Крокфорд довольно ясно об этом (JavaScript: хорошие стороны).

Однако есть одно единственное исключение: == null - это эффективный способ проверить, является ли значение null или undefined:

if ( value == null ){
    // value is either null or undefined
}

Например, jQuery 1.9.1 использует этот шаблон 43 раза, а Средство проверки синтаксиса JSHint даже предоставляет расслабляющую опцию eqnull по этой причине.

Из руководство по стилю jQuery:

Strict equality checks (===) should be used in favor of ==. The only exception is when checking for undefined and null by way of null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

ИЗМЕНИТЬ 2021-03:

В настоящее время большинство браузеров поддерживать Оператор нулевого объединения (??) и Логическое нулевое присвоение (??=), что позволяет более кратко присвоить значение по умолчанию, если переменная пуста или не определена, например:

if (a.speed == null) {
  // Set default if null or undefined
  a.speed = 42;
}

можно записать как любую из этих форм

a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;

JavaScript ===против==.

0==false   // true
0===false  // false, because they are of a different type
1= = "1"     // true, auto type coercion
1== = "1"    // false, because they are of a different type

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

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

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.info(a == b)  // false  
console.info(a === b) // false  

В приведенном выше коде и ==, и === получают значение false, потому что a и b - разные объекты.

То есть: если оба операнда == являются объектами, == ведет себя так же, как ===, что также означает идентичность. Существенная разница этих двух операторов заключается в преобразовании типов. == имеет преобразование до проверки равенства, а === нет.

Сравнение равенства:

Оператор ==

Возвращает истину, если оба операнда равны. Перед сравнением операнды преобразуются в один и тот же тип.

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

Равенство и сравнение типов:

Оператор ===

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

>>> 1 === '1'
false
>>> 1 === 1
true

* Операторы === vs == *

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

Вот удобная сравнительная таблица, в которой показаны происходящие преобразования и различия между == и ===.

Как говорится в заключении:

"Use three equals unless you fully understand the conversions that take place for two-equals."

http://dorey.github.io/JavaScript-Equality-Table/

null и undefined - это ничто, то есть

var a;
var b = null;

Здесь a и b не имеют значений. Тогда как 0, false и '' - все значения. У всех них есть одна общая черта: все они являются ложными значениями, что означает, что все они являются ложными условиями удовлетворить.

Итак, 0, false и '' вместе образуют подгруппу. С другой стороны, значения null и undefined образуют вторую подгруппу. Проверьте сравнения на изображении ниже. null и undefined будут равны. Остальные трое будут равны друг другу. Но все они рассматриваются в JavaScript как ложные.

Это то же самое, что и любой объект (например, {}, массивы и т. д.), Непустая строка и логическое значение true являются истинными условиями. Но не все они равны.

Интересное графическое изображение сравнения равенства между == и ===.

Источник: http://dorey.github.io/JavaScript-Equality-Table/

var1 === var2

When using === for JavaScript equality testing, everything is as is. Nothing gets converted before being evaluated.

var1 == var2

When using == for JavaScript equality testing, some funky conversions take place.

Moral of the story:

Use === unless you fully understand the conversions that take place with ==.

В JavaScript есть как строгие сравнения, так и сравнения с преобразованием типов. Строгое сравнение (например, ===) верно только в том случае, если операнды одного типа. Более часто используемое абстрактное сравнение (например, ==) преобразует операнды в один и тот же тип перед выполнением сравнения.

• Оператор равенства (==) преобразует операнды, если они не одного типа, а затем применяет строгое сравнение. Если один из операндов является числом или логическим значением, операнды по возможности преобразуются в числа; иначе, если любой из операндов является строкой, строковый операнд преобразуется в число, если это возможно. Если оба операнда являются объектами, тогда JavaScript сравнивает внутренние ссылки, которые равны, когда операнды ссылаются на один и тот же объект в памяти.

  Синтаксис:

  x == y

  Примеры:

  3 == 3     // true
  "3" == 3   // true
  3 == '3'   // true
  

• Оператор идентичности / строгого равенства (===) возвращает истину, если операнды строго равны (см. Выше) без преобразования типов.

  Синтаксис:

  x === y

  Примеры:

  3 === 3 // true

Для справки: Операторы сравнения (Сеть разработчиков Mozilla)

Да! Это имеет значение.

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

Вы можете легко это проверить. Вставьте следующий код в HTML-файл и откройте его в браузере.

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

Вы получите предупреждение «ложный». Теперь измените метод onPageLoad() на alert(x == 5);, вы получите правда.

Если вы создаете веб-приложение или защищенную страницу, вы всегда должны использовать (только когда это возможно)

===

потому что он проверит, является ли это одним и тем же содержимым и одного типа!

поэтому, когда кто-то входит:

var check = 1;
if (check == '1') {
    //someone continued with a string instead of number, most of the time useless for your webapp, most of the time entered by a user who does not now what he is doing (this will sometimes let your app crash), or even worse it is a hacker searching for weaknesses in your webapp!
}

но с

var check = 1;
if (check === 1) {
    //some continued with a number (no string) for your script
} else {
    alert('please enter a real number');
}

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

Я считаю, что

===

добавит безопасности вашим скриптам

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

Причина, по которой я опубликовал это, заключается в том, что в этом разговоре никогда не использовалось слово «более безопасный» или «безопасность» (если вы посмотрите на iCloud.com, он использует 2019 раз === и 1308 раз ==, это также означает, что вы иногда используйте == вместо ===, потому что в противном случае это заблокирует вашу функцию, но, как сказано в начале, вы должны использовать === как можно чаще)

Просто

== означает принуждение типа сравнение между операндами с

а также

=== означает принуждение типа сравнение между операндами без.

Приведение типов в JavaScript означает автоматическое преобразование типов данных в другие типы данных.

Например:

123 == "123"  // Returns true, because JS coerces string "123" to number 123
              // and then goes on to compare `123 == 123`.

123 === "123" // Returns false, because JS does not coerce values of different types here.

=== заботится о том, совпадают ли объекты. Следовательно, new String("Hello world") === "Hello world" возвращает false. Однако == не заботится о том, совпадают ли объекты; он просто преобразует один аргумент в тип другого: если преобразование невозможно, верните false. Тогда new String("Hello world") == "Hello world" возвращает true вместо false.

Простой пример:

2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.

JavaScript - это слабо типизированный язык, т.е. без каких-либо типов данных, как в C, например, C++. int, boolean, float и т. д., таким образом, переменная может содержать любой тип значения, поэтому существуют эти специальные операторы сравнения

Например

var i = 20;var j = "20";

если мы применим операторы сравнения, результат этих переменных будет

i==j //result is true

или же

j != i//result is false

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

если мы сделаем

i===j //result is false

Мой процесс рассуждений с использованием emacs org-mode и node.js для запуска теста.

| use ==     | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | t     | f       | f         | f    | f          |
| '0'        |    | x   | t     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | t          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | t    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          | 



| use ===    | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | x  | f   | f     | f       | f         | f    | f          |
| '0'        |    | x   | f     | f       | f         | f    | f          |
| false      |    |     | x     | f       | f         | f    | f          |
| 'false'    |    |     |       | x       | f         | f    | f          |
| undefined  |    |     |       |         | x         | f    | f          |
| null       |    |     |       |         |           | x    | f          |
| ' \t\r\n ' |    |     |       |         |           |      | x          |

Мой тестовый сценарий ниже: запустить> node xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
var colItems = rowItems

for(var i = 0; i < rowItems.length; i++) {
    for (var j = 0; j < colItems.length; j++) {
        var r = (rowItems[i] === colItems[j]) ? true : false;
        console.info(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
    };
}

Блок-схема выполнения Javascript для строгого равенства / сравнения '==='

Блок-схема выполнения Javascript для нестрогого равенства / сравнения '=='

Да, существует большая разница между равенством == и идентичностью операторов ===. Обычно оператор идентификации работает быстрее, потому что преобразование типов не выполняется. Но если значения одного типа, вы не увидите разницы. Посмотрите мой пост Легенда оператора равенства JavaScript, который объясняет детали, включая алгоритмы преобразования и сравнения типов, с множеством примеров.

Один Неупомянутая причина использования === - в том случае, если вы сосуществуете с / кросс-компиляцией с / с coffee-script. От Маленькая книга по CoffeeScript ...

The weak equality comparison in JavaScript has some confusing behavior and is often the source of confusing bugs.

The solution is to instead use the strict equality operator, which consists of three equal signs: ===. It works exactly like the normal equality operator, but without any type coercion. It's recommended to always use the strict equality operator, and explicitly convert types if needs be.

Если вы регулярно переходите на coffee-script и обратно, вам следует просто использовать ===. Фактически, компилятор coffee-script будет заставить вас ...

CoffeeScript solves this by simply replacing all weak comparisons with strict ones, in other words converting all == comparators into ===. You can't do a a weak equality comparison in CoffeeScript, and you should explicitly convert types before comparing them if necessary.

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

Javascript типизирован так же, как и php,

var x = "20";
var y =20;

if (x===y) // false

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

Один - строка, другой - int

If(x==y)//true

Однако это просто проверяет, является ли контент одинаковым, независимо от типов данных ...

Я не хочу говорить, что значения равны, потому что строковое значение не может быть логически равно значению int

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Увидел это в одном из ответов. a и b в данном случае не одного типа, если вы проверите typeof(a). вы получите 'объект', а typeof(b) - 'нить'.

Почему == такой непредсказуемый?

Что вы получите, если сравните пустую строку "" с нулевым номером 0?

true

Да, согласно ==, пустая строка и ноль совпадают.

И это еще не все, вот еще один:

'0' == false // true

С массивами дела обстоят действительно странно.

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

Тогда страннее со струнами

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

Становится хуже:

Когда равно не равно?

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

Позвольте мне сказать это еще раз:

(A == B) && (B == C) // true
(A == C) // **FALSE**

И это просто безумие, которое можно получить с примитивами.

Когда вы используете == с объектами, это совершенно новый уровень безумия.

В этот момент вам, вероятно, интересно ...

Почему это происходит?

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

== выполняет куча прочего.

Он имеет специальную обработку для функций, специальную обработку для значений NULL, undefined, строк и т. д.

Это довольно странно.

Фактически, если вы попытаетесь написать функцию, которая делает то, что делает ==, она будет выглядеть примерно так:

function isEqual(x, y) { // if `==` were a function
    if (typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if (xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if (typeof y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if (typeof x === "string") {
            return x === y.toString();
        } else if (typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    if (typeof x === "object") x = toPrimitive(x);
    if (typeof y === "object") y = toPrimitive(y);
    if (typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if (typeof x !== "number") x = +x;
    if (typeof y !== "number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if (obj !== value) return value;
    return obj.toString();
}

Так что это значит?

Значит, == сложен.

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

Это означает, что вы можете столкнуться с ошибками.

Итак, мораль этой истории ...

Сделайте свою жизнь менее сложной.

Используйте === вместо ==.

Конец.

1 == "1"    =>    true(define)
true === "true"    => false(undefined compare the type of variable)
Case 1
if (true === "true"){
  echo 'true'
}else{
 echo 'false undefined'
}
Ans :- false undefined because case 1 is check data type also with ===  
Case 2
if (1 == "1"){
  echo 'true define'
}else{
 echo 'false undefined'
}
Ans :- true define undefined because case 2 is not check data type with ==

Во-первых, некоторая терминология о Javascript string equals: Double equals официально известна как оператор сравнения абстрактного равенства, в то время как тройное равенство называется оператором сравнения строгого равенства. Различие между ними можно резюмировать следующим образом: абстрактное равенство будет пытаться разрешить типы данных посредством приведения типов перед выполнением сравнения. Строгое равенство вернет false, если типы различаются. Рассмотрим следующий пример:

console.info(3 == "3"); // true
console.info(3 === "3"); // false.
console.info(3 == "3"); // true
console.info(3 === "3"); // false.

Использование двух знаков равенства возвращает истину, потому что строка «3» преобразуется в число 3 перед проведением сравнения. Три знака равенства означает, что типы разные, и возвращает false. Вот еще одно:

console.info(true == '1'); // true
console.info(true === '1'); // false
console.info(true == '1'); // true
console.info(true === '1'); // false

Опять же, сравнение абстрактного равенства выполняет преобразование типа. В этом случае и логическое значение «истина», и строка «1» преобразуются в число 1, и результат будет истинным. Строгое равенство возвращает false.

Если вы понимаете, что уже хорошо разбираетесь в различиях между == и ===. Однако есть некоторые сценарии, в которых поведение этих операторов не интуитивно понятно. Давайте взглянем на еще несколько примеров:

console.info(undefined == null); // true
console.info(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.
console.info(undefined == null); // true     
console.info(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.

console.info(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
console.info(true === 'true'); // false
console.info(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
console.info(true === 'true'); // false

Пример ниже интересен тем, что он показывает, что строковые литералы отличаются от строковых объектов.

console.info("This is a string." == new String("This is a string.")); // true
console.info("This is a string." === new String("This is a string.")); // false
console.info("This is a string." == new String("This is a string.")); // true
console.info("This is a string." === new String("This is a string.")); // false

Оператор == просто сравнивает значения, а не тип данных.

Оператор === сравнивает значения со сравнением своего типа данных.

например:

1 == "1" //true

1 === "1" //false

Этот оператор ("== = ") используется в языках, которые выполняют автоматическое приведение типов, например. Оператор PHP, Javascript.
"== = " помогает предотвратить неожиданное сравнение, вызванное автоматическим приведением типов.

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

Строгое равенство с использованием ===

Strict equality compares two values for equality. Neither value is implicitly converted to some other value before being compared. If the values have different types, the values are considered unequal. Otherwise, if the values have the same type and are not numbers, they're considered equal if they have the same value. Finally, if both values are numbers, they're considered equal if they're both not NaN and are the same value, or if one is +0 and one is -0.

var num = 0;
var obj = new String('0');
var str = '0';

console.info(num === num); // true
console.info(obj === obj); // true
console.info(str === str); // true

console.info(num === obj); // false
console.info(num === str); // false
console.info(obj === str); // false
console.info(null === undefined); // false
console.info(obj === null); // false
console.info(obj === undefined); // false

Свободное равенство с использованием ==

Loose equality compares two values for equality, after converting both values to a common type. After conversions (one or both sides may undergo conversions), the final equality comparison is performed exactly as === performs it. Loose equality is symmetric: A == B always has identical semantics to B == A for any values of A and B (except for the order of applied conversions).

var num = 0;
var obj = new String('0');
var str = '0';

console.info(num == num); // true
console.info(obj == obj); // true
console.info(str == str); // true

console.info(num == obj); // true
console.info(num == str); // true
console.info(obj == str); // true
console.info(null == undefined); // true

// both false, except in rare cases
console.info(obj == null);
console.info(obj == undefined);

Different's Between = , = = , = = =

• Оператор = Используется только для назначения value.
• Оператор = = Используется для простого сравнения values, а не datatype
• Оператор = = = Используется для сравнения values, а также datatype.

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

Строгое равенство по большей части лучше

Тот факт, что Javascript - это слабо типизированный язык, должен постоянно находиться в вашем уме, когда вы работаете с ним. Пока структура данных одна и та же, действительно нет причин не использовать строгое равенство, при обычном равенстве часто происходит неявное преобразование значений, которое происходит автоматически, что может иметь далеко идущие последствия для вашего кода. Очень легко получить проблемы с этим преобразованием, поскольку они происходят автоматически.

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

Дилемма «Следует ли мне использовать == или === при сравнении JavaScript» аналогична или аналогична вопросу: «Следует ли мне использовать« ложку »или« вилку »для еды.

Единственный разумный ответ на этот вопрос:

1. Вы должны использовать сравнение Динамический Тип, например: == для сравнения свободный Тип.
2. Вы должны использовать сравнение Статический тип, например: === для сравнения сильный Тип.

Это потому, что они разные. Они не имеют той же цели и не предназначены для использования с той же целью.

Конечно, и вилки, и ложки предназначены для «еды», но вы решите использовать их в соответствии с тем, что вам подали.

Значение: вы решите использовать «ложку», например: ==, чтобы приготовить «суп», и / или «вилку», например: ===, для сбора.

Спросить, лучше ли использовать «вилку» или «ложку» для «еды» - все равно что спросить, лучше ли использовать статический [===] или динамический [==] уравнение, op. в JS. Оба вопроса одинаково неверны и отражают очень узкое или поверхностное понимание предмета, о котором идет речь.