DIV CSS 佈局教程網

JavaScript 浮點數精度問題:成因、判等與四則運算修正
編輯:關於JavaScript     

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)。這是無法避免的精度損失。

二、在 JavaScript 中表現得更明顯

以下是在 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(".") 拿不到正確位數。
  • 修改 Number.prototype 有污染風險。 團隊專案中建議封裝成獨立工具模組(例如 math.add(a, b)),而非擴充原型。

七、更實際的建議

如果你在處理金額,最可靠的做法不是修補浮點運算,而是根本不使用浮點運算——把金額一律換算成最小單位(分)用整數計算,只在顯示時才除回去。

若專案允許引入套件,decimal.js、big.js 這類十進位精確運算函式庫已經把上述所有邊界情況處理完畢,比自己維護一套 homemade 的修正函式划算得多。

最後要強調的是:不要用 == 直接比較兩個浮點數。 這不是 JavaScript 特有的問題,Java、Python、C 全都一樣。養成比較差值絕對值的習慣,能省下大量難以追查的 bug。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved