Skillnaden mellan null och odefinierad i JavaScript

Referens

JavaScript

Typisk användning av null

Som en funktionsparameter betyder det att funktionsparametern inte är ett objekt

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

Som slutet på objektets prototypkedja

            Object.getPrototypeOf(Object.prototype);
        

När du släpper variabeln, tilldela variabeln null

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

Vanlig användning av odefinierad

Variabeln deklareras men tilldelas inte, variabelns värde är odefinierat

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

Parametern som funktionen ska tillhandahålla tillhandahålls inte vid anrop, då är värdet på parametern som inte tillhandahålls odefinierat

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

Egenskaper som objektet inte innehåller, värdet är odefinierat

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

När funktionen inte returnerar ett värde returnerar den odefinierad som standard

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

Likheter mellan noll och odefinierad

Falskt när det omvandlas till booleskt

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

Skillnaden mellan noll och odefinierad

Resultatet är annorlunda när det konverteras till ett nummer. Resultatet av nollomvandling är ett giltigt talvärde på 0 och resultatet av odefinierad omvandling är NaN.

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

De två typerna är olika, typen av null är objekt och typen av odefinierad är odefinierad.

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

jämför null och odefinierad

För att skilja mellan noll och odefinierad kan endast kongruens användas. I kongruens jämförs det strikt om de två typerna är lika.

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

För att sammanfatta

Efter ovanstående jämförelse har vi en klar förståelse för dessa två typer. Vanligtvis när vi bedömer om en variabel har ett giltigt värde när vi skriver kod behöver vi inte skilja mellan de två, bara använda den som en boolsk typ. Men när vi behöver bedöma om fastigheten finns måste vi strikt använda typen för att bedöma odefinierad. Slutligen, om vi passerar ett numeriskt värde, måste vi först göra en bedömning och kan inte kastas direkt till en numerisk typ, annars kommer null att få oss onormala resultat, och odefinierad beräknar direkt det ogiltiga resultatet NaN.