用回调包装异步函数

Question

我需要在一个新函数中顺序调用两个异步函数。这两个函数都使用回调来执行异步操作。

当我一个一个地调用我的函数时，我面临的问题是，据我所知，它们是同步调用的，第二个函数不等待第一个函数执行

如何包装它们以按顺序执行？

我拥有的代码：

let firstFunction = (data, callback) => {

    DBCallingFirst
    .asyncMethodFirst(resultObj, (err, result) => {
      if (err) return callback(err);
      // Some code
    });
}

let secondFunction = (data, callback) => {

    DBCallingSecond
    .asyncMethodSecond(resultObj, (err, result) => {
      if (err) return callback(err);

      // Some code
    });
}

let newFunction = (data, callback) => {

    firstFunction(data, callback);
    
    secondFunction(data, callback);
}

感谢您的关注！

Answer 1

如果您能够使用 Promise 或 async/await，则可以使这变得更简洁。实际上，您可以在第一个回调中执行第二个 db 操作 - 这样可以保证第一个在调用第二个之前完成

    let firstFunction = async (data, callback) => {

    DBCallingFirst
    .asyncMethodFirst(resultObj, (err, result) => {
      if (err) return callback(err);
      DBCallingSecond
        .asyncMethodSecond(resultObj, (err, result) => {
          if (err) return callback(err);
          // Some code
        });
    });
}

编辑：有了 Promise，你可以像这样构造它：

let firstFunction = (data) => {
  return new Promise(() => {
    DBCallingFirst
      .asyncMethodFirst(data, (err, result) => {
        if (err) {
          return Promise.reject();
        }
        return Promise.resolve(result);
      });
  });
}

let secondFunction = (data) => {
  return new Promise(() => {
    DBCallingSecond
    .asyncMethodSecond(data, (err, result) => {
      if (err) {
        return Promise.reject();
      }
      return Promise.resolve(result);
    });
  });
}

let newFunction = (data, callback) => {

  firstFunction(data).then((result1) => {
    secondFunction(data).then(result2) {

    }).catch(err2) {
      console.error(err2);
    });
  }.catch((err1) => {
    console.error(err1);
  });
}

Answer 2

从这两个函数返回 Promise 并像这样等待它们

const firstFunction = (data) => {
  return new Promise((resolve, reject) => {
    DBCallingFirst.asyncMethodFirst(data, (err, result) => {
       if(err) reject(err);
       resolve(result);
    })
  })
}

    const secondFunction = (data) => {
      return new Promise((resolve, reject) => {
        DBCallingSecond.asyncMethodSecond(data, (err, result) => {
           if(err) reject(err);
           resolve(result);
         })
      })
    }

现在您可以使用 await 顺序调用它们两个

const newFunction = async (data) => { // note the async part in function definition
  try {
     const result1 = await firstFunction(data);
     const result2 = await secondFunction(data); // this will be executed only after firstFunction resolves/rejects;
  } catch (err) { 
    console.log('Error from the function', error) // promise rejection will be caught here
  } 
   
}