Les nombres sont un type primitif en JavaScript, mais la simple utilisation de typeof ne permettra pas de différencier les nombres de NaN ou Infinity.
.
Il est utile de savoir comment vérifier si une valeur est du type primitif nombre, puisque JavaScript est un langage dynamiquement typé.
La façon la plus simple de vérifier si un nombre est un nombre est d’utiliser typeof, qui retournera la chaîne "number" pour toute valeur du type primitif nombre, notamment NaNInfinity, et -Infinity.
Un exemple où un nombre pourrait apparaître comme un autre type, indiquant un bug dans mon code, serait dans l’analyse de la monnaie :
Dans ce cas, je saurais que j’ai oublié d’analyser la chaîne en un nombre lorsque je récupère la valeur de « string » à partir de typeof.
.
Si j’utilise parseFloat() pour vérifier la valeur de la devise, mais que j’ai oublié de dépouiller le symbole de la monnaie, j’obtiens un échec d’analyse et un résultat étrange :
Oh, non. Dans ce cas, il semble que typeof ne fonctionne pas comme je l’attendais – car les valeurs NaN sont considérées comme des nombres en JavaScript.
Quand le mot-clé typeof renvoie « nombre »
Une solution évidente pour vérifier le type primitif nombre est d’utiliser le mot-clé typeof, comme je l’ai montré ci-dessus.
Mais typeof est une solution incomplète, à cause de deux valeurs spéciales en JavaScript : NaN (« Not a Number ») et Infinity.
Pour mon exemple de monnaie, je sais que j’ai un bug si ma valeur monétaire est NaN ou Infinity, mais typeof renvoie "number" pour ces deux valeurs.
Peut-être que mon entrée a été écrite en utilisant un symbole monétaire, et que j’ai simplement essayé d’utiliser parseFloat() pour capturer la valeur. Cela donnerait lieu à NaN :
.
Une fonction isNumber() personnalisée
Arobuste, fonction personnalisée isNumber() utiliserait typeof pour vérifier le type primitif, vérifier les valeurs NaN et vérifier Infinity :
Ou, dans le cas où l’on est sûr que NaN et Infinity ne vont pas apparaître, il suffirait de vérifier que typeof==="number" serait suffisant.
.
La one-liner
J’adore les one-liners. Je pense qu’ils doivent être documentés avec des commentaires, mais je pense qu’ils sont en fait vraiment utiles, pas seulement fantaisistes.
Voici le one-liner pour savoir comment vérifier un nombre en JavaScript :
Mais, il existe une meilleure façon de vérifier un nombre fini en JavaScript – la fonction d’aide Number.isFinite() a le même comportement que la fonction personnalisée isNumber() que j’ai écrite. J’inclus un exemple dans la section suivante.
.
La façon la plus simple de vérifier l’existence d’un nombre : Number.isFinite()
Il n’est en fait pas nécessaire d’écrire des fonctions personnalisées pour vérifier la présence d’un nombre, bien que ce soit un moyen instructif de se rappeler que les valeurs JavaScript Infinity-Infinity et NaN sont toutes du type primitif nombre.
« La méthode
Number.isFinite()détermine si la valeur passée est un nombre fini. » – MDN Docs
La méthode Number.isFinite() renverra true pour les nombres finis, et false pour Infinity-Infinity, et NaN – exactement ce que nous voulons :
Il existe également la fonction globale isFinite(), qui effectuera la coercition de type (comme la coercition des chaînes de caractères vers les nombres), comme indiqué ci-dessus.
J’aborde ces méthodes en profondeur dans mon article sur Infinity dans The Startup :
Vérifier si une variable est un entier
Pour vérifier si la variable A est un entier, je pourrais utiliser l’opérateur d’égalité libre == pour voir si la valeur analysée est égale à elle-même.
Le bout de code suivant donne un exemple de la façon de vérifier si un entier est un entier :
L’utilisation de typeof permettrait de différencier une chaîne de caractères contrainte en un nombre d’un nombre réel, tout comme l’opérateur d’égalité stricte ===.
.
Supprimer les symboles monétaires
Pour une meilleure, fonction plus robuste, je pourrais vouloir dépouiller les symboles monétaires (comme le signe dollar et toute virgule) en premier lieu.
L’analyse approfondie de la monnaie à l’aide d’expressions régulières en JavaScript dépasse le cadre de cet article, mais ce code supprime $ et , avant l’analyse :
Notez que les fonctions globales parseInt() et parseFloat() contraindront les valeurs en chaînes de caractères, si nécessaire, et renverront NaN si la coercition échoue.
Il existe également les fonctions Numbers.parseInt() et Number.parseFloat(), qui ont exactement le même comportement.
Selon les MDN Docs, ces fonctions dupliquées ont été ajoutées à ECMAScript 2015 pour la » modularisation des globaux à des fins utiles. »
.
Le JavaScript a-t-il réellement des entiers séparés ?
Non, JavaScript n’a qu’un seul type de nombre, qui est représenté en interne comme une représentation à virgule flottante de 64 bits.
Cette virgule flottante est le type de données primitif nombre, et il existe également un type appelé BigInt qui peut être utilisé pour des nombres arbitrairement grands.
Les fonctions globales parseInt() et parseFloat() diffèrent dans ce qu’elles attendent et produiront, mais pas parce qu’il existe réellement des types entiers et à virgule flottante distincts en JavaScript.
Conclusion
La vérification d’un nombre en JavaScript n’est pas particulièrement compliquée – typeof fonctionne fondamentalement comme il se doit, tant que l’on sait que les deux NaN et Infinity ont le numéro typeof.
La façon la plus simple de vérifier s’il s’agit d’un nombre fini (c’est-à-dire. pas NaN ou Infinity) en JavaScript est d’utiliser Number.isFinite(), qui ne coerce pas les valeurs en nombres, ou le global isFinite(), qui effectue une coercition de type.
La vérification d’un nombre entier implique spécifiquement l’utilisation de la fonction parseInt(), suivie de la comparaison de la valeur analysée à elle-même à l’aide de == (qui effectuera une coercition de type sur les valeurs non numériques, comme les chaînes de caractères, pour les transformer en nombres) ou === (qui ne renverra true que si les deux valeurs sont des nombres).
Sous le capot, les entiers et les flottants sont tous les mêmes : JavaScript n’a qu’un seul type de nombre, le type primitif nombre.
Lecture complémentaire
- La fonction
Number.isInteger()ne coerce pas les chaînes de caractères en nombres :
- Sumit Kumar Pradhan a écrit sur la vérification des nombres sur Dev.to:
- Chris Ferdinandi discute de l’analyse syntaxique des nombres sur son blog vanilla JS:
- L’expression régulière
^+(\.{1,2})?$correspond à l’argent:
- Sarah Dayan a écrit sur l’analyse syntaxique de l’argent en JavaScript sur frontstuff :
.