js 小数点精度问题 0.1+0.2 !== 0.3 解释原理 计算机小白也能懂

femario
79 阅读8分钟

在 JavaScript 中，0.1 + 0.2 的结果不等于 0.3，这其实是一个由计算机内部表示浮动小数的方式引起的问题。为了通俗易懂地解释这个问题，我们需要了解计算机如何处理数字。

计算机如何表示数字？

计算机内部的数字并不是完全按照我们平时写的方式存储的。我们通常会认为数字像 0.1 和 0.2 是“精确的”，但在计算机中，这些数字是通过二进制（0 和 1）来表示的。而不是所有的数字都可以完美地用二进制表示。

比如：

  • 0.1 在二进制中是一个无限不循环的小数，就像我们用十进制表示 1/3（它是一个无限循环的小数：0.333...）。
  • 0.2 也有类似的二进制表示问题。

为什么 0.1 + 0.2 !== 0.3？

当计算机将 0.1 和 0.2 转换成二进制数时，它们无法被完全精确表示。因此，它们在计算时会有一些微小的误差。当我们加起来时，这些误差会累积，导致结果 0.1 + 0.2 不等于 0.3，而是一个很接近 0.3 的数字，可能是 0.30000000000000004。

举个例子：

  1. 0.1 在计算机中存储的实际上是一个非常接近但不完全等于 0.1 的数字。
  2. 0.2 也是如此。

所以，当你执行 0.1 + 0.2 时，计算机得出的结果是一个稍微大于 0.3 的值，结果是 0.30000000000000004。

解决方法：

如果你需要做比较，可以使用一些方法来避免直接比较浮点数，比如：

  • 四舍五入：你可以将计算结果四舍五入到特定的小数位数（例如 2 位）。

    const result = (0.1 + 0.2).toFixed(1);  // "0.3"

  • 使用误差范围：可以设置一个小的误差值（比如 0.00001），如果两个数的差小于这个误差值，就认为它们是相等的。

这个问题不仅仅出现在 JavaScript 中，几乎所有计算机语言中的浮点数都会有类似的情况，因为它们都是基于二进制表示法的。

背后的原理

这个问题背后的原理涉及到计算机如何表示和处理浮点数的 精度问题。我们从计算机内部如何存储数字的方式来深入了解。

1. 浮点数的二进制表示

计算机使用 二进制（0 和 1）来表示所有数据，包括数字。在十进制系统中，数字像 0.1 和 0.2 看起来是简单的分数（分别是 1/10 和 2/10），但在二进制中，这些数字无法精确表示。

  • 0.1 在二进制下无法完全精确表示。它变成了一个无限长的二进制数，像 0.00011001100110011... 这样不断重复下去。
  • 同样，0.2 在二进制下也无法精确表示，它变成了 0.0011001100110011...。

计算机通常会将这些无限的二进制数字截断，取一个有限长度的近似值。因此，当计算机存储 0.1 和 0.2 时，它们实际上是非常接近但不完全等于 0.1 和 0.2 的数字。

2. 浮点数的精度限制

为了节省内存和提高运算效率，计算机使用 浮点数格式 来表示这些非整数的数字。浮点数有固定的精度，通常是 32 位（单精度）或 64 位（双精度），这意味着计算机只能表示有限精度的数值。对于某些数字（比如 0.1 和 0.2），它们无法用有限的位数准确表示，只能表示成一个最接近的数。

3. 误差积累

当进行 0.1 + 0.2 这样的加法操作时，计算机会首先将 0.1 和 0.2 转换成它们各自的近似值。然后进行加法运算，但由于每个数的近似值都含有一些误差，最终结果也会有误差。

具体来说，计算机内部实际上计算的是：

0.1 (近似值) + 0.2 (近似值) = 0.30000000000000004

这个结果是因为在加法过程中，微小的误差并没有完全消失，而是累积在一起，导致最终的结果稍微偏大，出现了 0.30000000000000004。

4. IEEE 754 标准

浮点数在计算机中的表示遵循 IEEE 754 标准，它定义了如何在计算机中存储和操作浮点数。标准中规定了如何将一个十进制数转换为二进制浮点数，但由于二进制系统和十进制系统的差异，某些小数在转换时会丢失精度。

总结

  • 问题的根本原因：计算机用二进制表示数字，而某些十进制数（如 0.1 和 0.2）在二进制中无法精确表示，因此计算结果会出现微小的误差。
  • 精度限制：计算机有固定的精度（如 32 位或 64 位），这导致无法表示无限的或非常精确的小数。
  • 累积误差：在执行运算时，误差会积累，导致最终结果的精度不符合我们的预期。

这是计算机中浮点数运算的普遍问题，并不仅仅是 JavaScript 中的特例，其他编程语言也会遇到类似的精度问题。

推荐的第三方库

为了解决 JavaScript 中的浮点数精度问题，许多开发者采用了第三方库来处理浮点数的精度和计算问题。以下是一些常用且流行的第三方库：

1. Big.js

  • 简介：Big.js 是一个专门用于高精度数学运算的库，特别适合处理浮点数精度问题。它支持任意精度的十进制运算，不会出现传统浮点数计算中的误差。

  • 特点：

    • 精确处理浮点运算，避免了 0.1 + 0.2 !== 0.3 这样的错误。
    • 支持加法、减法、乘法、除法等多种数学运算。
    • 处理大数也非常方便。

  • 安装：

    npm install big.js

  • 示例代码：

    const Big = require('big.js');

let sum = new Big(0.1).plus(0.2);
console.log(sum.toString());  // 输出: 0.3

2. Decimal.js

  • 简介：Decimal.js 是一个高精度的浮点数库，它允许你在应用程序中进行高精度的数学运算，避免了 JavaScript 本身浮点数表示精度不准确的问题。

  • 特点：

    • 提供了比 JavaScript 原生浮点数更高精度的运算。
    • 支持整数和小数的运算。
    • 提供多种数学函数，例如：sqrt, log, exp 等。

  • 安装：

    npm install decimal.js

  • 示例代码：

    const Decimal = require('decimal.js');

let sum = new Decimal(0.1).plus(0.2);
console.log(sum.toString());  // 输出: 0.3

3. bignumber.js

  • 简介：bignumber.js 是一个高精度的数学运算库，适用于需要进行大数字计算和浮点精度调整的场景。

  • 特点：

    • 用于处理任意精度的数字，能够防止浮点数计算精度丢失。
    • 支持加法、减法、乘法、除法等基本运算。
    • 支持大数和小数的处理。

  • 安装：

    npm install bignumber.js

  • 示例代码：

    const BigNumber = require('bignumber.js');

let sum = new BigNumber(0.1).plus(0.2);
console.log(sum.toString());  // 输出: 0.3

4. Math.js

  • 简介：Math.js 是一个功能强大的数学库，适用于解决更复杂的数学计算，包括线性代数、统计学等领域。它也可以解决浮点数精度问题，提供了大数和精确小数的支持。

  • 特点：

    • 支持大数计算和符号计算。
    • 提供了丰富的数学函数。
    • 可以配置精度设置，避免浮点数的误差。

  • 安装：

    npm install mathjs

  • 示例代码：

    const math = require('mathjs');

let sum = math.bignumber(0.1).plus(0.2);
console.log(sum.toString());  // 输出: 0.3

5. NumJS

  • 简介：NumJS 是一个针对数学和数值运算的库，灵感来自于 Python 的 NumPy 库，适合需要进行复杂计算的应用。

  • 特点：

    • 提供类似于 NumPy 的 API。
    • 支持高精度浮点数计算。

  • 安装：

    npm install numjs

  • 示例代码：

    const nj = require('numjs');

let sum = nj.array([0.1]).add(0.2);
console.log(sum.get(0));  // 输出: 0.3

选择合适的库

  • 对于简单的精度问题：Big.js、Decimal.js 和 bignumber.js 是最常用的解决方案，它们都专注于提供高精度的数字运算。
  • 对于更复杂的数学计算：Math.js 是一个更为强大的库，适合需要进行线性代数或统计计算的场景。
  • 对于高维计算：如果需要处理多维数组和矩阵运算，可以考虑使用 NumJS。

这些库的使用都能帮助你避免传统浮点数计算带来的误差，确保在数值运算中获得更加精确的结果。

tofixed()

toFixed() 在某些情况下也会有精度问题，但问题的根本原因与浮点数本身的表示有关，而不是 toFixed() 本身的实现。toFixed() 只是将浮点数转换为指定小数位的字符串，无法修复浮点数精度问题。

toFixed() 的工作方式

toFixed() 方法会：

  1. 将浮点数四舍五入到指定的小数位。
  2. 返回一个字符串形式的结果，而不是数字。

为什么 toFixed() 会有问题？

由于 JavaScript 中的浮点数遵循 IEEE 754 双精度浮点数标准，在实际计算中，浮点数本身的表示精度有限。当调用 toFixed() 时：

  1. 浮点数的误差可能已经存在，所以即使四舍五入，也可能基于一个略微不准确的值。
  2. toFixed() 本质上是基于浮点数进行运算，因此问题并没有被彻底解决。

示例：

let num = 1.005;
console.log(num.toFixed(2));  // 输出: 1.00，而不是预期的 1.01

原因：1.005 在二进制中表示时，实际上被存储为 1.004999999...。因此，当 toFixed(2) 进行四舍五入时，结果是 1.00。

如何更精确地处理 toFixed() 的问题？

为了更精确地控制四舍五入，可以手动调整数值，例如通过乘法和除法避免中间的精度丢失。

方法 1：手动调整数值

let num = 1.005;
let rounded = Math.round(num * 100) / 100;
console.log(rounded);  // 输出: 1.01

原理：先将数值放大（例如乘以 100），再取整（Math.round），最后缩小。

方法 2：使用第三方库

使用专门处理浮点数精度的库（如前面提到的 Big.js 或 Decimal.js）。

const Decimal = require('decimal.js');

let num = new Decimal(1.005);
console.log(num.toFixed(2));  // 输出: 1.01

总结

  • toFixed() 的局限：它本身并不会修复浮点数的精度问题，只是对已有数值的字符串表示进行处理。
  • 推荐解决方法：对于需要高精度数值计算的场景，避免直接使用 toFixed()，而是采用数学方法或第三方库来处理。
avatar
文章
阅读
粉丝