Node.js：循环执行多个函数后如何调用另一个函数？

看起来你现在面临的是Node.js里典型的异步循环控制问题——循环里的每个迭代都包含异步操作，你需要等所有这些异步操作全部完成后，再触发后续的函数。下面我结合你的代码场景，给出几种实用的解决方案：

第一步：把回调风格API转为Promise风格 #

你的代码里大量使用回调函数（比如get_label_info、deposite_model.get_coin_info、address_transaction），嵌套回调不仅容易陷入“回调地狱”，也很难精准控制异步流程。我们可以先把这些函数包装成返回Promise的版本，这样就能用async/await来更清晰地管理流程。

示例包装代码：

// 包装get_label_info为Promise版本
function get_label_info_promise() {
  return new Promise((resolve, reject) => {
    get_label_info((err, data) => {
      if (err) reject(err);
      else resolve(data);
    });
  });
}

// 包装deposite_model.get_coin_info为Promise版本
function get_coin_info_promise() {
  return new Promise((resolve, reject) => {
    deposite_model.get_coin_info((err, data1) => {
      if (err) reject(err);
      else resolve(data1);
    });
  });
}

// 包装address_transaction为Promise版本
function address_transaction_promise(address, user_id, coin_key, deposite_txn_fee) {
  return new Promise((resolve, reject) => {
    address_transaction(address, user_id, coin_key, deposite_txn_fee, (callback) => {
      // 假设callback为成功回调，若有错误逻辑请补充reject处理
      resolve(callback);
    });
  });
}

// 改造get_btc为返回Promise的异步函数
async function get_btc_promise(address) {
  // 先获取币种信息
  const data1 = await get_coin_info_promise();
  const coin_name = data1[0].coin_code;
  const return_functions = get_switch(coin_name);
  
  // 等待地址交易查询完成
  const callback = await address_transaction_promise(address, user_id, coin_key, deposite_txn_fee);
  
  // 处理交易列表，若循环内有异步操作，同样用Promise.all管理
  const txs = callback.response.data.txs;
  await Promise.all(txs.map(async (tx) => {
    let user_id = callback.user_id;
    // 这里写你的业务逻辑，若为异步操作需加await
  }));
  
  return;
}

第二步：用Promise.all批量等待异步任务 #

现在所有异步函数都转为Promise后，我们可以在循环中收集所有异步任务的Promise实例，再用Promise.all等待它们全部完成：

async function main() {
  try {
    // 先获取标签信息
    const data = await get_label_info_promise();
    
    // 收集循环内所有异步任务
    const asyncTasks = data.map(async (item) => {
      const address = item.address;
      // 等待当前迭代的get_btc操作完成
      await get_btc_promise(address);
    });
    
    // 等待所有循环中的异步任务全部执行完毕
    await Promise.all(asyncTasks);
    
    // 所有操作完成后，调用你的收尾函数
    console.log("所有异步操作已完成！");
    yourFinalFunction(); // 替换为你实际需要执行的后续函数
  } catch (err) {
    // 统一处理所有异步操作中的错误
    console.error("异步操作出错：", err);
  }
}

// 启动主流程
main();

关键注意事项 #

• 变量作用域：你原代码中循环用了var i，记得换成let或const，避免变量提升导致异步操作中变量值异常的问题（示例中已采用const/let）。
• 错误处理：务必用try/catch包裹await代码，或给Promise添加.catch()，避免遗漏错误导致流程中断。
• 串行vs并发：上面的方案是并发执行所有循环异步任务，如果你的场景需要串行（前一个迭代完成后再执行下一个），可以改用for...of循环：

  async function main() {
    try {
      const data = await get_label_info_promise();
      
      // 串行执行每个迭代的异步任务
      for (const item of data) {
        const address = item.address;
        await get_btc_promise(address);
      }
      
      yourFinalFunction();
    } catch (err) {
      console.error(err);
    }
  }
  

备选方案：使用Async库（不转Promise） #

如果你暂时不想改造回调为Promise，也可以用async库（需先安装：npm install async），通过async.each或async.mapLimit控制循环：

const async = require('async');

get_label_info((err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  
  // 用async.each遍历，等待所有异步操作完成
  async.each(data, (item, callback) => {
    const address = item.address;
    
    deposite_model.get_coin_info((err, data1) => {
      if (err) return callback(err);
      
      const coin_name = data1[0].coin_code;
      const return_functions = get_switch(coin_name);
      
      // 注意：需要改造get_btc，让它在内部异步完成后触发回调
      // 例如修改get_btc：function get_btc(address, done) { ... 内部异步完成后调用done() }
      get_btc(address, callback);
    });
  }, (err) => {
    // 所有循环异步操作完成后执行此处
    if (err) console.error(err);
    else yourFinalFunction();
  });
});

不过更推荐Promise+async/await的方案，这是当前Node.js的标准异步控制方式，代码可读性和可维护性更高。

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