JavaScript中的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.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
中心的数字并不持续,而是离散的。
比方: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中的number的具体介绍的具体内容,更多请关注百分百源码网其它相关文章!