先还原一个结算页的小事故。促销活动里两个商品分别卖 0.1 元和 0.2 元,前端把两行金额直接相加,页面上的合计变成了 0.30000000000000004。负责这个页面的同事第一反应是计算器坏了,换了浏览器、换了设备、甚至重装了依赖,数字还是那一串。更麻烦的是另一个接口:订单单价 1.005 元,代码先把金额乘 100 换算成分,再向下取整,结果算出 100 分,而业务口径应收 101 分,一笔订单少收了一分钱。月底对账,这一分钱被财务翻了出来。

这两件事看起来无关,其实是同一个原因。0.1、0.2、1.005 在十进制里都是很规矩的小数,但计算机内部把它们存成二进制浮点数,而这三个数都找不到一个有限的二进制写法。存进去的那一刻,它就已经是一个近似值;后面的加法、乘法只是把这个近似值继续往下传。

所以先把结论说清楚:不是计算器坏了,是十进制小数在二进制里存不准。这篇剩下的内容都在解释三件事,为什么存不准、误差到底有多大、它在什么情况下会真的变成线上事故。

现场:那一分钱是怎么少的

错误代码非常短,短到没人愿意为它写测试。金额用元做单位,换算成分时直接乘 100,再向下取整:

const price = 1.005;
const cents = Math.floor(price * 100);
console.log(price * 100);   // 100.49999999999999
console.log(cents);         // 100

1.005 元应该是 100.5 分,按业务规则四舍五入到 101 分,也就是 1.01 元。但 1.005 在双精度浮点里存的是一个略小于 1.005 的值,乘 100 之后得到 100.49999999999999,向下取整就落到 100 分。少收的其实就是那半个分,取整方向把它变成了整整一分。

把同一段逻辑换成最普通的加法,现象更直观:

console.log(0.1 + 0.2);          // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);  // false
console.log(0.3 - 0.1);          // 0.19999999999999998

这三个输出都是本机 Node.js 24 实际跑出来的。注意第二行:两个写法在数学上等价,在计算机里却判不相等。很多「优惠券校验失败」「库存对比不通过」的 bug,最后都追到这一行比较上。

一个十进制小数进入计算机的过程
业务输入 0.1,十进制写法
转成二进制,发现除不尽
截到 52 位尾数,发生舍入
参与运算,误差继续传播

这张图里最关键的是第二步。除不尽不是实现偷懒,而是数学事实:有些十进制小数在二进制里就是无限循环小数,和十进制里的三分之一写不完是同一类问题。计算机只能截断,截断就会产生误差。

十进制小数转二进制,为什么会除不尽

整数转二进制用「除二取余」,小数转二进制用「乘二取整」:把小数不断乘 2,每次取整数部分当一位,剩下的小数部分继续乘,直到小数部分变成 0 或者达到精度上限。这个方法本身没有问题,问题出在「什么时候变成 0」。

拿 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;0.6 乘 2 得 1.2,取 1,剩下 0.2。到这里 0.2 又回来了,后面的 0011 会一直循环,永远不会出现小数部分为 0 的时刻。

function bitsOf(x, n) {
  let out = "";
  for (let i = 0; i < n; i++) {
    x *= 2;
    if (x >= 1) { out += "1"; x -= 1; }
    else { out += "0"; }
  }
  return out;
}
console.log(bitsOf(0.1, 60));
// 000110011001100110011001100110011001100110011001100110100000
console.log(bitsOf(0.2, 60));
// 001100110011001100110011001100110011001100110011001101000000

前 52 位能清楚看到 0011 在不断重复,末尾几位和纯数学的展开略有不同,因为这段代码读到的 0.1 本身已经是双精度存下来的近似值,不是数学意义上的 0.1。这个细节很重要:误差不是从运算开始的,是从「把十进制字面量变成二进制」那一步就开始了。

0.2 是同一串循环节整体左移一位,0.3 则是 0.0100110011 这样的循环。三个数都写不完,截断的位置又不同,所以 0.1 加 0.2 得到的二进制串,和 0.3 存进去的二进制串并不完全一样。加法本身没有错,错的是两个加数和结果都已经不是精确的十进制值。

IEEE 754:符号、指数、尾数三段

现在计算机里的浮点数基本都遵循 IEEE 754 标准。所谓浮点数,就是让小数点「浮动」的表示法:同一个位宽里,既能表示很大的数,也能表示很小的数,代价是有效数字的位数固定。它把一段二进制拆成三段来理解。

符号位1 位,决定正负。0 是正数,1 是负数。它不参与数值大小的计算,只负责方向。
指数段双精度占 11 位,记的是一个偏移过的指数。实际指数等于存储值减去 1023,它决定小数点在二进制里的位置,也就是数量级。
尾数段双精度占 52 位,存有效数字。规格化数的最高位 1 被省略,所以实际有 53 位有效位。

把三段拼起来,一个双精度浮点数的值约等于「正负号乘 1 点几,再乘 2 的若干次方」。那个「1 点几」就是尾数,那个「若干次方」就是指数。因为指数可以很大也可以很小,浮点数能覆盖约 1.8 乘 10 的 308 次方到 5 乘 10 的负 324 次方这么大的范围;但尾数只有 52 位可存,能保证的有效数字位数始终有限。

这也解释了一个常见误解:浮点数精度高不高,不能只看它能不能表示很大的数。范围大和精度高是两件事。双精度可以表示 10 的 300 次方,但在这个量级上,相邻两个可表示数之间的间隔也非常大,个位数早就存不进去了。

53 位有效位,到底意味着什么

双精度有 53 位有效位,换算成十进制大约是 15 到 17 位有效数字。这就是为什么很多语言打印浮点数时默认只显示 15 位左右,再往后显示的位数已经不可靠了。

先看 0.1 到底被存成了什么。Python 的 Decimal 可以直接打印一个浮点数的完整十进制值:

from decimal import Decimal
print(Decimal(0.1))
# 0.1000000000000000055511151231257827021181583404541015625

这就是 0.1 在双精度里的真身。它比 0.1 大了一点点,差值约 5.55 乘 10 的负 18 次方。单看一个数,这点误差完全可以忽略;但当成千上万次运算叠加,或者拿它和另一个同样有误差的值做相等比较,问题就会露出来。

有效位还决定了大整数能不能连续表示。双精度能精确表示的最大连续整数是 2 的 53 次方减 1,也就是 9007199254740991,JavaScript 用 Number.MAX_SAFE_INTEGER 把它暴露出来。超过这个值,相邻整数之间就会出现「空洞」,加一可能加不动:

console.log(Number.MAX_SAFE_INTEGER);  // 9007199254740991
console.log(9007199254740992 + 1);     // 9007199254740992
console.log(9007199254740993 + 1);     // 9007199254740992

第二行的结果和加数一样,第三行甚至「往回走」了,原因是这两个大整数在双精度里被舍入到了同一个可表示值。订单号、雪花 ID、时间戳纳秒值一旦越过这条线,末位就会悄悄变化,而且不会报错。

舍入本身也不是随便砍掉。IEEE 754 默认采用「就近舍入,平局取偶」,也就是落到最近的可表示值上,正好在中间时选尾数为偶数的那一个。这条规则让误差在统计上更均衡,但也意味着同一个十进制小数在不同位宽下可能落到不同的位置。

直接比较

写 a === b 或 a == b,要求两个浮点数每一位都相同。只要中间经过一次不同的运算顺序,结果就可能不相等,这种写法在金额和测量值上基本不可靠。

容差比较

先算两个值的差,再判断差是否小于一个阈值。阈值要按业务精度定,比如金额到分就用半分,坐标到厘米就用对应的度数。它承认误差存在,再决定误差是否可以接受。

这两种写法没有绝对的对错,区别在用途。判断「两个金额是不是同一笔」应该用整数分加容差;判断「两个坐标是不是同一个点」可以用容差;而判断「这个值是不是恰好等于零」,几乎永远不该直接用浮点相等。

误差不是一次,是会累积的

单次误差通常在 10 的负 16 次方量级,看起来无害。真正麻烦的是累积。把 0.01 连续加 100 次,数学结果是 1,本机跑出来是 1.0000000000000007:

let sum = 0;
for (let i = 0; i < 100; i++) sum += 0.01;
console.log(sum);            // 1.0000000000000007
console.log(sum.toFixed(2)); // 1.00

每次加法都要把结果舍入到最近的可表示值,误差因此一步一步往里加。100 次还不算多,账目按天、按月累计,或者传感器每秒采样几十次,误差就会从「看不见」变成「对不上」。加法顺序也会影响结果:先加大的再加小的,和先加小的再加大的,最后可能差出好几个末位。

还有一类更隐蔽的丢失,叫相减抵消。两个很接近的数相减,前面的有效位互相抵消,剩下的结果把原本藏在后面的误差暴露出来。0.3 减 0.1 得到 0.19999999999999998,就是这种效应的日常版本。如果两个数本身是上亿级别的近似值,相减之后相对误差会被放大得非常厉害。

另一个常见错觉是「显示两位小数就没事了」。显示层确实能把 1.0000000000000007 格式化成 1.00,但计算层还在用那个带误差的值。只要后面还有比较、取整、累加、写库,误差就仍然在链条里。格式化只能遮住结果,不能修正过程。

如果确实需要在浮点上累加大量小数,可以用 Kahan 求和:额外维护一个补偿项,把每次加法丢掉的低位先存起来,下一次再补回去。它能把误差从随次数线性增长压到很小,但并不能把浮点变成精确十进制,最终的比较和存储仍然要按业务精度处理,不能因为用了补偿算法就放弃整数分。

金额、库存、积分这类需要「一分不差」的字段,不要在浮点上做累加后再取整。取整会把连续的误差压成离散的跳变,跳变方向一旦错,就是实实在在的少收或多付。

现象、真实原因与第一步排查

下面这些症状在业务代码里出现频率很高。看到类似现象,先按表的第三列定位,不要急着重写整段计算逻辑。

现象真实原因第一步查什么
页面合计显示 0.300000000000000040.1 和 0.2 在二进制里都存不准,相加后误差保留下来金额是否用元为单位的浮点在累加
对账时差一分钱先乘 100 再向下取整,1.005 乘 100 得到 100.49999999999999是否把元换算成分后又直接取整
100 笔 0.01 元累加成 1.0000000000000007每次加法都发生舍入,误差逐笔累积累加变量是否用整数分或十进制类型
两个明明相等的金额比较结果为 false两个值经过不同运算路径,末位不同是否直接用等于号比较浮点数
大整数 ID 末位对不上数值超过 2 的 53 次方减 1,双精度无法连续表示ID 是否以 Number 解析或参与运算
同一笔金额存库前后差一点计算层是浮点,存储层是 decimal,两边舍入规则不同计算和存储是否使用了同一种数值类型
单精度字段存 0.1 变成 0.10000000149011612float32 只有 24 位有效位,误差比双精度大得多该字段是否真的需要单精度
16777217 存进 float32 变成 16777216单精度尾数只有 24 位,超过 2 的 24 次方后整数不再连续是否用 float 存计数或 ID

表里最容易被误判的是第二行和第六行。第二行看起来像「取整函数写错了」,实际是乘 100 之后的中间值已经小于 100.5;第六行看起来像「数据库把数改了」,实际是两套类型在不同环节做了不同的舍入。排查时不要只盯着最后一步,要把「字符串输入、类型转换、中间运算、存储、格式化」这五步逐个打印出来。

边界与代价:双精度也不是万能的

双精度的边界首先是「有效位固定」。它能表示极大的范围,但在大数值上只能保证十几位十进制有效数字。用它存金额,理论误差可以小到忽略;用它存纳秒时间戳,1.7 乘 10 的 18 次方已经越过 2 的 53 次方,最小间隔变成 256 纳秒,加 1 纳秒根本加不动。这不是精度「不够高」,而是需要的位数超过了类型能给的上限。本机验证过:1700000000000000000 + 1 的结果仍然是 1700000000000000000。

第二个边界是特殊值。浮点里有正无穷、负无穷和 NaN(不是一个数)。它们不报错,会安静地沿着计算传播。NaN 和任何值比较都返回 false,包括它自己,所以一个 NaN 混进汇总,可能让整张报表的比较全部失真,而日志里只看到一串正常的字段名。还有一个容易被忽略的值是负零,它在数值上等于零,打印出来却是 -0,某些序列化和相等判断会因此出现意外的分支。

第三个边界是类型转换。JSON 里的数字没有整数和浮点的区分,长整数经过 JSON.parse 会变成双精度,末位直接丢;很多语言把浮点打印成最短可往返字符串,看起来是 0.1,实际存的是那个长长的近似值。跨语言传递时,一边认为自己是精确的 decimal,另一边当成 double 解析,误差就在接口边界上产生了。

代价方面,整数分或十进制类型能给出精确结果,但运算更慢、范围受 scale 限制、还要额外处理除法舍入;双精度快、范围大、硬件直接支持,但不能保证十进制精确。这不是「哪个更好」,而是「哪个代价你愿意付」。金额场景付得起慢一点,就该换精确类型;图形和物理仿真需要速度和范围,双精度或单精度更合适。

还有一条实践边界:不要指望用「多留几位小数」解决问题。误差不是位数不够,而是二进制根本表示不了那个十进制值。留 10 位、20 位只是把误差藏得更深,比较和累计仍然会露馅。要精确,就换成能精确表示十进制的存储方式,比如整数分、整数毫(千分之一),或者语言自带的 Decimal 类型。

当天能做的练习

  1. 在本机用 Node.js 打印 0.1 + 0.2、0.3 - 0.1、0.1 + 0.7,把三个结果和数学答案并排写下来,再用 === 和 0.3 比较,记录哪些是 false。
  2. 把本文的 bitsOf 函数敲进去,分别输出 0.1、0.2、0.3 的前 60 位,圈出循环节,说明为什么截断位置不同会导致相加对不上。
  3. 写一个金额换算函数,输入 1.005,先乘 100 再分别用 Math.floor、Math.round、toFixed 处理,记录三种结果,并解释哪一种符合「四舍五入到分」。
  4. 用 0.01 累加 100 次、1000 次、10000 次,每次打印结果和 toFixed(2),观察误差怎样随次数增长,再换成整数分累加做同样的事。
  5. 验证 9007199254740991、9007199254740992、9007199254740993 三个数加一之后的结果,再用 BigInt 重跑一遍,记录两种类型在哪一位开始分道扬镳。
环境说明:本文的数字来自本机 Node.js 24.21.0 与 Python 3.15.0 的实际运行,输出与文中一致。不同语言默认的浮点类型可能不同,但 IEEE 754 双精度的位宽、53 位有效位和舍入规则是一致的;单精度的具体误差会随字段类型变化。

小结与下一篇

三句话收一下:十进制小数转二进制可能无限循环,存进去的第一步就发生了舍入;双精度用符号、指数、尾数三段换来大范围,但只保证 53 位有效位;误差会随运算累积,金额和大整数是最容易出事的两类数据。

既然浮点存不准十进制小数,另一个方向就是把小数「放大成整数」来存,也就是定点数。下一篇把定点与浮点放在一起比较:定点范围小、精度固定、算得准;浮点范围大、精度相对、算得快。库存重量、传感器读数、金额、坐标、时间戳该各选哪一种,下一篇会给出具体的判断标准。