JS 之 浮點數語言層面的終極探究

開場

春天來了，你們都充滿活力，幹勁十足，又蹦又跳。我也在網上看了一套題，沒想到剛開始看就花了眼:

var END = Math.pow(2, 53);
var START = END - 100;
var count = 0;
for (var i = START; i <= END; i++) {
    count++;
}
console.log(count);
複製代碼

只解題也不難，這是關於JS精度係數的問題，只須要記住2的53次方是能正確計算且不失精度的最大整數，便可。可是我工做兩年了，自我以爲應該要邁入稍微高級的那種程序員行列了，即便本人一點也不高級也應該用高級程序員的準則來要求本身了，因而便有了這篇探究總結的文章，來窺一窺浮點數語言層面的實現原理。 讀完本篇文章你不只能解開上題且能真正明白爲嘛下面的輸出結果是這樣的。

> 9007199254740992 + 1
    9007199254740992

    > 9007199254740992 + 2
    9007199254740994

    > 0.1 + 1 - 1
    0.10000000000000009
複製代碼

開整

咱們知道，JS中的全部數字均用浮點數值表示，其採用IEEE 754標準定義64位浮點格式表示數字。其表示格式以下圖，小數部分（fraction）佔用0~51位比特（52 bits）, 指數部分（exponent）佔用52~62位比特（11 bits），符號位（sign）佔用63位比特（1 bit）.

首先咱們看一看十進制和二進制如何表示數字： 一個十進制的浮點數，例如：abcd.efg (其中a ~ g值得範圍爲0 ~ 9)，其值用多項式爲： a 10^3 + b10^2 + c 10^1+d10^0+e 10^(-1)+f10^(-1)+g 10^(-3)。 而一個二進制的浮點數，咱們也將其表示成：abcd.efg (其中a~g值得範圍爲0或1)，其值表示爲： a2^3 + b 2^2 + c2^1+d 2^0+e2^(-1)+f 2^(-1)+g2^(-3)。 十進制科學計數法可表示爲： (-1)^s * f* 10^e。s表示符號。f爲尾數，範圍爲1<=f<10。e爲冪，也叫指數。 二進制的科學計數法，也是IEEE的浮點數標準格式可表示爲： (-1)^s * f* 2^e。f的範圍爲1<=m<2。 再者來解析上圖的符號位（sign）、指數位(exponent)、小數位（fraction）的含義分別是什麼： 一、當表示的浮點數是正數時 符號位 爲 0，反之則爲1。 二、指數有正有負，指數位長度爲11比特，因此能表示的數字範圍爲0~2047。爲了能表示負值得指數，咱們在這裏引入二進制偏移量（ offset binary）的概念。在這裏IEEE定義偏移量爲1023，咱們計算出的指數位數值減去1023則爲咱們真正想要的值。假設咱們用11位比特算出的值爲e,則咱們要帶入計算的結果爲2^(e-1023)。 三、尾數範圍爲1<=f<2, 就是說小數點前面總有一個1，爲了節省空間，IEEE規定將此處的1省略，直接將小數點後面的部分放入到小數部分（這也是爲何這部分叫「小數部分（fractiong）」而不叫「尾數部分」的緣由）。

分析

如何表示小數呢？

在這裏咱們約定，數字前加%表示二進制數字。下面就是一組表示非負浮點數的例圖。JS用有理數表示有效數字， 方式爲：1.f 。其中 f 爲52位比特小數位（fraction） 。忽略掉正負號，有效數字乘以2^p(p = e - 1023)就是咱們最終的二進制數字結果，JS就是用這種方式來表示小數的。

如何表示整數呢？

JS的有效數字有53個，其中一個在小數點的前面固定不變，值爲1，其他的在小數點的後面有52個。當p(p = e - 1023) = 52時， 咱們會用53個比特表示數字。因爲最高位的數值老是1，這也就代表咱們不能老是按着咱們的意願來操縱這些比特。不過IEEE經過兩個步驟巧妙的把這個問題解決了。 步驟1： 如圖，咱們作一個推理，若是53位比特數字最高位爲0，次位爲1，則咱們設 p = 51。若這時的最低位比特（也就是小數點後面）爲0，則咱們認爲該數字爲整數。如此反覆推導，直到p = 0, f = 0, 這時咱們獲得的編碼整數爲1。（經過步驟1，咱們能夠用53位比特精確的表示數字） 步驟2： 經過步驟1雖然能精確表示部分數字，可是卻不能表示0，在這一步咱們再定義0的表示方式: 當 p= - 1023 ( 即 e = 0)， f = 0 時，該值爲0 （後面還會有講解）。

綜上，咱們有 53 比特的精確一一對應的二進制數字來表示整數。

特別的指數，特別的約定

根據IEEE 754 規定， 在指數位上咱們有兩個值有特殊的定義，分別爲 e = 0 和 e = 2047。 特殊約定：

1.當 e = 0 時， 若 f = 0, 則 該數值爲 0 ， 因爲 有符號位 （sign）的存在，因此咱們在JS中有 -0 和 +0之分。

2.當 e = 0, f > 0，則該值用來表示一個很是接近於0 的數字，計值公式爲： (-1)^s * %0.f × 2^−1022 這種表示方式稱爲非規格化（denormalized）。咱們以前提到普通狀況下的的表示方式稱爲規格化（normalized） 最小的規格化的正數爲：%1.0 × 2^−1022 最大的非規格化的正數爲： %0.1... × 2^−1022 所以,規格化與非規格化的數字就能實現無縫對接。 3. 當 e = 2047, f = 0 時， 該數值在JS中被表示爲無窮（∞/infinity）。 4. 當e = 2047, f > 0 時， 該數值在JS中被表示爲 NaN。 總結一下：

十進制小數

在JS中並非全部的十進制小數都能被精確的表示出來，看一看下面的例子：

> 0.1 + 0.2
    0.30000000000000004
複製代碼

那麼計算過程是怎樣呢？ 咱們首先來看0.1和0.2在二進制浮點數中的表示方式

0.5 用二進制浮點數的形式儲存爲 %0.1 
可是 0.1 = 1/10 因此它表示爲 1/16 + (1/10-1/16) = 1/16 + 0.0375
0.0375 = 1/32 + (0.0375-1/32) = 1/32 + 00625 ... etc
因此在二進制浮點數中0.1 表示爲 %0.00011... 
0.1 -> %0.0001100110011001...(無限)
0.2 -> %0.0011001100110011...(無限)
複製代碼

IEEE 754 標準的 64 位雙精度浮點數的小數部分最多支持 53 位二進制位，因此二者相加以後獲得二進制爲：

%0.0100110011001100110011001100110011001100110011001100 
複製代碼

讓咱們再看一個例子：

> 0.1 + 1 - 1
    0.10000000000000009
複製代碼

這個是爲何呢？ 首先咱們知道

0.1 -> %0.0001100110011001...(無限)
複製代碼

根據其精度因此最終在內存中保存的樣子應該爲

%0.0001(100110011001...010) // 因爲末尾後面是1，0舍1入，因此...後面爲010而非001. （）中一共52位
複製代碼

加1以後能夠表示爲

%1.(0001100110011...010) // 因爲末尾後面是1，0舍1入，因此...後面爲010而非001. （）中一共52位
複製代碼

再減去1以後能夠表示爲

減去1後的儲存二進制：%0.0001(100110011001...0100000) // ()中一共52位

   0.1原始儲存大小：%0.0001(100110011001...0011010) 
複製代碼

注意比較最後末尾的7位數字因此值稍微大於實際值。 你也能夠按照上面的方式推算0.2+1-1的值，試一試。

最大整數

什麼是最大整數？ 在這裏咱們給最大整數（x）下一個定義：它指在 0 ≤ n ≤ x 範圍內，每一個整數 n 都能被表示出來，大於x時就不能保證該特性。在JS中 2^53就符合的要求，全部小於它的數都能被表示

> Math.pow(2, 53)
    9007199254740992
    > Math.pow(2, 53) - 1
    9007199254740991
    > Math.pow(2, 53) - 2
    9007199254740990
複製代碼

可是大於它的數字就不必定能被表示出來了：

> Math.pow(2, 53) + 1
    9007199254740992
複製代碼

出現上面狀況的緣由我會分紅幾個小的問題一一解答，當你明白這些小問題，那麼上面的問題確定也就明白了。你只要記住限制其最高精確度的是小數位（fraction）部分，可是指數位（exponent）仍然有很大的上升空間。 爲啥是53位？ 由於咱們有53位比特（bits）能夠用來表示數字的大小(不包括符號)，只是表示小數部分爲52比特，整數部分永遠是1（二進制科學計數法）。 爲啥最大整數不是(2^53) - 1 ? 一般狀況下，x 比特能表示的整數範圍爲 0 ～ (2^x) - 1。好比說一個字節（byte）有8 比特（bits）那麼一個字節所能表示最大的整數爲 255。在 JS中，最大的小數部分的確是(2^53) - 1，多虧有指數位的幫忙，2^53也是能夠表示的。 當 小數位 f =0 ， 指數位 p = 53:

%1.f × 2p = %1.0 × 2^53 = 2^53
複製代碼

大於2^53的數字如何被表示出來的呢？ 請看下面的例子

> Math.pow(2, 53)
    9007199254740992
    > Math.pow(2, 53) + 1  // not OK
    9007199254740992
    > Math.pow(2, 53) + 2  // OK
    9007199254740994

    > Math.pow(2, 53) * 2  // OK
    18014398509481984
複製代碼

2^53 × 2 能正確的表示，由於它在指數位的正常範圍以內，每次乘2均可以表示成指數位加1，而對小數位沒有任何影響。那爲啥咱們能表示2 + 2 ^53 卻不能表示 1+2^53呢？咱們來看下面的列表：

請看當p = 53的這一行，因爲JS能表示的小數位只有52比特，因此第0位比特只能用0來填充。因此，在2^53 ≤ x < 2^54的範圍內，只有偶數才能被正確表示出來。 同理當p = 54時， 在 2^54 ≤ x < 2^55 內增加是按照4的倍數來的。

> Math.pow(2, 54)
    18014398509481984
    > Math.pow(2, 54) + 1
    18014398509481984
    > Math.pow(2, 54) + 2
    18014398509481984
    > Math.pow(2, 54) + 3
    18014398509481988
    > Math.pow(2, 54) + 4
    18014398509481988
複製代碼

而後一直持續下去，直到 p = 1023時均可以以此類推（p=1024有特點含義，詳情請看上面 特別的指數，特別的約定模塊）。

如何避免浮點精度錯誤

咱們應當避免避免直接進行小數之間的比較。由於總的來講就是沒有好辦法來解決這些偏差。不過咱們能夠經過設置一個偏差上限來肯定這個值是否是咱們能接受的。這個偏差上限就是咱們所說的機器精度（machine epsilon）。標準的雙浮點精度值爲 2 ^-52。

var epsEqu = function () { // IIFE, keeps EPSILON private
        var EPSILON = Math.pow(2, -53);
        return function epsEqu(x, y) {
            return Math.abs(x - y) < EPSILON;
        };
    }();
複製代碼

上面的函數能保證咱們的結果是否是在精度範圍內所能接受的值。

> 0.1 + 0.2 === 0.3
  false
  > epsEqu(0.1+0.2, 0.3)
  true
複製代碼

咱們還能夠經過下面有幾個不錯的類庫能夠處理精度問題。

Math JS

Sinful JS

BigDecimal

JS原生提供了兩種處理精度的方法Number.prototype.toPrecision()和Number.prototype.toFixed() 只是這兩種方法都是用來展現值的，類型都爲String。好比：

function foo(x, y) {
    return x.toPrecision() + y.toPrecision()
}

> foo(0.1, 0.2)
"0.10.2"
複製代碼

因此用的時候必定要當心，最好不要用JS處理浮點數，若是必定要用JS處理數字問題，最好不要本身寫，好的類庫每每是比較好的選擇。

總結

咱們走了一大圈，終於完徹底全的明白了JS在內部是如何表示數字的。咱們得出的深入結論是：若是你用JS 計算帶有小數的數字，你將沒法肯定你獲得的結果。

P.S.: 世界是屬於理解它的人，很高興，咱們對編程的世界又有了更深一層的理解。若是文章有不足或理解不到位的地方，還請不吝賜教，若是有不明白的地方也能夠留言，咱們共同討論 (^-^)

附錄

我看的原題集在這裏

What Every JavaScript Developer Should Know About Floating Points

What Every Computer Scientist Should Know About Floating-Point Arithmetic

How numbers are encoded in JavaScript

浮點數在計算機中的儲存

浮點數在計算機中的表示