Explication détaillée des problèmes de multiplication et de division du point décimal dans les compétences javascript(js)_javascript

1. Utilisez js pour calculer
12.32 * 7 Quel est le résultat ? Réponse : 86.24000000000001

Pourquoi ce problème se produit-il ? Comment le résoudre ?
Il y a un bug dans js lors du traitement de la multiplication et de la division des décimales. La solution peut être : convertir les décimales en entiers pour le traitement.
Le calcul ci-dessus peut être modifié en :
12,32 * 100 * 7 /100
Le résultat est : 86,24, correct.

Calculez également :
8,80 * 100 * 12 / 100
Résultat : 105,60000000000002
38,80 Des problèmes similaires se produiront également.

Précision augmentée de 10 fois :
8,80 * 1000 * 12/1000
Résultat : 105,6
Normal.

16.40 * 1000000 * 6/1000000
Le résultat est également problématique

Afin de rendre l'exécution de js plus précise, dans le futur calcul décimal de js, augmentez directement la valeur de 10 000 fois, puis divisez par 10 000 pour résoudre le problème.
var num = 38.80;
var num2 = 13;
alerte(num * 10000 * 12 / 10000);

Après les tests, 10 000 est le nombre le plus approprié pour être multiplié et divisé. S'il est plus petit, certains nombres poseront des problèmes, et s'il est plus grand (1 000 000), certains nombres poseront également des problèmes.

2.

Copiez le code Le code est le suivant :

Cette solution est plus gênante, mais elle peut vous donner une idée générale de la façon de résoudre ce problème.

Copier le code Le code est le suivant :

//Fonction de division, utilisée pour obtenir de la précision résultats de division
//Remarque : le résultat de division de JavaScript comportera des erreurs, qui seront plus évidentes lors de la division de deux nombres à virgule flottante. Cette fonction renvoie un résultat de division plus précis.
//Appel : accDiv(arg1,arg2)
//Valeur de retour : le résultat exact de la division arg1 par arg2
fonction accDiv(arg1,arg2){
var t1=0,t2= 0 ,r1,r2;
essayer{t1=arg1.toString().split(".")[1].length}catch(e){}
essayer{t2=arg2.toString(). split ("".")[1].length}catch(e){}
with(Math){
r1=Number(arg1.toString().replace(".",""))
r2=Number(arg2.toString().replace(".",""))
return (r1/r2)*pow(10,t2-t1);
}
}

//Ajoutez une méthode div au type Number pour rendre l'appel plus pratique.
Number.prototype.div = function (arg){
return accDiv(this, arg);
}

//Fonction de multiplication, utilisée pour obtenir des résultats de multiplication précis
//Explication : Le résultat de multiplication de JavaScript aura des erreurs, qui seront plus évidentes lorsque deux nombres à virgule flottante sont multipliés. 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){}
retour Numéro(s1.replace(".",""))*Nombre(s2.replace(".", " "))/Math.pow(10,m)
>

// Ajoutez une méthode mul au type Number pour rendre l'appel plus pratique.
Number.prototype.mul = function (arg){
return accMul(arg, this);
}

//Fonction d'addition, utilisée pour obtenir des résultats d'addition précis
//Explication : Le résultat de l'addition de JavaScript aura des erreurs, qui seront plus évidentes 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 arg1 plus arg2
fonction 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))
return (arg1*m arg2*m)/ m
}

//Ajoutez une méthode d'ajout au type Numéro pour rendre l'appel plus pratique.
Number.prototype.add = function (arg){
return accAdd(arg,this);
}