javascript - vergleich - node js equals




Welcher Operator equals(== vs===) sollte in JavaScript-Vergleichen verwendet werden? (20)

Der Identitätsoperator ( === ) verhält sich identisch mit dem Gleichheitsoperator ( == ), es sei denn, es wird keine Typkonvertierung durchgeführt. Die Typen müssen gleich sein, damit sie als gleich angesehen werden.

Referenz: Javascript-Tutorial: Vergleichsoperatoren

Der Operator == vergleicht die Gleichheit, nachdem alle erforderlichen Typkonvertierungen vorgenommen wurden . Der Operator === führt keine Konvertierung durch. Wenn zwei Werte nicht vom gleichen Typ === wird === einfach false . Beide sind gleich schnell.

Um Douglas Crockfords hervorragendes JavaScript zu zitieren : The Good Parts ,

JavaScript verfügt über zwei Gleichheitsoperatoren: === und !== und ihre bösen Zwillinge == und != . Die Guten arbeiten so, wie Sie es erwarten würden. Wenn die beiden Operanden vom gleichen Typ sind und denselben Wert haben, erzeugt === true und !== false . Die bösen Zwillinge tun das Richtige, wenn die Operanden vom gleichen Typ sind, aber wenn sie unterschiedlichen Typs sind, versuchen sie, die Werte zu zwingen. Die Regeln, nach denen sie das tun, sind kompliziert und unübersehbar. 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 gebrauchen. Verwenden === stattdessen immer === und !== . Alle gerade gezeigten Vergleiche erzeugen mit dem Operator === den === false .

Aktualisieren:

Ein guter Punkt wurde von @Casebash in den Kommentaren und in der answer @Phillipe Laybaert bezüglich Referenztypen angesprochen . Bei Referenztypen == und === agieren Sie konsistent (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

Der Sonderfall liegt vor, wenn Sie ein Literal mit einem Objekt vergleichen, das aufgrund seiner toString oder valueOf Methode mit demselben Literal valueOf wird. Betrachten Sie beispielsweise den Vergleich eines Zeichenfolgenlitals mit einem vom String Konstruktor erstellten Zeichenfolgenobjekt.

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

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

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

Ich verwende JSLint , um durch JavaScript zu gehen, und es gibt viele Vorschläge, um == (zwei Gleichheitszeichen) durch === (drei Gleichheitszeichen) zu ersetzen, wenn Sie Dinge wie den Vergleich von idSele_UNVEHtype.value.length == 0 innerhalb eines idSele_UNVEHtype.value.length == 0 vergleichen Aussage.

Gibt es einen Leistungsvorteil, === == durch === ?

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

Wenn keine Typkonvertierung stattfindet, ergibt sich ein Leistungsgewinn gegenüber == ?


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

Nehmen wir 2 vars a und b.

Um "a == b" als wahr zu bewerten, müssen a und b den gleichen Wert haben .

Im Fall von "a === b" müssen a und b den gleichen Wert und auch den gleichen Typ haben, damit der Wert " true" ist.

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, als wahr ausgewertet werden. Die Verwendung des Operators === wäre daher sicherer.

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


Es ist unwahrscheinlich, dass bei der Verwendung zwischen den beiden Vorgängen ein Leistungsunterschied besteht. Es ist keine Typumwandlung erforderlich, da beide Parameter bereits denselben Typ haben. Beide Operationen haben einen Typvergleich gefolgt von einem Wertvergleich.


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's very common to want this check to be "false"

Ein weiteres allgemeines Beispiel:

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

In JavaScript bedeutet dies den gleichen Wert und Typ.

Zum Beispiel,

4 == "4" // will return true

aber

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

In PHP und JavaScript ist es ein strikter Gleichheitsoperator. Das bedeutet, dass sowohl Typ als auch Werte verglichen werden.


In einem typischen Skript gibt es keinen Leistungsunterschied. Wichtiger ist möglicherweise die Tatsache, dass Tausend "===" 1 KB schwerer als Tausend "==" ist. :) JavaScript-Profiler können Ihnen sagen, ob in Ihrem Fall ein Leistungsunterschied besteht.

Aber persönlich würde ich tun, was JSLint vorschlägt. Diese Empfehlung gibt es nicht aufgrund von Leistungsproblemen, sondern weil der Typ Zwang ('\t\r\n' == 0) wahr ist.


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

Lassen Sie mich diesen Rat hinzufügen:

Im Zweifelsfall lesen Sie die specification !

ECMA-262 ist die Spezifikation für eine Skriptsprache, für die JavaScript ein Dialekt ist. In der Praxis ist es natürlich wichtiger, wie sich die wichtigsten Browser verhalten, als eine esoterische Definition, wie etwas behandelt 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 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 fortfahren.

Durchsuchen der PDF-Datei nach === bringt mich zur Seite 56 der Spezifikation: 11.9.4. Der Strict-Equals-Operator (===) , und nachdem ich durch das Specificationalese gewatet bin, finde ich:

11.9.6 Der strenge Gleichheitsvergleichs-Algorithmus
Der Vergleich x === y, wobei x und y Werte sind, erzeugt wahr oder falsch . 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 Number 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 ist und y -0 ist, kehre true zurück .
9. Wenn x -0 ist und y +0 ist, wird true zurückgegeben .
10. Gib falsch zurück .
11. Wenn Type (x) String ist, dann true zurückgeben, wenn x und y genau dieselbe Zeichenfolge sind (gleiche Länge und gleiche Zeichen an entsprechenden Positionen); 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 sich auf dasselbe Objekt beziehen oder wenn sie sich auf Objekte beziehen, die miteinander verbunden sind (siehe 13.1.2). Andernfalls geben Sie false zurück .

Interessant ist Schritt 11. Ja, Zeichenfolgen werden als Werttyp behandelt. Aber das erklärt nicht, warum der neue String ("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 wird verwendet: Gib false zurück, wenn die Typen unterschiedlich sind.

Wenn Sie sich fragen, warum ein neuer String ("a") keinen String zurückgibt, wie wäre es mit einer Übung, die eine Spezifikation liest? Habe Spaß!

Aidiakapi schrieb dies in einem Kommentar:

Aus der Spezifikation

11.2.2 Der neue Betreiber :

Wenn Typ (Konstruktor) nicht Object ist, lösen Sie eine TypeError-Ausnahme aus.

Mit anderen Worten, wenn String nicht vom Typ Object sein würde, kann 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 Zeichenfolgen (siehe Schritt 11) geht verloren.

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


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 )

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

Dies liegt daran, dass der Gleichheitsoperator == Typumwandlung durchführt , was bedeutet, dass der Interpreter implizit versucht, die Werte vor dem Vergleich zu konvertieren.

Auf der anderen Seite führt der Identitätsoperator === keine Typumwandlung durch und konvertiert die Werte daher nicht beim Vergleichen.


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

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


Der Gleichheitsoperator == ist verwirrend und sollte vermieden werden.

Wenn Sie damit leben MÜSSEN, beachten Sie die folgenden drei Dinge:

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

EQUAL OPERATOR TRUTH TABLE IN JAVASCRIPT

  • Jede Zeile in der Tabelle ist ein Satz von 3 gegenseitig "gleichen" Werten. Dies bedeutet, dass zwei Werte unter 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.

Ja! Es ist wichtig.

=== Operator in Javascript überprüft den Wert sowie den Typ, bei dem der Operator == nur den Wert überprüft (ggf. Konvertierung des Typs) .

Sie können es leicht testen. Fügen Sie folgenden Code in eine HTML-Datei ein und öffnen Sie ihn im Browser

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

Sie erhalten " falsch " in Alarm. Ändern Sie nun die onPageLoad()Methode, damit alert(x == 5);Sie wahr werden .


Warum ist so unberechenbar?

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

true

Ja, das ist richtig bei == eine leere Zeichenkette und die Zahl Null ist die gleiche Zeit.

Und es endet nicht dort, hier ist noch einer:

'0' == false // true

Mit Arrays wird es wirklich komisch.

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

Dann mit Strings wehrender

[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 einfach 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 diesem Punkt wundern Sie sich wahrscheinlich ...

Warum passiert das?

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

== macht eine ganze Reihe von anderen Sachen .

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

Es wird ziemlich verrückt.

Wenn Sie versuchen, eine Funktion zu schreiben, die == tut, würde sie ungefähr so ​​aussehen:

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

Was bedeutet das?

Es bedeutet, dass es kompliziert ist.

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

Was bedeutet, dass Sie mit Fehlern enden könnten.

Die Moral der Geschichte ist also ...

Machen Sie Ihr Leben weniger kompliziert.

Verwenden Sie === anstelle von == .

Das Ende.


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.

Einfach

==bedeutet Vergleich zwischen Operanden mit type conversion

&

===bedeutet Vergleich zwischen Operanden ohne type conversion

Typenkonvertierung 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 

null und undefiniert sind nichts, das heißt

var a;
var b = null;

Hier aund bhabe keine Werte. Dabei sind 0, false und '' alle Werte. Eine Sache gemeinsam beween all dies sind , dass sie alle falsy Werte sind, das heißt , sie alle erfüllen falsy Bedingungen.

0, falsch und '' bilden also zusammen eine Untergruppe. Andererseits bilden null und undefined die zweite Untergruppe. Überprüfen Sie die Vergleiche in der folgenden Abbildung. null und undefined wäre gleich. Die anderen drei würden sich gleich sein. Sie werden jedoch alle in JavaScript als falsche Bedingungen behandelt.

Dies ist mit jedem Objekt (wie {}, Arrays usw.) identisch. Nicht leere Zeichenfolge und boolescher Wert sind alle wahrheitsgemäßen Bedingungen. Aber sie sind nicht alle gleich.


* Operatoren === vs == *

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true

Aus dem Kern Javascript Referenz

===Gibt zurück, truewenn die Operanden streng gleich sind (siehe oben), ohne Typumwandlung.


Die ersten beiden Antworten, die beide erwähnt werden, bedeuten Gleichheit und Identität. Leider ist diese Aussage falsch.

Wenn beide Operanden von == Objekte sind, werden sie verglichen, um zu sehen, 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 erhalten sowohl == als auch === false, da a und b nicht die gleichen Objekte sind.

Das heißt: Sind beide Operanden von == Objekte, verhält sich == genauso wie ===, was auch Identität bedeutet. Der wesentliche Unterschied dieser beiden Operatoren besteht in der Typumwandlung. == hat eine Konvertierung, bevor sie die Gleichheit prüft, aber === nicht.





identity-operator