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

avatar
bcasp
11 декабря 2008 в 14:19
1927000
48
5658

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

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

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

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

Источник

Ответы (48)

avatar
Bill the Lizard
11 декабря 2008 в 14:25
6844

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

Ссылка: Учебное пособие по 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

Equality Comparison Table

Отсутствие транзитивности настораживает. Мой совет - никогда не использовать злых близнецов. Вместо этого всегда используйте === и !==. Все только что показанные сравнения дают 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 для создания строковых объектов из строковых литералов.

Ссылка

Ovinus Real
11 октября 2020 в 13:39
2

Я также хотел бы указать, что 0 === -0 и NaN! == NaN, что иногда может сбивать с толку. Если вы хотите различать ± 0 и считать NaN равными, используйте Object.is (ES2015)

aross
25 марта 2021 в 09:29
0

Мягкий ввод - это функция . Очевидно, Крокфорд указывает на некоторые «артефакты» дизайнерского решения, но мягкая печать все еще остается функцией. При правильном использовании абсолютно нормально использовать . Не выбрасывайте ребенка вместе с водой из ванны.

avatar
Kalpesh Rajai
29 апреля 2019 в 01:53
1191

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

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 тест), поскольку он пропускает один шаг.

avatar
Bekim Bacaj
26 ноября 2017 в 19:38
1

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

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

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

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

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

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

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

Bekim Bacaj
5 декабря 2017 в 22:08
0

PS: JSLint (или Crockford) не подходит для того, чтобы настаивать или просить вас использовать строгое сравнение типов при работе со значениями одного и того же типа. Свойство JavaScript length всегда имеет тип: число. И поэтому нет места или возможности для фальшивых срабатываний. Кроме того, нет необходимости в dSele_UNVEHtype.value.length === 0, когда вы можете использовать вместо него прямое сокращение !dSele_UNVEHtype.value.length.

Jasper
22 декабря 2017 в 13:49
2

Зачем вам отвечать на вопрос 9-летней давности, на который уже есть 49 ответов, на который также есть принятый ответ с более чем 5 тыс. Голосов, с ответом, который содержит странную аналогию и не объясняет ничего из того, что еще не было сказано?

Bekim Bacaj
26 декабря 2017 в 13:13
1

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

Jasper
27 декабря 2017 в 08:22
1

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

Bekim Bacaj
28 декабря 2017 в 17:14
0

Приведенная аналогия является лучшей иллюстрацией их различия и качества использования. Это лучшее короткое эссе, чтобы узнать абсолютную суть, даже если вы новичок в JS. И не менее хорош, возможно, лучше, чем мой поздний ответ о том, как очистить массив JS [по-настоящему].

avatar
Neil Meyer
16 ноября 2017 в 10:56
3

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

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

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

avatar
Narendra Kalekar
1 августа 2017 в 09:13
1

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

avatar
RïshïKêsh Kümar
25 июня 2017 в 10:21
8

Разные между =, = =, = = =

  • Оператор = Используется для простого присвоения value.
  • = = оператор Используется для простого сравнения values, а не datatype
  • Оператор = = = Используется для сравнения values, а также datatype.
avatar
Alireza
7 мая 2017 в 12:10
1

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

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

Строгое равенство сравнивает два значения на равенство. Ни одно из значений не неявно конвертируется в какое-либо другое значение перед сравнением. Если значения имеют разные типы, значения считаются неравными. В противном случае, если значения имеют один и тот же тип и не являются числами, они считаются равными, если имеют одинаковую ценность. Наконец, если оба значения являются числами, они считаются равными, если они оба не 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);
SeanRamzan
18 мая 2017 в 15:45
0

Я действительно считаю, что это субъективно в отношении того, что вы должны / не должны делать, и вводить в заблуждение, когда кто-то всегда использует определенное действие. Хотя я согласен с тем, что в большинстве случаев мы предпочитаем использовать '===' вместо '==', может быть особый случай, когда вы хотите, чтобы преобразование типа было выполнено. - Я не могу придумать точный вариант использования, но, возможно, дизайн должен быть свободным. В любом случае, если что-то и включено в язык, значит, на это есть причина. На мой взгляд, нам следует избегать общих заявлений о том, что «всегда делай х».

Alireza
18 мая 2017 в 17:41
0

Я почти согласен с вами, если вы прочитаете мой ответ полностью, вы видите, что я объясню более подробно позже, честно говоря, мы не так много случаев используем и нуждаемся в свободном сравнении в Javascript ... Я могу сказать, что менее 5 процентов , даже намного меньше, но я использую «всегда» для тех людей без фона js, которые думают == проверяют строгое сравнение в JavaScript, они учатся быть терпеливыми и не используют его в первую очередь, но по мере того, как они становятся более опытными, они знать, в каких редких случаях они могут его использовать. Вот почему я так пишу свой ответ.

avatar
Sharad Kale
28 апреля 2017 в 04:55
8
Оператор

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

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

например:

1 == "1" //true

1 === "1" //false

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

mrmr68
25 мая 2017 в 12:04
0

для '==' dataType не важен

Sebastian Simon
22 мая 2020 в 20:13
0

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

avatar
Rotimi
24 апреля 2017 в 12:11
1

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

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

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

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

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

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

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
avatar
Luis Perez
9 августа 2016 в 16:50
90

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

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

Что это значит?

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

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

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

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

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

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

Конец.

avatar
Orri Scott
5 июля 2016 в 12:53
0
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) будет 'строка' .

avatar
yanguya995
1 июля 2016 в 17:00
1

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

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

if (x===y) // false

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

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

If(x==y)//true

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

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

avatar
Alexandr
1 июля 2016 в 13:29
7

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

avatar
Alex Gray
15 мая 2016 в 00:06
5

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

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

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

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

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

avatar
Dmitri Pavlutin
4 января 2016 в 13:26
5

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

avatar
Samar Panda
5 сентября 2015 в 13:53
74

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

Javascript strict equality

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

Javascript non equality

avatar
CodeFarmer
6 августа 2015 в 05:44
13

Мой процесс рассуждений с использованием 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 + "]")
    };
}
avatar
Akshay Khale
22 июля 2015 в 13:28
11

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
avatar
Vikas
14 мая 2015 в 14:45
28

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

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

2 === '2'  -> false, values are NOT SAME because of no type conversion.
avatar
29 марта 2015 в 21:48
12

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

Sebastian Simon
15 марта 2021 в 09:20
0

Этот ответ немного ошибочен или, по крайней мере, не очень точен… «объекты»? Вы имеете в виду «типы»? == заботится о том, совпадают ли типы; он делегирует строгое сравнение на равенство, если они есть. Два объекта сравниваются по ссылке, но это касается обоих операторов. «если преобразование невозможно» - я думаю ... но обычно возможно принуждение, и этого недостаточно, чтобы вызвать тот или иной результат сравнения, например "undefined" != undefined, даже если принуждение возможно.

avatar
Amit
20 марта 2015 в 05:05
34

Просто

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

и

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

Приведение типов в 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.
avatar
Sake Salverda
28 ноября 2014 в 20:06
16

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

===

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

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

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

avatar
Aniket Thakur
14 ноября 2014 в 06:02
39

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

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

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 .

avatar
vivek_nk
26 октября 2014 в 11:15
21

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

var a;
var b = null;

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

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

Enter image description here

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

avatar
garakchy
8 августа 2014 в 16:52
18

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

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

    Синтаксис:

    x == y

    Примеры:

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

    Синтаксис:

    x === y

    Примеры:

    3 === 3 // true

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

avatar
SNag
5 мая 2014 в 05:21
792

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

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


var1 === var2

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

Equality evaluation of === in JS


var1 == var2

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

Equality evaluation of == in JS


Заключение:

Всегда используйте === .

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

rocketsarefast
24 мая 2021 в 14:40
0

Лучшая таблица '==': algassert.com/visualization/2014/03/27/…

avatar
Christian Hagelid
27 марта 2014 в 00:18
21

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

Согласно заключению:

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

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

avatar
Mr.G
19 марта 2014 в 12:08
18

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

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true
avatar
user2601995
2 октября 2013 в 21:54
22

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

Оператор ==

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

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

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

Оператор ===

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

>>> 1 === '1'
false
>>> 1 === 1
true
avatar
Harry He
9 сентября 2013 в 08:31
26

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

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

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

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

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

avatar
user2496033
3 июля 2013 в 04:08
56

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
avatar
mar10
27 апреля 2013 в 14:15
28

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

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

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

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;

ИЗМЕНИТЬ 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;
Sebastian Simon
15 марта 2021 в 09:24
0

«== null - это эффективный способ проверки« is null или undefined ’» или document.all.

avatar
ashes
5 июня 2012 в 07:53
33

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

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

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

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

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

aross
25 марта 2021 в 10:17
0

Интересно, что a.length===4 на самом деле медленнее в Firefox, чем a.length==4. В любом случае это микрооптимизация, но это противоречит тому, что люди утверждают.

avatar
CuongHuyTo
16 сентября 2011 в 14:25
47

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

Если вы ДОЛЖНЫ жить с этим, помните следующие 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.
avatar
Daniel
12 мая 2010 в 13:19
34

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

Это хорошо, особенно если вы проверяете от 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
Ry-♦
6 мая 2013 в 03:07
3

В JavaScript это совершенно неправильно и ошибочно неполно. 0 != null. -1

avatar
Niraj CHoubey
12 мая 2010 в 13:03
34

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

Оператор

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

avatar
Paul Butcher
12 мая 2010 в 12:59
23

Из основной ссылки javascript

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

avatar
Pop Catalin
12 мая 2010 в 12:59
55

Это означает равенство без приведения типа принуждение типа означает, что 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 
avatar
Shiki
12 мая 2010 в 12:58
104

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

avatar
Dimitar
12 мая 2010 в 12:58
100

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

Например,

4 == "4" // will return true

но

4 === "4" // will return false 
avatar
vsync
12 мая 2010 в 12:58
85

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


Пример:

'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 или "" или "" ""

avatar
nalply
28 ноября 2009 в 18:18
276

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

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

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

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

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

11.9.6 Алгоритм сравнения строгого равенства
Сравнение x === y, где x и y - значения, дает истина или ложь . Такое сравнение выполняется следующим образом:
1. Если Тип (x) отличается от Типа (y), вернуть false .
2. Если Type (x) - Undefined, вернуть true .
3. Если Тип (x) равен Null, вернуть true .
4. Если тип (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. Если Тип (x) равен String, то вернуть true , если x и y - это точно такая же последовательность символов (одинаковая длина и одинаковые символы в соответствующих позициях); в противном случае верните false .
12. Если Type (x) - Boolean, вернуть true , если x и y оба равны true или оба false ; в противном случае верните false .
13. Верните true , если x и y относятся к одному и тому же объекту или если они относятся к объектам, соединенным друг с другом (см. 13.1.2). В противном случае верните false .

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

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

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

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


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

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

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

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

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

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

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

avatar
Philippe Leybaert
5 июня 2009 в 19:11
636

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

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

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 и <647418375> имеют одинаковый тип8228 >

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

Для строк: ​​
a === b возвращает истину, если a и b являются точными символами 187317 и содержат> 18375173


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

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

avatar
Thomas Hansen
29 декабря 2008 в 11:54
23

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

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

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

CString x;
delete x;

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

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

Garrett
13 января 2014 в 00:25
4

0 == null ложно.

avatar
Simon Scarfe
25 декабря 2008 в 11:17
107

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

Hubert OG
13 июля 2013 в 21:13
6

Теперь, как они сравниваются, когда есть фактическое приведение типа для оператора ==? Помните, что тогда производительность повышается.

Doug Morrow
6 июля 2015 в 17:04
3

ОСНОВНАЯ разница при правильном тестировании по вышеупомянутым причинам, заключающаяся в более быстрой проверке только неравенства типов. jsfiddle.net/4jhuxkb2

avatar
Constantin
16 декабря 2008 в 14:29
49

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

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

avatar
Doctor Jones
11 декабря 2008 в 14:58
91

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

Возьмем 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");
}

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

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

avatar
Sean
11 декабря 2008 в 14:44
41

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