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 位），存储体式格局以下：

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) 示意 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)

版权声明：自在转载-非商用-非衍生-坚持签名（创意同享3.0许可证）