解决JS浮点数(小数)计算加减乘除的BUG 

    1. /**
    2.  ** 加法函数，用来得到精确的加法结果
    3.  ** 说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
    4.  ** 调用：accAdd(arg1,arg2)
    5.  ** 返回值：arg1加上arg2的精确结果
    6.  **/
    7. function accAdd(arg1, arg2) {
    8.     var r1, r2, m, c;
    9.     try {
    10.         r1 = arg1.toString().split(".")[1].length;
    11.     }
    12.     catch (e) {
    13.         r1 = 0;
    14.     }
    15.     try {
    16.         r2 = arg2.toString().split(".")[1].length;
    17.     }
    18.     catch (e) {
    19.         r2 = 0;
    20.     }
    21.     c = Math.abs(r1 - r2);
    22.     m = Math.pow(10, Math.max(r1, r2));
    23.     if (c > 0) {
    24.         var cm = Math.pow(10, c);
    25.         if (r1 > r2) {
    26.             arg1 = Number(arg1.toString().replace(".", ""));
    27.             arg2 = Number(arg2.toString().replace(".", "")) * cm;
    28.         } else {
    29.             arg1 = Number(arg1.toString().replace(".", "")) * cm;
    30.             arg2 = Number(arg2.toString().replace(".", ""));
    31.         }
    32.     } else {
    33.         arg1 = Number(arg1.toString().replace(".", ""));
    34.         arg2 = Number(arg2.toString().replace(".", ""));
    35.     }
    36.     return (arg1 + arg2) / m;
    37. }

    减法函数，用来得到精确的减法结果

    1. /**
    2.  ** 减法函数，用来得到精确的减法结果
    3.  ** 说明：javascript的减法结果会有误差，在两个浮点数相减的时候会比较明显。这个函数返回较为精确的减法结果。
    4.  ** 调用：accSub(arg1,arg2)
    5.  ** 返回值：arg1加上arg2的精确结果
    6.  **/
    7. function accSub(arg1, arg2) {
    8.     var r1, r2, m, n;
    9.     try {
    10.         r1 = arg1.toString().split(".")[1].length;
    11.     }
    12.     catch (e) {
    13.         r1 = 0;
    14.     }
    15.     try {
    16.         r2 = arg2.toString().split(".")[1].length;
    17.     }
    18.     catch (e) {
    19.         r2 = 0;
    20.     }
    21.     m = Math.pow(10, Math.max(r1, r2)); //last modify by deeka //动态控制精度长度
    22.     n = (r1 >= r2) ? r1 : r2;
    23.     return ((arg1 * m - arg2 * m) / m).toFixed(n);
    24. }

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

    1. /**
    2.  ** 乘法函数，用来得到精确的乘法结果
    3.  ** 说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
    4.  ** 调用：accMul(arg1,arg2)
    5.  ** 返回值：arg1乘以 arg2的精确结果
    6.  **/
    7. function accMul(arg1, arg2) {
    8.     var m = 0, s1 = arg1.toString(), s2 = arg2.toString();
    9.     try {
    10.         m += s1.split(".")[1].length;
    11.     }
    12.     catch (e) {
    13.     }
    14.     try {
    15.         m += s2.split(".")[1].length;
    16.     }
    17.     catch (e) {
    18.     }
    19.     return Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m);
    20. }

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

    1. /** 
    2.  ** 除法函数，用来得到精确的除法结果
    3.  ** 说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。
    4.  ** 调用：accDiv(arg1,arg2)
    5.  ** 返回值：arg1除以arg2的精确结果
    6.  **/
    7. function accDiv(arg1, arg2) {
    8.     var t1 = 0, t2 = 0, r1, r2;
    9.     try {
    10.         t1 = arg1.toString().split(".")[1].length;
    11.     }
    12.     catch (e) {
    13.     }
    14.     try {
    15.         t2 = arg2.toString().split(".")[1].length;
    16.     }
    17.     catch (e) {
    18.     }
    19.     with (Math) {
    20.         r1 = Number(arg1.toString().replace(".", ""));
    21.         r2 = Number(arg2.toString().replace(".", ""));
    22.         return (r1 / r2) * pow(10, t2 - t1);
    23.     }
    24. }

    来源：https://segmentfault.com/a/1190000000324193