假设我有一组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 promise1 = //...
const promise2 = //...
const data = await Promise.all([promise1, promise2])
const dataFromPromise1 = data[0]
const dataFromPromise2 = data[1]
其他回答
类似的答案，但更适合ES6:
const a = Promise.resolve(1); const b =承诺。拒绝(新的错误(2)); const c = Promise.resolve(3); 的承诺。[a, b, c]。(p => p.catch(e => e))) .then(results => console.log(results)) // 1，错误:2,3 .catch(e => console.log(e)); const console = {log: msg => div.innerHTML += msg + "<br>"}; < div id = " div " > < / div >
根据返回值的类型，通常可以很容易地区分错误(例如，用undefined表示“don't care”，用typeof表示普通的非对象值，用result。result.toString(). startswith ("Error:")等
我真的很喜欢本杰明的回答，以及他如何把所有的承诺都变成了总是能解决但有时会导致错误的承诺。：） 这是我对你的要求的尝试，以防你正在寻找替代方案。该方法简单地将错误视为有效的结果，其编码类似于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
*/
与其拒绝，不如用一个对象来解决。 当你实现承诺时，你可以这样做
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))
我最近建立了一个库，可以满足你的需要。它并行执行承诺，如果一个承诺失败，进程继续，最后它返回一个包含所有结果的数组，包括错误。
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
