不，不破，但大多数小数必须近似

总结

浮点运算是精确的，不幸的是，它与我们通常的以10为基数的数字表示法不太匹配，所以我们经常给它的输入与我们写的略有不同。

即使是像0.01、0.02、0.03、0.04…0.24这样的简单数字也不能精确地表示为二进制分数。如果你数到0.01、.02、.03…，直到你数到0.25，你才能得到以2为底的第一个分数。如果你尝试使用FP，那么你的0.01会稍微有点偏差，所以要将其中的25个相加到一个精确的0.25，就需要一长串的因果关系，包括保护位和舍入。很难预测，所以我们举手说“FP不准确”，但事实并非如此。

我们不断地给FP硬件一些在基数10中看似简单但在基数2中却是重复的分数。

这是怎么发生的？

当我们用十进制书写时，每个分数（特别是每个终止的小数）都是形式的有理数

          a/（2n x 5m）

在二进制中，我们只得到2n项，即：

a/2n

所以在十进制中，我们不能表示1/3。因为基数10包括2作为素因子，所以我们可以写成二进制分数的每个数字也可以写成基数10的分数。然而，我们写为10进制分数的任何东西都很难用二进制表示。在0.01、0.02、0.03…0.99的范围内，只有三个数字可以用我们的FP格式表示：0.25、0.50和0.75，因为它们是1/4、1/2和3/4，所有的数字都只使用2n项。

在base10中，我们不能表示1/3。但在二进制中，我们不能做1/10或1/3。

因此，虽然每一个二进制分数都可以用十进制来表示，但反过来却不正确。事实上，大多数小数在二进制中重复。

处理它

开发人员通常被要求进行＜epsilon比较，更好的建议可能是舍入为整数值（在C库中：round（）和round f（），即保持FP格式），然后进行比较。舍入到特定的小数部分长度可以解决大多数输出问题。

此外，在实数运算问题（FP是在早期昂贵的计算机上为之发明的问题）上，宇宙的物理常数和所有其他测量值只为相对较少的有效数字所知，因此整个问题空间无论如何都是“不精确的”。FP“精度”在这种应用中不是问题。

当人们尝试使用FP进行计数时，整个问题就真的出现了。它确实可以做到这一点，但前提是你坚持使用整数值，这会破坏使用它的意义。这就是为什么我们拥有所有这些小数软件库的原因。

我喜欢克里斯的披萨回答，因为它描述了实际问题，而不仅仅是关于“不准确”的通常手写。如果FP只是“不准确”，我们可以修复它，而且几十年前就已经做到了。我们没有这样做的原因是因为FP格式紧凑快速，是处理大量数字的最佳方式。此外，这也是太空时代和军备竞赛以及早期使用小型内存系统解决速度非常慢的计算机的大问题的尝试所留下的遗产。（有时，单个磁芯用于1位存储，但这是另一回事。）

结论

如果您只是在银行数豆子，那么首先使用十进制字符串表示的软件解决方案工作得非常好。但你不能这样做量子色动力学或空气动力学。

浮点舍入错误。从每个计算机科学家应该知道的浮点运算：

将无限多的实数压缩成有限位数需要近似表示。虽然有无限多的整数，但在大多数程序中，整数计算的结果可以存储在32位中。相反，给定任何固定位数，大多数使用实数的计算将产生无法使用那么多位数精确表示的量。因此，浮点计算的结果必须经常舍入，以适应其有限表示。这种舍入误差是浮点计算的特征。

我的答案很长，所以我把它分成了三部分。因为这个问题是关于浮点数学的，所以我把重点放在了机器的实际功能上。我还将其指定为双精度（64位），但该参数同样适用于任何浮点运算。

序言

IEEE 754双精度二进制浮点格式（binary64）数字表示以下形式的数字

值=（-1）^s*（1.m51m50…m2m1m0）2*2e-1023

64位：

第一位是符号位：如果数字为负，则为1，否则为0。接下来的11位是指数，偏移1023。换句话说，在从双精度数字中读取指数位之后，必须减去1023以获得2的幂。剩下的52位是有效位（或尾数）。在尾数中，“隐含”1。由于任何二进制值的最高有效位为1，因此总是省略2。

1-IEEE 754允许有符号零的概念-+0和-0被不同地对待：1/（+0）是正无穷大；1/（-0）是负无穷大。对于零值，尾数和指数位均为零。注意：零值（+0和-0）未明确归为非标准2。

2-非正规数的情况并非如此，其偏移指数为零（以及隐含的0）。非正规双精度数的范围为dmin≤|x|≤dmax，其中dmin（最小的可表示非零数）为2-1023-51（≈4.94*10-324），dmax（最大的非正规数，其尾数完全由1组成）为2-1023+1-21-23-51（≈2.225*10-308）。

---

将双精度数字转换为二进制

存在许多在线转换器来将双精度浮点数转换为二进制（例如，在binaryconvert.com），但这里有一些示例C#代码来获得双精度数字的IEEE 754表示（我用冒号（：）分隔这三个部分：

public static string BinaryRepresentation(double value)
{
    long valueInLongType = BitConverter.DoubleToInt64Bits(value);
    string bits = Convert.ToString(valueInLongType, 2);
    string leadingZeros = new string('0', 64 - bits.Length);
    string binaryRepresentation = leadingZeros + bits;

    string sign = binaryRepresentation[0].ToString();
    string exponent = binaryRepresentation.Substring(1, 11);
    string mantissa = binaryRepresentation.Substring(12);

    return string.Format("{0}:{1}:{2}", sign, exponent, mantissa);
}

---

开门见山：最初的问题

（对于TL；DR版本，跳到底部）

卡托·约翰斯顿（提问者）问为什么0.1+0.2！=0.3.

以二进制（用冒号分隔三个部分）编写，IEEE 754值表示为：

0.1 => 0:01111111011:1001100110011001100110011001100110011001100110011010
0.2 => 0:01111111100:1001100110011001100110011001100110011001100110011010

请注意，尾数由0011的重复数字组成。这是为什么计算有任何错误的关键-0.1、0.2和0.3不能用二进制精确地表示在有限数量的二进制位中，任何超过1/9、1/3或1/7的二进制位都可以用十进制数字精确地表示。

还要注意，我们可以将指数的幂减小52，并将二进制表示中的点向右移动52位（非常类似10-3*1.23==10-5*123）。这使我们能够将二进制表示表示为它以a*2p形式表示的精确值。其中“a”是整数。

将指数转换为十进制、删除偏移量并重新添加隐含的1（在方括号中）、0.1和0.2为：

0.1 => 2^-4 * [1].1001100110011001100110011001100110011001100110011010
0.2 => 2^-3 * [1].1001100110011001100110011001100110011001100110011010
or
0.1 => 2^-56 * 7205759403792794 = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794 = 0.200000000000000011102230246251565404236316680908203125

要添加两个数字，指数必须相同，即：

0.1 => 2^-3 *  0.1100110011001100110011001100110011001100110011001101(0)
0.2 => 2^-3 *  1.1001100110011001100110011001100110011001100110011010
sum =  2^-3 * 10.0110011001100110011001100110011001100110011001100111
or
0.1 => 2^-55 * 3602879701896397  = 0.1000000000000000055511151231257827021181583404541015625
0.2 => 2^-55 * 7205759403792794  = 0.200000000000000011102230246251565404236316680908203125
sum =  2^-55 * 10808639105689191 = 0.3000000000000000166533453693773481063544750213623046875

由于和的形式不是2n*1.｛bbb｝，我们将指数增加1，并移动小数（二进制）点以获得：

sum = 2^-2  * 1.0011001100110011001100110011001100110011001100110011(1)
    = 2^-54 * 5404319552844595.5 = 0.3000000000000000166533453693773481063544750213623046875

现在尾数中有53位（第53位在上一行的方括号中）。IEEE 754的默认舍入模式是“舍入到最近”，即如果数字x介于两个值a和b之间，则选择最低有效位为零的值。

a = 2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875
  = 2^-2  * 1.0011001100110011001100110011001100110011001100110011

x = 2^-2  * 1.0011001100110011001100110011001100110011001100110011(1)

b = 2^-2  * 1.0011001100110011001100110011001100110011001100110100
  = 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125

注意，a和b仅在最后一位不同。。。0011 + 1 = ...0100。在这种情况下，最低有效位为零的值为b，因此总和为：

sum = 2^-2  * 1.0011001100110011001100110011001100110011001100110100
    = 2^-54 * 5404319552844596 = 0.3000000000000000444089209850062616169452667236328125

而0.3的二进制表示是：

0.3 => 2^-2  * 1.0011001100110011001100110011001100110011001100110011
    =  2^-54 * 5404319552844595 = 0.299999999999999988897769753748434595763683319091796875

其仅与0.1和0.2之和的二进制表示相差2-54。

0.1和0.2的二进制表示是IEEE 754允许的数字的最精确表示。由于默认舍入模式，添加这些表示会导致一个仅在最低有效位不同的值。

TL；博士

将0.1+0.2写入IEEE 754二进制表示（用冒号分隔三个部分），并将其与0.3进行比较，这是（我将不同的位放在方括号中）：

0.1 + 0.2 => 0:01111111101:0011001100110011001100110011001100110011001100110[100]
0.3       => 0:01111111101:0011001100110011001100110011001100110011001100110[011]

转换回十进制，这些值为：

0.1 + 0.2 => 0.300000000000000044408920985006...
0.3       => 0.299999999999999988897769753748...

与原始值相比，差异正好为2-54，约为5.5511151231258×10-17（对于许多应用）。

比较浮点数的最后几位本来就很危险，任何读过著名的《每一位计算机科学家都应该知道的关于浮点运算》（该书涵盖了这个答案的所有主要部分）的人都会知道。

大多数计算器使用额外的保护数字来解决这个问题，这就是0.1+0.2如何给出0.3：最后几位是四舍五入的。

浮点舍入错误。由于缺少5的素因子，0.1在基-2中不能像在基-10中那样精确地表示。正如1/3以十进制表示需要无限位数，但以3为基数表示为“0.1”，0.1以2为基数表示，而以10为基数不表示。计算机没有无限的内存。

简而言之，这是因为：

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

因此，就像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

它被打破的方式与你在小学学习并每天使用的十进制（以10为基础）表示法完全相同，只是以2为基础。

要理解，请考虑将1/3表示为十进制值。这是不可能做到的！世界将在你写完小数点后的3之前结束，所以我们写了一些地方，认为它足够准确。

以同样的方式，1/10（十进制0.1）不能以2为基数（二进制）精确地表示为“十进制”值；小数点后的重复模式将永远持续下去。该值不精确，因此无法使用常规浮点方法对其进行精确计算。与基数10一样，还有其他值也显示了这个问题。