Comment vérifiez-vous qu'un nombre est NaN en JavaScript?


415

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;

5
vaut la peine d'être lu si votre objectif réel est de vérifier les chiffres: stackoverflow.com/questions/18082/…
Paul


1
@Gothdo: bien sûr, mais j'ai demandé comment vérifier qu'un nombre est NaN, par opposition à n'importe quelle valeur.
Paul D. Waite

3
@ PaulD.Waite Oui, mais beaucoup de gens viennent ici pour googler quelque chose comme "comment vérifier si une variable est nan en javascript".
Michał Perłakowski

PaulD.Waite Je suis d'accord avec vous, mais j'ai la même préoccupation que @Gothdo. Beaucoup de gens atterrissent sur cette question avec l'intention de "Comment vérifier si une valeur dans JS est NaN". Vous pouvez vérifier le commentaire de mjohnsonengr sur la même réponse . BTW, moi aussi j'ai signalé cette question à l'attention des modérateurs.
dopeddude

Réponses:


582

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?


8
Y a-t-il un besoin de paseFloat?
rahul

23
Si vous voulez qu'une chaîne vide soit interprétée comme NaN, alors oui. (Je ne dis pas que vous le feriez toujours.)
Paul D. Waite

1
Si j'étais vous, je l'attribuerais à une variable et utiliser la variable de condition! == variable. Comme il est présenté dans les spécifications tc39.github.io/ecma262/#sec-isnan-number
allsyed

3
isNaN(parseFloat("geoff")) // true isNaN(parseFloat("10geo")) // false Comment est-ce utile?
Prashanth

Cela pourrait également être utile pour essayer w3schools.com/jsref/jsref_isnan.asp
Srijan Chaudhary

146

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


27
Efficace mais contre-intuitif. Je ne voudrais pas conserver ce type de code.
osa

35
Ce n'est pas le code qui est contre-intuitif, c'est NaN.
Jazzy

20
@DanM Ce n'est pas un bug, c'est le comportement standard IEE754 de NaN. C'est comme ça qu'il est implémenté dans les CPU, et c'est le comportement attendu dans tous les langages de programmation dans le monde qui utilise des flottants.
Tarmil

4
@Tarmil dûment noté! C'est vraiment très intéressant; J'ai toujours pensé que la bizarrerie de l'inégalité NaN était une chose Javascript.
Dan M

2
NaN === Nan; // faux. Il s'agit d'un bug connu en javascript. isNan est une nouvelle méthode.
atilkan

52

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

1
C'est peut-être juste moi, mais l'idée de NaN devient confuse quand var value = 0/0;et var value2= String("123 131");crée des valeurs NaN et quelque chose comme ça var value3 = "abcd";est aussi une valeur NaN.
Nick Pineda

@NickPineda Pourquoi?
Sinjai

44

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.


6
Merci de ne pas avoir simplement utilisé "isNan ()" mais d'avoir fourni une réponse complètement détaillée. C'est exactement ce que je cherchais lorsque j'ai trouvé cette question sur Google.
mjohnsonengr

1
".... donnait des résultats erronés pour les cas ci-dessus" Je ne dirais pas faux, juste différent, parce que le global isNaNconvertit d'abord l'argument en une valeur numérique.
Felix Kling

1
@FelixKling Veuillez vérifier la réponse mise à jour. Merci.
dopeddude

1
isNaN ("lorem ipsum"); // vrai avec ES5 m'a époustouflé
Nick Pineda

2
@NickPineda Le sentiment est tellement réciproque, mais finalement MDN pourrait l'expliquer de cette façon "Lorsque l'argument de la fonction isNaN n'est pas de type Number, la valeur est d'abord contrainte à un Number. La valeur résultante est ensuite testée pour déterminer si elle est NaN. "
dopeddude

16

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.


1
Ce n'est pas un moyen parfaitement fiable. Selon les spécifications. variable! == la variable est le moyen le plus fiable de vérifier la
présence

1
Voir ma réponse ci-dessus à ce sujet ^
Jazzy

14

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.


1
Ouais, isNaN('') //falsemais parseInt('') //NaN. On peut en dire autant null.
Silent Penguin

13

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


9

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".


7

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.


1
Intéressant. Est-il possible de contrer cela et de détecter que "1.2geoff" n'est pas vraiment une chaîne numérique valide?
Gabe Halsmer

2
Notez que cela se produit uniquement lorsque la chaîne commence par un nombre. parseFloat('test1.2')reviendra NaN.
Eduard Luca

6

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:


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.


1
@ PaulD.Waite peut-être son application, mais je ne vois pas de réponse acceptée. En fait, je ne vois que 5 réponses, mais je vois qu'il est dit qu'il y en a 15
SpYk3HH

1
Quelle application utilisez-vous?
Paul D. Waite

2
@ PaulD.Waite Le SE pour Android. sur galaxy s3
SpYk3HH

1
Aha. Je n'ai pas l'application pour me regarder, mais voici un lien vers la réponse acceptée: stackoverflow.com/a/2652335/20578
Paul D. Waite

@ PaulD.Waite Ah, je vois. Je suppose qu'en réponse directe à la seule question en soi, cette réponse peut suffire. J'ai posté ma réponse sur une autre question en relation totale avec "la façon dont JS vérifie si c'est" vraiment "NaN", car ce isNaNn'est PAS fiable. On m'a commenté là-bas et on m'a dit que cette question conviendrait mieux à ma réponse, la déplaçant ainsi ici. Il suffit juste de mettre sur quelque chose utile / utile il par rapport à cette question qui va apparaître sur une recherche Google de la question à, is it NaN?. En passant, ma réponse serait plus précise plus souvent que la réponse sélectionnée.
SpYk3HH

5

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 .


5

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

7
Mon environnement prend uniquement en charge ECMAScript XP Home Edition :(
Paul D. Waite

1
@ PaulD.Waite (j'espère que vous vouliez dire IE 6: D) Pas de problème :-) N'oubliez pas que cela isNaNpourrait vous causer des ennuis et n'oubliez pas d'utiliser Number.isNaNdans les environnements ECMAScript 2015 :-)
thefourtheye

5

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

4

J'utilise laisNaN fonction de soulignement car en JavaScript:

isNaN(undefined) 
-> true

Au moins, soyez conscient de ce piège.


10
Je suis confus. Pourquoi isNaN retournant vrai une fois transmis undefinedserait-il un comportement incorrect? Il est vrai que ce undefinedn'est pas un nombre, n'est-ce pas?
Xaxis

3
@Xaxis NaN ne doit pas être considéré comme équivalent à undefined, ce sont des valeurs spéciales avec des significations spécifiques et différentes . Considérez ceci: j'ai une valeur mais je ne dis pas ce que c'est, peut-être que c'est un nombre et peut-être que ce n'est pas, néanmoins, de votre point de vue, c'est indéfini.
Corin

1
@Corin undefinedpeut être quelque chose de différent NaN, mais ce n'est toujours pas un nombre, donc isNaN(undefined)devrait l'être (et l'est)true
neuhaus

4

Peut-être aussi ceci:

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

3

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

Bien sûr, mais je ne posais pas de questions sur Node.js.
Paul D. Waite



2

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

1

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.


1

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

1
«Le seul moyen simple de savoir si la variable est NaN est une fonction globale isNaN ()» - pas vrai; il existe un autre moyen simple: var xIsNaN = x !== x;cela ne donne la vérité que si x l'est NaN.
Raphael Schweikert

1

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


1

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'

1

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

1

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

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

1

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


Votre prémisse l'infini n'est techniquement pas un nombre est techniquement défectueux: math.stackexchange.com/questions/36289/is-infinity-a-number . D'après ma lecture des réponses, l'infini étant un nombre, cela dépend du contexte.
Jon P

je vais déplacer ceci à une autre question
adddff

1
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.


1

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

0

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

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

0

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 ".


pas très utile si vous recherchez explicitement des valeurs NaN au lieu de chercher le contraire
liviu blidar
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.