Que se passe-t-il lorsque les opérations JavaScript perdent en précision ?

Dans la programmation quotidienne, nous utilisons souvent divers langages de programmation​​pour gérer diverses opérations numériques, parmi lesquelles JavaScript est sans aucun doute le plus utilisé. Cependant, lorsqu'il s'agit de calculs numériques complexes, dans certains cas extrêmes, nous pouvons rencontrer des situations dans lesquelles les résultats de l'opération perdent en précision. Alors pourquoi cela arrive-t-il ? Comment éviter la perte de précision des calculs ?

1. La raison de la perte de précision des opérations
   En JavaScript, l'une des principales raisons de la perte de précision des opérations est l'inexactitude des nombres à virgule flottante. Il n'existe qu'un seul type de nombre en JavaScript, le type Number, qui utilise une représentation numérique à virgule flottante de 64 bits. La valeur maximale pouvant être représentée est 1,7976931348623157e+308, et la valeur minimale est 5e-324. de décimales, nombres à virgule flottante La représentation binaire de ne peut souvent pas être représentée avec précision, ce qui entraîne une perte de précision. Jetez un œil à l'exemple suivant :

console.log(0.1 + 0.2); // 0.30000000000000004

Parce que le binaire ne peut pas représenter avec précision 0,1 et 0,2, le résultat de leur addition est inexact en JavaScript et il y a des chiffres supplémentaires après la virgule décimale.

2. Comment éviter la perte de précision des calculs
   Il existe de nombreuses façons d'éviter la perte de précision des calculs. Voici quelques méthodes courantes.

2.1 Utiliser des entiers pour le calcul
Lorsque nous effectuons des opérations complexes, nous pouvons convertir des décimales en nombres entiers pour le calcul, et enfin convertir les résultats en décimales. Par exemple, le code suivant peut multiplier respectivement 0,1 et 0,2 par 10, puis additionner les résultats et enfin diviser le résultat par 10 :

console.log((0.1 * 10 + 0.2 * 10) / 10); // 0.3

2.2 Utilisation de la fonction toFixed()
Le type Number en JavaScript fournit une méthode toFixed() qui convertit un nombre en décimal avec une précision spécifiée (le nombre de décimales placées entre parenthèses est conservé). Par exemple, dans le code suivant, la fonction toFixed() conservera deux décimales et obtiendra finalement un nombre à virgule flottante avec une précision de 0,30.

console.log((0.1 + 0.2).toFixed(2)); // 0.30

2.3 Extension de la précision
La précision des opérations en JavaScript peut être augmentée pour éviter la perte de précision. Une approche courante consiste à convertir la décimale en nombre entier, puis à effectuer le calcul. Une autre option consiste à utiliser la bibliothèque BigNumber en JavaScript. Cette bibliothèque fournit des types numériques de haute précision, ce qui peut grandement améliorer la précision des opérations. Par exemple, le code suivant peut utiliser la bibliothèque BigNumber pour résoudre le problème de perte de précision des opérations :

var BigNumber = require('bignumber.js');
var x = new BigNumber("0.1");
var y = new BigNumber("0.2");
console.log(x.plus(y).toString()); // "0.3"

Cet article résume les causes et les méthodes courantes d'évitement de la perte de précision des opérations en JavaScript. Lorsqu'il s'agit de calculs numériques complexes, nous devons analyser soigneusement des problèmes spécifiques, adopter des méthodes appropriées pour éviter toute perte de précision et garantir l'exactitude du programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!