Der spezielle Zahlenwert NaN (siehe NaN) ist nicht gleich sich selbst:

> NaN === NaN
false

Daher müssen Sie andere Mittel verwenden, um ihn zu überprüfen, die in Fallstrick: Überprüfen, ob ein Wert NaN ist beschrieben sind.

Ein strikter Ungleichheits-Vergleich:

x !== y

ist äquivalent zur Negation eines strikten Gleichheitsvergleichs

!(x === y)

Ein Ungleichheits-Vergleich:

x != y

ist äquivalent zur Negation eines Gleichheitsvergleichs

!(x == y)

Schritt 3 bedeutet, dass Gleichheit und Konvertierung in einen Boolean (siehe Konvertierung in Boolean) unterschiedlich funktionieren. Wenn Zahlen größer als 1 in einen Boolean konvertiert werden, werden sie true (z. B. in if-Anweisungen). Aber diese Zahlen sind nicht lenient gleich true. Die Kommentare erklären, wie die Ergebnisse berechnet wurden

> 2 == true  // 2 === 1
false
> 2 == false  // 2 === 0
false

> 1 == true  // 1 === 1
true
> 0 == false  // 0 === 0
true

Ähnlich verhält es sich so, dass die leere Zeichenkette gleich false ist, aber nicht alle nicht-leeren Zeichenketten gleich true sind:

> '' == false   // 0 === 0
true
> '1' == true  // 1 === 1
true
> '2' == true  // 2 === 1
false
> 'abc' == true  // NaN === 1
false

Ein Teil der Lenienz kann nützlich sein, abhängig davon, was Sie möchten:

> 'abc' == new String('abc')  // 'abc' == 'abc'
true
> '123' == 123  // 123 === 123
true

Andere Fälle sind problematisch, aufgrund der Art und Weise, wie JavaScript Zeichenketten in Zahlen umwandelt (siehe Konvertierung in Zahl)

> '\n\t123\r ' == 123  // usually not OK
true
> '' == 0  // 0 === 0
true

Wenn Sie ein Objekt mit einem Nicht-Objekt vergleichen, wird es in einen primitiven Wert umgewandelt, was zu seltsamen Ergebnissen führt:

> {} == '[object Object]'
true
> ['123'] == 123
true
> [] == 0
true

Zwei Objekte sind jedoch nur dann gleich, wenn sie dasselbe Objekt sind. Das bedeutet, dass Sie keine Wrapper-Objekte wirklich vergleichen können

> new Boolean(true) === new Boolean(true)
false
> new Number(123) === new Number(123)
false
> new String('abc') == new String('abc')
false

Der folgende Vergleich stellt sicher, dass x weder undefined noch null ist:

if (x != null) ...

Obwohl dies eine kompakte Schreibweise für diese Prüfung ist, verwirrt sie Anfänger, und Experten können nicht sicher sein, ob es sich um einen Tippfehler handelt oder nicht. Wenn Sie also überprüfen möchten, ob x einen Wert hat, verwenden Sie die Standardprüfung auf Wahrhaftigkeit (behandelt in Wahrheitswerte und Falschwerte)

if (x) ...

Wenn Sie präziser sein möchten, sollten Sie eine explizite Prüfung für beide Werte durchführen

if (x !== undefined && x !== null) ...

Wenn Sie nicht sicher sind, ob ein Wert x eine Zahl oder eine Zahl-als-Zeichenkette ist, können Sie Prüfungen wie die folgenden verwenden:

if (x == 123) ...

Das Vorherige prüft, ob x entweder 123 oder '123' ist. Wiederum ist dies sehr kompakt, und wieder ist es besser, explizit zu sein

if (Number(x) === 123) ...

Leniente Gleichheit ermöglicht Ihnen den Vergleich von primitiven Werten mit gewrappten primitiven Werten:

> 'abc' == new String('abc')
true

Es gibt drei Gründe gegen diesen Ansatz. Erstens funktioniert leniente Gleichheit nicht zwischen gewrappten primitiven Werten:

> new String('abc') == new String('abc')
false

Zweitens sollten Sie Wrapper ohnehin vermeiden. Drittens, wenn Sie sie doch verwenden, ist es besser, explizit zu sein

if (wrapped.valueOf() === 'abc') ...

Unter ECMAScript 5 ist void selten nützlich. Seine Haupt-Anwendungsfälle sind:

Laut JavaScript-Erfinder Brendan Eich hat er ihn zur Sprache hinzugefügt, um javascript: Links (einer der oben genannten Anwendungsfälle) zu unterstützen:

Leider ist typeof null 'object'. Dies wird als Fehler betrachtet (null ist kein Mitglied des internen Typs Object), aber es kann nicht behoben werden, da dies bestehenden Code brechen würde. Sie müssen daher null vorsichtig behandeln. Beispielsweise prüft die folgende Funktion, ob value ein Objekt ist:

function isObject(value) {
    return (value !== null
       && (typeof value === 'object'
           || typeof value === 'function'));
}

Ausprobieren

> isObject(123)
false
> isObject(null)
false
> isObject({})
true

Die erste JavaScript-Engine stellte JavaScript-Werte als 32-Bit-Wörter dar. Die niedrigsten 3 Bits eines solchen Wortes wurden als Typ-Tag verwendet, um anzugeben, ob der Wert ein Objekt, eine Ganzzahl, eine Gleitkommazahl, eine Zeichenkette oder ein Boolean war (wie Sie sehen können, speicherte selbst diese frühe Engine Zahlen bereits als Ganzzahlen, wenn möglich).

Das Typ-Tag für Objekte war 000. Um den Wert null darzustellen, verwendete die Engine den Maschinen-NULL-Zeiger, ein Wort, bei dem alle Bits Null sind. typeof prüfte das Typ-Tag, um den Werttyp zu bestimmen, weshalb es null als Objekt meldete.^[13]

Die Prüfung:

typeof x === 'undefined'

hat zwei Anwendungsfälle

Hier sind Beispiele für beide Anwendungsfälle

> var foo;
> typeof foo === 'undefined'
true

> typeof undeclaredVariable === 'undefined'
true

Für den ersten Anwendungsfall ist der direkte Vergleich mit undefined in der Regel besser. Für den zweiten Anwendungsfall funktioniert dies jedoch nicht

> var foo;
> foo === undefined
true

> undeclaredVariable === undefined
ReferenceError: undeclaredVariable is not defined