Exemples de N façons de déterminer les types entiers dans les compétences JavaScript_javascript

Le type Integer (Integer) provoque souvent des problèmes étranges en JavaScript. Dans la spécification ECMAScript, ils n'existent que sous forme de concepts :

Tous les nombres sont des nombres à virgule flottante et les entiers ne sont qu'un ensemble de nombres sans décimales.

Dans ce blog, je vais vous expliquer comment vérifier si une valeur est un entier.
ECMAScript 5

Il existe de nombreuses méthodes que vous pouvez utiliser dans ES5. Parfois, vous souhaiterez peut-être utiliser votre propre méthode : une fonction isInteger(x), qui renvoie vrai s'il s'agit d'un entier, sinon elle renvoie faux.

Regardons quelques exemples.

Réussir le contrôle du reste

Vous pouvez utiliser l'opération de reste (%) pour calculer le reste d'un nombre par 1 afin de voir si le reste est 0.

function isInteger(x) {
  return x % 1 === 0;
}

J'aime cette méthode car elle est très simple et efficace.

> isInteger(17)
true
> isInteger(17.13)
false

Il faut être prudent lors des opérations de reste, car le résultat dépend du signe du premier nombre. S'il est positif, le résultat est positif sinon, il est négatif.

> 3.5 % 1
0.5
> -3.5 % 1
-0.5

Ensuite, on peut aussi vérifier 0, ce qui n'est pas vraiment un problème. Mais le problème est que cette méthode retournera également vrai pour les non-nombres, car % le convertira en nombre :

> isInteger('')
true
> isInteger('33')
true
> isInteger(false)
true
> isInteger(true)
true

Peut être résolu avec une vérification de type très simple :

function isInteger(x) {
  return (typeof x === 'number') && (x % 1 === 0);
}

Grâce à Math.round(), si un nombre est identique à sa valeur précédente après arrondi, alors c'est un entier. Cela peut être vérifié via Math.round() en JavaScript :

function isInteger(x) {
  return Math.round(x) === x;
}

Cette méthode est également bonne

> isInteger(17)
true
> isInteger(17.13)
false

Il peut également déterminer des non-nombres, car Math.round() renvoie toujours des nombres, et === renvoie vrai uniquement lorsque les types sont les mêmes.

> isInteger('')
false

Si vous souhaitez rendre le code un peu plus clair, vous pouvez ajouter une vérification de type (ce que nous avons fait dans les versions précédentes). De plus, Math.floor() et Math.ceil() fonctionnent comme Math.round(). Vérification des opérations sur les bits Les opérateurs de bits offrent une autre façon d'"arrondir" :

function isInteger(x) {
  return (x | 0) === x;
}

Cette solution (comme les autres opérations au niveau du bit) a un défaut : elle ne peut pas gérer les nombres supérieurs à 32 bits.

> isInteger(Math.pow(2, 32))
false

Check by parseInt() parseInt() fournit également une méthode similaire à Math.round() pour convertir les nombres en entiers. Voyons pourquoi cette méthode est bonne.

function isInteger(x) {
  return parseInt(x, 10) === x;
}

Comme la solution Math.round(), elle peut également gérer des cas non numériques, mais elle ne gère pas non plus correctement tous les nombres entiers :

> isInteger(1000000000000000000000)
false

Pourquoi ? parseInt() force le premier argument à être analysé sous forme de chaîne avant d'analyser un entier. Par conséquent, utiliser cette méthode pour convertir des nombres en entiers n’est pas un bon choix.

> parseInt(1000000000000000000000, 10)
1
> String(1000000000000000000000)
'1e+21'

Tout comme ci-dessus, parseInt() a arrêté le traitement à 1 lors de l'analyse de '1e 21', il renverra donc 1. ECMAScript 6 En plus de Math.round(), ES6 fournit une autre méthode numérique pour convertir en entier : Math .trunc(). Cette fonction supprime la partie décimale d'un nombre.

> Math.trunc(4.1)
4
> Math.trunc(4.9)
4
> Math.trunc(-4.1)
-4
> Math.trunc(-4.9)
-4

De plus, ECMAScript 6 n'a pas besoin de s'occuper de la tâche triviale de vérification des entiers car il est livré avec une fonction intégrée Number.isInteger().