JavaScript 浮点数陷阱

已于 2022-03-31 21:46:57 修改
阅读量3.5k 收藏
点赞数 1
分类专栏： JavaScript 文章标签： javascript ecmascript
于 2021-12-24 13:52:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/don_gw/article/details/109067208
版权

在这里插入图片描述

前言

  JavaScript中的浮点数经常会有奇怪的运算结果，例如0.1 + 0.2 != 0.3或者是1.005.toFixed(2)结果为1.00，又或者Number.MAX_VALUE与Number.MAX_SAFE_INTEGER的区别等等。

  此处对JavaScript浮点数的存储标准和以上疑问做了比较细致的整理，希望对你有用。

IEEE 754

  JavaScript与其它语言不同，Number类型是不区分整型和浮点的。对于所有的数字包括整数和小数相同存储，遵循IEEE 754的双精度标准，64位固定长度，也即是常说的double类型。

  由于整数和小数都采用64位存储，对于内存来说整型和浮点型也就没有区别了。

位运算上，会将操作数转为32位有符号数，小数部分直接丢弃

  64位比特包括三个部分。

  • 符号位（S，sign）：第63位，0表示正数，1表示负数
  • 指数位（E，exponent）：第52到62位，共11位，取值范围为0~2047。但是指数位是可以为负数的，偏移2023后取值范围变为[-1023, 1024]
  • 尾数位（M，mantissa）：第0到51位，共52位。

在这里插入图片描述

  计算公式为。

V = ( − 1 ) S 2 E − 1023 ( M + 1 ) V=(-1)^S2^{E-1023}(M+1) V=(−1)S2E−1023(M+1)

  11.25的64位表示。

  • 将整数和小数部分转换成二进制，即11.25 = 1011.01
  • 移动小数点，使其位于第1、2位之间，规范化为1.01101 * 2 ^ 3
  • 11.25为正数，S = 0。另外指数为3，则E = 1023 + 3 = 1026，即100 0000 0010
  • 舍去整数部分1，剩下尾数部分01101，空位补0，即0110 1000 ... 0000（52位）
  • 11.25的64位浮点数的二进制表示为0 10000000010 01101000...0000

在这里插入图片描述

  (图片来源)

规范化后的整数部分必然为1，存储时可以省略，只记录小数点之后的部分, 也就节约了一位内存

就近舍入

  在四舍五入中，0 ~ 9十个数，0比较特殊，不会存在舍去的情况，舍不舍去都是当前数。而剩下的9个数中，1 ~ 4舍去，5 ~ 9上入，概率上舍去为4 / 9，上入为5 / 9，因此并不是公平的。

  就近舍入，或者叫银行家舍入，是四舍六入五成双。即1 ~ 4舍去，6 ~ 9上入，5的情况则看前一位是奇数还是偶数，偶数则舍去，奇数则上入，因此概率都是50%，更加合理。

  二进制中的就近舍入，其中1001大于1000则上入1，0111小于1000则舍去，而对于1000的情况，看前一位是奇数还是偶数，若为0则舍去，为1则上入1。

1.001 1001 // 1.010
1.001 0111 // 1.001
1.001 1000 // 1.010

1.100 1001 // 1.101
1.100 0111 // 1.100
1.100 1000 // 1.100

Number.MAX_VALUE

  Number.MAX_VALUE 即JavaScript中所能表示的最大数值。

  按照IEEE 754的64位标准，可以明显想到以下表示。

0 11111111111 1111111111111111111111111111111111111111111111111111

  但是注意指数位全为1用来表示NaN或Infinity，因此指数位最大为111 1111 1110。

0 11111111110 1111111111111111111111111111111111111111111111111111

  转为十进制。

  1.1111111111111111111111111111111111111111111111111111 * 2 ^ (2046 - 1023)
= 1.1111111111111111111111111111111111111111111111111111 * 2 ^ 1023
= 1 1111111111111111111111111111111111111111111111111111 * 2 ^ (1023 - 52)
= 1 1111111111111111111111111111111111111111111111111111 * 2 ^ 971
= (2 ^ 53 - 1) * 2 ^ 971
= 1.7976931348623157e+308

  也即是Number.MAX_VALUE。

(Math.pow(2, 53) - 1) * Math.pow(2, 971) // 1.7976931348623157e+308
(Math.pow(2, 53) - 1) * Math.pow(2, 971) === Number.MAX_VALUE // true

Number.MAX_SAFE_INTEGER

  Number.MAX_SAFE_INTEGER 表示JavaScript中最大的安全整数。

  Number.MAX_SAFE_INTEGER二进制表示，注意指数刚好为52。

0 10000110011 1111111111111111111111111111111111111111111111111111

  转为十进制。

  1.1111111111111111111111111111111111111111111111111111 * 2 ^ (1075 - 1023)
= 1.1111111111111111111111111111111111111111111111111111 * 2 ^ 52
= 1 1111111111111111111111111111111111111111111111111111
= 2 ^ 53 - 1
= 9007199254740991

  然后来说说为什么叫安全整数，指的是当前整数转换为二进制时，可以完全存储在尾数位中，不会发生舍入。

  而Number.MAX_SAFE_INTEGER + 1和Number.MAX_SAFE_INTEGER + 2都会存在舍去的情况。

  Number.MAX_SAFE_INTEGER + 2，9007199254740993的二进制表示。

100000000000000000000000000000000000000000000000000001

  规范化。

1.00000000000000000000000000000000000000000000000000001 * 2 ^ 53

  由于指数位只能容纳52位，低位为1且前一位为0，就近舍入时会被舍去。

0000000000000000000000000000000000000000000000000000(1)
0000000000000000000000000000000000000000000000000000

  64位浮点数表示。

0 10000110100 0000000000000000000000000000000000000000000000000000

  另外Number.MAX_SAFE_INTEGER + 1，也会存在舍去的情况。

  9007199254740992的浮点数表示。

0 10000110100 0000000000000000000000000000000000000000000000000000

  因此会造成以下结果。

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2 // true

0.1 + 0.2 != 0.3

0.1

  先来将0.1转换为二进制，连续乘以2并取整。

0.1 * 2 = 0.2 ----- 整 0 余 0.2
0.2 * 2 = 0.4 ----- 整 0 余 0.4
0.4 * 2 = 0.8 ----- 整 0 余 0.8
0.8 * 2 = 1.6 ----- 整 1 余 0.6
0.6 * 2 = 1.2 ----- 整 1 余 0.2
0.2 * 2 = 0.4 ----- 整 0 余 0.4

  0.1的二进制表示，0011将无限循环下去。

0.0 0011 0011 0011 (0011)

  规范化，另外0.1为正数，S = 0，指数为-4 + 1023 = 1019，即011 1111 1011。

1.1 0011 0011 (0011) * 2 ^ -4

  尾数位最多存储52位，且采用就近舍入模式，向前进1。

1001100110011001100110011001100110011001100110011001(10011)
1001100110011001100110011001100110011001100110011010

  0.1的64位浮点数表示。

0 01111111011 1001100110011001100110011001100110011001100110011010

在这里插入图片描述

0.2

  0.2的二进制。

0.0011 0011 0011 (0011)

  规范化0.2，S = 0，指数为-3 + 1023 = 1020，即011 1111 1100。

1.1 0011 0011 (0011) * 2 ^ -3

  存储52位，其余舍去，向前进1。

1001100110011001100110011001100110011001100110011001(10011) 
1001100110011001100110011001100110011001100110011010

  0.2的64位浮点数表示。

0 01111111100 1001100110011001100110011001100110011001100110011010

在这里插入图片描述

  因此实际上0.1和0.2转换为64位的双精度浮点数时，都存在精度损失。

0 01111111011 1001100110011001100110011001100110011001100110011010 // 0.1
0 01111111100 1001100110011001100110011001100110011001100110011010 // 0.2

浮点数运算三步骤，对阶、求和、规范化

对阶

  0.1和0.2的指数部分阶次不一致，要先统一阶次，且遵循小阶向大阶看齐的原则。

  比如十进制的1.5 * 10 ^ 10 + 1.23 * 10 ^ 13，保留小数点前后1位。

  • 大阶向小阶看齐时，即1.5 * 10 ^ 10 + 1230 * 10 ^ 10，结果为1231.5 * 10 ^ 10，规则舍弃后为1.5 * 10 ^ 10
  • 小阶向大阶看齐时，即0.0015 * 10 ^ 13 + 1.23 * 10 ^ 13，结果为1.2315 * 10 ^ 13，规则舍弃后为1.2 * 10 ^ 13

  明显看到小阶向大阶更能接近实际结果。另外阶次若加1，尾数位就要右移1位，阶次相同时对阶完成。

  为什么阶次加1尾数位就右移1位呢？

  0.1的64位浮点数表示，值为1.1001 1001 ... 1001 1001 1010 * 2 ^ -4。

0 01111111011 (1.)1001100110011001100110011001100110011001100110011010

  此处若阶次加1，要保持值大小不变，小数点要左移1位，即0.1 1001 1001 ... 1001 1001 1010 * 2 ^ -3，也就相当于尾数位右移1位。右移后空位补1，也就是省略的整数部分的1。注意若还要右移，空位只能补0，原因在于整数部分后续都是0了。

0 01111111110 (0.)1100110011001100110011001100110011001100110011001101(0)

  因此对阶过程如下，由于低位为0，可以省去。

0 01111111011 1001100110011001100110011001100110011001100110011010 // 0.1
0 01111111100  100110011001100110011001100110011001100110011001101(0) // 阶次加 1，尾数位右移 1 位
0 01111111100 1100110011001100110011001100110011001100110011001101 // 空位补 1

注意尾数位右移是将低位移出，会损失一定的精度，为了减小误差，将保留若干移出的位，在以后的规范化时再做舍入

求和

  阶数相同，开始求和。

  0 01111111100 1100110011001100110011001100110011001100110011001101 // 0.1
+ 0 01111111100 1001100110011001100110011001100110011001100110011010 // 0.2

  更好理解的方式，注意尾数位产生了进位。

  0.1100110011001100110011001100110011001100110011001101
+ 1.1001100110011001100110011001100110011001100110011010
 10.0110011001100110011001100110011001100110011001100111

规范化

  求和结果为10.0 1100 1100 ... 1100 1100 111 * 2 ^ -3，即1.00 1100 1100 ... 1100 1100 111 * 2 ^ -2。

1.00110011001100110011001100110011001100110011001100111

  由于指数位只能容纳52位，就近舍入后向前进1。

0011001100110011001100110011001100110011001100110011(1)
0011001100110011001100110011001100110011001100110100

  IEEE 754的双精度64位表示。

0 01111111101 0011001100110011001100110011001100110011001100110100

  即1.0011 0011 ... 0011 0011 0100 * 2 ^ -2，转换为十进制也就是0.30000000000000004。

小结

  要明确的是，诸如0.1、0.2之类的数，虽然在十进制中能非常清晰地表达，但是在二进制中却是无穷尽的，无法精确表示。而JavaScript遵循IEEE 754的双精度标准，仅64位，进制的转换中要舍弃低位来存储，因此必然存在精度丢失。

  另外在相加的过程中，对阶、求和、规范化都可能存在舍入，也会存在精度的丢失。

1.005.toFixed(2)

  1.005的二进制表示，0000 1010 0011 1101 0111将无限循环下去。

1.000 (0000 1010 0011 1101 0111)

  IEEE 754的双精度64位表示。

0 01111111111 0000000101000111101011100001010001111010111000010100(0)
0 01111111111 0000000101000111101011100001010001111010111000010100

  1.005截断后面位数后，已经小于1.005，利用 Number.prototype.toPrecision 来看下1.005的20位精度。

在这里插入图片描述

  因此toFixed保留两位小数，四舍五入时。

1.005.toFixed(2) // 1.00

Number.MAX_VALUE + 1 不是 Infinity

Number.MAX_VALUE + 1 === Number.MAX_VALUE

  Number.MAX_VALUE与1的64位浮点数表示为。

0 11111111110 1111111111111111111111111111111111111111111111111111 // Number.MAX_VALUE
0 01111111111 0000000000000000000000000000000000000000000000000000 // 1

  相加对阶时1的阶数将由0升到1023，尾数位将右移1023位。

  0 11111111110 1111111111111111111111111111111111111111111111111111 // Number.MAX_VALUE
+ 0 11111111110 0000000000000000000000000000000000000000000000000000(000...0001) // 1

  求和。

  1.1111111111111111111111111111111111111111111111111111
+ 0.0000000000000000000000000000000000000000000000000000(000...0001)
  1.1111111111111111111111111111111111111111111111111111(000...0001)

  规范化时低位将舍弃，实际相当于Number.MAX_VALUE加0，所以会有以下结果。

Number.MAX_VALUE + 1 === Number.MAX_VALUE // true

2 ^ 970

  那到底Number.MAX_VALUE加上多少等于Infinity呢？

  按照IEEE 754的规范，只要大于等于以下数，就会被表示为Infinity。

2 E m a x ( 2 − 2 1 − p 2 ) 2^{E_{max}}(2-\frac{2^{1-p}}{2}) 2Emax​(2−221−p​)

  64位浮点数中，Emax为1023，p为53。

  2 ^ 1023 * (2 - 2 ^ (1 - 53) / 2)
= 2 ^ 1023 * (2 - 2 ^ -53)
= 2 ^ 970 * (2 ^ 54 - 1)

  此结果与Number.MAX_VALUE差值为。

  (2 ^ 54 - 1) * 2 ^ 970 - (2 ^ 53 - 1) * 2 ^ 971
= 2 ^ 970

  因此Number.MAX_VALUE至少加上2 ^ 970才能等于Infinity。

Number.MAX_VALUE + 2 ^ 970 === Infinity

  Number.MAX_VALUE与2 ^ 970的64位浮点数表示。

0 11111111110 1111111111111111111111111111111111111111111111111111 // Number.MAX_VALUE
0 11111001001 0000000000000000000000000000000000000000000000000000 // 2 ^ 970

  相加对阶时2 ^ 970阶数将由970升到1023，差值为53，尾数位将右移53位。

  0 11111111110 1111111111111111111111111111111111111111111111111111 // Number.MAX_VALUE
+ 0 11111111110 0000000000000000000000000000000000000000000000000000(1) // 2 ^ 970

  求和，就近舍入时，低位舍入，向前进1。

  1.1111111111111111111111111111111111111111111111111111
+ 0.0000000000000000000000000000000000000000000000000000(1)
  1.1111111111111111111111111111111111111111111111111111(1)
 10.0000000000000000000000000000000000000000000000000000

  注意尾数位产生了进位，指数位则加1，尾数位右移1位。

  结果的64位浮点数表示，而以下表示实际就是Infinity的64位浮点数表示。

0 11111111111 0000000000000000000000000000000000000000000000000000

参考

🎉 写在最后

🍻伙伴们，如果你已经看到了这里，觉得这篇文章有帮助到你的话不妨点赞👍或 Star ✨支持一下哦！

手动码字，如有错误，欢迎在评论区指正💬~

你的支持就是我更新的最大动力💪~

GitHub / Gitee、GitHub Pages、掘金、CSDN 同步更新，欢迎关注😉~

DonV
关注
专栏目录
浅析js中的浮点型运算问题
12-09
js中浮点型是如何运算的呢？ 例如：var a=0.69; 我想得到6.9 直接这样写 var c=a*10; alert(c);   得到结果是：6.8999999999999995 到网上一搜，有网友说这是一个JS浮点数运算Bug,找了解决方法： 方法一：有js自定义函数 代码如下:[removed] //加法函数，用来得到精确的加法结果 //说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。 //调用：accAdd(arg1,arg2) //返回值：arg1加上arg2的精确结果 function accAdd(arg1,arg
帮助避免错误的Javascript陷阱清单
10-29
在Javascript编程中，浮点数的运算可能会让初学者感到困惑。由于浮点数在计算机内部是以二进制形式表示的，这可能导致精度问题。例如： ```javascript alert(0.02 / 0.1); // 0.*** alert(1.14 * 100); // 113.*** ...
js 浮点数陷阱
林恒的博客
01-08 210
众所周知，JavaScript 浮点数运算时经常遇到会0.000000001和0.999999999这样奇怪的结果，如0.1+0.2=0.30000000000000004、1-0.9=0.09999999999999998，很多人知道这是浮点数误差问题，但具体就说不清楚了。本文帮你理清这背后的原理以及解决方案，还会向你解释JS中的大数危机和四则运算中会遇到的坑。 浮点数的存...
JavaScript 浮点数陷阱及解法
前端开发博客
12-10 554
关注公众号前端开发博客，回复“加群”加入我们一起学习，天天进步作者：camsong链接：https://github.com/camsong/blog/issues/9众所周知，Jav...
令人误解的浮点
qq_42309685的博客
09-22 96
令人误解的浮点 JavaScript 中的数字均保存为64位的浮点数(Floats) 所有的编程语言，包括JavaScript，都存在处理浮点值的困难，例如下面这串代码： var a = 0.2; var b = 0.4; var c = a + b; console.log(c); 竟然不是0.6 ,而是0.6000000000000001怎么处理上面的这种情况呢？ 请用乘除运算 var a ...
解决JS浮点数(小数)计算加减乘除的BUG
最新发布
01-04
总的来说，理解JavaScript浮点数计算的底层原理以及其可能导致的误差是至关重要的。通过采用适当的策略，如四舍五入、使用高精度库或调整比较方式，可以有效地解决这类问题，确保计算结果的准确性。在实际开发中，...
JavaScript中的数值范围介绍
12-09
JavaScript中的数值类型是基于ECMAScript规范的，所有数字都被表示为64位浮点数，这与Java的`double`类型类似。这意味着JavaScript能够处理的数值范围是有限的，并且对于某些运算，精度可能会受到影响。以下是关于...
JavaScript秘密花园：探索诡异用法与陷阱
"JavaScript秘密花园是一个专注于揭示JavaScript中不寻常特性和陷阱的文档，旨在帮助开发者避免常见错误、性能问题和不良实践。该资源强调深入理解JavaScript语言特性，并且建议读者具备一定的基础知识。作者包括Ivo...
shell脚本打字游戏界面框架
Mr.W的博客
11-13 4771
本来有音乐来着，但是由于音乐文件没有，所以没有音乐，如果需要音乐，怎么后台播放，以及怎么去杀死这个进程，当时测试的时候加上去的，参照程序顶头注释部分，前提条件：装好了相应的播放器，准备好了相应的音乐文件。此代码保存到xxx.sh文件即可运行  #!/bin/bash #declare -i mm #nohup play 刚刚好.flac & #pgrep play > 1.txt...
Hadoop 基本常用命令
石头
08-03 1044
hdfs文件的相关操作主要使用hadoop fs、hadoop dfs、hdfs dfs 命令 hadoop fs命令可以用于HDFS、Local FS等不同的文件系统。而hdfs dfs命令只用于HDFS文件系统； （1）查看帮助 hdfs dfs -help （2）查看当前目录信息 hdfs dfs -ls / ...
CPU高速缓存SRAM命中问题的总结与实验
liu_if_else的博客
11-23 3271
1，多级缓存结构由于内存传输信号至CPU的速度过慢（相对于CPU的计算速度），目前在CPU与内存之间都存在着多级缓存（intel core i5和i7是3级缓存，L1,L2,L3），内存，缓存，CPU的结构关系大致如下。 (图1）高速缓存中存储信息的主要单位是组（sets)，每组里有行（associative)，每行里存着固定大小的字节，数据块，（line size）。每级缓存大小既是sets*a
关于JAVA底层编码和输出中文乱码问题
xiaohao0001abc的博客
02-25 1053
输出乱码问题和从Java编码层次来解决解释问题
关于Integer.MAX_VALUE + 1 = Integer.MIN_VALUE 问题
时光如白驹过隙的博客
09-11 3455
1、负数二进制表示 由于计算机中数据都以二进制表示，而负数的二级制是根据正数二进制取补码（补码就是先取反码，然后加1）得到，如： 一个int 类型的数值为5，其长度为32位，二进制表示为 00000000 00000000 00000000 00000101 -5是根据5的二进制表示每一位先取反码（0变1，1变0）得到 11111111 11111111 11111111 11111010 再对反码加1，得到-5的二进制表示 11111111 11111111 11111111 11111011 2、
大数相乘算法
weixin_33775572的博客
08-23 384
几年前曾经写过大数相乘，但也忘记怎么写了。今天重新写了一个，中心思想就是把乘法变成加法，用字符串的方式去模拟。 感觉效率很差，算1000！花了2分23秒。有很多地方可以优化，但是目前还没时间去想。 顺便记一下： 1000!= 40238726007709377354370243392300398571937486421071463254379991042993851239862902 ...
洛谷题单 算法1-1 模拟和高精度
付某人的博客
07-23 1333
1 乒乓球 题目背景 国际乒联现在主席沙拉拉自从上任以来就立志于推行一系列改革，以推动乒乓球运动在全球的普及。其中1111分制改革引起了很大的争议，有一部分球员因为无法适应新规则只能选择退役。华华就是其中一位，他退役之后走上了乒乓球研究工作，意图弄明白1111分制和2121分制对选手的不同影响。在开展他的研究之前，他首先需要对他多年比赛的统计数据进行一些分析，所以需要你的帮忙。 题目描述 华华通过以下方式进行分析，首先将比赛每个球的胜负列成一张表，然后分别计算在1111分制和2121分制下，双方的比赛结果（
【03NOIP普及组】麦森数（信息学奥赛一本通 1925）（洛谷 1045）
anglanjing7414的博客
08-06 929
【题目描述】 形如2P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。 任务：输入P（1000＜P＜3100000），计算2P-1的位数和最后500位数字(用十进制高精度数表示) 【输入】 ...
ALV tree DUMP 问题处理-20180328
anchangong3418的博客
03-28 1455
Category ABAP Programming Error Runtime Errors MESSAGE_TYPE_X ABAP Program ...
Codevs_P2123 麦森数2
BeiYu
11-03 1120
题目描述 Description 形如2P-1的素数称为麦森数, 这时P一定也是个素数. 但反过来不一定, 即如果P是个素数, 2P-1不一定也是素数. 在1998年底, 人们找到了37个麦森数. 当时最大的一个是P=3021377, 它有909526位. 但是截止到2013年2月, 美国中央密苏里大学数学家库珀领导的研究小组通过参加一个名为“互联网梅森素数大搜索”(GIMPS)项目, 日前发现了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DonV

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值