这不是记录错误日志的最佳方法，但是您总是可以为promiseAll设置一个数组，并将结果存储到新变量中。

如果你使用graphQL，你需要后处理响应，无论如何，如果它没有找到正确的引用，它将崩溃应用程序，缩小问题所在

const results = await Promise.all([
  this.props.client.query({
    query: GET_SPECIAL_DATES,
  }),
  this.props.client.query({
    query: GET_SPECIAL_DATE_TYPES,
  }),
  this.props.client.query({
    query: GET_ORDER_DATES,
  }),
]).catch(e=>console.log(e,"error"));
const specialDates = results[0].data.specialDates;
const specialDateTypes = results[1].data.specialDateTypes;
const orderDates = results[2].data.orders;

使用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]

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

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

你考虑过Promise.prototype.finally()吗?

它的设计似乎完全是为了做你想做的事情——一旦所有的承诺都解决了(解决/拒绝)，就执行一个函数，而不管其中一些承诺是否被拒绝。

来自MDN文档:

如果您希望在承诺确定之后进行一些处理或清理，而不管其结果如何，那么finally()方法可能很有用。

finally()方法非常类似于调用.then(onFinally, onFinally)，但是有一些区别:

在内联创建函数时，可以传递一次，而不是被迫声明两次，或者为它创建一个变量。

finally回调将不会接收任何参数，因为没有可靠的方法来确定承诺是否被实现或拒绝。当您不关心被拒绝的原因或实现价值时，这个用例恰好适用，因此不需要提供它。

与Promise.resolve(2).then(() =>{}，() =>{})(将被未定义解析)不同，Promise.resolve(2).finally(() =>{})将被2解析。 类似地，与Promise.reject(3).then(() =>{}，() =>{})(将用undefined实现)不同，Promise.reject(3).finally(() =>{})将被3拒绝。

==后退==

如果你的JavaScript版本不支持Promise.prototype.finally()，你可以使用Jake Archibald的这个变通方法:Map (p => p.catch(() => undefined)));

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博客文章。

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