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小数在做四则运算时,精度会丢失,这会在项目中引起诸多不便,先请看下面脚本:

  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的次方)。现收集并整理贴于此,以备后用。

  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. }
  9. //减法
  10. Number.prototype.sub = function (arg){
  11. return this.add(-arg);
  12. }
  13. //乘法
  14. Number.prototype.mul = function (arg)
  15. {
  16. var m=0,s1=this.toString(),s2=arg.toString();
  17. try{m+=s1.split(".")[1].length}catch(e){}
  18. try{m+=s2.split(".")[1].length}catch(e){}
  19. return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
  20. }
  21. //除法
  22. Number.prototype.div = function (arg){
  23. var t1=0,t2=0,r1,r2;
  24. try{t1=this.toString().split(".")[1].length}catch(e){}
  25. try{t2=arg.toString().split(".")[1].length}catch(e){}
  26. with(Math){
  27. r1=Number(this.toString().replace(".",""))
  28. r2=Number(arg.toString().replace(".",""))
  29. return (r1/r2)*pow(10,t2-t1);
  30. }
  31. }
  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. }

上一篇:支持阻塞操作和轮询操作的globalfifo设备驱动代码分析以及测试代码


下一篇:Jfinal启动源码解读