在專案中計算商品價格的時候再次遇到js浮點數計算出現誤差的問題，以前一碰到這個問題就用tofixed方法進行處理一下，這對於一個程式設計師來說是及其不嚴謹的。

1、發現問題：

在測試js浮點數進行加減乘除計算時，都可能出現問題，如下：

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

2、不精準原因：

下面我們來說一下浮點數運算產生誤差的原因：（拿0.1+0.2=0.30000000000000004進行舉例）

首先，我們要站在計算機的角度思考 0.1 + 0.2 這個看似小兒科的問題。我們知道，能被計算機讀懂的是二進位制，而不是十進位制，所以我們先把 0.1 和 0.2 轉換成二進位制看看：  

0.1 => 0.0001 1001 1001 1001…（無限迴圈）

0.2 => 0.0011 0011 0011 0011…（無限迴圈）  

上面我們發現0.1和0.2轉化為二進位制之後，變成了一個無限迴圈的數字，這在現實生活中，無限迴圈我們可以理解，但計算機是不允許無限迴圈的，對於無限迴圈的小數，計算機會進行舍入處理。進行雙精度浮點數的小數部分最多支援 52 位，所以兩者相加之後得到這麼一串 0.0100110011001100110011001100110011001100110011001100 因浮點數小數位的限制而截斷的二進位制數字，這時候，我們再把它轉換為十進位制，就成了 0.30000000000000004。

3、解決辦法：

var floatObj = function () {

        /*
         * 判斷obj是否為一個整數
         */
        function isInteger(obj) {
            return Math.floor(obj) === obj
        }

        /*
         * 將一個浮點數轉成整數，返回整數和倍數。如 3.14 >> 314，倍數是 100
         * @param floatNum {number} 小數
         * @return {object}
         *   {times:100, num: 314}
         */
        function toInteger(floatNum) {
            var ret = {times: 1, num: 0};
            if (isInteger(floatNum)) {
                ret.num = floatNum;
                return ret
            }
            var strfi = floatNum + '';
            var dotPos = strfi.indexOf('.');
            var len = strfi.substr(dotPos + 1).length;
            var times = Math.pow(10, len);
            var intNum = parseInt(floatNum * times + 0.5, 10);
            ret.times = times;
            ret.num = intNum;
            return ret
        }

        /*
         * 核心方法，實現加減乘除運算，確保不丟失精度
         * 思路：把小數放大為整數（乘），進行算術運算，再縮小為小數（除）
         *
         * @param a {number} 運算數1
         * @param b {number} 運算數2
         * @param op {string} 運算型別，有加減乘除（add/subtract/multiply/divide）
         *
         */
        function operation(a, b, op) {
            var o1 = toInteger(a);
            var o2 = toInteger(b);
            var n1 = o1.num;
            var n2 = o2.num;
            var t1 = o1.times;
            var t2 = o2.times;
            var max = t1 > t2 ? t1 : t2;
            var result = null;
            switch (op) {
                case 'add':
                    if (t1 === t2) { // 兩個小數位數相同
                        result = n1 + n2
                    } else if (t1 > t2) { // o1 小數位 大於 o2
                        result = n1 + n2 * (t1 / t2)
                    } else { // o1 小數位 小於 o2
                        result = n1 * (t2 / t1) + n2
                    }
                    return result / max;
                case 'subtract':
                    if (t1 === t2) {
                        result = n1 - n2
                    } else if (t1 > t2) {
                        result = n1 - n2 * (t1 / t2)
                    } else {
                        result = n1 * (t2 / t1) - n2
                    }
                    return result / max;
                case 'multiply':
                    result = (n1 * n2) / (t1 * t2);
                    return result;
                case 'divide':
                    result = (n1 / n2) * (t2 / t1);
                    return result
            }
        }

        // 加減乘除的四個介面
        function add(a, b) {
            return operation(a, b, 'add')
        }

        function subtract(a, b) {
            return operation(a, b, 'subtract')
        }

        function multiply(a, b) {
            return operation(a, b, 'multiply')
        }

        function divide(a, b) {
            return operation(a, b, 'divide')
        }

        // exports
        return {
            add: add,
            subtract: subtract,
            multiply: multiply,
            divide: divide
        }
    }();
 

呼叫方法：

console.log(floatObj.add(0.1, 0.2));//0.3
console.log(floatObj.subtract(1.0, 0.9));//0.1
console.log(floatObj.multiply(19.9, 100));//1990
console.log(floatObj.divide(6.6, 0.2));//33