• /除法函数，用来得到精确的除法结果
• //说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。
• //调用：accDiv(arg1,arg2)
• //返回值：arg1除以arg2的精确结果
• function
• var
• try{t1=arg1.toString().split(".")[1].length}catch(e){}
• try{t2=arg2.toString().split(".")[1].length}catch(e){}
• with(Math){
• ".",""));
• ".",""));
• return
• }
• }
• //给Number类型增加一个div方法，调用起来更加方便。
• Number.prototype.div = function
• return accDiv(this, arg);
• };
• //乘法函数，用来得到精确的乘法结果
• //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
• //调用：accMul(arg1,arg2)
• //返回值：arg1乘以arg2的精确结果
• function
• {
• var
• 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
• return accMul(arg, this);
• };
• //加法函数，用来得到精确的加法结果
• //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
• //调用：accAdd(arg1,arg2)
• //返回值：arg1加上arg2的精确结果
• function
• var
• 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
• }
• //给Number类型增加一个add方法，调用起来更加方便。
• Number.prototype.add = function
• return accAdd(arg,this);
• }
• //减法函数
• function
• var
• 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
• }
• ///给number类增加一个sub方法，调用起来更加方便
• Number.prototype.sub = function
• return accSub(arg,this);
• }
JavaScript小数在做四则运算时，精度会丢失，这会在项目中引起诸多不便，先请看下面脚本：
Js代码
1. <script type="text/javascript" language="javascript">
2. //弹出: 0.3333333333333333
3. //弹出: 0.09999999999999999
4. //弹出: -0.09999999999999999
5. //弹出: 1.2344999999999999e-8
6. //弹出: 0.009999999999999998
7. </script>
按正常计算的话，除第一行外(因为其本身就不能除尽)，其他都应该要得到精确的结果，从弹出的结果我们却发现不是我们想要的正确结果。为了解决浮点数运算不准确的问题，在运算前我们把参加运算的数先升级(10的X的次方)到整数，等运算完后再降级(0.1的X的次方)。现收集并整理贴于此，以备后用。
Js代码
1. //加法
2. Number.prototype.add = function(arg){
3. var
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. //减法
11. Number.prototype.sub = function
12. return this.add(-arg);
13. }
14.
15. //乘法
16. Number.prototype.mul = function
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. }
23.
24. //除法
25. Number.prototype.div = function
26. var
27. try{t1=this.toString().split(".")[1].length}catch(e){}
28. try{t2=arg.toString().split(".")[1].length}catch(e){}
29. with(Math){
30. this.toString().replace(".",""))
31. ".",""))
32. return
33. }
34. }
测试
Js代码
1. <script type="text/javascript" language="javascript">
2. //弹出: 0.1
3. //注意，如果是负数，一定要先使用Number转型，否则结果不正确
4. //弹出: -0.1
5. //弹出: 1.2345e-8
6. //弹出: 0.01
7. </script>
JS精度问题处理
1. /除法函数，用来得到精确的除法结果
2. //说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。
3. //调用：accDiv(arg1,arg2)
4. //返回值：arg1除以arg2的精确结果
5. function
6. var
7. try{t1=arg1.toString().split(".")[1].length}catch(e){}
8. try{t2=arg2.toString().split(".")[1].length}catch(e){}
9. with(Math){
10. ".",""));
11. ".",""));
12. return
13. }
14. }
15. //给Number类型增加一个div方法，调用起来更加方便。
16. Number.prototype.div = function
17. return accDiv(this, arg);
18. };
19. //乘法函数，用来得到精确的乘法结果
20. //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
21. //调用：accMul(arg1,arg2)
22. //返回值：arg1乘以arg2的精确结果
23. function
24. {
25. var
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
32. return accMul(arg, this);
33. };
34. //加法函数，用来得到精确的加法结果
35. //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
36. //调用：accAdd(arg1,arg2)
37. //返回值：arg1加上arg2的精确结果
38. function
39. var
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
44. }
45. //给Number类型增加一个add方法，调用起来更加方便。
46. Number.prototype.add = function
47. return accAdd(arg,this);
48. }
49. //减法函数
50. function
51. var
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
59. }
60. ///给number类增加一个sub方法，调用起来更加方便
61. Number.prototype.sub = function
62. return accSub(arg,this);
63. }本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
