这不是记录错误日志的最佳方法，但是您总是可以为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;

如果您可以使用q库https://github.com/kriskowal/q 它有q. allsettle()方法可以解决这个问题 您可以根据每个承诺的状态来处理它，可以是完全提交的，也可以是拒绝的 所以

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

existingPromiseChain = existingPromiseChain.then(function(arrayResolved) {
//so here you have all your promises the fulfilled and the rejected ones
// you can check the state of each promise
arrayResolved.forEach(function(item){
   if(item.state === 'fulfilled'){ // 'rejected' for rejected promises
     //do somthing
   } else {
     // do something else
   }
})
// do stuff with my array of resolved promises, eventually ending with a res.send();
});

继续承诺。我写了一个名为executeAllPromises的实用函数。这个实用函数返回一个带有结果和错误的对象。

其思想是，传递给executeAllPromises的所有Promise都将被包装成一个新的Promise，该Promise将始终解决。新的Promise解析了一个有2个点的数组。第一个点保存解析值(如果有的话)，第二个点保留错误(如果包装的Promise拒绝)。

作为最后一步，executeAllPromises会累积包装的promise的所有值，并返回带有结果数组和错误数组的最终对象。

代码如下:

function executeAllPromises(promises) { // Wrap all Promises in a Promise that will always "resolve" var resolvingPromises = promises.map(function(promise) { return new Promise(function(resolve) { var payload = new Array(2); promise.then(function(result) { payload[0] = result; }) .catch(function(error) { payload[1] = error; }) .then(function() { /* * The wrapped Promise returns an array: * The first position in the array holds the result (if any) * The second position in the array holds the error (if any) */ resolve(payload); }); }); }); var errors = []; var results = []; // Execute all wrapped Promises return Promise.all(resolvingPromises) .then(function(items) { items.forEach(function(payload) { if (payload[1]) { errors.push(payload[1]); } else { results.push(payload[0]); } }); return { errors: errors, results: results }; }); } var myPromises = [ Promise.resolve(1), Promise.resolve(2), Promise.reject(new Error('3')), Promise.resolve(4), Promise.reject(new Error('5')) ]; executeAllPromises(myPromises).then(function(items) { // Result var errors = items.errors.map(function(error) { return error.message }).join(','); var results = items.results.join(','); console.log(`Executed all ${myPromises.length} Promises:`); console.log(`— ${items.results.length} Promises were successful: ${results}`); console.log(`— ${items.errors.length} Promises failed: ${errors}`); });

这就是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);
        });
    });
}

正如@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
  })

你考虑过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)));