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 ビット) を占有します。格納方法は次のとおりです。 :

1. #0 - 51

   : 小数部 (52 ビット)

##52 - 62
2. :指数部 (11 ビット)

63
3. : 符号ビット (1 ビット: 0 は数値が正であることを意味し、1 は数値が負であることを意味します)
   符号ビットは、正の数か負の数かを示すために使用され、1 つのビットと 2 つの状況 (0 は正の数を意味し、1 は負の数を意味します) を示します。

他の 2 つの部分は小数部分と指数部分で、数値の絶対値を計算するために使用されます。

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 個のゼロを表します)

  2
格納方法:
• 1.00 * 2 ^ (1024 - 1023)

  ( f = 0000..., e = 1024 , ... は 48 個の 0 を表します)

  #9
格納方法:
• 1.01 * 2 ^ (1025 - 1023)

  (f = 0100..., e = 1025, ... は 48 個のゼロを表します)

  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 個のゼロを表します)1.2 絶対値の範囲と境界値

上記の式からわかります:

1.2.1

0 < 2047

When0 < ; e < 2047 の場合、値の範囲は

f = 0, e = 1

～ f = 11...11, e = 2046 (48 個の 1 は途中省略) つまり: Math.pow(2, -1022) to

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

(途中の 0 が 48 個省略) ～

f = 11...11, e = 0 (途中の 48 個の 1 が省略)中央) つまり: Math.pow(2, -1074) から ~= Math.pow(2, -1022)

(

~ = はほぼ等しいという意味です) このうち、Math.pow(2, -1074) は Number.MIN_VALUE

の値であり、

js can 表現される最小値 (絶対値)。 1.2.3 e = 0, f = 0

は値

0 のみを表しますが、符号ビットがあるため、 0

および

-0。 しかし、演算では:

> +0 === -0
true<code>1.2.4 </code>e = 2047, f > 0<p></p>これは 1 つの値のみを表します<h4> NaN <code>。 </code>
</h4>しかし、操作では: <p></p>
<pre class="brush:php;toolbar:false">> NaN == NaN
false

> NaN === NaN
false

1.2.5 e = 2047, f = 0

これは 1 つの値のみを表します

∞ (無限、無限)。

運用中:

> 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

以上がJavaScript の数値の詳細な紹介の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。