1. Calculer avec js
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é comme suit :
12,32*100*7/100
Le résultat est : 86,24, correct.
Faites également quelques calculs :
8,80*100*12/100
Résultat : 105.60000000000002
Des problèmes similaires se produiront avec 38,80.
Précision augmentée de 10 fois :
8,80*1000*12/1000
Résultat : 105,6
C'est normal.
16,40 * 1 000 000 * 6 / 1 000 000
Il y a aussi un problème avec le résultat
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-la par 10 000 pour résoudre le problème.
varnum = 38,80 ;
var num2 = 13 ;
alerte (num * 10000 * 12/10000);
Le nombre à multiplier et à diviser a été testé et trouvé égal à 10 000. S'il est plus petit, certains nombres poseront des problèmes. S'il est plus grand (1 000 000), certains nombres poseront également des problèmes.
deux,
Copiez le code comme suit :
<script différé>
Numéro.prototype.rate=fonction(){
varoStr=this.toString();
if(oStr.indexOf(".")==-1)
retour1 ;
autre
returnMath.pow(10,parseInt(oStr.length-oStr.indexOf(".")-1));
}
fonctiontran(){
args=tran.arguments;
vartemp=1;
pour(i=0;i<args.length;i++)
temp*=args[i]*args[i].rate();
pour(i=0;i<args.length;i++)
temp/=args[i].rate();
température de retour
}
alerte(tran(11,22.9));
</script>
Cette solution est un peu plus lourde, mais elle vous donnera une idée du processus réel de résolution de ce problème.
Copiez le code comme suit :
//Fonction de division, utilisée pour obtenir des résultats de division précis
//Remarque : le résultat de la 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 renvoyée : le résultat exact de la division de arg1 par arg2
fonction accDiv(arg1,arg2){
vart1=0,t2=0,r1,r2;
essayez{t1=arg1.toString().split(".")[1].length}catch(e){}
essayez{t2=arg2.toString().split(".")[1].length}catch(e){}
avec(Mathématiques){
r1=Nombre(arg1.toString().replace(".",""))
r2=Nombre(arg2.toString().replace(".",""))
retourner (r1/r2)*pow(10,t2-t1);
}
}
//Ajoutez une méthode div au type Number pour le rendre plus pratique à appeler.
Number.prototype.div = fonction (arg){
return accDiv(this, arg);
}
//Fonction de multiplication, utilisée pour obtenir des résultats de multiplication précis
//Remarque : le résultat de la multiplication de JavaScript comportera 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 renvoyée : le résultat exact de la multiplication de arg1 par arg2
fonction accMul(arg1,arg2)
{
var m=0,s1=arg1.toString(),s2=arg2.toString();
essayer{m+=s1.split(".")[1].length}catch(e){}
essayer{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}
// Ajoutez une méthode mul au type Number pour le rendre plus pratique à appeler.
Number.prototype.mul = fonction (arg){
return accMul(arg, ceci);
}
//Fonction d'addition, utilisée pour obtenir des résultats d'addition précis
//Remarque : le résultat de l'ajout de JavaScript comportera 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 : accAjoute(arg1,arg2)
// Valeur de retour : le résultat exact de arg1 plus arg2
fonction accAdd(arg1,arg2){
varr1,r2,m;
essayez{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
essayez{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))
retour (arg1*m+arg2*m)/m
}
//Ajoutez une méthode add au type Number pour le rendre plus pratique à appeler.
Number.prototype.add = fonction (argument){
return accAdd(arg,this);
}