A diferenza entre nulo e indefinido en JavaScript

Referencia

JavaScript

Uso típico de nulo

Como parámetro de función, significa que o parámetro de función non é un obxecto

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

Como final da cadea de prototipo de obxecto

            Object.getPrototypeOf(Object.prototype);
        

Ao liberar a variable, asigna nulo á variable

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

Uso típico de indefinido

A variable declárase pero non está asignada, o valor da variable non está definido

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

O parámetro que debería proporcionar a función non se proporciona ao chamar, entón o valor do parámetro que non se proporciona non está definido

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

Propiedades que o obxecto non contén, o valor non está definido

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

Cando a función non devolve un valor, devolve por defecto sen definir

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

Semellanzas entre nulo e indefinido

Falso cando se converte a booleano

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

A diferenza entre nulo e indefinido

O resultado é diferente cando se converte nun número. O resultado da conversión nula é un valor de número válido de 0 e o resultado da conversión sen definir é NaN.

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

Os dous tipos son diferentes, o tipo de nulo é obxecto e o tipo de indefinido está indefinido.

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

comparar nulo e indefinido

Para distinguir entre nulo e indefinido, só se pode empregar a congruencia. En congruencia, comparará estritamente se os dous tipos son iguais.

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

para resumir

Despois da comparación anterior, temos unha clara comprensión destes dous tipos. Normalmente, cando xulgamos se unha variable ten un valor válido ao escribir código, non necesitamos distinguir entre as dúas, só usala como un tipo booleano. Pero cando necesitamos xulgar se a propiedade existe, debemos usar estritamente o tipo para xulgar indefinido. Finalmente, se pasamos un valor numérico, primeiro debemos emitir un xuízo e non podemos emitir directamente un tipo numérico, se non, nulo fará que obteñamos resultados anormais e non definido calculará directamente o resultado inválido NaN.