Essayez ce code:

 isNaN(parseFloat("geoff")) 

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

Je viens de rencontrer cette technique dans le livre JavaScript efficace qui est assez simple:

Puisque NaN est la seule valeur JavaScript qui est considérée comme inégale, vous pouvez toujours tester si une valeur est NaN en la vérifiant pour l'égalité à elle-même:

 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 

Ne s'est pas rendu compte jusqu'à ce que @allsyed ait commenté, mais cela se trouve dans la spécification ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Utilisez ce code:

 isNaN('geoff'); 

Voir les documents isNaN() sur MDN .

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

Dans la mesure où une valeur de type Number doit être testée, qu'il s'agisse d'un NaN ou non, la fonction globale isNaN fera le travail

 isNaN(any-Number); 

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

Pour les utilisateurs de ECMAScript-5:

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

Et pour un objectif de cohérence sur ECMAScript 5 et 6, nous pouvons également utiliser ce 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; } 

Veuillez vérifier cette réponse pour plus de détails.

NaN est une valeur spéciale qui ne peut pas être testée comme ça. Une chose intéressante que je voulais juste partager c'est ceci

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

Cela renvoie vrai uniquement pour les valeurs NaN et constitue un moyen de test sécurisé. Devrait certainement être enveloppé dans une fonction ou au moins commenté, car il n'a pas beaucoup de sens, évidemment, de tester si la même variable n'est pas égale l'une à l'autre, hehe.

Vous devez utiliser l'appel de fonction isNaN(value) global, car:

• Il est compatible avec le navigateur croisé
• Voir isNaN pour la documentation

Exemples:

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

J'espère que cela t'aidera.

Pour résoudre le problème où '1.2geoff' est analysé, utilisez plutôt l'analyseur Number() à la place.

Donc plutôt que ceci:

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

Faire cela:

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

EDIT: J'ai juste remarqué un autre problème à partir de cela, mais … les fausses valeurs (et vrai comme un vrai booléen) sont passées dans Number() return as 0 ! Dans ce cas, parseFloat fonctionne à chaque fois. Revenez donc à cela:

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

Et cela couvre apparemment tout. Je l'ai évalué à 90% plus lent que le Lodash's _.isNaN mais celui-ci ne couvre pas tous les NaN:

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

Juste pour être clair, le mien prend soin de l'interprétation littérale humaine de quelque chose qui est "Not a Number" et lodash's s'occupe de l'interprétation littérale de l'ordinateur pour vérifier si quelque chose est "NaN".

Alors que la réponse de @chiborg EST correcte, il y a plus à noter que cela doit être noté:

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

En l'occurrence, si vous utilisez cette méthode pour la validation de la saisie, le résultat sera plutôt libéral.

Donc, oui, vous pouvez utiliser parseFloat(string) (ou dans le cas de nombres complets parseInt(string, radix) ', puis ensuite enveloppez-le avec isNaN() , mais soyez conscient du getcha avec des nombres entrelacés avec des caractères non numériques supplémentaires .

Solution simple!

VRAIMENT super simple! Ici! Avoir cette méthode!

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

Utilisez aussi simple que:

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

Voir le test de performance ici en utilisant cette fonction vs la réponse sélectionnée

Aussi: voir ci-dessous le 1er exemple pour un couple d'implémentations alternatives.

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> 

À partir de 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 

Si votre environnement prend en charge ECMAScript 2015 , vous voudrez peut-être utiliser Number.isNaN pour vous assurer que la valeur est vraiment NaN .

Le problème avec isNaN est que, si vous utilisez cela avec des données non numériques, il existe peu de règles confuses (selon MDN). Par exemple,

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

Ainsi, dans les environnements pris en charge ECMA Script 2015, vous voudrez peut-être utiliser

 Number.isNaN(parseFloat('geoff')) 

Il semble que isNaN () ne soit pas pris en charge dans Node.js hors de la boîte.
J'ai travaillé avec

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

J'utilise la fonction isNaN de soulignement car en JavaScript:

 isNaN(undefined) -> true 

Tout le moins, soyez conscient de ce gotcha.

Je veux simplement partager une autre alternative, ce n'est pas nécessairement mieux que d'autres ici, mais je pense qu'il vaut la peine d'examiner:

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

La logique derrière cela est que tous les nombres sauf 0 et NaN sont transmis à true .

J'ai fait un test rapide, et il fonctionne aussi bien que Number.isNaN et comme vérification contre lui-même pour faux. Tous les trois fonctionnent mieux que isNan

Les resultats

 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 devenir utile si vous voulez éviter la fonction cassé isNaN .

La façon exacte de 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' 

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

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

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

Regardez la documentation de Mozilla La propriété NaN globale est une valeur représentant Not-A-Numbe

La meilleure façon est d'utiliser 'isNaN ()' qui est la fonction buit-in pour vérifier NaN. Tous les navigateurs prennent en charge la façon dont …

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 un double, donc je ne veux pas perdre mon travail.

Regardez Mozilla Developer Network sur NaN .

Réponse courte

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

Longue réponse

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

Vous vouliez vérifier si NaN == null ce qui est false . Hovewer, même NaN == NaN résultats avec false .

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

Un autre est x !== x qui est seulement vrai lorsque x est NaN. (Merci de rappeler @ raphael-schweikert)

Mais pourquoi la courte réponse a fonctionné?

Découvrons-le.

Lorsque vous appelez NaN == false le résultat est false , identique avec NaN == true .

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

• NaN – Not-a-Number
• "" – chaîne vide
• false – un faux booléen
• null – null object
• undefined – variables indéfinies
• 0 – 0 numérique, y compris +0 et -0

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

Il fournit une fonction de filtrage pour analyser strictement

 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 puis vous pouvez utiliser isNaN pour vérifier si c'est NaN

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

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

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

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

La réponse de marksyzm fonctionne bien, mais elle ne renvoie pas false pour Infinity comme Infinity n'est techniquement pas un nombre.

Je suis venu avec une fonction isNumber qui vérifiera si c'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")); 

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

Ce n'est pas élégant. Mais après avoir essayé wasNAN (), je suis arrivé à cette solution qui est une autre alternative. Dans cet exemple, j'ai aussi autorisé '.' Parce que je suis masquant pour le flotteur. Vous pouvez également inverser cela pour vous assurer qu'aucun nombre n'est utilisé.

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

Il s'agit d'une évaluation de caractère unique, mais vous pouvez également passer une chaîne pour vérifier les numéros.

Il suffit de convertir le résultat en Chaîne et de comparer avec 'NaN'.

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