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

Eine nicht genannter Grund für die Verwendung === - ist in dem Fall, dass Sie mit / Cross-Kompilierung zu / von coffee-script . Von der Kleines Buch über CoffeeScript ...

Der schwache Gleichheitsvergleich in JavaScript hat einige verwirrende Verhalten und ist oft die Quelle von verwirrenden Bugs.

Die Lösung besteht darin, stattdessen den strikten Gleichheitsoperator zu verwenden, der aus drei Gleichheitszeichen besteht: ===. Er funktioniert genau wie der normale Gleichheitsoperator, aber ohne jegliche Typenzwänge. Es wird empfohlen, immer den strengen Gleichheitsoperator zu verwenden und bei Bedarf explizit Typen zu konvertieren.

Wenn Sie regelmäßig Konvertierungen von und nach coffee-script sollten Sie einfach === . In der Tat, die coffee-script Der Compiler wird zwingen Sie zu ...

CoffeeScript löst dies, indem es einfach alle schwachen Vergleiche durch strenge ersetzt, also alle ==-Vergleicher in === umwandelt. Ein schwacher Gleichheitsvergleich ist in CoffeeScript nicht möglich, und man sollte Typen explizit konvertieren, bevor man sie vergleicht, falls nötig.

Answer 2

Strenge Gleichheit ist in den meisten Fällen besser

Die Tatsache, dass es sich bei Javascript um eine lose typisierte Sprache handelt, muss Ihnen bei der Arbeit mit ihr ständig vor Augen sein. Solange die Datenstruktur dieselbe ist, gibt es eigentlich keinen Grund, keine strikte Gleichheit zu verwenden. Bei der regulären Gleichheit findet oft eine implizite Konvertierung von Werten statt, die automatisch erfolgt, was weitreichende Auswirkungen auf Ihren Code haben kann. Es ist sehr einfach, Probleme mit dieser Konvertierung zu bekommen, da sie automatisch erfolgt.

Bei strikter Gleichheit gibt es keine automatische implizite Konvertierung, da die Werte bereits die richtige Datenstruktur haben müssen.

Answer 3

Zunächst einige Begriffe zu Javascript String Equals: Double equals ist offiziell als abstrakter Gleichheitsvergleichsoperator bekannt, während triple equals als strenger Gleichheitsvergleichsoperator bezeichnet wird. Der Unterschied zwischen ihnen lässt sich wie folgt zusammenfassen: Bei der abstrakten Gleichheit wird versucht, die Datentypen vor dem Vergleich durch Typenzwang aufzulösen. Strenge 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.

Die Verwendung von zwei Gleichheitszeichen ergibt true, da die Zeichenkette "3" in die Zahl 3 umgewandelt wird, bevor der Vergleich durchgeführt wird. Bei drei Gleichheitszeichen wird festgestellt, dass die Typen unterschiedlich sind, und falsch zurückgegeben. Hier ist eine andere:

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 Typumwandlung durch. In diesem Fall werden sowohl der boolesche Wert true als auch die Zeichenkette '1' in die Zahl 1 umgewandelt und das Ergebnis ist true. Strenge Gleichheit ergibt false.

Wenn Sie das verstehen, sind Sie auf dem besten Weg, zwischen == und === zu unterscheiden. Es gibt jedoch einige Szenarien, in denen das Verhalten dieser Operatoren nicht intuitiv ist. Schauen wir uns ein paar 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, weil es verdeutlicht, dass sich String-Literale von String-Objekten 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

Answer 4

Das Dilemma "Soll ich die == o === im JavaScript-Vergleich" ist gleichbedeutend oder analog zu einer Frage wie: "Soll ich zum Essen einen 'Löffel' oder eine 'Gabel' benutzen.

Die einzige vernünftige Antwort auf diese Frage ist, dass

1. Sie sollten Folgendes verwenden Dynamischer Typ Vergleich z.B.: == pour lose Art Vergleiche.
2. Sie sollten Folgendes verwenden Statischer Typ Vergleich z.B.: === pour starker Typ Vergleiche.

Das liegt daran, dass sie nicht dasselbe sind. Sie haben nicht denselben Zweck und sind nicht für denselben Zweck bestimmt.

Natürlich sind sowohl "Gabeln" als auch "Löffel" zum "Essen" gedacht, aber Sie werden sie je nach dem benutzen, was Ihnen zum Essen serviert wurde.

Das bedeutet: Sie werden sich entschließen, einen "Löffel" zu benutzen, d.h.: == für eine "Suppe" und / oder die "Gabel" d.h.: === zum Pflücken.

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, einen statischen [===] oder einen dynamischen [==] Gleichheitswert zu verwenden, op. in JS. Beide Fragen sind gleichermaßen falsch und spiegeln ein sehr enges oder oberflächliches Verständnis des betreffenden Themas wider.

Answer 5

Der Grund, warum er vorschlägt, die == con === ist, dass die === Operator ist zuverlässiger als == . In unserem Zusammenhang bedeutet zuverlässig === gilt auch für die Typenprüfung. Unter Berücksichtigung der besten Programmierpraktiken sollten wir immer die zuverlässigere Funktion der weniger zuverlässigen vorziehen. Wann immer wir über den Operator "genau gleich" nachdenken, sind wir in den meisten Fällen der Meinung, dass der Typ gleich sein sollte. Als === bietet, sollten wir uns darauf einlassen.