假设我有一组正在进行网络请求的Promise，其中一个将会失败：
// 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没有提供这样的方法，那么在不使用任何 promises 库的情况下，推荐使用什么模式来处理此问题？
更新，您可能想要使用内置的本地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:")等）。
.map(p => p.catch(e => e)) 部分将所有拒绝转换为已解决的值，所以 Promise.all 仍然会等待所有东西完成，无论个别函数是解决还是拒绝，无论它们需要多长时间。试一下。 - jib.catch(e => console.log(e));从未被调用。 - fregantee 并将其作为常规值（成功值）返回。与 p.catch(function(e) { return e; }) 相同，只是更短。return 是隐式的。 - jibp.catch(e => e) 仍然会拒绝 Promise，因为它返回一个 Error，尽管实际上它是解决了这个 Error。 - AndyBenjamin的回答提供了一个很好的抽象方法来解决这个问题，但我希望有一个不太抽象的解决方案。明确的解决方法是在内部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));
进一步地，你可以编写一个通用异常捕获处理程序，它看起来像这样：
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!' ]
为了遵循DRY原则，你需要采用Benjamin的回答：
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!' ]
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!' ]
const apiMethod = () => fetch()
.catch(error => {
console.log(error.message);
throw error;
});
这样，应用程序的其余部分如果希望可以忽略其错误，并在需要时将其视为未定义值。
我希望我的高级函数能够安全地失败，而不必担心为什么它的依赖项失败，当我需要做出权衡时，我更喜欢KISS而不是DRY -- 这就是我选择不使用reflect的最终原因。
Promise非常简单和惯用。虽然你的reflect提高了代码重用性，但它也建立了另一个抽象层次。由于迄今为止，与您相比，Nathan的答案只收到了一小部分赞同票，我想知道这是否表明他的解决方案存在问题，而我尚未意识到。 - user6445533new Promise((res, rej) => res(new Error('合法错误'))) 与 new Promise(((res, rej) => rej(new Error('非法错误'))) 是无法区分的吗？或者更进一步地说，您将无法通过 x.status 进行过滤吗？我会在我的答案中添加这一点，以便区别更加明显。 - Nathan HagenPromise.all()变体中使用的具体用例绑定在一起，这也使得承诺的消费者必须知道特定的Promise不会拒绝，但会吞噬其错误。事实上，reflect()方法可以通过将其称为PromiseEvery(promises).then(...)来使其更少抽象且更明确。与Benjamin的答案相比，上面的答案的复杂性应该能说明这个解决方案的问题。 - Neil现在有一个已经完成的提案，可以在纯JavaScript中原生实现这个功能：Promise.allSettled。它已经到达了第四阶段，在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"
}
]
对于旧版浏览器，可以使用符合规范的兼容性补丁程序这里。
我真的很喜欢Benjamin的回答，以及他如何将所有Promise基本上转化为总是解决但有时会以错误作为结果的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);
});
}
Promise构造函数（并避免使用那个var resolve的东西）？ - BergiPromise 构造函数具有无与伦比的优势，超越了 deferreds，它可以捕获异常（例如当 promises 不是我们所期望的内容时）。 - Bergivar err;
Promise.all([
promiseOne().catch(function(error) { err = error;}),
promiseTwo().catch(function(error) { err = error;})
]).then(function() {
if (err) {
throw err;
}
});
Promise.all会吞掉任何被拒绝的Promise并将错误存储在变量中，因此它将在所有Promise都已解析时返回。然后您可以重新抛出错误或执行其他操作。通过这种方式，我猜您会得到最后一个拒绝而不是第一个。err.push(error) 来聚合错误，以便所有错误都可以被传递上来。 - ps2goat我曾经遇到过同样的问题，并通过以下方式解决了它:
const fetch = (url) => {
return node-fetch(url)
.then(result => result.json())
.catch((e) => {
return new Promise((resolve) => setTimeout(() => resolve(fetch(url)), timeout));
});
};
tasks = [fetch(url1), fetch(url2) ....];
Promise.all(tasks).then(......)
Promise.all将等待每个Promise进入resolved或rejected状态。catch执行”。事实上，我们并没有停止任何东西，我们只是以未决状态返回Promise，当超时后它会返回另一个Promise。Promise.all时，它会立即调用所有的承诺。我正在寻找一种方法来监听所有承诺都已被调用的情况，但不要自己调用它们。谢谢。 - SudoPlzall() 就是这样，它等待所有 Promise 的履行或至少一个 Promise 的拒绝。 - user1016265.all会启动所有内容。 - SudoPlzthen或.all方法）时才会运行，但实际上它们在创建时就已经开始运行了。 - SudoPlzif(!Promise.allSettled) {
Promise.allSettled = function (promises) {
return Promise.all(promises.map(p => Promise.resolve(p).then(v => ({
state: 'fulfilled',
value: v,
}), r => ({
state: 'rejected',
reason: r,
}))));
};
}
不要拒绝，使用一个对象来解决它。 当你实现Promise时，可以这样做：
const promise = arg => {
return new Promise((resolve, reject) => {
setTimeout(() => {
try{
if(arg != 2)
return resolve({success: true, data: arg});
else
throw new Error(arg)
}catch(e){
return resolve({success: false, error: e, data: arg})
}
}, 1000);
})
}
Promise.all([1,2,3,4,5].map(e => promise(e))).then(d => console.log(d))e&v这样的短对象属性也没有帮助，但当然可以更改。Error。理想情况下，您总是会抛出此类的实例/后代。优点是您可以执行instanceof Error，并且您知道某些东西是错误的。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两个对象。最初的回答：您可以争论说！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();
allSettled方法，可以满足你的需求，而无需自己编写代码实现。 - DanPromise.all会在 任何一个 promise 被拒绝时立即拒绝，因此您提出的习语不能保证所有 promise 都已解决。 - Jörg W Mittag