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

Verwenden Sie === wenn Sie mehrere Dinge in JavaScript vergleichen wollen, heißt das strikte Gleichstellung bedeutet dies, dass true zurückgegeben wird, wenn nur Typ und Wert sind identisch so dass es für Sie keine unerwünschte Typkorrektur gibt, wenn Sie die == ist der Typ im Grunde egal, und in vielen Fällen könnte es Probleme mit einem losen Gleichheitsvergleich geben.

Strenge Gleichheit mit ===

Strenge Gleichheit vergleicht zwei Werte auf Gleichheit. Keiner der beiden Werte wird implizit in einen anderen Wert umgewandelt, bevor er verglichen wird. Wenn die Werte unterschiedliche Typen haben, werden die Werte als ungleich betrachtet. Andernfalls, wenn die Werte denselben Typ haben und keine Zahlen sind, werden sie als gleich betrachtet, wenn sie denselben Wert haben. Wenn schließlich beide Werte Zahlen sind, werden sie als gleich angesehen, wenn sie beide nicht NaN sind und den gleichen 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 sie beide Werte in einen gemeinsamen Typ. Nach Konvertierungen (eine oder beide Seiten können Konvertierungen durchlaufen), wird der endgültige Gleichheitsvergleich durchgeführt genau wie bei === durchgeführt. Lose Gleichheit ist symmetrisch: A == B hat immer die gleiche Semantik wie B == A für beliebige Werte von A und B (abgesehen von der Reihenfolge der angewandten Umwandlungen).

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

Answer 2

Javascript ist locker typisiert, genau wie php,

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

if (x===y) // false

Dies führt immer zu einem falschen Ergebnis, denn obwohl die Werte der Variablen gleich sind, sind die Datentypen nicht gleich

Eine ist string, die andere ist int

If(x==y)//true

Es wird jedoch nur geprüft, ob der Inhalt gleich ist, unabhängig von den Datentypen...

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

Answer 3

var a = new String("123");
var b = "123";

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

Dies habe ich in einer der Antworten gesehen. a y b sind in diesem Fall nicht wirklich derselbe Typ, wenn Sie prüfen wollen typeof(a) erhalten Sie 'Objekt' y typeof(b) es String .