#现象

一个数据聚合接口,输入是几万条订单记录,输出按商家分组的汇总。压测数据量到 5 万条时,服务端 CPU 单核跑满,P99 从 80ms 涨到 900ms。

火焰图看得很清楚:aggregate() 这一层占了 62% 的采样,里面没有 IO、没有正则、没有任何可疑的库函数,就是一层 for 循环加对象读写。

那问题只能出在「对象」本身。

#先做个对照实验

服务端是 Node 20(V8 11.x),我把它挪到本地,用 performance.now() 跑了 20 轮取中位数,构造最简复现:

JavaScript
// A:字段顺序一致
function buildA(rows) {
  const acc = {};
  for (const row of rows) {
    const key = row.shopId;
    if (!acc[key]) acc[key] = { shopId: key, count: 0, amount: 0, firstAt: null };
    acc[key].count++;
    acc[key].amount += row.amount;
  }
  return acc;
}

// B:字段顺序随数据变化
function buildB(rows) {
  const acc = {};
  for (const row of rows) {
    const key = row.shopId;
    if (!acc[key]) acc[key] = {};
    if (row.firstFlag) acc[key].firstAt = row.createdAt;   // 有时先有 firstAt
    acc[key].count = (acc[key].count || 0) + 1;
    acc[key].amount = (acc[key].amount || 0) + row.amount;
    acc[key].shopId = key;
  }
  return acc;
}
版本 5 万条耗时 相对基线
A(固定形状) 21ms 1.00x
B(顺序不定) 36ms 1.71x

差异确实存在,而且和业务代码里那个「先判断再补字段」的写法一模一样。

#隐藏类是什么

V8 里每个对象都有一个隐藏类(hidden class / map),记录「这个对象有哪些属性、分别在哪个偏移」。访问 obj.amount 时,V8 不需要查字典,直接用隐藏类里的偏移量做一次内存寻址——这是 JavaScript 对象访问能接近 C 结构体的原因。

问题在于隐藏类是随赋值过程演进的:

JavaScript
const a = {};         // map: {}
a.x = 1;              // map: { x }
a.y = 2;              // map: { x, y }

每次新增属性都会产生一个新的 map,V8 内部维护一棵 map 树。只要两个对象以相同顺序走完相同的路径,它们就共享同一个 map,访问点的内联缓存(inline cache)就能命中,走「单态」快路径。

一旦顺序不同:

JavaScript
const b = {};
b.y = 2;   // map: { y }
b.x = 1;   // map: { y, x }  ← 完全不同的分支

两个对象结构上「一样」,但对 V8 来说是两种类型。访问点从单态退化成多态,甚至超多态(megamorphic),每次都要重新判断形状——这就是那 1.7 倍的来源。

#怎么确认是这个问题

不靠猜。V8 提供了几个诊断入口,我在排查时用了三个。

一、--trace-ic 看内联缓存状态。(需要 --allow-natives-syntax 或直接用 d8)

Bash
node --trace-ic ./bench.mjs 2>&1 | grep "aggregate" | head -30

输出里的 1 MONO 表示单态,4 POLY 表示多态,>4 MEGA 就是灾难信号。我们那段代码在 B 版本下出现了大量 MEGA。

二、%HaveSameMap 直接比较两个对象的隐藏类。 这个只能在 d8 或开启了 --allow-natives-syntax 的 node 里用:

JavaScript
// 启动:node --allow-natives-syntax
const x = { a: 1, b: 2 };
const y = {}; y.b = 2; y.a = 1;
console.log(%HaveSameMap(x, y));  // false

开发环境跑一次,比读十篇博客都直接。

三、--trace-deopt 看优化是否被撤销。

Bash
node --trace-deopt ./bench.mjs 2>&1 | grep -i "deoptimiz" | head

如果函数在热起来之后被反复去优化,几乎一定是形状不稳定或者类型混杂导致的。

#修复:把形状固定下来

业务代码的修法很朴素——先建完整对象,后填值,而不是边判断边加字段:

JavaScript
// 修复前:字段是"长"出来的
const acc = {};
if (row.firstFlag) acc.firstAt = row.createdAt;
acc.count = (acc.count || 0) + 1;

// 修复后:字段在创建时就齐了
const acc = { shopId: key, count: 0, amount: 0, firstAt: null };

改完之后:

指标 修复前 修复后
5 万条耗时 36ms 22ms
P99(全链路) 900ms 540ms
CPU 单核占用 98% 61%

40% 的整体提升,来自一行字段顺序。

#几个容易踩的变体

一、delete 直接打回字典模式。

JavaScript
const o = { a: 1, b: 2, c: 3 };
delete o.b;   // 对象退化为 dictionary mode,后续所有访问都变慢

如果确实要「去掉一个字段」,用赋值 null 代替 delete:

JavaScript
o.b = null;

二、JSON.parse 出来的对象形状其实很稳定。 同一段 JSON 重复解析,V8 会缓存 map,性能很好。真正的风险在于解析后你又往里补字段——那就回到了上面的问题。

三、对象当 Map 用,键空间很大时很危险。 每次新增键都会扩展 map 树,几十万键之后查询会明显退化。数量级超过几千就该换 Map:

JavaScript
// 键数量不可控,用 Map
const index = new Map();
index.set(key, value);

四、构造函数里 this.x = ... 顺序不一致。 两个子类混在同一个数组里遍历,访问点必然是超多态。要么统一顺序,要么拆成两个数组。

五、数组元素类型混杂。 这条不算隐藏类,但同源:[1, 2, 3] 是 PACKED_SMI,[1, 2, 'x'] 变成 PACKED_ELEMENTS,遍历时会有额外开销。数据清洗在入口做,别留到热路径。

#什么时候不用管这些

说实话,90% 的业务代码不需要考虑隐藏类。V8 的优化已经足够宽容,几万次迭代的差异肉眼不可见。

值得关注的信号只有三个:

  1. 单函数占据显著 CPU 采样(比如火焰图里超过 20%);
  2. 数据量进入十万级且循环体内有大量对象读写;
  3. --trace-ic 里出现成片的 MEGA。

三条同时成立,再去优化形状。否则你只是在给一台没坏的机器换零件。

#附:可直接复用的基准脚本

JavaScript
import { performance } from 'node:perf_hooks';

function bench(name, fn, rounds = 20) {
  const samples = [];
  for (let i = 0; i < rounds; i++) {
    const t = performance.now();
    fn();
    samples.push(performance.now() - t);
  }
  samples.sort((a, b) => a - b);
  const median = samples[Math.floor(samples.length / 2)];
  console.log(`${name}: ${median.toFixed(1)}ms (min ${samples[0].toFixed(1)})`);
  return median;
}

两点提醒:一定要先跑几轮预热(让 JIT 完成优化),一定要取中位数而不是平均值——GC 的偶发停顿会把平均值污染得毫无意义。