it-swarm.com.de

Welcher Gleichheitsoperator (== vs ===) sollte in JavaScript-Vergleichen verwendet werden?

Ich benutze JSLint , um JavaScript zu durchlaufen, und es gibt viele Vorschläge, um == (zwei Gleichheitszeichen) durch === (drei Gleichheitszeichen) zu ersetzen, wenn ich Dinge wie Vergleichen tue idSele_UNVEHtype.value.length == 0 innerhalb einer if Anweisung.

Hat das Ersetzen von == durch === einen Leistungsvorteil?

Jede Leistungsverbesserung wäre zu begrüßen, da viele Vergleichsoperatoren existieren.

Wenn keine Typkonvertierung stattfindet, würde es einen Leistungsgewinn gegenüber == geben?

5668
bcasp

Der Identitätsoperator (===) verhält sich identisch mit dem Gleichheitsoperator (==), mit der Ausnahme, dass keine Typkonvertierung durchgeführt wird und die Typen identisch sein müssen, damit sie als gleich gelten.

Referenz: Javascript Tutorial: Vergleichsoperatoren

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

Um Douglas Crockfords vorzügliches zu zitieren JavaScript: The Good Parts ,

JavaScript hat zwei Gruppen von Gleichheitsoperatoren: === und !== und ihre bösen Zwillinge == und !=. Die Guten arbeiten so, wie Sie es erwarten würden. Wenn die beiden Operanden vom selben Typ sind und denselben Wert haben, dann erzeugt ===true und !==false. Die bösen Zwillinge tun das Richtige, wenn die Operanden vom selben Typ sind, aber wenn sie von unterschiedlichem Typ sind, versuchen sie, die Werte zu erzwingen. Die Regeln, nach denen sie das tun, sind kompliziert und nicht zu merken. Dies 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 die bösen Zwillinge zu benutzen. Verwenden Sie stattdessen immer === und !==. Alle soeben gezeigten Vergleiche führen zu false mit dem Operator ===.


Aktualisieren:

Ein guter Punkt wurde von @ Casebash in den Kommentaren und in @ Phillipe LaybaertsAntwort in Bezug auf Referenztypen angesprochen. Bei Referenztypen handeln == und === konsistent miteinander (außer in besonderen Fällen).

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

Der Sonderfall ist, wenn Sie ein Literal mit einem Objekt vergleichen, das aufgrund seiner toString - oder valueOf -Methode dasselbe Literal ergibt. Angenommen, Sie vergleichen ein Zeichenfolgenliteral mit einem Zeichenfolgenobjekt, das vom Konstruktor String erstellt wurde.

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

Hier überprüft der Operator == die Werte der beiden Objekte und gibt true zurück, aber der Operator === stellt fest, dass sie nicht vom selben Typ sind und false zurückgeben. Welches ist richtig? Das hängt wirklich davon ab, was Sie vergleichen wollen. Mein Rat ist, die Frage vollständig zu umgehen und den Konstruktor String nicht zum Erstellen von Zeichenfolgenobjekten zu verwenden.

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

6254
Bill the Lizard

Verwenden des Operators == ( Equality )

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

Verwenden des Operators === ( Identity )

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

Dies liegt daran, dass der Gleichheitsoperator == Zwang eingibt, was bedeutet, dass der Interpreter implizit versucht, die Werte vor dem Vergleich zu konvertieren.

Der Identitätsoperator === führt dagegen keinen Typenzwang durch und konvertiert daher die Werte beim Vergleich nicht schneller (wie laut This JS Benchmark test), da ein Schritt übersprungen wird.

1089
Andreas Grech

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

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


var1 === var2

Wenn Sie === für JavaScript-Gleichheitstests verwenden, ist alles wie es ist. Nichts wird konvertiert, bevor es ausgewertet wird.

Equality evaluation of === in JS


var1 == var2

Bei Verwendung von == für JavaScript-Gleichheitstests finden einige irre Konvertierungen statt.

Equality evaluation of == in JS

Moral der Geschichte:

Verwenden Sie ===, sofern Sie die mit == durchgeführten Konvertierungen nicht vollständig verstehen.

659
SNag

In den Antworten hier habe ich nichts darüber gelesen, was gleich bedeutet. Einige werden sagen, dass ===gleich und vom selben Typ bedeutet, aber das ist nicht wirklich wahr. Dies bedeutet tatsächlich, dass beide Operanden verweisen auf dasselbe Objekt oder im Fall von Werttypen haben denselben Wert.

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

Dasselbe 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 auch:

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 zu sein und vom selben Typ zu sein.

Die Regel ist:

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 Zeichenfolgen:
a === b gibt true zurück, wenn a und b beide Zeichenfolgen sind und exakt dieselben Zeichen enthalten


Streicher: der Sonderfall ...

Zeichenfolgen sind keine Werttypen, aber in JavaScript verhalten sie sich wie Werttypen. Sie sind also "gleich", wenn die Zeichen in der Zeichenfolge identisch 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, Strings verhalten sich wie Werttypen? Nun, es kommt darauf an, wen Sie fragen ... In diesem Fall sind a und b nicht der gleiche Typ. a ist vom Typ Object, während b vom Typ string ist. Denken Sie daran, dass beim Erstellen eines Zeichenfolgenobjekts mit dem Konstruktor String etwas vom Typ Object erstellt wird, das sich die meiste Zeit wie eine Zeichenfolge verhält .

597

Lassen Sie mich diesen Ratschlag hinzufügen:

Lesen Sie im Zweifelsfall die Spezifikation !

ECMA-262 ist die Spezifikation für eine Skriptsprache, deren Dialekt JavaScript ist. Natürlich ist es in der Praxis wichtiger, wie sich die wichtigsten Browser verhalten, als eine esoterische Definition, wie mit etwas umgegangen werden soll. Es ist jedoch hilfreich zu verstehen, warum neue Zeichenfolge ("a")! == "a" .

Bitte lassen Sie mich erklären, wie Sie die Spezifikation lesen, um diese Frage zu klären. Ich sehe, dass in diesem sehr alten Thema niemand eine Antwort auf den sehr seltsamen Effekt hatte. Wenn Sie also eine Spezifikation lesen können, wird dies Ihnen in Ihrem Beruf enorm helfen. Es ist eine erworbene Fähigkeit. Also lasst uns weitermachen.

Durch Durchsuchen der Datei PDF nach === komme ich zu Seite 56 der Spezifikation: 11.9.4. Der Strict Equals Operator (===) , und nachdem ich mich durch die Specificationalese geblättert habe, finde ich:

11.9.6 Der Algorithmus für den strengen Gleichheitsvergleich
Der Vergleich x === y, wobei x und y Werte sind, ergibt wahr oder false . Ein solcher Vergleich wird wie folgt durchgeführt:
1. Wenn sich Typ (x) von Typ (y) unterscheidet, geben Sie false zurück.
2. Wenn Typ (x) nicht definiert ist, geben Sie true zurück.
3. Wenn Typ (x) Null ist, geben Sie true zurück.
4. Wenn Typ (x) nicht 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 Zahlenwert 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. Geben Sie false zurück.
11. Wenn Type (x) String ist, geben Sie true zurück, wenn x und y genau dieselbe Zeichenfolge (gleiche Länge) haben und gleiche Zeichen in entsprechenden Positionen); Andernfalls geben Sie false zurück.
12. Wenn Typ (x) boolesch ist, geben Sie true zurück, wenn x und y beide sind. true oder both false ; Andernfalls geben Sie false zurück.
13. Geben Sie true zurück, wenn sich x und y auf dasselbe Objekt beziehen oder wenn sie sich auf miteinander verbundene Objekte beziehen (siehe 13.1. 2). Andernfalls geben Sie false zurück.

Interessant ist Schritt 11. Ja, Zeichenfolgen werden als Werttypen behandelt. Dies erklärt jedoch nicht, warum neue Zeichenfolge ("a")! == "a" . Haben wir einen Browser, der nicht ECMA-262 entspricht?

Nicht so schnell!

Lassen Sie uns die Typen der Operanden überprüfen. Probieren Sie es aus, indem Sie sie in typeof () einwickeln. Ich finde, dass neuer String ("a") ein Objekt ist und Schritt 1 verwendet wird: return false wenn die Typen unterschiedlich sind.

Wenn Sie sich fragen, warum neue Zeichenfolge ("a") keine Zeichenfolge zurückgibt, wie wäre es mit einer Übung zum Lesen einer Spezifikation? Habe Spaß!


Aidiakapi hat dies in einem Kommentar unten geschrieben:

Aus der Spezifikation

11.2.2 Der neue Operator :

Wenn Type (Konstruktor) nicht Object ist, wird eine TypeError-Ausnahme ausgelöst.

Mit anderen Worten, wenn String nicht vom Typ Object wäre, könnte er nicht mit dem neuen Operator verwendet werden.

new gibt immer ein Objekt zurück, auch für String Konstruktoren. Und leider! Die Wertesemantik für Strings (siehe Schritt 11) geht verloren.

Und das bedeutet schließlich: neuer String ("a")! == "a" .

261
nalply

In PHP und JavaScript ist dies ein strikter Gleichheitsoperator. Das heißt, es werden sowohl Typ als auch Werte verglichen.

98
Shiki

Ich habe dies 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 (jeweils fünfmal getestet und gemittelt):

==: 115.2
===: 114.4

Also würde ich sagen, dass der winzige Unterschied (das sind über 100000 Iterationen, denk dran) vernachlässigbar ist. Leistung ist nicht ein Grund, === zu machen. Geben Sie Sicherheit ein (na ja, so sicher, wie Sie es in JavaScript bekommen werden), und die Codequalität ist.

94
Simon Scarfe

In JavaScript bedeutet dies den gleichen Wert und Typ.

Zum Beispiel,

4 == "4" // will return true

aber

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

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

Nehmen wir 2 Gläser a und b.

Damit "a == b" als wahr bewertet werden kann, müssen a und b der gleiche Wert sein .

Im Fall von "a === b" müssen a und b der gleiche Wert sein und auch der gleiche Typ , damit er als wahr ausgewertet wird.

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

Zusammenfassend ; Die Verwendung des Operators == kann in Situationen, in denen dies nicht gewünscht wird, mit dem Operator == als wahr bewertet werden = Operator wäre sicherer.

Im 90% -Nutzungsszenario spielt es keine Rolle, welches Sie verwenden, aber es ist praktisch, den Unterschied zu kennen, wenn eines Tages unerwartetes Verhalten auftritt.

80
Doctor Jones

Es wird geprüft, ob die gleichen Seiten sowohl in Typ als auch in Wert gleich sind.

Beispiel:

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

Allgemeines Beispiel:

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

Ein weiteres häufiges Beispiel:

null == undefined // returns "true", but in most cases a distinction is necessary
75
vsync

Warum ist == so unvorhersehbar?

Was erhalten Sie, wenn Sie eine leere Zeichenfolge "" mit der Zahl Null 0 vergleichen?

true

Ja, das stimmt laut ==, eine leere Zeichenkette und die Zahl Null sind zur selben Zeit.

Und hier ist noch eine:

'0' == false // true

Bei Arrays wird es wirklich komisch.

[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

Dann weirder mit Strings

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

Es wird schlimmer:

Wann ist gleich nicht gleich?

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!

Lassen Sie mich das noch einmal sagen:

(A == B) && (B == C) // true
(A == C) // **FALSE**

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

Es ist eine völlig neue Ebene des Verrückten, wenn Sie == mit Objekten verwenden.

An dieser Stelle wundern Sie sich wahrscheinlich ...

Warum passiert das?

Nun, es liegt daran, dass im Gegensatz zu "Triple Equals" (===) nur überprüft wird, ob zwei Werte gleich sind.

== macht ein ganzer Haufen anderer Sachen.

Es hat eine spezielle Behandlung für Funktionen, eine spezielle Behandlung für Nullen, undefinierte Zeichenfolgen, wie Sie es nennen.

Es wird ziemlich verrückt.

In der Tat würde es ungefähr so ​​aussehen, wenn Sie versuchen würden, eine Funktion zu schreiben, die das tut, was == tut:

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

Also, was bedeutet das?

Es bedeutet, dass == kompliziert ist.

Weil es kompliziert ist, ist es schwer zu wissen, was passieren wird, wenn Sie es verwenden.

Das heißt, Sie könnten mit Fehlern enden.

Die Moral der Geschichte ist also ...

Machen Sie Ihr Leben weniger kompliziert.

Verwenden Sie === anstelle von ==.

Das Ende.

72
Luis Perez

Ablaufdiagramm der Ausführung von Javascript für strikte Gleichheit/Vergleich '==='

Javascript strict equality

Ablaufdiagramm der Ausführung von Javascript für nicht strenge Gleichheit/Vergleich '=='

Javascript non equality

67
Samar Panda

JavaScript ===vs==.

0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type
53
user2496033

Dies bedeutet Gleichheit ohne Typenzwang Typenzwang bedeutet, dass JavaScript andere Datentypen nicht automatisch in Zeichenfolgendatentypen konvertiert

0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 
52
Pop Catalin

In einem typischen Skript gibt es keinen Leistungsunterschied. Wichtiger ist vielleicht die Tatsache, dass Tausend "===" 1 KB schwerer ist als Tausend "==" :) JavaScript-Profiler kann Ihnen sagen, ob es in Ihrem Fall einen Leistungsunterschied gibt.

Aber persönlich würde ich tun, was JSLint vorschlägt. Diese Empfehlung gibt es nicht wegen Leistungsproblemen, sondern weil Typenzwang bedeutet, dass ('\t\r\n' == 0) wahr ist.

47
Constantin

Der Gleichheitsvergleichsoperator == ist verwirrend und sollte vermieden werden.

Wenn Sie MÜSSEN damit leben, dann denken Sie an die folgenden 3 Dinge:

  1. Es ist nicht transitiv: (a == b) und (b == c) führt nicht zu (a == c)
  2. Es schließt sich gegenseitig zu seiner Negation aus: (a == b) und (a! = B ) immer entgegengesetzte Boolesche Werte mit allen a und b.
  3. Lernen Sie im Zweifelsfall die folgende Wahrheitstabelle auswendig:

WAHRHEITSTABELLE GLEICHER BETREIBER IN JAVASCRIPT

  • Jede Zeile in der Tabelle besteht aus 3 Werten, die sich gegenseitig "gleichen". Dies bedeutet, dass jeweils 2 Werte unter Verwendung des Gleichheitszeichens == gleich sind. *

** SELTSAM: Beachten Sie, dass zwei beliebige 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.
43
CuongHuyTo

Ja! Es ist wichtig.

=== -Operator in Javascript überprüft Wert und Typ , wobei als == -Operator nur überprüft ) den Wert (führt bei Bedarf eine Typumrechnung durch) .

enter image description here

Sie können es einfach testen. Füge folgenden Code in eine HTML-Datei ein und öffne sie im Browser

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

Sie erhalten eine Warnung mit " false ". Ändern Sie nun die Methode onPageLoad() in alert(x == 5);, um true zu erhalten.

36
Aniket Thakur

Es ist unwahrscheinlich, dass zwischen den beiden Vorgängen in Ihrer Verwendung ein Leistungsunterschied besteht. Es muss keine Typkonvertierung durchgeführt werden, da beide Parameter bereits den gleichen Typ haben. Beide Operationen haben einen Typvergleich, gefolgt von einem Wertvergleich.

36
Sean

Der Operator === überprüft die Werte sowie die Typen der Variablen auf Gleichheit.

Der Operator == überprüft nur den Wert der Variablen auf Gleichheit.

33
Niraj CHoubey

Es ist ein strenger Kontrolltest.

Es ist eine gute Sache, besonders wenn Sie zwischen 0 und false und null prüfen.

Zum Beispiel, wenn Sie:

$a = 0;

Dann:

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

Alle Rückgaben sind wahr und Sie möchten dies möglicherweise nicht. Angenommen, Sie haben eine Funktion, die den 0. Index eines Arrays zurückgeben kann oder bei einem Fehler false. Wenn Sie mit "==" false überprüfen, können Sie ein verwirrendes Ergebnis erhalten.

Also mit der gleichen Sache wie oben, aber einem strengen Test:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false
31
Daniel

JSLint gibt Ihnen manchmal unrealistische Gründe, Dinge zu ändern. === hat genau die gleiche Leistung wie ==, wenn die Typen bereits identisch sind.

Es ist nur dann schneller, wenn die Typen nicht gleich sind. In diesem Fall wird nicht versucht, Typen zu konvertieren, sondern direkt ein false zurückgegeben.

Also, IMHO, JSLint wird möglicherweise verwendet, um neuen Code zu schreiben, aber unnötige Überoptimierung sollte unter allen Umständen vermieden werden.

Das heißt, es gibt keinen Grund, == in === in einer Prüfung wie if (a == 'test') zu ändern, wenn Sie wissen, dass a nur ein String sein kann.

Das Ändern vieler Codes auf diese Weise verschwendet Zeit für Entwickler und Überprüfer und führt zu nichts.

30
ashes

Einfach

== bedeutet Vergleich zwischen Operanden mittype conversion

&

=== bedeutet Vergleich zwischen Operanden ohnetype conversion

Typkonvertierung in JavaScript bedeutet, dass JavaScript andere Datentypen automatisch in Zeichenfolgendatentypen 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 
29
Amit

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
Vikas

Die ersten beiden Antworten bedeuten == Gleichheit und === Identität. Diese Aussage ist leider falsch.

Wenn beide Operanden von == Objekte sind, werden sie verglichen, um festzustellen, ob sie dasselbe Objekt sind. Wenn beide Operanden auf dasselbe Objekt zeigen, gibt der Gleichheitsoperator true zurück. Ansonsten sind die beiden nicht gleich.

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

Im obigen Code werden == und === falsch, da a und b nicht dieselben Objekte sind.

Das heißt: Wenn beide Operanden von == Objekte sind, verhält sich == wie ===, was auch Identität bedeutet. Der wesentliche Unterschied dieser beiden Operatoren liegt in der Typkonvertierung. == hat eine Konvertierung, bevor die Gleichheit überprüft wird, === jedoch nicht.

24
Harry He

Als Faustregel würde ich im Allgemeinen === anstelle von == (und !== anstelle von !=) verwenden.

Die Gründe sind in den obigen Antworten erklärt und auch Douglas Crockford ist ziemlich klar darüber ( JavaScript: The Good Parts ).

Es gibt jedoch eine einzige Ausnahme : == null ist ein effizienter Weg, um zu überprüfen, ob 'null oder undefiniert' ist:

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

Zum Beispiel verwendet jQuery 1.9.1 dieses Muster 43 Mal, und das JSHint-Syntaxprüfprogramm bietet aus diesem Grund sogar die Relaxing-Option eqnull.

Aus dem jQuery Style Guide :

Strenge Gleichheitsprüfungen (===) sollten zugunsten von == angewendet werden. Die einzige Ausnahme ist die Überprüfung auf undefined und null mit null.

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

Das Problem ist, dass Sie leicht in Schwierigkeiten geraten können, da JavaScript viele implizite Konvertierungen hat, was bedeutet ...

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

Welches ziemlich bald ein Problem wird. Das beste Beispiel dafür, warum implizite Konvertierung "böse" ist, kann diesem Code in MFC /C++ entnommen werden, der aufgrund einer impliziten Konvertierung von CString in HANDLE vom Typ Zeigertypef kompiliert wird. ..

CString x;
delete x;

Was offensichtlich zur Laufzeit sehr undefinierte Dinge bewirkt ...

Google für implizite Konvertierungen in C++ und STL , um einige der Argumente dagegen zu bekommen ...

22
Thomas Hansen

Aus der Kern Javascript Referenz

=== Gibt true zurück, wenn die Operanden ohne Typkonvertierung genau gleich sind (siehe oben).

22
Paul Butcher

Gleichstellungsvergleich:

Operator ==

Gibt true zurück, wenn beide Operanden gleich sind. Die Operanden werden vor dem Vergleich in denselben Typ konvertiert.

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

Gleichheits- und Typenvergleich:

Operator ===

Gibt true zurück, wenn beide Operanden gleich und vom gleichen Typ sind. Es ist im Allgemeinen besser und sicherer, wenn Sie dies so vergleichen, da es keine Typkonvertierungen hinter den Kulissen gibt.

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

Hier ist eine praktische Vergleichstabelle, die die Konvertierungen und die Unterschiede zwischen == und === zeigt.

In der Schlussfolgerung heißt es:

Msgstr "Verwende drei Gleiche, es sei denn du verstehst die Konvertierungen, die für zwei Gleiche stattfinden, vollständig."

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

19

* Operatoren === vs == *

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

null und undefiniert sind nichts, das heißt,

var a;
var b = null;

Hier haben a und b keine Werte. Während 0, false und '' alle Werte sind. Allen gemeinsam ist, dass sie alle falsche Werte sind, was bedeutet, dass sie alle erfüllen falsche Bedingungen.

Also bilden die 0, false und '' zusammen eine Untergruppe. Auf der anderen Seite bilden null & undefined die zweite Untergruppe. Überprüfen Sie die Vergleiche in der folgenden Abbildung. null und undefined wären gleich. Die anderen drei wären einander gleich. In JavaScript werden sie jedoch alle als falsche Bedingungen behandelt.

Enter image description here

Dies ist dasselbe wie bei jedem Objekt (wie {}, Arrays usw.). Nicht leere Zeichenfolgen und Boolesche Wahrheiten sind alle Wahrheitsbedingungen. Aber sie sind nicht alle gleich.

19
vivek_nk

JavaScript bietet sowohl strenge als auch typkonvertierende Vergleiche. Ein strenger Vergleich (z. B. ===) ist nur wahr, wenn die Operanden vom gleichen Typ sind. Der am häufigsten verwendete abstrakte Vergleich (z. B. ==) konvertiert die Operanden vor dem Vergleich in denselben Typ.

  • Der Gleichheitsoperator (==) konvertiert die Operanden, wenn sie nicht vom gleichen Typ sind, und wendet dann einen strengen Vergleich an. Wenn einer der Operanden eine Zahl oder ein Boolescher Wert ist, werden die Operanden nach Möglichkeit in Zahlen konvertiert. Andernfalls wird, wenn einer der Operanden eine Zeichenfolge ist, der Zeichenfolgenoperand nach Möglichkeit in eine Zahl konvertiert. Wenn beide Operanden Objekte sind, vergleicht JavaScript interne Referenzen, die gleich sind, wenn Operanden auf dasselbe Objekt im Speicher verweisen.

    Syntax:

    x == y

    Beispiele:

    3 == 3     // true
    "3" == 3   // true
    3 == '3'   // true
    
  • Der Operator identity/strict equality (===) gibt true zurück, wenn die Operanden ohne Typkonvertierung streng gleich sind (siehe oben).

    Syntax:

    x === y

    Beispiele:

    3 === 3 // true

Als Referenz: Vergleichsoperatoren (Mozilla Developer Network)

17
garakchy

Wenn Sie eine Webanwendung oder eine gesicherte Seite erstellen, sollten Sie immer verwenden (nur wenn möglich)

===

denn es wird geprüft, ob es sich um denselben Inhalt und denselben Typ handelt!

also wenn jemand eintritt:

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!
}

aber mit

var check = 1;
if(check === 1) {
    //some continued with a number (no string) for your script
} else {
    alert('please enter a real number');
}

ein Hacker wird niemals tiefer in das System eindringen, um Fehler zu finden und Ihre App oder Ihre Benutzer zu hacken

mein Punkt ist es, dass die

===

erhöht die Sicherheit Ihrer Skripte

natürlich können Sie auch überprüfen, ob die eingegebene Nummer gültig ist, eine Zeichenfolge usw. mit anderen if-Anweisungen im ersten Beispiel, aber dies ist zumindest für mich einfacher zu verstehen und zu verwenden

Der Grund, warum ich dies gepostet habe, ist, dass das Wort "sicherer" oder "Sicherheit" in dieser Konversation noch nie verwendet wurde (wenn Sie sich iCloud.com ansehen, werden 2019-mal === und 1308-mal == verwendet, bedeutet dies auch, dass Sie Verwenden Sie manchmal == anstelle von ===, da sonst Ihre Funktion blockiert wird. Wie eingangs erwähnt, sollten Sie === so oft wie möglich verwenden.)

16
Sake Salverda

=== kümmert sich darum, ob die Objekte gleich sind. Daher gibt new String("Hello world") === "Hello world" false zurück. == kümmert sich jedoch nicht darum, ob die Objekte gleich sind. Es konvertiert einfach ein Argument in den Typ des anderen: Wenn eine Konvertierung nicht möglich ist, geben Sie false zurück. Dann gibt new String("Hello world") == "Hello world" true statt false zurück.

13
hopper

Mein Argumentationsprozess mit emacs org-mode und node.js, um einen Test auszuführen.

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

Mein Testskript unten: run> node xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
var colItems = rowItems

for(var i = 0; i < rowItems.length; i++) {
    for (var j = 0; j < colItems.length; j++) {
        var r = (rowItems[i] === colItems[j]) ? true : false;
        console.log(rowItems[i] + " = " + colItems[j] + " " + r + " [" + i + "] ==> [" + j + "]")
    };
}
12
CodeFarmer

Das Javascript ist eine schwach typisierte Sprache d. H. Ohne irgendwelche Datentypen wie dort in C, c ++, z. int, boolean, float usw. Somit kann eine Variable jeden Wert enthalten, weshalb diese speziellen Vergleichsoperatoren vorhanden sind

Z.B

var i = 20;var j = "20";

wenn wir Vergleichsoperatoren anwenden, sind diese Variablen das Ergebnis

i==j //result is true

oder

j != i//result is false

dazu benötigen wir einen speziellen Vergleichsoperator, der sowohl nach dem Wert als auch nach dem Datentyp der Variablen sucht

wenn wir es tun

i===j //result is false
11
Akshay Khale

Verschiedenes zwischen =, = =, = = =

  • = Operator Wird verwendet, um nur den value zuzuweisen.
  • = = Operator Wird verwendet, um nur den values nicht datatype zu vergleichen.
  • = = = Operator Zum Vergleichen von values und datatype.
9

Der Operator == vergleicht nur die Werte, nicht den Datentyp

=== Operator vergleicht die Werte mit dem Vergleich seines Datentyps

z.B.

1 == "1" //true

1 === "1" //false

"===" Operator, der in Sprachen verwendet wird, die eine automatische Typumwandlung durchführen, z. PHP, Javascript. Der Operator "===" verhindert unerwartete Vergleiche, die durch automatische Typumwandlung verursacht werden.

8
Sharad Kale

immer benutze '===' und du wirst tausend Fehler vermeiden. Heutzutage ist die Verwendung von Dreifach Gleichheit für verschiedene Styleguides vorzuziehen, da sie unter Berücksichtigung der Art der Operanden vergleicht.

6
Alexandr

Ein nicht erwähnter Grund für die Verwendung von === - besteht in dem Fall, dass Sie mit/cross-compiling to/from coffee-script koexistieren. Aus dem Büchlein über CoffeeScript ...

Der schwache Gleichheitsvergleich in JavaScript hat etwas verwirrendes Verhalten und ist oft die Ursache für verwirrende Fehler.

Die Lösung besteht darin, stattdessen den strengen Gleichheitsoperator zu verwenden, der aus drei Gleichheitszeichen besteht: ===. Es funktioniert genauso wie der normale Gleichheitsoperator, jedoch ohne jegliche Art von Zwang. Es wird empfohlen, immer den strengen Gleichheitsoperator zu verwenden und Typen bei Bedarf explizit zu konvertieren.

Wenn Sie regelmäßig von und nach coffee-script konvertieren, sollten Sie nur === verwenden. Tatsächlich wird der Compiler coffee-script Sie zwingen , ...

CoffeeScript löst dieses Problem, indem es einfach alle schwachen Vergleiche durch strenge ersetzt, dh alle == Komparatoren in === konvertiert. Sie können in CoffeeScript keinen schwachen Gleichheitsvergleich durchführen, und Sie sollten Typen vor dem Vergleich explizit konvertieren, falls erforderlich.

5
Alex Gray

Ja, es gibt einen großen Unterschied zwischen den == und den === Identitätsoperatoren.
Normalerweise arbeitet der Identitätsoperator schneller, da keine Typenkonvertierung durchgeführt wird. Wenn die Werte jedoch vom gleichen Typ sind, sehen Sie keinen Unterschied.
Überprüfen Sie meinen Beitrag Die Legende des JavaScript-Gleichheitsoperators , in dem die Details, einschließlich der Typenumwandlungs- und Vergleichsalgorithmen, mit vielen Beispielen erläutert werden.

5
Dmitri Pavlutin

Strikte Gleichheit ist größtenteils besser

Die Tatsache, dass Javascript eine lose geschriebene Sprache ist, muss ständig im Vordergrund stehen, wenn Sie damit arbeiten. Solange die Datenstruktur identisch ist, gibt es keinen Grund, keine strikte Gleichheit zu verwenden. Bei regelmäßiger Gleichheit erfolgt häufig eine implizite Konvertierung von Werten, die automatisch erfolgt. Dies kann weitreichende Auswirkungen auf Ihren Code haben. Es ist sehr einfach, Probleme mit dieser Konvertierung zu haben, da diese automatisch auftreten.

Bei strikter Gleichheit findet keine automatische implizite Konvertierung statt, da die Werte bereits die richtige Datenstruktur aufweisen müssen.

3
Neil Meyer

Verwenden Sie ===, wenn Sie einige Dinge in JavaScript vergleichen möchten. Der Name lautet strikte Gleichheit. Dies bedeutet, dass true zurückgegeben wird, wenn nur Typ und Wert sind gleich =, es würde also keine unerwünschte Typkorrektur für Sie geben. Wenn Sie == verwenden, interessiert Sie der Typ im Grunde nicht und in vielen Fällen können Probleme mit einem losen Gleichheitsvergleich auftreten.

Strikte Gleichheit mit ===

Strikte Gleichheit vergleicht zwei Werte auf Gleichheit. Keiner der Werte wird vor dem Vergleich implizit in einen anderen Wert konvertiert. Wenn die Werte unterschiedliche Typen haben, werden die Werte als ungleich angesehen. Wenn die Werte denselben Typ haben und keine Zahlen sind, werden sie als gleich angesehen, wenn sie denselben Wert haben. Wenn beide Werte Zahlen sind, werden sie als gleich angesehen, wenn sie nicht NaN sind und denselben Wert haben oder wenn einer +0 und einer -0 ist.

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


Lose Gleichheit mit ==

Lose Gleichheit vergleicht zwei Werte auf Gleichheit, nachdem beide Werte in einen gemeinsamen Typ konvertiert wurden. Nach Konvertierungen (eine oder beide Seiten können Konvertierungen durchführen) wird der endgültige Gleichheitsvergleich genauso durchgeführt, wie er durchgeführt wird. Lose Gleichheit ist symmetrisch: A == B hat immer die gleiche Semantik wie B == A für alle Werte von A und B (mit Ausnahme der Reihenfolge der angewendeten Konvertierungen).

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

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

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

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

Der Grund, warum vorgeschlagen wird, == durch === zu ersetzen, ist, dass der Operator === zuverlässiger ist als ==. In unserem Zusammenhang dient das verlässliche Mittel === auch zur Typprüfung. In Anbetracht der besten Programmierpraktiken sollten wir immer eine zuverlässigere Funktion anstelle einer weniger zuverlässigen wählen. Immer wenn wir davon ausgehen, dass der Operator die meiste Zeit exakt gleich ist, wird standardmäßig davon ausgegangen, dass der Typ identisch sein sollte. Da === dasselbe bietet, sollten wir es versuchen.

1

Javascript ist lose getippt wie PHP,

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

if (x===y) // false

Dies gibt immer ein falsches Ergebnis aus, da die Datentypen nicht identisch sind, obwohl die Werte der Variablen identisch sind

Einer ist String, der andere ist Int

If(x==y)//true

Dies prüft jedoch nur, ob der Inhalt derselbe ist, unabhängig von den Datentypen ...

Ich möchte nicht sagen, dass die Werte gleich sind, da ein String-Wert logisch nicht gleich einem int-Wert sein kann

1
yanguya995

Zunächst einige Begriffe zu Javascript-Zeichenfolgen: Double Equals wird offiziell als abstrakter Gleichheitsvergleichsoperator bezeichnet, während Triple Equals als strenger Gleichheitsvergleichsoperator bezeichnet wird. Der Unterschied zwischen ihnen kann wie folgt zusammengefasst werden: Abstrakte Gleichheit versucht, die Datentypen vor dem Vergleich durch Typenzwang aufzulösen. Strikte Gleichheit gibt false zurück, wenn die Typen unterschiedlich sind. Betrachten Sie das folgende Beispiel:

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

Wenn Sie zwei Gleichheitszeichen verwenden, wird true zurückgegeben, da die Zeichenfolge "3" vor dem Vergleich in die Zahl 3 konvertiert wird. Drei Gleichheitszeichen erkennen, dass die Typen unterschiedlich sind, und geben false zurück. Hier ist ein anderes:

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

Auch hier führt der abstrakte Gleichheitsvergleich eine Typkonvertierung durch. In diesem Fall werden sowohl der Boolesche Wert true als auch die Zeichenfolge "1" in die Zahl 1 konvertiert, und das Ergebnis ist true. Strikte Gleichheit gibt falsch zurück.

Wenn Sie verstehen, dass Sie auf dem besten Weg sind, zwischen == und === zu unterscheiden. Es gibt jedoch einige Szenarien, in denen das Verhalten dieser Operatoren nicht intuitiv ist. Schauen wir uns einige weitere Beispiele an:

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

Das folgende Beispiel ist interessant, da es veranschaulicht, dass sich Zeichenfolgenliterale von Zeichenfolgenobjekten unterscheiden.

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

Das Dilemma von "Soll ich == oder === im JavaScript-Vergleich verwenden" ist gleich oder analog zu einer Frage von: "Soll ich einen" Löffel "oder eine" Gabel "zum Essen verwenden.

Die einzig vernünftige Antwort auf diese Frage lautet:

  1. Sie sollten Dynamic Type -Vergleich verwenden, z. B. :== für loose Type -Vergleiche.
  2. Sie sollten statischen Vergleichstyp verwenden, z. B. :=== für strong Type Vergleiche.

Das liegt daran, dass sie nicht gleich sind. Sie haben nicht den gleichen Zweck und sollen nicht für den gleichen Zweck verwendet werden.

Natürlich sind sowohl "Gabeln" als auch "Löffel" für "Essen" gedacht, aber Sie werden sie entsprechend dem verwenden, was Ihnen zum Essen serviert wurde.

Das heißt: Sie beschließen, einen Löffel, d. H .: ==, für eine Suppe, und/oder die Gabel, d. H .: ===, zum Pflücken zu verwenden.

Die Frage, ob es besser ist, eine "Gabel" oder einen "Löffel" zum "Essen" zu verwenden - ist gleichbedeutend mit der Frage, ob es besser ist, eine statische [===] versus dynamische [==] Gleichung zu verwenden, op. in JS. Beide Fragen sind gleichermaßen falsch und spiegeln ein sehr enges oder flaches Verständnis des betreffenden Themas wider.

1
Bekim Bacaj
var a = new String("123");
var b = "123";

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

Sah dies in einer der Antworten. a und b sind in diesem Fall nicht wirklich der gleiche Typ. Wenn Sie typeof(a) markieren, erhalten Sie 'object' und typeof(b) is 'string'.

0
Orri Scott