假设我有一组Promise发出网络请求的s，其中一个会失败：
// http://does-not-exist will throw a TypeError
var arr = [ fetch('index.html'), fetch('http://does-not-exist') ]
Promise.all(arr)
.then(res => console.log('success', res))
.catch(err => console.log('error', err)) // This is executed
假设我想等到所有这些都完成，无论是否失败。对于我可以没有的资源，可能存在网络错误，但如果我能得到，我需要在继续之前。我想优雅地处理网络故障。
既然Promise.all没有为此留出任何空间，那么在不使用Promise库的情况下处理这个问题的推荐模式是什么？
更新，您可能想使用内置的 native Promise.allSettled：
Promise.allSettled([promise]).then(([result]) => {
//reach here regardless
// {status: "fulfilled", value: 33}
});
作为一个有趣的事实，下面的这个答案是将该方法添加到语言中的现有技术:]
当然，你只需要一个reflect：
const reflect = p => p.then(v => ({v, status: "fulfilled" }),
e => ({e, status: "rejected" }));
reflect(promise).then((v => {
console.log(v.status);
});
或者使用 ES5：
function reflect(promise){
return promise.then(function(v){ return {v:v, status: "fulfilled" }},
function(e){ return {e:e, status: "rejected" }});
}
reflect(promise).then(function(v){
console.log(v.status);
});
或者在你的例子中：
var arr = [ fetch('index.html'), fetch('http://does-not-exist') ]
Promise.all(arr.map(reflect)).then(function(results){
var success = results.filter(x => x.status === "fulfilled");
});
类似的答案，但对于 ES6 来说可能更惯用：
const a = Promise.resolve(1);
const b = Promise.reject(new Error(2));
const c = Promise.resolve(3);
Promise.all([a, b, c].map(p => p.catch(e => e)))
.then(results => console.log(results)) // 1,Error: 2,3
.catch(e => console.log(e));
const console = { log: msg => div.innerHTML += msg + "<br>"};<div id="div"></div>根据类型的值（一个或多个）返回时，往往可以区分错误很轻松了（如使用undefined了“不关心”，typeof对于普通的非对象值result.message，result.toString().startsWith("Error:")等等）
本杰明的回答为解决这个问题提供了一个很好的抽象，但我希望有一个不那么抽象的解决方案。解决这个问题的明确方法是简单地调用.catch内部Promise，并从他们的回调中返回错误。
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。缺点是你有更多的代码，你必须记住反映你所有的Promise，使事情保持一致。
我会将我的解决方案描述为明确的和 KISS，但确实不那么健壮。该接口不能保证您确切知道Promise是成功还是失败。
例如你可能有这个：
const a = Promise.resolve(new Error('Not beaking, just bad'));
const b = Promise.reject(new Error('This actually didnt work'));
这不会被 抓住a.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!' ]
就我而言，我不需要知道错误或它是如何失败的——我只关心我是否拥有value。我会让生成Promise的函数担心记录特定的错误。
const apiMethod = () => fetch()
.catch(error => {
console.log(error.message);
throw error;
});
这样，应用程序的其余部分可以根据需要忽略其错误，并根据需要将其视为未定义的值。
我希望我的高级函数能够安全地失败，而不用担心它的依赖项失败的原因的细节，而且当我必须做出权衡时，我也更喜欢 KISS 而不是 DRY——这就是我最终选择不使用reflect.
有一个可以在原生 Javascript 中完成此功能的完整提案Promise.allSettled，它已进入第 4 阶段，在 ES2020 中正式化，并在所有现代环境中实现。它与另一个答案中的reflect功能非常相似。这是提案页面上的一个示例。以前，您必须执行以下操作：
function reflect(promise) {
return promise.then(
(v) => {
return { status: 'fulfilled', value: v };
},
(error) => {
return { status: 'rejected', reason: error };
}
);
}
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.all(promises.map(reflect));
const successfulPromises = results.filter(p => p.status === 'fulfilled');
使用Promise.allSettled代替，以上将等效于：
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.allSettled(promises);
const successfulPromises = results.filter(p => p.status === 'fulfilled');
那些使用现代环境的人将能够在没有任何库的情况下使用这种方法。在这些中，以下代码段应该可以正常运行：
Promise.allSettled([
Promise.resolve('a'),
Promise.reject('b')
])
.then(console.log);输出：
[
{
"status": "fulfilled",
"value": "a"
},
{
"status": "rejected",
"reason": "b"
}
]
对于旧的浏览器，有一个符合规范的填充工具在这里。
我真的很喜欢本杰明的回答，以及他如何基本上把所有的Promise变成总是解决但有时会出错的结果。:)
这是我应您要求的尝试，以防万一您正在寻找替代品。此方法只是将错误视为有效结果，并且编码与Promise.all其他方式类似：
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);
});
}