假设我有一组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
假设我想要等到所有这些都完成，不管是否有一个失败了。可能有一个资源的网络错误，我可以没有，但如果我能得到，我想在继续之前。我想优雅地处理网络故障。
因为承诺。所有这些都没有留下任何空间，在不使用承诺库的情况下，处理这个问题的推荐模式是什么?
当前回答
与其拒绝，不如用一个对象来解决。 当你实现承诺时，你可以这样做
Const promise = arg => { 返回新的承诺((resolve, reject) => { setTimeout(() => { 尝试{ If (arg != 2) 返回解析({success: true, data: arg}); 其他的 抛出新的错误(arg) }捕捉(e) { 返回解析({success: false, error: e, data: arg}) ｝ }, 1000); }) ｝ Promise.all([1、2、3、4、5)。Map (e => promise(e)))。然后(d => console.log(d))
其他回答
这应该与Q的做法一致:
if(!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.all()的原始实现，并尝试模仿该逻辑-除了如果一个Promise失败不停止执行之外。
public promiseExecuteAll(promisesList: Promise<any>[] = []): Promise<{ data: any, isSuccess: boolean }[]>
{
let promise: Promise<{ data: any, isSuccess: boolean }[]>;
if (promisesList.length)
{
const result: { data: any, isSuccess: boolean }[] = [];
let count: number = 0;
promise = new Promise<{ data: any, isSuccess: boolean }[]>((resolve, reject) =>
{
promisesList.forEach((currentPromise: Promise<any>, index: number) =>
{
currentPromise.then(
(data) => // Success
{
result[index] = { data, isSuccess: true };
if (promisesList.length <= ++count) { resolve(result); }
},
(data) => // Error
{
result[index] = { data, isSuccess: false };
if (promisesList.length <= ++count) { resolve(result); }
});
});
});
}
else
{
promise = Promise.resolve([]);
}
return promise;
}
解释: -循环输入的许诺列表并执行每个许诺。 —无论Promise是被解决还是被拒绝:将Promise的结果按照索引保存为结果数组。还保存解析/拒绝状态(isSuccess)。 -一旦所有承诺完成，将一个承诺与所有其他承诺的结果一起返回。
使用示例:
const p1 = Promise.resolve("OK");
const p2 = Promise.reject(new Error(":-("));
const p3 = Promise.resolve(1000);
promiseExecuteAll([p1, p2, p3]).then((data) => {
data.forEach(value => console.log(`${ value.isSuccess ? 'Resolve' : 'Reject' } >> ${ value.data }`));
});
/* Output:
Resolve >> OK
Reject >> :-(
Resolve >> 1000
*/
我只是想要一个完全复制ES2020行为的填充，因为我被锁定在比12.9更早的节点版本(当Promise。allsettle出现了)，不幸的是。所以不管怎样，这是我的版本:
const settle = (promise) => (promise instanceof Promise) ?
promise.then(val => ({ value: val, status: "fulfilled" }),
err => ({ reason: err, status: "rejected" })) :
{ value: promise, status: 'fulfilled' };
const allSettled = async (parr) => Promise.all(parr.map(settle));
它处理承诺值和非承诺值的混合数组，就像ES版本一样。它返回与原生版本相同的{status, value/reason}对象数组。
我也遇到过同样的问题，我用下面的方法解决了这个问题:
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，当它在超时后被解决时，它会返回另一个Promise。
我不知道你在使用哪个承诺库，但大多数都有类似allsettle的东西。
编辑:好的，因为你想使用普通的ES6而没有外部库，没有这样的方法。
换句话说:您必须手动遍历承诺，并在所有承诺解决后立即解决新的组合承诺。
