使用Reduce实现数组元素的带延迟逐次函数执行

看起来你正在处理一个很典型的链式API数据同步场景——既要应对严格的速率限制，又得保证依赖型请求的顺序执行，还要批量处理数组元素。我之前也遇到过类似的需求，下面是一套实用的解决方案，结合异步控制和速率限制来实现你的需求：

核心实现思路 #

• 用异步函数+await确保链式请求的顺序执行，因为下一个API的参数完全依赖前一个的返回结果，必须等前一步完成再继续
• 加入固定延迟来控制调用频率，避免触发API的小时调用次数限制
• 遍历数组时使用for...of循环（而非forEach），保证每个元素的整套链式请求完成后，再处理下一个元素

示例代码实现 #

假设你已经有了基础的API调用逻辑，这里给出完整的流程示例（你可以替换成自己的真实请求和存储代码）：

// 模拟第一个数据库的API调用，传入初始参数
async function fetchDB1(initialParam) {
  const response = await fetch(`https://your-api-url/db1?param=${initialParam}`);
  if (!response.ok) throw new Error(`DB1请求失败：${response.status}`);
  return response.json();
}

// 模拟第二个数据库的API调用，依赖第一个数据库的返回结果
async function fetchDB2(db1Result) {
  const response = await fetch(`https://your-api-url/db2?referenceId=${db1Result.uniqueId}`);
  if (!response.ok) throw new Error(`DB2请求失败：${response.status}`);
  return response.json();
}

// 模拟将数据存入自有数据库的操作
async function saveToMyDB(data) {
  // 替换成你的数据库插入/更新逻辑
  console.log("已存入自有数据库：", data);
}

// 处理单个元素的整套链式请求，包含速率控制
async function processSingleItem(item) {
  try {
    // 第一步：调用第一个数据库
    const db1Data = await fetchDB1(item.initialParam);
    
    // 第二步：用第一个结果调用第二个数据库
    const db2Data = await fetchDB2(db1Data);
    
    // 第三步：保存到自有数据库
    await saveToMyDB({ sourceItem: item, db1: db1Data, db2: db2Data });
    
    // 添加延迟，控制调用频率（根据API限制调整，比如每15秒一次）
    await new Promise(resolve => setTimeout(resolve, 15000));
    
    console.log(`✅ 元素 ${item.id} 处理完成`);
  } catch (error) {
    console.error(`❌ 元素 ${item.id} 处理失败：`, error.message);
    // 可选：添加重试逻辑，比如失败后等待一段时间再重试
    // await new Promise(resolve => setTimeout(resolve, 30000));
    // await processSingleItem(item);
  }
}

// 批量处理数组中的所有元素，保证顺序执行
async function processAllItems(itemsArray) {
  for (const item of itemsArray) {
    await processSingleItem(item);
  }
  console.log("🎉 所有元素处理完成！");
}

// 调用示例：替换成你的实际数组
const targetItems = [
  { id: 1, initialParam: "user_001" },
  { id: 2, initialParam: "user_002" },
  { id: 3, initialParam: "user_003" }
];
processAllItems(targetItems);

关键细节说明 #

1. 异步顺序控制：await会暂停当前函数执行，直到异步操作完成，完美适配"下一个请求依赖前一个结果"的场景，不会出现请求乱序的问题
2. 速率限制处理：通过setTimeout包装的Promise，强制在每次请求流程后等待固定时间，你可以根据API的小时限制计算出安全的调用间隔（比如小时限制是60次，那间隔至少是60秒）
3. 数组遍历方式：for...of循环会等待每个processSingleItem完成后再进入下一次迭代，而forEach会同时触发所有异步操作，无法保证顺序，也容易瞬间触发大量请求导致超限
4. 错误处理：每个元素的处理都包裹在try/catch中，单个元素的失败不会中断整个批量处理流程，还可以按需添加重试逻辑

额外优化建议 #

• 如果API支持批量查询，可以尝试将多个初始参数打包成一次请求，减少调用次数，但如果必须依赖前序结果，顺序执行仍是唯一选择
• 可以添加调用计数和日志，实时监控已调用次数，避免接近API限制阈值
• 对于长时间运行的脚本，可以考虑加入断点续传逻辑，比如记录已处理的元素ID，重启脚本时跳过已完成的部分

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