JS的乘、除、加、减法结果会有误差，在两个浮点数相乘的时候会比较明显

问题：

　　37.5*5.5=206.08 (JS算出来是这样的一个结果，我四舍五入取两位小数)
　　我先怀疑是四舍五入的问题，就直接用JS算了一个结果为：206.08499999999998
　　怎么会这样，两个只有一位小数的数字相乘，怎么可能多出这么小数点出来。
　　我Google了一下，发现原来这是JavaScript浮点运算的一个bug。
　　比如：7*0.8 JavaScript算出来就是：5.6000000000000005

 

[csharp] view plain copy

1. //乘法函数，用来得到精确的乘法结果  
2.     //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。  
3.     //调用：accMul(arg1,arg2)  
4.     //返回值：arg1乘以arg2的精确结果  
5.     function accMul(arg1,arg2)  
6.     {  
7.        var m=0,s1=arg1.toString(),s2=arg2.toString();  
8.        try  
9.        {  
10.            m+=s1.split(".")[1].length  
11.              
12.        }  
13.        catch(e)  
14.        {}  
15.        try  
16.        {  
17.            m+=s2.split(".")[1].length  
18.        }  
19.        catch(e)  
20.        {}  
21.        return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)  
22.     }  
23.   
24.     //给Number类型增加一个mul方法，调用起来更加方便。  
25.     Number.prototype.mul = function (arg)  
26.     {  
27.       return accMul(arg, this);  
28.     }  
29.      
30.     //除法函数，用来得到精确的除法结果  
31.     //说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。  
32.     //调用：accDiv(arg1,arg2)  
33.     //返回值：arg1除以arg2的精确结果  
34.       
35.     function accDiv(arg1,arg2)  
36.     {  
37.       var t1=0,t2=0,r1,r2;  
38.       try  
39.       {  
40.          t1=arg1.toString().split(".")[1].length  
41.       }  
42.       catch(e)  
43.       {}  
44.       try  
45.       {  
46.          t2=arg2.toString().split(".")[1].length  
47.       }  
48.       catch(e)  
49.       {}  
50.       with(Math)  
51.       {  
52.          r1=Number(arg1.toString().replace(".",""))  
53.          r2=Number(arg2.toString().replace(".",""))  
54.          return (r1/r2)*pow(10,t2-t1);  
55.       }  
56.     }  
57.   
58.     //给Number类型增加一个div方法，调用起来更加方便。  
59.     Number.prototype.div = function (arg)  
60.     {  
61.       return accDiv(this, arg);  
62.     }  
63.   
64.     //加法函数，用来得到精确的加法结果  
65.     //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。  
66.     //调用：accAdd(arg1,arg2)  
67.     //返回值：arg1加上arg2的精确结果  
68.       
69.     function accAdd(arg1,arg2)  
70.     {  
71.       var r1,r2,m;  
72.       try  
73.       {  
74.          r1=arg1.toString().split(".")[1].length  
75.       }  
76.       catch(e)  
77.       {  
78.          r1=0  
79.       }  
80.       try  
81.       {  
82.          r2=arg2.toString().split(".")[1].length  
83.       }  
84.       catch(e)  
85.       {  
86.          r2=0  
87.       }  
88.       m=Math.pow(10,Math.max(r1,r2))  
89.       return (arg1*m+arg2*m)/m  
90.     }  
91.   
92.     //给Number类型增加一个add方法，调用起来更加方便。  
93.     Number.prototype.add = function (arg)  
94.     {  
95.       return accAdd(arg,this);  
96.     }  

[csharp] view plain copy

1.    

[csharp] view plain copy

1. <p>    //减法函数，用来得到精确的减法结果   
2.     //说明：javascript的减法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的减法结果。   
3.     //调用：accSub(arg1,arg2)   
4.     //返回值：arg1减去arg2的精确结果   
5.       
6.     function accSub(arg1,arg2)  
7.     {  
8.      var r1,r2,m,n;  
9.      try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}  
10.      try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}  
11.      m=Math.pow(10,Math.max(r1,r2));  
12.      //last modify by deeka  
13.      //动态控制精度长度  
14.      n=(r1>=r2)?r1:r2;  
15.      return ((arg2*m-arg1*m)/m).toFixed(n);  
16.     }</p><p>    //给Number类型增加一个add方法，调用起来更加方便。  
17.     Number.prototype.sub = function (arg)  
18.     {  
19.       return accSub(arg,this);  
20.     }</p><p> </p><p>比如你要计算：12*0.95 ，则改成  (12).mul(0.95) ;   
21.             12/0.95,  则改成  (12).div(0.95) ;  
22.             12+0.95,  则改成  (12).add(0.95)   
23.             12-0.95,  则改成  (12).sub(0.95)</p><p> </p>  

     在你要用的地方包含这些函数，然后调用它来计算就可以了。
　　比如你要计算：7*0.8 ，则改成 (7).mul(8)  
　　其它运算类似，就可以得到比较精确的结果。

看了很多关于解决javacsript浮点计算BUG办法，这个算是比较不错的了。但最终测试发现，加法还是有BUG

accAdd(0.0192, 0.12965)计算出来的结果0.14884999999999998，仍然存在问题。经过冷凝改写JS后，完美解决加法问题。

代码如下:

[csharp] view plain copy

1. /** 
2. * javascript calc 
3. *  
4. * 描  述   :  JS浮点计算BUG屏蔽 
5. * 创建人   :  冷凝 
6. * 创建日期 :  2012-12-21更新，解决触发部分BUG 
7. *  
8. */  
9.   
10. function accDiv(arg1, arg2) {  
11.   
12.     var t1 = 0, t2 = 0, t3 = 0, r1, r2;  
13.   
14.     try { t1 = arg1.toString().split(".")[1].length } catch (e) { }  
15.   
16.     try { t2 = arg2.toString().split(".")[1].length } catch (e) { }  
17.   
18.     r1 = Number(arg1.toString().replace(".", ""))  
19.   
20.     r2 = Number(arg2.toString().replace(".", ""))  
21.   
22.     if (r2 == 0)  
23.         return 0;  
24.   
25.     var result = String(r1 / r2);  
26.   
27.     try { t3 = result.toString().split(".")[1].length } catch (e) { }  
28.   
29.     var index = t2 - t1 - t3;  
30.   
31.     if (index < 0) {  
32.         result = result.replace(".", "");  
33.   
34.         while (result.length <= Math.abs(index)) {  
35.             result = '0' + result;  
36.         }  
37.   
38.         var start = result.substring(0, result.length + index);  
39.         var end = result.substring(result.length + index, result.length);  
40.   
41.         result = start + '.' + end;  
42.   
43.         return Number(result);  
44.     }  
45.     else if (index > 0) {  
46.         result = result.replace(".", "");  
47.   
48.         while (result.length <= Math.abs(index)) {  
49.             result += '0';  
50.         }  
51.         return Number(result);  
52.     }  
53.     else return Number(result.replace(".", ""));  
54.   
55. }  
56.   
57.   
58. //给Number类型增加一个div方法，调用起来更加方便。  
59.   
60. Number.prototype.div = function (arg) {  
61.     /// <summary>  
62.     ///     除法  
63.     /// </summary>  
64.     return accDiv(this, arg);  
65.   
66. }  
67. function accMul(arg1, arg2) {  
68.   
69.     var m = 0, s1 = arg1.toString(), s2 = arg2.toString();  
70.   
71.     try { m += s1.split(".")[1].length } catch (e) { }  
72.   
73.     try { m += s2.split(".")[1].length } catch (e) { }  
74.   
75.     return Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m)  
76.   
77. }  
78.   
79. Number.prototype.mul = function (arg) {  
80.     /// <summary>  
81.     ///     乘法  
82.     /// </summary>  
83.     return accMul(arg, this);  
84.   
85. }  
86.   
87. function accAdd(arg1, arg2) {  
88.   
89.     var r1, r2, m, c;  
90.   
91.     try { r1 = arg1.toString().split(".")[1].length } catch (e) { r1 = 0 }  
92.   
93.     try { r2 = arg2.toString().split(".")[1].length } catch (e) { r2 = 0 }  
94.   
95.     c = Math.abs(r1 - r2);  
96.     m = Math.pow(10, Math.max(r1, r2))  
97.     if (c > 0) {  
98.         var cm = Math.pow(10, c);  
99.         if (r1 > r2) {  
100.             arg1 = Number(arg1.toString().replace(".", ""));  
101.             arg2 = Number(arg2.toString().replace(".", "")) * cm;  
102.         }  
103.         else {  
104.             arg1 = Number(arg1.toString().replace(".", "")) * cm;  
105.             arg2 = Number(arg2.toString().replace(".", ""));  
106.         }  
107.     }  
108.     else {  
109.         arg1 = Number(arg1.toString().replace(".", ""));  
110.         arg2 = Number(arg2.toString().replace(".", ""));  
111.     }  
112.     return (arg1 + arg2) / m  
113.   
114. }  
115.   
116. Number.prototype.add = function (arg) {  
117.     /// <summary>  
118.     ///     加法  
119.     /// </summary>  
120.     return accAdd(arg, this);  
121.   
122. }