使用Async await -

这里一个异步函数func1返回一个解析值，func2抛出一个错误并返回null，在这种情况下，我们可以按照自己的想法处理它并相应地返回。

const callingFunction  = async () => {
    const manyPromises = await Promise.all([func1(), func2()]);
    console.log(manyPromises);
}


const func1 = async () => {
    return 'func1'
}

const func2 = async () => {
    try {
        let x;
        if (!x) throw "x value not present"
    } catch(err) {
       return null
    }
}

callingFunction();

输出是- ['func1'， null]

在allsettle的帮助下，我们现在可以读取的状态 每个承诺都是，并单独处理每个错误，而不会丢失任何关键信息

const promises = [
    fetch('/api/first'), // first
    fetch('/api/second') // second
];

最简单的方法是处理错误

const [firstResult, secondResult] = await Promise.allSettled(promises)


 // Process first
 if (firstResult.status === 'rejected') {
   const err = firstResult.reason
   // Here you can handle error
 } else {
   const first = firstResult.value
 }

  // Process second
 if (secondResult.status === 'rejected') {
   const err = secondResult.reason
   // Here you can handle error
 } else {
   const second = secondResult.value
 }

处理错误的好方法

const results = await Promise.allSettled(promises);
const [first, second] = handleResults(results)


function handleResults(results) {
  const errors = results.filter(result => result.status === 'rejected').map(result => result.reason)

  if (errors.length) {
    // Aggregate all errors into one
    throw new AggregateError(errors)
  }

  return results.map(result => result.value)
}

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); }; ｝

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

这里我拒绝了第一个承诺，所以它没有定义，但是我们可以使用第二个承诺的结果，它在索引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)); ｝

不幸的是，我没有足够的声誉来评论(或者做任何事情，真的)，所以我把这篇文章作为对Eric的回答的回应。

executor函数也可以是异步函数。然而，这通常是一个错误，原因如下: 如果异步执行器函数抛出错误，错误将被丢失，不会导致新构造的Promise被拒绝。这可能会使调试和处理某些错误变得困难。 如果Promise执行函数使用await，这通常表明实际上不需要使用新的Promise构造函数，或者可以缩小新的Promise构造函数的作用域。

由此解释了为什么promise不应该使用异步执行器函数

相反，您应该选择promise . allsettle()，就像Asaf在这里建议的那样。

的承诺。要么全部，要么一无所有。一旦数组中的所有承诺都被解决，它就会被解决，或者一旦其中一个承诺被拒绝，它就会被拒绝。换句话说，它要么使用所有已解析值的数组进行解析，要么使用单个错误进行拒绝。

一些图书馆有一种叫做承诺的东西。当，我理解它会等待数组中的所有承诺解决或拒绝，但我不熟悉它，它不在ES6中。

你的代码

我同意这里其他人的看法，您的修复应该有效。它应该使用一个包含成功值和错误对象的混合数组进行解析。在成功路径中传递错误对象是不寻常的，但假设您的代码期望它们，我认为这没有问题。

我能想到为什么它会“不解决”的唯一原因是它在代码中失败了，你没有向我们展示，而你没有看到任何关于此的错误消息的原因是因为这个承诺链没有以最终捕获终止(就你展示给我们的而言)。

我冒昧地从您的示例中提出了“现有链”，并用catch终止了该链。这可能不适合你，但对于阅读这篇文章的人来说，总是返回或终止链是很重要的，否则潜在的错误，甚至是编码错误，将被隐藏(这就是我怀疑在这里发生的事情):

Promise.all(state.routes.map(function(route) {
  return route.handler.promiseHandler().catch(function(err) {
    return err;
  });
}))
.then(function(arrayOfValuesOrErrors) {
  // handling of my array containing values and/or errors. 
})
.catch(function(err) {
  console.log(err.message); // some coding error in handling happened
});