Het verschil tussen null en ongedefinieerd in JavaScript

Referentie

JavaScript

Typisch gebruik van null

Als functieparameter betekent dit dat de functieparameter geen object is

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

Als het einde van de prototypeketen van het object

            Object.getPrototypeOf(Object.prototype);
        

Wijs null toe aan de variabele bij het vrijgeven van de variabele

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

Typisch gebruik van ongedefinieerd

De variabele is gedeclareerd maar niet toegewezen, de waarde van de variabele is niet gedefinieerd

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

De parameter die de functie moet leveren, wordt niet opgegeven bij het aanroepen, en de waarde van de parameter die niet wordt opgegeven, is niet gedefinieerd

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

Eigenschappen die het object niet bevat, de waarde is niet gedefinieerd

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

Als de functie geen waarde retourneert, retourneert deze standaard ongedefinieerd

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

Overeenkomsten tussen nul en ongedefinieerd

False bij conversie naar boolean

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

Het verschil tussen nul en ongedefinieerd

Het resultaat is anders bij conversie naar een getal. Het resultaat van een nulconversie is een geldige getalswaarde van 0, en het resultaat van een ongedefinieerde conversie is NaN.

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

De twee typen zijn verschillend, het type null is object en het type ongedefinieerd is ongedefinieerd.

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

vergelijk null en ongedefinieerd

Om onderscheid te maken tussen nul en ongedefinieerd, kan alleen congruentie worden gebruikt.In congruentie zal het strikt vergelijken of de twee typen gelijk zijn.

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

opsommen

Na bovenstaande vergelijking hebben we een duidelijk begrip van deze twee typen. Als we beoordelen of een variabele een geldige waarde heeft bij het schrijven van code, hoeven we meestal geen onderscheid te maken tussen de twee, gebruik het gewoon als een Booleaans type. Maar als we moeten beoordelen of de eigenschap bestaat, moeten we strikt het type gebruiken om ongedefinieerd te beoordelen. Ten slotte, als we een numerieke waarde doorgeven, moeten we eerst een oordeel vellen, en kunnen we niet direct naar een numeriek type casten, anders zal null ervoor zorgen dat we abnormale resultaten krijgen, en ongedefinieerd zal direct het ongeldige resultaat NaN berekenen.