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

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

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

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

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

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

你总是可以用一种方式来包装你的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'};
    }

}

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

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

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