代码复用场景下如何避免多态以实现性能优化？

编程中的一项核心技能是代码复用（遵循DRY原则），但函数通常仅编译一次，即便不同调用位点传入的数据形状互不交叉，调用同一函数时传入略有差异的数据仍会引发多态，损害内联缓存（inline cache）及其他优化机制。

示例代码 #

const f = a => {
  let diagonal = 0;
  for (let i = 0; i < 256; i += 16 + 1) diagonal += a[i].x;
  return diagonal;
};
// 代码中一处调用：
const a1 = Array.from({ length: 256 }, () => ({ x: 0 }));
f(a1);
// 另一处无关调用：
const a2 = Array.from({ length: 256 }, () => ({ x: 0, hiddenClassChange: 0 }));
f(a2);

这类场景在性能瓶颈处频繁出现，核心问题包括：

• V8引擎是否已有应对方案？
• 是否存在理解误区？
• 除复制粘贴函数代码外，还有什么解决方法？

补充场景 #

两处调用有不同的(x, y) => data寻址方式，但迭代逻辑一致，希望避免复制迭代代码，但如果会导致寻址无法内联、错失逃逸分析等优化，可能不得不复制。

疑问[1] #

当函数被内联时，嵌入到外部函数中的代码能否在不同调用位点拥有不同的内联缓存？若能可靠实现，可解决该问题。

基准测试示例（仅用于展示性能差异） #

const f = a => {
  let diagonal = 0;
  for (let i = 0; i < 256; i += 16 + 1) diagonal += a[i].x;
  return diagonal;
};
// f的副本
const g = a => {
  let diagonal = 0;
  for (let i = 0; i < 256; i += 16 + 1) diagonal += a[i].x;
  return diagonal;
};
// 为便于理解，未简化代码
const a1 = Array.from({ length: 256 }, () => ({ x: 0, a: 0 }));
const a2 = Array.from({ length: 256 }, () => ({ x: 0, b: 0 }));
const a3 = Array.from({ length: 256 }, () => ({ x: 0, c: 0 }));
const a4 = Array.from({ length: 256 }, () => ({ x: 0, d: 0 }));
const a5 = Array.from({ length: 256 }, () => ({ x: 0, e: 0 }));
const a6 = Array.from({ length: 256 }, () => ({ x: 0, f: 0 }));
const a = [a1, a2, a3, a4, a5, a6];
// 预热f和g
for (let i = 0; i < 100000; i++) {
  for (const an of a) f(an);
  g(a1);
}
// 简单计时
let start = performance.now();
for (let i = 0; i < 100000; i++) f(a1);
console.log(performance.now() - start);
start = performance.now();
for (let i = 0; i < 100000; i++) g(a1);
console.log(performance.now() - start);

V8的应对方案 #

1. 内联时的类型特化：V8的TurboFan编译器在函数内联时，会针对不同调用位点的输入类型生成特化代码。如果调用目标函数的外部函数是单态/寡态的，内联后原函数代码会绑定到外部函数的类型上下文，每个调用位点的内联缓存（IC）完全独立。
2. 自动函数克隆与去泛化：当V8检测到函数因多态导致性能下降时，会自动克隆函数，为不同类型组合生成特化版本。该行为有触发阈值，仅在函数调用足够频繁且多态影响显著时激活。
3. 寡态IC优化：即使函数处于寡态（2-4种类型），V8的IC仍能高效处理，不会直接退化为慢路径，仅性能略逊于单态场景。

常见理解误区 #

• 绝对化"函数仅编译一次"：V8会根据调用情况生成多个特化版本。比如函数先被单态调用生成单态编译版本，后续遇到新类型时，可能生成寡态/通用版本，同时保留之前的特化版本。
• 复制代码是唯一解：手动复制代码并非必要，V8的内联和自动特化机制已能处理大部分场景，复制反而增加维护成本。
• 内联会共享IC：内联后的代码继承外部调用位点的类型上下文，不同调用位点的内联代码拥有独立IC，不会互相干扰。

替代解决方法 #

1. 封装单态调用函数：将针对不同类型的调用逻辑封装到独立的单态函数中，确保目标函数被内联后绑定到固定类型上下文：

function processTypeA(a) {
  return f(a); // 此处a类型固定，f会被内联并特化
}
function processTypeB(b) {
  return f(b); // 此处b类型固定，不影响processTypeA的特化
}

processTypeA(a1);
processTypeB(a2);

2. 工厂函数生成特化副本：通过工厂函数批量生成针对不同类型的函数副本，避免手动复制代码：

function createProcessor() {
  return a => {
    let diagonal = 0;
    for (let i = 0; i < 256; i += 16 + 1) diagonal += a[i].x;
    return diagonal;
  };
}

const fForTypeA = createProcessor();
const fForTypeB = createProcessor();

fForTypeA(a1);
fForTypeB(a2);

3. 统一数据结构：使用类（确保实例共享同一隐藏类）、Array或TypedArray替代动态对象，从根源减少对象形状差异，避免多态。

疑问[1]解答 #

是的，函数被内联后，不同调用位点的嵌入代码会拥有独立的内联缓存。V8的内联过程会将原函数代码注入到调用者上下文，每个调用位点的类型信息会用于特化内联代码，IC也针对该位点类型生成，不会与其他位点共享，这是V8解决此类多态问题的核心稳定机制。

内容的提问来源于stack exchange，提问作者Doofus