A brief analysis of floating point arithmetic in js

How do we compute floating point in js?

For example, var a=0.69;

I want to get 6.9 let me just write it this way var c is equal to a times 10;

Alert (c);     The result: 6.8999999999999995

Search to the Internet, a netizen said that this is a JS floating point arithmetic Bug, found a solution:

Method 1: there are js custom functions

<script>
//The addition function, used to get accurate addition results
//Note: javascript addition results will have errors, in the two floating point Numbers will be more obvious when adding. This function returns a more accurate addition result.
//Call: accAdd (arg1, arg2)
//Return value: the exact result of arg1 plus arg2
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)/m 
} 
//Add an add method to the Number type to make it easier to call.
Number.prototype.add = function (arg){ 
return accAdd(arg,this); 
}
//The addition function, used to get accurate addition results
//Note: javascript addition results will have errors, in the two floating point Numbers will be more obvious when adding. This function returns a more accurate addition result.
//Call: accAdd (arg1, arg2)
//Return value: the exact result of arg1 plus arg2
function accSub(arg1,arg2){
    var r1,r2,m,n;
    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));
    //last modify by deeka
    //Dynamic control precision length
    n=(r1>=r2)?r1:r2;
    return ((arg1*m-arg2*m)/m).toFixed(n);
}
//Division function, used to get accurate division results
//Note: javascript division results will have errors, in two floating point division will be more obvious. This function returns a more precise division result.
//Call: accDiv (arg1, arg2)
//Return value: the exact result of arg1 divided by arg2
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 to make it easier to call.
Number.prototype.div = function (arg){ 
return accDiv(this, arg); 
} 
//The multiplication function, which is used to get exact multiplication results
//Note: javascript multiplication results will have errors, in the two floating point number multiplication will be more obvious. This function returns a more precise multiplication result.
//Call: accMul (arg1, arg2)
//Return value: the exact result of arg1 times arg2
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) 
} 
//Add a mul method to the Number type to make it easier to call.
Number.prototype.mul = function (arg){ 
return accMul(arg, this); 
} 
var a=0.69;
var b=10;
alert(a*b);//6.8999999999999995
alert((a*100)/10);
</script>

Just call the function directly.

Method 2: If you know the number of decimal places, you can think about doing the operation by enlarging the floating point number to the integer (and then dividing by the corresponding multiple), and then you can get the correct result