如何优化生成两个对象数组所有可能组合的嵌套循环实现

优化前提 #

两个数组的完整笛卡尔积本身的时间复杂度固定为O(m*n)（m为supply数组长度，n为demand数组长度），不存在规避双重遍历的实现，所有优化都围绕降低遍历过程中的额外开销实现。

可落地优化方案 #

• 替换高阶函数+concat逻辑，改用预分配数组+原生for循环
  你现有实现中的reduce+concat+map组合会产生大量额外开销：concat每次执行都会生成新数组，触发多次内存拷贝和数组扩容，高阶函数的回调调用也会产生冗余性能损耗。换成预分配固定长度的结果数组+双层for循环直接赋值，性能可以提升3~10倍（根据数据量不同有波动）。

const m = supply.length;
const n = demand.length;
// 预分配和结果数量完全匹配的数组，避免中途扩容
const result = new Array(m * n);
let index = 0;
for (let i = 0; i < m; i++) {
  const currentSupply = supply[i];
  const supplyId = currentSupply.id;
  const supplyName = currentSupply.name;
  for (let j = 0; j < n; j++) {
    const currentDemand = demand[j];
    result[index++] = {
      id: `${supplyId}-${currentDemand.id}`,
      supply: supplyName,
      demand: currentDemand.name
    };
  }
}
return result;

• 按需生成结果，降低内存开销
  如果后续业务不需要一次性拿到全量组合，而是可以逐个处理每个组合，推荐用生成器函数实现，不需要在内存中存储全量结果数组，内存占用可以降低数个量级，特别适合超大规模数据集的场景。

function* generateCombination(supply, demand) {
  for (const currentSupply of supply) {
    const supplyId = currentSupply.id;
    const supplyName = currentSupply.name;
    for (const currentDemand of demand) {
      yield {
        id: `${supplyId}-${currentDemand.id}`,
        supply: supplyName,
        demand: currentDemand.name
      };
    }
  }
}

// 使用时按需遍历即可，不会一次性占用大量内存
for (const combination of generateCombination(supply, demand)) {
  // 单个组合的处理逻辑
}

• 前置过滤无效数据
  如果业务逻辑允许，在生成笛卡尔积之前提前过滤掉不需要的supply、demand项，缩小两个数组的长度基数，是最直接的性能提升方式。

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