Comment vérifier qu'un nombre est NaN en JavaScript?

Question

Je ne l'ai essayé dans la console JavaScript de Firefox, mais aucun des énoncés suivants renvoient true:

parseFloat('geoff') == NaN;

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

Answer 1

Essayez ce code:

isNaN(parseFloat("geoff"))

Pour vérifier si une valeur est NaN, au lieu de chiffres seulement, voir ici: Comment tester NaN en Javascript?

Answer 2

Je viens de découvrir cette technique dans le livre JavaScript efficace qui est assez simple:

Depuis NaN est la seule valeur JavaScript qui est traité comme inégal à lui-même, vous pouvez toujours tester si une valeur est NaN en cochant la case pour l'égalité se:

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'a pas réalisé jusqu'à ce que @allsyed a commenté, mais cela est dans la spécification ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Answer 3

Utilisez ce code:

isNaN('geoff');

Voir isNaN() docs sur MDN.

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

Answer 4

En ce qui concerne une valeur de type Nombre est à tester si elle est un NaN ou non, la isNaN fonction globale fera le travail

isNaN(any-Number);

---

Pour une approche générique qui fonctionne pour tous les types de JS, nous pouvons utiliser les éléments suivants:

Pour ECMAScript 5 utilisateurs:

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

Pour les personnes utilisant ECMAScript-6:

#2
Number.isNaN(x);

Pour des raisons de cohérence entre ECMAScript 5 et 6 fois, nous pouvons également utiliser cette polyfill pour 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;
}

cette réponse pour plus de détails.

Answer 5

NaN est une valeur spéciale qui ne peut pas être testé comme ça. Une chose intéressante que je voulais juste part est ce

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

Retourne vrai seulement pour les valeurs NaN et est un moyen sûr de tests. Devrait certainement être enveloppé dans une fonction ou du moins commenté, car il ne marche pas beaucoup de sens évidemment pour tester si la même variable ne correspond pas à l'autre, hehe.

Answer 6

Vous devez utiliser l'appel de la fonction globale de isNaN(value), parce que:

• Il est multi-navigateur pris en charge
• Voir isNaN pour la documentation

Exemples:

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

J'espère que cela vous aidera.

Answer 7

ES6 , Object.is(..) est un nouvel utilitaire qui peut être utilisé pour tester deux valeurs pour l'égalité absolue:

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

Answer 8

Pour résoudre le problème où '1.2geoff' devient analysée, il suffit d'utiliser à la place l'analyseur Number().

Ainsi, plutôt que ceci:

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

Pour ce faire:

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

EDIT: Je viens de remarquer une autre question de ce bien que ... les fausses valeurs (et vrai comme un véritable booléen) passé en retour Number() comme 0! Dans ce cas ... parseFloat fonctionne à chaque fois à la place. Donc, revenir à ce que:

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

Et qui couvre tout en apparence. Je l'ai benchmarkée à 90% plus lent que _.isNaN de lodash mais que l'on ne couvre pas toutes NAN:

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

Pour être clair, le mien prend soin de l'interprétation littérale de l'homme quelque chose qui est « pas un nombre » et de lodash prend soin de l'ordinateur interprétation littérale de vérifier si quelque chose est « NaN ».

Answer 9

Alors que la réponse de » @chiborg est correcte, il est plus à ce qu'il convient de relever:

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

être point, si vous utilisez cette méthode pour la validation de l'entrée, le résultat sera plutôt libéral.

Alors, oui, vous pouvez utiliser parseFloat(string) (ou dans le cas de plein numéros parseInt(string, radix) », puis par la suite WRAP avec isNaN(), mais être conscient du Gotcha avec des chiffres entrelacés avec des caractères non numériques supplémentaires.

Answer 10

Solution simple!

simple, vraiment super! Ici! Cette méthode!

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

Utilisation aussi simple que:

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

  

Voir test de performance ici en utilisant ce func vs < a href = "https://stackoverflow.com/questions/2652319/how-do-you-check-that-a-number-is-nan-in-javascript/#answer-2652335"> réponse sélectionnée

     

Aussi:. Voir ci-dessous le 1er exemple pour une mise en oeuvre d'alternatives couple

---

Exemple:

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>

Il y a quelques chemins alternatifs que vous prenez pour implementaion, si vous ne voulez pas utiliser une méthode nommée tour à tour, et aimeraient assurer qu'il est plus disponible au niveau mondial. Attention Ces solutions impliquent en train de modifier des objets natifs et peuvent ne pas être la meilleure solution. Soyez toujours vigilant et être conscient que d'autres bibliothèques que vous pourriez utiliser peut dépendre du code natif ou des modifications similaires.

Autre mise en œuvre 1: Remplacer la méthode native isNaN

.

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

Mise en œuvre Alternate 2: append à Numéro de l'objet
^{* suggérée comme il est aussi un poly-remplissage pour ECMA de 5 à 6}

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

---

Autre solution _{test si vide}

Une méthode simple de fenêtre je l'ai écrit ce test si l'objet est vide . Il est un peu différent en ce qu'il ne donne pas si l'article est « exactement » NaN , mais je pensais que je jetterais cela comme il peut aussi être utile lors de la recherche des articles vides.

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

Exemple:

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

---

Extrêmement profond Vérifiez si est vide

Ce dernier va un profond bits, même vérifier si un objet est plein d'objets en blanc. Je suis sûr qu'il a de la place pour les fosses d'amélioration et possibles, mais jusqu'à présent, il semble attraper presque tout.

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>

Answer 11

Si vos supports d'environnement EcmaScript 2015 , vous pouvez utiliser Number.isNaN pour vous assurer que la valeur est vraiment NaN.

Le problème avec isNaN est, si vous utilisez que des données non numériques il y a peu de règles confuses (comme par MDN) sont appliqués. par exemple,

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

Ainsi, dans ECMAScript 2015 environnements pris en charge, vous voudrez peut-être utiliser

Number.isNaN(parseFloat('geoff'))

Answer 12

NaN en JavaScript signifie "Not A Number", bien que son type est en fait nombre.

typeof(NaN) // "number"

Pour vérifier si une variable est de la valeur NaN, nous ne pouvons pas simplement utiliser la fonction isNaN (), parce que isNaN () a la question suivante, voir ci-dessous:

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

Qu'est-ce qui se passe vraiment ici mavar est contraint implicitement à un certain nombre:

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

Il est en fait sens, parce que « A » est en fait pas un nombre. Mais ce que nous voulons vraiment vérifier est si myVar est exactement de la valeur NaN.

isNaN () ne peut pas aider. Alors que devons-nous faire à la place?

Dans la lumière qui NaN est la seule valeur JavaScript qui est traité inégal à lui-même, afin que nous puissions vérifier son égalité s'utilisant! ==

var myVar; // undefined
myVar !== myVar // false

var myVar = "A";
myVar !== myVar // false

var myVar = NaN
myVar !== myVar // true

Pour conclure , s'il est vrai qu'une variable == lui-même, cette variable est exactement la valeur NaN:

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

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

Answer 13

J'utilise underscore de fonction isNaN car en JavaScript:

isNaN(undefined) 
-> true

Au moins, être conscient de ce Gotcha.

Answer 14

Je veux juste partager une autre alternative, ce n'est pas nécessairement mieux que d'autres, mais je pense qu'il vaut la peine de regarder à:

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

La logique derrière cela est que chaque numéro, sauf 0 et NaN sont jetés à true.

Je l'ai fait un test rapide, et il effectue aussi bon que Number.isNaN et que la vérification contre lui-même pour faux. Tous les trois fonctionnent mieux que isNan

Les résultats

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

Peut être utile si vous voulez éviter la fonction isNaN brisée.

Answer 15

Il semble que isNaN () ne sont pas pris en charge dans Node.js hors de la boîte.
Je CONTOURNÉS avec

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

Answer 16

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

Answer 17

Peut-être aussi ceci:

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

Answer 18

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

  

opérateur d'égalité (== et ===) ne peut pas être utilisé pour tester une valeur par rapport NNA.

Regardez Mozilla Documentation NAN global la propriété est une valeur représentant non-a-Numbe

La meilleure façon est d'utiliser « isNaN () » qui est buit en fonction pour vérifier NaN. Tous les navigateurs prend en charge le chemin ..

Answer 19

La façon exacte à vérifier est:

//takes care of boolen, undefined and empty

isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'

Answer 20

Selon IEEE 754, toutes les relations impliquant NaN évaluer comme faux sauf! =. Ainsi, par exemple, (A> B =) = false et (A <= B) = false si A ou B, ou les deux est / sont NaN.

Answer 21

J'ai écrit cette réponse à une autre question sur StackOverflow où un autre vérifie quand NaN == null, mais il a été marqué comme doublon, donc je ne veux pas perdre mon travail.

Regardez Mozilla Developer réseau sur NaN.

---

Réponse courte

Il suffit d'utiliser distance || 0 lorsque vous voulez être sûr que vous la valeur est un nombre approprié ou isNaN() pour le vérifier.

Réponse longue

Le NaN (Not-a-Number) est un cinglé objet global en javascript fréquemment retourné quand une opération a échoué mathématique.

Vous voulez vérifier si NaN == null qui résulte false. Hovewer même avec des résultats NaN == NaN false.

Une façon simple de savoir si la variable est NaN est une isNaN() de fonction globale.

Une autre est x !== x qui est vrai que lorsque x est NaN. (merci pour rappeler à @ raphael-Schweikert)

Mais pourquoi la réponse courte a travaillé?

Let trouver.

Lorsque vous appelez NaN == false le résultat est false, même avec NaN == true.

Quelque part dans les spécifications JavaScript a un dossier avec des valeurs toujours fausses, qui comprend:

• NaN - Non-a-Number
• "" - chaîne vide
• false - un faux booléen
• null - objet null
• undefined - variables non définies
• 0 - 0 numérique, y compris +0 -0

Answer 22

Une autre solution est mentionnée dans la page parseFloat de MDN

Il fournit une fonction de filtre pour faire l'analyse syntaxique stricte

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

Et vous pouvez utiliser isNaN pour vérifier si elle est NaN

Answer 23

J'ai créé cette petite fonction qui fonctionne comme un charme. Au lieu de vérifier NaN qui semble être contre-intuitif, vous vérifiez un numéro. Je suis sûr que je ne suis pas le premier à le faire de cette façon, mais je pensais que je partagerais.

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

    return retval;
}

Answer 24

trouvé une autre façon, juste pour le plaisir.

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

Answer 25

La réponse de marksyzm fonctionne bien, mais il ne retourne pas faux pour Infinity comme Infinity est techinicly pas un nombre.

je suis venu avec une fonction isNumber qui va vérifier si elle est un nombre.

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"));

Mise à jour: i remarqué que ce code échoue pour certains paramètres, donc je l'ai fait mieux.

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

Answer 26

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

Ce n'est pas élégant. mais après avoir essayé isNAN () je suis arrivé à cette solution qui est une autre alternative. Dans cet exemple, je également permis. » parce que je suis un masque facial pour flotter. Vous pouvez également inverser ce pour vous assurer qu'aucun numéros sont utilisés.

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

Ceci est une évaluation de caractère unique, mais vous pouvez aussi la boucle par une chaîne pour vérifier les chiffres.

Answer 27

(NaN> = 0) ? ...... " Je ne sais pas ".

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

Conditions d'exécuter uniquement si TRUE .

Pas sur false .

Pas sur " Je ne sais pas ".

Answer 28

La règle est:

NaN != NaN

Le problème de la fonction isNaN () est qu'il peut retourner des résultats inattendus dans certains cas:

isNaN('Hello')      //true
isNaN('2005/12/12') //true
isNaN(undefined)    //true
isNaN('NaN')        //true
isNaN(NaN)          //true
isNaN(0 / 0)        //true

Une meilleure façon de vérifier si la valeur est vraiment NaN est:

function is_nan(value) {
    return value != value
}

is_nan(parseFloat("geoff"))

Answer 29

convertir simplement le résultat à cordes et comparer avec NAN.

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

Answer 30

Je vois plusieurs réponses à cela,

Mais je viens d'utiliser:

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