js 浮点运算bug

js几个浮点运算的bug，比如6.9-1.1，7*0.8，2.1/0.3，2.2+2.1

实现思路

通过将浮点数放大倍数到整型(最后再除以相应倍数)，再进行运算操作，这样就能得到正确的结果了

比如：11*(22.9*10)/10

<script>    
            //除法函数，用来得到精确的除法结果 
            //说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。 
            //调用：2.1.div(0.3)     等于2.1 / 0.3 
            //返回值：this除以arg的精确结果
            //给Number类型增加一个div方法，调用起来更加方便。 
            Number.prototype.div = function(arg) {
                var t1 = 0,
                    t2 = 0,
                    r1, r2;
                try { t1 = this.toString().split(".")[1].length } catch(e) {}
                try { t2 = arg.toString().split(".")[1].length } catch(e) {}
                with(Math) {
                    r1 = Number(this.toString().replace(".", ""))
                    r2 = Number(arg.toString().replace(".", ""))
                    return(r1 / r2) * pow(10, t2 - t1);
                }
            }
            //乘法函数，用来得到精确的乘法结果 
            //说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。 
            //调用：7.0.mul(0.8)  等于7*0.8
            //返回值：this乘以arg的精确结果 
            //给Number类型增加一个mul方法，调用起来更加方便。 
            Number.prototype.mul = function(arg) {
                var m = 0,
                    s1 = this.toString(),
                    s2 = arg.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)
            }
            //加法函数，用来得到精确的加法结果 
            //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。 
            //调用： 2.2.add(2.1) 等于 2.2+2.1
            //返回值：this加上arg的精确结果 
            //给Number类型增加一个add方法，调用起来更加方便。 
            Number.prototype.add = function(arg) {
                var r1, r2, m;
                try { r1 = this.toString().split(".")[1].length } catch(e) { r1 = 0 }
                try { r2 = arg.toString().split(".")[1].length } catch(e) { r2 = 0 }
                m = Math.pow(10, Math.max(r1, r2))
                return(this * m + arg * m) / m    
            }
            //减法函数，用来得到精确的减法结果 
            //说明：javascript的减法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的减法结果。 
            //调用：6.9.subtr(1.1) 等于     6.9 - 1.1
            //返回值：this减去arg的精确结果 
            //给Number类型增加一个subtr 方法，调用起来更加方便。 
            Number.prototype.subtr = function(arg) {
                var r1, r2, m, n;
                try { r1 = this.toString().split(".")[1].length } catch(e) { r1 = 0 }
                try { r2 = arg.toString().split(".")[1].length } catch(e) { r2 = 0 }
                m = Math.pow(10, Math.max(r1, r2));
                //动态控制精度长度
                n = (r1 >= r2) ? r1 : r2;
                return((this * m - arg * m) / m).toFixed(n);
            }    
            console.log("6.9 - 1.1："+(6.9 - 1.1).toString());
            console.log("6.9.subtr(1.1)："+6.9.subtr(1.1));
            console.log("7*0.8："+(7*0.8).toString());
            console.log("7.0.mul(0.8)："+7.0.mul(0.8).toString());
            console.log("2.1/0.3："+(2.1/0.3));
            console.log("2.1.div(0.3)："+2.1.div(0.3));
            console.log("2.2+2.1："+(2.2+2.1).toString());
            console.log("2.2.add(2.1)："+2.2.add(2.1));
            //通过将浮点数放大倍数到整型(最后再除以相应倍数)，再进行运算操作，这样就能得到正确的结果了
            console.log(11*(22.9*10)/10);
        </script>