
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 x
es NaN
o 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 NaN
o 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í |
- Expresión const en JavaScript
- Expresión let en JavaScript
- Expresión var en JavaScript
- Expresión try…catch en JavaScript
- Expresión throw en JavaScript
- Continue en JavaScript
- Switch en JavaScript
- Expresiones if…else en JavaScript
- Declaración vacía o empty en JavaScript
- Break en JavaScript
- Sentencia block en JavaScript
- Arguments en JavaScript
- Promise en JavaScript
- Number en JavaScript
- Características JSON en JavaScript
- Array en JavaScript
- RegExp en JavaScript
- String en JavaScript
- Date en JavaScript
- Math en JavaScript
- URIError en JavaScript
- TypeError en JavaScript
- SyntaxError en JavaScript
- ReferenceError en JavaScript
- RangeError en JavaScript
- EvalError en JavaScript
- Características Boolean en JavaScript
- Error en JavaScript
- Función Symbol en JavaScript
- Constructor Function en JavaScript
- Constructor Object en JavaScript
- Función unescape() en JavaScript
- Función eval() en JavaScript
- Valor null en JavaScript
- Características Undefined en JavaScript
- Características NaN en JavaScript
- Características Infinity en JavaScript
- Función parseFloat() en JavaScript
- Función isNaN() en JavaScript
- Función isFinite() en JavaScript
- Función escape() en JavaScript
- Función encodeURIComponent() en JavaScript