JavaScript-Prüfung auf null vs. undefiniert und Unterschied zwischen == und ===

Question

1. Wie prüfe ich eine Variable, wenn sie null o undefined und was ist der Unterschied zwischen dem null y undefined ?

2. Was ist der Unterschied zwischen == y === (es ist schwierig, bei Google nach "===" zu suchen)?

Answer 1

Wie prüfe ich eine Variable, wenn sie null o undefined ...

Ist die Variable null :

if (a === null)
// or
if (a == null) // but see note below

...aber beachten Sie, dass Letzteres auch dann zutrifft, wenn a es undefined .

Ist es undefined :

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

...aber auch hier ist zu beachten, dass der letzte Punkt vage ist; er wird auch zutreffen, wenn a es null .

Trotz der obigen Ausführungen ist die üblich Sie können diese überprüfen, indem Sie die Tatsache nutzen, dass sie falsch :

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

Dies ist definiert durch ToBoolean in der Spezifikation.

...und was ist der Unterschied zwischen dem null y undefined ?

Beides sind Werte, die normalerweise verwendet werden, um die Abwesenheit von etwas anzuzeigen. undefined ist der allgemeinere Wert, der als Standardwert von Variablen verwendet wird, bis ihnen ein anderer Wert zugewiesen wird, als Wert von Funktionsargumenten, die beim Aufruf der Funktion nicht angegeben wurden, und als Wert, den Sie erhalten, wenn Sie ein Objekt nach einer Eigenschaft fragen, die es nicht hat. Er kann aber auch explizit in all diesen Situationen verwendet werden. (Es gibt einen Unterschied zwischen einem Objekt, das eine Eigenschaft nicht hat, und einem Objekt, das die Eigenschaft mit dem Wert undefined ; es gibt einen Unterschied zwischen dem Aufruf einer Funktion mit dem Wert undefined für ein Argument zu verwenden und dieses Argument ganz wegzulassen).

null ist etwas spezifischer als undefined : Es ist eine leere Objektreferenz. JavaScript ist natürlich lose typisiert, aber nicht alle Dinge, mit denen JavaScript interagiert, sind lose typisiert. Wenn eine API wie das DOM in Browsern einen Objektverweis benötigt, der leer ist, verwenden wir null ではなく undefined . Und in ähnlicher Weise ist die DOM getElementById Operation gibt eine Objektreferenz zurück - entweder eine gültige (wenn sie das DOM-Element gefunden hat), oder null (wenn sie es nicht getan hat).

Interessanterweise (oder auch nicht) sind sie ihre eigenen Typen. Was soviel heißt wie, null ist der einzige Wert vom Typ Null, und undefined ist der einzige Wert des Typs Undefiniert.

Was ist der Unterschied zwischen "==" und "==="?

Der einzige Unterschied zwischen ihnen besteht darin, dass == versucht, die Werte durch Typenzwang zur Übereinstimmung zu bringen, und === wird nicht. Also zum Beispiel "1" == 1 ist wahr, denn "1" zwingt zu 1 . Aber "1" === 1 es falsch , weil die Typen nicht übereinstimmen. ( "1" !== 1 wahr ist.) Der erste (echte) Schritt von === lautet "Sind die Typen der Operanden gleich?", und wenn die Antwort "nein" lautet, ist das Ergebnis false . Wenn die Typen gleich sind, tut es genau das, was == tut.

Der Typenzwang verwendet recht komplexe Regeln und kann zu überraschenden Ergebnissen führen (zum Beispiel, "" == 0 wahr ist).

Mehr dazu in der Spezifikation:

• Abstrakter Gleichheitsvergleich ( == auch "lose" Gleichheit genannt)
• Strenger Gleichheitsvergleich ( === )

Answer 2

Der Unterschied ist subtil.

In JavaScript wird ein undefined Variable ist eine Variable, die noch nie deklariert wurde oder der noch nie ein Wert zugewiesen wurde. Angenommen, Sie deklarieren var a; zum Beispiel, dann a wird undefined weil ihm nie ein Wert zugewiesen wurde.

Wenn Sie dann aber a = null; entonces a wird nun null . In JavaScript null ein Objekt ist (versuchen Sie typeof null in einer JavaScript-Konsole, wenn Sie mir nicht glauben), was bedeutet, dass null ein Wert ist (tatsächlich ist sogar undefined ist ein Wert).

Ejemplo:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

Dies kann sich bei Funktionsargumenten als nützlich erweisen. Vielleicht möchten Sie einen Standardwert haben, halten aber null für akzeptabel. In diesem Fall können Sie dies tun:

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

Wenn Sie die optional Parameter doSomething(1, 2) then optional wird die "three" String, aber wenn Sie doSomething(1, 2, null) dann wird optional sein null .

Was die Gleichheit betrifft == und streng gleich === Komparatoren ist der erste schwach typisiert, während bei strictly equal auch der Typ der Werte geprüft wird. Das bedeutet, dass 0 == "0" wird true zurückgeben; während 0 === "0" gibt false zurück, da eine Zahl keine Zeichenkette ist.

Sie können diese Operatoren verwenden, um zu prüfen zwischen undefined un null . Zum Beispiel:

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

Der letzte Fall ist interessant, weil er es ermöglicht, zu prüfen, ob eine Variable entweder undefiniert oder null ist und nichts anderes:

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

Answer 3

Die Spezifikation ist die richtige Anlaufstelle, um diese Fragen umfassend zu beantworten. Hier ist eine Zusammenfassung:

1. Für eine Variable x können Sie:

   • prüfen, ob es sich um null durch direkten Vergleich mit === . Beispiel: x === null
   • prüfen, ob es sich um undefined mit einer von zwei grundlegenden Methoden: direkter Vergleich mit undefined o typeof . Für verschiedene Gründe Ich bevorzuge typeof x === "undefined" .
   • prüfen, ob es sich um eine der null y undefined durch die Verwendung von == und sich auf die etwas undurchsichtigen Regeln für den Typenzwang verlassen, die bedeuten x == null macht genau das, was Sie wollen.

2. Der grundlegende Unterschied zwischen == y === ist, dass wenn die Operanden von unterschiedlichem Typ sind, === wird immer zurückkehren false während == wandelt einen oder beide Operanden in denselben Typ um, indem es Regeln die zu einem etwas unintuitiven Verhalten führen. Wenn die Operanden vom gleichen Typ sind (z.B. sind beide Strings, wie in der typeof Vergleich oben), == y === verhalten sich genau gleich.

Lesen Sie weiter:

• Angus Crolls Wahrheit, Gleichheit und JavaScript
• Andrea Giammarchi's JavaScript-Zwang entmystifiziert
• comp.lang.javascript FAQs: JavaScript Typ-Konvertierung

Answer 4

Wie überprüfe ich eine Variable, ob sie null oder undefiniert ist?

Prüfen Sie einfach, ob eine Variable einen gültigen Wert hat, etwa so:

if(variable)

es wird true zurückgegeben, wenn die Variable nicht enthält:

• null
• undefiniert
• 0
• falsch
• "" (eine leere Zeichenkette)
• NaN

Answer 5

Ad 1. null kein Bezeichner für eine Eigenschaft des globalen Objekts ist, wie undefined kann sein

let x;      // undefined
let y=null; // null
let z=3;    // has value
// 'w'      // is undeclared

if(!x) console.log('x is null or undefined');
if(!y) console.log('y is null or undefined');
if(!z) console.log('z is null or undefined');

try { if(w) 0 } catch(e) { console.log('w is undeclared') }
// typeof not throw exception for undelared variabels
if(typeof w === 'undefined') console.log('w is undefined');

Ad 2. Die === Werte und Typen prüfen. Die Website == erfordern nicht dieselben Typen und haben eine implizite Konvertierung vor dem Vergleich vorgenommen (mit .valueOf() y .toString() ). Hier haben Sie alle ( src ):

wenn

\== (seine Verneinung != )

\=== (seine Verneinung !== )