Forskellen mellem null og udefineret i JavaScript

Reference

JavaScript

Typisk brug af null

Som en funktionsparameter betyder det, at funktionsparameteren ikke er et objekt

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

Som afslutningen på objektets prototypekæde

            Object.getPrototypeOf(Object.prototype);
        

Når du frigiver variablen, skal du tildele null til variablen

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

Typisk anvendelse af udefineret

Variablen erklæres, men ikke tildeles, værdien af ​​variablen er udefineret

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

Parameteren, som funktionen skal levere, er ikke angivet under opkald, så værdien af ​​den parameter, der ikke er angivet, er udefineret

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

Egenskaber, som objektet ikke indeholder, værdien er udefineret

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

Når funktionen ikke returnerer en værdi, returneres den udefineret som standard

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

Ligheder mellem null og udefineret

Falsk, når den konverteres til boolsk

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

Forskellen mellem null og udefineret

Resultatet er anderledes, når det konverteres til et tal. Resultatet af nulkonvertering er en gyldig talværdi på 0, og resultatet af udefineret konvertering er NaN.

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

De to typer er forskellige, typen null er objekt, og typen udefineret er udefineret.

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

sammenlign null og udefineret

For at skelne mellem null og udefineret kan kun kongruens bruges. I kongruens sammenlignes det nøje, om de to typer er ens.

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

at opsummere

Efter ovenstående sammenligning har vi en klar forståelse af disse to typer. Normalt når vi bedømmer, om en variabel har en gyldig værdi, når vi skriver kode, behøver vi ikke skelne mellem de to, bare brug den som en boolsk type. Men når vi har brug for at bedømme, om ejendommen eksisterer, skal vi strengt bruge typen til at bedømme udefineret. Endelig, hvis vi videregiver en numerisk værdi, skal vi først foretage en dom og kan ikke kastes direkte til en numerisk type, ellers får null os til at få unormale resultater, og udefineret beregner direkte det ugyldige resultat NaN.