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

Question

Ich benutze JSLint durch JavaScript zu gehen, und es werden viele Vorschläge zum Ersetzen von == (zwei Gleichheitszeichen) mit === (drei Gleichheitszeichen), wenn Sie z. B. Folgendes vergleichen idSele_UNVEHtype.value.length == 0 innerhalb eines if Erklärung.

Gibt es einen Leistungsvorteil durch den Austausch von == con === ?

Da es viele Vergleichsoperatoren gibt, wäre jede Leistungsverbesserung zu begrüßen.

Wenn keine Typkonvertierung stattfindet, gibt es dann einen Leistungsgewinn gegenüber == ?

Answer 1

Ich habe dies in Firefox mit Firebug mit einem Code wie diesem:

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

et

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

Ich würde also sagen, dass der winzige Unterschied (es handelt sich um über 100000 Iterationen) vernachlässigbar ist. Leistung ist nicht ein Grund zu tun === . Typsicherheit (nun ja, so sicher wie es in JavaScript möglich ist) und Codequalität.

Answer 2

In PHP und JavaScript ist es ein strenger Gleichheitsoperator. Das heißt, er vergleicht sowohl Typ als auch Werte.

Answer 3

In JavaScript bedeutet dies, dass sie den gleichen Wert und Typ haben.

Zum Beispiel,

4 == "4" // will return true

sondern

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

Answer 4

Warum == so unberechenbar ist?

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

true

Ja, das ist richtig, laut == eine leere Zeichenkette und die Zahl Null sind gleichzeitig.

Und das ist noch nicht alles, hier ist noch eine weitere:

'0' == false // true

Mit Arrays werden die Dinge wirklich seltsam.

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

Dann noch seltsamer mit Strings

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

Es wird noch 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 sind nur die verrückten Dinge, die man mit Primitiven erreichen kann.

Es ist eine ganz neue Stufe der Verrücktheit, wenn man == mit Objekten.

An diesem Punkt fragen Sie sich wahrscheinlich...

Warum ist das so?

Nun, das liegt daran, dass im Gegensatz zu "Triple Equals" ( === ), die nur prüft, ob zwei Werte gleich sind.

== macht eine einen ganzen Haufen anderer Dinge .

Es hat eine spezielle Handhabung für Funktionen, eine spezielle Handhabung für Nullen, undefinierte, Zeichenketten, was auch immer.

Es wird ziemlich verrückt.

Wenn Sie nämlich versuchen würden, eine Funktion zu schreiben, die das tut, was == würde es etwa 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 also?

Das bedeutet == ist kompliziert.

Da es kompliziert ist, ist es schwer zu wissen, was passiert, wenn man es benutzt.

Das bedeutet, dass Sie mit Fehlern konfrontiert werden könnten.

Die Moral von der Geschicht' ist also...

Machen Sie Ihr Leben weniger kompliziert.

Verwenden Sie === anstelle von == .

Das Ende.

Answer 5

Le site \=== Operator wird als strenger Vergleichsoperator bezeichnet, er hace unterscheiden sich von der \== Betreiber.

Nehmen wir 2 Variablen a und b.

Para "a == b" um wahr zu werden, müssen a und b gleich sein gleicher Wert .

Im Fall von "a === b" a und b müssen gleich sein gleicher Wert und auch die gleiche Art damit sie als wahr ausgewertet wird.

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

Zusammengefasst ; unter Verwendung der \== Operator könnte in Situationen, in denen Sie das nicht wollen, als wahr ausgewertet werden, so dass die Verwendung des \=== Betreiber sicherer wäre.

In einem 90%igen Nutzungsszenario ist es egal, welche Sie verwenden, aber es ist praktisch, den Unterschied zu kennen, wenn Sie eines Tages ein unerwartetes Verhalten feststellen.