A diferença entre nulo e indefinido em JavaScript

Referência

Uso típico de nulo

Como um parâmetro de função, significa que o parâmetro de função não é um objeto

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

Como o fim da cadeia de protótipos de objetos

            Object.getPrototypeOf(Object.prototype);
        

Ao liberar a variável, atribua nulo à variável

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

Uso típico de indefinido

A variável é declarada, mas não atribuída, o valor da variável é indefinido

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

O parâmetro que a função deve fornecer não é fornecido ao chamar, então o valor do parâmetro que não é fornecido é indefinido

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

Propriedades que o objeto não contém, o valor é indefinido

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

Quando a função não retorna um valor, ela retorna indefinido por padrão

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

Semelhanças entre nulo e indefinido

Falso quando convertido para booleano

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

A diferença entre nulo e indefinido

O resultado é diferente quando convertido em um número. O resultado da conversão nula é um valor de número válido de 0, e o resultado da conversão indefinida é NaN.

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

Os dois tipos são diferentes, o tipo de nulo é objeto e o tipo de indefinido é indefinido.

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

compare nulo e indefinido

Para distinguir entre nulo e indefinido, apenas congruência pode ser usada. Em congruência, ele irá comparar estritamente se os dois tipos são iguais.

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

Resumindo

Após a comparação acima, temos uma compreensão clara desses dois tipos. Normalmente, quando julgamos se uma variável tem um valor válido ao escrever o código, não precisamos distinguir entre os dois, apenas usá-lo como um tipo booleano. Mas quando precisamos julgar se a propriedade existe, devemos usar estritamente o tipo para julgar indefinido. Finalmente, se passarmos um valor numérico, devemos primeiro fazer um julgamento e não pode ser diretamente convertido para um tipo numérico, caso contrário, nulo nos fará obter resultados anormais e undefined calculará diretamente o resultado inválido NaN.