十进制数（如0.1、0.2和0.3）在二进制编码浮点类型中没有精确表示。0.1和0.2的近似值之和与0.3的近似值不同，因此，0.1+0.2==0.3的错误在这里可以更清楚地看到：

#include <stdio.h>

int main() {
    printf("0.1 + 0.2 == 0.3 is %s\n", 0.1 + 0.2 == 0.3 ? "true" : "false");
    printf("0.1 is %.23f\n", 0.1);
    printf("0.2 is %.23f\n", 0.2);
    printf("0.1 + 0.2 is %.23f\n", 0.1 + 0.2);
    printf("0.3 is %.23f\n", 0.3);
    printf("0.3 - (0.1 + 0.2) is %g\n", 0.3 - (0.1 + 0.2));
    return 0;
}

输出：

0.1 + 0.2 == 0.3 is false
0.1 is 0.10000000000000000555112
0.2 is 0.20000000000000001110223
0.1 + 0.2 is 0.30000000000000004440892
0.3 is 0.29999999999999998889777
0.3 - (0.1 + 0.2) is -5.55112e-17

为了更可靠地计算这些计算，您需要对浮点值使用基于十进制的表示。C标准没有默认指定此类类型，而是作为技术报告中描述的扩展。

_Decimal32、_Decimal64和_Decimal128类型可能在您的系统上可用（例如，GCC在选定的目标上支持它们，但Clang在OS X上不支持它们）。

想象一下，以10为基数，例如8位数的精度工作。您检查是否

1/3 + 2 / 3 == 1

并了解到这返回错误。为什么？好吧，作为真实的数字

1/3=0.333….和2/3=0.666。。。。

在小数点后八位截断，我们得到

0.33333333 + 0.66666666 = 0.99999999

当然，这与1.00000000正好相差0.00000001。

具有固定位数的二进制数的情况完全类似。作为实数，我们有

1/10=0.0001100110011001100…（底座2）

and

1/5=0.00111001100110011001…（底座2）

如果我们把这些截成七位

0.0001100 + 0.0011001 = 0.0100101

而另一方面，

3/10=0.010011001100110011…（基数2）

被截断为七位的值为0.0100110，两者相差0.0000001。

确切的情况稍显微妙，因为这些数字通常以科学符号存储。因此，例如，我们可以将其存储为1.10011*2^-4，而不是将1/10存储为0.0001100，这取决于我们为指数和尾数分配了多少位。这会影响计算的精度位数。

结果是，由于这些舍入错误，您根本不想在浮点数上使用==。相反，您可以检查它们的差值的绝对值是否小于某个固定的小数字。

简而言之，这是因为：

浮点数不能以二进制精确表示所有小数

因此，就像10/3不精确地存在于基数10中（它将是3.33……重复出现）一样，1/10也不存在于二进制中。

那又怎么样？如何处理？有什么解决办法吗？

为了提供最佳解决方案，我可以说我发现了以下方法：

parseFloat((0.1 + 0.2).toFixed(10)) => Will return 0.3

让我解释一下为什么这是最好的解决方案。正如上面提到的其他答案一样，使用现成的Javascript toFixed（）函数来解决问题是一个好主意。但很可能你会遇到一些问题。

假设你将两个浮点数相加，如0.2和0.7，这里是：0.2+0.7=0.8999999999999999。

您的预期结果是0.9，这意味着您需要一个精度为1位数的结果。因此，您应该使用（0.2+0.7）.tfixed（1）但是不能只给toFixed（）一个特定的参数，因为它取决于给定的数字，例如

0.22 + 0.7 = 0.9199999999999999

在本例中，您需要2位精度，因此它应该为Fixed（2），那么，适合每个给定浮点数的参数应该是什么？

你可以说在每种情况下都是10：

(0.2 + 0.7).toFixed(10) => Result will be "0.9000000000"

该死你打算怎么处理那些9后不需要的零？现在是将其转换为浮动的时候了，以实现您的愿望：

parseFloat((0.2 + 0.7).toFixed(10)) => Result will be 0.9

既然找到了解决方案，那么最好将其作为如下函数提供：

function floatify(number){
           return parseFloat((number).toFixed(10));
        }
    

让我们自己试试吧：函数floatify（数字）{return parseFloat（（number）.toFixed（10））；}函数addUp（）{var number1=+$（“#number1”）.val（）；var number2=+$（“#number2”）.val（）；var expectedResult=number1+number2；var expectedResult=浮动（number1+number2）；$（“#意外结果”）.text（意外结果）；$（“#expectedResult”）.text（expectedResult）；}addUp（）；输入{宽度：50px；}#预期结果{颜色：绿色；}#未预期结果{颜色：红色；}<script src=“https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js“></script><input id=“number1”value=“0.2”onclick=“addUp（）”onkeyup=“addUp（）”/>+<input id=“number2”value=“0.7”onclick=“addUp（）”onkeyup=“addUp（）”/>=<p>预期结果：<span id=“expectedResult”></span></p><p>意外结果：<span id=“expectedResult”></span></p>

您可以这样使用：

var x = 0.2 + 0.7;
floatify(x);  => Result: 0.9

正如W3SCHOOLS所建议的，还有另一种解决方案，您可以通过乘法和除法来解决上述问题：

var x = (0.2 * 10 + 0.1 * 10) / 10;       // x will be 0.3

请记住，（0.2+0.1）*10/10根本不起作用，尽管看起来是一样的！我更喜欢第一种解决方案，因为我可以将其作为一个函数应用，将输入浮点转换为精确的输出浮点。

仅供参考，乘法也存在同样的问题，例如0.09*10返回0.8999999999999999。应用flotify函数作为解决方法：flotify（0.09*10）返回0.9

已经发布了很多好的答案，但我想再补充一个。

并非所有数字都可以通过浮点数/双精度表示例如，在IEEE754浮点标准中，数字“0.2”将以单精度表示为“0.200000003”。

用于在引擎盖下存储实数的模型将浮点数表示为

即使您可以轻松键入0.2，FLT_RADIX和DBL_RADIX都是2；对于使用“IEEE二进制浮点运算标准（ISO/IEC Std 754-1985）”的带有FPU的计算机，不是10。

所以准确地表示这些数字有点困难。即使在没有任何中间计算的情况下显式指定此变量。

从Python 3.5开始，您可以使用math.isclose（）函数来测试近似相等性：

>>> import math
>>> math.isclose(0.1 + 0.2, 0.3)
True
>>> 0.1 + 0.2 == 0.3
False

除了其他正确答案之外，您可能还需要考虑缩放值以避免浮点运算的问题。

例如：

var result = 1.0 + 2.0;     // result === 3.0 returns true

…而不是：

var result = 0.1 + 0.2;     // result === 0.3 returns false

在JavaScript中，表达式0.1+0.2===0.3返回false，但幸运的是，浮点中的整数运算是精确的，因此可以通过缩放来避免十进制表示错误。

作为一个实际的例子，为了避免精度至关重要的浮点问题，建议1将钱作为一个整数来处理：2550美分而不是25.50美元。

1 Douglas Crockford：JavaScript：好的部分：附录A——糟糕的部分（第105页）。