一笔订单三行明细:19.99 元、0.01 元、5.99 元,合计 25.99 元。按 8% 逐行算含税价,得 21.5892、0.0108、6.4692,四舍五入到分是 21.59、0.01、6.47,合计 28.07 元。先合计再计税,25.99 乘 1.08 得 28.0692,舍入也是 28.07 元。这一笔两边碰巧一样。
换一笔就不一定。10 件单价 0.01 元的商品,逐件算税再舍入,每件含税 0.0108 元,舍成 0.01 元,10 件合计 0.10 元;先合计再算税,0.10 乘 1.08 得 0.108,舍入是 0.11 元。同一笔交易,两种算法差一分钱。两个结果都「按规则算了」,却只有一个能和发票对上。
这一分钱不是程序写错,而是舍入顺序不同。这篇讲四件事:金额为什么用整数分存、税和折扣先算哪一步、优惠怎么分摊到多行、展示层怎样把 2599 分变回 25.99 元。代码和输出都在本机 Node.js 24 上跑过。
现场:三行明细与两次合计
先把三行金额转成整数分。转换函数只做两件事:去掉小数点,把小数部分补齐两位。19.99 元变成 1999 分,0.01 元变成 1 分,5.99 元变成 599 分,三行相加得 2599 分,正好 25.99 元。全程没有浮点运算,所以不会有 25.990000000000002 这种尾巴。
function toCents(s) {
let sign = 1;
s = s.trim();
if (s[0] === '-') { sign = -1; s = s.slice(1); }
const [i, f = ''] = s.split('.');
if (f.length > 2) throw new Error('超过分');
return sign * (Number(i) * 100 + Number((f + '00').slice(0, 2)));
}
const lines = ['19.99', '0.01', '5.99'];
const cents = lines.map(toCents);
console.log(cents.join(' '));
console.log(cents.reduce((a, b) => a + b, 0));
本机输出:
1999 1 599
2599
这里用 Number 存分,是因为 2599 远小于安全整数上限。金额超过 9e15 分,约 90 万亿元,就必须换 BigInt(任意精度整数),否则整数也会丢精度,边界一节会展开。
关键是「补齐两位」:1.5 元必须变成 150 分,不是 15 分;0.005 元这类三位小数不能直接转分,要么先定义舍入规则,要么换更小的单位。函数里「超过分就报错」是防止调用方把厘当成厘来传,最后差出十倍。
一分钱差在哪:逐件舍入与整体舍入
回到 10 件单价 0.01 元的订单。每件税是 0.01 乘 8%,等于 0.0008 元,也就是 0.08 分。按分结账,0.08 分不够一分,舍成 0 分;10 件税是 0 分,总价 0.10 元。先算整单,商品合计 0.10 元,税是 0.008 元,也就是 0.8 分,舍成 1 分,总价 0.11 元。两种算法差的这一分,来自 10 个 0.08 分被分别丢掉,而整单时它们凑成了 0.8 分。
let perItemTax = 0;
for (let i = 0; i < 10; i++) perItemTax += Math.round(0.08);
const wholeTax = Math.round(0.8);
console.log('逐件税分:', perItemTax, '总价分:', 10 + perItemTax);
console.log('整体税分:', wholeTax, '总价分:', 10 + wholeTax);
本机输出:
逐件税分: 0 总价分: 10
整体税分: 1 总价分: 11
这里的 Math.round(0.08) 是 0,Math.round(0.8) 是 1,两个数都舍入了,只是作用对象不同。逐件舍入是「每行先变成整数分,再相加」;整体舍入是「先把精确值相加,最后变一次整数分」。舍入是非线性操作,先舍后加和先加后舍一般不会相等。
逐件舍入
每一行独立结算,行金额和发票明细一一对应,退款、对账、开票都容易追溯。代价是每行丢掉的小数会累积,行数越多,和整单结果的偏差可能越大。
整体舍入
先把精确值加总,只在最后舍入一次,总额和「精确总额」最接近。代价是明细行加起来可能和总额差一分,用户逐行加一遍会发现对不上,需要额外的尾差处理。
哪种正确由业务规则决定,不由程序员选。发票通常要求价税合计(不含税价加税额)与明细匹配,很多场景必须逐行舍入,再用尾差把总额拉平;有的场景按整单计税,就以整单为准。关键是全系统只能有一套规则,不能下单逐件、退款整体,否则同一笔钱会有两个版本。
浮点为什么不能存金额
金额是十进制小数,二进制浮点只能精确表示分母是 2 的幂的分数。0.01 在 double 里的实际值是 0.0100000000000000002081668171172,不等于百分之一。单次运算差别很小,累加之后就会露出来。
本机跑了三组:0.01 累加 100 次得 1.0000000000000007;1 分累加 100 次得 100 分,格式化成 1.00 元,一分不差;0.1 加 0.2 得 0.30000000000000004。这不是 JavaScript 的 bug,而是 IEEE 754 的固有行为,换 Java、Python、Go 用 double 也一样。
let sum = 0;
for (let i = 0; i < 100; i++) sum += 0.01;
console.log(sum);
let cents = 0;
for (let i = 0; i < 100; i++) cents += 1;
console.log(cents, (cents / 100).toFixed(2));
console.log(0.1 + 0.2);
本机输出:
1.0000000000000007
100 1.00
0.30000000000000004
有人会说,展示时用 toFixed(2) 不就好了。格式化只能掩盖已经发生的误差,不能阻止误差在中间累积;把格式化后的字符串再转回数字继续算,等于把误差放回链路。金额的存储和运算必须是整数,浮点只允许出现在最后的展示环节。
以分为单位:存储与转换
「以分为单位」就是数据库存 2599,不存 25.99;程序算 1999 加 1 加 599,不算三个小数。单位是分,类型是整数,加减都在整数域完成,不会引入二进制小数误差。展示时再除以 100,把 2599 变回 25.99。
单位固定后,很多问题自动消失。比较金额直接比整数,判断为零直接看 0,对账时两边的分相加,不用考虑小数点对齐。上一篇大数加减里的小数点对齐、补零、进位,在这里退化成普通整数加减,因为 scale(小数位数)已固定在 2 位并折进了单位。
转换时注意负号和超长小数。负号只能出现在最前面;小数超过两位不能静默截断,要么报错,要么按明确规则舍入。0.005 元是 0 分还是 1 分取决于业务约定,不能让 parseInt 随手截掉。本文选择直接报错,把决定权交回调用方。
税率与折扣:先算哪一步
8% 在代码里怎么表示也有讲究。用 0.08 这个浮点去乘金额,等于把误差请回来;更好的做法是用万分比的整数 800,表示 800/10000。金额以分为单位时,税额用「分乘万分比再除以一万」来算,先得到更细的单位,再决定在哪舍入。
本机用整数毫(1 毫等于万分之一元,也等于十分之一分)承接中间结果。19.99 元的税是 15992 毫,即 1.5992 元;0.01 元的税是 8 毫,即 0.0008 元;5.99 元是 4792 毫,即 0.4792 元。舍入到分,三行税是 160、0、48 分,合计 208 分,总价 28.07 元。整单税是 207.92 分,舍入也是 208 分,总价同样 28.07 元。
function taxMills(cents, rateBps) {
return cents * rateBps / 100;
}
for (const c of [1999, 1, 599]) {
const tax = taxMills(c, 800);
console.log(c, '税毫:', tax, '税分:', Math.round(tax / 100), '含税分:', c + Math.round(tax / 100));
}
本机输出:
1999 税毫: 15992 税分: 160 含税分: 2159
1 税毫: 8 税分: 0 含税分: 1
599 税毫: 4792 税分: 48 含税分: 647
三行合起来 2159 加 1 加 647 等于 2807 分,即 28.07 元,和前面的 21.5892、0.0108、6.4692 对得上。区别是整数路径从头到尾没出现过 21.589199999999998 这种尾巴,每一步都能说清这一位怎么来的。
折扣顺序同样重要:先打折再计税,还是先计税再打折,结果会差。多数场景先算折扣后净额再计税;也有场景按原价计税、折扣作为税后优惠。两种都可能有依据,但不能在同一张订单里混用。写代码前先把规则写成一句话,再让代码严格执行。
税率也可能带更多小数位。8% 恰好在毫上除尽,13%、6% 在两位小数金额上通常也能落到毫,但叠加多次折扣或按比例分摊后,尾数会继续变长。这时要么继续放大单位,要么明确在哪一层舍入,不能指望一个固定单位包打天下。
分摊优惠:最大余数法
优惠 10 分要摊到三行明细,最容易出尾差。三行金额 1999 分、1 分、599 分,权重合计 2599。10 分乘各行权重再除以 2599,精确份额是 7.6914、0.0038、2.3047 分。直接四舍五入得 8、0、2,加起来 10,碰巧平了;换成别的数字,舍入后的和可能是 9 或 11。
最大余数法(largest remainder method)分三步:先给每行取整数下限,再把剩下的分逐个发给小数部分最大的行,直到分完。它保证每行都是整数分,且总和正好等于优惠额。下面的代码用整数取余比较余数,避免浮点比较的抖动。
function allocate(total, weights) {
const W = weights.reduce((a, b) => a + b, 0);
const rows = weights.map((w, i) => ({
i, base: Math.floor(total * w / W), rem: (total * w) % W,
}));
let rest = total - rows.reduce((a, r) => a + r.base, 0);
rows.sort((a, b) => b.rem - a.rem || a.i - b.i);
for (let k = 0; k < rest; k++) rows[k].base += 1;
rows.sort((a, b) => a.i - b.i);
return rows.map(r => r.base);
}
本机跑了三组。优惠 10 分、权重 1999、1、599,结果是 8、0、2,合计 10。三行等额时精确份额是 3.3333 分,先各取 3 分,剩下 1 分给余数最大的第一行,结果 4、3、3。权重 500、300、200 的份额正好 5、3、2,不用补余数。
allocate(10, [1999, 1, 599]) // 8 0 2
allocate(10, [1, 1, 1]) // 4 3 3
allocate(10, [500, 300, 200]) // 5 3 2
余数相等时必须有确定的排序规则,比如按行号从小到大。否则两次运行、两个实例可能给出不同结果,对账时同一张订单的优惠分摊会对不上。代码里的 a.i - b.i 就是兜底。
还有一种常见但危险的做法:把余数全塞给最后一行。代码短,但最后一行可能多摊几分甚至变成负数,退款逻辑就会崩。最大余数法把余数分给「最接近进位」的行,既保证总和,又让每行偏差不超过一分。
单位选择:分、厘、毫
「以分为单位」最常见,但不是唯一。人民币的辅币(主币以下的小额单位)里,1 元等于 100 分,1 分等于 10 厘,1 厘等于 10 毫,所以 1 元等于 1000 厘、10000 毫。单位越细,单次舍入丢掉的信息越少,代价是数值变大、存储和展示更麻烦。
拿 19.99 元的 8% 税看。精确税额 1.5992 元,等于 159.92 分、1599.2 厘、15992 毫。按分四舍五入是 160 分;按厘是 1599 厘,即 159.9 分;按毫完全精确,没有舍入。单行看三种做法只差零点几分,很容易忽略。
放到 100 万行,差别就出来了。精确税额合计 159,920,000 分。按分逐行舍入再累加,得 160,000,000 分,多 80,000 分,即 800 元;按厘逐行舍入再累加,得 1,599,000,000 厘,即 159,900,000 分,少 20,000 分,即 200 元。两者差 100,000 分,刚好 1000 元。
| 单位 | 1 元等于 | 19.99 元的 8% 税 | 单行舍入结果 |
|---|---|---|---|
| 分 | 100 | 159.92 分 | 160 分,偏多 0.08 分 |
| 厘 | 1000 | 1599.2 厘 | 1599 厘,偏少 0.2 厘 |
| 毫 | 10000 | 15992 毫 | 精确,无舍入 |
这组数字不是说「必须用毫」。单位越细,数值越大,数据库、接口、前端都要跟着改;毫在 100 万行时也可能因税率带更多位而再次除不尽。真正要定的是结算粒度:面向用户收付通常用分,内部税额计算可以先用更细单位,最后按规则舍入到分。把计算单位和结算单位分开,比盲目追求更细更实际。
展示层:整数分怎么变回金额
展示层只做一件事:2599 变 25.99,1 变 0.01,0 变 0.00。1 分不能显示成 0.1,整数部分要补零,小数部分固定两位。下面的函数先取绝对值,再左补零到至少三位,从右往左两位切开。
function formatCents(c) {
const neg = c < 0;
const mag = String(Math.abs(c)).padStart(3, '0');
return (neg ? '-' : '') + mag.slice(0, -2) + '.' + mag.slice(-2);
}
console.log(formatCents(2599));
console.log(formatCents(1));
console.log(formatCents(0));
本机输出:
25.99
0.01
0.00
大额金额要用 BigInt 的同一套逻辑。本机拿 9999999999999999999999 分测试,格式化结果是 99999999999999999999.99 元。先转 Number 再除以 100,会变成 100000000000000000000,即 1e20,最后两位直接消失。这是上一篇浮点精度问题在金额上的翻版。
展示层还有两个细节。第一,舍入规则要统一:遇五进位还是银行家舍入,全系统必须一致。第二,货币符号和千分位属于展示格式,不要拼进数据库字段。把 2599 存成「¥25.99」看似方便,下次要算只能再解析,等于把整数分的优势丢掉。
现象、原因与第一步排查
下面这些症状在对账和订单系统里很常见。遇到时先按表里的第一步定位,不要急着重写整条金额链路。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 明细逐行相加比订单总额少一分 | 逐件舍入和整体舍入作用在不同层级,尾差(各行舍入后与总额的零头差)没有归集 | 舍入是按行做还是按单做,尾差记在哪个字段 |
| 10 件 0.01 元,税后金额少一分 | 每件 0.08 分被舍成 0,10 件凑成 0.8 分后本应进位 | 是否逐件舍入,能否改为整单计税 |
| 优惠分摊后三行合计不等于优惠额 | 每行独立四舍五入,余数被丢掉 | 是否用了最大余数法并补齐余数 |
| 金额出现 25.990000000000002 | 用浮点存金额或中途转成浮点 | 存储字段和运算变量是不是整数分 |
| 100 次 0.01 元累加得到 1.0000000000000007 | 二进制浮点误差随累加放大 | 累加变量是 Number 还是整数 |
| 大额订单金额变成 1e20 | 整数分超过 2 的 53 次方后转成 Number | 是否该用 BigInt 或字符串 |
| 退款金额和原单差一分 | 退款时重新按比例分摊,舍入结果和原单不一致 | 退款是否沿用原单的分摊明细 |
| 页面金额少了末尾的零 | 整数分除以 100 后直接打印,没有固定两位 | 展示函数是否统一补零 |
前两行是本文的核心。第一行像「加法算错」,其实两边都对,只是舍入层级不同;第二行像「税算少了」,其实是每行丢掉的小数在整单层面又凑了回来。判断时先把每行的精确值、舍入值、误差列出来,再对比整单,通常一眼能看出差在哪层。
第六行和第七行分别属于类型和流程问题:前者存储类型选错,后者退款没有复用原单数据。两类问题都等到对账才发现,而这时已积累了大量订单。把单位、类型、舍入规则、退款依据在需求阶段写清楚,比事后写脚本补账更省力。
边界与代价
第一道边界是整数上限。Number 能精确表示 9e15 以内的整数,换成金额约 90 万亿元。单笔订单远到不了,但账户余额、年度汇总、批量对账的累加值可能接近。BigInt 能解决上限,代价是不能和 Number 混算,JSON 也不能直接序列化,要转字符串传输。
第二道边界是负数与退款。退款应沿用原单的分摊结果,不要重新按比例算,否则舍入顺序不同会差一分。负数舍入方向也要先定:按绝对值舍入后加负号,还是直接对负数做 half-up(遇五进位)。两种在边界值上结果不同,必须和财务规则对齐。
第三道边界是币种。人民币两位小数,日元零位,科威特第纳尔三位,辅币单位不同。代码里不能到处写死 100,要把最小单位做成配置:人民币 100,日元 1,第纳尔 1000。展示的小数位数也跟着配置走,否则日元金额会被显示成两位小数。
第四道边界是规则本身。税率按行还是按单、折扣在税前还是税后、运费是否参与分摊、退款是否退手续费,这些不是技术问题,而是业务和合规问题。技术能做的是参数化规则、把中间值落库、把舍入位置写进文档,而不是替业务拍板。
最后是复杂度。整数分会带来更多字段:原价、优惠、税额、应付、已退,每个都要有明确含义和更新时机。相比存一个浮点数,前期确实麻烦;但换来的是每次加减都可复现、每分钱都能追到来源,对账系统需要这个成本,不是过度设计。
当天能做的练习
- 用本文的
toCents把 19.99、0.01、5.99 转成分,验证合计是 2599,再把结果格式化成 25.99,确认没有浮点尾巴。 - 复制 10 件 0.01 元的例子,分别按逐件和整单计算 8% 税,记录两次总价,并写出那一分钱是在哪一步产生的。
- 实现
allocate,用 10 分优惠测试权重 1999、1、599 和三个等额行,检查两组结果是否都等于 10,并说明余数给了哪一行。 - 把 0.01 元累加 100 次、1000 次,再对比整数分累加同样次数,记录两种结果的差值,解释差值随次数变化的趋势。
- 设计一张订单表的金额字段:原价、优惠、税额、应付、已退,全部用整数分,写清楚每个字段的更新时机和退款时的取值来源。
小结与组内回望
三句话收一下:金额用整数分存,因为十进制小数在二进制浮点里存不准,整数加减永远精确;逐件与整体舍入的差别来自「先舍后加」和「先加后舍」,差一分是规则问题,不是算术错误;优惠分摊用最大余数法补齐,保证每行都是整数分且总和不变。
三篇连起来看,线索是同一条:数值的「值」和「表示」必须分开。IEEE 754 那篇讲二进制浮点怎么表示十进制小数,为什么 0.1 加 0.2 不是 0.3,银行家舍入在做什么;大数加减那篇讲超出浮点精度时,怎么用字符串或 BigInt 逐位算准;这篇把这些手段落到钱上,用整数分固定单位,用明确的舍入顺序和分摊算法保证每分钱都对得上。
共同结论压成一句:先问这个数要精确到哪一位,再选能保住这一位的表示;把舍入当成显式的业务规则,而不是存储类型的副作用。做到这两点,1e20 加 0.01 不会静默消失,19.99 加 0.01 加 5.99 也不会悄悄变成 25.990000000000002。