undefined
y null
los valores se cuelan en el flujo de código todo el tiempo. Ya sea que perdamos una referencia debido a efectos secundarios, olvidemos asignar una variable de referencia a un objeto en la memoria u obtengamos una respuesta vacía de otro recurso, base de datos o API, tenemos que lidiar con undefined
valores null
todo el tiempo.
DIFERENCIA ENTRE INDEFINIDO Y NULO
undefined
y null
las variables a menudo van de la mano, y algunos usan los términos indistintamente. Sin embargo, hay una diferencia entre ellos:
- undefined es una variable que se refiere a algo que no existe, y la variable no está definida para ser nada.
null es una variable que está definida pero le falta un valor.
La diferencia entre los dos es quizás un poco más clara a través del código:
let a;
console.log(a); // undefined
let b = null;
console.log(b); // null
a
no está definido: no está asignado a nada y no hay una definición clara de lo que realmente es. b
se define como un valor nulo .
No importa si b
se definió directamente como null
o se definió como el valor devuelto de una función (que simplemente devuelve un null valor
), se define como algo .
Por otro lado, a
es literalmente nada . No se realizó ninguna asignación y no está del todo claro qué debería o podría ser.
En la práctica, la mayoría de los valores null
y undefined
surgen del error humano durante la programación, y estos dos van juntos en la mayoría de los casos. Al buscar uno, normalmente también buscamos el otro.
COMPRUEBE SI LA VARIABLE NO ESTÁ DEFINIDA O EN NULA
Hay dos enfoques por los que puede optar al verificar si una variable es undefined
y null
en JavaScript estándar.
Operadores == y ===
Hay una diferencia entre el operador de igualdad flexible ( ==) y el operador de igualdad estricta ( ===) en JavaScript. La igualdad flexible puede dar lugar a resultados inesperados y, en este contexto, se comporta de manera diferente al operador de igualdad estricta:
console.log(null == undefined); // true
console.log(null === undefined); // false
Dicho esto, dado que el operador de igualdad flexible trata nully undefinedcomo lo mismo, puede usarlo como la versión abreviada de verificar ambos:
// Undefined variable
if (a == null) {
let a;
console.log('Null or undefined value!');
} else {
console.log(a);
}
Esto verificaría si a es o null o undefined. Como a es undefined, esto da como resultado:
Null or undefined value!
Aunque, realmente no sabemos cuál de estos es. Si tuviéramos que usar el operador estricto, que verifica si aes null, nos sorprendería desagradablemente encontrarnos con un undefined valor en la console.log()declaración:
let a;
if (a === null) {
console.log('Null or undefined value!');
} else {
console.log(a); // undefined
}
a realmente no lo es null , pero lo es undefined. En este caso, nos gustaría verificarlos por separado, pero tener la flexibilidad de conocer la verdadera razón del flujo:
if (a === null || a === undefined) { // true
console.log('Null or undefined value!');
} else {
console.log(a);
}
Aquí los hemos combinado con un OR exclusivo, aunque también puede separarlos para diferentes operaciones de recuperación si así lo desea:
let a;
if (a === null) {
console.log('Null value!');
} else if (a === undefined) { // true
console.log('Undefined value!');
}