js 中的 number 为何很怪异
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 中的数字，不管是整数、小数、分数，还是正数、负数，全部是浮点数，都是用 4 个字节（64 位）来存储的。
一个数字（如 12、0.12、-999）在内存中占用 4 个字节（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
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 绝对值的最大安全值
从上面可以看出，4 个字节能存储的最大数值是 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.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 所能表示的最大数值（4 个字节能存储的最大数值）。
~= 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.cnblogs.com/lovellll/p/10188952.html
js 中的 number 为何很怪异相关推荐
- js 中的 number 为何很怪异 1
js 中的 number 为何很怪异 声明:需要读者对二进制有一定的了解 对于 JavaScript 开发者来说,或多或少都遇到过 js 在处理数字上的奇怪现象,比如: > 0.1 + 0.2 ...
- Vue.js中文官网打开很慢
我家是移动网,打开github的官网会比vue的官网快一点,改过host还是一样打开vue.js官网一直转特别慢,求助大神们
- 详解JS中的原型与继承
每当我们提起原型链时不免会想到原型对象,对象的原型,还有众多的继承方式.于是prototype.[[prototype]].constructor等等难免在头脑中打架. 然而原型其实并不是什么高大上的 ...
- python之js解密_python中的RSA加密和JS中的解密
我是密码学的全新人物.我想从服务器端生成RSA密钥对,并将其发送给所有客户端(浏览器).但在此之前,我只是通过加密python中的数据并通过pubnub发送到index.html文件并尝试在JavaS ...
- Js中Number对象
Js中Number对象 JavaScript的Number对象是经过封装从而能够处理数字值的对象,Number对象由Number()构造器以及字面量声明的值在转化为包装对象时创建,JavaScript ...
- js中单引号和双引号的区别（html中属性规范是用双引号，js中字符串规定是用单引号）（js中单引号区别和php很像：单引号快，双引号可转义字符，双引号可解析变量）...
js中单引号和双引号的区别(html中属性规范是用双引号,js中字符串规定是用单引号)(js中单引号区别和php很像:单引号快,双引号可转义字符,双引号可解析变量) 一.总结 1.html中属性规范是 ...
- js中字符串类型转化toString、parseInt、parseFloat、Number
全栈工程师开发手册 (作者:栾鹏) js系列教程3-字符串.正则表达式全解 js中字符串类型转化 其他类型转化为字符串: 代码如下: var num= 19; // 19 var myStr = nu ...
- 这一篇彻底搞懂JS中的prototype、__proto__与constructor真的很好
文章目录 1. 前言 2. _ _ proto _ _ 属性 3. prototype属性 4. constructor属性 5. 总结 提示:不要排斥,静下心来,认真读完,你就搞懂了!(可以先看一下 ...
- JS对象转换为Number/String的内部原理 JS在浏览器中的运行环境
ECMAScript2015官方文档:http://www.ecma-international.org/ecma-262/6.0/#sec-functiondeclarationinstantiat ...
最新文章
- 《预训练周刊》第6期：GAN人脸预训练模型、通过深度生成模型进行蛋白序列设计
- 每周AI应用方案精选：虹膜识别；基于深度学习人脸识别方案等
- 9.LDA(线性判别分析)
- 转行，转向哪里？电子工程师！！！
- 苹果cms V8 M1938蓝色自适应模板
- 浅谈，JavaScript 运行机制和Event Loop
- vue开发 - 将方法绑定到window对象，给app端调用
- KL散度的通俗易懂理解
- 猜算式，四个两位数字不可以重复（一）
- java冒泡排序_冒泡排序法丨java、python冒泡排序实现代码
- [转]OAuth 认证步骤
- 参考文献起止页码怎么写_参考文献起止页码格式
- 猿创征文｜国产数据库之OceanBase详解安装和使用
- 职友集(www.jobui.com) Lucene Similarity 的排序规则更改了...
- 【排序算法】图解冒泡排序(多图+解决两种无效比较问题)
- 家用电脑搭建外网服务器
- 面试官问你有什么优点/缺点该如何回答
- uni-app 对接第三方h5
- Oracle等数据库报盘步骤(使用脚本批量压缩)
- 输出集合的所有子集(幂集)-C语言