NodeJS中从对象数组选项生成万级变体的高效实现方案

Hey，我明白你遇到的问题了——用递归生成大量变体时直接爆内存对吧？咱们一步步来解决，先把需求和现有情况理清楚：

你从PostgreSQL拉取的选项数据，数据库里的极简结构大概是这样：

OPTIONS
label choices
style [{label: 'Flat'}, {label: 'J', price: 10}, {label: 'Curved', price: 20}]
color [{label: 'Black'}, {label: 'Purple'}, {label: 'Blue'}, {label: 'Orange', price: 40}]

拉取后得到的JSON格式是：

var options = [
  {label: 'style', choices: [{label: 'Flat'}, {label: 'J', price: 10}, {label: 'Curved', price: 20}]},
  {label: 'color', choices: [{label: 'Black'}, {label: 'Purple'}, {label: 'Blue'}, {label: 'Orange', price: 40}]}
];

最终要生成的变体组合示例是所有选项的笛卡尔积：

[
  { style: {label: 'Flat'}, color: {label: 'Black'} },
  { style: {label: 'Flat'}, color: {label: 'Purple'} },
  // ... 剩余所有组合省略
  { style: {label: 'Curved', price: 20}, color: {label: 'Orange', price: 40} }
]

你之前写的递归函数在小数据集下没问题，但当选项数量增加到20个、潜在变体达数万级时，因为一次性把所有变体都存入数组，会直接导致内存堆耗尽，程序崩溃。

咱们换个思路，用**生成器函数（Generator）**来实现按需生成变体，这样不用一次性把所有数据加载到内存里，同时先实现高效计算总变体数的逻辑。

1. 高效计算潜在变体总数 #

这个逻辑很简单，把每个选项的choices长度相乘即可，同时处理空选项的边界情况：

function calculateTotalVariations(options) {
  return options.reduce((total, option) => {
    const choiceCount = option.choices?.length || 0;
    // 只要有一个选项没有可选值，总变体数直接为0
    if (choiceCount === 0) return 0;
    return total * choiceCount;
  }, 1);
}

// 用法示例
const total = calculateTotalVariations(options);
console.log(`总变体数：${total}`);

2. 分批生成变体的生成器函数 #

用Generator实现递归式的笛卡尔积生成，每次调用next()就能得到一个变体，也可以封装工具函数批量取出指定数量的变体：

function* generateVariations(options, optionIndex = 0, current = {}) {
  if (optionIndex >= options.length) {
    // 深拷贝当前组合，避免后续修改影响已返回的结果
    yield JSON.parse(JSON.stringify(current));
    return;
  }

  const option = options[optionIndex];
  const optionKey = option.label;

  for (const choice of option.choices) {
    current[optionKey] = choice;
    yield* generateVariations(options, optionIndex + 1, current);
  }

  // 清理当前层级的属性，避免影响其他分支的生成
  delete current[optionKey];
}

// 封装分批获取的工具函数，默认每批500个
async function getVariationBatch(generator, batchSize = 500) {
  const batch = [];
  for (let i = 0; i < batchSize; i++) {
    const result = generator.next();
    if (result.done) break;
    batch.push(result.value);
  }
  return batch;
}

3. 使用示例 #

// 初始化变体生成器
const variationGenerator = generateVariations(options);

// 分批处理所有变体
async function processVariations() {
  let batch;
  let batchNumber = 1;
  do {
    batch = await getVariationBatch(variationGenerator, 500);
    if (batch.length > 0) {
      console.log(`处理第${batchNumber}批，共${batch.length}个变体`);
      // 这里替换成你的业务逻辑，比如写入数据库、数据校验等
      // processBatch(batch);
      batchNumber++;
    }
  } while (batch.length > 0);
  console.log("所有变体处理完成");
}

// 启动处理流程
processVariations();

• 内存友好：生成器每次只生成一个变体，不会一次性把所有变体存入内存，即使是几十万级的变体也能稳定运行
• 灵活可控：通过getVariationBatch可以自由调整每批的数量（比如500-1000个），适配你的业务场景
• 逻辑清晰：保留了递归处理笛卡尔积的思路，代码易读、易维护

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