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

Acabei de encontrar esta técnica no Livro eficaz JavaScript Isso é muito simples:

Uma Vez Que NaN é o único valor JavaScript que é tratado como desigual para si mesmo, você pode sempre testar se um valor é NaN, verificando-o para a igualdade para si 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 isto até @allsyed comentar, mas isto está no ECMA spec: https://tc39.github.io/ecma262/#sec-isnan-number

Utilizar este código:

isNaN('geoff');

Ver isNaN() docs on 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 número deve ser testado quer se trate de um NaN ou não, a função global isNaN fará o trabalho

isNaN(any-Number);

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

Para Os Utilizadores ECMAScript-5:

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

Para pessoas que utilizam ECMAScript-6:

#2
Number.isNaN(x);

E para efeitos de coerência em todo o ECMAScript 5 & 6, também podemos usar este polifill para Numero.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.

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

Isto devolve true apenas para valores NaN e é uma forma segura de testar. Deve definitivamente ser envolto em uma função ou pelo menos comentado, porque não faz muito sentido obviamente testar se a mesma variável não é igual entre si, hehe.

Deve usar a chamada de função global isNaN(value), Porque:

• é suportado cross-browser
• VerisNaN para documentação

Exemplos:

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

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

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

Para corrigir o problema onde '1.2geoff' se torna processado, basta usar o analisador Number() em vez disso.

Então, em vez disto:

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

Faz isto:

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

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

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

Só para ser claro, o meu cuida da interpretação literal humana de algo que não é um número e o de lodash cuida da interpretação literal do computador de verificar se algo é "NaN".

Embora a resposta de @chiborg esteja correcta, há mais coisas que devem ser anotadas:

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

Por isso, sim, pode usar parseFloat(string) (ou no caso dos números completos parseInt(string, radix)' e, em seguida, embrulhá-los com isNaN(), mas tenha em atenção o sistema de gotcha com números entrelaçados com caracteres não-numéricos adicionais.

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

Utilizar tão simples como:

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

Ver ensaio de desempenho aqui usar este func vs resposta seleccionada

Também: Veja abaixo o primeiro exemplo para 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($("<tr />", { "class": strAnswer }).append($("<th />", {
        html: x
    }), $("<td />", {
        html: strAnswer
    })))
};

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>

Implementação alternativa 1: substituir o método nativo isNaN.

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

Implementação Alternativa 2: Adicionar ao objecto do número
^{*sugerida como também é um Poly-fill para ECMA 5 a 6}

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

solução alternativa _{testar se vazia}

Um simples método de janela eu escrevi esse teste se o objecto é vazio. É um pouco diferente na medida em que ele não dá se o item é "exatamente" NaN , mas eu pensei que eu iria vomitar isso porque também pode ser útil quando se procura vazio item.

/** 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);
})();

Exemplo:

;(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>

Verificação Extremamente Profunda Se Está Vazio

function isEmpty(a) {
	if (!a || 0 >= a) return !0;
	if ("object" == typeof a) {
		var b = JSON.stringify(a).replace(/"[^"]*":(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '').replace(/"[^"]*":\{\},?/g, '');
		if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		else if (a instanceof Array)  {
			b = b.replace(/(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '');
			if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		}
	}
	return false;
}
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,
    'Object Full of Empty Items': { 1: '', 2: [], 3: {}, 4: false, 5:new Array(3), 6: NaN, 7: null, 8: void 0, 9: 0, 10: '0', 11: { 6: NaN, 7: null, 8: void 0 } },
    'Array Full of Empty Items': ["",[],{},false,[null,null,null],null,null,null,0,"0",{"6":null,"7":null}]
  }

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>

Se o seu ambiente suportar ECMAScript 2015 , então poderá querer usar Number.isNaN para ter certeza de que o valor é realmente NaN.

O problema com isNaN is, Se você usar isso com dados não-numéricos, existem poucas regras confusas (como por MDN) são aplicadas. por exemplo,

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

Então, no ECMA Script 2015 suportado ambientes, você pode querer usar

Number.isNaN(parseFloat('geoff'))

Uso sublinhado isNaN função porque em JavaScript:

isNaN(undefined) 
-> true

NaN em JavaScript significa "não um número", embora seu tipo seja realmente número.

typeof(NaN) // "number"

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

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

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

À luz de que NaN é o único valor JavaScript que é tratado de forma desigual a si mesmo, para que possamos verificar a 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 != = ela própria, então esta variável é exatamente do valor NaN:

function isOfValueNaN(v) {
    return v !== v;
}

var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false

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

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

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

A lógica por trás disto é que todos os números excepto 0 e {[3] } são moldados para true.

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 tornar-se útil se quiser evitar a ruptura isNaN funcao.

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.

Olhe para documentação Mozilla a propriedade global NaN é um valor que representa não-a-Numbe

A melhor maneira é usando 'isNaN ()' que é função buit-in para verificar NaN. Todos os navegadores suportam o caminho..

A forma exacta 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'

Talvez também isto:

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

Eu escrevi esta resposta a outra pergunta em StackOverflow {[[24]} onde outra verificação quando {[[[[0]} mas depois foi marcado como duplicado para que eu não quero desperdiçar o meu trabalho.

Veja a rede de desenvolvimento Mozilla acerca de NaN.

Resposta curta

Basta usar distance || 0 quando quiser ter a certeza que o seu valor é um número adequado ou isNaN() para o verificar.

Resposta longa

O NaN (não-um-número) é um objecto global estranho em o javascript voltou frequentemente quando alguma operação matemática falhou.

Queria verificar se NaN == null quais os resultados false. Hovewer even NaN == NaN resultados com false.

Uma forma simples de descobrir se a variável é NaN é uma função global isNaN().

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

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

Algures nas especificações, o JavaScript tem um registo com sempre valores falsos, que inclui:

• NaN - Não-Número a
• "" - Texto vazio
• false - um falso booleano
• null - objecto nulo
• undefined - variáveis indefinidas
• 0 - numérico 0, incluindo +0 e -0

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

Ele fornece uma função de filtro para fazer uma análise rigorosa

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 depois pode usar isNaN para verificar se é NaN

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

    return retval;
}

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

A resposta de Marksyzm funciona bem, mas não devolve falsa para Infinity pois o infinito não é tecnicamente um número.

Criei uma função isNumber que vai 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"));

Actualizar: reparei que este código falha em alguns parâmetros, por isso tornei-o melhor.

function isNumber(i) {//function for checking if parameter is number
if(!arguments.length) {
throw new SyntaxError("not enough arguments.");
	} else if(arguments.length > 1) {
throw new SyntaxError("too many arguments.");
	} else if([Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY].indexOf(i) !== -1) {
throw new RangeError("number cannot be \xB1infinity.");
	} else if(typeof i === "object" && !(i instanceof RegExp) && !(i instanceof Number) && !(i === null)) {
throw new TypeError("parameter cannot be object/array.");
	} else if(i instanceof RegExp) {
throw new TypeError("parameter cannot be RegExp.");
	} else if(i == null || i === undefined) {
throw new ReferenceError("parameter is null or undefined.");
	} else {
return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && (i === i);
	}
}
console.log(isNumber(Infinity));
console.log(isNumber(this));
console.log(isNumber(/./ig));
console.log(isNumber(null));

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

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

Esta é uma única avaliação de caracteres, mas você também pode fazer um loop através de uma cadeia de caracteres para verificar quaisquer números.

É (NaN >= 0) ?...... "[3] Eu não sei".

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

As condições só são executadas se for verdadeiro.

Não emfalso .

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

Mas eu só uso:

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

Basta converter o resultado em cadeia e comparar com'NaN'.

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