本杰明的回答为解决这个问题提供了一个很好的抽象，但我希望有一个不那么抽象的解决方案。解决这个问题的显式方法是简单地对内部promise调用.catch，并从它们的回调返回错误。

let a = new Promise((res, rej) => res('Resolved!')),
    b = new Promise((res, rej) => rej('Rejected!')),
    c = a.catch(e => { console.log('"a" failed.'); return e; }),
    d = b.catch(e => { console.log('"b" failed.'); return e; });

Promise.all([c, d])
  .then(result => console.log('Then', result)) // Then ["Resolved!", "Rejected!"]
  .catch(err => console.log('Catch', err));

Promise.all([a.catch(e => e), b.catch(e => e)])
  .then(result => console.log('Then', result)) // Then ["Resolved!", "Rejected!"]
  .catch(err => console.log('Catch', err));

---

更进一步，你可以写一个通用的catch处理程序，看起来像这样:

const catchHandler = error => ({ payload: error, resolved: false });

然后你就可以

> Promise.all([a, b].map(promise => promise.catch(catchHandler))
    .then(results => console.log(results))
    .catch(() => console.log('Promise.all failed'))
< [ 'Resolved!',  { payload: Promise, resolved: false } ]

这样做的问题是，被捕获的值将与未被捕获的值有不同的接口，所以要清理这个，你可以这样做:

const successHandler = result => ({ payload: result, resolved: true });

现在你可以这样做:

> Promise.all([a, b].map(result => result.then(successHandler).catch(catchHandler))
    .then(results => console.log(results.filter(result => result.resolved))
    .catch(() => console.log('Promise.all failed'))
< [ 'Resolved!' ]

为了保持干燥，你看到了本杰明的答案:

const reflect = promise => promise
  .then(successHandler)
  .catch(catchHander)

现在是什么样子

> Promise.all([a, b].map(result => result.then(successHandler).catch(catchHandler))
    .then(results => console.log(results.filter(result => result.resolved))
    .catch(() => console.log('Promise.all failed'))
< [ 'Resolved!' ]

---

第二种解决方案的优点是它是抽象的和DRY的。缺点是你有更多的代码，你必须记住反映你所有的承诺，使事情一致。

我将把我的解决方案描述为explicit和KISS，但确实不那么健壮。接口不能保证您确切地知道承诺是成功了还是失败了。

例如，你可以这样写:

const a = Promise.resolve(new Error('Not beaking, just bad'));
const b = Promise.reject(new Error('This actually didnt work'));

这个不会被。catch抓到，所以

> Promise.all([a, b].map(promise => promise.catch(e => e))
    .then(results => console.log(results))
< [ Error, Error ]

没有办法判断哪个是致命的，哪个不是。如果这很重要，那么您将希望强制和接口跟踪它是否成功(这是reflect所做的)。

如果你只是想优雅地处理错误，那么你可以把错误视为未定义的值:

> Promise.all([a.catch(() => undefined), b.catch(() => undefined)])
    .then((results) => console.log('Known values: ', results.filter(x => typeof x !== 'undefined')))
< [ 'Resolved!' ]

在我的例子中，我不需要知道错误或它是如何失败的——我只关心是否有值。我将让生成承诺的函数负责记录特定的错误。

const apiMethod = () => fetch()
  .catch(error => {
    console.log(error.message);
    throw error;
  });

这样，应用程序的其余部分就可以忽略它的错误，并将其视为一个未定义的值。

我希望我的高级函数安全失败，而不担心它的依赖项失败的细节，当我必须做出权衡时，我也更喜欢KISS而不是DRY——这就是我最终选择不使用reflect的原因。

我不知道你在使用哪个承诺库，但大多数都有类似allsettle的东西。

编辑:好的，因为你想使用普通的ES6而没有外部库，没有这样的方法。

换句话说:您必须手动遍历承诺，并在所有承诺解决后立即解决新的组合承诺。

这是我的custom settdpromiseall ()

const settledPromiseAll = function(promisesArray) {
  var savedError;

  const saveFirstError = function(error) {
    if (!savedError) savedError = error;
  };
  const handleErrors = function(value) {
    return Promise.resolve(value).catch(saveFirstError);
  };
  const allSettled = Promise.all(promisesArray.map(handleErrors));

  return allSettled.then(function(resolvedPromises) {
    if (savedError) throw savedError;
    return resolvedPromises;
  });
};

与Promise.all相比

如果所有的承诺都得到了解决，那么它的性能与标准承诺完全相同。 如果多个promise中有一个被拒绝，它返回第一个被拒绝的promise，与标准的promise大致相同，但不同的是，它等待所有的promise都被解决/拒绝。

为了勇敢，我们可以改变。

(function() {
  var stdAll = Promise.all;

  Promise.all = function(values, wait) {
    if(!wait)
      return stdAll.call(Promise, values);

    return settledPromiseAll(values);
  }
})();

小心。一般来说，我们从不改变内置程序，因为这可能会破坏其他不相关的JS库，或者与未来对JS标准的更改发生冲突。

我的承诺是向后兼容的承诺。并扩展其功能。

开发标准的人——为什么不将其包含到新的Promise标准中呢?

Benjamin Gruenbaum的回答当然很好。但我也能看出内森哈根的观点在抽象层面上显得模糊。拥有像e和v这样的短对象属性也没有帮助，但当然这是可以改变的。

在Javascript中有一个标准的Error对象，称为Error。理想情况下，您总是抛出该实例/后代。这样做的好处是您可以使用instanceof Error，并且您知道某些东西是错误的。

利用这个想法，下面是我对这个问题的看法。

基本上捕捉错误，如果错误不是error类型，则将错误包装在error对象中。结果数组将具有已解析的值或可以检查的Error对象。

catch内部的instanceof，是为了防止你使用一些外部库可能会reject("error")，而不是reject(new error ("error"))。

当然，如果您解决了一个错误，您也可以有承诺，但在这种情况下，无论如何都应该将其视为错误，就像最后一个示例所示的那样。

这样做的另一个好处是，数组析构保持简单。

const [value1, value2] = PromiseAllCatch(promises);
if (!(value1 instanceof Error)) console.log(value1);

而不是

const [{v: value1, e: error1}, {v: value2, e: error2}] = Promise.all(reflect..
if (!error1) { console.log(value1); }

你可能会说!error1检查比instanceof简单，但你也必须销毁v和e。

function PromiseAllCatch(promises) { return Promise.all(promises.map(async m => { try { return await m; } catch(e) { if (e instanceof Error) return e; return new Error(e); } })); } async function test() { const ret = await PromiseAllCatch([ (async () => "this is fine")(), (async () => {throw new Error("oops")})(), (async () => "this is ok")(), (async () => {throw "Still an error";})(), (async () => new Error("resolved Error"))(), ]); console.log(ret); console.log(ret.map(r => r instanceof Error ? "error" : "ok" ).join(" : ")); } test();

的承诺。所有这些都使用现代异步/等待方法

const promise1 = //...
const promise2 = //...

const data = await Promise.all([promise1, promise2])

const dataFromPromise1 = data[0]
const dataFromPromise2 = data[1]

我真的很喜欢本杰明的回答，以及他如何把所有的承诺都变成了总是能解决但有时会导致错误的承诺。：） 这是我对你的要求的尝试，以防你正在寻找替代方案。该方法简单地将错误视为有效的结果，其编码类似于Promise。否则:

Promise.settle = function(promises) {
  var results = [];
  var done = promises.length;

  return new Promise(function(resolve) {
    function tryResolve(i, v) {
      results[i] = v;
      done = done - 1;
      if (done == 0)
        resolve(results);
    }

    for (var i=0; i<promises.length; i++)
      promises[i].then(tryResolve.bind(null, i), tryResolve.bind(null, i));
    if (done == 0)
      resolve(results);
  });
}