先还原一个结算页的小事故。促销活动里两个商品分别卖 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,最后都追到这一行比较上。
这张图里最关键的是第二步。除不尽不是实现偷懒,而是数学事实:有些十进制小数在二进制里就是无限循环小数,和十进制里的三分之一写不完是同一类问题。计算机只能截断,截断就会产生误差。
十进制小数转二进制,为什么会除不尽
整数转二进制用「除二取余」,小数转二进制用「乘二取整」:把小数不断乘 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 点几,再乘 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.30000000000000004 | 0.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.10000000149011612 | float32 只有 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 类型。
当天能做的练习
- 在本机用 Node.js 打印
0.1 + 0.2、0.3 - 0.1、0.1 + 0.7,把三个结果和数学答案并排写下来,再用===和0.3比较,记录哪些是 false。 - 把本文的
bitsOf函数敲进去,分别输出 0.1、0.2、0.3 的前 60 位,圈出循环节,说明为什么截断位置不同会导致相加对不上。 - 写一个金额换算函数,输入 1.005,先乘 100 再分别用
Math.floor、Math.round、toFixed处理,记录三种结果,并解释哪一种符合「四舍五入到分」。 - 用 0.01 累加 100 次、1000 次、10000 次,每次打印结果和
toFixed(2),观察误差怎样随次数增长,再换成整数分累加做同样的事。 - 验证
9007199254740991、9007199254740992、9007199254740993三个数加一之后的结果,再用 BigInt 重跑一遍,记录两种类型在哪一位开始分道扬镳。
小结与下一篇
三句话收一下:十进制小数转二进制可能无限循环,存进去的第一步就发生了舍入;双精度用符号、指数、尾数三段换来大范围,但只保证 53 位有效位;误差会随运算累积,金额和大整数是最容易出事的两类数据。
既然浮点存不准十进制小数,另一个方向就是把小数「放大成整数」来存,也就是定点数。下一篇把定点与浮点放在一起比较:定点范围小、精度固定、算得准;浮点范围大、精度相对、算得快。库存重量、传感器读数、金额、坐标、时间戳该各选哪一种,下一篇会给出具体的判断标准。