Por qué typeof null es object

Escribe esto en la consola

typeof null; // "object"

null no es un objeto. Es un valor primitivo, igual que un número o un texto. Y aun así typeof dice que es un objeto.

No es una decisión de diseño. Es un bug de 1995 que sigue ahí porque arreglarlo sería peor.

De dónde viene

En la primera implementación de JavaScript, cada valor se guardaba en memoria como una etiqueta de tipo de tres bits, seguida del dato.

La etiqueta 000 significaba "esto es un objeto".

Y null se representaba con el puntero nulo de la máquina, que es sencillamente todo ceros. Sus tres primeros bits eran, por tanto, 000.

Cuando typeof iba a mirar la etiqueta de null, encontraba la de un objeto. Y respondía lo que veía.

Por qué no se ha arreglado

Se intentó. Durante el diseño de una versión posterior del lenguaje se propuso que typeof null devolviera "null".

La propuesta se rechazó. Hay demasiado código ahí fuera escrito contando con el comportamiento actual, y cambiarlo rompería páginas que hoy funcionan.

Así que se quedó como está. Es más fácil documentar la rareza que arreglarla.

Cómo comprobar si algo es null

Con typeof no. Compara directamente

valor === null;

Usa siempre ===. Con == no distingues null de undefined

null == undefined;   // true
null === undefined;  // false

typeof undefined;    // "undefined"
typeof null;         // "object"

Comprobando un objeto

Cuando quieres saber si algo es un objeto de verdad

// mal: null pasa el filtro
if (typeof valor === "object") { ... }

// bien
const esObjeto = (v) => typeof v === "object" && v !== null;

esObjeto({});    // true
esObjeto(null);  // false

Ese && v !== null que ves en tantas librerías está justo por esto.

typeof tiene más sorpresas

typeof [];              // "object"    no hay "array"
typeof new Date();      // "object"
typeof NaN;             // "number"    un no-número que es número
typeof function () {};  // "function"  esta sí tiene la suya

Para los arrays tienes Array.isArray(). Para el resto, hay un truco.

El truco que lo distingue todo

const tipo = (v) => Object.prototype.toString.call(v).slice(8, -1);

tipo(null);         // "Null"
tipo(undefined);    // "Undefined"
tipo([]);           // "Array"
tipo(new Date());   // "Date"
tipo(42);           // "Number"

Ese método devuelve cadenas del estilo [object Null], y el slice(8, -1) se queda con lo de dentro.

Para el día a día te sobra con === null y Array.isArray(). Pero cuando necesites saber de verdad qué tienes delante, typeof no es la herramienta.

Cosas de Javascript ;)