null y undefined

En JavaScript hay dos formas de decir “no hay valor”: undefined y null. A primera vista parecen lo mismo, pero representan ideas distintas. Entender la diferencia te evitará confusiones cuando empieces a trabajar con datos.

Objetivos

Al terminar esta lección deberías ser capaz de:

• Explicar con un ejemplo sencillo qué significa undefined y qué significa null.
• Reconocer cuándo JavaScript pone undefined por su cuenta.
• Decidir cuándo conviene usar null.
• Comparar ambos valores correctamente.
• Saber qué comprueba typeof en cada caso.

La idea central

Imagina una estantería con cajas etiquetadas:

• undefined: la caja existe, pero todavía nadie ha metido nada. JavaScript la creó y la dejó pendiente. Es un “aún no”.
• null: la caja existe y tú has decidido dejarla vacía. Es un “aquí no hay nada, y lo hago a propósito”.

Dicho de otra forma: undefined suele ponerlo el lenguaje; null lo pone quien programa.

la-diferencia.js

console.log(undefined); // undefined → todavía no hay valor
console.log(null); // null → el vacío está puesto a propósito

¿Cuándo aparece undefined?

JavaScript lo genera cuando falta un valor y nadie lo dio. Lo encontrarás en situaciones como estas:

• Cuando declares algo sin darle contenido todavía (lo practicarás en Guardando valores).
• Cuando pidas un dato que todavía no existe.
• Cuando una operación no produce ningún resultado que entregar.

Todas comparten la misma idea: faltó un valor. Por ahora quédate con la frase: undefined = “aún no”.

Consejo

Si ves undefined en pantalla, pregúntate: “¿qué valor esperaba aquí y quién debía ponerlo?”. Casi siempre la respuesta es que falta una asignación.

¿Cuándo conviene usar null?

null es una decisión explícita. Se usa para indicar: “sé que este dato existe, pero ahora mismo está vacío”.

Casos típicos:

• Un campo que el usuario todavía no rellenó, pero que sabemos que existe.
• El resultado de una búsqueda que no encontró nada.
• Un dato que antes tenía contenido y que quieres dejar vacío.

La diferencia con undefined es la intención: con null estás diciendo “esto está vacío porque yo lo decidí”.

vacio-a-proposito.js

console.log(null === null); // true → es el mismo valor "vacío"
console.log(null === undefined); // false → no son lo mismo

Comparación de ambos

Aspecto	undefined	null
Quién lo pone	Normalmente JavaScript	Quien programa
Significado	“Aún no hay valor”	“Hay un vacío a propósito”
typeof	"undefined"	"object" ⚠️
Es un tipo primitivo	Sí	Sí
Valor de algo sin contenido	Sí	No
Comparación estricta entre ellos	undefined === null → false	null === undefined → false

comparaciones.js

console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" → error histórico del lenguaje

console.log(null === undefined); // false → tipos distintos
console.log(null == undefined); // true  → excepción de la igualdad débil

No uses typeof para detectar null

Como typeof null es "object", la comprobación fiable es siempre directa: compara con === null. Y para detectar undefined, compara con === undefined.

Nota

null y undefined son los dos últimos tipos primitivos de esta primera clase. En la siguiente lección aprenderás a darles un nombre para poder reutilizarlos.

Errores frecuentes

• Asignar undefined a mano. No suele hacer falta: usa null para expresar un vacío intencional.
• Creer que null es de tipo "object" porque typeof lo dice. No lo es; es un primitivo.
• Usar == para compararlos y confiar en que son iguales. Con === son distintos.
• Creer que ambos significan lo mismo. undefined es “aún no”; null es “vacío decidido”.
• Fiarse de typeof con null. Devuelve "object"; mejor comparar directamente.

Ejercicio

1. Ejecuta console.log(undefined) y console.log(null) y observa cómo los muestra la consola.
2. Ejecuta typeof undefined y typeof null. Anota por qué el segundo resultado sorprende.
3. Predice y comprueba: null === undefined, null == undefined, null === null.
4. Escribe con tus palabras una frase que distinga “aún no hay valor” de “hay un vacío a propósito”.

Resumen

• undefined = “todavía no hay valor”; lo pone JavaScript cuando falta una asignación.
• null = “vacío a propósito”; lo escribes tú para indicar que el dato existe pero está sin contenido.
• typeof undefined es "undefined"; typeof null es "object" por un error histórico.
• Con === son distintos; con == JavaScript los considera iguales (mejor evitarlo).
• Para comprobarlos de forma fiable, compara directamente con === null o === undefined.

Siguiente paso: Guardando valores (Variables).