Cinq façons js de déterminer s'il s'agit d'un type entier_javascript skills

Cet article explique comment déterminer le type entier (Integer). JavaScript ne fait pas de distinction entre les nombres entiers et les nombres à virgule flottante. Tous les nombres sont représentés en interne au format à virgule flottante 64 bits, ce qui est le même que le type double de Java. Cependant, les opérations réelles telles que l'indexation de tableaux et les opérations sur les bits sont basées sur des entiers de 32 bits.
Méthode 1, utilisez l'opérateur reste pour déterminer
Tout entier est divisible par 1, c'est-à-dire que le reste est 0. Utilisez cette règle pour déterminer s’il s’agit d’un entier.

function isInteger(obj) {
 return obj%1 === 0
}
isInteger(3) // true
isInteger(3.3) // false　

Le résultat ci-dessus montre que cette fonction est très simple à utiliser, mais elle est impuissante pour les chaînes et certaines valeurs spéciales

isInteger('') // true
isInteger('3') // true
isInteger(true) // true
isInteger([]) // true

True est renvoyé pour les chaînes vides, les numéros de type chaîne, les booléens true et les tableaux vides, ce qui est vraiment inacceptable. Si vous êtes intéressé par les détails de conversion interne de ces types, veuillez vous référer à : Fausses valeurs étranges en JavaScript
Par conséquent, vous devez d'abord déterminer si l'objet est un nombre, par exemple en ajoutant un type de

function isInteger(obj) {
 return typeof obj === 'number' && obj%1 === 0
}
isInteger('') // false
isInteger('3') // false
isInteger(true) // false
isInteger([]) // false

Eh bien, c'est plus parfait.
Méthode 2, utilisez Math.round, Math.ceil, Math.floor pour juger
L'entier est toujours égal à lui-même après arrondi. Utilisez cette fonctionnalité pour déterminer s'il s'agit d'un entier, exemple Math.floor, comme suit

function isInteger(obj) {
 return Math.floor(obj) === obj
}
isInteger(3) // true
isInteger(3.3) // false
isInteger('') // false
isInteger('3') // false
isInteger(true) // false
isInteger([]) // false

Cela bloque directement les chaînes, true et [], et la quantité de code est inférieure à celle de la fonction précédente.
Méthode 3, juger par parseInt

function isInteger(obj) {
 return parseInt(obj, 10) === obj
}
isInteger(3) // true
isInteger(3.3) // false
isInteger('') // false
isInteger('3') // false
isInteger(true) // false
isInteger([]) // false

Très bien, mais il y a un inconvénient

isInteger(1000000000000000000000) // false

Il a en fait renvoyé false, ce qui est déraisonnable. La raison en est que parseInt force l'analyse du premier argument dans une chaîne avant d'analyser l'entier. Cette méthode de conversion de nombres en entiers n’est pas un bon choix.
Méthode 4 : Déterminer par des opérations sur les bits

function isInteger(obj) {
 return (obj | 0) === obj
}
isInteger(3) // true
isInteger(3.3) // false
isInteger('') // false
isInteger('3') // false
isInteger(true) // false
isInteger([]) // false

Cette fonction est très bonne et très efficace. Mais il y a un défaut. Comme mentionné ci-dessus, les opérations sur les bits ne peuvent gérer que les nombres de 32 bits et ne peuvent rien faire avec les nombres dépassant 32 bits, comme
.

Copier le code Le code est le suivant :

isInteger(Math.pow(2, 32)) // Un nombre de plus de 32 chiffres Renvoyé faux

Bien sûr, la plupart du temps, nous n’utiliserons pas de chiffres aussi gros.
Méthode 5. ES6 fournit Number.isInteger

Number.isInteger(3) // true
Number.isInteger(3.1) // false
Number.isInteger('') // false
Number.isInteger('3') // false
Number.isInteger(true) // false
Number.isInteger([]) // false

Actuellement, les derniers Firefox et Chrome le prennent déjà en charge.

Ci-dessus sont les cinq façons de déterminer s'il s'agit d'un type entier. Chacune de ces cinq méthodes a ses propres avantages et inconvénients. Vous pouvez les comparer soigneusement et choisir la meilleure à utiliser.