Apprenez la précision en virgule flottante javascript avec les compétences me_javascript

La plupart des langages de programmation ont plusieurs types de données numériques, mais JavaScript n'en a qu'un. Vous pouvez utiliser l'opérateur typeof pour vérifier le type d'un numéro. Qu'il s'agisse d'entiers ou de nombres à virgule flottante, JavaScript les classe simplement comme des nombres.

typeof 17; //number
typeof 98.6; //number
typeof -21.3; //number

En fait, tous les nombres en JavaScript sont des nombres à virgule flottante double précision. Il s'agit de nombres codés sur 64 bits - "doubles" - spécifiés par la norme IEEE754. Si ce fait vous amène à vous demander comment JavaScript représente les entiers, rappelez-vous que les nombres à virgule flottante double précision représentent parfaitement des entiers jusqu'à 53 chiffres de précision. Tous les nombres entiers compris entre –9 007 199 254 740 992 (–253) et 9 007 199 254 740 992 (253) sont des nombres à virgule flottante double précision valides. Ainsi, malgré le manque de types entiers évidents en JavaScript, l’arithmétique entière est parfaitement possible.
La plupart des opérateurs arithmétiques peuvent effectuer des calculs à l'aide de nombres entiers, de nombres réels ou d'une combinaison des deux.

0.1 * 0.9; //0.19
-99 + 100; //1
21- 12.3; //8.7
2.5 /5; //0.5
21%8; //5

Cependant, les opérateurs arithmétiques sur bits sont spéciaux. JavaScript n'opère pas directement sur l'opérande comme un nombre à virgule flottante, mais le convertit implicitement en un entier de 32 bits avant d'effectuer l'opération. (Pour être précis, ils sont convertis en représentation complémentaire big-endian 2 de 32 bits d'entiers.) Prenons l'expression OR au niveau du bit comme exemple :

8|1; //9

Une expression apparemment simple nécessite en réalité plusieurs étapes pour mener à bien l’opération. Comme mentionné précédemment, les nombres 8 et 1 en JavaScript sont tous deux des nombres à virgule flottante double précision. Mais ils peuvent également être représentés sous forme d’entiers de 32 bits, qui sont des séquences de 32 bits 0 et 1. L'entier 8 est représenté sous la forme d'une séquence binaire de 32 bits comme suit :

00000000000000000000000000001000

Vous pouvez également utiliser la méthode toString de type numérique pour le visualiser vous-même :

(8).toString(2) //"1000"

Le paramètre de la méthode

toString précise sa base de conversion. Cet exemple est exprimé en base 2 (c'est-à-dire binaire). La valeur résultante omet les 0 (bits) supplémentaires à gauche car ils n'affectent pas la valeur finale.
L'entier 1 est représenté sous forme binaire de 32 bits comme suit :

00000000000000000000000000000001

L'expression OR au niveau du bit combine deux séquences de bits. Tant que l'un des deux bits impliqués dans l'opération est 1, le bit du résultat de l'opération sera 1. Le résultat exprimé sous forme de modèle de bits est le suivant :

00000000000000000000000000001001

Cette séquence représente l'entier 9. Vous pouvez utiliser la fonction de bibliothèque standard parseInt pour vérifier, également en utilisant la base 2 :

parseInt("1000", 2); //9

(Encore une fois, les bits 0 en tête sont inutiles car ils n'affectent pas le résultat de l'opération.)
Tous les opérateurs au niveau du bit fonctionnent de la même manière. Ils convertissent les opérandes en nombres entiers, puis effectuent des opérations à l'aide de modèles de bits entiers et enfin convertissent le résultat en un nombre à virgule flottante JavaScript standard. En règle générale, le moteur JavaScript doit effectuer un travail supplémentaire pour effectuer ces conversions. Étant donné que le nombre est stocké sous forme de nombre à virgule flottante, il doit être converti en nombre entier, puis reconverti en nombre à virgule flottante. Cependant, dans certains cas, les expressions arithmétiques ou même les variables ne peuvent être utilisées qu'avec des entiers, et les compilateurs d'optimisation peuvent parfois déduire ces situations et stocker les nombres sous forme d'entiers en interne pour éviter les conversions redondantes.

Un dernier avertissement concernant les nombres à virgule flottante est que vous devez toujours vous en méfier. Les nombres à virgule flottante peuvent sembler familiers, mais ils sont notoirement imprécis. Même certaines opérations arithmétiques apparemment simples peuvent produire des résultats incorrects.

0,1 0,2; 0,300000000000004

Bien que la précision de 64 bits soit assez élevée, les nombres à virgule flottante double précision ne peuvent représenter qu'un ensemble limité de nombres, mais ne peuvent pas représenter l'ensemble des nombres réels. Les opérations en virgule flottante ne peuvent produire que des résultats approximatifs, arrondis au nombre réel représentable le plus proche. Au fur et à mesure que vous effectuez une série d'opérations, les résultats deviennent de moins en moins précis à mesure que les erreurs d'arrondi s'accumulent. L’arrondi peut également produire des écarts inattendus par rapport aux lois arithmétiques auxquelles nous nous attendons normalement. Par exemple, les nombres réels satisfont à la loi associative, ce qui signifie que pour tout nombre réel x, y, z, (x y) z = x (y z) est toujours satisfait.

Cependant, pour les nombres à virgule flottante, ce n'est pas toujours le cas.

（0.1+0.2）+0.3; //0.60000000000000001
0.1+(0.2+ 0.3); //0.6

Les nombres à virgule flottante font un compromis entre précision et performances. Lorsque nous nous soucions de précision, faites attention aux limites des nombres à virgule flottante. Une solution efficace consiste à utiliser autant que possible l’arithmétique des nombres entiers, car les nombres entiers sont représentés sans arrondi. Lorsqu'ils effectuent des calculs liés aux devises, les programmeurs convertissent souvent proportionnellement la valeur dans la plus petite unité monétaire avant d'effectuer le calcul, afin que le calcul puisse être effectué sous la forme d'un nombre entier. Par exemple, si le calcul ci-dessus est en dollars américains, nous pouvons le convertir en une représentation entière de centimes.

(10+20)+30; //60
10+ (20+30); //60

Pour les opérations sur les nombres entiers, vous n'avez pas à vous soucier des erreurs d'arrondi, mais vous devez quand même faire attention à ce que tous les calculs ne s'appliquent qu'aux nombres entiers de –253 à 253.

Conseils

• Les nombres JavaScript sont tous des nombres à virgule flottante double précision.
• Les entiers en JavaScript ne sont qu'un sous-ensemble de nombres à virgule flottante double précision, pas un type de données distinct
• Les opérateurs au niveau du bit traitent les nombres comme des entiers signés 32 bits.

Ce qui précède est l'introduction des nombres à virgule flottante dans JavaScript.Nous devons toujours faire attention aux pièges de précision dans les opérations à virgule flottante.J'espère que cet article sera utile à l'apprentissage de chacun.