1. Utilisez JS pour calculer
12.32 * 7 Quel est le résultat?
Réponse: 86.240000000000001
Pourquoi ce problème se produit-il? Comment le résoudre?
Il y a un bug lorsque JS traite de la multiplication et de la division des décimales. La solution peut être: transformer la décimale en entier pour le gérer.
Le calcul ci-dessus peut être modifié en:
12.32 * 100 * 7/100
Le résultat est: 86.24, correct.
Calculons-le à nouveau:
8,80 * 100 * 12/100
Résultat: 105.600000000000002
Des problèmes similaires se produiront à 38,80.
Augmenter la précision de 10 fois:
8,80 * 1000 * 12/1000
Résultats: 105.6
C'est normal.
16.40 * 1000000 * 6/1000000
Il y a des problèmes avec le résultat
Afin de rendre l'exécution JS plus précise, la valeur peut être directement élargie de 10 000 fois dans le calcul décimal JS ultérieur, puis divisé par 10 000 pour résoudre le problème.
var num = 38,80;
var num2 = 13;
alerte (num * 10000 * 12/10000);
Le nombre multiplié et divisé par 10 000 est le plus adapté aux tests. Certains chiffres ont des problèmes lorsqu'ils sont plus petits et que certains chiffres ont des problèmes lorsqu'ils sont plus grands (1000 000).
deux,
<cript> nombre.prototype.rate = function () {varoStr = this.toString (); if (ostr.indexof (".") == - 1) return1; elsereturnmath.pow (10, parseInt (ostr.length-ostr.indexof (".") - 1));} functiontran () {args = tran.arguments; vartemp = 1; for (i = 0; i <args.length; i ++) temp * = args [i] * args [i] .rate (); for (i = 0; i <args.length; i ++) temp / = args [i] .rate (); returnTemp} alert (tran (11,22.9); </cript>Cette solution est une solution plus lourde, mais elle peut vous donner une compréhension approximative du processus réel de résolution de ce problème.
// La fonction de division est utilisée pour obtenir des résultats de division précis // Remarque: Il y aura des erreurs dans le résultat de la division de JavaScript, ce qui sera plus évident 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 l'arg1 divisé par la fonction arg2 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] .leng th} catch (e) {} avec (math) {r1 = nombre (arg1.toString (). Remplace (".", ")) r2 = nombre (arg2.toString (). remplace (". ",")) (R1 / R2) * POW (10, T2-T1);}} // Ajoutez une méthode div au type de nombre, ce qui le rend plus pratique pour appeler. Number.prototype.div = fonction (arg) {return accdiv (this, arg);} // La fonction multiple est utilisée pour obtenir des résultats de multiplication précis // note: il y aura des erreurs dans les résultats de multiplication de JavaScript, qui sera plus évident lors de la multiplication de deux nombres à virgule flottante. 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 la fonction arg2 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 (retour Numéro (s1.replace (".", ")) * Numéro (s2.replace (". ",")) / Math.pow (10, m)} // ajouter une méthode MUL au type de nombre, ce qui est plus pratique à appeler. Number.prototype.mul = fonction (arg) {return accmul (arg, this);} // La fonction d'addition est utilisée pour obtenir des résultats supplémentaires précis // Remarque: il y aura des erreurs dans le résultat de JavaScript, qui sera plus évident lors de l'ajout de deux nombres à virgule flottante. Cette fonction renvoie un résultat d'addition plus précis. // Appel: Accadd (Arg1, Arg2) // Valeur de retour: le résultat exact de la fonction arg1 plus arg2 Accadd (arg1, arg2) {var r1, r2, m; try {r1 = arg1.toString (). Split (".") [1] .length} catch (e) {r1 = 0} try {r2 = arg2.tostring (). Split (".") [1] .length} catch (e) {r2 = 0} m = math.pow (10, math.max (r1, r2)) (Arg1 * M + Arg2 * M) / M} // Ajouter une méthode Ajouter au type de nombre, ce qui le rend plus pratique à appeler. Nombre.prototype.add = fonction (arg) {return Accadd (arg, this);}La gestion des erreurs du résultat de multiplication décimales JavaScript ci-dessus est tout le contenu que j'ai partagé avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.