**
** avascript 有一个很好玩的事情， 0.1 + 0.2 = 0.30000000000000004。稍微有经验大概能反应出来这是存储时数据长度截取产生的原因，但是具体是计算机怎么计算的呢，自己也解释不清，于是带着好奇稍微探索了一下。 （ps：实际上并不是只有 javascript 存在这种问题，具体可以看看 http://0.30000000000000004.com/ 这个网站。） 浮点数在计算机中的存储
IEEE 标准 首先科普一下 js 中使用的二进制浮点数算术标准 IEEE_754 他采用的存储格式为： E = (-1)^1 × M × 2^E • (-1)^s 表示符号位，当 s=0，V 为正数；当 s=1，V 为负数。 • M 表示有效数字，大于等于 1，小于 2。 • 2^E 表示指数位。 举例来说，十进制的 5.0，写成二进制是 101.0，相当于 1.01×2^2。那么，按照上面 V 的格式，可以得出 s=0，M=1.01，E=2。 十进制的 -5.0，写成二进制是 -101.0，相当于 -1.01×2^2。那么，s = 1，M = 1.01，E = 2。 存储格式 对于 32 位的浮点数，最高的 1 位是符号位 s，接着的 8 位是指数 E，剩下的 23 位为有效数字 M。
对于 64 位的浮点数，最高的 1 位是符号位 S，接着的 11 位是指数 E，剩下的 52 位为有效数字 M。
这里只简单说一下第一种情况存储时的一些点：
尾数 M IEEE 754 规定，在 计算机内部保存 M 时，默认这个数的第一位总是 1，因此可以被舍去，只保存后面的 xxxxxx 部分 。比如保存 1.01 的时候，只保存 01，等到读取的时候，再把第一位的 1 加上去。这样做的目的，是节省 1 位有效数字。以 32 位浮点数为例，留给 M 只有 23 位，将第一位的 1 舍去以后，等于可以保存 24 位有效数字。 指数 E 指数 E 的情况稍微复杂一点点。 首先，E 为一个无符号整数）。这意味着，如果 E 为 8 位，它的取值范围为 0~255；如果 E 为 11 位，它的取值范围为 0~2047。但是，我们知道，科学计数法中的 E 是可以出现负数的，所以 IEEE 754 规定，E 的真实值必须再减去一个中间数，对于 8 位的 E，这个中间数是 127；对于 11 位的 E，这个中间数是 1023。 比如，2^10 的 E 是 10，当保存成 32 位浮点数时，必须保存成 10 + 127 = 137，即 10001001。如果要保存成 64 位浮点数的时候，就会保存成 10 + 1023 = 1033，即 10000001001。 然后，指数 E 还可以再分成三种情况：
E 不全为 0 或不全为 1。这时，浮点数就采用上面的规则表示，即指数 E 的计算值减去 127（或 1023），得到真实值，再将有效数字 M 前加上第一位的 1。E 全为 0。这时，浮点数的指数 E 等于 1-127（或者 1-1023），有效数字 M 不再加上第一位的 1，而是还原为 0.xxxxxx 的小数。这样做是为了表示 ±0，以及接近于 0 的很小的数字。E 全为 1。这时，如果有效数字 M 全为 0，表示 ± 无穷大（正负取决于符号位 s）；如果有效数字 M 不全为 0，表示这个数不是一个数（NaN）。浮点数转换为二进制方法 浮点数转换成二进制，我们要将整数部分和小数部分分开，大概就是整数部分采用除 2 取余倒叙记录，小数部分采用乘 2 取整顺序记录。具体例子和实现方式可自行搜索。 以 0.1 为例，0.1 的二进制
0.1------- 又从0.2开始循环了 于是，我们得到了 0.1 的二进制表示，为 0.0001100110011(0011循环)，即 1.100110011(0011) * 2^-4 在计算机中的存储表达里，符号 s=0，尾数 M = 1.100110011 (0011)，阶码 E = -4，实际存储为 -4+1023 = 1019 的二进制 1111111011。由于 javascript 是双精度的，所以 0.1 在计算机中存储格式为：
s: 0 exp:01111111011 frac:1001100110011001100110011001100110011001100110011010 frac(52位，注意存储时候前面的1会舍去，最后一位进1)
同理，0.2 的二进制表示为 0.001100110011(0011循环)，即 1.100110011(0011)*2^-3 在计算机中的存储表达里，符号 s=0，尾数 M = 1.100110011 (0011)，阶码 E = -3，实际存储为 -3+1023 = 1020 的二进制 1111111100。在计算机中存储格式为：
s: 0 exp:01111111100 frac:1001100110011001100110011001100110011001100110011010 (52位，注意存储时候前面的1会舍去，最后一位进1) 运算
运算 存储讲完，接下来就该聊下浮点数的加减运算了，它一般有 6 个步骤完成，先补充一下理论知识：
（1）对0、Infinity 和 NaN 操作数作检查，若有一个操作数为 NaN 则直接返回 NaN; 若有一个操作数为 0 则直接返回另一个操作数；若有一个操作数为 Infinity, 若另一个操作数也是 Infinity 且符号相同则返回第一个操作数；若另一个操作数也是 Infinity 且符号不同则返回 NaN; 若其他情况则返回 Infinity。
（2）对阶：对阶是将两个进行运算的浮点数的阶码对齐的操作。因为只有使两浮点数的指数值部分相同，才能将相同的指数值作为公因数提出来，然后进行尾数的加减运算。具体方法为：求出两浮点数阶码的差，即⊿E＝Ex-Ey，将小阶码加上⊿E，使之与大阶码相等，同时将小阶码对应的浮点数的尾数右移相应位数，以保证该浮点数的值不变。几点注意： • 对阶的原则是小阶对大阶。因为若大阶对小阶，则尾数的数值部分的高位需移出，而小阶对大阶移出的是尾数的数值部分的低位，这样损失的精度更小。 • 采用补码表示的尾数右移时，符号位保持不变。 • 由于尾数右移时是将最低位移出，会损失一定的精度，为减少误差，可先保留若干移出的位，供以后舍入处理用。
（3）尾数运算：主要为进行完成对阶后的尾数相加减的相关操作（包含隐藏位），采用双符号法判断是否溢出。
（4）结果规格化，主要分为三种 向右规格化：若上一步出现溢出，则尾数右移 1 位，阶码 + 1; 向左规格化：若上一步没有出现溢出，且数值域最高位与符号位数值相同，则尾数左移 1 位且阶码 - 1，直到数值域最高位为 1 为止。
（5）舍入处理：由于浮点数无法精确表示所有数值，因此在存储前必须对数值作舍入操作。具体有五种方式，这里我们只谈 IEEE 754 默认的舍入模式：就近舍入 Round to nearest, ties to even： 就是我们日常所说的四舍五入，当存在两个数一样接近时，取偶数值 (如 2.4 舍入为 2，2.6 舍入为 3；2.5 舍入为 2，1.5 舍入为 2)。 另外还有 round toward +∞，round toward -∞，round toward 0 这三种模式，有兴趣的可自行查相关资料。
（6）溢出判断：与定点数运算不同的是，浮点数的溢出是以其运算结果的阶码的值是否产生溢出来判断的。若阶码的值超过了阶码所能表示的最大正数，则为上溢，进一步，若此时浮点数为正数，则为正上溢，记为 +∞，若浮点数为负数，则为负上溢，记为 -∞；若阶码的值超过了阶码所能表示的最小负数，则为下溢，进一步，若此时浮点数为正数，则为正下溢，若浮点数为负数，则为负下溢。正下溢和负下溢都作为 0 处理。 一堆理论扯完之后，我们来看 0.1 + 0.2 的运算过程。 原本的 0.1 和 0.2 的二进制表示
0.1 = 1.1001100110011001100110011001100110011001100110011010 * 2^-4 0.2 = 1.1001100110011001100110011001100110011001100110011010 * 2^-3
可以看到，0.1 的阶码为 -4，0.2 的阶码为 -3，依照小阶对大阶的原则，我们需要将 0.1 的阶码变为 -3，因此其尾数部分需要右移一位。对阶之后 0.1 的存储为： 0.1 = 0.11001100110011001100110011001100110011001100110011010 * 2^-3 想右移一位导致尾数需要进行阶段，因为最后一位刚好是 0，所以这里直接舍弃，因此 0.1 对阶之后的存储为
s:0 exp:01111111100 frac:1100110011001100110011001100110011001100110011001101
然后我们就可以愉快的进行相加这个运算步骤了：
0 01111111100 1100110011001100110011001100110011001100110011001101 + 0 01111111100 1001100110011001100110011001100110011001100110011010
计算的话，手动画一画也没啥大问题，不过身为程序员就比较懒了，这里我们写一个二进制相加的方法：
const a = “1100110011001100110011001100110011001100110011001101”.split(’’); const b = “1001100110011001100110011001100110011001100110011010”.split(’’); const res = []; let flag = 0; for (let i = a.length - 1; i >= 0; i–) { const ai = parseInt(a[i]); const bi = parseInt(b[i]); const cur = (ai ^ bi) ^ flag; // 当前数值 flag = (ai + bi + flag) >= 2 ? 1 : 0; // 进位 res.unshift(cur); if (i === 0 && flag === 1) { res.unshift(flag); } } console.log(res.join(’’)); // 10110011001100110011001100110011001100110011001100111
得出：
0 01111111100 1100110011001100110011001100110011001100110011001101 + 0 01111111100 1001100110011001100110011001100110011001100110011010
= 0 01111111100 10110011001100110011001100110011001100110011001100111
可以看到发生了进位，此时尾数超过 52，因此阶码部分加 1（乘以 2），即阶码由原来的 -3 变为 -2，所以阶码部分为 01111111101。而尾数部分右移一位（除以 2），进行舍入（最后一位是 1 因此最低位进位），得到 52 位新的二进制表示为：
1011001100110011001100110011001100110011001100110011 11011001100110011001100110011001100110011001100110100
所以，最终的计算结果在计算机中的存储表达如下：
0 1111111101 1011001100110011001100110011001100110011001100110100
将其转换成十进制数为：
2^-2 + (1+(12^-1 + 0 * 2-2+1*2-3+12^-4+… ) = 0.3000000000000000444089209850062616169452667236328125
由于精度问题，只取到 0.30000000000000004。 然后看看 0.3.toString (2) 的结果
console.log(0.3.toString(2) ); // 0.010011001100110011001100110011001100110011001100110011
好了，我们已经知道为什么 0.1 + 0.2 !== 0.3 的原因了，主要由于 0.1 和 0.2 转为二进制的时候为无限循环小数，而计算机的存储位置有限因此会做一定的截取舍入处理，再进行加减就有一定的误差了。
我的解决办法：
把需要计算的数字乘以 10 的 n 次幂，然后用Math.round来四舍五入，换算成计算机能够精确识别的整数，然后再除以 10 的 n 次幂。然而这不够，实际操作会发现浮点数总有一点（小于Number.EPSILON）差距,导致Math.round出来的数有所偏差，所以我在此处添加 m 为-(digit+1), 解决精度问题。 （你可以把m去掉试试,会发现formatNum(8234.335, 2)的结果是8234.33）
formatNum = function(f, digit) { var n = Math.pow(10, digit); var m = Math.pow(10, -(digit+1)); return Math.round(f * n +m) / n; } console.log(formatNum(2.55,1)); // 结果: 2.6 console.log(formatNum(8234.335, 2)); // 结果：8234.34