先还原一个称重系统的事故。仓库的皮带秤每 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。除法只在最后显示时做一次,而且结果是整除,不产生误差。两种写法的循环次数、数据、业务含义完全相同,差别只在「把小数存在哪里」。
这里的关键不是「整数比小数快」,而是「整数能精确表示,且每次加法都不丢位」。定点数把小数问题转化成了整数问题,代价是范围被缩放因子锁死,这一点后面会详细算。
定点数:把小数放大成整数存
定点数(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,展示层最后格式化」,把精度问题关在边界内。
当天能做的练习
- 用
Float32Array累加 0.001,分别跑 1000 次、10 万次、100 万次,记录结果和与理论值的差,说明误差为什么随次数加速变大。 - 用整数毫克实现同样的累加,再写一个除法显示函数,对比两种写法在 100 万次后的结果,确认整数版本是否精确。
- 写一个小型定点结构,scale 等于 3,支持加减、乘、除,乘除时明确 scale 变化和舍入规则,用 1.005 千克和 3 做测试。
- 在 Node.js 里验证
2147483647 + 1与(2147483647 + 1) | 0的结果,再算一下 scale 等于 3 时这个上限对应多少千克,判断你的业务会不会越界。 - 把 116.397 分别存进 Float32Array 和普通 Number,打印两者的差,再折算成米,判断这个误差对你的定位场景是否可接受。
小结与下一篇
三句话收一下:定点数把小数放大成整数,精度固定、加减精确,代价是范围受 scale 和位宽限制;浮点数用指数加尾数换来极大的范围,但精度相对,数值越大绝对误差越大;金额用整数分或十进制类型,坐标看精度要求选双精度或定点,纳秒时间戳必须用 64 位整数。
定点数的思路是「用整数表示小数」,但它仍然依赖一个固定的 scale。如果业务需要任意位数的小数、又要精确的四则运算,就得自己实现一个十进制小数:整数部分和小数部分分开存,或者用一个 BigInt 加上小数点位置。下一篇从这个思路出发,手写一个能精确计算 0.1 加 0.2 的十进制类型,并说明它和语言内置 Decimal 的差别。