你总是可以用一种方式来包装你的promise返回函数，让它们捕获失败并返回一个一致的值(例如error.message)，这样异常就不会一直滚到promise。所有功能和禁用它。

async function resetCache(ip) {

    try {

        const response = await axios.get(`http://${ip}/resetcache`);
        return response;

    }catch (e) {

        return {status: 'failure', reason: 'e.message'};
    }

}

如果您可以使用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();
});

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

或者，如果你有这样的情况，当有一个失败时，你并不特别关心已解决的承诺的值，但你仍然希望它们运行，你可以这样做，当它们都成功时，你会正常地解决承诺，当它们中的任何一个失败时，你会拒绝失败的承诺:

function promiseNoReallyAll (promises) {
  return new Promise(
    async (resolve, reject) => {
      const failedPromises = []

      const successfulPromises = await Promise.all(
        promises.map(
          promise => promise.catch(error => {
            failedPromises.push(error)
          })
        )
      )

      if (failedPromises.length) {
        reject(failedPromises)
      } else {
        resolve(successfulPromises)
      }
    }
  )
}

的承诺。用过滤器解决

const promises = [
  fetch('/api-call-1'),
  fetch('/api-call-2'),
  fetch('/api-call-3'),
];
// Imagine some of these requests fail, and some succeed.

const resultFilter = (result, error) => result.filter(i => i.status === (!error ? 'fulfilled' : 'rejected')).map(i => (!error ? i.value : i.reason));

const result = await Promise.allSettled(promises);

const fulfilled = resultFilter(result); // all fulfilled results
const rejected = resultFilter(result, true); // all rejected results

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" }]