undefined en JavaScript: 5 formas de verificar (y cuál elegir)

«Uncaught ReferenceError» — ¿tu primer enemigo? Aprendiendo a verificar correctamente undefined en JavaScript

Cualquiera que haya escrito JavaScript aunque sea un par de líneas se ha encontrado con el misterioso undefined. No es simplemente un «espacio vacío» — es un tipo de dato completo con su propio valor. Pero, ¿cómo atraparlo correctamente? Si has buscado en Google «How can I check for undefined in JavaScript», no estás solo: esta pregunta en Stack Overflow ha acumulado cientos de miles de visitas. El problema es que en JS hay varias formas de verificar, y cada una tiene sus trampas.

En este artículo, analizaremos 5 enfoques, de lo simple a lo complejo, compararemos su rendimiento y fiabilidad, y descubriremos qué método vale la pena usar en 2025. ¡Allá vamos!

¿Qué es realmente undefined?

Antes de verificar, pongámonos de acuerdo en los términos. undefined es un valor primitivo que se asigna a una variable si se declara pero no se inicializa:

let a;\nconsole.log(a); // undefined\n

Importante: undefined ≠ null ≠ not defined. null es una «nada» intencionada, mientras que not defined (ReferenceError) ocurre cuando la variable ni siquiera está declarada. Estos matices son críticos para elegir la verificación correcta.

Método n.º 1: Operador typeof — ¿el estándar de oro?

La forma más popular y segura es usar typeof:

if (typeof x === 'undefined') {\n  console.log('x no está definido');\n}\n

¿Por qué funciona incluso con variables no declaradas? typeof nunca lanza un ReferenceError. Si la variable no existe, simplemente devuelve la cadena "undefined".

Ventajas:

\n
• Seguro para variables no declaradas
\n
• Código legible y comprensible
\n
• Funciona en todos los navegadores y entornos (Node.js, Deno)
\n

Desventajas:

\n
• Un poco extenso para uso frecuente
\n
• Puede confundir a los principiantes (comparación de cadenas)
\n

Veredicto: La mejor opción para verificaciones globales y casos donde la variable podría no estar declarada.

Método n.º 2: Comparación estricta con undefined (===)

La segunda forma más popular es comparar el valor directamente:

if (x === undefined) {\n  console.log('x es igual a undefined');\n}\n

Aquí hay un detalle: la variable debe estar declarada. Si x no existe, obtendrás un ReferenceError. Por lo tanto, este código solo es seguro para:

\n
• Propiedades de objetos (obj.prop === undefined)
\n
• Parámetros de funciones
\n
• Variables declaradas con let, const o var
\n

Trampa: el undefined global

En navegadores antiguos (IE 8 e inferiores), undefined podía sobrescribirse:

undefined = 'ahora soy una cadena'; // ¡Pesadilla!\n

Ahora esto es imposible (en modo estricto), pero si das soporte a código heredado, es mejor usar typeof.

Veredicto: Un excelente método para variables locales y propiedades de objetos. Rápido y conciso.

Método n.º 3: Operador void

Una forma poco conocida pero elegante es void 0:

if (x === void 0) {\n  console.log('x undefined');\n}\n

El operador void evalúa una expresión y devuelve undefined. void 0 es la forma más corta de obtener un undefined puro, independiente de la variable global.

¿Cuándo es útil?

\n
• En código minificado (ahorra bytes)
\n
• En librerías donde es importante protegerse contra la redefinición de undefined
\n
• En programación funcional (por ejemplo, en cadenas de promesas)
\n

Desventaja: Se ve extraño