对于那些使用ES8的人来说，你可以使用异步函数做如下的事情:

var arrayOfPromises = state.routes.map(async function(route){
  try {
    return await route.handler.promiseHandler();
  } catch(e) {
    // Do something to handle the error.
    // Errored promises will return whatever you return here (undefined if you don't return anything).
  }
});

var resolvedPromises = await Promise.all(arrayOfPromises);

这就是Promise。一切都是为了工作而设计。如果只有一个promise reject()，整个方法立即失败。

有一些用例可能需要Promise。都是为了让承诺落空。要做到这一点，只需不要在承诺中使用任何reject()语句。然而，为了确保你的应用程序/脚本不会在任何一个底层承诺从未得到响应的情况下冻结，你需要给它设置一个超时。

function getThing(uid,branch){
    return new Promise(function (resolve, reject) {
        xhr.get().then(function(res) {
            if (res) {
                resolve(res);
            } 
            else {
                resolve(null);
            }
            setTimeout(function(){reject('timeout')},10000)
        }).catch(function(error) {
            resolve(null);
        });
    });
}

ES2020为Promise类型引入了新的方法:Promise. allsettle()。

的承诺。当所有输入承诺都已解决时，allsettle会给你一个信号，这意味着它们要么被满足，要么被拒绝。这在不关心承诺状态的情况下很有用，您只想知道工作何时完成，而不管它是否成功。

异步函数(){ Const promises = [ Fetch ('/api.stackexchange.com/2.2')， //成功 Fetch ('/this-will-fail') //失败 ]; const result = await promise . allsettle (promises); console.log(结果。Map (promise => promise.status)); // [' completed '， 'rejected'] ｝

详见v8博客文章。

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

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

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

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

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
const promises = [promise1, promise2];
let sum = 0;
let promiseErrorArr = [];

Promise.allSettled(promises)
.then((results) => {
          results.forEach(result => {
            if (result.status === "rejected") {
              sum += 1;
              promiseErrorArr.push(result)
            }
          })
    return ( (sum>0) ? promiseFailed() : promisePassed())
})

function promiseFailed(){
  console.log('one or all failed!')
  console.log(promiseErrorArr)
}

function promisePassed(){
  console.log('all passed!')
}

// expected output:
// "one or all failed!"
// Array [Object { status: "rejected", reason: "foo" }]

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

一些图书馆有一种叫做承诺的东西。当，我理解它会等待数组中的所有承诺解决或拒绝，但我不熟悉它，它不在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
});