0.1+0.2 为什么不等于0.3

本文详细解析了0.1+0.2不等于0.3的原因,涉及二进制浮点数表示、精度丢失与计算过程。在JavaScript中,由于浮点数存储限制,导致计算0.1+0.2时产生精度误差,最终结果为0.30000000000000004。此外,还探讨了由此引发的编程误差及解决方案,如使用Math.js库或toFixed()方法。

目录

一、0.1+0.2的计算过程

1.十进制转成二进制

2.转成浮点数

3.浮点数相加

4.浮点数转成十进制

二、答案

三、拓展


一、0.1+0.2的计算过程

1.十进制转成二进制

在JS内部所有的计算都是以二进制方式计算的。 所以运算 0.1+ 0.2 时要先把 0.1和 0.2 从十进制转成二进制。

  • 0.1转化成二进制的算法:
    0.1*2=0.2======取出整数部分0
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    接下来会无限循环
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    所以0.1转化成二进制是:0.0001 1001 1001 1001......
  • 0.2转化成二进制的算法:
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    接下来会无限循环
    0.2*2=0.4======取出整数部分0
    0.4*2=0.8======取出整数部分0
    0.8*2=1.6======取出整数部分1
    0.6*2=1.2======取出整数部分1
    所以0.2转化成二进制是:0.0011 0011 0011 0011......

这里要注意 0.1 和 0.2 转成的二进制是无穷的。另外在现代浏览器中是用浮点数形式的二进制来存储二进制,所以还要把上面所转化的二进制转成浮点数形式的二进制。

2.转成浮点数

浮点数分为单精度对应32位操作系统和双精度对应64位操作系统。目前的操作系统大多是64位操作系统,故这里只解释一下二进制如何转成双精度浮点数的二进制。

双精度浮点数用1位表示符号位,11位表示指数位,52位表示小数位,如下图所示:

  • 符号位:正数为0,负数为1;
  • 指数位:阶数+偏移量,阶数是:

,e为阶码的位数。偏移量是把小数点移动到整数位只有1时移动的位数,正数表示向左移,负数表示向右移;

  • 小数位:即二进制小数点后面的数。

接下来把0.1转成的二进制0.0001100110011001 ......转成浮点数形式的二进制。

  • 先要把小数点移动到整数位只有1,要向右移动4位,故偏移量为−4,通过指位数的计算公式

,把1019转成二进制为1111111011,不够11位要补零,最终得出指位数为01111111011;

  • 小数位为100110011001...... ,因为小数位只能保留52位,第53位为1故进1。

转换结果如下图所示:

同理,再把 0.2 转成的二进制0.0011 0011 0011 0011...... 转成浮点数形式的二进制,转换结果如下图所示:

3.浮点数相加

浮点数相加时,需要先比较指位数是否一致,如果一致则小数位直接相加,如果不一致,要先把指位数调成一致的,指位数小的向大的调整。

为了行文方便,把0.1转成的浮点数称为为0.1,把0.2转成的浮点数称为0.2。

0.1的指数位是1019 ,0.2的指数位是1020 。故要把0.1的指数位加1,即把0.1的小数点向左移动1位,另外浮点数的整数位固定为1,过程如下所示

1.1001100110011001100110011001100110011001100110011010   原先
0.11001100110011001100110011001100110011001100110011010  移动后  
0.1100110011001100110011001100110011001100110011001101   将小数的第53位舍去,因为为0故不需进1

导致0.1的小数位变成如下所示:

现在0.1和0.2的指数位相同了,把小数位直接相加。

    1100110011001100110011001100110011001100110011001101 0.1的小数位
+   1001100110011001100110011001100110011001100110011010 0.2的小数位
=  10110011001100110011001100110011001100110011001100111

会发现现在的小数位多出了一位,超出了52位,故要把小数位最后一位截掉,小数位最后一位是1,故要进1,如下所示:

10110011001100110011001100110011001100110011001100111
1011001100110011001100110011001100110011001100110100

截掉小数位的最后一位相当把小数点向左移了一位,故指数位要加1,此时的指数是0.2的指数1021 ,加1后变成1021 ,转成二进制为01111111101 ,那么相加后的浮点数如下所示:

4.浮点数转成十进制

二进制浮点数计算结束后,把结果(二进制的浮点数)转成十进制,其转换公式为

,s是符号位为0或1,e为浮点数指数位转成十进制的值,i表示小数位从左到右的位数,第一位 i=1 ,

表示每一位的值为0或1。

那么按着公式把二进制的浮点数转成十进制:

结果如下所示:

0.3000000000000000444089209850062616169452667236328125

由于精度问题,只取到0.30000000000000004。

二、答案

0.1+0.2 不等于 0.3 ,因为在 0.1+0.2 的计算过程中发生了两次精度丢失。第一次是在 0.1 和 0.2 转成双精度二进制浮点数时,由于二进制浮点数的小数位只能存储52位,导致小数点后第53位的数要进行为1则进1为0则舍去的操作,从而造成一次精度丢失。第二次在 0.1 和 0.2 转成二进制浮点数后,二进制浮点数相加的过程中,小数位相加导致小数位多出了一位,又要让第53位的数进行为1则进1为0则舍去的操作,又造成一次精度丢失。最终导致 0.1+0.2 不等于0.3 。

三、拓展

0.1+0.2 不等于 0.3 会引起那些BUG ?

会引起统计页面展示错乱的BUG,还有 300.01 优惠300 元后,支付金额不足0.01 元等类似的BUG。

怎么解决 0.1+0.2 不等于 0.3 ?

可以用Math.js数学计算库来解决,或者用toFixed()给计算结果四舍五入,但是toFixed()在chrome或者火狐浏览器下四舍五入也有精度误差。可以用Math.round来解决精度误差,比如要把 2.55 四舍五入保留 1 位小数,先把 2.55∗10 得到 25.5 ,再用Math.round取整25.5 ,会得到25,再把 25÷10 得到 2.5 ,就这样间接实现了四舍五入。可以用Math.pow来做个简单的封装Math.round(Math.pow(10, m) * number) / Math.pow(10, m),其中number是要四舍五入的数,m是保留几位小数。

<think> 首先,用户的问题是:我想了解在JavaScript0.1 + 0.2等于0.3的原因。用户明确要求解释原因。 我有几个引用提供背景: - 引用[1]解释了这是一个常见问题,涉及浮点数的表示。 - 引用[2]提到这发生在多种语言如Java、Python、JavaScript中。 - 引用[3]展示了JavaScript代码示例,显示0.1 + 0.2的结果是0.30000000000000004,等于0.3。 - 引用[4]提供了解决方案,使用Number.EPSILON来比较浮点数。 关键点是,这个问题源于计算机如何表示浮点数,使用的是IEEE 754标准,特别是双精度浮点数(64位),这在JavaScript中是默认的。 原因的核心: - 浮点数在计算机中是用二进制表示的,而是十进制。 - 0.10.2在十进制中是简单的分数,但在二进制中是无限循环小数。 - 0.1 (十进制) = 1/10 = 在二进制中是0.0001100110011...(无限循环) - 0.2 (十进制) = 1/5 = 在二进制中是0.001100110011...(无限循环) - 由于内存限制,计算机只能存储有限位数,因此这些值被四舍五入到最接近的可表示值,这引入了舍入误差。 - 当相加时,这些误差累积,导致结果是精确的0.3。 - 0.3在二进制中也是无限循环小数:0.01001100110011...,所以它也能被精确表示。 在JavaScript中,当执行0.1 + 0.2时,实际计算涉及这些近似值,结果是一个接近但等于0.3的值,如0.30000000000000004。 我的回答需要: - 使用中文。 - 结构清晰,逐步解释。 - 遵循系统级指令:行内数学表达式用 $...$,独立公式用 $$...$$ 并单独成段。 - 正确使用LaTeX语法。 - 生成相关问题。 - 在引用的段落末尾添加引用标识,如 [^1]。引用来自提供的参考。 引用来源: - 引用[1] 来自 "13-为什么JavaScript0.1 + 0.2等于0.3?" - 引用[2] 来自 "【10.24程序员节征文】(转载)" - 引用[3] 来自 "0.1 + 0.2 到底等等于 0.3 ?" - 引用[4] 来自 "JavaScript0.1+0.2为什么等于0.3?如何实现等于0.3?" 我应该在回答中自然地引用这些,当使用它们的信息时。 回答结构: 1. **引言**:承认问题并简要解释这是一个常见现象。 2. **原因解释**: - 描述浮点数表示。 - 解释二进制表示下的问题。 - 使用数学表达式说明。 - 讨论IEEE 754标准。 3. **JavaScript特定**:展示代码示例,并解释结果。 4. **解决方案**:简要提到如何处理这个问题,如使用Number.EPSILON。 5. **生成相关问题**:在最后添加相关问题部分。 确保数学表达式正确: - 行内:例如,$0.1_{10} = 0.0001100110011\ldots_{2}$ - 独立公式:如果需要详细公式。 最终,添加相关问题部分。 </think>### JavaScript0.1 + 0.2等于0.3的原因 在JavaScript中,表达式 `0.1 + 0.2` 的结果并精确等于 `0.3`,而是会得到类似 `0.30000000000000004` 的值。这是因为计算机在处理浮点数时使用了二进制表示法,导致十进制小数在转换过程中出现舍入误差。下面我将逐步解释这一现象的原因。 #### 1. **浮点数在计算机中的表示** - 计算机使用二进制(base-2)系统存储数字,而人类通常使用十进制(base-10)。像 `0.1` 和 `0.2` 这样的十进制小数,在二进制中无法精确表示。 - 例如: - $0.1_{10}$(十进制)在二进制中是无限循环小数:$0.1_{10} = 0.0001100110011\ldots_{2}$。 - $0.2_{10}$ 在二进制中也是无限循环小数:$0.2_{10} = 0.001100110011\ldots_{2}$。 - 计算机使用 IEEE 754 标准(双精度浮点数)存储浮点数,该标准只有64位空间(1位符号位、11位指数位、52位尾数位)。因此,无限循环的二进制小数必须被截断和四舍五入,导致精度损失[^1][^2]。 #### 2. **舍入误差的累积** - 当 `0.1` 和 `0.2` 被转换为二进制浮点数时,它们会被近似存储: - $0.1 \approx 1.10011001100110011001101 \times 2^{-4}$(在 IEEE 754 中)。 - $0.2 \approx 1.10011001100110011001101 \times 2^{-3}$。 - 在加法操作中: $$ 0.1 + 0.2 \approx (1.10011001100110011001101 \times 2^{-4}) + (1.10011001100110011001101 \times 2^{-3}) $$ 由于指数同,需要对齐后进行加法,这会放大舍入误差。最终结果近似为: $$ 0.3000000000000000444089209850062616169452667236328125 $$ 在JavaScript中,这个值被简化为 `0.30000000000000004`[^1][^3]。 - 相比之下,`0.3` 在二进制中也是无限循环小数:$0.3_{10} = 0.01001100110011\ldots_{2}$,因此它同样无法精确存储。计算机存储的 `0.3` 是一个近似值,但 `0.1 + 0.2` 的计算结果等于这个近似值[^2]。 #### 3. **JavaScript中的验证** - 在JavaScript中运行以下代码,可以看到结果: ```javascript console.log(0.1 + 0.2); // 输出: 0.30000000000000004 console.log(0.1 + 0.2 === 0.3); // 输出: false ``` 这是因为 `0.1 + 0.2` 的实际结果略大于 `0.3`,而 JavaScript 使用严格的相等比较(`===`),因此返回 `false`[^3][^4]。 - 这JavaScript独有的问题,而是所有使用 IEEE 754 浮点数的语言(如Python、Java)中的常见现象[^2]。 #### 4. **如何避免或处理这个问题** - 在需要精确比较时,要直接使用 `==` 或 `===` 比较浮点数。可以使用容差(tolerance)方法: ```javascript // 使用 Number.EPSILON(ES6引入,表示最小的浮点数误差) function isEqual(a, b) { return Math.abs(a - b) < Number.EPSILON; } console.log(isEqual(0.1 + 0.2, 0.3)); // 输出: true ``` `Number.EPSILON` 的值约为 $2^{-52} \approx 2.220446049250313 \times 10^{-16}$,它定义了可接受的误差范围[^4]。 - 或者,将浮点数转换为整数进行计算(例如,以分为单位处理金额)。 总之,`0.1 + 0.2 !== 0.3` 的原因在于二进制浮点数表示的局限性,导致舍入误差在算术运算中累积。这是bug,而是计算机科学中的基本限制[^1][^3]。
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值