Der Unterschied zwischen null und undefiniert in JavaScript

Referenz

Typische Verwendung von null

Als Funktionsparameter bedeutet dies, dass der Funktionsparameter kein Objekt ist

            function myFn(obj) {
    if(null == obj) {
        // code
    }
}
        

Als Ende der Objektprototypkette

            Object.getPrototypeOf(Object.prototype);
        

Weisen Sie der Variablen beim Freigeben der Variablen null zu

            let o={
 code:'abc'
};
o = null;
        

Typische Verwendung von undefiniert

Die Variable wird deklariert, aber nicht zugewiesen. Der Wert der Variablen ist undefiniert

            let o;
console.log(o);    //undefined
        

Der Parameter, den die Funktion bereitstellen soll, wird beim Aufruf nicht angegeben. Der Wert des Parameters, der nicht angegeben wird, ist undefiniert

            function myFn(o) {
    console.log(o);
}
myFn();   //undefined
        

Eigenschaften, die das Objekt nicht enthält, ist der Wert undefiniert

            let o={
 code:'abc'
};
console.log(o.name);    //undefined
        

Wenn die Funktion keinen Wert zurückgibt, wird standardmäßig undefiniert zurückgegeben

            function myFn(obj) {
    obj = 'a';
}
console.log(myFn());    //undefined
        

Ähnlichkeiten zwischen null und undefiniert

Falsch bei Konvertierung in Boolesche Werte

            console.log(Boolean(null));  // false
console.log(Boolean(undefined)); // false
        

Der Unterschied zwischen null und undefiniert

Das Ergebnis ist anders, wenn es in eine Zahl konvertiert wird. Das Ergebnis der Nullkonvertierung ist ein gültiger Zahlenwert von 0, und das Ergebnis der undefinierten Konvertierung ist NaN.

            console.log(Number(null));  // 0
console.log(Number(undefined)); // NaN
        

Die beiden Typen sind unterschiedlich, der Typ Null ist Objekt und der Typ Undefiniert ist Undefiniert.

            console.log(typeof null); //object
console.log(typeof undefined); //undefined
        

Vergleiche null und undefiniert

Zur Unterscheidung zwischen null und undefiniert kann nur Kongruenz verwendet werden. Bei Kongruenz wird streng verglichen, ob die beiden Typen gleich sind.

            console.log(Boolean(null == undefined));  // true
console.log(Boolean(null === undefined)); // false
        

um zusammenzufassen

Nach dem obigen Vergleich haben wir ein klares Verständnis dieser beiden Typen. Wenn wir beim Schreiben von Code beurteilen, ob eine Variable einen gültigen Wert hat, müssen wir normalerweise nicht zwischen beiden unterscheiden, sondern verwenden sie einfach als Booleschen Typ. Wenn wir jedoch beurteilen müssen, ob die Eigenschaft vorhanden ist, müssen wir den Typ streng verwenden, um undefiniert zu beurteilen. Wenn wir einen numerischen Wert übergeben, müssen wir zuerst ein Urteil fällen und können nicht direkt in einen numerischen Typ umgewandelt werden. Andernfalls führt null zu abnormalen Ergebnissen, und undefiniert berechnet direkt das ungültige Ergebnis NaN.