处理Promise.all中的错误

我有一个promise数组，我用Promise.all(arrayOfPromises)来解析它;

我继续承诺链。大概是这样的

existingPromiseChain = existingPromiseChain.then(function() {
  var arrayOfPromises = state.routes.map(function(route){
    return route.handler.promiseHandler();
  });
  return Promise.all(arrayOfPromises)
});

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
  // do stuff with my array of resolved promises, eventually ending with a res.send();
});

我想添加一个catch语句来处理一个单独的promise，以防它出错，但是当我尝试时，promise。all返回它找到的第一个错误(忽略其余的错误)，然后我就不能从数组中的其余承诺(没有错误)中获得数据。

我试过做一些像…

existingPromiseChain = existingPromiseChain.then(function() {
      var arrayOfPromises = state.routes.map(function(route){
        return route.handler.promiseHandler()
          .then(function(data) {
             return data;
          })
          .catch(function(err) {
             return err
          });
      });
      return Promise.all(arrayOfPromises)
    });

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
      // do stuff with my array of resolved promises, eventually ending with a res.send();
});

但这并不能解决问题。

谢谢!

编辑:

下面的答案是完全正确的，代码被破坏是由于其他原因。如果有人感兴趣，这是我最终得出的解决方案……

节点快速服务器链

serverSidePromiseChain
    .then(function(AppRouter) {
        var arrayOfPromises = state.routes.map(function(route) {
            return route.async();
        });
        Promise.all(arrayOfPromises)
            .catch(function(err) {
                // log that I have an error, return the entire array;
                console.log('A promise failed to resolve', err);
                return arrayOfPromises;
            })
            .then(function(arrayOfPromises) {
                // full array of resolved promises;
            })
    };

API调用(路由。异步调用)

return async()
    .then(function(result) {
        // dispatch a success
        return result;
    })
    .catch(function(err) {
        // dispatch a failure and throw error
        throw err;
    });

把。catch作为承诺。在.then之前的所有内容似乎都用于从原始的promise中捕获任何错误，但随后将整个数组返回到下一个.then

谢谢!

当前回答

您需要知道如何识别结果中的错误。如果您没有标准的预期错误，我建议您对catch块中的每个错误运行转换，使其在结果中可识别。

try {
  let resArray = await Promise.all(
    state.routes.map(route => route.handler.promiseHandler().catch(e => e))
  );

  // in catch(e => e) you can transform your error to a type or object
  // that makes it easier for you to identify whats an error in resArray
  // e.g. if you expect your err objects to have e.type, you can filter
  // all errors in the array eg
  // let errResponse = resArray.filter(d => d && d.type === '<expected type>')
  // let notNullResponse = resArray.filter(d => d)

  } catch (err) {
    // code related errors
  }

2019-11-19 00:54:13

其他回答

我们可以在单个承诺级别处理拒绝，所以当我们在结果数组中获得结果时，被拒绝的数组索引将是未定义的。我们可以根据需要处理这种情况，并使用剩余的结果。

这里我拒绝了第一个承诺，所以它没有定义，但是我们可以使用第二个承诺的结果，它在索引1处。

const manyPromises = Promise.all([func1()， func2()])。然后(result => { console.log(结果[0]);/ /定义 console.log(结果[1]);/ / func2 })；函数func1() { return new Promise((res, rej) => rej('func1'))。Catch (err => { Console.log('错误处理'，err); })；｝函数func2() { return new Promise((res, rej) => setTimeout(() => res('func2')， 500)); ｝

2018-09-03 14:47:55

您需要知道如何识别结果中的错误。如果您没有标准的预期错误，我建议您对catch块中的每个错误运行转换，使其在结果中可识别。

try {
  let resArray = await Promise.all(
    state.routes.map(route => route.handler.promiseHandler().catch(e => e))
  );

  // in catch(e => e) you can transform your error to a type or object
  // that makes it easier for you to identify whats an error in resArray
  // e.g. if you expect your err objects to have e.type, you can filter
  // all errors in the array eg
  // let errResponse = resArray.filter(d => d && d.type === '<expected type>')
  // let notNullResponse = resArray.filter(d => d)

  } catch (err) {
    // code related errors
  }

2019-11-19 00:54:13

正如@jib所说，

的承诺。要么全部，要么一无所有。

不过，您可以控制某些“允许”失败的承诺，我们希望继续进行。

为例。

  Promise.all([
    doMustAsyncTask1,
    doMustAsyncTask2,
    doOptionalAsyncTask
    .catch(err => {
      if( /* err non-critical */) {
        return
      }
      // if critical then fail
      throw err
    })
  ])
  .then(([ mustRes1, mustRes2, optionalRes ]) => {
    // proceed to work with results
  })

2019-02-14 21:08:35

Promise.allSettled

而不是承诺。都使用Promise。等待所有承诺的解决，不管结果如何

let p1 = new Promise(resolve => resolve("result1")); let p2 = new Promise((resolve,reject) => reject('some trouble ')); let p3 = new Promise(resolve => resolve("result3")); //返回每个promise状态和值的信息 Promise.allSettled ((p1, p2, p3))。然后(结果= > console.log(结果));

Polyfill

if (! promise . allsettle) { const rejectHandler = reason => ({status: 'rejected'， reason}); const resolveHandler = value =>({状态:'已完成'，value}); 的承诺。allsettle =函数(承诺){ const convertedPromises = promises .map(p =>承诺。resolve(p)。然后(resolveHandler rejectHandler)); 返回Promise.all (convertedPromises); }; ｝

2020-06-29 09:00:24

我已经找到了一种方法(变通)来做到这一点，而不使它同步。

正如《承诺》之前提到的。一切皆为虚无。

所以…使用附带的承诺来捕获并强制解决。


      let safePromises = originalPrmises.map((imageObject) => {
            return new Promise((resolve) => {
              // Do something error friendly
              promise.then(_res => resolve(res)).catch(_err => resolve(err))
            })
        })
    })

    // safe
    return Promise.all(safePromises)

2019-11-17 18:37:56

处理Promise.all中的错误

推荐文章

最新文章

标签