Est-ce que Number.IsNaN () est plus cassé que isNaN ()
Soooooo isNaN est apparemment cassé en JavaScript, avec des choses comme:
isNaN('')
isNaN(' ')
isNaN(true)
isNaN(false)
isNaN([0])
Renvoyer faux, quand ils semblent tous être ... Pas un nombre ...
Dans ECMAScript 6, le brouillon inclut un nouveau Number.isNaN mais il semble (imo) que cela est également cassé ...
Je m'attendrais
Number.isNaN('RAWRRR')
Pour renvoyer true, puisqu'il s'agit d'une chaîne et ne peut pas être converti en nombre ... Cependant ...
Il semble que les choses que je considérerais ... pas un nombre, ne sont en effet pas, pas un nombre ...
http://people.mozilla.org/~jorendorff/es6-draft.html#sec-isfinite-number
Les exemples sur MDN disent:
Number.isNaN ("blabla"); // par exemple. cela aurait été vrai avec isNaN
Je ne comprends pas ce qu'il en est "une version plus robuste de l'isNaN global d'origine". quand je ne peux pas vérifier pour voir si les choses ne sont pas un nombre.
Cela signifierait que nous sommes toujours soumis à des vérifications de type et à des vérifications isNaN ... ce qui semble idiot ...
http://people.mozilla.org/~jorendorff/es6-draft.html#sec-isnan-number
Le brouillon ES3 indique essentiellement que tout est toujours faux, à l'exception de son numéro.NaN
Est-ce que quelqu'un d'autre trouve que cela est cassé ou est-ce que je ne comprends pas le sens d'isNaN?
isNaN() et Number.isNaN() testent tous les deux si une valeur est (ou, dans le cas de isNaN(), peut être convertie en une valeur de type nombre qui représente) la valeur NaN. En d'autres termes, "NaN" ne signifie pas simplement que "cette valeur n'est pas un nombre", cela signifie spécifiquement "cette valeur est une valeur numérique Pas un nombre conformément à IEEE-754".
La raison pour laquelle tous vos tests précédents renvoient false est parce que toutes les valeurs données peuvent être converties en une valeur numérique qui n'est pas NaN:
Number('') // 0
Number(' ') // 0
Number(true) // 1
Number(false) // 0
Number([0]) // 0
La raison pour laquelle isNaN() est "en panne" est parce que, apparemment, les conversions de type ne sont pas censées se produire lors du test des valeurs. C’est le problème que Number.isNaN() doit résoudre. En particulier, Number.isNaN() tentera seulement de comparer une valeur à NaN si la valeur est une valeur de type nombre. Tout autre type renverra false, même s’ils sont littéralement "pas un nombre", car le type de la valeur NaN est un nombre. Voir les documents MDN respectifs pour isNaN() et Number.isNaN() .
Si vous voulez simplement déterminer si une valeur est du type numérique, même si cette valeur est NaN, utilisez plutôt typeof:
typeof 'RAWRRR' === 'number' // false
Non, l'original isNaN est cassé. Vous ne comprenez pas le point de isNaN.
Le but de ces deux fonctions est de déterminer si quelque chose a ou non la valeur NaN. Ceci est fourni parce que something === NaN sera toujours false et ne peut donc pas être utilisé pour le tester. (note: something !== something est en fait un test fiable, bien que contre-intuitif, pour NaN)
La raison pour laquelle isNaN est cassé est qu’elle peut renvoyer true dans les cas où une valeur n’est pas réellement NaN. En effet, la valeur est d'abord convertie en nombre.
Alors
isNaN("hello")
est true, même si "hello" n'est pas NaN.
Si vous voulez vérifier si une valeur est réellement un nombre fini, vous pouvez utiliser:
Number.isFinite(value)
Si vous voulez vérifier si une valeur est un nombre fini ou une chaîne de caractères, vous pouvez utiliser:
Number.isFinite(value) || (Number.isFinite(Number(value)) && typeof value === 'string')
La principale différence entre les deux réside dans le fait que la fonction globale isNaN(x) effectue une conversion du paramètre x en un nombre. Alors
isNaN("blabla") === true
parce que Number("blabla") donne NaN
Il existe deux définitions de "pas un nombre" ici et c'est peut-être là que réside la confusion. Number.isNaN(x) ne renvoie true que pour la définition de Not a Number par la spécification à virgule flottante IEEE 754, par exemple:
Number.isNaN(Math.sqrt(-1))
par opposition à déterminer si l'objet transmis est de type numérique ou non. Quelques façons de faire sont:
typeof x === "number"
x === +x
Object.prototype.toString.call(x) === "[object Number]"
Comme mentionné dans les commentaires isNaN() et Number.isNaN(), vérifiez que la valeur que vous transmettez est différente de la valeur NaN. La clé ici est que NaN est une valeur réelle et non un résultat évalué, par ex. "blabla" est une String et la valeur est "blabla", ce qui signifie qu'il ne s'agit pas de la valeur "NaN".
Une solution plausible serait de faire quelque chose comme:
Number.isNaN(Number("blabla")); //returns true.
1. Nombre.isNaN
alert(Number.isNaN('Hello')); // false
Ne devrait-il pas renvoyer true car Hello est une string et son Not A Number droit? Mais permet de savoir pourquoi il retourne false.
Documents MDN dit:
true si la valeur donnée est NaN et que son type est Number; autrement, faux.
Oui Hello la valeur est NaN mais le type est string, vous pouvez vérifier le type comme suit:
alert(typeof `Hello`); // string
Utilisation:
Utilisez cette option lorsque vous voulez vérifier que la valeur est NaN et que type est number.
2. isNaN
alert(isNaN('Hello')); // true
Documents MDN dit:
true si la valeur donnée est NaN; sinon, faux.
Utilisation:
À utiliser lorsque vous voulez vérifier la valeur, c'est simplement NaN.
3. jQuery.isNumeric ()
Jquery Docs dit:
Détermine si son argument représente un nombre JavaScript.
alert($.isNumeric('Hello')); // false
alert($.isNumeric(3)); //true
Utilisation:
Utilisez cette option lorsque vous souhaitez vérifier que la valeur est un nombre ou qu'elle peut être convertie en nombre.
Ce qui suit fonctionne car NaN est la seule valeur en javascript qui ne soit pas égale à elle-même.
Number.isNaN = Number.isNaN || function(value) {
return value !== value;
}
De manière générale, window.isNaN effectue une conversion de type en nombre, puis vérifie si c'est NaN. Alors que Number.isNaN n'essaye pas de convertir son argument en nombre. Donc, fondamentalement, vous pouvez penser à window.isNaN et Number.isNaN comme fonctionnant comme tel.
window.isNaN = function(n){
return Number(n) !== Number(n);
}
window.Number.isNaN = function(n){
return n !== n;
}
Veuillez noter que vous n'avez pas réellement besoin du window. pour appeler isNaN ou Number.isNaN. Je l’utilise plutôt pour mieux distinguer les deux méthodes portant le même nom et pour tenter de réduire la confusion.
~ Joyeux Codage!
@phill, comme indiqué dans d'autres réponses, ni l'un ni l'autre n'est cassé.
Number.isNaN fonctionne sur un nombre ou une instance de Number, de sorte que même Number.isNaN(new Date(NaN)) est faux.
isNaN, en revanche, est générique et essaie de convertir son paramètre en nombre avant de le vérifier.
Si vous voulez déterminer si une valeur est (ou contient) NaN, vous pouvez utiliser cette fonction:
function valueIsNaN(value) {
// eslint-disable-next-line no-self-compare
return value !== value || typeof value == 'object' && Number.isNaN(value.valueOf());
}