Welcher Operator ist gleich (== vs ===) für den JavaScript-Vergleich?

Ich benutze JSLint, um JavaScript zu durchlaufen, und es gibt viele Sätze zurück, um == (zwei Gleichheitszeichen) durch === (drei Gleichheitszeichen) zu ersetzen, wenn Sie einen Vergleich wie idSele_UNVEHtype.value.length == 0 Inneren durchführen Betreiber if .

Gibt es einen Leistungsvorteil für das Ersetzen von == in === ?

Leistungsverbesserungen sind willkommen, da es viele Vergleichsoperatoren gibt.

Wird die Typumwandlung nicht durchgeführt, wird der Gewinn mit == verglichen?

5673
11 дек. eingestellt von Bcasp 11. Dezember 2008-12-11 17:19 08 um 17:19 2008-12-11 17:19
ответ 51 Antworten
  • 1
  • 2

Der Identitätsoperator ( === ) verhält sich identisch zum Gleichheitsoperator ( == ), mit der Ausnahme, dass die Typkonvertierung nicht durchgeführt wird und die Typen als identisch gelten müssen.

Referenz: Javascript-Tutorial: Vergleichsoperatoren

Der Operator == vergleicht die Gleichheit, nachdem alle erforderlichen Typkonvertierungen durchgeführt wurden. Der Operator === führt die Konvertierung nicht durch. Wenn also die beiden Werte nicht übereinstimmen, gibt === einfach false . Beide sind gleich schnell.

Zitat Douglas Crockford ausgezeichnetes Javascript: gute Teile ,

In JavaScript gibt es zwei === von Gleichheitsoperatoren: === und !== und ihre bösen Zwillinge == und != . Die Guten arbeiten wie erwartet. Wenn zwei Operanden desselben Typs denselben Wert haben, erzeugt === true und !== false . Böse Zwillinge tun das Richtige, wenn Operanden vom gleichen Typ sind, aber wenn sie unterschiedliche Typen haben, versuchen sie, Werte durchzusetzen. die Regeln, nach denen sie das machen, sind komplex und unüberwindbar. Hier sind einige der interessanten Fälle:

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

Der Mangel an Transitivität ist alarmierend. Mein Rat ist, niemals böse Zwillinge zu verwenden. Verwenden === stattdessen immer === und !== . Alle obigen Vergleiche zeigen false mit dem Operator === .


Update:

Ein guter Punkt wurde von @Casebash in den Kommentaren und in @Phillipe Laybaert bezüglich Referenztypen angesprochen . Bei Referenztypen === == und === konsistent miteinander (außer im Sonderfall).

 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 

Ein Sonderfall ist der Vergleich eines Literal mit einem Objekt, das aufgrund seiner toString oder valueOf das gleiche Literal valueOf . Vergleichen Sie beispielsweise ein String-Literal mit einem vom String Konstruktor erstellten String-Objekt.

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

Hier prüft der Operator == die Werte von zwei Objekten und gibt true . === sieht jedoch, dass sie nicht vom selben Typ sind und false . Welches ist richtig? Es hängt wirklich davon ab, was Sie zu vergleichen versuchen. Mein Rat ist, die Frage vollständig zu umgehen und den String Konstruktor nicht einfach zum Erstellen von String-Objekten zu verwenden.

Referenz
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

5840
11 дек. Antwort von Bill the Lizard am 11. Dezember 2008-12-11 17:25 08 um 17:25 Uhr 2008-12-11 17:25

Verwenden des Operators == (Gleichheit)

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

Verwenden des Operators === (Identität)

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

Dies liegt an der Tatsache, dass der Gleichheitsoperator == einen Zwangs-Typ hat , was bedeutet, dass der Interpreter implizit versucht, die Werte vor dem Vergleich zu konvertieren.

Andererseits führt der Identity === Operator keinen === und konvertiert daher beim Vergleich keine Werte.

1016
11 дек. Die Antwort gibt Andreas Grech 11 Dez. 2008-12-11 17:33 08 um 17:33 2008-12-11 17:33

In den Antworten hier habe ich nichts darüber gelesen, was gleichbedeutend ist. Einige werden sagen, dass === gleich und vom selben Typ bedeutet , aber das ist nicht der Fall. Tatsächlich heißt das, dass beide Operanden auf dasselbe Objekt verweisen oder bei Werttypen den gleichen Wert haben .

Nehmen wir also den folgenden Code:

 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 

Gleiches hier:

 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 

Oder sogar:

 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 

Dieses Verhalten ist nicht immer offensichtlich. Die Geschichte hat mehr zu bieten als gleich und vom gleichen Typ zu sein.

Regel:

Für Werttypen (Zahlen):
a === b gibt true zurück, wenn a und b denselben Wert und denselben Typ haben

Für Referenztypen:
a === b gibt true zurück, wenn a und b auf dasselbe Objekt verweisen.

Für Saiten:
a === b gibt true zurück, wenn a und b beide Zeichenfolgen sind und dieselben Zeichen enthalten.


Saiten: Sonderfall ...

Zeichenfolgen sind keine Werttypen. In Javascript verhalten sie sich jedoch wie Werttypen. Sie sind also "gleich", wenn die Zeichen in der Zeichenfolge gleich sind und dieselbe Länge haben (wie in der dritten Regel erläutert).

Jetzt wird es interessant:

 var a = "12" + "3"; var b = "123"; alert(a === b); // returns true, because strings behave like value types 

Aber wie wäre es damit?:

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

Ich dachte, dass sich Strings wie Werttypen verhalten? Nun, es kommt darauf an, wen Sie fragen ... In diesem Fall sind a und b nicht derselbe Typ. a ist vom Typ Object und b vom Typ string . Denken Sie jedoch daran, dass beim Erstellen eines Zeichenfolgenobjekts mit dem string der Typ Object , der sich meistens wie eine Zeichenfolge verhält.

564
05 июня '09 в 22:11 2009-06-05 22:11 antwortete Philippe Leybaert am 5. Juni 09 um 10:11 Uhr 2009-06-05 22:11

Eine interessante grafische Darstellung des Gleichheitsvergleichs zwischen == und === .

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


var1 === var2

Wenn Sie === zum Testen der JavaScript-Gleichheit verwenden, ist alles so wie es ist Vor der Auswertung wird nichts konvertiert.

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 Die Antwort wird von SNag am 5. Mai 14 um 08:21 2014-05-05 08:21 gegeben

Lassen Sie mich diesen Tipp hinzufügen:

Im Zweifelsfall lesen Sie die Spezifikation !

ECMA-262 ist eine Skriptsprachenspezifikation, in der JavaScript ein Dialekt ist. In der Praxis ist es natürlich wichtig, wie sich die wichtigsten Browser verhalten, und nicht die esoterische Definition, wie etwas gehandhabt werden soll. Aber es ist hilfreich zu verstehen, warum der neue String ("a")! == "a" .

Lassen Sie mich erklären, wie Sie die Spezifikation lesen, um dieses Problem zu klären. Ich sehe, dass in diesem sehr alten Thema niemand eine Antwort auf eine sehr seltsame Wirkung bekam. Wenn Sie also die Spezifikation lesen können, wird dies Ihnen in Ihrem Beruf sehr helfen. Dies ist eine erworbene Fähigkeit. Also mach weiter.

Das Finden einer PDF-Datei für === führt mich zur Seite 56 der Spezifikation: 11.9.4. Der Operator Strict Equals (===) , und nachdem ich die Spezifikation durchgegangen bin, finde ich:

11.9.6 Algorithmus zum strengen Gleichheitsvergleich
Beim Vergleich von x === y, wobei x und y Werte sind, wird true oder false erstellt . Ein solcher Vergleich wird wie folgt durchgeführt:
1. Wenn sich Typ (x) von Typ (y) unterscheidet, geben Sie false zurück .
2. Wenn type (x) Undefined ist, geben Sie true zurück .
3. Wenn Typ (x) Null ist, geben Sie true zurück .
4. Wenn Typ (x) keine Zahl ist, fahren Sie mit Schritt 11 fort.
5. Wenn x NaN ist , geben Sie false zurück .
6. Wenn y NaN ist , geben Sie false zurück .
7. Wenn x der gleiche numerische Wert wie y ist, geben Sie true zurück .
8. Wenn x +0 und y -0 ist, geben Sie true zurück .
9. Wenn x -0 und y +0 ist, geben Sie true zurück .
10. Gib falsch zurück .
11. Wenn Typ (x) String ist, geben Sie true zurück, wenn x und y genau dieselbe Zeichenfolge sind (gleiche Länge und gleiche Zeichen an den entsprechenden Stellen). Andernfalls geben Sie false zurück .
12. Wenn Typ (x) boolean ist, geben Sie true zurück, wenn x und y beide wahr oder beide falsch sind . Andernfalls geben Sie false zurück .
13. Geben Sie true zurück, wenn x und y zu demselben Objekt gehören oder sich auf miteinander verbundene Objekte beziehen (siehe 13.1.2). Andernfalls geben Sie false zurück .

Phase 11 ist interessant: Ja, Zeichenfolgen werden als Werttyp behandelt. Aber das erklärt nicht, warum der neue String ("a")! == "a" . Haben wir einen Nicht-ECMA-262-Browser?

Nicht so schnell!

Überprüfen Sie die Operandentypen. Probieren Sie es selbst aus, indem Sie sie in typeof () einwickeln. Ich habe festgestellt, dass der neue String ("a") ein Objekt ist, und Schritt 1 wird verwendet: Geben Sie false zurück, wenn sich die Typen unterscheiden.

Wenn Sie sich fragen, warum der neue String ("a") keinen String zurückgibt, wie wäre es mit einigen Übungen, die die Spezifikation lesen? Viel spaß


Aidiakapi schrieb dies in einem Kommentar:

Aus der Spezifikation

11.2.2 Neuer Operator :

Wenn der Typ (Konstruktor) kein Objekt ist, lösen Sie eine TypeError-Ausnahme aus.

Wenn der String nicht vom Typ Object ist, kann er mit dem neuen Operator nicht verwendet werden.

new gibt immer ein Objekt zurück, auch für String- Konstruktoren. Und leider! Die Semantik des Werts für Zeichenfolgen (siehe Schritt 11) geht verloren.

Und das heißt schließlich: der neue String ("a")! == "a" .

254
28 нояб. Die Antwort wird am 28. November gegeben . 2009-11-28 21:18 09 um 21:18 2009-11-28 21:18

In PHP und JavaScript ist dies ein strikter Gleichheitsoperator. Dies bedeutet, dass Typ und Werte miteinander verglichen werden.

95
12 мая '10 в 15:58 2010-05-12 15:58 Die Antwort gibt Shiki am 12. Mai '10 um 15:58 2010-05-12 15:58

Ich habe es in Firefox mit Firebug mit folgendem Code getestet:

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

und

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

Meine Ergebnisse (fünfmal geprüft und gemittelt):

 ==: 115.2 ===: 114.4 

Ich würde also sagen, dass ein geringfügiger Unterschied (dies sind mehr als 100.000 Iterationen, erinnern Sie sich daran) vernachlässigbar ist. Leistung ist nicht die Ursache === . Die Art der Sicherheit (gut, wie sicher, wie Sie Javascript ausführen möchten) und die Qualität des Codes.

91
25 дек. Die Antwort gibt Simon Scarfe am 25. Dezember. 2008-12-25 14:17 08 um 14:17 Uhr 2008-12-25 14:17 Uhr

In JavaScript bedeutet dies den gleichen Wert und Typ.

Zum Beispiel

 4 == "4" // will return true 

aber

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 Die Antwort gibt Dimitar am 12. Mai '10 um 15:58 2010-05-12 15:58

Der Operator === wird als strikter Vergleichsoperator bezeichnet. Er unterscheidet sich vom Operator === .

Nimm 2 Vars a und b.

Für "a == b" sollte die Bewertung der Wahrheit von a und b ein Wert sein .

Im Fall von "a === b" müssen a und b den gleichen Wert sowie denselben Typ haben, damit die Wahrheit ermittelt werden kann.

Nehmen Sie das folgende Beispiel

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

Abschließend ; Die Verwendung des Operators == kann in Situationen, in denen Sie dies nicht möchten, als wahr eingestuft werden. Die Verwendung des Operators === ist daher sicherer.

Im 90% -igen Nutzungsszenario ist es egal, welches Sie verwenden. Es ist jedoch hilfreich, den Unterschied zu erkennen, wenn Sie eines Tages unerwartetes Verhalten feststellen.

77
11 дек. Die Antwort wird von Doctor Jones vom 11. Dezember gegeben. 2008-12-11 17:58 08 um 17:58 Uhr 2008-12-11 17:58

Es prüft, ob die gleichen Seiten in Typ und Wert gleich sind .

Beispiel:

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

Allgemeines Beispiel:

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

Ein weiteres allgemeines Beispiel ist:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 Die Antwort wird von vsync am 12. Mai '10 um 15:58 2010-05-12 15:58 gegeben

Warum so unberechenbar?

Was bekommen Sie, wenn Sie den leeren String "" mit der Zahl 0 0 ?

<code> Truecode>

Ja, dies ist in Übereinstimmung mit == leeren Zeichenfolge korrekt, und die numerische Null ist dieselbe Zeit.

Und hier endet noch ein anderes:

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

Bei Arrays wird es sehr seltsam.

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

Dann mit Strings

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

Immer schlimmer:

Wann ist nicht gleich?

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

Lass es mich noch einmal sagen:

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

Und das ist einfach das verrückte Zeug, das man mit Primitiven bekommt.

Dies ist eine neue Ebene des Wahnsinns, wenn Sie == mit Objekten verwenden.

An diesem Punkt wundern Sie sich wahrscheinlich ...

Warum passiert das?

Gut, weil im Gegensatz zu "Triple Equality" ( === ) einfach überprüft wird, ob die beiden Werte übereinstimmen.

== eine ganze Reihe anderer Dinge tun.

Es hat eine spezielle Verarbeitung für Funktionen, eine spezielle Verarbeitung für Nullen, undefinierte Zeichenfolgen, die Sie aufrufen.

Es wird ziemlich dumm.

Wenn Sie versucht haben, eine Funktion zu schreiben, die das tut, was sie tut == , sieht sie == so aus:

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

Was bedeutet das?

Dies bedeutet, dass == komplex ist.

Da es schwierig ist, ist es schwer zu verstehen, was passiert, wenn Sie es verwenden.

Dies bedeutet, dass Sie möglicherweise Fehler haben.

Also die Moral der Geschichte ...

Machen Sie Ihr Leben weniger kompliziert.

Verwenden Sie === anstelle von == .

Das Ende

68
09 авг. die antwort wird von Luis Perez 09 aug gegeben. 2016-08-09 19:50 '16 um 19:50 Uhr 2016-08-09 19:50

Javascript-Ablaufdiagramm für strikte Gleichheit / Vergleich '==='

2019

05 сент. die antwort ist gegeben samar panda 05 sep. 2015-09-05 16:53 '15 am 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 Die Antwort wird von user2496033 3. Juli 13 um 07:08 2013-07-03 07:08 gegeben

Dies bedeutet Gleichheit ohne Typumwandlung. Mit dem Typ "Koerzierungstyp" konvertiert JavaScript andere Datentypen nicht automatisch in String-Datentypen.

 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 Die Antwort ist gegeben Pop Catalin 12. Mai '10 um 15:59 2010-05-12 15:59

In einem typischen Skript gibt es keinen Leistungsunterschied. Noch wichtiger ist die Tatsache, dass tausend "===" 1 Kilobyte ist, schwerer als tausend "==". :) JavaScript-Profiler können Ihnen sagen, ob in Ihrem Fall ein Leistungsunterschied besteht.

Aber persönlich würde ich tun, was JSLint bietet. Diese Empfehlung beruht nicht auf Leistungsproblemen, sondern auf einer Typeinschränkung ('\t\r\n' == 0) .

46
16 дек. Antwort gegeben Constantin 16 Dez. 2008-12-16 17:29 08 um 17:29 Uhr 2008-12-16 17:29

Gleicher Vergleichsoperator == ist verwirrt und sollte vermieden werden.

Wenn Sie mit HAVE zusammenleben , denken Sie an die folgenden drei Dinge:

  • Es ist nicht transitiv: (a == b) und (b == c) führt nicht zu (a == c)
  • Sie schließt ihre Negation gegenseitig aus: (a == b) und (a! = B) haben bei allen a und b immer entgegengesetzte boolesche Werte.
  • Wenn Sie Zweifel haben, merken Sie sich die folgende Wahrheitstabelle:

TABELLE DES RECHTEN BETREIBERS IN JAVASCRIPT

  • Jede Zeile in der Tabelle ist ein Satz von 3 gegenseitig "gleichen" Werten. Dies bedeutet, dass alle zwei Werte von ihnen mit dem Gleichheitszeichen == * gleich sind

** STRANGE: Beachten Sie, dass zwei Werte in der ersten Spalte in diesem Sinne nicht gleich sind. **

 '' == 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 сент. Antwort von CuongHuyTo 16. September 2011-09-16 17:25 '11 um 17:25 2011-09-16 17:25

Es gibt kaum Leistungsunterschiede zwischen den beiden Vorgängen bei Ihrer Verwendung. Es ist keine Typumwandlung durchzuführen, da beide Parameter vom gleichen Typ sind. Beide Operationen haben einen Typvergleich gefolgt von einem Wertvergleich.

35
11 дек. Antwort gegeben Sean 11 Dez 2008-12-11 17:44 08 um 17:44 2008-12-11 17:44

Ja Ist es wichtig.

=== Operator === in Javascript überprüft den Wert sowie den Typ , wobei der Operator == den Wert einfach prüft (konvertiert ggf. den Typ) .

2019

35
14 нояб. Antwort von Aniket Thakur 14. November 2014-11-14 09:02 '14 am 9:02 2014-11-14 09:02
Betreiber

=== prüft Werte und Variablentypen auf Gleichheit.

Betreiber

== prüft nur den Wert der Variablen auf Gleichheit.

32
12 мая '10 в 16:03 2010-05-12 16:03 Die Antwort gibt Niraj Choubey am 12. Mai 10 um 16:03 2010-05-12 16:03

Dies ist ein strenger Test.

Das ist gut, vor allem, wenn Sie zwischen 0 und falsch und null prüfen.

Zum Beispiel, wenn Sie:

 $a = 0; 

Dann:

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

Alles kehrt wahr zurück, und Sie möchten es möglicherweise nicht. Angenommen, Sie haben eine Funktion, die den 0. Array-Index oder bei einem Fehler den Wert false zurückgeben kann. Wenn Sie das Kästchen mit "==" false markieren, können Sie ein verwirrendes Ergebnis erhalten.

Also wie oben, aber ein strenger Test:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 Die Antwort ist Daniel 12. Mai '10 um 16:19 2010-05-12 16:19 gegeben

JSLint gibt manchmal unrealistische Gründe für das Ändern des Materials an. === hat die gleiche Leistung wie == wenn die Typen bereits übereinstimmen.

Dies ist nur dann schneller, wenn die Typen nicht übereinstimmen. In diesem Fall wird nicht versucht, Typen zu konvertieren, sondern es wird false zurückgegeben.

IMHO, JSLint kann daher verwendet werden, um neuen Code zu schreiben, aber eine unnötige Überoptimierung sollte um jeden Preis vermieden werden.

Das heißt, es gibt keinen Grund, == in === in einem Test zu ändern, z. B. if (a == 'test') , wenn Sie es wissen, weil ein Fakt nur ein String sein kann.

Das Ändern einer großen Menge Code auf diese Weise erfordert Zeit für Entwickler und Prüfer und bringt nichts.

29
05 июня '12 в 10:53 2012-06-05 10:53 Antwort gegeben Asche am 5. Juni 12 um 10:53 2012-06-05 10:53

Nur

== bedeutet einen Vergleich zwischen Operanden mit type conversion

=== bedeutet einen Vergleich zwischen Operanden ohne type conversion

Typkonvertierung in JavaScript bedeutet, dass JavaScript alle anderen Datentypen automatisch in String-Datentypen konvertiert.

Zum Beispiel:

 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 Antwort wird gegeben Amit 20. März '15 um 8:05 2015-03-20 08:05

Ein einfaches Beispiel ist

 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 Die Antwort wird von Vikas am 14. Mai um 15.45 Uhr 2015-05-14 17:45 gegeben

Die ersten beiden Antworten für beide genannten == bedeutet Gleichheit und === Bezeichner. Leider ist diese Aussage falsch.

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

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

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

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

23
ответ дан Harry He 09 сент. '13 в 11:31 2013-09-09 11:31

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

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

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

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

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

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

 // Check for both undefined and null values, for some important reason. undefOrNull == null; 
22
ответ дан mar10 27 апр. '13 в 17:15 2013-04-27 17:15

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

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

22
ответ дан Paul Butcher 12 мая '10 в 15:59 2010-05-12 15:59

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

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

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

 CString x; delete x; 

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

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

21
ответ дан Thomas Hansen 29 дек. '09 в 14:54 2008-12-29 14:54

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

Оператор ==

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

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

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

Оператор ===

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

 >>> 1 === '1' false >>> 1 === 1 true 
20
ответ дан user2601995 03 окт. '13 в 0:54 2013-10-03 00:54

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

 1 == true => true true == true => true 1 === true => false true === true => true 
18
ответ дан Mr.G 19 марта '14 в 15:08 2014-03-19 15:08

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

 var a; var b = null; 

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

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

2019

18
ответ дан vivek_nk 14 апр. '14 в 12:28 2014-04-14 12:28
  • 1
  • 2

Другие вопросы по меткам или Задайте вопрос