js 中的 number 為何很怪異

MRZYD 發布于2019-08-23 14:22 / 1923人閱讀

摘要：但這個數值并不安全從到中間的數字并不連續，而是離散的。對象中的常量表示與可表示的大于的最小的浮點數之間的差值。絕對值的最大安全值。尋找奇怪現象的原因為什么結果是與的逼近算法類似。

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 中的數字，不管是整數、小數、分數，還是正數、負數，全部是浮點數，都是用 8 個字節（64 位）來存儲的。

一個數字（如 12、0.12、-999）在內存中占用 8 個字節（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.001 * 2 ^ (1026 - 1023)（f = 0010..., e = 1026，... 表示 48 個 0）

0.5 的存儲方式：1.00 * 2 ^ (1022 - 1023)（f = 0000..., e = 1022，... 表示 48 個 0）

0.625 的存儲方式：1.01 * 2 ^ (1022 - 1023)（f = 0100..., e = 1022，... 表示 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 絕對值的最大安全值

從上面可以看出，8 個字節能存儲的最大數值是 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 所能表示的最大數值（8 個字節能存儲的最大數值）。

~= 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

參考文章

How numbers are encoded in JavaScript

JavaScript是怎樣編碼數字的

后續

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

作者：深予之 (@senntyou)

云服務器 GPU云服務器很怪異 js number數據類型 js的number數據類型怪異

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/100503.html

怪異的JavaScript系列(一)

摘要：是一門偉大的語言，它擁有非常簡潔的語法，龐大的生態系統，以及最重要的有一個偉大的社區支撐著。可是因為它已經被廣泛使用，所以委員會覺得保留它，但是違背了的規范。其實最小的數是，盡管它不是一個實際存在的數。譯者按： JavaScript有很多坑，經常一不小心就要寫bug。原文: What the f*ck JavaScript? 譯者: Fundebug 為了保證可讀性，本文采...

darry 2019-08-22 16:40 評論0 收藏0
怪異的JavaScript系列(三)

摘要：本文的思想源自于在上的演講。我收集這些例子的主要目的是將它們整理并清楚理解它們的原理。著主要是因為大括號也是函數定義語法的一部分。自從年雙十一正式上線，累計處理了億錯誤事件，得到了金山軟件等眾多知名用戶的認可。譯者按： JavaScript有很多坑，經常一不小心就要寫bug。原文: What the f*ck JavaScript? 譯者: Fundebug 為了保證可讀性...

XboxYan 2019-08-22 16:44 評論0 收藏0
怪異的JavaScript系列(二)

摘要：函數不是函數這是一個低版本的，，或則。對應的進制數為。因此最安全的方法是調用的時候指定進制。它會將字符串形式的整數轉換為，非字符串的，，和也會被轉換。對于不能轉換的值，返回。而瀏覽器主要指系列，其實已經沒有必要支持這個特性了。譯者按： JavaScript有很多坑，經常一不小心就要寫bug。原文: What the f*ck JavaScript? 譯者: Fundebug ...

YacaToy 2019-08-22 16:42 評論0 收藏0
JavaScript里的語句用分號結尾是個選項嗎

摘要：在以下的種情況是用回車或換行，是不會作自動插入分號來讓語句作結尾。以下情況必用分號。但有例外，賦值時可以加分號是對的語法。起因這個文章一開始回覆于這篇回答中: javascript初級問題也有之前的朋友寫信來問，因為在讀到我個人寫的一本電子書: 從ES6開始的JavaScript學習生活，繁體，gitbook。我在寫作風格里有說明，這本電子書中的范例都是使用不用分號(;)作為代碼...

stormzhang 2019-08-22 10:42 評論0 收藏0
寫了十年JS卻不知道模塊化為何物？

摘要：于是模塊化的需求也就產生了。現存的規范還真不少，不知道能否終結這場混戰和分別是和定義的標準。是使用的模塊化標準。的模塊化聲明的方式與類似，只是更進一步，天然隔離了命名空間。其他，關于前端化趨勢模塊化意味著什么更強大的前端，技術整體前移。作者：肖光宇野狗科技聯合創始人，先后在貓撲、百度、搜狗任職，愛折騰的前端工程師。野狗官博：https://blog.wilddog.com/ 野狗官網...

LittleLiByte 2019-08-21 10:46 評論0 收藏0