声明：需要读者对二进制有一定的了解
对于 JavaScript 开发者来说，或多或少都遇到过js在处理数字上的奇怪现象，比如：
如果想要弄明白为什么会出现这些奇怪现象，首先要弄清楚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 绝对值计算公式
说明：
这个公式是二进制的算法公式，结果用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.10 < 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.2e = 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.3e = 0, f = 0
这只表示一个值0，但加上符号位，所以有+0与-0。
但在运算中：
1.2.4e = 2047, f > 0
这只表示一种值NaN。
但在运算中：
1.2.5e = 2047, f = 0
这只表示一个值∞(infinity, 无穷大)。
在运算中：
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) + 1不能用公式得出，就无法存储在内存中，所以只有取最靠近这个数的、能够用公式得出的其他数，Math.pow(2, 53)，然后存储在内存中，这就是失真，即不安全。
1.4 小数的存储方式与计算
小数中，除了满足m / (2 ^ n)（m, n都是整数）的小数可以用完整的 2 进制表示之外，其他的都不能用完整的 2 进制表示，只能无限的逼近一个 2 进制小数。
（注：[2]表示二进制，^表示 N 次方）
从上面可以看出，小数中大部分都只是近似值，只有少部分是真实值，所以只有这少部分的值（满足m / (2 ^ n)的小数）可以直接比较大小，其他的都不能直接比较。
为了安全的比较两个小数，引入Number.EPSILON [Math.pow(2, -52)]来比较浮点数。
1.5 小数最大保留位数
js从内存中读取一个数时，最大保留17位有效数字。
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的逼近算法类似。
但f = 00110011001100110011001100110011001100110011001100111有 53 位，超过了正常的 52 位，无法存储，所以取最近的数：
js读取这个数字为0.30000000000000004
3.2 为什么Math.pow(2, 53) + 1结果是Math.pow(2, 53)
因为Math.pow(2, 53) + 1不能用公式得出，无法存储在内存中，所以只有取最靠近这个数的、能够用公式得出的其他数。
比这个数小的、最靠近的数：
比这个数大的、最靠近的数：
取第一个数：Math.pow(2, 53)。
所以：
参考文章
How numbers are encoded in JavaScript
后续
原文链接：https://segmentfault.com/a/1190000017545048
最后：“相信有很多想学前端的小伙伴，今年年初我花了一个月整理了一份最适合2018年学习的web前端干货，从最基础的HTML+CSS+JS到移动端HTML5等都有整理，送给每一位前端小伙伴，53763，1707这里是小白聚集地，欢迎初学和进阶中的小伙伴。”
最后祝大家早日学有所成，拿到满意offer，快速升职加薪，走上人生巅峰。
