La differenza tra null e undefined in JavaScript

Riferimento

Utilizzo tipico di null

Come parametro di funzione, significa che il parametro di funzione non è un oggetto

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

Come la fine della catena del prototipo dell'oggetto

            Object.getPrototypeOf(Object.prototype);
        

Quando si rilascia la variabile, assegnare null alla variabile

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

Utilizzo tipico di undefined

La variabile è dichiarata ma non assegnata, il valore della variabile è indefinito

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

Il parametro che la funzione deve fornire non viene fornito durante la chiamata, quindi il valore del parametro che non viene fornito non è definito

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

Proprietà che l'oggetto non contiene, il valore non è definito

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

Quando la funzione non restituisce un valore, restituisce undefined per impostazione predefinita

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

Somiglianze tra null e undefined

Falso quando convertito in booleano

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

La differenza tra null e undefined

Il risultato è diverso quando viene convertito in un numero. Il risultato della conversione nullo è un valore numerico valido pari a 0 e il risultato della conversione non definita è NaN.

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

I due tipi sono diversi, il tipo di null è object e il tipo di undefined è undefined.

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

confronta null e undefined

Per distinguere tra null e undefined, è possibile utilizzare solo la congruenza, che in congruenza confronta rigorosamente se i due tipi sono uguali.

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

per riassumere

Dopo il confronto di cui sopra, abbiamo una chiara comprensione di questi due tipi. Di solito quando giudichiamo se una variabile ha un valore valido durante la scrittura del codice, non abbiamo bisogno di distinguere tra i due, basta usarla come tipo booleano. Ma quando dobbiamo giudicare se la proprietà esiste, dobbiamo usare rigorosamente il tipo per giudicare indefinito. Infine, se passiamo un valore numerico, dobbiamo prima esprimere un giudizio e non possiamo essere convertiti direttamente in un tipo numerico, altrimenti null ci farà ottenere risultati anormali e undefined calcolerà direttamente il risultato non valido NaN.