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

Използвам JSLint за преминаване през JavaScript и връща много изречения, които да заменят == (два знака за равенство) с === (три равни знака), когато правите нещо като сравнение idSele_UNVEHtype.value.length == 0 оператор, if .

Има ли предимство за производителност за замяна на == с === ?

Всяко подобрение на производителността ще бъде добре дошло, тъй като има много оператори за сравнение.

Ако преобразуването на типа не се случи, ще се сравни ли печалбата с == ?

5673
11 дек. настроен от bcasp 11 декември 2008-12-11 17:19 '08 в 17:19 2008-12-11 17:19
ответ 51 отговора
  • 1
  • 2

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

Справка: Урок на 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 по отношение на типовете справки. За референтни типове == и === действат последователно една с друга (освен в специалния случай).

 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 

Специален случай е сравняването на литерала с обект, който оценява същия литерал поради valueOf 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

5840
11 дек. Отговор, даден от Bill Lizard на 11 декември 2008-12-11 17:25 '08 в 17:25 ч. 2008-12-11 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 

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

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

Това се дължи на факта, че операторът за равенство == има тип принуда , което означава, че интерпретаторът имплицитно се опитва да преобразува стойностите преди сравнението.

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

1016
11 дек. Отговорът е даден от Andreas Grech 11 декември. 2008-12-11 17:33 '08 в 17:33 2008-12-11 17:33

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

Така че нека вземем следния код:

 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 , който се държи през повечето време като низ.

564
05 июня '09 в 22:11 2009-06-05 22:11 отговори на Philippe Leybaert на 05.06.09 в 10:11 2009-06-05 22:11

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

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


var1 === var2

Когато използвате === за тестване на JavaScript равенството, всичко е както е. Преди оценката нищо не се преобразува.

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 отговорът е даден от SNag на 05 май 14 в 8:21 2014-05-05 08: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. Ако type (x) е Undefined, върнете true .
3. Ако Type (x) е Null, върнете true .
4. Ако Type (x) не е число, преминете към стъпка 11. \ t
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) е boolean, върнете true, ако x и y са истина или и двете са 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.

С други думи, ако низът не е от тип Object, той не може да се използва с новия оператор.

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

И накрая това означава: новия String ("а")! == "a" .

254
28 нояб. Отговорът е даден на 28 ноември. 2009-11-28 21:18 '09 в 21:18 2009-11-28 21:18

В PHP и JavaScript това е оператор за стриктно равенство. Това означава, че ще сравнява типа и стойностите.

95
12 мая '10 в 15:58 2010-05-12 15:58 отговорът е даден от Шики на 12 май '10 в 15:58 2010-05-12 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 

Така че, бих казал, че една малка разлика (това е повече от 100 000 повторения, не забравяйте) е незначителна. Изпълнението не е причина === . Вид на сигурността (добре, толкова безопасно, колкото ще JavaScript), както и качеството на кода.

91
25 дек. Отговорът е даден от Саймън Скарфе на 25 декември. 2008-12-25 14:17 '08 в 14:17 ч. 2008-12-25 14:17

В JavaScript това означава една и съща стойност и тип.

Например

 4 == "4" // will return true 

но

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 отговорът е даден от Димитър на 12 май '10 в 15:58 2010-05-12 15:58

Операторът === се нарича оператор за стриктно сравнение, той е различен от оператора == .

Вземете 2 vars a и b.

За "a == b", за да се оцени истинността на a и b трябва да бъде една стойност .

В случай на "а === b" а и 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% използване няма значение кой ще използвате, но е полезно да знаете разликата, когато един ден получите някакво неочаквано поведение.

77
11 дек. Отговорът е даден от Доктор Джоунс 11 декември. 2008-12-11 17:58 '08 в 17:58 ч. 2008-12-11 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" 

Друг често срещан пример е:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 отговорът е даден от vsync на 12 май '10 в 15:58 2010-05-12 15:58

Защо == толкова непредсказуемо?

Какво получавате, когато сравните празния низ с номера 0 0 ?

<code> Truecode>

Да, това е правилно в съответствие с == празен низ, а числовата нула е едно и също време.

И това не свършва дотук, друго:

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

Нещата стават много странни с масивите.

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

След това с низове

  [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 ** Код> 

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

Това е ново ниво на лудост, когато използвате == с обекти.

На този етап вероятно се чудите ...

Защо се случва това?

Добре, защото за разлика от "тройното равенство" ( === ), което просто проверява дали двете стойности съвпадат.

== цял куп други неща .

Той има специална обработка за функции, специална обработка за нули, неопределени, низове, които наричате.

Тя става доста тъпа.

Всъщност, ако се опитате да напишете функция, която прави това, което прави == , тя ще изглежда по следния начин:

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

И така, какво означава това?

Това означава, че == е сложно.

Тъй като е трудно, трудно е да се разбере какво ще се случи, когато го използвате.

Това означава, че може да имате грешки.

Така че моралът на историята ...

Направете живота си по-малко сложен.

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

Краят.

68
09 авг. отговорът е даден от Луис Перес 09 август. 2016-08-09 19:50 '16 в 19:50 2016-08-09 19:50

Диаграма за последователност на изпълнение на Javascript за стриктно равенство / Сравнение '==='

2019

05 сент. отговорът е даден на Самар Панда 05 сеп. 2015-09-05 16:53 '15 в 16:53 2015-09-05 16:53

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 
52
03 июля '13 в 7:08 2013-07-03 07:08 отговорът е даден от user2496033 03 юли '13 в 7:08 2013-07-03 07: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 
51
12 мая '10 в 15:59 2010-05-12 15:59 отговорът е даден от Поп Каталин на 12 май '10 в 15:59 2010-05-12 15:59

В един типичен скрипт няма да има разлика в производителността. По-важното е, че фактът, че хиляда "===" е 1 килобайт, е по-тежък от хиляда "==" :) Профилерите на JavaScript могат да ви кажат дали има разлика в производителността във вашия случай.

Но лично аз бих направил това, което JSLint предлага. Тази препоръка не се дължи на проблеми с производителността, а поради ограничение на типа ('\t\r\n' == 0) .

46
16 дек. отговор, даден Константин 16 декември. 2008-12-16 17:29 '08 в 17:29 ч. 2008-12-16 17:29

Равен оператор за сравнение == е объркан и трябва да се избягва.

Ако живеете с HAVE , запомнете следните 3 неща:

  • Не е транзитивно: (a == b) и (b == c) не води до (a == c)
  • Той взаимно изключва неговото отрицание: (a == b) и (a! = B) винаги имат противоположни булеви стойности с всички a и b.
  • Когато се съмнявате, запомнете следната таблица на истината:

ТАБЛИЦА НА ПРАВЕН ОПЕРАТОР В ЯВАСКРИПТ

  • Всеки ред в таблицата е набор от 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. 
42
16 сент. отговор, даден от CuongHuyTo 16 септември 2011-09-16 17:25 '11 в 17:25 2011-09-16 17:25

Едва ли има разлика в производителността между двете операции във вашата употреба. Не се извършва преобразуване на типа, тъй като и двата параметъра са от един и същи тип. И двете операции ще имат тип сравнение, последвано от сравнение на стойности.

35
11 дек. отговор даден Шон 11 декември 2008-12-11 17:44 '08 в 17:44 2008-12-11 17:44

Да! Това има значение.

=== в javascript проверява стойността, както и типа , където операторът == просто проверява стойността (конвертира типа, ако е необходимо) .

2019

35
14 нояб. Отговор, даден от Аникет Тхакур 14 ноември 2014-11-14 09:02 '14 в 9:02 2014-11-14 09:02
оператор

=== проверява стойностите, както и типовете променливи за равенство.

оператор

== просто проверява стойността на променливите за равенство.

32
12 мая '10 в 16:03 2010-05-12 16:03 отговорът е даден от Niraj Choubey на 12 май '10 в 16:03 часа

Това е строг тестов тест.

Това е добре, особено ако проверявате между 0 и false и null.

Например, ако имате:

 $a = 0; 

След това:

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

Всичко връща вярно и може да не го искате. Да предположим, че имате функция, която може да върне индекса на 0-ия масив или фалшивата грешка. Ако поставите отметка в квадратчето с "==" false, можете да получите объркващ резултат.

Така че, със същото, както по-горе, но строг тест:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 Отговор е даден Даниел 12 май '10 в 16:19 2010-05-12 16:19

JSLint понякога дава нереалистични причини за промяна на материала. === има същата производителност като == ако типовете вече съвпадат.

Това е по-бързо само ако типовете не съвпадат, в който случай не се опитва да конвертира типове, а връща false.

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

Значение, няма причина да се променя == на === в тест, например if (a == 'test') , когато го знаете, защото фактът може да бъде само String.

Промяната на голямо количество код по този начин отнема време на разработчици и рецензенти и не постига нищо.

29
05 июня '12 в 10:53 2012-06-05 10:53 отговор, даден пепел на 05 юни '12 в 10:53 2012-06-05 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 
28
20 марта '15 в 8:05 2015-03-20 08:05 отговор е даден Амит 20 март '15 в 8:05 2015-03-20 08:05

Един прост пример е

 2 == '2' -> true, values are SAME because of type conversion. 2 === '2' -> false, values are NOT SAME because of no type conversion. 
25
14 мая '15 в 17:45 2015-05-14 17:45 отговорът е даден от Vikas на 14 май в 17:45 часа 2015-05-14 17:45

Топ 2 отговора за двете споменати == означава равенство и === означава идентификатор. За съжаление, това твърдение е неправилно.

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

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