Comprobar si una variable está vacía en Javascript

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
let a;if (a == null) {
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!');
}