0.1 + 0.2 !== 0.3 大概是 JavaScript 面試中最常被問到的題目之一。它不是 bug,而是 IEEE-754 浮點標準的必然結果。本文說明成因,並整理判等與四則運算的實用解法。
JavaScript 只有一種數字型別 Number,所有數字都以 IEEE-754 標準的雙精度格式表示。問題的根源在於:有些小數用二進位表示時,位數是無限的。
十進制 二進位 0.1 0.0001 1001 1001 1001 … 0.2 0.0011 0011 0011 0011 … 0.3 0.0100 1100 1100 1100 … 0.4 0.0110 0110 0110 0110 … 0.5 0.1 0.6 0.1001 1001 1001 1001 …
只有 0.5 這種能被 2 的整數次方整除的數,才有精確的二進位表示。其餘的都被迫截斷,於是像 1.1 這樣的數字,程式實際上無法真正表示,只能做到一定程度上的接近(1.09999999999999999)。這是無法避免的精度損失。
以下是在 Chrome 中實測的結果:
console.log(1.0 - 0.9 == 0.1) // false console.log(1.0 - 0.8 == 0.2) // false console.log(1.0 - 0.7 == 0.3) // false console.log(1.0 - 0.6 == 0.4) // true console.log(1.0 - 0.5 == 0.5) // true console.log(1.0 - 0.4 == 0.6) // true console.log(1.0 - 0.3 == 0.7) // true console.log(1.0 - 0.2 == 0.8) // true console.log(1.0 - 0.1 == 0.9) // true
這個「有的對、有的不對」的散亂結果,正是浮點誤差的典型面貌——它取決於各個數字的二進位表示恰好往哪個方向偏。
要避免 1.0 - 0.9 != 0.1 這種「非 bug 型」的問題,一個常見做法是在比較前先縮小精度,因為縮小精度的過程會自動四捨五入:
(1.0 - 0.9).toFixed(digits) // toFixed() 的精度參數 digits 須在 0 與 20 之間 console.log(parseFloat((1.0 - 0.9).toFixed(10)) === 0.1) // true console.log(parseFloat((1.0 - 0.8).toFixed(10)) === 0.2) // true console.log(parseFloat((1.0 - 0.7).toFixed(10)) === 0.3) // true console.log(parseFloat((11.0 - 11.8).toFixed(10)) === -0.8) // true
封裝成工具函式:
//透過 isEqual 工具方法判斷數值是否相等
function isEqual(number1, number2, digits){
digits = digits == undefined ? 10 : digits; //預設精度為 10
return number1.toFixed(digits) === number2.toFixed(digits);
}
console.log(isEqual(1.0 - 0.7, 0.3)); // true
//原型擴充方式,更親向物件導向的風格
Number.prototype.isEqual = function(number, digits){
digits = digits == undefined ? 10 : digits; //預設精度為 10
return this.toFixed(digits) === number.toFixed(digits);
};
console.log((1.0 - 0.7).isEqual(0.3)); // true
ES6 之後還可以直接用 Number.EPSILON,它代表 1 與「比 1 大的最小可表示浮點數」之間的差值:
function isEqualEps(a, b){
return Math.abs(a - b) < Number.EPSILON;
}
console.log(isEqualEps(0.1 + 0.2, 0.3)); // true
這個做法比 toFixed 更貼近問題本質——它比較的是「差值是否小到可以忽略」,而不是依賴字串格式化。
console.log(1.79 + 0.12) // 1.9100000000000001 console.log(2.01 - 0.12) // 1.8899999999999997 console.log(1.01 * 1.3) // 1.3130000000000002 console.log(0.69 / 10) // 0.06899999999999999
核心思路是「先放大成整數運算,算完再縮回來」。
//加法函式,用來得到精確的加法結果
//說明:javascript 的加法結果會有誤差,兩個浮點數相加時特別明顯。
//呼叫:accAdd(arg1, arg2)
//回傳值:arg1 加上 arg2 的精確結果
function accAdd(arg1, arg2){
var r1, r2, m;
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 (arg1 * m + arg2 * m) / m;
}
//為 Number 型別增加 add 方法,呼叫更方便
Number.prototype.add = function (arg){
return accAdd(arg, this);
};
//減法函式
//呼叫:accSub(arg1, arg2)
//回傳值:arg1 減去 arg2 的精確結果
function accSub(arg1, arg2){
var r1, r2, m, n;
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));
//動態控制精度長度
n = (r1 >= r2) ? r1 : r2;
return ((arg1 * m - arg2 * m) / m).toFixed(n);
}
//除法函式
//呼叫:accDiv(arg1, arg2)
//回傳值:arg1 除以 arg2 的精確結果
function accDiv(arg1, arg2){
var t1 = 0, t2 = 0, r1, r2;
try { t1 = arg1.toString().split(".")[1].length } catch (e) {}
try { t2 = arg2.toString().split(".")[1].length } catch (e) {}
with(Math){
r1 = Number(arg1.toString().replace(".", ""));
r2 = Number(arg2.toString().replace(".", ""));
return (r1 / r2) * pow(10, t2 - t1);
}
}
Number.prototype.div = function (arg){
return accDiv(this, arg);
};
//乘法函式
//呼叫:accMul(arg1, arg2)
//回傳值:arg1 乘以 arg2 的精確結果
function accMul(arg1, arg2){
var m = 0, s1 = arg1.toString(), s2 = arg2.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);
}
Number.prototype.mul = function (arg){
return accMul(arg, this);
};
//驗證一下:
console.log(accAdd(1.79, 0.12)); // 1.91
console.log(accSub(2.01, 0.12)); // 1.89
console.log(accDiv(0.69, 10)); // 0.069
console.log(accMul(1.01, 1.3)); // 1.313
乘法最直觀:把兩個數的小數位數加總當作放大倍數的指數,去掉小數點後當整數相乘,最後再除回來。加減法則是取兩者中較大的小數位數統一放大。
with(Math) 不建議使用。 accDiv 中的 with 在嚴格模式下會直接報錯,且會拖慢作用域解析。改成直接寫 Math.pow(10, t2 - t1) 即可。try/catch 判斷小數位數太耗資源。 檢查字串中是否含 . 用 indexOf 或 split 的長度判斷就夠了,不必包例外處理。1e-7)toString 後是 "1e-7",split(".") 拿不到正確位數。math.add(a, b)),而非擴充原型。如果你在處理金額,最可靠的做法不是修補浮點運算,而是根本不使用浮點運算——把金額一律換算成最小單位(分)用整數計算,只在顯示時才除回去。
若專案允許引入套件,decimal.js、big.js 這類十進位精確運算函式庫已經把上述所有邊界情況處理完畢,比自己維護一套 homemade 的修正函式划算得多。
最後要強調的是:不要用 == 直接比較兩個浮點數。 這不是 JavaScript 特有的問題,Java、Python、C 全都一樣。養成比較差值絕對值的習慣,能省下大量難以追查的 bug。