La diferencia entre nulo e indefinido en JavaScript
Referencia
JavaScriptUso 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.