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


Ich benutze JSLint JavaScript durchläuft und viele zu ersetzende Vorschläge zurückgegeben werden == (zwei Gleichheitszeichen) mit === (Drei Gleichheitszeichen) wenn man Vergleiche anstellt idSele_UNVEHtype.value.length == 0 innerhalb eines if Erklärung.

Gibt es einen Leistungsvorteil beim Ersetzen? == mit ===?

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

Wenn keine Typumwandlung stattfindet, wäre der Leistungsgewinn höher ==?


5674
2017-12-11 14:19


Ursprung


Antworten:


Die Identität (===) operator verhält sich identisch zur Gleichheit (==) operator, außer dass keine Typkonvertierung vorgenommen wurde, und die Typen müssen identisch sein, um als gleich zu gelten.

Referenz: Javascript Tutorial: Vergleichsoperatoren

Das == Operator wird für die Gleichheit vergleichen nach den notwendigen Typumwandlungen. Das === Betreiber wird nicht mache die Konvertierung, wenn also zwei Werte nicht vom selben Typ sind === wird einfach zurückkehren false. Beide sind gleich schnell.

Um Douglas Crockfords exzellent zu zitieren JavaScript: Die guten Teile,

JavaScript hat zwei Sätze von Gleichheitsoperatoren: === und !==und ihre bösen Zwillinge == und !=. Die Guten funktionieren so, wie Sie es erwarten würden. Wenn die beiden Operanden vom selben Typ sind und denselben Wert haben, dann === produziert true und !== produziert false. Die bösen Zwillinge machen das Richtige, wenn die Operanden vom selben Typ sind, aber wenn sie von verschiedenen Typen sind, versuchen sie die Werte zu erzwingen. die Regeln, nach denen sie das tun, sind kompliziert und unüberschaubar. 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. Benutze stattdessen immer === und !==. Alle eben gezeigten Vergleiche erzeugen false mit dem === Operator.


Aktualisieren:

Ein guter Punkt wurde durch gebracht @ Casebash in den Kommentaren und in @Phillipe Laybaerts  Antworten in Bezug auf Referenztypen. Für Referenztypen == und === (außer in einem speziellen Fall) konsistent miteinander handeln.

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 Spezialfall ist, wenn Sie ein Literal mit einem Objekt vergleichen, das aufgrund seines toString oder valueOf Methode. Betrachten Sie beispielsweise den Vergleich eines Zeichenfolgenliterals mit einem Zeichenfolgenobjekt, das mit dem Zeichenfolgenobjekt erstellt wurde String Konstrukteur.

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

Hier das == Der Operator überprüft die Werte der beiden Objekte und kehrt zurück true, aber die === sieht, dass sie nicht vom selben Typ sind und zurückkehren false. Welches ist korrekt? Das hängt wirklich davon ab, was Sie vergleichen möchten. Mein Rat ist, die Frage vollständig zu umgehen und einfach nicht die String Konstruktor zum Erstellen von String-Objekten.

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


5716
2017-12-11 14:25



Verwendung der ==Operator (Gleichberechtigung)

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

Verwendung der ===Operator (Identität)

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

Dies ist, weil die Gleichheitsoperator == gibt Zwang einDies bedeutet, dass der Interpreter implizit versucht, die Werte vor dem Vergleich zu konvertieren.

Auf der anderen Seite, die Identitätsoperator === macht keinen Zwangund konvertiert daher die Werte beim Vergleich nicht.


988
2018-06-05 19:11



In den Antworten habe ich nichts darüber gelesen gleich meint. Manche werden das sagen === meint gleich und vom selben Typ, aber das stimmt nicht wirklich. Es bedeutet tatsächlich, dass Beide Operanden verweisen auf dasselbe Objektoder im Falle von Werttypen, haben den gleichen Wert.

Nehmen wir 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. Es gibt mehr in der Geschichte als gleich zu sein und vom selben Typ zu sein.

Die Regel ist:

Für Werttypen (Nummern):
a === b gibt wahr zurück wenn a und b haben den gleichen Wert und sind vom gleichen Typ

Für Referenztypen:
a === b gibt wahr zurück wenn a und b referenziere das exakt gleiche Objekt

Für Strings:
a === b gibt wahr zurück wenn a und b sind beide Zeichenfolgen und enthalten genau die gleichen Zeichen


Strings: der Sonderfall ...

Zeichenfolgen sind keine Werttypen, aber in Javascript verhalten sie sich wie Wertetypen. Sie sind also "gleich", wenn die Zeichen in der Zeichenfolge gleich sind und wenn sie die gleiche 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 Zeichenketten wie Wertetypen verhalten? Nun, es hängt davon ab, wen Sie fragen ... In diesem Fall sind a und b nicht der gleiche Typ. a ist vom Typ Object, während b ist vom Typ string. Erinnern Sie sich daran, dass Sie ein Zeichenfolgenobjekt mit dem Befehl String Konstruktor erstellt etwas vom Typ Object das verhält sich wie eine Zeichenfolge meistens.


545
2018-05-05 05:21



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

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


var1 === var2

Beim Benutzen === Für JavaScript-Gleichheitstests ist alles so wie es ist. Vor der Auswertung wird nichts konvertiert.

Equality evaluation of === in JS


var1 == var2

Beim Benutzen == für JavaScript Gleichheitsprüfung, einige   Funky Conversions finden statt.

Equality evaluation of == in JS

Moral der Geschichte: 

Benutzen === es sei denn, Sie verstehen das vollständig   Konvertierungen, die mit stattfinden ==.


519
2017-11-28 18:18



Lassen Sie mich diesen Rat hinzufügen:

Wenn Sie Zweifel haben, lesen Sie die Spezifikation! 

ECMA-262 ist die Spezifikation für eine Skriptsprache, bei der JavaScript ein Dialekt ist. Natürlich spielt es in der Praxis mehr eine Rolle, wie sich die wichtigsten Browser verhalten, als eine esoterische Definition, wie etwas gehandhabt werden soll. Aber es ist hilfreich zu verstehen, warum neuer String ("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 für den sehr seltsamen Effekt hatte. Also, wenn Sie eine Spezifikation lesen können, wird dies Ihnen in Ihrem Beruf enorm helfen. Es ist eine erworbene Fähigkeit. Also, lass uns weitermachen.

Das Durchsuchen der PDF-Datei nach === bringt mich auf Seite 56 der Spezifikation: 11.9.4. Der Strict Equals Operator (===)und nachdem ich durch die Spezifikation gegangen bin, finde ich:

11.9.6 Der Strikte Gleichheitsvergleichsalgorithmus
  Der Vergleich x === y, wobei x und y Werte sind, erzeugt wahr oder falsch. Ein solcher Vergleich wird wie folgt durchgeführt:
  1. Wenn Typ (x) sich von Typ (y) unterscheidet, kehren Sie zurück falsch.
  2. Wenn Typ (x) nicht definiert ist, kehren Sie zurück wahr.
  3. Wenn Typ (x) Null ist, kehren Sie zurück wahr.
  4. Wenn Typ (x) keine Nummer ist, fahren Sie mit Schritt 11 fort.
  5. Wenn x ist NaN, Rückkehr falsch.
  6. Wenn y ist NaN, Rückkehr falsch.
  7. Wenn x der gleiche Zahlenwert wie y ist, kehren Sie zurück wahr.
  8. Wenn x +0 und y -0 ist, zurückgeben wahr.
  9. Wenn x ist -0 und y ist +0, zurückgeben wahr.
  10. Zurück falsch.
  11. Wenn Typ (x) eine Zeichenfolge ist, kehren Sie zurück wahr wenn x und y genau die gleiche Zeichenfolge sind (gleiche Länge und gleiche Zeichen in den entsprechenden Positionen); Andernfalls, zurück falsch.
  12. Wenn Typ (x) ein Boolescher Wert ist, kehren Sie zurück wahr wenn x und y beide sind wahr oder beides falsch; Andernfalls, zurück falsch.
  13. Zurück wahr wenn sich x und y auf dasselbe Objekt beziehen oder sich auf Objekte beziehen, die miteinander verbunden sind (siehe 13.1.2). Andernfalls, zurück falsch.

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

Nicht so schnell!

Lassen Sie uns die Arten der Operanden überprüfen. Probieren Sie es aus, indem Sie sie einpacken Art der(). Ich finde, dass neue Zeichenfolge ("a") ist ein Objekt, und Schritt 1 wird verwendet: zurückgeben falsch wenn die Typen unterschiedlich sind.

Wenn Sie sich fragen, warum neue Zeichenfolge ("a") gibt keine Zeichenfolge zurück, wie wäre es mit einer Übung, die eine Spezifikation liest? Habe Spaß!


Aidiakapi schrieb dies in einem Kommentar unten:

Aus der Spezifikation

11.2.2 Der neue Betreiber:

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

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

Neu gibt immer ein Objekt zurück, auch für Zeichenfolge Konstrukteure auch. Und leider! Die Wertesemantik für Strings (siehe Schritt 11) ist verloren.

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


250
2018-05-12 12:58



In PHP und JavaScript ist es ein strenger Gleichheitsoperator. Dies bedeutet, dass sowohl der Typ als auch die Werte verglichen werden.


93
2017-12-25 11:17



Ich habe das in Firefox mit getestet Feuerwanze mit Code wie folgt:

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ünf Mal getestet und gemittelt):

==: 115.2
===: 114.4

Also würde ich sagen, dass der winzige Unterschied (das sind über 100000 Iterationen, erinnern) vernachlässigbar ist. Performance ist nicht ein Grund zu tun ===. Geben Sie Sicherheit ein (gut, so sicher, wie Sie es in JavaScript bekommen) und die Codequalität ist.


88
2018-05-12 12:58



In JavaScript bedeutet es den gleichen Wert und Typ.

Beispielsweise,

4 == "4" // will return true

aber

4 === "4" // will return false 

84
2017-12-11 14:58



Das === Operator wird als strikter Vergleichsoperator bezeichnet tut unterscheiden sich von der == Operator.

Nehmen wir 2 vars a und b.

Zum "a == b" zu wahren a und b müssen die sein gleicher Wert.

Im Falle des "a === b" a und b müssen die sein gleicher Wert und auch die dieselbe Art um es als wahr zu bewerten.

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; Verwendung der == Der Operator könnte in Situationen, in denen Sie nicht möchten, dass er dies tut, den Wert true auswerten === Betreiber wäre sicherer.

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


72
2018-05-12 12:58



Es prüft, ob gleiche Seiten gleich sind Art ebenso gut wie Wert.

Beispiel:

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

Gemeinsames Beispiel:

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

Ein anderes häufiges Beispiel:

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

64
2017-09-05 13:53