摘要:但这个数值并不安全从到中间的数字并不连续,而是离散的。对象中的常量表示与可表示的大于的最小的浮点数之间的差值。绝对值的最大安全值。寻找奇怪现象的原因为什么结果是与的逼近算法类似。
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 true1.2.4 e = 2047, f > 0
这只表示一种值 NaN。
但在运算中:
> NaN == NaN false > NaN === NaN false1.2.5 e = 2047, f = 0
这只表示一个值 ∞ (infinity, 无穷大)。
在运算中:
> Infinity === Infinity true > -Infinity === -Infinity true1.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 true1.5 小数最大保留位数
js 从内存中读取一个数时,最大保留 17 位有效数字。
> 0.010011001100110011001100110011001100110011001100110011 0.30000000000000000 0.3
> 0.010011001100110011001100110011001100110011001100110010 0.29999999999999993
> 0.010011001100110011001100110011001100110011001100110100 0.30000000000000004
> 0.0000010100011110101110000101000111101011100001010001111100 0.0200000000000000042. Number 对象中的常量 2.1 Number.EPSILON
表示 1 与 Number 可表示的大于 1 的最小的浮点数之间的差值。
Math.pow(2, -52)
用于浮点数之间安全的比较大小。
2.2 Number.MAX_SAFE_INTEGER绝对值的最大安全值。
Math.pow(2, 53) - 12.3 Number.MAX_VALUE
js 所能表示的最大数值(8 个字节能存储的最大数值)。
~= Math.pow(2, 1024) - 12.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
负无穷大。
-Infinity2.7 Number.POSITIVE_INFINITY
正无穷大。
+Infinity2.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许可证)
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/100503.html
摘要:是一门伟大的语言,它拥有非常简洁的语法,庞大的生态系统,以及最重要的有一个伟大的社区支撑着。可是因为它已经被广泛使用,所以委员会觉得保留它,但是违背了的规范。其实最小的数是,尽管它不是一个实际存在的数。 译者按: JavaScript有很多坑,经常一不小心就要写bug。 原文: What the f*ck JavaScript? 译者: Fundebug 为了保证可读性,本文采...
摘要:本文的思想源自于在上的演讲。我收集这些例子的主要目的是将它们整理并清楚理解它们的原理。着主要是因为大括号也是函数定义语法的一部分。自从年双十一正式上线,累计处理了亿错误事件,得到了金山软件等众多知名用户的认可。 译者按: JavaScript有很多坑,经常一不小心就要写bug。 原文: What the f*ck JavaScript? 译者: Fundebug 为了保证可读性...
摘要:函数不是函数这是一个低版本的,,或则。对应的进制数为。因此最安全的方法是调用的时候指定进制。它会将字符串形式的整数转换为,非字符串的,,和也会被转换。对于不能转换的值,返回。而浏览器主要指系列,其实已经没有必要支持这个特性了。 译者按: JavaScript有很多坑,经常一不小心就要写bug。 原文: What the f*ck JavaScript? 译者: Fundebug ...
摘要:在以下的种情况是用回车或换行,是不会作自动插入分号来让语句作结尾。以下情况必用分号。但有例外,赋值时可以加分号是对的语法。 起因 这个文章一开始回覆于这篇回答中: javascript初级问题 也有之前的朋友写信来问,因为在读到我个人写的一本电子书: 从ES6开始的JavaScript学习生活,繁体,gitbook。我在写作风格里有说明,这本电子书中的范例都是使用不用分号(;)作为代码...
摘要:于是模块化的需求也就产生了。现存的规范还真不少,不知道能否终结这场混战和分别是和定义的标准。是使用的模块化标准。的模块化声明的方式与类似,只是更进一步,天然隔离了命名空间。其他,关于前端化趋势模块化意味着什么更强大的前端,技术整体前移。 作者:肖光宇野狗科技联合创始人,先后在猫扑、百度、搜狗任职,爱折腾的前端工程师。野狗官博:https://blog.wilddog.com/ 野狗官网...
阅读 2998·2021-11-24 10:47
阅读 3781·2021-11-02 14:43
阅读 2143·2021-09-26 10:15
阅读 2131·2021-09-08 09:35
阅读 516·2019-08-30 12:45
阅读 2735·2019-08-29 17:04
阅读 3186·2019-08-26 14:05
阅读 1230·2019-08-26 12:10