Convertir un nombre flottant en Int dans JavaScript

1. Convertir Float en Int en utilisant la fonction parseInt() en JavaScript
2. Convertir Float en Int en utilisant Number.toFixed() en JavaScript
3. Convertir Float en Int avec des opérateurs bit à bit dans JavaScript
4. Convertir Float en Int en utilisant les fonctions de la bibliothèque Math en JavaScript
5. Conclusion

En JavaScript, nous avons de nombreuses façons de convertir float en int, comme indiqué ci-dessous.

• La fonction parseInt()
• La méthode Number.toFixed()
• Conversion avec des opérateurs bit à bit
  • Appliquer OR par 0
  • Utilisation du double opérateur NOT
  • Droite SHIFT de 0
• Utilisation des fonctions de la bibliothèque Math en javascript
  • Math.floor()
  • Math.round()
  • Math.ceil()
  • Math.trunc()

Convertir Float en Int en utilisant la fonction parseInt() en JavaScript

parseInt() est largement utilisé en JavaScript. Avec cette fonction, nous pouvons convertir les valeurs de différents types de données en type entier. Dans cette section, nous verrons la conversion d’un nombre flottant en nombre entier. La syntaxe de parseInt() est parseInt(<value>). Le code suivant montre le comportement de la fonction.

console.log(parseInt(123.321));
console.log(parseInt(123.998));

Production:

123
123

Remarques

• Pour plus d’informations, reportez-vous à la documentation MSN.
• Lors de la conversion des valeurs flottantes, parseInt() supprime les décimales et ne les considère pas en retournant la partie entière de la valeur flottante.
• parseInt() renvoie NaN dans le cas où la conversion n’est pas possible. Par conséquent, il est bon d’inclure une vérification isNaN() lors de la conversion des valeurs afin que le code soit sûr et ne casse pas.

Convertir Float en Int en utilisant Number.toFixed() en JavaScript

Number.toFixed() se comporte un peu différemment de parseInt(). Il arrondit le nombre à la valeur entière la plus proche. Par conséquent, méfiez-vous du fait d’arrondi. Number.toFixed() arrondit la valeur décimale de float inférieure à .5 à la valeur entière inférieure. Si la valeur décimale est égale ou supérieure à 0.5, le nombre flottant sera arrondi à la valeur entière supérieure suivante. La syntaxe de la fonction Number.toFixed() est la suivante.

numberObject.toFixed(<number of digits>);

Habituellement, nous devons passer un paramètre à cette fonction qui spécifie le nombre de chiffres après la décimale dans la sortie. Pour notre propos, nous n’avons besoin de mentionner aucun argument car, par défaut, il prend le paramètre pour être 0, donc renvoyer une valeur entière. Reportez-vous aux exemples de codes suivants.

console.log( (123.123).toFixed(2) );
console.log( (123.123).toFixed() );
console.log( (123.98).toFixed() );
console.log( (123.49).toFixed() );
console.log( (123.5).toFixed() );

Production:

123.12
123
124
123
124

Remarques

• Contrairement à la méthode parseInt(), Number.toFixed() n’est pas si célèbre pour l’extraction de la partie entière, comme il fait un arrondi de la valeur flottante passée en paramètre.
• On peut utiliser cette fonction pour convertir uniquement des valeurs flottantes. Contrairement à la fonction parseInt(), la conversion de valeur de chaîne en float n’est pas supportée par Number.toFixed().

Convertir Float en Int avec des opérateurs bit à bit dans JavaScript

Nous avons vu les méthodes de parseInt() et de Number.toFixed(). Ces deux exécutent des opérations internes pour obtenir les résultats souhaités. Les opérateurs au niveau du bit sont efficaces, rapides et par formant pour convertir les valeurs flottantes en un entier par rapport aux deux méthodes. Nous pouvons utiliser les opérateurs binaires suivants pour la conversion.

Appliquer OR par 0

Nous pouvons utiliser l’opérateur OR au niveau du bit pour obtenir la partie entière d’un nombre à virgule flottante. Les opérateurs binaires fonctionnent au niveau binaire. Il convertit le numéro d’opérande en binaire, puis l’opération bit par bit OR est exécutée. Appliquer OR avec 0 à tout nombre à virgule flottante dans la plage acceptable renverra la partie entière de la valeur à virgule flottante. Reportez-vous aux exemples ci-dessous.

console.log(123.321 | 0);
console.log(123.5432 | 0);
console.log(123.921 | 0);
console.log(216 | 0);
console.log(-321.456 | 0)

Production:

123
123
123
216
-321

Utilisation de l’opérateur Double NOT

Un autre opérateur au niveau du bit est l’opérateur NOT, représenté par le signe ~. Étant un opérateur unaire, nous pouvons utiliser l’opérateur NOT au niveau du bit pour supprimer la partie décimale d’un nombre flottant. L’opérateur NOT, au niveau binaire, inverse les valeurs des bits binaires (renvoyant 0 pour un bit 1 et 1 pour une valeur de bit 0). Cela signifie que si un nombre est représenté en binaire par 10110, alors en lui appliquant NOT, on obtient la valeur inversée 01001. Une nouvelle application de la fonctionnalité NOT renvoie les bits d’origine (10110) du nombre. Par conséquent, appliquer deux fois l’opérateur NOT renvoie la valeur numérique, et pendant le processus, cela ne change pas le nombre s’il s’agit d’un entier. Mais pour une valeur flottante, appliquer deux fois l’opérateur NOT ne retournera que la partie entière du nombre flottant. Les exemples suivants clarifient ce fait.

console.log(~~(123.321));
console.log(~~(123.53));
console.log(~~(23.97));
console.log(~~(-23.97));
console.log(~~(-0.97));

Production:

123
123
23
-23
0

Décalage à droite de 0

Nous pouvons appliquer l’opérateur de décalage à droite au niveau du bit (représenté par des caractères >>). Il convertira la valeur flottante en un entier. En dessous, au niveau binaire, l’opérateur SHIFT droit au niveau du bit décale les bits binaires de l’opérande vers la droite d’un nombre spécifié par le deuxième opérande. Par conséquent, il ignore les bits qui débordent vers la droite. Ce faisant, la fonction préserve la valeur de signe du nombre. Les codes suivants représentent le fonctionnement de l’opérateur SHIFT droit.

console.log(123.321 >> 0);
console.log(123.53 >> 0);
console.log(23.97 >> 0);
console.log(-23.97 >> 0);
console.log(-0.97 >> 0);

Production:

123
123
23
-23
0

Remarques

• Les opérateurs au niveau du bit sont plus rapides car ils sont plus proches du langage machine et n’ont pas besoin d’effectuer de vérification ou d’opérations supplémentaires comme le feraient en interne parseInt() ou Number.toFixed().
• Les opérateurs au niveau du bit comme OR, NOT etc., lorsqu’ils sont appliqués sur de grands nombres, peuvent donner des résultats inattendus. La valeur maximale prise en charge pour obtenir la valeur décimale tronquée est 2147483647 (2³¹-1). Tout nombre supérieur à 2147483647 donnera des résultats inattendus.
• En JavaScript, les nombres à virgule flottante sont représentés par 64 bits, avec un bit réservé pour conserver la valeur du signe (positif ou négatif), 32 bits pour la partie entière du nombre. Les opérateurs au niveau du bit opèrent sur les nombres 32 bits signés en ignorant la valeur décimale. Par conséquent, nous obtenons la partie nombre entier de la valeur flottante.

Convertir Float en Int en utilisant les fonctions de la bibliothèque Math en JavaScript

Nous pouvons utiliser la bibliothèque JavaScript Math, qui possède diverses fonctions pour obtenir des entiers à partir de nombres à virgule flottante. Contrairement aux opérateurs bit à bit, ceux-ci offrent des fonctionnalités supplémentaires basées sur des exigences telles que l’arrondissement des valeurs aux nombres les plus proches, la troncature des valeurs, etc. Nous pouvons utiliser les méthodes suivantes à cet effet.

Conversion avec Math.floor()

La fonction Math.floor() arrondit la valeur passée en paramètre à la valeur entière inférieure suivante. La syntaxe de Math.floor() est Math.floor(<float value>). Voici quelques exemples qui illustrent l’utilisation et la façon dont il convertit un flottant en un nombre entier.

console.log(Math.floor(123.321));
console.log(Math.floor(123.53));
console.log(Math.floor(23.97));
console.log(Math.floor(-23.97));
console.log(Math.floor(-0.97));

Production:

123
123
23 - 24 - 1

Le cas des nombres flottants négatifs comme Math.floor(-23.97) peut sembler déroutant, mais la fonction convertit à juste titre la valeur en l’entier inférieur suivant, -24. Rappelez-vous que plus la valeur numérique d’un nombre négatif est élevée, moins sa valeur réelle est élevée.

Conversion avec Math.round()

Contrairement à la fonction Math.floor(), Math.round() se rapproche de la valeur passée en paramètres. Si la valeur après la virgule est 5 ou plus, le nombre est arrondi à l’entier supérieur suivant. Sinon, si la valeur après la virgule est inférieure à 5, elle est arrondie à l’entier inférieur. Ainsi, sur la base de la valeur après la virgule décimale, la fonction Math.round() peut se comporter de la même manière que les fonctions Math.floor() ou Math.ceil(). Voici quelques exemples avec Math.round().

console.log(Math.round(123.321));
console.log(Math.round(123.53));
console.log(Math.round(23.97));
console.log(Math.round(-23.97));
console.log(Math.round(-0.97));

Production:

123
124
24
-24
-1

Conversion avec Math.ceil()

La fonction Math.ceil() se comporte à l’opposé de la fonction Math.floor(). Au lieu d’arrondir à l’entier inférieur suivant comme dans Math.floor(), Math.ceil() renvoie la valeur entière supérieure suivante. Voici quelques conversions avec Math.ceil().

console.log(Math.ceil(123.321));
console.log(Math.ceil(123.53));
console.log(Math.ceil(23.97));
console.log(Math.ceil(-23.97));
console.log(Math.ceil(-0.97));

Production:

124
124
24
-23
-0

Conversion avec Math.trunc()

Comme le nom l’indique, la fonction Math.trunc() tronque la valeur décimale et renvoie la partie numérique entière de la valeur flottante. Cette méthode peut être considérée comme similaire aux opérateurs binaires évoqués précédemment. Ici, il n’y a pas d’arrondi aux nombres entiers les plus proches. Au lieu de cela, il renvoie la partie numérique entière de la valeur flottante telle quelle. Voici quelques cas d’utilisation de Math.trunc().

console.log(Math.trunc(123.321));
console.log(Math.trunc(123.53));
console.log(Math.trunc(23.97));
console.log(Math.trunc(-23.97));
console.log(Math.trunc(-0.97));

Production:

123
123
23
-23
-0

Conclusion

Il existe différentes manières d’extraire la partie entière d’une valeur flottante. Les opérateurs au niveau du bit sont plus rapides dans l’exécution car ils effectuent des opérations au niveau binaire sans les exigences de conversion ou de tout autre traitement. parseInt(), Math.trunc() et les opérateurs au niveau du bit (OR par 0, Double NOT, décalage à droite de 0) donnent le nombre entier exact comme s’ils déchiraient la valeur flottante à la virgule décimale et n’en renvoie que la partie entière du nombre. Si nous sommes intéressés à traiter le nombre flottant pour l’arrondir ou obtenir l’entier le plus proche en fonction de l’exigence métier, il serait bon d’utiliser les fonctions Number.toFixed(), Math.round(), Math.ceil() et Math.floor().