statement - ¿Cómo verificas que un número es NaN en JavaScript?

parseint javascript (29)

Solo lo he estado probando en la consola de JavaScript de Firefox, pero ninguna de las siguientes afirmaciones devuelve verdadero:

parseFloat(''geoff'') == NaN; parseFloat(''geoff'') == Number.NaN;

¡Solución simple!

REALMENTE super simple! ¡Aquí! ¡Ten este método!

function isReallyNaN(a) { return a !== a; };

Utilice tan simple como:

if (!isReallyNaN(value)) { return doingStuff; }

Ver prueba de rendimiento aquí usando esta función vs respuesta seleccionada
También: Ver abajo 1er ejemplo para un par de implementaciones alternativas.

Ejemplo:

table { border-collapse: collapse; } th, td { border: 1px solid; padding: 2px 5px; } .true { color: red; } .false { color: green; }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script> <table></table>

Hay un par de rutas alternativas que toma para la implementación, si no desea utilizar un método con nombre alternativo, y desea asegurarse de que esté más disponible a nivel mundial. Advertencia Estas soluciones implican alterar objetos nativos, y puede que no sean su mejor solución. Siempre tenga cuidado y tenga en cuenta que otras bibliotecas que puede usar pueden depender de código nativo o alteraciones similares.

Implementación alternativa 1: Reemplace el método nativo de `isNaN` .

// Extremely simple. Just simply write the method. window.isNaN = function(a) { return a !==a; }

Implementación alternativa 2: anexar al objeto numérico
^{* Sugerido ya que también es un relleno múltiple para ECMA 5 a 6}

Number[''isNaN''] || (Number.isNaN = function(a) { return a !== a }); // Use as simple as Number.isNaN(NaN)

_{Prueba de} solución alternativa _{si está vacío}

Un método de ventana simple escribí esa prueba si el objeto está vacío . Es un poco diferente, ya que no da si el artículo es "exactamente" NaN , pero pensé que iba a lanzar esto, ya que también puede ser útil cuando se buscan artículos vacíos.

/** isEmpty(varried) * Simple method for testing if item is "empty" **/ ;(function() { function isEmpty(a) { return (!a || 0 >= a) || ("object" == typeof a && //{/}|/[(null(,)*)*/]/.test(JSON.stringify(a))); }; window.hasOwnProperty("empty")||(window.empty=isEmpty); })();

Ejemplo:

;(function() { function isEmpty(a) { return !a || void 0 === a || a !== a || 0 >= a || "object" == typeof a && //{/}|/[(null(,)*)*/]/.test(JSON.stringify(a)); }; window.hasOwnProperty("empty")||(window.empty=isEmpty); })(); var example = { ''NaN'': NaN, ''an empty Objet'': {}, ''a parse to NaN'': parseFloat(''$5.32''), ''a non-empty Objet'': { a: 1, b: 2 }, ''an empty Array'': new Array(), ''an empty Array w/ 9 len'': new Array(9), ''a semi-passed parse'': parseInt(''5a5''), ''a non-empty Array'': [ ''a'', ''b'', ''c'' ], ''Math to NaN'': Math.log(-1), ''an undefined object'': undefined } for (x in example) { var answer = empty(example[x]), strAnswer = answer.toString(); $("#t1").append( $("<tr />", { "class": strAnswer }).append( $("<th />", { html: x }), $("<td />", { html: strAnswer.toUpperCase() }) ) ) }; function isReallyNaN(a) { return a !== a; }; for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; } th, td { border: 1px solid; padding: 2px 5px; } .true { color: red; } .false { color: green; }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script> <table id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table> <table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

Verificación extremadamente profunda si está vacío

Este último va un poco más profundo, incluso comprobando si un Objeto está lleno de Objetos en blanco. Estoy seguro de que tiene margen de mejora y posibles picaduras, pero hasta ahora, parece que atrapa casi todo.

table { border-collapse: collapse; float: left; } th, td { border: 1px solid; padding: 2px 5px; } .true { color: red; } .false { color: green; }

¿Es (NaN> = 0) ? ...... " No sé ".

function IsNotNumber( i ){ if( i >= 0 ){ return false; } if( i <= 0 ){ return false; } return true; }

Las condiciones solo se ejecutan si son VERDADERAS .

No en FALSO .

No en " No sé ".

A partir de ES6 , Object.is(..) es una nueva utilidad que se puede usar para probar dos valores de igualdad absoluta:

var a = 3 / ''bar''; Object.is(a, NaN); // true

Acabo de encontrar esta técnica en el libro Effective JavaScript que es bastante simple:

Dado que NaN es el único valor de JavaScript que se trata como desigual a sí mismo, siempre puede probar si un valor es NaN al verificar que sea igual a sí mismo:

var a = NaN; a !== a; // true var b = "foo"; b !== b; // false var c = undefined; c !== c; // false var d = {}; d !== d; // false var e = { valueOf: "foo" }; e !== e; // false

No me di cuenta de esto hasta que @allsyed comentó, pero esto está en la especificación ECMA: tc39.github.io/ecma262/#sec-isnan-number

Así que veo varias respuestas a esto,

Pero yo solo uso:

function isNaN(x){ return x == x && typeof x == ''number''; }

De acuerdo con IEEE 754, todas las relaciones que involucran NaN se evalúan como falsas, excepto! =. Así, por ejemplo, (A> = B) = falso y (A <= B) = falso si A o B o ambos son NaN.

Debe usar la llamada a la función global isNaN(value) , porque:

Es compatible con varios navegadores
Ver isNaN para la documentación.

Ejemplos:

isNaN(''geoff''); // true isNaN(''3''); // false

Espero que esto ayude.

En cuanto a un valor de tipo Number va a probar si es un NaN o no, la función global isNaN hará el trabajo

isNaN(any-Number);

Para un enfoque genérico que funcione para todos los tipos en JS, podemos usar cualquiera de los siguientes:

Para usuarios de ECMAScript-5:

#1 if(x !== x) { console.info(''x is NaN.''); } else { console.info(''x is NOT a NaN.''); }

Para las personas que usan ECMAScript-6:

#2 Number.isNaN(x);

Y para propósitos de coherencia en ECMAScript 5 y 6, también podemos usar este polyfill para Number.isNan

#3 //Polyfill from MDN Number.isNaN = Number.isNaN || function(value) { return typeof value === "number" && isNaN(value); } // Or Number.isNaN = Number.isNaN || function(value) { return value !== value; }

por favor revise esta respuesta para más detalles.

Encontré otra manera, sólo por diversión.

function IsActuallyNaN(obj) { return [obj].includes(NaN); }

He creado esta pequeña función que funciona como un encanto. En lugar de verificar el NaN, que parece ser contrario a la intuición, verifica un número. Estoy bastante seguro de que no soy el primero en hacerlo de esta manera, pero pensé que lo compartiría.

function isNum(val){ var absVal = Math.abs(val); var retval = false; if((absVal-absVal) == 0){ retval = true } return retval; }

La forma exacta de comprobar es:

//takes care of boolen, undefined and empty isNaN(x) || typeof(x) ===''boolean'' || typeof(x) !==''undefined'' || x!=='''' ? ''is really a nan'' : ''is a number''

La respuesta de marksyzm funciona bien, pero no devuelve falso para Infinity ya que Infinity no es técnicamente un número.

Se me ocurrió una función isNumber que verificará si es un número.

function isNumber(i) { return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY].indexOf(i) === -1; } console.log(isNumber(Infinity)); console.log(isNumber("asdf")); console.log(isNumber(1.4)); console.log(isNumber(NaN)); console.log(isNumber(Number.MAX_VALUE)); console.log(isNumber("1.68"));

ACTUALIZACIÓN: noté que este código falla para algunos parámetros, así que lo mejoré.

NaN en JavaScript significa "No es un número", aunque su tipo es en realidad número.

typeof(NaN) // "number"

Para verificar si una variable es de valor NaN, no podemos simplemente usar la función isNaN (), ya que isNaN () tiene el siguiente problema, vea a continuación:

var myVar = "A"; isNaN(myVar) // true, although "A" is not really of value NaN

Lo que realmente sucede aquí es que myVar se obliga implícitamente a un número:

var myVar = "A"; isNaN(Number(myVar)) // true. Number(myVar) is NaN here in fact

Realmente tiene sentido, porque "A" en realidad no es un número. Pero lo que realmente queremos comprobar es si myVar es exactamente de valor NaN.

Así que isNaN () no puede ayudar. Entonces, ¿qué debemos hacer en su lugar?

A la luz de que NaN es el único valor de JavaScript que se trata de manera desigual a sí mismo, por lo que podemos verificar su igualdad utilizando el mismo ==

var myVar; // undefined myVar !== myVar // false var myVar = "A"; myVar !== myVar // false var myVar = NaN myVar !== myVar // true

Entonces, para concluir , si es cierto que una variable! == en sí misma, entonces esta variable es exactamente de valor NaN:

function isOfValueNaN(v) { return v !== v; } var myVar = "A"; isNaN(myVar); // true isOfValueNaN(myVar); // false

NaN es un valor especial que no puede ser probado de esa manera. Una cosa interesante que solo quería compartir es esto

var nanValue = NaN; if(nanValue !== nanValue) // Returns true! alert(''nanValue is NaN'');

Esto devuelve verdadero solo para los valores de NaN y es una forma segura de prueba. Definitivamente debería estar envuelto en una función o al menos comentado, porque obviamente no tiene mucho sentido probar si la misma variable no es igual a otra, jeje.

Otra solución se menciona en la página parseFloat de MDN.

Proporciona una función de filtro para hacer un análisis estricto.

var filterFloat = function (value) { if(/^(/-|/+)?([0-9]+(/.[0-9]+)?|Infinity)$/ .test(value)) return Number(value); return NaN; } console.log(filterFloat(''421'')); // 421 console.log(filterFloat(''-421'')); // -421 console.log(filterFloat(''+421'')); // 421 console.log(filterFloat(''Infinity'')); // Infinity console.log(filterFloat(''1.61803398875'')); // 1.61803398875 console.log(filterFloat(''421e+0'')); // NaN console.log(filterFloat(''421hop'')); // NaN console.log(filterFloat(''hop1.61803398875'')); // NaN

Y luego puedes usar isNaN para verificar si es NaN

Para solucionar el problema donde se analiza ''1.2geoff'' , simplemente use el analizador Number() lugar.

Así que en lugar de esto:

parseFloat(''1.2geoff''); // => 1.2 isNaN(parseFloat(''1.2geoff'')); // => false isNaN(parseFloat(''.2geoff'')); // => false isNaN(parseFloat(''geoff'')); // => true

Hacer esto:

Number(''1.2geoff''); // => NaN isNaN(Number(''1.2geoff'')); // => true isNaN(Number(''.2geoff'')); // => true isNaN(Number(''geoff'')); // => true

EDITAR: Acabo de notar otro problema de esto, sin embargo ... los valores falsos (y verdaderos como un booleano real) pasaron a Number() devuelto como 0 En cuyo caso ... parseFloat funciona cada vez en su lugar. Así que vuelve a eso:

function definitelyNaN (val) { return isNaN(val && val !== true ? Number(val) : parseFloat(val)); }

Y eso cubre aparentemente todo. Lo comparé en un 90% más lento que el _.isNaN de _.isNaN pero ese no cubre todos los NaN:

http://jsperf.com/own-isnan-vs-underscore-lodash-isnan

Para que quede claro, el mío se encarga de la interpretación literal humana de algo que no es "un número" y la de lodash se encarga de la interpretación literal de la computadora de verificar si algo es "NaN".

Parece que isNaN () no es compatible con Node.js fuera de la caja.
Trabajé alrededor de

var value = 1; if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);

Prueba este código:

isNaN(parseFloat("geoff"))

Para verificar si algún valor es NaN, en lugar de solo números, consulte aquí: ¿Cómo se prueba NaN en Javascript?

Quizás también esto:

function isNaNCustom(value){ return value.toString() === ''NaN'' && typeof value !== ''string'' && typeof value === ''number'' }

Si bien la respuesta de @chiborg ES correcta, hay algo más que debe tenerse en cuenta:

parseFloat(''1.2geoff''); // => 1.2 isNaN(parseFloat(''1.2geoff'')); // => false isNaN(parseFloat(''.2geoff'')); // => false isNaN(parseFloat(''geoff'')); // => true

El punto es que, si está utilizando este método para la validación de la entrada, el resultado será más bien liberal.

Entonces, sí, puede usar parseFloat(string) (o en el caso de los números completos parseInt(string, radix) ''y luego envolver eso con isNaN() , pero tenga en cuenta el gotcha con números entrelazados con caracteres no numéricos adicionales .

Simplemente convierta el resultado a String y compárelo con ''NaN''.

var val = Number("test"); if(String(val) === ''NaN'') { console.log("true"); }

Solo quiero compartir otra alternativa, no es necesariamente mejor que otras aquí, pero creo que vale la pena mirar:

function customIsNaN(x) { return (typeof x == ''number'' && x != 0 && !x); }

La lógica detrás de esto es que todos los números excepto 0 y NaN se NaN en true .

He hecho una prueba rápida, y funciona tan bien como Number.isNaN y como comprobado contra sí mismo por falso. Los tres funcionan mejor que isNan

Los resultados

customIsNaN(NaN); // true customIsNaN(0/0); // true customIsNaN(+new Date(''?'')); // true customIsNaN(0); // false customIsNaN(false); // false customIsNaN(null); // false customIsNaN(undefined); // false customIsNaN({}); // false customIsNaN(''''); // false

Puede ser útil si desea evitar la función isNaN rota.

Usa este código:

isNaN(''geoff'');

Consulte la documentación de isNaN() en MDN .

alert ( isNaN(''abcd'')); // alerts true alert ( isNaN(''2.0'')); // alerts false alert ( isNaN(2.0)); // alerts false

Yo uso la función isNaN de guión isNaN porque en JavaScript:

isNaN(undefined) -> true

Por lo menos, ten en cuenta que tienes gotcha.

Escribí esta respuesta a otra pregunta en donde otra verifica cuando NaN == null pero luego se marcó como duplicado, por lo que no quiero desperdiciar mi trabajo.

Mire la Red de Desarrolladores de Mozilla sobre NaN .

Respuesta corta

Solo usa la distance || 0 distance || 0 cuando quiere asegurarse de que el valor es un número correcto o isNaN() para verificarlo.

Respuesta larga

El NaN (Not-a-Number) es un objeto global raro en javascript que se devuelve con frecuencia cuando falla una operación matemática.

Quería comprobar si NaN == null que resulta false . Hovewer incluso NaN == NaN resultados con false .

Una forma sencilla de averiguar si la variable es NaN es una función global isNaN() .

Otra es x !== x que solo es verdadera cuando x es NaN. (Gracias por recordar a @ raphael-schweikert)

Pero ¿por qué funcionó la respuesta corta?

Vamos a averiguar.

Cuando llama a NaN == false el resultado es false , igual que NaN == true .

En algún lugar de las especificaciones, JavaScript tiene un registro con valores siempre falsos, que incluye:

NaN - No es un número
"" - cadena vacía
false - un falso booleano
null - objeto nulo
undefined - variables indefinidas
0 - 0 numérico, incluyendo +0 y -0

Si su entorno es compatible con ECMAScript 2015 , es posible que desee utilizar Number.isNaN para asegurarse de que el valor sea realmente NaN .

El problema con isNaN es que, si usa eso con datos no numéricos, se aplican algunas reglas confusas (según MDN). Por ejemplo,

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

Por lo tanto, en los entornos compatibles con ECMA Script 2015, es posible que desee utilizar

Number.isNaN(parseFloat(''geoff''))

function isNotANumber(n) { if (typeof n !== ''number'') { return true; } return n !== n; }

NaN === NaN; // false Number.NaN === NaN; // false isNaN(NaN); // true isNaN(Number.NaN); // true

El operador de igualdad (== y ===) no se puede usar para probar un valor contra NaN.

Mire la documentación de Mozilla La propiedad global NaN es un valor que representa a Not-A-Numbe

La mejor manera es usar ''isNaN ()'', que es una función incorporada para verificar NaN. Todos los navegadores soportan el camino ..

alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);

Esto no es elegante. pero después de probar isNAN () llegué a esta solución, que es otra alternativa. En este ejemplo también permití ''.'' porque estoy enmascarando para flotar. También puede revertir esto para asegurarse de que no se usen números.

("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)

Esta es una evaluación de un solo carácter, pero también puede recorrer una cadena para verificar cualquier número.

statement - ¿Cómo verificas que un número es NaN en JavaScript?

parseint javascript (29)

¡Solución simple!

Ejemplo:

Implementación alternativa 1: Reemplace el método nativo de isNaN .

Implementación alternativa 2: anexar al objeto numérico * Sugerido ya que también es un relleno múltiple para ECMA 5 a 6

Ejemplo:

Verificación extremadamente profunda si está vacío

Respuesta corta

Respuesta larga

Pero ¿por qué funcionó la respuesta corta?

Implementación alternativa 1: Reemplace el método nativo de `isNaN` .

Implementación alternativa 2: anexar al objeto numérico
^{* Sugerido ya que también es un relleno múltiple para ECMA 5 a 6}