it-swarm.com.ru

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

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

Есть ли выигрыш в производительности при замене == на ===?

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

Если преобразование типов не выполняется, будет ли увеличение производительности по сравнению с ==?

5670
bcasp

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

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

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

Процитирую превосходное Дугласа Крокфорда 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'sanswer относительно ссылочных типов. Для ссылочных типов == и === действуют согласованно друг с другом (за исключением специального случая).

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.

6187
Bill the Lizard

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

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

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

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

1073
Andreas Grech

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

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


var1 === var2

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

Equality evaluation of === in JS


var1 == var2

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

Equality evaluation of == in JS

Мораль истории:

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

637
SNag

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

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

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, которое в большинстве случаев ведет себя как строка .

596
Philippe Leybaert

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

В случае сомнений прочитайте спецификацию !

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

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

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

11.9.6 Алгоритм сравнения строгого равенства
Сравнение x === y, где x и y являются значениями, дает true или ложь . Такое сравнение выполняется следующим образом:
1. Если Тип (x) отличается от Типа (y), верните false .
2. Если Тип (x) не определен, верните true .
3. Если Тип (x) равен Null, верните true .
4. Если Тип (x) не Номер, перейдите к шагу 11.
5. Если x равен NaN , вернуть false ,.
6. Если у - 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. Если тип (x) - логическое значение, верните true , если x и y оба true или оба false ; в противном случае верните false .
13. Вернуть true , если x и y ссылаются на один и тот же объект или если они ссылаются на объекты, соединенные друг с другом (см. 13.1. 2). В противном случае верните false .

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

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

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

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


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

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

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

Если Type (конструктор) не является Object, генерировать исключение TypeError.

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

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

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

261
nalply

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

98
Shiki

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

94
Simon Scarfe

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

Например,

4 == "4" // will return true

но

4 === "4" // will return false 
91
Dimitar

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

Давайте возьмем 2 переменные 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");
}

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

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

80
Doctor Jones

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

Пример:

'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
74
vsync

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

Что вы получаете, когда сравниваете пустую строку "" с нулевым числом 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**

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

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

На данный момент ваш, вероятно, интересно ...

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

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

== выполняет кучу других вещей .

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

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

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

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();
}

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

Это означает, что == сложен.

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

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

Так что мораль этой истории ...

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

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

Конец.

72
Luis Perez

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

Javascript strict equality

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

Javascript non equality

67
Samar Panda

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
53
user2496033

Это означает равенство без приведения типов приведение типов означает, что 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 
52
Pop Catalin

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

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

47
Constantin

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

Если вы ДОЛЖНЫ жить с этим, то помните следующие 3 вещи:

  1. Это не транзитивно: (a == b) и (b == c) не приводит к (a == c)
  2. Это взаимоисключающее исключение: (a == b) и (a! = B ) всегда содержат противоположные логические значения, со всеми 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.
43
CuongHuyTo

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

Оператор === в 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.

36
Aniket Thakur

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

36
Sean

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

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

33
Niraj CHoubey

Это строгий проверочный тест.

Это хорошо, особенно если вы проверяете между 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
31
Daniel

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

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

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

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

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

30
ashes

Просто

== означает сравнение между операндами с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 
29
Amit

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

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

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

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

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

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

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

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

24
Harry He

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

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

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

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

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

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

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

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

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

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

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

CString x;
delete x;

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

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

22
Thomas Hansen

Из основная ссылка на JavaScript

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

22
Paul Butcher

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

Оператор ==

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

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

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

Оператор ===

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

>>> 1 === '1'
false
>>> 1 === 1
true
21
user2601995

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

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

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

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

19
Christian Hagelid

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

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true
19
Mr.G

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

var a;
var b = null;

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

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

Enter image description here

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

19
vivek_nk

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

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

    Синтаксис:

    x == y

    Примеры:

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

    Синтаксис:

    x === y

    Примеры:

    3 === 3 // true

Для справки: операторы сравнения (Mozilla Developer Network)

17
garakchy

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

===

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

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

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 раз ==, это также означает, что вы иногда используйте == вместо ===, потому что иначе это заблокирует вашу функцию, но, как было сказано в начале, вы должны использовать === как можно больше)

16
Sake Salverda

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

13
hopper

Мой процесс рассуждений с использованием 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          |

Мой тестовый скрипт ниже: run> 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.log(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
    };
}
12
CodeFarmer

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
11
Akshay Khale

Различия между =, = =, = = =

  • Оператор = Используется только для назначения value.
  • = = оператор Используется только для сравнения values не datatype
  • Оператор = = = Используется для сравнения values, а также datatype.
9
RïshïKêsh Kümar

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

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

например.

1 == "1" //true

1 === "1" //false

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

7
Sharad Kale

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

6
Alexandr

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

Сравнение слабого равенства в JavaScript имеет некоторое запутанное поведение и часто является источником сбивающих с толку ошибок.

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

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

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

5
Alex Gray

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

5
Dmitri Pavlutin

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

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

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

3
Neil Meyer

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

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

Строгое равенство сравнивает два значения на равенство. Ни одно из значений неявно преобразуется в какое-то другое значение перед сравнением. Если значения имеют разные типы, значения считаются неравными. В противном случае, если значения имеют одинаковый тип и не являются числами, они считаются равными, если имеют одинаковое значение. Наконец, если оба значения являются числами, они считаются равными, если они оба не являются NaN и имеют одинаковое значение, или если одно равно +0, а одно равно -0.

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

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

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


Слабое равенство, используя ==

Свободное равенство сравнивает два значения на равенство после преобразования обоих значений в общий тип. После преобразований (одна или обе стороны могут пройти преобразования), окончательное сравнение на равенство выполняется точно так же, как ===. Свободное равенство симметрично: A == B всегда имеет семантику, идентичную B == A для любых значений A и B (кроме порядка примененных преобразований).

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

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

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

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

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

1
Narendra Kalekar

Javascript свободно печатается так же, как PHP,

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

if (x===y) // false

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

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

If(x==y)//true

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

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

1
yanguya995

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

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

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

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

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

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

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

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

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

console.log("This is a string." == new String("This is a string.")); // true
console.log("This is a string." === new String("This is a string.")); // false
console.log("This is a string." == new String("This is a string.")); // true
console.log("This is a string." === new String("This is a string.")); // false
1
Akintunde-Rotimi

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

Единственный разумный ответ на этот вопрос заключается в том, что

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

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

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

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

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

1
Bekim Bacaj
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), вы получите 'object' и typeof(b) is 'string'.

0
Orri Scott