JavaScript의 숫자에 대한 자세한 소개

이 글은 JavaScript의 숫자에 대한 자세한 소개를 제공합니다. 도움이 필요한 친구들이 참고할 수 있기를 바랍니다.

면책 조항: 독자는 바이너리에 대해 어느 정도 이해해야 합니다.

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비트)를 차지하며 다음과 같이 저장됩니다. 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.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 绝对值的最大安全值

从上面可以看出，8 个字节能存储的最大数值是 Number.MAX_VALUE 的值，也就是 ~= Math.pow(2, 1024) - 1。

但这个数值并不安全：从 1 到 Number.MAX_VALUE

1. 0 - 51: 소수부(52비트) 🎜
2. 🎜52 - 62 : 지수부(11비트) 🎜
3. 🎜63: 부호 비트(1비트: 0은 숫자가 양수, 1은 음수를 의미) 🎜

🎜부호 비트는 양수인지 음수인지를 나타내는 데 사용됩니다. 비트는 1개이고 상황은 2개입니다(0은 양수, 1은 음수). 🎜🎜다른 두 부분은 숫자의 절대값을 계산하는 데 사용되는 분수 부분과 지수 부분입니다. 🎜🎜🎜1.1 절대값 계산 공식🎜🎜

> Math.pow(2, 53)
9007199254740992

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

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

🎜설명: 🎜

• 🎜이 공식은 바이너리 알고리즘 공식이며, 그 결과는 abs , 분수 부분은 <code>f로 표시되고 지수 부분은 e🎜
• 🎜2 ^ (e - 1023) e - 1023 2🎜
• 🎜소수부는 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) (<code>f = 0000.. ., e = 1024, ...는 48개의 0을 의미함) 🎜
• 🎜9 저장 방법: <code>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 < code>

🎜< code>0 < e < 2047인 경우 값 범위는 f = 0, e = 1 ~ f = 11입니다. ...11, e = 2046< /code> (중간 48개의 1은 생략됨) 🎜🎜즉, <code>Math.pow(2, -1022)에서 ~= Math. pow(2, 1024) - 1 (~=는 대략 같음을 의미함) 🎜🎜그 중 ~= Math.pow(2, 1024) - 1</code >는 <code>Number.MAX_VALUE 값으로, js가 나타낼 수 있는 최대값입니다. 🎜

1.2.2 e = 0, f > 0

🎜 e = 0, f > 0일 때 값 범위는 다음과 같습니다. code>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.5 = 1 / 2 = [2]0.1
0.875 = 7 / 8 = 1 / 2 + 1 / 4 + 1 / 8 = [2]0.111

1.2.4 e = 2047, f > 0

🎜이것은 하나의 값 NaN만 나타냅니다. 🎜🎜그러나 연산에서는: 🎜

# 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)

1.2.5 e = 2047, f = 0

🎜이것은 하나의 값 f(무한대, 무한). 🎜🎜작동 중 : 🎜

> 0.5 + 0.125 === 0.625
true

> 0.1 + 0.2 === 0.3
false

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

위 내용은 JavaScript의 숫자에 대한 자세한 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!