¿Qué es NaN (Not A Number)?

El acrónimo NaN es un valor especial de Javascript que significa literalmente Not A Number (No es un número). Sin embargo, no hay que dejarse llevar por su significado literal, ya que nos podría dar lugar a malentendidos. El valor NaN, a pesar de su significado, se usa para representar valores numéricos (y ahora es donde viene el matiz) que son indeterminados o imposibles de representar como número.

Dentro de esa categoría hay varios:

• Indeterminación matemática: Por ejemplo, 0 / 0.
• Valores imposibles: Por ejemplo, 4 - 'a', ya que es imposible restar una letra a un número.
• Operaciones con NaN: Por ejemplo, NaN + 4, ya que el primer operando es NaN.

Uno de los más frecuentes es el segundo, ya que Javascript es un lenguaje flexible que no requiere tipos. Eso, unido a que la mayoría de datos que extraemos de una página web se obtienen como , da como resultado operaciones de ese tipo, o concatenaciones inesperadas.

Por aquí puedes encontrar las propiedades y métodos relacionados con NaN que existen:

Observa que aunque NaN es un valor global, también existe un Number.NaN como propiedad de Number, para tenerlo modularizado y encapsulado como propiedad estática en el objeto Number.

Todos los NaN son diferentes

Como hemos dicho, el valor NaN se utiliza para intentar representar un valor que no se puede representar. Sin embargo, no podemos compararlo literalmente con NaN, sino que tenemos que usar la función Number.isNaN():

NaN == NaN;         // false (El valor no es el mismo)
NaN === NaN;        // false (Ni el valor, ni el tipo de dato es el mismo)

Number.isNaN(NaN);  // true (Forma correcta de comprobarlo)
Number.isNaN(5);    // false (5 es un número, no es un NaN)
Number.isNaN("A");  // false ("A" es un string, no es un NaN)

Recuerda que aunque desafortunamente, NaN significa Not A Number (no es un número), pero NaN sí que es un valor numérico, lo que ocurre es que ese valor no es representable de forma numérica:

const number = NaN;

typeof number;              // "number"
number.constructor.name;    // "Number"

Conversiones de valores NaN

Si intentamos convertir un valor NaN a otro tipo de dato primitivo utilizando un typecast (forzar conversión explícita), nos encontraremos lo siguiente:

Boolean(NaN);   // false (convertimos a booleano)
String(NaN);    // "NaN" (convertimos a texto)
Number(NaN);    // NaN (Ya estaba en contexto numérico)