The processing method of error of JavaScript decimal multiplication result _javascript skill

First, with JS calculation

12.32 * 7 How much is the result?
Answer: 86.24000000000001

Why is there such a problem? How to solve?
JS in processing decimal multiplication and division of the time there is a bug, the solution can be: The decimal into an integer to deal with.
The above calculation can be read as follows:
12.32 * 100 * 7/100
The result is: 86.24, correct.

In addition, calculate again:
8.80 * 100 * 12/100
Results: 105.60000000000002
A similar problem can occur in 38.80.

Increased accuracy by 10 times times:
8.80 * 1000 * 12/1000
Results: 105.6
It's normal.

16.40 * 1000000 * 6/1000000
The results are also problematic

In order to allow JS to perform more accurately, in the next JS decimal calculation directly to expand the value of 10,000 times times, and then divided by 10000, you can solve the problem.
var num = 38.80;
var num2 = 13;
Alert (NUM * 10000 * 12/10000);

The number multiplied and removed was tested 10000 most appropriate, small some numbers out of the question, big (1000000) some numbers are also problematic.

Two

<script>
number.prototype.rate=function () {
varostr=this.tostring ();
if (Ostr.indexof (".") ==-1)
return1;
else
Returnmath.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));
 
</script>

The solution is a tricky one, but it gives you an idea of the actual process of solving the problem.

The Division function, which is used to get the exact division result//Description: JavaScript division results will have errors, it is more obvious when dividing two floating-point numbers.
This function returns a more precise division result. Call: Accdiv (ARG1,ARG2)//return value: Arg1 divided by arg2 exact result function 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) {} with (Math) {R1=number (arg1.tostring (). Replace (".", ")) R2=number (Arg2.tostring (). Replace (". "
, "")) return (R1/R2) *pow (10,T2-T1);
}}//Add a Div method to the number type, which is more convenient to call.
 
Number.prototype.div = function (ARG) {return Accdiv (this, arg);} multiplication function, to get the exact result of multiplication//description: JavaScript multiplication results will have errors, the two floating-point numbers are more obvious when multiplying.
This function returns a more accurate result of the multiplication. Call: Accmul (ARG1,ARG2)//return value: Arg1 times Arg2 's exact result function 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 Number (S1.replace (".", "")) *number (S2.replace (".", ""))/math.pow (10,M)}//
Adding a Mul method to the number type is more convenient to call.
 
Number.prototype.mul = function (ARG) {return Accmul (ARG, this);} An additive function that is used to obtain an exact addition knot.Fruit//Description: JavaScript addition results will be error, in two floating-point number added when it is more obvious.
This function returns a more precise addition result. Call: Accadd (ARG1,ARG2)//return value: Arg1 plus arg2 exact result function 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)///+ Adds an Add method to the number type, which is easier to invoke. Number.prototype.add = function (ARG) {return accadd (arg,this);}

Above this javascript decimal multiplication error processing method is small series to share all the content, hope to give you a reference, but also hope that we support cloud habitat community.