关于JavaScript中计算精度丢失的问题（二）

转贴：http://rockyee.iteye.com/blog/891547

 

3.3 加减乘除
对指定数字进行四舍五入可以通过floor/ceil或者正则表达式达到舍入的目的，那么四则运算是不是也可以升级成计算机能够精确识别的整数来计算，计算完毕再降级呢？这个答案是肯定的，我们先来看看加法：

Js代码  

1. Number.prototype.add = function(arg)   
2. {   
3.     var n, n1, n2, s, s1, s2, ps;   
4.   
5.     s1 = this.toString();   
6.     ps = s1.split('.');   
7.     n1 = ps[1] ? ps[1].length : 0;   
8.   
9.     s2 = arg.toString();   
10.     ps = s2.split('.');   
11.     n2 = ps[1] ? ps[1].length : 0;   
12.   
13.     n = n1 > n2 ? n1 : n2;   
14.     s = Number(s1.movePoint(n)) + Number(s2.movePoint(n));   
15.     s = s.toString().movePoint(-n);   
16.     return Number(s);   
17. }  

Number.prototype.add = function(arg){    var n, n1, n2, s, s1, s2, ps;    s1 = this.toString();    ps = s1.split('.');    n1 = ps[1] ? ps[1].length : 0;    s2 = arg.toString();    ps = s2.split('.');    n2 = ps[1] ? ps[1].length : 0;    n = n1 > n2 ? n1 : n2;    s = Number(s1.movePoint(n)) + Number(s2.movePoint(n));    s = s.toString().movePoint(-n);    return Number(s);}

这时候再执行之前的加法
alert(Number(0.1).add(0.2));//弹出0.3
这时候就可以计算出精确的结果了。
类似可以写出减法：

Js代码  

1. Number.prototype.sub = function(arg)   
2. {   
3.     var n, n1, n2, s, s1, s2, ps;   
4.   
5.     s1 = this.toString();   
6.     ps = s1.split('.');   
7.     n1 = ps[1] ? ps[1].length : 0;   
8.   
9.     s2 = arg.toString();   
10.     ps = s2.split('.');   
11.     n2 = ps[1] ? ps[1].length : 0;   
12.   
13.     n = n1 > n2 ? n1 : n2;   
14.     s = Number(s1.movePoint(n)) - Number(s2.movePoint(n));   
15.     s = s.toString().movePoint(-n);   
16.     return Number(s);   
17. }  

Number.prototype.sub = function(arg){    var n, n1, n2, s, s1, s2, ps;    s1 = this.toString();    ps = s1.split('.');    n1 = ps[1] ? ps[1].length : 0;    s2 = arg.toString();    ps = s2.split('.');    n2 = ps[1] ? ps[1].length : 0;    n = n1 > n2 ? n1 : n2;    s = Number(s1.movePoint(n)) - Number(s2.movePoint(n));    s = s.toString().movePoint(-n);    return Number(s);}

类似可以写出乘法：

Js代码  

1. Number.prototype.mul = function(arg)   
2. {   
3.     var n, n1, n2, s, s1, s2, ps;   
4.   
5.     s1 = this.toString();   
6.     ps = s1.split('.');   
7.     n1 = ps[1] ? ps[1].length : 0;   
8.   
9.     s2 = arg.toString();   
10.     ps = s2.split('.');   
11.     n2 = ps[1] ? ps[1].length : 0;   
12.   
13.     n = n1 + n2;   
14.     s = Number(s1.replace('.', '')) * Number(s2.replace('.', ''));   
15.     s = s.toString().movePoint(-n);   
16.     return Number(s);   
17. }  

Number.prototype.mul = function(arg){    var n, n1, n2, s, s1, s2, ps;    s1 = this.toString();    ps = s1.split('.');    n1 = ps[1] ? ps[1].length : 0;    s2 = arg.toString();    ps = s2.split('.');    n2 = ps[1] ? ps[1].length : 0;    n = n1 + n2;    s = Number(s1.replace('.', '')) * Number(s2.replace('.', ''));    s = s.toString().movePoint(-n);    return Number(s);}

类似可以写出除法：

Js代码  

1. Number.prototype.div = function(arg)   
2. {   
3.     var n, n1, n2, s, s1, s2, ps;   
4.   
5.     s1 = this.toString();   
6.     ps = s1.split('.');   
7.     n1 = ps[1] ? ps[1].length : 0;   
8.   
9.     s2 = arg.toString();   
10.     ps = s2.split('.');   
11.     n2 = ps[1] ? ps[1].length : 0;   
12.   
13.     n = n1 - n2;   
14.     s = Number(s1.replace('.', '')) / Number(s2.replace('.', ''));   
15.     s = s.toString().movePoint(-n);   
16.     return Number(s);   
17. }  

Number.prototype.div = function(arg){    var n, n1, n2, s, s1, s2, ps;    s1 = this.toString();    ps = s1.split('.');    n1 = ps[1] ? ps[1].length : 0;    s2 = arg.toString();    ps = s2.split('.');    n2 = ps[1] ? ps[1].length : 0;    n = n1 - n2;    s = Number(s1.replace('.', '')) / Number(s2.replace('.', ''));    s = s.toString().movePoint(-n);    return Number(s);}

重要提示：由于除法不能精确到几位小数，在计算完成的时候应根据需要进行适当的四舍五入，以避免产生精度差异。
4. 结论
由于计算机是用二进制来存储和处理数字，不能精确表示浮点数，因此这种精度差异几乎出现在所有的编程语言中（例如C/C++/C#,Java），准确的说：“使用了IEEE 754浮点数格式”来存储浮点类型(float 32,double 64)的任何编程语言都有这个问题！而C#、Java是因为提供了封装类decimal、BigDecimal来进行相应的处理才避开了这个精度差异。
为了避免产生精度差异，把需要计算的数字全升级（乘以10的n次幂）成计算机能够精确识别的整数，等计算完毕再降级（除以10的n次幂），这是大部分编程语言处理精度差异的通用方法。