先还原一个对账的事故。后台要给供应商导出一张结算单,单价 1.9 元,优惠 0.01 元,数量 3。同事写了一个很小的金额工具函数:先看两个数小数点后各有几位,把位数少的补零对齐,再用 Number 相加。单看 1.9 加 0.01,页面上显示 1.91,完全正常,测试也就这么过了。

上线后第一个月,财务反馈结算单每单少一分钱。查下来,问题不在加法,而在同一个函数被乘法复用之后:1.9 乘 3 得到 5.699999999999999,导出时按两位小数截断,变成 5.69,按分算应该是 570 分。另一条链路更直接,0.29 元乘 100 想换成分,得到 28.999999999999996,向下取整成了 28 分。三千多单,差了几十块,可每一行单独看都「像是对的」。

根子是同一个:Number 里没有「小数位数」这个东西。1.9 有一位小数、0.01 有两位,这只存在于字符串里;一旦转成 Number,两者都变成一串二进制有效数字,位数的概念就丢了。后面再用 toFixed 补回来,补的只是显示,不是数值。这篇从零写一个最小的十进制小数类型:用 BigInt 存「去掉小数点之后的整数」,再单独存一个 scale 表示小数点后有几位,然后实现解析、对齐、加、减、乘、除和输出。目标不是替代成熟库,而是把金额计算里那几步真正讲清楚:零补在哪一边、乘法的 scale 为什么相加、除法的余数去了哪里、负数怎么处理。

现场:加法对了,乘法没对

先把事故里的几个数原样跑一遍。下面是 Node.js 24 的实际输出,注释就是屏幕上的结果。

console.log(1.9 + 0.01);   // 1.91
console.log(1.9 * 3);      // 5.699999999999999
console.log(0.29 * 100);   // 28.999999999999996
console.log(0.3 - 0.1);    // 0.19999999999999998

第一行最容易被当成「没问题」的证据。1.9 加 0.01 在双精度里刚好落到一个打印出来是 1.91 的值上,于是补零、相加、toFixed 这一套看起来全对。第二行和第三行才暴露真相:乘法把误差放大,换成分之后又向下取整,一分钱就没了。第四行更常见,减法留下一个尾巴,只是因为 toFixed 把它遮住了,所以很少有人发现。

同一笔金额的两条出口
读取金额字符串
转成 Number
四则运算
按两位显示或按分取整

同一个值在两条出口上得到不同的分,是因为出口各自又做了一次舍入,而入口早已把「几位小数」这个信息扔掉。更麻烦的是位数不齐:1.9 和 0.01 在字符串里长度不同,函数为了对齐先把短的补成 1.90,这一步方向是对的;但补完之后仍然转成 Number 计算,等于把刚对齐的信息再扔掉一次。对齐只在十进制写法里成立,二进制浮点不认这个。

为什么 Number 没有小数位

要理解这件事,得先接受一个事实:计算机里的 Number 是二进制浮点数,它存的不是「1.9」这个十进制写法,而是「离 1.9 最近的那个二进制分数」。二进制分数只有分母是 2 的幂的数能写尽,比如 1/2、1/4、1/8、1/16;0.1 的分母是 10,写成二进制是 0.0001100110011 一直循环,永远写不完。

所以 0.1 在内存里是一个近似值,本机把完整位数打印出来是 0.1000000000000000055511151231257827021181583404541015625。0.2、0.3 也一样。两个近似值相加,结果再被舍入到最近的可表示值,于是得到 0.30000000000000004。这不是某个语言的 bug,是表示法的必然结果:十进制的小数位语义,在二进制浮点里根本不存在。

双精度有 53 位二进制有效数字,能精确表示的最大整数是 2 的 53 次方减 1,也就是 9007199254740991;超过这个范围,连整数都会开始丢位。金额本身通常不大,可小数部分从一开始就不精确。所以问题不是「精度够不够用」,而是「你要的那个十进制语义,它压根没打算给你」。

换一种存法:整数加 scale

既然二进制存不了十进制小数,就干脆不存小数。把 1.90 看成 190 个 0.01,把 1.9 看成 19 个 0.1:数字部分用 BigInt 存 190 或 19,再配一个 scale 记「小数点后有几位」。值等于整数除以 10 的 scale 次方,但这个除法只发生在最终输出时,中间全程是整数运算。BigInt 是 JavaScript 里能表示任意大小整数的类型,写法是在数字后面加 n,比如 190n;它没有 2 的 53 次方这个上限,加减乘都是精确的,代价是不能和 Number 直接混算。

数字去掉小数点之后的整数,用 BigInt 存,符号也包含在里面。1.9 存 19n,1.90 存 190n。
刻度scale,小数点后有几位,决定这个整数要除以 10 的几次方。它同时是一条业务精度声明。
展示toString 按 scale 补零、插小数点。整篇代码里,只有这一步会出现小数点。

同一个值可以有多种存法:1.9 存成 19 配 scale 1,1.90 存成 190 配 scale 2,数值相等但 scale 不同。这不是缺陷,反而有用,scale 记录了业务精度:1.90 表示精确到分,1.9 只精确到角。代价是做加减之前必须先对齐,否则 19 和 1 相加得到 20,被误读成 2.0,差了十倍。

解析:从字符串直接进 BigInt

构造函数只接受两个东西:BigInt 整数和 scale。所有从外部进来的金额都先当字符串处理,绝不过 Number。解析要做的事情很朴素:摘掉符号,按小数点切成两段,把两段拼成一个纯数字串,再交给 BigInt;scale 就是小数那一段的字符长度。

class Dec {
  constructor(i, s) { this.i = i; this.s = s; }

  static parse(text) {
    let sign = 1n, t = text.trim();
    if (t[0] === '-' || t[0] === '+') {
      if (t[0] === '-') sign = -1n;
      t = t.slice(1);
    }
    const [intPart, fracPart = ''] = t.split('.');
    const digits = (intPart || '0') + fracPart;
    return new Dec(sign * BigInt(digits), fracPart.length);
  }
}

几个细节值得说。符号先摘掉,最后再乘回去,这样 BigInt 只需要处理非负数字串;整数部分可能为空,比如 .5,用空串兜底成 0;小数部分也可能为空,比如 1.,长度是 0,scale 也就是 0,等价于整数。前导零不用手动去掉,BigInt 会把 007 认成 7n。空格先 trim,不然从 CSV 里读出来的字段很容易带一个尾部空格。

解析阶段唯一的规则是:scale 等于小数点后的字符数,包括末尾的零。1.90 的 scale 是 2,不是 1;把末尾零吃掉,等于擅自改变了业务精度。反过来,1.900 的 scale 是 3,值一样但精度声明不同,后面的对齐会按 3 位处理。没有小数点的输入,比如 1200,小数段是空串,scale 为 0,得到 1200n。负零不用特殊处理,BigInt 里没有负零,-0.00 最终就是 0n,输出时按 scale 补成 0.00,符号不会漏出来。

对齐:补零补在右边

加减之前必须把两个数的 scale 变成一样。做法是取两者较大的 scale,把 scale 小的那个整数乘上 10 的差值次方。1.9 的 scale 是 1,0.01 的 scale 是 2,差 1,于是 19 乘 10 变成 190,和 1 相加得到 191,scale 保持 2,输出 1.91。这个「乘 10」就是在小数点右边补一个零,数值不变,位数补齐。

补零的方向必须说清楚:补在小数点右边,也就是让整数变大,而不是在整数前面补零。1.9 补成 1.90 是右边补一个零,值不变;在左边补成 01.9 纯属多余,值也不变;真正会出错的是把 1.9 当成 190 却仍配 scale 1,那就变成 19.0 了。代码里的对齐只做一件事:整数乘 10 的幂,scale 跟着变大,值保持不变。

  align(other) {
    if (this.s === other.s) return [this.i, other.i, this.s];
    const s = Math.max(this.s, other.s);
    return [
      this.i * 10n ** BigInt(s - this.s),
      other.i * 10n ** BigInt(s - other.s),
      s
    ];
  }

  add(other) {
    const [a, b, s] = this.align(other);
    return new Dec(a + b, s);
  }

  sub(other) {
    const [a, b, s] = this.align(other);
    return new Dec(a - b, s);
  }

本机跑出来的结果:0.1 加 0.2 等于 0.3,0.3 减 0.1 等于 0.2,1.9 加 0.01 等于 1.91。注意这里的 0.3 是精确的 3 配 scale 1,不是那个 0.30000000000000004。加减法在这个模型里没有任何近似,只要两个操作数的 scale 对齐,结果就是精确的整数加法。

负数不需要额外分支。BigInt 的加减本身就带符号,-1.5 存成 -15n 配 scale 1,加 0.3 的 3n 配 scale 1,得到 -12n,输出 -1.2。要小心的是别在解析时把符号和小数点后的数字搞混:-1.5 去掉符号后是 1.5,scale 仍然是 1。如果先把整串转成数字再取符号,遇到 -0.5 很容易得到 0 而丢掉小数部分,这类错误在退款场景里会直接变成金额错账。

对齐还有一个副作用:结果的 scale 会变成两者中较大的那个。1.90 加 0.001 得到 1.901,scale 3,这是对的;但如果业务只允许两位,需要另外做一次舍入或截断,不能指望加法自动收窄。

乘法:scale 相加

乘法的规则最短:整数相乘,scale 相加。原因是 a 除以 10 的 sa 次方,乘上 b 除以 10 的 sb 次方,等于 a 乘 b 除以 10 的 sa 加 sb 次方。19.99 的整数是 1999、scale 2,3 的整数是 3、scale 0,相乘得到 5997、scale 2,输出 59.97。整个过程没有一次浮点运算。

  mul(other) {
    return new Dec(this.i * other.i, this.s + other.s);
  }

0.1 乘 0.1 也符合直觉:1 乘 1 得 1,scale 1 加 1 得 2,输出 0.01。用整数分来算也等价:10 分乘 10 分得到 100,但单位是「分的平方」,必须再除以 100 才回到分,这一步除以 100 就是 scale 相加在十进制里的样子。理解了这一点,就不会觉得「scale 相加」是人为规定,它只是单位换算。

乘法会让 scale 迅速变大。1.90 的 scale 2 乘 1.00 的 scale 2,得到 1.9000,scale 4;值没变,但精度声明变长了。连续乘几次,scale 会累加到十几位。业务上通常要在乘完之后做一次收尾:去掉末尾多余的零,或者按目标位数舍入。前者叫规范化,后者是下一篇的主题。规范化只删掉末尾的零,不改变数值,也不应该改变业务约定的最小精度;这两件事经常被混在一起写,结果是把 1.90 无声地变成 1.9。

除法:余数与截断

除法最容易被忽略,因为它不像加减乘那样有唯一的精确结果。1 除以 3 在十进制里是无限循环小数,任何有限位数都只是近似。所以除法的接口必须多一个参数:保留几位小数。这个位数不能由实现偷偷决定,否则调用方根本不知道结果被截到了哪一位。

  div(other, scale) {
    if (other.i === 0n) throw new Error('divide by zero');
    const num = this.i * 10n ** BigInt(other.s + scale);
    const den = other.i * 10n ** BigInt(this.s);
    return new Dec(num / den, scale);
  }

推导一下。a 等于 ai 除以 10 的 sa 次方,b 等于 bi 除以 10 的 sb 次方,a 除以 b 等于 ai 乘 10 的 sb 次方,再除以 bi 乘 10 的 sa 次方。为了让结果带上 scale 位小数,再在分子上乘 10 的 scale 次方。所以分子是 ai 乘 10 的 sb 加 scale 次方,分母是 bi 乘 10 的 sa 次方。

1 除以 3、保留 6 位:分子是 1 乘 10 的 6 次方等于 1000000n,分母是 3n,整除得到 333333n,scale 6,输出 0.333333。余数是 1000000 减 3 乘 333333 等于 1,这 1 就是被丢掉的 0.000000333。代码里没有取余数,因为 BigInt 的除法直接把它扔了;如果要判断「是否除尽」,得单独算一次 remainder。很多对账系统只比较结果,不比较余数,于是「差一点点」永远沉在水面下。

这里用的是截断,不是四舍五入:结果朝零方向取,2 除以 3 得到 0.666666,而不是 0.666667。负数同样朝零:-1 除以 3 得到 -0.333333。这个方向和「向下取整」不同,-1 除以 3 如果向下取整会得到 -0.333334,两者差一个最小单位。财务上「欠款按分向上进」还是「按分截断」,必须由业务规则决定,不能交给除法默认。除以零会直接抛错,这是对的:金额除法里出现零,通常意味着上游数据缺失,静默返回 0 会把问题藏起来。

输出:小数点只在最后出现

toString 是整套代码里唯一需要处理小数点的地方。步骤只有三步:取绝对值转成数字串;如果 scale 是 0,直接拼符号返回;否则先把串补到至少 scale 加 1 位,保证整数部分至少有一个 0,再从小数点位置切开。

  toString() {
    const neg = this.i < 0n;
    let d = (neg ? -this.i : this.i).toString();
    if (this.s === 0) return (neg ? '-' : '') + d;
    d = d.padStart(this.s + 1, '0');
    return (neg ? '-' : '') + d.slice(0, -this.s) + '.' + d.slice(-this.s);
  }

拿几个值走一遍。scale 2、整数 1n,先把 1 补成 001,切成 0 和 01,输出 0.01;scale 2、整数 0n,补成 000,输出 0.00;scale 0、整数 1200n,直接输出 1200。padStart 的长度是 scale 加 1,不是 scale,少加这个 1,整数 1、scale 2 会补成 01,切出来整数部分是空串,输出 .01。这个边界在金额小于 1 元时天天遇到,测试用例里必须有 0.01、0.09、0.10 这几个值。

不要用 Number 中转再 toFixed。BigInt 一旦转成 Number,超过 2 的 53 次方的部分就丢了;即使没超,toFixed 也会把 scale 之外的信息按它自己的规则处理。toString 必须只依赖 i 和 s 两个字段,这样同一个对象在任何机器、任何语言里输出都一样。输出的字符串还要定一条规则:是否允许负号、是否固定位数、空值怎么表示。金额接口最常见的争议不是算法,而是 0 到底写成 0 还是 0.00。

现象、原因与第一步排查

下面这些现象在金额代码里出现频率很高。看到类似症状,先按表里的第一步定位,不要一上来就把整个工具函数重写。

现象真实原因第一步查什么
1.9 乘 3 导出成 5.699999999999999Number 没有十进制位数,乘法后落到了相邻的可表示值运算前是否已经转成了 Number
0.29 乘 100 取整少 1 分乘积是 28.999999999999996,向下取整丢掉一分换成分时用 floor 还是整数分
页面显示 1.91,导出的分却是 190显示走 toFixed,结算走乘 100 取整,两条出口各自舍入两条链路是否共用同一个值
同一金额一处显示 1.9,一处显示 1.90scale 丢失,输出按 Number 的默认写法toString 是否依赖 scale 字段
乘法结果的小数位越来越长scale 相加,乘完没有收窄是否在乘后统一规范化或舍入
除法末位比预期少 1按位截断丢了余数,不是四舍五入业务要截断还是进位
负数除法差一个最小单位向零截断与向下取整方向不同用 -1 除以 3 验证一遍
超大金额的末位发生变化Number 超过 2 的 53 次方后整数不再精确是否全程 BigInt 或字符串
JSON 序列化时直接报错BigInt 不能直接 JSON.stringify对外是否转成字符串并约定格式

表里最容易误判的是第一行和第三行。第一行看起来像「乘法算错了」,其实是「进去的时候已经不是 1.9」;第三行看起来像「导出的代码有问题」,其实是「同一个数被两条链路各自舍入了一次」。判断金额问题,先问这个值在哪一步从字符串变成了 Number,再问有几条出口各自做了舍入。把这两个问题答清楚,大部分一分钱的悬案都能定位。

边界与代价

这套实现能解决「十进制小数算不准」,但它自己也有代价。第一是性能:BigInt 是堆上的对象,每次加减乘除都比 Number 慢,对齐还要做 10 的幂运算。单笔金额无所谓,几百万行批量对账时差距会显现。第二是 scale 管理:加法的 scale 取最大、乘法相加、除法由调用方指定,这些规则必须由使用方统一,否则同一个金额在系统各处会有不同的 scale,比较和输出都会出问题。scale 不是内部实现细节,它是接口契约的一部分。

第三是序列化。JSON.stringify 遇到 BigInt 会直接抛 TypeError,本机验证的报错是 Do not know how to serialize a BigInt。所以对外传输要转成字符串,并且约定字符串格式,不能一边传 1.9 一边传 1.90。数据库里用 DECIMAL 或定点整数存,读出来也按字符串进 parse。第四是能力边界:这个类没有比较、排序、舍入、开方、百分比,也没有处理科学计数法,只适合做金额加减乘和定量除法这一小块。真实项目里要么用成熟库,要么用整数分。

整数分的做法是把人民币统一存成最小单位,所有运算都是整数,输出时再除 100。它实现更简单,性能更好,代价是只能表达一种精度,遇到四位小数的单价或六位小数的汇率就不够用。十进制类则把 scale 显式化,灵活但代码量大。两条路都不是「银弹」,选择标准是这段代码是否要求「十进制写法上的精确」:要求,就用整数分或十进制类型;只是测量、统计、画图,双精度完全够用。

当天能做的练习

  1. 把本文的 Dec 类敲进 Node.js,跑 1.9 加 0.01、0.1 加 0.2、0.3 减 0.1,同时打印 i 和 s,再和直接 Number 的结果对照,说明差异发生在哪一步。
  2. 解析 1.90、.5、1.、-0.00、007.50 五个字符串,记录每个对象的 i 和 s,并解释每个 scale 为什么是那个值。
  3. 把 align 里的补零改成「在数字串左边补零」,再跑 1.9 加 0.01,观察结果怎么变,说明为什么必须在整数右边补零,也就是乘 10 的幂。
  4. 用 div 计算 1 除以 3 保留 2、4、6 位,再计算 -1 除以 3,记录结果,并手算每一次的余数,确认截断方向。
  5. 用整数分重写 add 和 mul,跑 19.99 乘 3 与 0.29 乘 100,对比两种实现的输出、代码行数和出错的可能性。
环境说明:本文代码用 Node.js 24 在本机实际运行,文中出现的 1.91、5.699999999999999、28.999999999999996、0.19999999999999998、0.30000000000000004 都是本机输出。BigInt 的行为在主流 JavaScript 引擎里一致,但性能数字会随引擎和数据量变化,文中没有给出耗时承诺。

小结与下一篇

三句话收一下:Number 里没有小数位,十进制位数只存在于字符串和 scale 里;用 BigInt 存去掉小数点的整数,加减先对齐、乘法 scale 相加、除法按调用方给的位数截断;输出的确定性来自 i 和 s 两个字段,而不是 toFixed。

这套实现只解决了「算得准」,没有解决「怎么舍」。真实业务终究要把结果收窄到两位小数,而一旦开始舍入,就会遇到 1.005 保留两位到底是 1.00 还是 1.01、2.675 到底是 2.67 还是 2.68 这类问题。下一篇进入 IEEE 754 与舍入模式,解释银行家舍入为什么存在、五种模式在正负半轴上的方向差异,以及为什么「先舍入再比较」在浮点上经常失效。