writefile function failed怎么解决_完美解决JS浮点型的运算精度问题

作者：姜治宇

转发链接：https://www.jianshu.com/p/d138e9ba4db9

精度问题

大家一定遇到过这种问题：

    console.log(0.1 + 0.2);//0.30000000000000004    console.log(2.22 + 0.1);// 2.3200000000000003    console.log(1.0 - 0.9);//0.09999999999999998    console.log(19.9 * 100);//1989.9999999999998    console.log(6.6 / 0.2);//32.99999999999999

这真是一个令人黯然蛋碎的bug，而且即使在es6时代依然没能解决，怎么办呢？只能靠自己了。 为什么出现这个问题呢？ 我们生活中用到的十进制计算，在计算机底层都会将其转为二进制运算。我们把0.1转为二进制，其实是： 0.1 => 0.0001 1001 1001 1001…(无限循环) 这就是浮点型数值计算不准确的原因。

解决方案

既然浮点型直接计算会出问题，那么我们就换种思路，可以将其先转为整型计算，然后再转回去。 比如0.1+0.2，我们完全可以先都扩大10倍，相加得3，然后除以10，不就得到0.3这个准确数值了么？ 根据这个思路，我们写出如下代码：

(function (Number) {    //加法    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)) // 按小数位多的那个扩大倍数        var a = this * m         var b = arg * m        return (a + b) / m    }})(Number)

代码很简单我们不做过多解释，直接看结果吧：

console.log(0.1 + 0.2) // 0.30000000000000004console.log((0.1).add(0.2)) // 0.3

ok,貌似大功告成啊？别着急，咱们再看个例子：

console.log(2.22 + 0.1) // 2.3200000000000003console.log((2.22).add(0.1)) // 2.3200000000000003

草草？神马情况这是？不科学啊~~ 其实我们忽略了一个重要问题，那就是——浮点乘法也会有精度问题！！

console.log(2.22*100) //222.00000000000003console.log(19.9 * 100);//1989.9999999999998

愁人不？太愁人了！！咋办呢？ 别急，有办法。 我们的目标，就是要保证扩大倍数后得到的整数一定要准确，我们是否可以通过parseInt函数，对乘法结果直接取整呢？ 如果是2.22x100，parseInt取整得到222，这是准确的；然鹅，19.9x100，取整就是1989，正确的结果应该是1990，这就不对了。 怎么就能让它对呢？ 咱们可以这样： 将乘法得到的数值，再加个0.5，然后再取整，以保障整数的准确。 为啥要加0.5呢？ 答案是：0.5会保证四舍五入。

    console.log(2.22*100+0.5) //222.50000000000003    console.log(19.9 * 100+0.5);//1990.4999999999998

这样一来，parseInt取整不就对了么。 好的，我们将之前的代码做一下修正：

    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))  // 取位数最大的那个        var a = parseInt(this * m + 0.5)        var b = parseInt(arg * m + 0.5)        return (a + b) / m    }

然后再看看结果：

    console.log(0.1 + 0.2);//0.30000000000000004    console.log(2.22 + 0.1);// 2.3200000000000003   console.log((0.1).add(0.2)) // 0.3   console.log((2.22).add(0.1)) // 2.32

好，下面我们继续把减法、乘法和除法都补全。 减法其实很简单，加一个负数不就是减法了嘛~~

    Number.prototype.sub = function (arg) {        return this.add(-arg);    }

然后是乘法。 乘法思路也很简单，比如3.15x7.2，其实可以这么计算： (315x72)/1000 对吧？ 也就是说，我们可以先去掉他们的小数点，先转为整数乘法，然后再将结果缩小n倍。 于是我们写出如下代码：

    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 // m是累加结果        } catch (e) {        }        return Number(s1.replace('.', '')) * Number(s2.replace('.', '')) / Math.pow(10, m) // 直接去掉小数点，转为整型计算，最后缩小n倍    }

最后是除法。 我们举个例子，比如：1.5/0.21，还记得小学除法老师是怎么教的来着？ 是不是把分子分母同时都扩大n倍，然后相除呢？也就是：150/21 但我们前面说过，浮点型直接扩大整数倍，也会产生精度问题，这个问题要注意。 好，顺着这个思路，我们可以轻松写出代码：

    Number.prototype.div = 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))        var a = parseInt(this * m + 0.5)        var b = parseInt(arg * m + 0.5)        return a/b    }

完整代码

(function (Number) {    //加法    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))        var a = parseInt(this * m + 0.5)        var b = parseInt(arg * m + 0.5)        return (a + b) / m    }//减法    Number.prototype.sub = function (arg) {        return this.add(-arg);    }//乘法    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 // m是累加结果        } catch (e) {        }        return Number(s1.replace('.', '')) * Number(s2.replace('.', '')) / Math.pow(10, m)    }//除法    Number.prototype.div = 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))        var a = parseInt(this * m + 0.5)        var b = parseInt(arg * m + 0.5)        return a/b    }})(Number)

作者：姜治宇
转发链接：https://www.jianshu.com/p/d138e9ba4db9