财务月结时发现两笔数对不上。一笔是 1.005 元的手续费,按两位小数应该是 1.01,报表里却是 1.00;另一笔是 2.675 元的单价,按两位应该是 2.68,报表里是 2.67。开发同学第一反应是舍入函数写错了,把 toFixed 换成 Math.round,又把 Math.round 换成自己写的四舍五入,两个数还是原样。
真正的原因在更前面:代码里的 1.005 从来就不是 1.005。它是十进制写法,落到双精度浮点里会变成离它最近的那个二进制数,而那个数比 1.005 小一点点。舍入函数拿到的是一个略小于平局值的数,按任何「看第五位」的规则都会向下走,跟业务预期的 1.01 差一分。2.675 也一样,它存进去之后比 2.675 小,于是 2.67 出现得理所当然。
这篇把 IEEE 754 的存储布局、五种舍入模式、银行家舍入的来历讲清楚,再说明为什么「先舍入再比较」在浮点上经常失效,以及什么场景必须换成十进制库或者整数分。开头那两个数会贯穿全文,因为它们同时踩中了两个不同的坑:一个是存不准,一个是规则不同。这两件事必须分开看,否则调一辈子也调不对。
现场:两个对不上的数
先把报表里的运算原样跑一遍。下面是 Node.js 24 的实际输出,注释就是结果。
console.log((1.005).toFixed(2)); // 1.00
console.log((2.675).toFixed(2)); // 2.67
console.log(2.675 * 100); // 267.5
console.log(1.005 * 100); // 100.49999999999999
console.log(0.1 + 0.2); // 0.30000000000000004
第三行是个陷阱。很多人看到 2.675 乘 100 得到 267.5,会以为这个值精确地落在平局线上,于是怀疑 toFixed 的平局规则;可真正的乘积是 267.49999999999998 左右,只是它离 267.5 足够近,乘法的结果又被舍入成了 267.5。也就是说,乘 100 这一步不但没有暴露误差,反而把误差藏了起来。拿它去判断「是不是正好一半」,方向从一开始就错了。
Python 的 round 也一样。本机 Python 3.15 的输出是 2.67 和 1.0,不是 2.68 和 1.01。因为 round 作用在已经存成二进制的值上,它看到的是 2.6749999999999998,而不是十进制文本里的 2.675。
print(round(2.675, 2)) # 2.67
print(round(1.005, 2)) # 1.0
关键在第三步:误差发生在读入的那一刻,后面所有函数都只是在这个已经偏小的值上做决定。你把舍入函数换成哪一种,都改变不了它看到的输入。所以排查这类问题时,第一步不是看舍入代码,而是把值按完整精度打印出来,确认它到底是不是你以为的那个数。
IEEE 754 把数存成什么
IEEE 754 是浮点数的国际标准,JavaScript 的 Number、Java 的 double、C 的 double 都按它的双精度格式存数。双精度一共 64 位,分成三段:1 位符号、11 位指数、52 位尾数。符号位决定正负;指数位记录数量级,实际指数要减去一个固定的偏移量 1023;尾数位记录有效数字,并且默认省略了一个前导的 1,所以实际有 53 位有效数字。
把这三段拼起来,一个双精度数的值是负一的符号次方,乘上 1 点几的尾数,再乘 2 的真实指数次方。这里的「1 点几」是二进制写法,尾数每一位代表 2 的负一次方、负二次方、负三次方。能写尽的数,分母必须是 2 的幂:0.5、0.25、0.125 都没问题;0.1、0.01、1.005 的分母含因子 5,写不尽,只能取最近的值。
为什么 1.005 不是 1.005
把两个数按完整精度打印出来,谜底就清楚了。本机输出如下,末尾省略号是我加的,实际位数远不止这些。
1.005 存成 1.00499999999999989341858963598497211933135986328125
2.675 存成 2.67499999999999982236431605997495353221893310546875
0.1 存成 0.1000000000000000055511151231257827021181583404541015625
1 附近的相邻两个双精度数之间,间隔是 2 的负 52 次方,约等于 2.22 乘 10 的负 16 次方。1.005 存下来的值比 1.005 小约 1.07 乘 10 的负 16 次方,小于半个间隔,所以它就是「离 1.005 最近的那个可表示值」。换句话说,这不是存错了,而是按规则只能存到这个数。2.675 同理,它比真值小约 1.78 乘 10 的负 16 次方,也在半个间隔之内。
再看 2.675 乘 100。真值乘积大约是 267.4999999999999822;267 附近的相邻双精度数间隔约 5.68 乘 10 的负 14 次方,误差只有这个间隔的三分之一左右,于是乘积被舍入到最近的 267.5。打印出来是漂亮的 267.5,可它并不是精确的 267.5。这就是为什么「先乘 100 再判断奇偶」不可靠:判断的对象已经被第二次舍入改造过。
所以同一个 1.00,可能有两个完全不同的原因。一是存储误差:1.005 存成了 1.004999,任何就近舍入都只能给 1.00。二是规则差异:即使真的拿到精确的 1.005,用的是银行家舍入,结果也是 1.00,因为保留的末位 0 是偶数。要判断到底是哪一个,得先看存的是什么,再看用的是什么规则,不能把两个问题混成一个。
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
print(Decimal('1.005').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)) # 1.01
print(Decimal('1.005').quantize(Decimal('0.01'), rounding=ROUND_HALF_EVEN)) # 1.00
print(Decimal('2.675').quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)) # 2.68
五种舍入模式
舍入模式决定一个不能精确表示的值往哪个方向变成可表示值,最容易分歧的是正好一半的时候。IEEE 754 定义了五种,每一种在正半轴和负半轴上的方向都可能不同。下面这张表用 2.5 和负 2.5 舍到整数做例子,数字都是本机 Python 3.15 的实际输出。
| 模式 | 2.5 的结果 | 负 2.5 的结果 | 一句话解释 |
|---|---|---|---|
| 就近取偶 | 2 | 负 2 | 离哪边近就去哪边,正好一半时让保留的末位变成偶数 |
| 向零 | 2 | 负 2 | 直接砍掉小数部分,也叫截断 |
| 向正无穷 | 3 | 负 2 | 永远往大的方向走,也叫向上取整 |
| 向负无穷 | 2 | 负 3 | 永远往小的方向走,也叫向下取整 |
| 远离零 | 3 | 负 3 | 正好一半时往绝对值大的方向走,中文常说的四舍五入通常是它 |
先澄清一个常见误解:就近取偶不是「结果取偶数」,而是「正好一半时,让保留下来的最后一位是偶数」。2.5 舍到整数,保留的是个位,2 是偶数、3 是奇数,所以取 2;3.5 舍到整数,3 是奇数、4 是偶数,所以取 4。它和四舍五入只在平局时不同;不是平局的时候,两者完全一样。
还要注意负数的方向。向零对正数相当于向下,对负数相当于向上;向正无穷对正数是向上,对负数是向下。很多「负数手续费多一分」的事故,就是把这两组方向记混了。测试舍入函数时,只测正数是不够的,必须拿正负 2.5、正负 0.5 这类平局值各跑一遍。
四舍五入
平局时远离零,正数向上、负数向下。它符合大多数人对「四舍五入」的直觉,但每次平局都把绝对值推大一点,大量数据汇总时会系统性偏高。
银行家舍入
平局时就近取偶,可能向上也可能向下。单笔结果看起来「时高时低」,但大量平局的正负误差会相互抵消,汇总值更接近未舍入的真实和。
银行家舍入为什么存在
银行家舍入这个名字容易让人以为它是金融业的特殊规矩,其实它是 IEEE 754 的默认舍入方向,名字来自它在记账和统计里的典型用途。它的目标只有一个:让平局带来的误差在大量数据上互相抵消,而不是单方向累积。
拿四个正好一半的数做实验:0.5、1.5、2.5、3.5,全部舍到整数。这四个数的真实和是 8。用四舍五入,得到 1、2、3、4,和是 10,凭空多了 2;用就近取偶,得到 0、2、2、4,和还是 8,误差为零。这不是巧合:每一对相邻的平局值,一个向下、一个向上,偏差正好抵消。
单笔金额当然不会因为银行家舍入而「更准」,它和真实值仍然差半个最小单位。但在月度汇总、利息计提、成千上万笔手续费累加的场景里,方向一致的偏差会变成一笔看得见的钱。这就是为什么 IEEE 把它设为默认,也是为什么 Python 的 round 默认采用它。
先舍入再比较,为什么会失效
浮点比较最常见的写法是先 round 到两位,再判断相等。这个做法在多数时候能用,但在平局附近会同时制造两种错误:把本来不同的值判成相同,把本来相同的值判成不同。
先看第一种。0.1 加 0.2 在双精度里是 0.30000000000000004,和 0.3 不相等;但如果两边都 toFixed(2),都会变成 0.30,比较通过。看起来问题解决了,实际上只是把误差扫到了地毯下面:如果这两个值本来应该差一分钱,舍入后的相等会把它彻底掩盖。对账系统里「明明差钱,程序却说一致」,很多就是这么来的。
第二种更隐蔽。假设两个金额在十进制下分别是 1.004999 和 1.005,业务上第一个该进 1.00,第二个该进 1.01。可它们存成 double 后都可能落在 1.005 的下方,舍入后都变成 1.00。你拿舍入后的值比较,得到「相等」,但业务语义上它们并不相等。根子在于:舍入是有损的,比较应该发生在无损的表示上,而不是发生在已经丢掉信息的表示上。
还有一种叫双重舍入。先把数舍到四位,再舍到两位,结果可能和直接舍到两位不同。比如某个值在四位上是 1.0049,舍到两位是 1.00;另一个值在四位上是 1.0051,舍到两位是 1.01,可如果中间某一步先把 1.0051 舍成 1.005,再舍两位就变成 1.00。每多一次舍入,就多一次丢信息的机会。报表链路里经过导出、导入、再汇总,往往已经舍了两三次,最后差一分钱却找不到是哪一步。
所以正确的顺序是:要么全程用整数分或十进制类型,比较精确值;要么在比较前统一转换成同一个整数单位,只舍入一次,并用这个整数做相等判断。用浮点加容差比较也能应付测量数据,但容差本身在平局附近没有定义,不能拿来处理金额。
什么时候必须换十进制
判断标准不是「浮点危险」,而是「这段代码是否要求十进制语义上的精确」。下面这些场景建议直接用整数分或十进制库:金额、发票、税费、工资、利息、积分、汇率换算、对账、审计报表。它们的共同点是结果要和人看到的十进制写法一致,而且往往有法规或契约规定舍入方式。
如果小数位数固定,整数分是最省事的选择。人民币用分,日元没有小数位,科威特第纳尔有三位,把最小货币单位定下来,所有运算都是整数,输出时再按位数插小数点。它的优点是快、简单、不会引入第三方库;缺点是遇到四位小数的单价、六位小数的汇率,或者按比例分摊的场景,就得再引入更细的单位。
如果小数位数不固定,或者需要保留运算过程中的精度,就用十进制库。Python 有标准库 decimal,Java 有 BigDecimal,JavaScript 常见的是 decimal.js 一类库。使用的关键有两条:从字符串构造,不要从 float 构造;显式指定舍入模式和精度,不要依赖默认值。Decimal(2.675) 会保留二进制近似值,只有 Decimal('2.675') 才是你以为的那个十进制数。
存储和传输也要一起改。数据库用 DECIMAL 或 NUMERIC 列,不要用 FLOAT;接口传字符串或整数分,不要传 JSON 数字,因为 JSON 的数字最终还是要落进某个浮点类型。前端展示可以格式化,但不要把格式化后的字符串再传回后端参与计算。整条链路都换成十进制表示,才有意义;只在最后一层换,等于没换。
反过来,物理测量、图形渲染、机器学习、统计抽样这些场景,双精度完全够用。它们本来就不要求十进制精确,1 的负 16 次方量级的相对误差远小于测量噪声。把金额那套十进制规则硬套到这些场景,只会让代码变慢、变复杂,没有任何收益。
现象、原因与第一步排查
下面这些症状经常被归咎于「舍入函数写错了」,实际上原因分布在存储、规则和链路三个层面。按表里的第一步查,比反复换函数有效。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 1.005 保留两位得到 1.00 | 字面量存成 1.00499999999999989 的 double,没到平局 | 按完整精度打印存储值,而不是看显示 |
| 2.675 保留两位得到 2.67,但乘 100 得 267.5 | 原值是 2.67499999999999982,乘积又被舍入成 267.5 | 分开看原值和乘法结果 |
| 0.1 加 0.2 得到 0.30000000000000004 | 两个加数都不能精确表示,和再被舍入 | 是否直接用等号比较两个浮点 |
| 汇总报表比明细合计多几分 | 每笔先舍入再相加,方向性误差累积 | 是否改成整数分或最后统一舍入 |
| Python 的 round(2.675, 2) 得到 2.67 | round 作用在二进制值上,平局规则是就近取偶 | 用 Decimal(str(x)) 而不是 Decimal(x) |
| Decimal(2.675) 不等于 2.675 | 从 float 构造时保留了二进制近似值 | 构造 Decimal 时是否传字符串 |
| 两个本应相等的金额判断为不相等 | 二进制表示不同,等号比较失败 | 比较前是否换回整数分 |
| 同一笔钱两种舍入结果差一分 | 一边用四舍五入,一边用银行家舍入 | 舍入模式是否写进接口契约 |
| 负数手续费舍入后多一分 | 向零、向下、远离零在负半轴方向不同 | 用负 2.5 把五种模式各跑一遍 |
表里前两行指向同一个事实:你看到的十进制字面量,和内存里的值不是一回事;第三行到第六行再叠一层舍入规则和构造方式的误差。最后三行则是链路问题,必须把「值从哪来、经过几次舍入、最后拿什么比较」画出来才查得清。
边界与代价
IEEE 754 不是「不准」的代名词,它在自己的语义里非常可靠:整数在 2 的 53 次方以内精确,0.5、0.25 这类二进制分数精确,加减乘除的结果都是按明确规则舍入到最近的可表示值。问题只出现在「用二进制表示十进制小数」这一件事上。理解这个边界,就不会把浮点当成万能,也不会把它当成废物。
十进制库也有自己的代价。第一是性能,十进制运算通常比双精度慢,具体慢多少取决于实现和数据规模,本文不给统一倍数。第二是上下文,Python 的 decimal 有精度上下文,默认 28 位有效数字,运算结果会按上下文舍入;如果你以为 Decimal 就是无限精确,可能在很多位之后被悄悄截断。第三是跨语言差异,不同库的默认舍入模式、精度上限、异常行为都不完全一样,接口两边必须显式约定。
当天能做的练习
- 用 Python 的 Decimal(float) 打印 1.005、2.675、0.1 的完整存储值,和十进制字面量比较,算出每个值偏大或偏小了多少。
- 用 Decimal('1.005') 和 Decimal('2.675') 分别按 HALF_UP 与 HALF_EVEN 保留两位,记录四个结果,再和 toFixed、round 的结果对照,指出哪一处差异来自存储,哪一处来自规则。
- 把 0.5、1.5、2.5、3.5 分别用四舍五入和就近取偶舍到整数,求和,和真实和 8 比较,解释偏差从哪里来。
- 写一个整数分的舍入函数,显式支持四舍五入和就近取偶,用正负 0.5、正负 1.5、正负 2.5 六个数各跑一遍,确认负数方向没有写反。
- 在现有代码里找一个用等号比较金额的地方,分别用「先舍入再比较」和「换回整数分再比较」两种写法跑同一组数据,记录哪种写法会把差异掩盖掉。
小结与下一篇
三句话收一下:十进制的 1.005 和 2.675 存进双精度后都比真值略小,所以按任何就近规则都会向下走;五种舍入模式在平局和负半轴上的方向不同,银行家舍入用就近取偶来抵消大批量数据的偏差;先舍入再比较会同时掩盖真差异、制造假相等,金额比较应该回到整数分或十进制精确值。
理解了存储和舍入,下一步是把这些十进制数真正加起来。下一篇讲大数加减:小数点怎么对齐、进位与借位怎么处理、为什么从低位往高位算、以及超过语言整数范围时怎样用数组或字符串逐位运算。那一篇会把今天说的 scale 和进位规则落到一份可以手写出来的加法器上。