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 位)來存儲的。
一個數字(如 12
、0.12
、-999
)在內存中佔用 4 個字節(64 位),存儲方式如下:
-
0 - 51
:分數部分(52 位) -
52 - 62
:指數部分(11 位) -
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)
表示2
的e - 1023
次方 - 因爲分數部分佔 52 位,所以
f
的取值範圍爲00...00
(中間省略 48 個 0) 到11...11
(中間省略 48 個 1) - 因爲指數部分佔 11 位,所以
e
的取值範圍爲0
(00000000000
) 到2047
(11111111111
)
從上面的公式可以看出:
-
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 = 1
到 f = 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
。
但這個數值並不安全:從 1
到 Number.MAX_VALUE
中間的數字並不連續,而是離散的。
比如:Number.MAX_VALUE - 1
, Number.MAX_VALUE - 2
等數值都無法用公式得出,就存儲不了。
所以這裏引出了最大安全值 Number.MAX_SAFE_INTEGER
,也就是從 1
到 Number.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
版權聲明:自由轉載-非商用-非衍生-保持署名(創意共享3.0許可證)