Question

这个问题的性能解决方案是什么，我想做一些异步调用，等到最后所有调用都完成，然后返回结果。

function parseAndMatch(arg1, arg2){
   async.all([
      asyncCall1(arg1, arg2),
      asyncCall2(arg1, arg2)]
   ).then( result => {
      //do something with result;
      return finalResult;
   });
}

我尝试使用npm deasync，asyncawait，bluebird和async包来解决此问题。但我找不到解决方案。

Answer 1

在JavaScript中，可以使用all对象上的Promise方法处理多个异步操作。不需要使用库。

Promise.all返回一个Promise，并获取一个包含需要解析的多个Promise的iterable。一旦所有，迭代中的Promise已通过调用Promise.all解析而解决了返回的Promise。如果可迭代拒绝中的任何承诺，Promise.all返回的承诺会立即拒绝。

Promise.all使用赋予它的Promises的所有分辨率值的可迭代值进行解析。 Promise.all拒绝了被拒绝的迭代中给出的Promise的值。

举个例子，你可以像这样使用Promise.all：

function parseAndMatch(arg1, arg2){
  return Promise.all([
    asyncCall1(arg1, arg2),
    asyncCall2(arg1, arg2),
  ]);
}

parseAndMatch()
  .then(doSomethingElse)
  .catch(handleRejection);

进一步阅读

Answer 2

在@wing回答的基础上，我使用原生Promise和npm deasync库解决了这个问题。但我不确定它的效率和性能如何。

function parseAndMatch(callback) {
  return Promise.all([
      new Promise(function(resolve, reject) {
            var sum = 1;
            for (var i = 0; i < 10000; i++) {
                sum++;
            }
            return resolve(sum);
      }),
      new Promise(function(resolve, reject) {
            var sum = 1;
            for (var i = 0; i < 90000; i++) {
                sum++;
            }
            return resolve(sum);
      }),
  ]);
}

function joinAndReturn(){
    var done = false;
    var result;
    parseAndMatch().then((results) => {
        result = results[0] + results[1];
        done = true;
    });
    deasync.loopWhile(function(){return !done;});
    return result;
}

console.log(joinAndReturn());//100002

Answer 3

如果asyncCall1和asyncCall2返回Promises。使用bluebird：

function parseAndMatch(arg1, arg2){
  return Promise.join(
      asyncCall1(arg1, arg2), 
      asyncCall2(arg1, arg2), 
      (result1, result2) => {
        //do something with result1, result2;
        return finalResult;
  });
}

如果他们支持回调。使用async.parallel：

function parseAndMatch(arg1, arg2, callback) {
  async.parallel([
      callback => {
        asyncCall1(arg1, arg2, callback);
      },
      callback => {
        asyncCall2(arg1, arg2, callback);
      },
    ], (err, results) => {
        if (err)
          return callback(err);
        //do something with result[0], result[1];
        return callback(null, results);
    })
}

加入所有异步调用以返回一些结果

3 个答案: