假设我有一组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。否则:
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.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
*/
你可以通过同步执行器nsynjs按顺序执行你的逻辑。它将在每个承诺上暂停，等待解析/拒绝，并将解析的结果分配给data属性，或者抛出异常(用于处理您将需要try/catch块)。这里有一个例子:
function synchronousCode() { function myFetch(url) { try { return window.fetch(url).data; } catch (e) { return {status: 'failed:'+e}; }; }; var arr=[ myFetch("https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js"), myFetch("https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/NONEXISTANT.js"), myFetch("https://ajax.NONEXISTANT123.com/ajax/libs/jquery/2.0.0/NONEXISTANT.js") ]; console.log('array is ready:',arr[0].status,arr[1].status,arr[2].status); }; nsynjs.run(synchronousCode,{},function(){ console.log('done'); }); <script src="https://rawgit.com/amaksr/nsynjs/master/nsynjs.js"></script>
我不知道你在使用哪个承诺库，但大多数都有类似allsettle的东西。
编辑:好的，因为你想使用普通的ES6而没有外部库，没有这样的方法。
换句话说:您必须手动遍历承诺，并在所有承诺解决后立即解决新的组合承诺。
我也遇到过同样的问题，我用下面的方法解决了这个问题:
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。
我最近建立了一个库，可以满足你的需要。它并行执行承诺，如果一个承诺失败，进程继续，最后它返回一个包含所有结果的数组，包括错误。
https://www.npmjs.com/package/promise-ax
我希望这对某些人有帮助。
const { createPromise } = require('promise-ax');
const promiseAx = createPromise();
const promise1 = Promise.resolve(4);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, new Error("error")));
const promise3 = Promise.reject("error");
const promise4 = promiseAx.resolve(8);
const promise5 = promiseAx.reject("errorAx");
const asyncOperation = (time) => {
return new Promise((resolve, reject) => {
if (time < 0) {
reject("reject");
}
setTimeout(() => {
resolve(time);
}, time);
});
};
const promisesToMake = [promise1, promise2, promise3, promise4, promise5, asyncOperation(100)];
promiseAx.allSettled(promisesToMake).then((results) => results.forEach((result) => console.log(result)));
// Salida esperada:
// 4
// Error: error
// error
// 8
// errorAx
// 100
