Je ne l'ai essayé que dans la console JavaScript de Firefox, mais aucune des déclarations suivantes ne renvoie true:

parseFloat('geoff') == NaN;

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

Essayez ce code:

isNaN(parseFloat("geoff"))

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

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

Étant donné que NaN est la seule valeur JavaScript qui est traitée comme inégale à elle-même, vous pouvez toujours tester si une valeur est NaN en vérifiant son égalité avec 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

Je ne l'ai pas réalisé jusqu'à ce que @allsyed commente, mais cela se trouve dans la spécification ECMA: https://tc39.github.io/ecma262/#sec-isnan-number

Utilisez ce code:

isNaN('geoff');

Voir les isNaN()documents 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'elle soit NaNou non, la fonction globale isNaNfera le travail

isNaN(any-Number);

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

Pour les utilisateurs d'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 à des fins de cohérence dans 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 est la suivante

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

Cela renvoie vrai uniquement pour les valeurs NaN et est un moyen sûr de tester. Devrait certainement être enveloppé dans une fonction ou au moins commenté, car cela 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' isNaN(value)appel de fonction globale , car:

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

Exemples:

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

J'espère que cela t'aidera.

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

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

Pour résoudre le problème où '1.2geoff'l' Number()analyse est effectuée , utilisez simplement l' analyseur à la place.

Donc plutôt que ça:

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

Faites ceci:

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

EDIT: Je viens de remarquer un autre problème à partir de cela cependant ... de fausses valeurs (et vraies comme un vrai booléen) sont passées en Number()retour comme 0! Dans ce cas ... parseFloat fonctionne à chaque fois à la place. Revenons donc à cela:

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

Et cela couvre apparemment tout. Je l'ai comparé à 90% plus lentement que lodash, _.isNaNmais celui-ci ne couvre pas tous les NaN:

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

Juste pour être clair, le mien s'occupe de l'interprétation littérale humaine de quelque chose qui n'est "pas un nombre" et lodash's s'occupe de l'interprétation littérale informatique de vérifier si quelque chose est "NaN".

Bien que la réponse de @chiborg soit correcte, il y a plus à noter:

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

Le fait étant que si vous utilisez cette méthode pour valider la saisie, le résultat sera plutôt libéral.

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

Solution simple!

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

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

Utilisez aussi simple que:

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

Voir test de performance enhere utilisant ce func vsselected answer

Voir aussi ci-dessous le 1er exemple pour quelques 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>

Il y a quelques chemins alternatifs que vous prenez pour l'implémentation, si vous ne voulez pas utiliser une méthode nommée alternativement, et que vous souhaitez vous assurer qu'elle est plus globalement disponible. Attention Ces solutions impliquent de modifier des objets natifs et peuvent ne pas être votre meilleure solution. Soyez toujours prudent et sachez que d'autres bibliothèques que vous pourriez utiliser peuvent dépendre du code natif ou de modifications similaires.

Autre implémentation 1: remplacer la isNaNméthode native .

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

Mise en œuvre alternative 2: Ajouter à l'objet numérique
^{* Suggéré car il s'agit également d'un poly-remplissage pour ECMA 5 à 6}

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

_{Test de} solution alternative _{si vide}

Une méthode de fenêtre simple, j'ai écrit ce test si l'objet est vide . C'est un peu différent dans la mesure où il ne donne pas si l'élément est "exactement" NaN , mais j'ai pensé que je mettrais cela en place car cela peut également être utile lorsque vous recherchez des éléments 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>

Vérification extrêmement profonde s'il est vide

Ce dernier va un peu en profondeur, vérifiant même si un objet est plein d'objets vides. Je suis sûr qu'il a de la place pour des améliorations et des éventuelles fosses, mais jusqu'à présent, il semble pouvoir tout rattraper.

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>

Je veux juste partager une autre alternative, ce n'est pas nécessairement mieux que les autres ici, mais je pense que cela vaut la peine d'être examiné:

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

La logique derrière cela est que tous les nombres sauf 0et NaNsont exprimés en true.

J'ai fait un test rapide, et il fonctionne aussi bien Number.isNaNet se vérifie que faux. Tous les trois fonctionnent mieux queisNan

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 isNaNfonction cassée .

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

Le problème avec isNaNest que si vous utilisez cela avec des données non numériques, il y a peu de règles déroutantes (selon MDN) qui sont appliquées. Par exemple,

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

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

Number.isNaN(parseFloat('geoff'))

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

typeof(NaN) // "number"

Pour vérifier si une variable est de valeur NaN, nous ne pouvons pas simplement utiliser la fonction isNaN (), car isNaN () a le problème suivant, voir ci-dessous:

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

Ce qui se passe vraiment ici, c'est que myVar est implicitement contraint à un nombre:

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

Cela a du sens, car "A" n'est en fait pas un nombre. Mais ce que nous voulons vraiment vérifier, c'est si myVar a exactement la valeur NaN.

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

Étant donné que NaN est la seule valeur JavaScript traitée de manière inégale, nous pouvons donc vérifier son égalité avec lui-même en utilisant! ==

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

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

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

Donc pour conclure , s'il est vrai qu'une variable! == elle-même, alors cette variable est exactement de valeur NaN:

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

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

J'utilise laisNaN fonction de soulignement car en JavaScript:

isNaN(undefined) 
-> true

Au moins, soyez conscient de ce piège.

Peut-être aussi ceci:

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

Il semble que isNaN () ne soit pas pris en charge dans Node.js prêt à l'emploi.
J'ai travaillé avec

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

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é globale NaN est une valeur représentant Not-A-Numbe

La meilleure façon est d'utiliser 'isNaN ()' qui est une fonction intégrée pour vérifier NaN. Tous les navigateurs prennent en charge la façon ..

La règle est:

NaN != NaN

Le problème de la fonction isNaN () est qu'elle peut retourner un résultat inattendu 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"))

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

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

Regardez Mozilla Developer Network à propos NaN.

Réponse courte

Utilisez-le simplement distance || 0lorsque vous voulez vous assurer que la valeur est un nombre correct ou isNaN()pour le vérifier.

Longue réponse

Le NaN (Not-a-Number) est un objet global bizarre en javascript fréquemment renvoyé lorsque certaines opérations mathématiques ont échoué.

Vous vouliez vérifier NaN == nullquels résultats false. Hovewer NaN == NaNobtient même des résultats avec false.

Un moyen simple de savoir si une variable NaNest une fonction globale isNaN().

Un autre est x !== x vrai uniquement lorsque x est NaN. (merci de rappeler à @ raphael-schweikert)

Mais pourquoi la réponse courte a fonctionné?

Découvrons-le.

Lorsque vous appelez, NaN == falsele résultat est falseidentique à NaN == true.

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

• NaN - Pas un numéro
• "" - chaîne vide
• false - un faux booléen
• null - objet nul
• undefined - variables non définies
• 0 - numérique 0, dont +0 et -0

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

Il fournit une fonction de filtre pour effectuer une analyse 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 puis vous pouvez utiliser isNaNpour vérifier s'il estNaN

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'

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

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

    return retval;
}

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 retourne pas faux Infinitycar Infinity n'est techniquement pas un nombre.

j'ai trouvé une isNumberfonction qui vérifiera s'il s'agit d'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: j'ai remarqué que ce code échoue pour certains paramètres, donc je l'ai amélioré.

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

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, j'ai également autorisé "." parce que je me cache pour flotter. Vous pouvez également inverser cela pour vous assurer qu'aucun chiffre n'est utilisé.

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

Il s'agit d'une évaluation à un seul caractère, mais vous pouvez également parcourir une chaîne pour vérifier les nombres.

Vous pouvez vérifier NaN en utilisant la fonction javascript isNaN. Passer simplement le nombre ou la valeur à la fonction isNaN

isNaN(123) //false
isNaN(-1.23) //false
isNaN(5-2) //false
isNaN(0) //false
isNaN('123') //false
isNaN('Hello') //true
isNaN('2005/12/12') //true
isNaN('') //false
isNaN(true) //false
isNaN(undefined) //true
isNaN('NaN') //true
isNaN(NaN) //true
isNaN(0 / 0) //true

Convertissez simplement le résultat en String et comparez avec 'NaN'.

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

Est-ce que (NaN> = 0) ? ...... " Je ne sais pas ".

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

Les conditions ne s'exécutent que si VRAI .

Pas sur FAUX .

Pas sur " Je ne sais pas ".