先还原一次对账事故。财务系统的账户余额用浮点数存,某天日终对账,一个余额为 99999999999999999999.99 元的账户入账 0.01 元。跑完之后余额还是 100000000000000000000 元,也就是 1e20。账面上看,这一分钱没有进账,也没有报错,就像被系统吞了。

更麻烦的是,这一分钱不是加法执行时才丢的。把 99999999999999999999.99 读进 JavaScript 的那一刻,它已经被舍入成了 100000000000000000000,后面的加法只是延续这个错误。财务同事说凭证上明明是一分钱,开发复现出来却是「加了个零」,两边都没说错,只是说的不是同一个数。

这篇讲十进制大数的加减。重点不是「用 BigInt」这一句结论,而是三件具体的事:小数点怎么对齐、从最低位往高位怎么进位和借位、符号与末尾零怎么收尾。搞清这三件事,字符串实现和 BigInt 实现都只是外壳。文中所有输出都在本机 Node.js 24 上实际跑过,命令和结果一并贴出。

现场:一分钱加进去,余额没动

先把事故压缩成三行代码。第一行做加法,第二行单独看那个字面量被读成了什么,第三行验证 1e20 附近加一会不会变化。

console.log(99999999999999999999.99 + 0.01);
console.log(Number(99999999999999999999.99));
console.log(1e20 + 1 === 1e20);

本机输出:

100000000000000000000
100000000000000000000
true

三行输出指向同一个事实:在这个量级上,加 0.01 和不加没有区别,加 1 也没有区别。注意第二行,字符串还没参与任何运算,只是被转成数字,精度就已经没了。这说明问题发生在「读入」这一层,而不是「相加」这一层。很多人一看到结果不对就去换加法函数,方向从一开始就偏了。

十进制加法的四步
读入字符串,拆出符号与小数位
统一 scale,短的一边补零
去掉小数点,从最低位逐位加减
按 scale 插回小数点并收尾

这四步里没有任何一步需要浮点数。小数点只是位置标记,真正参与运算的是两边的数字。全程用字符串或整数保存,一分钱就丢不了。

浮点为什么在这里不够用

JavaScript 的数字只有一种:IEEE 754 双精度浮点(double)。它用 52 位存尾数(有效数字部分),加一个隐含前导位,共 53 位二进制有效数字,能精确表示所有整数的上限是 2 的 53 次方减一,约 9e15。超过这个范围,相邻两个可表示数之间的间距就不再是 1。

在 1e20 附近,这个间距是 2 的 14 次方,等于 16384。本机验证:1e20 加 16384 会跳到 100000000000000016384,控制台打印为 100000000000000020000;加 8192 还是 1e20。0.01 比 16384 小太多,加进去直接被舍掉。不是加法算错了,而是这个数在 double 里根本没有 0.01 这一档,就像一把刻度间隔 16384 的尺子量不出一毫米。

小数的问题更常见。0.01 在 double 里的实际值是 0.0100000000000000002081668171172,并不等于数学上的百分之一。0.1 加 0.2 得到 0.30000000000000004,原因相同:二进制小数只能精确表示分母是 2 的幂的分数,十进制里的十分之一、百分之一都不在这个集合里。

所以正确问法不是「为什么加不上」,而是「存储层还剩多少信息」。金额、数量、利率只要经过二进制浮点,就等于先被舍入了一次,后面再精确也补不回来。

先把规则定下来:符号、整数位、小数位和 scale

一个十进制数的文本形式可以拆成四段:符号、整数部分、小数点、小数部分。本文把小数部分的位数叫 scale,中文可以叫标度。1.5 的 scale 是 1,1.50 的 scale 是 2,1.5000 的 scale 是 4。三个写法数值相同,但精度不同:1.50 精确到分,1.5000 精确到丝。

加减前先对齐 scale:取两个数里较大的 scale,把另一个的小数部分右边补零。补零不改变数值,只改变写法。1.5 和 2.75 对齐到 scale 2,变成 1.50 和 2.75,两个小数点落在同一列,后面的逐位运算才有意义。

然后把小数点去掉,两个数就变成整数。1.50 变成 150,2.75 变成 275,相加得 425,再按 scale 2 插回小数点,得到 4.25。大数 99999999999999999999.99 变成 9999999999999999999999,0.01 变成 1,相加得 10000000000000000000000,再插回小数点就是 100000000000000000000.00。全程没有一次浮点运算。

解析层把文本拆成符号、整数部分和小数部分。负号只允许出现在最前面,小数点最多一个,空整数位按零处理。
对齐层取较大的 scale,短的一边补零。对齐的是小数点位置,不是字符串长度。
运算层去掉小数点后当成整数,从最低位开始逐位相加或相减,进位与借位只在这一层发生。
还原层按 scale 插回小数点,处理结果的符号、前导零和末尾零。

这四层里最容易出错的是对齐层。很多人拿到两个字符串,直接按字符从右往左加,忘了小数点两边位数不同。1.5 加 2.75 如果从末尾对齐,会变成 15 加 275,得到 290,再插小数点就成了 2.90。错误不在加法,而在小数点没有对齐。

字符串逐位相加

先写解析函数。它只负责拆分,不做任何数值转换,所以不会有精度损失。整数部分的前导零去掉,空字符串按零处理;小数部分原样保留,因为它的长度就是 scale。

function parseDecimal(s) {
  s = s.trim();
  let sign = 1;
  if (s[0] === '-') { sign = -1; s = s.slice(1); }
  else if (s[0] === '+') { s = s.slice(1); }
  const dot = s.indexOf('.');
  let intPart, fracPart;
  if (dot === -1) { intPart = s; fracPart = ''; }
  else { intPart = s.slice(0, dot); fracPart = s.slice(dot + 1); }
  intPart = intPart.replace(/^0+/, '') || '0';
  return { sign, intPart, fracPart };
}

接着把对齐后的两部分拼成一个纯数字串。整数部分在前,补过零的小数部分在后,前导零去掉。这个串的长度就是参与运算的位数,最低位在串的末尾。两个数对齐到同一个 scale 之后,这个纯数字串可以直接相加。

function digitsOf(num, scale) {
  const raw = num.intPart + num.fracPart.padEnd(scale, '0');
  return raw.replace(/^0+/, '') || '0';
}

function addDigits(x, y) {
  let i = x.length - 1, j = y.length - 1, carry = 0, out = '';
  while (i >= 0 || j >= 0 || carry) {
    const sum = (i >= 0 ? +x[i--] : 0) + (j >= 0 ? +y[j--] : 0) + carry;
    out = (sum % 10) + out;
    carry = sum >= 10 ? 1 : 0;
  }
  return out.replace(/^0+/, '') || '0';
}

进位(carry)就是这一位加完超过九之后送给高一位的一。循环条件里带上 carry,是因为两个数都走完后还可能剩一个进位,比如 99 加 1 会多出一位。循环从末尾开始,也就是最低位,每一位的进位能立刻交给下一位,不用回头重算。

最后按 scale 把数字串插回小数点。如果数字串长度不超过 scale,说明整数部分是零,前面补零;否则从右往左数 scale 位,前面是整数,后面是小数。再把符号补上。零值要单独判断,避免输出负零。

function formatDecimal(mag, scale, sign) {
  mag = mag.replace(/^0+/, '') || '0';
  const intPart = scale === 0 ? mag : (mag.length <= scale ? '0' : mag.slice(0, mag.length - scale));
  const fracPart = scale === 0 ? '' : mag.padStart(scale, '0').slice(-scale);
  let out = fracPart ? intPart + '.' + fracPart : intPart;
  const isZero = intPart === '0' && fracPart.replace(/0/g, '') === '';
  if (sign < 0 && !isZero) out = '-' + out;
  return out;
}

把上面的函数加上下一节的符号分支,就得到完整的 addDecimal;本机跑出来的结果如下。第一行是本文开头的事故数,第二行是普通小数,第三行专门验证末尾零。

99999999999999999999.99 + 0.01 = 100000000000000000000.00
1.5 + 2.75 = 4.25
1.2300 + 0.0700 = 1.3000

注意第一行保留两位小数,第三行保留四位。这不是多余,而是 scale 对齐的结果:输入最大 scale 是 4,输出就按 4 位给出。什么时候去掉这些零,是第七节要讲的事。

减法与借位:符号怎么处理

减法不能像加法那样直接按位减,因为低位可能不够减,需要向高一位借一当十。借位(borrow)就是这一位不够减时,从高一位拿一个十,同时把高一位减一。写法和手算一样,从最低位开始,记下有没有借位。

function subDigits(x, y) {
  let i = x.length - 1, j = y.length - 1, borrow = 0, out = '';
  while (i >= 0) {
    let d = +x[i--] - borrow - (j >= 0 ? +y[j--] : 0);
    if (d < 0) { d += 10; borrow = 1; } else { borrow = 0; }
    out = d + out;
  }
  return out.replace(/^0+/, '') || '0';
}

这个函数要求第一个串不小于第二个串,所以调用前必须先比较绝对值:位数多的更大,位数相同就逐位比字典序。然后用大的减小的,符号取绝对值大的那一边;两边相等时结果是零,不带符号。

把减法统一成加法更省代码:a 减 b 等于 a 加负 b,翻转 b 的符号再走加法分支。同号相加,异号相减,符号跟绝对值大的走。规则和手算一致,只是把判断放在运算之前。

function subDecimal(a, b) {
  if (b[0] === '-') return addDecimal(a, b.slice(1));
  return addDecimal(a, '-' + b);
}

function cmpDigits(x, y) {
  if (x.length !== y.length) return x.length > y.length ? 1 : -1;
  if (x === y) return 0;
  return x < y ? -1 : 1;
}

function addDecimal(a, b) {
  const A = parseDecimal(a), B = parseDecimal(b);
  const scale = Math.max(A.fracPart.length, B.fracPart.length);
  const x = digitsOf(A, scale), y = digitsOf(B, scale);
  if (A.sign === B.sign) return formatDecimal(addDigits(x, y), scale, A.sign);
  const c = cmpDigits(x, y);
  if (c === 0) return formatDecimal('0', scale, 1);
  return c > 0
    ? formatDecimal(subDigits(x, y), scale, A.sign)
    : formatDecimal(subDigits(y, x), scale, B.sign);
}

本机验证了三种边界:普通借位、跨很多位的连续借位、结果为负。输出如下。

1000.00 - 999.99 = 0.01
100000000000000000000.00 - 0.01 = 99999999999999999999.99
0.00 - 0.01 = -0.01

第二行值得单独看:一个 1 后面跟 20 个零的数,减 0.01,结果是 20 个 9 加小数点后两位 99。这个减法会从最低位一路借到最高位,每一位都变成 9。字符串实现里,这只是一次长度为 23 的循环,没有任何神奇的库调用,但每一位都必须算对。

还有三个小边界。第一,负零:0.00 减 0.00 要输出 0.00,不能输出 -0.00,否则下游按字符串比较时会把它当成另一个值。第二,输入里的正号要在解析时吃掉。第三,scale 为 0 时不要输出小数点。

用 BigInt 走另一条路

JavaScript 的 BigInt 是任意精度整数,写在数字后面加 n,比如 1n。它没有位数上限,也不经过浮点,所以去掉小数点之后的整数运算可以完全交给它。思路和字符串版本一样:按 scale 把文本变成整数,对齐,相加,再插回小数点。

function toScaledBigInt(s) {
  let sign = 1n;
  if (s[0] === '-') { sign = -1n; s = s.slice(1); }
  const [i, f = ''] = s.split('.');
  return { v: sign * BigInt(i + f), scale: f.length };
}

function formatBig(v, scale) {
  const neg = v < 0n;
  let mag = (neg ? -v : v).toString().padStart(scale + 1, '0');
  const intPart = mag.slice(0, mag.length - scale);
  const fracPart = mag.slice(mag.length - scale);
  return (neg ? '-' : '') + (scale ? intPart + '.' + fracPart : intPart);
}

function bigAdd(a, b) {
  const A = toScaledBigInt(a), B = toScaledBigInt(b);
  const scale = Math.max(A.scale, B.scale);
  const av = A.v * 10n ** BigInt(scale - A.scale);
  const bv = B.v * 10n ** BigInt(scale - B.scale);
  return formatBig(av + bv, scale);
}

formatBig 只做一件事:把整数按 scale 从右往左切开,补回小数点。先用 padStart(scale + 1, '0') 补足至少一个整数位,否则 1 分会被切成 0.1;负数要取绝对值再格式化,最后单独补负号。本机跑出来的结果和字符串版本逐字一致。

BigInt: 99999999999999999999.99 + 0.01 = 100000000000000000000.00
BigInt: 1.5 + 2.75 = 4.25
BigInt: 1000.00 + -999.99 = 0.01

Python 这边更省事:int 本身就是任意精度,Decimal 也能直接做十进制运算,本机算 99999999999999999999.99 加 0.01 得到 100000000000000000000.00。但 Decimal 有一个容易忽略的上限,它默认的计算上下文只有 28 位有效数字。本机验证:把 1 后面跟 40 个零的 41 位数加 1,默认输出是 1.000000000000000000000000000E+40,那个 1 被舍掉了;把 getcontext().prec 调到 60 之后,才得到完整的 10000000000000000000000000000000000000001。Decimal 本身不代表无限精确,精度是计算上下文的一个参数。

字符串逐位

不依赖语言特性,任何语言都能写;每一位的进位、借位都看得见,方便调试和加日志。代价是代码长,边界多,字符串拼接在大位数下会变慢。

BigInt

代码短,整数加减由运行时负责,正确性更容易保证。代价是只能处理整数,scale 要自己维护;不能和 Number 混算,解析大字符串本身也有成本。

怎么选不复杂:只是加减、语言又有原生大整数,就用 BigInt 或等价类型;要控制每一位的行为、做教学演示、或运行环境没有大整数,字符串版本更稳。两者还可以互相校验:随机生成十进制串,两种实现各算一遍,结果必须逐字相同。

结果末尾的零与 scale 规范化

末尾的零不是废话,它携带精度信息。1.20 表示精确到分,1.2 只表示精确到角。对账、发票通常要求固定两位,所以结果应保留输入里较大的 scale,而不是一算完就把零删光。

但存储和比较需要一种规范形式。同一个数值可以有 1.2、1.20、1.2000 三种写法,直接比字符串会得出「不相等」的错误结论。规范化的做法是去掉小数末尾的零,再去掉因此留下的小数点;整数部分变空就补零。本机验证:1.2300 加 0.0700 得 1.3000,规范化后是 1.3。

function normalizeDecimal(s) {
  if (!s.includes('.')) return s;
  let out = s.replace(/0+$/, '').replace(/\.$/, '');
  if (out === '-0') out = '0';
  return out;
}

比较两个金额是否相等,更稳的做法是对齐到同一个 scale 后比整数,而不是比字符串。1.2 和 1.20 对齐到 scale 2 都是 120,相等;1.2 和 1.02 是 120 和 102,不相等。整数比较没有前导零、末尾零和负零的麻烦。

存储时建议保留「整数加 scale」这一对值,而不是只存规范化后的字符串。整数可以直接运算,scale 保留业务精度;展示时再按业务规则格式化。只存字符串的话,每次运算都要重新解析,既慢又容易漏掉符号和 scale。

还要区分「数值规范化」和「展示格式化」。前者为了比较和存储,后者为了让人看。财务页面要求 1.5 显示成 1.50,这是展示规则,不该影响存储。两件事混在一起,就会出现库里存 1.5、页面按 1.5000 展示的混乱。

现象、原因与第一步排查

下面这些症状在大数加减里很常见。遇到时先按表里的第一步定位,不要急着换库或重写整个模块。

现象真实原因第一步查什么
加 0.01 后余额完全不变数值超过 2 的 53 次方,double 的间距已经大于 0.01输入在进入运算前是否已经被转成 Number
大数相加结果末几位不对逐位实现漏了最后的进位,或中途某一步转了浮点循环结束后 carry 是否还处理了一次
减法结果符号反了没有先比较绝对值,直接用小的减大的是否先比较位数和字典序再决定方向
1.2 加 0.3 得到 1.5000000000000002二进制浮点无法精确表示十进制小数金额是否用 Number 存储和运算
结果末尾多出一串零输出沿用了输入的最大 scale,没有按展示规则处理展示层是否单独做了格式化
1.2300 和 1.23 比较不相等直接比较字符串,scale 没有对齐比较前是否转成同 scale 的整数
结果出现负零或两个负号零值判断缺失,或者翻转符号时重复处理结果为零时是否强制去掉符号
十万位大数相加减很慢每次把新的一位拼到字符串头部,整体是平方级是否改用数组 push 后再 join

前两行最容易被误判。第一行像「加法没执行」,其实是「输入已经不存在」;第二行像「库有 bug」,其实是「循环少跑了一轮」。判断时先把输入原样打印成字符串,确认它还有多少位,再检查每一步的中间结果,而不是只看最后输出。

第五行和第六行属于「表示层」问题。数值本身是对的,只是写法和比较方式不统一。这类问题不会让账算错,却会让对账脚本每天多出几十条误报,把真正的问题淹掉。

边界与代价

第一道边界是精度上限。JavaScript 的 Number 只能精确表示 9e15 以内的整数,超过之后开始出现空隙。BigInt 没有这个限制,但运算比 Number 慢,和 Number 混算会抛类型错误。Python 的 int 没有上限,Decimal 的上限由 context 的 prec 决定,默认 28 位,必须显式调大。

第二道边界是「只能解决加减」。本文的算法只覆盖加法和减法。乘法要每位两两相乘再错位相加,除法要试商,都会产生新的 scale,还要决定在哪一位舍入。会了大数加法,不代表能直接处理含税单价,乘法和舍入是另一套东西。

第三道边界是输入已经丢失的精度。上游把金额存成 double 再传进来,后面的精确计算只是在传播一个错误的输入。判断方法是看数据进入系统那一刻的类型,而不是看最后的计算函数写得多认真。

第四道边界是性能。本机做过一组粗糙对照:2000 次 200 位整数加法,字符串实现约 12 毫秒,BigInt 约 0.8 毫秒,差一个数量级。这个数字受运行时优化、拼接方式和数据分布影响,不是通用结论;但它说明手写逐位运算在大位数、高频率下并不便宜,能用原生大整数时优先用原生。

字符串实现还有一个隐藏成本:每算一位都把字符拼到结果头部,位数是 n 时总复制量接近 n 的平方。200 位感觉不到,十万位就明显变慢。改成数组 push 再 join 可以降到线性。

最后是内存。一个十进制位至少占一个字符,十万位就是十万个字符,加上对象头和数组开销,一条大数可能占几百 KB。同时缓存几百万条,内存会比想象中先到上限。大数不是免费的,它只是把「精度不够」换成了「空间和计算更贵」。

当天能做的练习

  1. 把开头的三行代码原样运行并记录输出;再把 99999999999999999999.99 作为字符串打印,对比它和 Number 的长度与内容,说明精度在哪一步丢掉。
  2. 实现 addDecimal,用它算 1.5 加 2.75、1.2300 加 0.0700、0 加 0,再算三组负数,确认结果的 scale 和符号都符合预期。
  3. 实现减法,测试 1000.00 减 999.99、0.00 减 0.01、0.00 减 0.00,重点检查连续借位和负零两种情况。
  4. 用 BigInt 写一版加法,随机生成 100 组十进制串,和字符串版本逐个对比,记录第一次出现不一致的输入。
  5. 把逐位实现的字符串拼接改成数组 push 加 join,用 1 万位、10 万位各跑一次,记录耗时变化,并解释为什么差距会随位数放大。
环境说明:本文代码用 Node.js 24 在本机实际运行,Python 部分用 3.15 验证,文中输出与运行结果一致。毫秒数是一次测量的量级参考,不是基准测试结论。不同语言的整数上限和 Decimal 默认精度不同,动手前先确认运行环境的实际参数。

小结与下一篇

三句话收一下:十进制大数加减的核心是统一 scale,把小数点对齐之后当成整数逐位算;进位从最低位往高位传,借位从高位往低位借,符号在运算前先判断绝对值;结果末尾的零要不要保留,取决于展示规则,存储和比较则应该用「整数加 scale」的规范形式。

下一篇把同样的思路落到钱上。对账系统里的大数只是极端情况,更常见的是 19.99、0.01、5.99 这种两位小数。下一篇会讲为什么金额要以分为单位存整数、逐件计税和整体计税为什么会差一分、优惠分摊到多行时怎么用最大余数法补齐,以及展示层怎样把整数分安全地变回 25.99。