JS 精度问题处理

  • /除法函数，用来得到精确的除法结果 

  • //说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。 

  • //调用：accDiv(arg1,arg2) 

  • //返回值：arg1除以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); 

  •     }

  • }

  • //给Number类型增加一个div方法，调用起来更加方便。 

  • Number.prototype.div = function (arg){ 

  •     return accDiv(this, arg); 

  • };

  • //乘法函数，用来得到精确的乘法结果 

  • //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。 

  • //调用：accMul(arg1,arg2) 

  • //返回值：arg1乘以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); 

  • }

  • //给Number类型增加一个mul方法，调用起来更加方便。 

  • Number.prototype.mul = function (arg){ 

  •     return accMul(arg, this); 

  • };

  • //加法函数，用来得到精确的加法结果 

  • //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。 

  • //调用：accAdd(arg1,arg2) 

  • //返回值：arg1加上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; 

  • }

  • //给Number类型增加一个add方法，调用起来更加方便。 

  • Number.prototype.add = function (arg){ 

  •     return accAdd(arg,this); 

  • }

  • //减法函数 

  • 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 

  •      //动态控制精度长度 

  •      n=(r1>=r2)?r1:r2; 

  •      return ((arg2*m-arg1*m)/m).toFixed(n); 

  • }

  • ///给number类增加一个sub方法，调用起来更加方便 

  • Number.prototype.sub = function (arg){ 

  •     return accSub(arg,this); 

  • }

 

 

JavaScript小数在做四则运算时，精度会丢失，这会在项目中引起诸多不便，先请看下面脚本：

Js代码
  1. <script type="text/javascript" language="javascript">     
  2.     alert(1/3);//弹出: 0.3333333333333333  
  3.     alert(0.09999999 + 0.00000001);//弹出: 0.09999999999999999   
  4.     alert(-0.09999999 - 0.00000001);//弹出: -0.09999999999999999  
  5.     alert(0.012345 * 0.000001);//弹出: 1.2344999999999999e-8  
  6.     alert(0.000001 / 0.0001);//弹出: 0.009999999999999998  
  7. </script>   

按正常计算的话，除第一行外(因为其本身就不能除尽)，其他都应该要得到精确的结果，从弹出的结果我们却发现不是我们想要的正确结果。为了解决浮点数运算不准确的问题，在运算前我们把参加运算的数先升级(10的X的次方)到整数，等运算完后再降级(0.1的X的次方)。现收集并整理贴于此，以备后用。

Js代码
  1. //加法  
  2. Number.prototype.add = function(arg){  
  3.     var r1,r2,m;  
  4.     try{r1=this.toString().split(".")[1].length}catch(e){r1=0}  
  5.     try{r2=arg.toString().split(".")[1].length}catch(e){r2=0}  
  6.     m=Math.pow(10,Math.max(r1,r2))  
  7.     return (this*m+arg*m)/m  
  8. }  
  10. //减法  
  11. Number.prototype.sub = function (arg){  
  12.     return this.add(-arg);  
  13. }  
  15. //乘法  
  16. Number.prototype.mul = function (arg)  
  17. {  
  18.     var m=0,s1=this.toString(),s2=arg.toString();  
  19.     try{m+=s1.split(".")[1].length}catch(e){}  
  20.     try{m+=s2.split(".")[1].length}catch(e){}  
  21.     return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)  
  22. }  
  24. //除法  
  25. Number.prototype.div = function (arg){  
  26.     var t1=0,t2=0,r1,r2;  
  27.     try{t1=this.toString().split(".")[1].length}catch(e){}  
  28.     try{t2=arg.toString().split(".")[1].length}catch(e){}  
  29.     with(Math){  
  30.         r1=Number(this.toString().replace(".",""))  
  31.         r2=Number(arg.toString().replace(".",""))  
  32.         return (r1/r2)*pow(10,t2-t1);  
  33.     }  
  34. } 
测试
 
Js代码
  1. <script type="text/javascript" language="javascript">  
  2.    alert(Number(0.09999999).add(0.00000001));//弹出: 0.1  
  3.    //注意，如果是负数，一定要先使用Number转型，否则结果不正确  
  4.    alert(Number(-0.09999999).sub(0.00000001));//弹出: -0.1  
  5.    alert(Number(0.012345).mul(0.000001));//弹出: 1.2345e-8  
  6.    alert(Number(0.000001).div(0.0001));//弹出: 0.01  
  7. </script> 

 

 

 

 

 

JS精度问题处理

  1. /除法函数，用来得到精确的除法结果 

  2. //说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。 

  3. //调用：accDiv(arg1,arg2) 

  4. //返回值：arg1除以arg2的精确结果 

  5. function accDiv(arg1,arg2){ 

  6.     var t1=0,t2=0,r1,r2; 

  7.     try{t1=arg1.toString().split(".")[1].length}catch(e){} 

  8.     try{t2=arg2.toString().split(".")[1].length}catch(e){} 

  9.     with(Math){ 

  10.         r1=Number(arg1.toString().replace(".","")); 

  11.         r2=Number(arg2.toString().replace(".","")); 

  12.         return (r1/r2)*pow(10,t2-t1); 

  13.     }

  14. }

  15. //给Number类型增加一个div方法，调用起来更加方便。 

  16. Number.prototype.div = function (arg){ 

  17.     return accDiv(this, arg); 

  18. };

  19. //乘法函数，用来得到精确的乘法结果 

  20. //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。 

  21. //调用：accMul(arg1,arg2) 

  22. //返回值：arg1乘以arg2的精确结果 

  23. function accMul(arg1,arg2) 

  24. { 

  25.     var m=0,s1=arg1.toString(),s2=arg2.toString(); 

  26.     try{m+=s1.split(".")[1].length}catch(e){} 

  27.     try{m+=s2.split(".")[1].length}catch(e){} 

  28.     return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m); 

  29. }

  30. //给Number类型增加一个mul方法，调用起来更加方便。 

  31. Number.prototype.mul = function (arg){ 

  32.     return accMul(arg, this); 

  33. };

  34. //加法函数，用来得到精确的加法结果 

  35. //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。 

  36. //调用：accAdd(arg1,arg2) 

  37. //返回值：arg1加上arg2的精确结果 

  38. function accAdd(arg1,arg2){ 

  39.     var r1,r2,m; 

  40.     try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0} 

  41.     try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0} 

  42.     m=Math.pow(10,Math.max(r1,r2)); 

  43.     return (arg1*m+arg2*m)/m; 

  44. }

  45. //给Number类型增加一个add方法，调用起来更加方便。 

  46. Number.prototype.add = function (arg){ 

  47.     return accAdd(arg,this); 

  48. }

  49. //减法函数 

  50. function accSub(arg1,arg2){ 

  51.      var r1,r2,m,n; 

  52.      try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0} 

  53.      try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0} 

  54.      m=Math.pow(10,Math.max(r1,r2)); 

  55.      //last modify by deeka 

  56.      //动态控制精度长度 

  57.      n=(r1>=r2)?r1:r2; 

  58.      return ((arg2*m-arg1*m)/m).toFixed(n); 

  59. }

  60. ///给number类增加一个sub方法，调用起来更加方便 

  61. Number.prototype.sub = function (arg){ 

  62.     return accSub(arg,this); 

  63. }

posted on 2013-11-06 14:28  itjeff  阅读(1286)  评论(0)  编辑  收藏  举报

导航