Какой оператор равен (== vs ===) должен использоваться в сравнении JavaScript?

Я использую JSLint для прохождения через JavaScript, и он возвращает много предложений, чтобы заменить == (два знака равенства) на === (три знака равенства), когда вы делаете что-то вроде сравнения idSele_UNVEHtype.value.length == 0 внутри оператора if.

Есть ли преимущество в производительности для замены == на ===?

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

Если преобразование типа не происходит, будет ли коэффициент усиления по сравнению с ==?

5518
задан bcasp 11 дек. '08 в 17:19
источник поделиться

51 ответ

  • 1
  • 2

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

Справка: Javascript Tutorial: Операторы сравнения

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

Процитировать Douglas Crockford отлично JavaScript: хорошие части,

В JavaScript есть два набора операторов равенства: === и !==, а их злые близнецы == и !=. Хорошие работают так, как вы ожидали. Если два операнда одного типа и имеют одинаковое значение, то === создает true и !== производит false. Злые близнецы поступают правильно, когда операнды одного типа, но если они имеют разные типы, они пытаются принудить ценности. правила, с помощью которых они делают, которые являются сложными и непреодолимыми. Вот некоторые из интересных случаев:

'' == '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

Отсутствие транзитивности вызывает тревогу. Мой совет - никогда не использовать злых близнецов. Вместо этого всегда используйте === и !==. Все приведенные сравнения показывают false с помощью оператора ===.


Обновление:

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

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

5516
ответ дан Bill the Lizard 11 дек. '08 в 17:25
источник поделиться

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

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

Используя оператор === (Identity)

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

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

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

955
ответ дан Andreas Grech 11 дек. '08 в 17:33
источник поделиться

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

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

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 возвращает true, если a и b имеют одинаковое значение и имеют один и тот же тип

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

Для строк:
 a === b возвращает true, если 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, которое большую часть времени ведет себя как строка.

523
ответ дан Philippe Leybaert 05 июня '09 в 22:11
источник поделиться

Интересное живописное представление сравнения равенства == и ===.

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


var1 var2 ===

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

Equality evaluation of === in JS


var1 == var2

При использовании двух знаков равенства для проверки равенства JavaScript некоторые происходят фанки.

Equality evaluation of == in JS


Мораль истории: используйте три равных, если вы не полностью понимаете преобразования, которые имеют место для двух равных.

495
ответ дан SNag 05 мая '14 в 8:21
источник поделиться

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

Если есть сомнения, прочтите спецификацию!

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

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

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

11.9.6 Алгоритм сравнения строгого равенства
Сравнение x === y, где x и y - значения, создает true или false. Такое сравнение выполняется следующим образом:
  1. Если Type (x) отличается от Type (y), верните false.
  2. Если тип (x) равен Undefined, верните true.
  3. Если Type (x) - Null, верните true.
  4. Если Type (x) не является числом, перейдите к шагу 11.
  5. Если x NaN, верните false.
  6. Если y NaN, верните false.
  7. Если x - это то же числовое значение, что и y, верните true.
  8. Если x равно +0, а y равно -0, верните true.
  9. Если x равно -0 и y равно +0, верните true.
  10. Вернуть false.
  11. Если Type (x) - String, верните true, если x и y - это точно такая же последовательность символов (одинаковая длина и одинаковые символы в соответствующих позициях); в противном случае верните false.
  12. Если Type (x) является логическим, верните true, если x и y оба true или оба false; в противном случае верните false.
  13. Верните true, если x и y относятся к одному и тому же объекту или относятся к объектам, связанным друг с другом (см. 13.1.2). В противном случае верните false.

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

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

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

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


Aidiakapi написал это в комментарии ниже:

Из спецификации

11.2.2 Новый оператор:

Если тип (конструктор) не является объектом, вызовите исключение TypeError.

Другими словами, если String не будет иметь тип Object, он не может использоваться с новым оператором.

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

И это, наконец, означает: новый String ( "a" )! == "a" .

241
ответ дан nalply 28 нояб. '09 в 21:18
источник поделиться

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

89
ответ дан Shiki 12 мая '10 в 15:58
источник поделиться

Я тестировал это в 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), и качество кода.

83
ответ дан Simon Scarfe 25 дек. '08 в 14:17
источник поделиться

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

Например,

4 == "4" // will return true

но

4 === "4" // will return false 
81
ответ дан Dimitar 12 мая '10 в 15:58
источник поделиться

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

Возьмем 2 vars a и b.

Для "a == b" для оценки истины 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% не имеет значения, какой из них вы используете, но полезно знать разницу, когда вы получаете какое-то неожиданное поведение в один прекрасный день.

69
ответ дан Doctor Jones 11 дек. '08 в 17:58
источник поделиться

Он проверяет, равны ли одинаковые стороны в типе, а также значение.

Пример:

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

Общий пример:

0 == ''  // will be "true", but it very common to want this check to be "false"
60
ответ дан vsync 12 мая '10 в 15:58
источник поделиться

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

Javascript строгое равенство

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

Javascript non равенство

58
ответ дан Samar Panda 05 сент. '15 в 16:53
источник поделиться

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

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

<код > Trueкод >

Да, это правильно в соответствии с == пустая строка, а числовое ноль - одно и то же время.

И это не заканчивается, вот еще один:

  '0' == false//true
Код>

Вещи становятся очень странными с массивами.

  [1] == true//true
[] == false//true
[[]] == false//true
[0] == false//true
Код>

Затем weerder со строками

  [1,2,3] == '1,2,3'//true - ДЕЙСТВИТЕЛЬНО?!
'\ r\n\t' == 0//true - Давай!
Код>

Ухудшается:

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

  let A = ''//пустая строка
пусть В = 0//нуль
пусть C = '0'//нулевая строка

A == B//true - ok...
B == C//true - пока что так хорошо...
A == C//** FALSE ** - Закручивание сюжета!
Код>

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

  (A == B) && & & (B == C)//true
(A == C)//** FALSE **
Код>

И это просто сумасшедший материал, который вы получаете с примитивами.

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

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

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

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

== делает целую кучу других вещей.

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

Это становится довольно дурацким.

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

  function isEqual (x, y) {//если `==` были функцией   if (typeof y === typeof x) return y === x;   // обрабатываем null и undefined то же самое   var xIsNothing = (y === undefined) || (y === null);   var yIsNothing = (x === undefined) || (x === null);
   если (xIsNothing || yIsNothing) возвращается (xIsNothing & yIsNothing);
   if (typeof y ===  "function"  || typeof x ===  "function" ) {       // если любое значение является строкой       // преобразовать функцию в строку и сравнить       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;
   // конвертируем x и y в числа, если они еще не используют трюк +   if (typeof x! ==  "number" ) x = + x;   if (typeof y! ==  "number" ) y = + y;   // фактически реальный `==` еще более сложный, чем это, особенно в ES6   return x === y;
}

функция toPrimitive (obj) {   var value = obj.valueOf();   if (obj! == value) возвращаемое значение;   return obj.toString();
}
Код>

Итак, что это значит?

Это означает, что == является сложным.

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

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

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

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

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

Конец.

50
ответ дан Luis Perez 09 авг. '16 в 19:50
источник поделиться

JavaScript === vs ==.

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
48
ответ дан user2496033 03 июля '13 в 7:08
источник поделиться

Это означает равенство без принуждения типа тип принуждения означает, что 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 
45
ответ дан Pop Catalin 12 мая '10 в 15:59
источник поделиться

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

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

43
ответ дан Constantin 16 дек. '08 в 17:29
источник поделиться

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

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

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

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

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

** STRANGE: обратите внимание, что любые два значения в первом столбце не равны в этом смысле. **

''       == 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.
39
ответ дан CuongHuyTo 16 сент. '11 в 17:25
источник поделиться

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

31
ответ дан Sean 11 дек. '08 в 17:44
источник поделиться

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

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

enter image description here

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

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

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

30
ответ дан Aniket Thakur 14 нояб. '14 в 9:02
источник поделиться

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

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

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

$a = 0;

Тогда:

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

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

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

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false
28
ответ дан Daniel 12 мая '10 в 16:19
источник поделиться
Оператор

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

Оператор

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

28
ответ дан Niraj CHoubey 12 мая '10 в 16:03
источник поделиться

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

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

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

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

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

25
ответ дан ashes 05 июня '12 в 10:53
источник поделиться

Просто

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

&

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

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

Например:

123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator 
25
ответ дан Amit 20 марта '15 в 8:05
источник поделиться

Простым примером является

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

2 === '2'  -> false, values are NOT SAME because of no type conversion.
24
ответ дан Vikas 14 мая '15 в 17:45
источник поделиться

Топ-2 ответов на оба упомянутых == означает равенство и === означает идентификатор. К сожалению, это утверждение неверно.

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

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

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

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

21
ответ дан Harry He 09 сент. '13 в 11:31
источник поделиться

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

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

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

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

Например, jQuery 1.9.1 использует этот шаблон 43 раза, а руководство по стилю jQuery:

Строгие проверки равенства (===) должны использоваться в пользу ==. Единственный Исключение составляет при проверке для undefined и null с помощью null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;
20
ответ дан mar10 27 апр. '13 в 17:15
источник поделиться

В базовая ссылка javascript

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

19
ответ дан Paul Butcher 12 мая '10 в 15:59
источник поделиться

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

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

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

CString x;
delete x;

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

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

18
ответ дан Thomas Hansen 29 дек. '09 в 14:54
источник поделиться

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

Оператор ==

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

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

Сравнение уровней и типов:

Оператор ===

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

>>> 1 === '1'
false
>>> 1 === 1
true
17
ответ дан user2601995 03 окт. '13 в 0:54
источник поделиться

null и undefined - небытие, то есть

var a;
var b = null;

Здесь a и b не имеют значений. Принимая во внимание, что 0, false и '' - все значения. Одно из них заключается в том, что все они являются ложными значениями, а это означает, что все удовлетворяют условиям фальшивости.

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

Enter image description here

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

16
ответ дан vivek_nk 14 апр. '14 в 12:28
источник поделиться

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

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true
15
ответ дан Mr.G 19 марта '14 в 15:08
источник поделиться
  • 1
  • 2

Другие вопросы по меткам