Solution au problème des décimales principalement dans les opérations décimales JS

Écrit dans les mots précédents:

Aujourd'hui, j'ai aidé mon collègue à résoudre un problème, c'est-à-dire qu'il existe de nombreuses décimales qui apparaissent lors de la multiplication des décimales. J'ai déjà rencontré ce problème, donc je vais le résumer spécifiquement;

Type de numéro:

Le type de nombre est le type le plus couramment utilisé et le plus intéressant dans ECMAScript; Ce type utilise le format IEEEE754 pour représenter les entiers et les valeurs à virgule flottante (les valeurs de point flottantes sont également des valeurs de double précision dans certaines langues). Pour prendre en charge divers types de données, ECMA-262 définit différents formats de surface numérique.

Décimal:

var intnum = 10; //Entier

Octal:

var octalnum1 = 070; // octal 56

var octalnum2 = 079; // Résolu de valeur octale non valide comme 79

Les littéraux octaux ne sont pas valides en mode strict;

hexadécimal:

var hexnum1 = 0xa; // 10

N'oubliez pas: lors de l'exécution d'opérations, toutes les valeurs exprimées en octal et hexadécimal sont finalement converties en décimales;

Pourquoi le fonctionnement des décimales a-t-il des erreurs?

Le progrès le plus élevé d'une valeur à virgule flottante est une décimale à 17 chiffres, mais sa précision est bien inférieure à celle d'un entier lors de l'exécution d'opérations; Les entiers seront convertis en décimaux lors de l'exécution d'opérations; Et lors du calcul des opérations décimales dans Java et JavaScript, les décimales se sont d'abord converties en binaire correspondant, et certaines décimales ne peuvent pas être complètement converties en binaire, de sorte que la première erreur se produit ici. Après que toutes les décimales sont converties en binaire, les opérations binaires sont effectuées pour obtenir le résultat binaire. Convertissez ensuite le résultat binaire en décimal, et la deuxième erreur se produit généralement ici.

Donc (0,1 + 0,2)! = 03

Solution:

Code de programme

Fonction de division pour obtenir des résultats de division précis

Remarque: il y aura des erreurs dans le résultat de la division de JavaScript, qui sera plus évidente lors de la division de deux nombres de points flottants. Cette fonction renvoie un résultat de division plus précis.

Appel: AccDiv (Arg1, Arg2)

Valeur de retour: le résultat exact de Arg1 divisé par Arg2

 fonction accdiv (arg1, arg2) {var t1 = 0, t2 = 0, r1, r2; try {t1 = arg1.toString (). Split (".") [1] .length} catch (e) {} try {t2 = arg2.ToString (). Split (".") [1] .Length} catch (e) {} avec (math) {r1 = nombre (arg1.tostring (). r2 = nombre (arg2

L'ajout d'une méthode div au type de nombre est plus pratique à appeler.

 Number.prototype.div = fonction (arg) {return accdiv (this, arg); }

Fonction de multiplication pour obtenir des résultats de multiplication précis

Remarque: il y aura des erreurs dans le résultat de la multiplication de JavaScript, qui sera plus évidente lors de la multiplication de deux nombres de points flottants. Cette fonction renvoie un résultat de multiplication plus précis.

Appel: Accmul (Arg1, Arg2)

Valeur de retour: le résultat exact de Arg1 multiplié par Arg2

 fonction accmul (arg1, arg2) {var m = 0, s1 = arg1.toString (), s2 = arg2.ToString (); try {m + = s1.split (".") [1] .length} catch (e) {} try {m + = s2.split (".") [1] .length} catch (e) {} return numéro (s1.replace (".", ")) * numéro (s2.replace (". ",")) / math.pow (10, m)}

L'ajout d'une méthode MUL au type de nombre est plus pratique à appeler.

 Nombre.prototype.mul = fonction (arg) {return accmul (arg, this);}

Fonction d'addition pour obtenir des résultats d'ajout précis

Remarque: il y aura des erreurs dans le résultat d'addition de JavaScript, qui sera plus évidente lors de l'ajout de deux numéros de point flottants. Cette fonction renvoie un résultat d'addition plus précis.

Appel: Accadd (Arg1, Arg2)

Valeur de retour: le résultat exact de Arg1 plus Arg2

 fonction acadd (arg1, arg2) {var r1, r2, m; try {r1 = arg1.toString (). Split (".") [1] .length} catch (e) {r1 = 0} try {r2 = arg2 (arg1 * m + arg2 * m) / m}

Ajoutez une méthode Ajouter au type de nombre, ce qui le rend plus pratique à appeler.

 Nombre.prototype.add = fonction (arg) {return Accadd (arg, this);}

Incluez ces fonctions où vous souhaitez utiliser, puis appelez-la pour calculer.

Par exemple, si vous souhaitez calculer: 7 * 0,8, changez-le en (7) .mul (8)

D'autres opérations sont similaires et des résultats plus précis peuvent être obtenus.

Solution 2:

Les méthodes les plus couramment utilisées, les méthodes Tofixed () et TofixEd () peuvent arrondir le nombre en nombres avec un nombre décimal spécifié. L'ajout de cette méthode après nos résultats de calcul est OK; Mais cela aura un léger impact sur la précision. Si les exigences de précision ne sont pas élevées, il est recommandé de l'utiliser;