先还原一个称重系统的事故。仓库的皮带秤每 20 毫秒输出一次重量增量,每次约 0.001 千克,一个班次累计一百万次,理论总重正好 1000 千克。平台收到读数后直接累加,班末页面显示 991.1415405273438 千克,比实际少了将近 8.86 千克。现场先怀疑秤不准,换了传感器、重新标定、核对每一条原始读数,单条数据都对,唯独累加结果对不上。

问题出在累加变量的类型。那条链路用的是单精度浮点,也就是 float32,每次加法只保留大约 7 位十进制有效数字。小增量加到大数上,低位被一次次舍掉,加到一百万次,误差就滚成了八公斤多。同一批数据如果换成「以毫克为单位的整数」来累加,结果是一个整数 1000000,再除以 1000 就是精确的 1000 千克。

这就是定点与浮点最核心的差别。定点数把小数放大成整数存,精度固定在最后一位;浮点数用指数加尾数,能表示极大的范围,但精度是相对的,数值越大,绝对误差越大。选哪一种,本质上是在「范围」和「精度」之间做交易。这篇把交易的两边摆出来,再按金额、坐标、时间戳分别给判断。

现场:一百万次加法,少了八点八公斤

先看错误写法。为了模拟单精度,每次加法都写回一个 Float32Array,让它强制舍入到 24 位有效位:

const box = new Float32Array(1);
let total = 0;
for (let i = 0; i < 1000000; i++) {
  box[0] = total + 0.001;
  total = box[0];
}
console.log(total);   // 991.1415405273438

如果只累加 1000 次,结果是 0.999990701675415,误差约 9 微克,看起来完全可以忽略;10 万次时结果是 99.95669555664062,误差 0.043 千克;到 100 万次,误差变成 8.86 千克。误差不是突然出现的,它一直在,只是随着次数增长被放大。这个曲线很能说明问题:单次误差小,不代表累计误差小。

再看定点写法。约定 1 个整数代表 0.001 千克,也就是把千克放大 1000 倍,累加时只加整数:

let milli = 0;
for (let i = 0; i < 1000000; i++) milli += 1;
console.log(milli);          // 1000000
console.log(milli / 1000);   // 1000

只要不溢出,整数加法没有任何舍入,一百万次之后仍然是精确的 1000000。除法只在最后显示时做一次,而且结果是整除,不产生误差。两种写法的循环次数、数据、业务含义完全相同,差别只在「把小数存在哪里」。

定点数的存取过程
采集到 0.001 千克
乘 1000,存成整数 1
全程用整数累加
显示时再除以 1000

这里的关键不是「整数比小数快」,而是「整数能精确表示,且每次加法都不丢位」。定点数把小数问题转化成了整数问题,代价是范围被缩放因子锁死,这一点后面会详细算。

定点数:把小数放大成整数存

定点数(fixed point)的规则只有一句:选一个固定的缩放因子,把真实值乘以这个因子,存成整数;要用的时候再除回去。缩放因子通常是 10 的幂,比如金额用 100(分),重量用 1000(毫克),坐标用 10000000(百分之一毫米级别的度)。

用 scale 表示 10 的幂次,真实值等于原始整数除以 10 的 scale 次方。scale 一旦定下,这个字段能表示的最小刻度就固定了:scale 等于 2 时最小是一分钱,scale 等于 3 时最小是一毫克,scale 等于 7 时最小是 0.0000001 度。不管数值本身是 1 还是 100 万,最后一位的权重都不变,这就是「定点」这个名字的由来。

// 用整数分表示金额,scale = 2
const priceCents = 1005;      // 10.05 元
const count = 3;
const totalCents = priceCents * count;
console.log(totalCents);      // 3015
console.log(totalCents / 100); // 30.15

定点数的加减法最省心:只要两边的 scale 相同,直接把整数相加相减,结果仍然精确。乘法则要把 scale 相加,两个 scale 为 2 的数相乘,结果的 scale 变成 4;除法则相反,scale 相减,并且必须明确舍入规则,因为整数除法会丢余数。很多定点库把这一步封装起来,调用方只需要声明「我要保留几位」,但底层仍然是整数运算。

定点数的精度是绝对的,范围是有限的。一个 32 位有符号整数的最大值是 2147483647,scale 等于 3 时,能表示的最大重量是 2147483.647 千克,约 2147 吨。如果仓库总量超过这个数,再加一毫克就会溢出。64 位整数把上限抬到约 9.22 乘 10 的 18 次方,scale 等于 3 时约 9.22 乘 10 的 15 次方千克,日常业务基本够用。

定点数的另一个隐性成本是「scale 要统一」。A 服务用毫克,B 服务用克,接口传的是裸整数,接收方按自己的 scale 解释,数值就会差 1000 倍。这种错误不会抛异常,只会让库存、金额、坐标安静地错下去,排查时非常费劲。所以定点字段一定要把单位写进字段名,比如 weight_mg、amount_cents,不要只叫 weight 或 amount。

浮点数:指数加尾数,用范围换精度

浮点数(floating point)不固定小数点的位置,而是用「尾数乘 2 的指数」来表示一个值。指数决定数量级,尾数决定有效数字。上一篇已经拆过双精度的符号、指数、尾数三段,这里只补它对定点的影响:浮点数的精度是相对的,有效位数固定,绝对误差随数值大小一起变大。

双精度有 53 位有效位,约等于 15 到 17 位十进制有效数字;单精度只有 24 位有效位,约等于 7 位十进制有效数字。这个「有效位数」不是小数点后几位,而是从第一个非零数字开始数的位数。所以浮点数存 0.001 和存 1000,相对误差都在 10 的负 7 次方量级(单精度),但绝对误差差了 6 个数量级。

拿单精度估一下:在 1000 千克附近,相邻两个可表示数的间隔约 0.00006 千克,也就是 0.06 克;在 1 千克附近,间隔约 0.0000001 千克。同样是单精度,数值越大,能分辨的最小增量越大。这就是为什么小增量加到大数上会被「吃掉」:0.001 千克加到 991 千克上,落点附近的可表示间隔已经大于 0.001,低位只能舍入。

定点数

精度绝对且固定,最后一位的权重不随数值变化;范围由整数位宽和 scale 决定,超出就溢出。加减法精确,乘除法要处理 scale,适合金额、库存、计量这类「刻度固定」的数据。

浮点数

范围极大,双精度能到 10 的 308 次方;精度相对,数值越大绝对误差越大。硬件直接支持,运算快,适合科学计算、图形、物理仿真这类「量级变化大、允许近似」的数据。

这张对比不是在说定点更好。定点数一旦选错 scale,要么精度不够,要么提前溢出;浮点数虽然存不准十进制小数,但在它擅长的场景里,相对误差 10 的负 16 次方已经远小于测量本身的误差。真正的判断标准是:这个业务要的是「固定的最小刻度」,还是「足够宽的数量级范围」。

范围与精度的取舍,算一遍就清楚

把两种表示画成两条线更容易理解。定点数的精度是一条水平线:不管数值多大,最小刻度始终是 10 的负 scale 次方;浮点数的精度是一条随数值上升的斜线:数值每翻一倍,绝对精度就差一倍。两条线交叉的位置,就是选型的边界。

举个具体的例子。库存重量要求精确到 1 克,也就是 0.001 千克。用定点数,scale 等于 3,32 位整数能撑到 2147 吨,绝大多数仓库够用;用单精度浮点,在 1 吨附近的最小间隔约 0.06 千克,已经大于 1 克,直接不满足要求;用双精度浮点,在 1 吨附近的最小间隔约 10 的负 13 次方千克,精度绰绰有余,但它仍然不能保证「十进制的一克」精确累加,长时间累计还是会有微小偏差。

再看范围。定点数的范围是「整数上限除以缩放因子」,想扩大范围只能换更宽的整数,或者减小 scale;减小 scale 又会牺牲精度。浮点数的范围几乎不需要操心,代价是有效位固定。所以选型的顺序应该是:先确定业务需要的最小刻度和最大范围,再看哪种类型能同时满足;两者都能满足时,再看跨语言、存储、运算成本的约束。

很多团队栽在「只算精度、不算范围」上。金额用整数分,scale 等于 2,32 位整数上限约 2147 万元,单笔没问题,但年度汇总一旦用同一个类型,很容易溢出;重量用毫克,scale 等于 3,32 位整数上限约 2147 吨,单仓没问题,多仓汇总就可能越界。定点的溢出是回绕,不是饱和,超过最大值会突然变成负数,比浮点变成无穷更隐蔽。

金额、坐标、时间戳,各选哪一种

金额几乎不需要讨论:用整数分,或者用语言自带的十进制类型,不要用浮点。整数分能精确表示百分之一元,加减乘都精确,除法明确舍入;十进制类型能表示任意小数位,适合利率、汇率、分期这类需要更多位数的场景。唯一要注意的是币种的最小单位不同,日元没有分,某些币种有千分之一,scale 不能一律写死为 2。

坐标要分精度要求。普通地图展示用双精度完全够,甚至有点浪费;单精度存 116.397 会变成 116.39700317382812,偏差约 0.0000032 度,折算成地面距离约 0.35 米,做骑手定位、门店展示勉强够,做地籍测绘、室内导航就不够。如果存储空间紧张又想固定精度,可以用 32 位整数存「度乘 10 的 7 次方」,范围约正负 214.7 度,正好覆盖经度和纬度,最小刻度约 1.1 厘米,这是很多地图 SDK 的做法。

时间戳的关键是「单位」。毫秒时间戳现在的量级约 1.7 乘 10 的 12 次方,远小于 2 的 53 次方,用双精度整数存没问题;微秒约 1.7 乘 10 的 15 次方,仍在安全整数范围内;纳秒约 1.7 乘 10 的 18 次方,已经越过 2 的 53 次方,双精度只能每隔 256 纳秒表示一个值,加 1 纳秒根本不动。纳秒时间戳必须用 64 位整数或 BigInt,64 位有符号纳秒能覆盖 1677 年到 2262 年,够用但也要注意上限。

还有一类经常被忽略的数据是 ID。雪花 ID、订单号、设备编号往往超过 2 的 53 次方,用双精度或 JavaScript 的 Number 解析会丢末位。这类值不应该参与算术,应该按字符串或 BigInt 处理,JSON 里也最好用字符串传输,避免接收方在解析阶段就把它变成浮点。

现象、真实原因与第一步排查

下面这些症状都和「数值表示选错」有关,但表现各不相同。看到类似现象,先确认字段类型和 scale,再怀疑算法。

现象真实原因第一步查什么
一百万次 0.001 千克累加后少了 8.86 千克单精度只有 24 位有效位,小增量加到大数上被舍掉累加变量是不是 float32 或单精度字段
每笔金额都对,汇总差几分汇总用浮点,逐笔的舍入误差在累计时放大汇总字段是否用整数分或 Decimal
两个服务传来的重量差 1000 倍一方按毫克、一方按克解释同一个整数字段名和接口文档是否写明 scale 与单位
定点累计突然变成负数32 位整数溢出回绕,超过上限后跳到最小值累计上限是否按业务峰值估算过
坐标显示偏了约 0.3 米单精度在 116 度附近的舍入偏差约 0.0000032 度坐标字段是否用了 float32
纳秒时间戳加 1 没有变化数值超过 2 的 53 次方,双精度无法表示每一纳秒是否用 double 存纳秒时间戳
负数除法结果和预期差一截断除法与向下取整对负数的处理不同舍入规则是否明确,跨语言是否一致
浮点加法换个顺序结果就变浮点加法不满足结合律,每次舍入落点不同是否依赖固定的累加顺序或并行归约

第一行和第四行最值得记住。第一行看起来像「传感器漂移」,实际是累加器精度不够;第四行看起来像「数据被谁改成了负数」,实际是整数溢出回绕。两类问题的共同点是都不会抛异常,只会在结果上留下一个不合理的数字。排查时先打印字段类型、scale、当前累计值,再打印每一步的增量,基本就能定位。

边界与代价:溢出、精度位、跨语言

先说过滤掉一切溢出的办法:在选类型之前,把业务的最大可能值写下来,乘以缩放因子,和类型上限比一比。金额按「单笔上限乘并发乘账期」估,重量按「单仓上限乘仓库数乘时间」估,时间戳按「最大时间乘单位」估。估算结果接近上限时,不要赌「应该不会超」,直接换更宽的类型或更小的 scale。

浮点的溢出表现和整数不同。整数溢出会回绕,浮点溢出会变成正无穷或负无穷,继续运算会变成 NaN,而且不会中断程序。很多统计页面出现 NaN,最后追到一次除法把零当成了极小的正数,或者某个中间结果溢出。浮点也不会因为「超出精度」而报错,它只会安静地舍入,这正是它比整数溢出更难发现的地方。

精度位的关键是 scale 的选择。scale 太小,业务需要的最小刻度存不进去,比如金额要算到厘,却只存了分;scale 太大,同样的整数位宽能表示的最大值变小,更容易溢出。选 scale 的原则是「刚好覆盖业务最小刻度,再多留一位余量」,不要为了看起来精确而无限加位,因为每一位都在消耗范围。

跨语言差异主要集中在三处。第一,整数除法的舍入方向:JavaScript 的 Math.trunc(-1 / 2) 得到 -0,Math.floor(-1 / 2) 得到 -1;Python 的 int(-7 / 2) 是 -3,而 -7 // 2 是 -4。同一个公式换一种语言,负数就会差一。第二,默认数值类型:JavaScript 只有双精度 Number,Java 有 int、long、float、double、BigDecimal,C# 有 decimal,Python 的 int 可以无限大、float 是双精度、Decimal 是十进制。第三,序列化:JSON 不区分整数和浮点,长整数传到 JavaScript 会被解析成双精度,末位丢失。

代价方面,整数运算最快,定点只是整数加约定,几乎不增加成本;浮点有硬件支持,速度也很快;十进制类型需要软件实现,运算更慢,但能精确表示十进制小数。选型时不要只看运行时开销,还要看维护成本:一个 scale 约定没写清楚,排查成本远高于那点运算差异。工程上更常见的做法是「存储和传输用整数或字符串,计算用定点或 Decimal,展示层最后格式化」,把精度问题关在边界内。

当天能做的练习

  1. 用 Float32Array 累加 0.001,分别跑 1000 次、10 万次、100 万次,记录结果和与理论值的差,说明误差为什么随次数加速变大。
  2. 用整数毫克实现同样的累加,再写一个除法显示函数,对比两种写法在 100 万次后的结果,确认整数版本是否精确。
  3. 写一个小型定点结构,scale 等于 3,支持加减、乘、除,乘除时明确 scale 变化和舍入规则,用 1.005 千克和 3 做测试。
  4. 在 Node.js 里验证 2147483647 + 1 与 (2147483647 + 1) | 0 的结果,再算一下 scale 等于 3 时这个上限对应多少千克,判断你的业务会不会越界。
  5. 把 116.397 分别存进 Float32Array 和普通 Number,打印两者的差,再折算成米,判断这个误差对你的定位场景是否可接受。
环境说明:文中的累加结果来自本机 Node.js 24.21.0 的实际运行,单精度通过 Float32Array 强制舍入得到。不同语言的 float32 位宽和舍入规则一致,但默认类型不同,JavaScript 的普通数字是双精度,Java 的 float 才是单精度,迁移代码时要显式确认。

小结与下一篇

三句话收一下:定点数把小数放大成整数,精度固定、加减精确,代价是范围受 scale 和位宽限制;浮点数用指数加尾数换来极大的范围,但精度相对,数值越大绝对误差越大;金额用整数分或十进制类型,坐标看精度要求选双精度或定点,纳秒时间戳必须用 64 位整数。

定点数的思路是「用整数表示小数」,但它仍然依赖一个固定的 scale。如果业务需要任意位数的小数、又要精确的四则运算,就得自己实现一个十进制小数:整数部分和小数部分分开存,或者用一个 BigInt 加上小数点位置。下一篇从这个思路出发,手写一个能精确计算 0.1 加 0.2 的十进制类型,并说明它和语言内置 Decimal 的差别。