Como você verifica se um número é NaN em JavaScript?
só o tenho tentado na consola JavaScript do Firefox, mas nenhuma das seguintes declarações é verdadeira:
parseFloat('geoff') == NaN;
parseFloat('geoff') == Number.NaN;
29 answers
Tenta este código:
isNaN(parseFloat("geoff"))
Para verificar se algum valor é NaN, em vez de apenas números, veja aqui: Como é que se testa o 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
Espero que isto te ajude.
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
[[9]}EDIT: eu acabei de notar outro problema a partir disso... valores falsos (e verdadeiros como booleanos reais) passaram para Number()
retornando como 0
! Nesse caso... parseFloat funciona sempre. Por isso, retirem-se para isso.
function definitelyNaN (val) {
return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}
E isso cobre tudo. Avaliei-o 90% mais lento que o lodash. esse não cobre todos os Nan's:
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
A questão é que, se estás a usar este método para validar a entrada, o resultado será bastante liberal.
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
Este último vai um pouco fundo, mesmo verificando se um objeto está cheio de objetos em branco. Tenho a certeza que tem espaço para melhorias e possíveis fossas, mas até agora, parece apanhar a maior parte de tudo.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
Pelo menos, fica ciente disso.
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
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 é um número. Mas o que nós realmente queremos verificar é se myVar é exatamente de valor Fernanda.
Então o isNaN não pode ajudar. Então o que devemos fazer em vez disso?
À 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
.
Number.isNaN
e como verificar contra si mesmo por falso. Todos os três apresentam melhor do 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 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'
function isNotANumber(n) {
if (typeof n !== 'number') {
return true;
}
return n !== n;
}
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);
Isto não é elegante. mas depois de tentar isNAN() cheguei a esta solução que é outra alternativa. Neste exemplo, eu também permiti ". porque estou a mascarar-me de flutuador. Você também pode reverter isso para se certificar de que nenhum número é usado.
("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");
}