Como você verifica se um número é NaN em JavaScript?

Eu só tenho tentado isso no console JavaScript do Firefox, mas nenhuma das seguintes declarações retornam verdadeiro:

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

Experimente este código:

 isNaN(parseFloat("geoff")) 

Para verificar se algum valor é NaN, em vez de apenas números, veja aqui: Como você testa o NaN em JavaScript?

Acabei de encontrar essa técnica no livro JavaScript efetivo que é bem simples:

Como NaN é o único valor de JavaScript tratado como diferente de si mesmo, você pode sempre testar se um valor é NaN, verificando se há igualdade para ele mesmo:

 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 

Não percebi isso até que @allsyed comentou, mas isso está na especificação do ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Use este código:

 isNaN('geoff'); 

Veja documentos isNaN() no MDN .

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

Na medida em que um valor do tipo Number deve ser testado, seja NaN ou não, a function global isNaN fará o trabalho

 isNaN(any-Number); 

Para uma abordagem genérica que funciona para todos os tipos no JS, podemos usar qualquer um dos seguintes:

Para usuários do ECMAScript-5:

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

Para pessoas que usam o ECMAScript-6:

 #2 Number.isNaN(x); 

E para fins de consistência em todos os ECMAScript 5 e 6, também 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, verifique esta resposta para mais detalhes.

NaN é um valor especial que não pode ser testado assim. Uma coisa interessante que eu só queria compartilhar é isso

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

Isso retorna true apenas para valores NaN e é uma maneira segura de testar. Definitivamente deveria ser embrulhado em uma function ou pelo menos comentou, porque Não faz muito sentido obviamente testar se a mesma variável não é igual a um ao outro, hehe.

Você deve usar a chamada de function global isNaN(value) , porque:

  • É suportado cross-browser
  • Veja isNaN para documentação

Exemplos:

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

Eu espero que isso te ajude.

A partir do ES6 , Object.is(..) é um novo utilitário que pode ser usado para testar dois valores para igualdade absoluta:

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

Para corrigir o problema em que '1.2geoff' é analisado, basta usar o analisador Number() .

Então, ao invés disso:

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

Faça isso:

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

EDIT: Acabei de notar outro problema a partir deste porém … valores falsos (e verdadeiro como um booleano real) passou para Number() retornar como 0 ! Nesse caso … parseFloat funciona sempre em vez disso. Então, volte a isso:

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

E isso cobre tudo aparentemente. Eu o _.isNaN 90% mais devagar que o _.isNaN da _.isNaN mas esse não cobre todos os NaN’s:

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

Só para ficar claro, o meu cuida da interpretação literal humana de algo que é “Não um Número” e a lodash cuida da interpretação literal do computador para verificar se algo está “NaN”.

Enquanto a resposta do @chiborg ESTÁ correta, há mais que deve ser notado:

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

Aponte sendo, se você estiver usando este método para validação de input, o resultado será bastante liberal.

Então, sim, você pode usar parseFloat(string) (ou, no caso de números parseInt(string, radix) , parseInt(string, radix) e, em seguida, envolvê-lo com isNaN() , mas esteja ciente da pegadinha com números entrelaçados com caracteres não numéricos adicionais .

Solução Simples!

REALMENTE super simples! Aqui! Tem esse método!

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

Use tão simples como:

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

Veja o teste de desempenho aqui usando esta function vs resposta selecionada

Além disso: Veja abaixo o primeiro exemplo de algumas implementações alternativas.


Exemplo:

 function isReallyNaN(a) { return a !== a; }; 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': [], '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 = isReallyNaN(example[x]), strAnswer = answer.toString(); $("table").append($("", { "class": strAnswer }).append($("", { html: x }), $("", { html: strAnswer }))) }; 
 table { border-collapse: collapse; } th, td { border: 1px solid; padding: 2px 5px; } .true { color: red; } .false { color: green; } 
  

Se o seu ambiente suportar ECMAScript 2015 , talvez você queira usar Number.isNaN para certificar-se de que o valor seja realmente NaN .

O problema com o isNaN é que, se você usar isso com dados não numéricos, poucas regras confusas (de acordo com o MDN) serão aplicadas. Por exemplo,

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

Assim, nos ambientes suportados do ECMA Script 2015, talvez você queira usar

 Number.isNaN(parseFloat('geoff')) 

Eu uso a function isNaN do sublinhado porque em JavaScript:

 isNaN(undefined) -> true 

No mínimo, esteja ciente dessa pegadinha.

NaN em JavaScript significa “Not A Number”, embora seu tipo seja na verdade number.

 typeof(NaN) // "number" 

Para verificar se uma variável é do valor NaN, não podemos simplesmente usar a function isNaN (), porque isNaN () tem o seguinte problema, veja abaixo:

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

O que realmente acontece aqui é que myVar é implicitamente coagido a um número:

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

Na verdade, faz sentido, porque “A” não é realmente um número. Mas o que realmente queremos verificar é se myVar é exatamente de valor NaN.

Então isNaN () não pode ajudar. Então, o que devemos fazer em vez disso?

Sob a luz de que NaN é o único valor de JavaScript que é tratado de forma desigual para si mesmo, então podemos verificar sua igualdade para si mesmo usando! ==

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

Então, para concluir , se é verdade que uma variável! == em si, então essa variável é exatamente de valor NaN:

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

Parece que isNaN () não é suportado no Node.js fora da checkbox.
Trabalhei com

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

Eu só quero compartilhar outra alternativa, não é necessariamente melhor do que outros aqui, mas acho que vale a pena olhar para:

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

A lógica por trás disso é que todos os números, exceto 0 e NaN são convertidos em true .

Eu fiz um teste rápido, e ele funciona tão bem quanto Number.isNaN e checando se falso. Todos os três executam melhor que isNan

Os 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 

Pode se tornar útil se você quiser evitar a function isNaN quebrada.

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

Operador de igualdade (== e ===) não pode ser usado para testar um valor contra NaN.

Veja a documentação do Mozilla A propriedade global NaN é um valor que representa Not-A-Numbe

A melhor maneira é usar ‘isNaN ()’ que é a function buit-in para verificar NaN. Todos os navegadores suportam o caminho ..

A maneira exata de verificar é:

 //takes care of boolen, undefined and empty isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number' 
 function isNotANumber(n) { if (typeof n !== 'number') { return true; } return n !== n; } 

Talvez também isso:

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

De acordo com o IEEE 754, todas as relações envolvendo NaN são avaliadas como falsas, exceto! Assim, por exemplo, (A> = B) = falso e (A < = B) = falso se A ou B ou ambos são / são NaN.

Eu escrevi essa resposta para outra pergunta no StackOverflow, onde outra verificação quando NaN == null mas depois foi marcado como duplicado, então eu não quero perder meu trabalho.

Olhe para Mozilla Developer Network sobre NaN .


Resposta curta

Apenas use a distance || 0 distance || 0 quando você quer ter certeza de que você valoriza é um número adequado ou isNaN() para verificar isso.

Resposta longa

O NaN (Não-Num-Número) é um Objeto Global esquisito no javascript freqüentemente retornado quando alguma operação matemática falhava.

Você queria verificar se NaN == null que resulta false . Hovewer mesmo NaN == NaN resulta com false .

Uma maneira simples de descobrir se a variável é NaN é uma function global isNaN() .

Outro é x !== x que só é verdadeiro quando x é NaN. (obrigado por lembrar @ raphael-schweikert)

Mas por que a resposta curta funcionou?

Vamos descobrir.

Quando você chama NaN == false o resultado é false , mesmo com NaN == true .

Em algum lugar nas especificações, o JavaScript tem um registro com valores sempre falsos, o que inclui:

  • NaN – não-um-número
  • "" – string vazia
  • false – um booleano falso
  • null – object nulo
  • undefined – variables ​​indefinidas
  • 00 numérico, incluindo +0 e -0

Outra solução é mencionada na página parseFloat do MDN

Ele fornece uma function de filtro para fazer uma análise estrita

 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 

E então você pode usar isNaN para verificar se é NaN

Eu criei essa pequena function que funciona como um encanto. Em vez de verificar NaN, que parece ser contra-intuitivo, você verifica um número. Tenho certeza de que não sou o primeiro a fazer isso dessa maneira, mas pensei em compartilhar.

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

Encontrei outro jeito, só por diversão.

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

A resposta de marksyzm funciona bem, mas não retorna false para Infinity já que Infinity é tecnicamente não um número.

Eu isNumber uma function isNumber que irá verificar se é um 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")); 
 alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1); 

Isso não é elegante. mas depois de tentar isNAN () cheguei a essa solução que é outra alternativa. Neste exemplo, também permiti ‘.’ porque estou mascarando por flutuação. Você também pode inverter isso para garantir que nenhum número seja usado.

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

Esta é uma avaliação de um único caractere, mas você também pode percorrer uma string para verificar qualquer número.

É (NaN> = 0) ? …… ” Eu não sei “.

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

Condições só executadas se TRUE .

Não está em FALSE .

Não em " Eu não sei ".

Então eu vejo várias respostas para isso,

Mas eu só uso:

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

Simplesmente converta o resultado para String e compare com ‘NaN’.

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