Función isNaN()‎ en JavaScript

La función isNaN()‎ determina si el valor que se le pasa es NaN o no. Tenga en cuenta que la conversión de valores dentro de una función isNaN()‎ tiene reglas interesantes. Entonces puede usar la función Number.isNaN()‎ definida en ECMAScript en lugar de esta función.

Características generales

A diferencia del resto de los valores en JavaScript, no se puede confiar en los operadores de igualdad ( ==y ===) para determinar si un valor es NaN o no, porque el valor de las dos expresiones es NaN == NaN, por lo que esta función es necesaria NaN === NaNfalse

Origen NaN

Los valores se generan NaN cuando las operaciones matemáticas producen valores indefinidos o irrepresentables, y este valor también resulta de intentar convertir por la fuerza valores no numéricos en valores escalares que no pueden tener una representación numérica principal. Por ejemplo, dividir cero por cero producirá NaN, pero dividir el resto de los números por cero no NaN.

Caso especial de una función isNaN

Desde versiones anteriores de la especificación de la función, isNaN su comportamiento para argumentos no numéricos era confuso, cuando el argumento pasado a la función no es isNaN de tipo Número, el valor se convertirá forzosamente a Number. Luego se probará el valor resultante para ver si es NaN, por lo que cuando los valores no numéricos se convierten a la fuerza a un tipo Number.

Pero tenemos un escalar no NaN (específicamente la cadena vacía y los booleanos primitivos true y false, que darán valores escalares 0 o 1 cuando se conviertan a la fuerza en un número) y en la función regresará true aunque esperemos el valor false(por ejemplo, la cadena vacía definitivamente no es un número Not-A-Number).

Este comportamiento confuso surge porque el término Not-A-Number tiene un significado especial para los números representados como valores de punto flotante IEEE-754, y la función debe interpretarse isNaN como una respuesta a la pregunta: «¿Es este valor, cuando se convierte a la fuerza en ¿Un valor numérico, el valor de Not-A-Number según lo definido por IEEE-754?

Función agregada estándar ECMAScript 2015 Number.isNaN(), el uso de la función Number.isNaN(x) es una forma práctica de ver si el valor xes NaNo no, pero la definición NaN seguirá teniendo el significado digital no significará «no es un número» (Not-A-Number). Alternativamente, se puede usar la expresión (‎‎x != x)que es la forma más práctica de averiguar si un valor x es NaNo no, y el resultado de la expresión anterior no estará sujeto a casos que hagan que la función sea isNaN impráctica.

Se puede crear una solución convolucional para la función isNaN, aprovechando la propiedad de desigualdad de valores de NaN sí misma:

var isNaN = function(value) {
  var n = Number(value);
  return n !== n;
};

Estructura de la función isNaN

isNaN(value)

value

El valor a probar es si NaN.

Valor a devolver

El valor true si el valor dado es NaN y el valor en false caso contrario.

Ejemplos y aplicaciones en código

A continuación, se muestran algunos ejemplos de valores que devolverán Not-A-Number:

isNaN(NaN);       // true
isNaN(undefined); // true
isNaN({});        // true

Estos son valores que no son de NaN:

isNaN(true);      // false
isNaN(null);      // false
isNaN(37);        // false

Ejemplos de cadenas: "37"tenga en cuenta que la cadena del primer ejemplo se convierte al número 37 que no lo es NaN, y lo mismo ocurre con la cadena 37,37 que se convertirá en el número 37,37. La cadena "123ABC"es NaN, porque el resultado de Number("123ABC")‎es NaN(aunque el resultado de parseInt("123ABC")‎es 123). Los dos últimos ejemplos de cadenas que están vacías o tienen un solo espacio, que se convertirán en un número 0:

isNaN('37');      // false
isNaN('37.37');   // false
isNaN('123ABC');  // true
isNaN('');        // false
isNaN(' ');       // false

Un ejemplo de un objeto Date, que devolverá un número cuando se use con el constructor Number, y su cadena (que obtendremos a través de la función toString) sería NaN:

isNaN(new Date());                // false
isNaN(new Date().toString());     // true

Este es un resultado falso positivo, razón por la cual la función isNaN es completamente impráctica, porque la cadena "blabla"se convertirá en un número, y la interpretación de este número fallará y se devolverá el valor NaN:

isNaN('blabla');   // true

Caso especial de la función isNaN

Hay una forma en la que podemos hacer uso de la función isNaN()‎: si la función devolvió un isNaN(x)‎valor false, podemos usar x deportes como una expresión que no causa revalor NaN. Incluso si se devuelve true un valor conjunto x para hacer todas las expresiones matemáticas que vuelven a ingresar el valor NaN.

Esto se debe a que en JavaScript si la función devolvió isNaN(x)‎valor , true significa que la expresión x - 0( por ejemplo) devolverá el valor NaN(pero la expresión x - 0 == NaN devolverá valor false siempre en JavaScript porque NaN no vale lo mismo, por lo que no puede realizar esta prueba).

De hecho funciona, isNaN(x)‎, isNaN(x - 0)‎, isNaN(Number(x))‎, Number.isNaN(x - 0)‎ y el Number.isNaN(Number(x))‎mismo valor. La forma más corta de expresarlo es usar el isNaN(x)‎. Puede usar el comportamiento anterior para probar si el argumento pasado a la función es utilizable en expresiones matemáticas (es decir, puede tratarse como un número), y si no es así, podemos proporcionar un valor predeterminado o seguir algún otro procedimiento.

De esta forma, la función aprovechará la flexibilidad que proporciona JavaScript a la hora de convertir valores en función del contexto en el que se utilicen. Definiremos la función increment, que devuelve el resultado de sumar el valor 1 al argumento que se le pasa:

function increment(x) {
  if (isNaN(x)) x = 0;
  return x + 1;
}
// La siguiente función es equivalente a la 
function increment(x) {
  if (Number.isNaN(Number(x))) x = 0;
  return x + 1;
}

En los siguientes casos, el valor del parámetro x(es decir NaN, el argumento pasado a la función) no será , pero el valor del argumento no tiene que ser un valor numérico, pero se puede usar en expresiones matemáticas:

increment('');            // 1: "" => 0
increment(new String());  // 1: String object => 0
increment([]);            // 1: [] => 0
increment(new Array());   // 1: Array object => 0
increment('0');           // 1: "0" => 0
increment('1');           // 2: "1" => 1
increment('0.1');         // 1.1: "0.1" => 0.1
increment('Infinity');    // Infinity: "Infinity" => Infinity
increment(null);          // 1: null => 0
increment(false);         // 1: false => 0
increment(true);          // 2: true => 1
increment(new Date());     // Devuelve la fecha y hora actual en milisegundos + 1

En cuanto a los siguientes casos, el valor del parámetro x(es decir NaN, el argumento pasado a la función) no lo es , pero la mediana es un valor numérico:

increment(-1);            // 0
increment(-0.1);          // 0.9
increment(0);             // 1
increment(1);             // 2
increment(2);             // 3
// ... y así sucesivamente ... 
increment(Infinity);      // Infinity

En los siguientes casos, el resultado de la función isNaN(x)‎es true siempre y el valor del argumento pasado a la función no es un escalar (Not-A-Number), por lo que la función pondrá 0 en su lugar (como lo definimos adentro) y el el valor de retorno final es 1:

increment(String);              // 1
increment(Array);               // 1
increment('blabla');            // 1
increment('-blabla');           // 1
increment(0 / 0);               // 1
increment('0 / 0');             // 1
increment(Infinity / Infinity); // 1
increment(NaN);                 // 1
increment(undefined);           // 1
increment();                    // 1

Soporte de navegadores

Característica	Chrome	Firefox	IE	Ópera	Safari
Soporte básico	sí	sí	sí	sí	sí