undefined o null en JavaScript: cómo verificar una variable en 2025

«Variable no definida»: ¿por qué esta pregunta atormenta a todos?

Si alguna vez has escrito en JavaScript, seguro te has encontrado con esta situación: ejecutas el código y en la consola aparece un mensaje rojo Uncaught TypeError: Cannot read properties of undefined. O peor aún — null is not an object. ¿Te suena? Este es uno de los errores más comunes que persigue a desarrolladores de todos los niveles.

La pregunta «How can I determine if a variable is 'undefined' or 'null'?» en Stack Overflow ha acumulado miles de visitas y cientos de respuestas. Y no es casualidad: en JavaScript estos dos valores son similares, pero se comportan de manera diferente. En 2025, cuando el código se vuelve más complejo y los proyectos más grandes, saber cómo verificar correctamente undefined y null pasa de ser «bueno saberlo» a «obligatorio saberlo».

En este artículo analizaremos todas las formas de verificación, desde las simples hasta las avanzadas, y mostraremos qué métodos vale la pena usar en el desarrollo moderno. ¡Allá vamos!

undefined vs null: ¿cuál es la diferencia?

Antes de verificar, entendamos con qué estamos tratando. En JavaScript, undefined y null son dos valores primitivos diferentes, cada uno con su propio tipo.

undefined

undefined es el valor que se asigna automáticamente a una variable si la declaras pero no le asignas un valor. También una función devuelve undefined si no tiene un return explícito.

let myVar;\nconsole.log(myVar); // undefined\n\nfunction doNothing() {}\nconsole.log(doNothing()); // undefined\n\nconsole.log(someNonExistentVariable); // ReferenceError, pero si accedes a una propiedad de un objeto:\nconst obj = {};\nconsole.log(obj.prop); // undefined\n

null

null es un valor que el desarrollador asigna intencionalmente. Significa «vacío», «nada», «valor ausente». null es un objeto desde la perspectiva de typeof (sí, es un error histórico, pero ya se ha convertido en una característica).

let myVar = null;\nconsole.log(myVar); // null\nconsole.log(typeof myVar); // "object" — ¡sí, es así!\n

La principal diferencia: undefined es «aún no asignado», mientras que null es «intencionalmente vacío». Pero en una comparación no estricta, son iguales:

console.log(null == undefined); // true\nconsole.log(null === undefined); // false\n

Precisamente por esta igualdad no estricta surge la confusión. Por eso, las mejores prácticas de 2025 recomiendan usar la comparación estricta (===).

Top 5 formas de verificar undefined y null

Analicemos todos los métodos populares, desde los más simples hasta los modernos. Evaluaremos cada uno según tres criterios: legibilidad, fiabilidad y rendimiento.

1. Comparación estricta (===) — el estándar de oro

La forma más directa y clara es comparar la variable directamente con undefined o null usando ===.

let value = null;\n\n// Verificación de null\nif (value === null) {\n    console.log('Esto es null');\n}\n\n// Verificación de undefined\nif (value === undefined) {\n    console.log('Esto es undefined');\n}\n\n// Verificación de null O undefined (por separado)\nif (value === null || value === undefined) {\n    console.log('El valor está ausente');\n}\n

¿Por qué es la mejor práctica?

\n
• Máxima legibilidad — cualquier desarrollador entenderá lo que estás verificando.
\n
• No hay conversiones de tipo inesperadas.
\n
• Funciona en todas las versiones de JavaScript, incluidas las más antiguas.
\n

Desventaja: Si necesitas verificar ambos valores a la vez, tienes que escribir dos condiciones. Pero esto se soluciona con el operador ||, como en el ejemplo anterior.

2. Operador de fusión nula (??) — la novedad que se ha afianzado

A partir de ES2020, JavaScript incorporó el operador ?? (nu