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;
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;
Réponses:
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?
NaN
, alors oui. (Je ne dis pas que vous le feriez toujours.)
isNaN(parseFloat("geoff")) // true
isNaN(parseFloat("10geo")) // false
Comment est-ce utile?
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
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.
Dans la mesure où une valeur de type Number doit être testée, qu'elle soit 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 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.
isNaN
convertit d'abord l'argument en une valeur numérique.
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:
Exemples:
isNaN('geoff'); // true
isNaN('3'); // false
J'espère que cela t'aidera.
isNaN('') //false
mais parseInt('') //NaN
. On peut en dire autant null
.
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, _.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 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.
parseFloat('test1.2')
reviendra NaN
.
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.
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.
isNaN
méthode native .// Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }
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);
})();
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.
isNaN
n'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.
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 0
et NaN
sont exprimés en true
.
J'ai fait un test rapide, et il fonctionne aussi bien Number.isNaN
et 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 isNaN
fonction cassée .
Si votre environnement prend en charge ECMAScript 2015 , vous souhaiterez 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 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'))
isNaN
pourrait vous causer des ennuis et n'oubliez pas d'utiliser Number.isNaN
dans les environnements ECMAScript 2015 :-)
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.
undefined
serait-il un comportement incorrect? Il est vrai que ce undefined
n'est pas un nombre, n'est-ce pas?
undefined
peut ê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
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);
function isNotANumber(n) {
if (typeof n !== 'number') {
return true;
}
return n !== n;
}
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 == null
mais ensuite elle a été marquée comme doublon, donc je ne veux pas perdre mon travail.
Regardez Mozilla Developer Network à propos NaN
.
Utilisez-le simplement distance || 0
lorsque vous voulez vous assurer que la valeur est un nombre correct ou isNaN()
pour le vérifier.
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 == null
quels résultats false
. Hovewer NaN == NaN
obtient même des résultats avec false
.
Un moyen simple de savoir si une variable NaN
est une fonction globale isNaN()
.
Un autre est x !== x
vrai uniquement lorsque x est NaN. (merci de rappeler à @ raphael-schweikert)
Découvrons-le.
Lorsque vous appelez, NaN == false
le résultat est false
identique à 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 videfalse
- un faux booléennull
- objet nulundefined
- variables non définies0
- numérique 0, dont +0 et -0var xIsNaN = x !== x;
cela ne donne la vérité que si x l'est NaN
.
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 isNaN
pour 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 Infinity
car Infinity n'est techniquement pas un nombre.
j'ai trouvé une isNumber
fonction 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 ".