La diferencia entre nulo e indefinido en JavaScript

Referencia

JavaScript

Uso típico de null

Como parámetro de función, significa que el parámetro de función no es un objeto.

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

Como el final de la cadena de prototipos de objetos

            Object.getPrototypeOf(Object.prototype);
        

Al liberar la variable, asigne nulo a la variable

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

Uso típico de indefinido

La variable se declara pero no se asigna, el valor de la variable no está definido

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

El parámetro que la función debe proporcionar no se proporciona al llamar, entonces el valor del parámetro que no se proporciona no está definido

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

Propiedades que el objeto no contiene, el valor no está definido

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

Cuando la función no devuelve un valor, devuelve indefinido de forma predeterminada

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

Similitudes entre nulo e indefinido

Falso cuando se convierte a booleano

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

La diferencia entre nulo e indefinido

El resultado es diferente cuando se convierte en un número. El resultado de la conversión nula es un valor numérico válido de 0, y el resultado de la conversión indefinida es NaN.

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

Los dos tipos son diferentes, el tipo de nulo es objeto y el tipo de indefinido es indefinido.

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

comparar nulo e indefinido

Para distinguir entre nulo e indefinido, solo se puede utilizar la congruencia, en la que se comparará estrictamente si los dos tipos son iguales.

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

para resumir

Después de la comparación anterior, tenemos una comprensión clara de estos dos tipos. Por lo general, cuando juzgamos si una variable tiene un valor válido al escribir código, no necesitamos distinguir entre los dos, solo utilícelo como un tipo booleano. Pero cuando necesitamos juzgar si la propiedad existe, debemos usar estrictamente el tipo para juzgar indefinido. Finalmente, si pasamos un valor numérico, primero debemos emitir un juicio y no se puede convertir directamente a un tipo numérico; de lo contrario, null hará que obtengamos resultados anormales y undefined calculará directamente el resultado no válido NaN.