js 中的 number 爲何很怪異

js 中的 number 爲何很怪異

聲明:需要讀者對二進制有一定的瞭解

對於 JavaScript 開發者來說,或多或少都遇到過 js 在處理數字上的奇怪現象,比如:

> 0.1 + 0.2
0.30000000000000004

> 0.1 + 1 - 1
0.10000000000000009

> 0.1 * 0.2
0.020000000000000004

> Math.pow(2, 53)
9007199254740992

> Math.pow(2, 53) + 1
9007199254740992

> Math.pow(2, 53) + 3
9007199254740996

如果想要弄明白爲什麼會出現這些奇怪現象,首先要弄清楚 JavaScript 是怎樣編碼數字的

1. JavaScript 是怎樣編碼數字的

JavaScript 中的數字,不管是整數、小數、分數,還是正數、負數,全部是浮點數,都是用 4 個字節(64 位)來存儲的。

一個數字(如 120.12-999)在內存中佔用 4 個字節(64 位),存儲方式如下:

  1. 0 - 51:分數部分(52 位)
  2. 52 - 62:指數部分(11 位)
  3. 63:符號位(1 位:0 表示這個數是正數,1 表示這個數是負數)

符號位很好理解,用於指明是正數還是負數,且只有 1 位、兩種情況(0 表示正數,1 表示負數)。

其他兩部分是分數部分和指數部分,用於計算一個數的絕對值。

1.1 絕對值計算公式

1: abs = 1.f * 2 ^ (e - 1023)             0 < e < 2047
2: abs = 0.f * 2 ^ (e - 1022)             e = 0, f > 0
3: abs = 0                                e = 0, f = 0
4: abs = NaN                              e = 2047, f > 0
5: abs = ∞ (infinity, 無窮大)              e = 2047, f = 0

說明:

  • 這個公式是二進制的算法公式,結果用 abs 表示,分數部分用 f 表示,指數部分用 e 表示
  • 2 ^ (e - 1023) 表示 2e - 1023 次方
  • 因爲分數部分佔 52 位,所以 f 的取值範圍爲 00...00(中間省略 48 個 0) 到 11...11(中間省略 48 個 1)
  • 因爲指數部分佔 11 位,所以 e 的取值範圍爲 000000000000) 到 204711111111111

從上面的公式可以看出:

  • 1 的存儲方式:1.00 * 2 ^ (1023 - 1023)f = 0000..., e = 1023... 表示 48 個 0)
  • 2 的存儲方式:1.00 * 2 ^ (1024 - 1023)f = 0000..., e = 1024... 表示 48 個 0)
  • 9 的存儲方式:1.01 * 2 ^ (1025 - 1023)f = 0100..., e = 1025... 表示 48 個 0)
  • 0.5 的存儲方式:1.00 * 2 ^ (1022 - 1023)f = 0000..., e = 1022... 表示 48 個 0)
  • 0.625 的存儲方式:1.01 * 2 ^ (1021 - 1023)f = 0100..., e = 1021... 表示 48 個 0)

1.2 絕對值的取值範圍與邊界

從上面的公式可以看出:

1.2.1 0 < e < 2047

0 < e < 2047 時,取值範圍爲:f = 0, e = 1f = 11...11, e = 2046(中間省略 48 個 1)

即:Math.pow(2, -1022)~= Math.pow(2, 1024) - 1~= 表示約等於)

這當中,~= Math.pow(2, 1024) - 1 就是 Number.MAX_VALUE 的值,js 所能表示的最大數值。

1.2.2 e = 0, f > 0

e = 0, f > 0 時,取值範圍爲:f = 00...01, e = 0(中間省略 48 個 0) 到 f = 11...11, e = 0(中間省略 48 個 1)

即:Math.pow(2, -1074)~= Math.pow(2, -1022)~= 表示約等於)

這當中,Math.pow(2, -1074) 就是 Number.MIN_VALUE 的值,js 所能表示的最小數值(絕對值)。

1.2.3 e = 0, f = 0

這隻表示一個值 0,但加上符號位,所以有 +0-0

但在運算中:

> +0 === -0
true

1.2.4 e = 2047, f > 0

這隻表示一種值 NaN

但在運算中:

> NaN == NaN
false

> NaN === NaN
false

1.2.5 e = 2047, f = 0

這隻表示一個值 (infinity, 無窮大)。

在運算中:

> Infinity === Infinity
true

> -Infinity === -Infinity
true

1.3 絕對值的最大安全值

從上面可以看出,4 個字節能存儲的最大數值是 Number.MAX_VALUE 的值,也就是 ~= Math.pow(2, 1024) - 1

但這個數值並不安全:從 1Number.MAX_VALUE 中間的數字並不連續,而是離散的。

比如:Number.MAX_VALUE - 1, Number.MAX_VALUE - 2 等數值都無法用公式得出,就存儲不了。

所以這裏引出了最大安全值 Number.MAX_SAFE_INTEGER,也就是從 1Number.MAX_SAFE_INTEGER 中間的數字都是連續的,處在這個範圍內的數值計算都是安全的。

f = 11...11, e = 1075(中間省略 48 個 1)時,取得這個值 111...11(中間省略 48 個 1),即 Math.pow(2, 53) - 1

大於 Number.MAX_SAFE_INTEGER:Math.pow(2, 53) - 1 的數值都是離散的。

比如:Math.pow(2, 53) + 1, Math.pow(2, 53) + 3 不能用公式得出,無法存儲在內存中。

所以纔會有文章開頭的現象:

> Math.pow(2, 53)
9007199254740992

> Math.pow(2, 53) + 1
9007199254740992

> Math.pow(2, 53) + 3
9007199254740996

因爲 Math.pow(2, 53) + 1 不能用公式得出,就無法存儲在內存中,所以只有取最靠近這個數的、能夠用公式得出的其他數,Math.pow(2, 53),然後存儲在內存中,這就是失真,即不安全。

1.4 小數的存儲方式與計算

小數中,除了滿足 m / (2 ^ n)m, n 都是整數)的小數可以用完整的 2 進製表示之外,其他的都不能用完整的 2 進製表示,只能無限的逼近一個 2 進制小數。

(注:[2] 表示二進制,^ 表示 N 次方)

0.5 = 1 / 2 = [2]0.1
0.875 = 7 / 8 = 1 / 2 + 1 / 4 + 1 / 8 = [2]0.111
# 0.3 的逼近

0.25 ([2]0.01) < 0.3 < 0.5 ([2]0.10)

0.296875 ([2]0.0100110) < 0.3 < 0.3046875 ([2]0.0100111)
 
0.2998046875 ([2]0.01001100110) < 0.3 < 0.30029296875 ([2]0.01001100111)

... 根據公式計算,直到把分數部分的 52 位填滿,然後取最靠近的數

0.3 的存儲方式:[2]0.010011001100110011001100110011001100110011001100110011

(f = 0011001100110011001100110011001100110011001100110011, e = 1021)

從上面可以看出,小數中大部分都只是近似值,只有少部分是真實值,所以只有這少部分的值(滿足 m / (2 ^ n) 的小數)可以直接比較大小,其他的都不能直接比較。

> 0.5 + 0.125 === 0.625
true

> 0.1 + 0.2 === 0.3
false

爲了安全的比較兩個小數,引入 Number.EPSILON [Math.pow(2, -52)] 來比較浮點數。

> Math.abs(0.1 + 0.2 - 0.3) < Number.EPSILON
true 

1.5 小數最大保留位數

js 從內存中讀取一個數時,最大保留 17 位有效數字。

> 0.010011001100110011001100110011001100110011001100110011
0.30000000000000000
0.3
> 0.010011001100110011001100110011001100110011001100110010
0.29999999999999993
> 0.010011001100110011001100110011001100110011001100110100
0.30000000000000004
> 0.0000010100011110101110000101000111101011100001010001111100
0.020000000000000004

2. Number 對象中的常量

2.1 Number.EPSILON

表示 1 與 Number 可表示的大於 1 的最小的浮點數之間的差值。

Math.pow(2, -52)

用於浮點數之間安全的比較大小。

2.2 Number.MAX_SAFE_INTEGER

絕對值的最大安全值。

Math.pow(2, 53) - 1

2.3 Number.MAX_VALUE

js 所能表示的最大數值(4 個字節能存儲的最大數值)。

~= Math.pow(2, 1024) - 1

2.4 Number.MIN_SAFE_INTEGER

最小安全值(包括符號)。

-(Math.pow(2, 53) - 1)

2.5 Number.MIN_VALUE

js 所能表示的最小數值(絕對值)。

Math.pow(2, -1074)

2.6 Number.NEGATIVE_INFINITY

負無窮大。

-Infinity

2.7 Number.POSITIVE_INFINITY

正無窮大。

+Infinity

2.8 Number.NaN

非數字。

3. 尋找奇怪現象的原因

3.1 爲什麼 0.1 + 0.2 結果是 0.30000000000000004

0.3 的逼近算法類似。

0.1 的存儲方式:[2]0.00011001100110011001100110011001100110011001100110011010

(f = 1001100110011001100110011001100110011001100110011010, e = 1019)

0.2 的存儲方式:[2]0.0011001100110011001100110011001100110011001100110011010

(f = 1001100110011001100110011001100110011001100110011010, e = 1020)
0.1 + 0.2: 0.0100110011001100110011001100110011001100110011001100111

(f = 00110011001100110011001100110011001100110011001100111, e = 1021)

f = 00110011001100110011001100110011001100110011001100111 有 53 位,超過了正常的 52 位,無法存儲,所以取最近的數:

0.1 + 0.2: 0.010011001100110011001100110011001100110011001100110100

(f = 0011001100110011001100110011001100110011001100110100, e = 1021)

js 讀取這個數字爲 0.30000000000000004

3.2 爲什麼 Math.pow(2, 53) + 1 結果是 Math.pow(2, 53)

因爲 Math.pow(2, 53) + 1 不能用公式得出,無法存儲在內存中,所以只有取最靠近這個數的、能夠用公式得出的其他數。

比這個數小的、最靠近的數:

Math.pow(2, 53)

(f = 0000000000000000000000000000000000000000000000000000, e = 1076)

比這個數大的、最靠近的數:

Math.pow(2, 53) + 2

(f = 0000000000000000000000000000000000000000000000000001, e = 1076)

取第一個數:Math.pow(2, 53)

所以:

> Math.pow(2, 53) + 1 === Math.pow(2, 53)
true

參考文章

後續

更多博客,查看 https://github.com/senntyou/blogs

作者:深予之 (@senntyou)

版權聲明:自由轉載-非商用-非衍生-保持署名(創意共享3.0許可證

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章