假设我有一组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]
其他回答
这应该与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,
}))));
};
}
我不知道你在使用哪个承诺库，但大多数都有类似allsettle的东西。
编辑:好的，因为你想使用普通的ES6而没有外部库，没有这样的方法。
换句话说:您必须手动遍历承诺，并在所有承诺解决后立即解决新的组合承诺。
我认为下面提供了一个稍微不同的方法……比较fn_fast_fail()和fn_slow_fail()…尽管后者并没有因此而失败……你可以检查a和b中是否有一个或两个都是Error实例，如果你想让它到达catch块，就抛出这个错误(例如if (b instanceof Error) {throw b;})。参见jsfiddle。
var p1 = new Promise((resolve, reject) => {
setTimeout(() => resolve('p1_delayed_resolvement'), 2000);
});
var p2 = new Promise((resolve, reject) => {
reject(new Error('p2_immediate_rejection'));
});
var fn_fast_fail = async function () {
try {
var [a, b] = await Promise.all([p1, p2]);
console.log(a); // "p1_delayed_resolvement"
console.log(b); // "Error: p2_immediate_rejection"
} catch (err) {
console.log('ERROR:', err);
}
}
var fn_slow_fail = async function () {
try {
var [a, b] = await Promise.all([
p1.catch(error => { return error }),
p2.catch(error => { return error })
]);
console.log(a); // "p1_delayed_resolvement"
console.log(b); // "Error: p2_immediate_rejection"
} catch (err) {
// we don't reach here unless you throw the error from the `try` block
console.log('ERROR:', err);
}
}
fn_fast_fail(); // fails immediately
fn_slow_fail(); // waits for delayed promise to resolve
我也遇到过同样的问题，我用下面的方法解决了这个问题:
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。
Benjamin Gruenbaum的回答当然很好。但我也能看出内森哈根的观点在抽象层面上显得模糊。拥有像e和v这样的短对象属性也没有帮助，但当然这是可以改变的。
在Javascript中有一个标准的Error对象，称为Error。理想情况下，您总是抛出该实例/后代。这样做的好处是您可以使用instanceof Error，并且您知道某些东西是错误的。
利用这个想法，下面是我对这个问题的看法。
基本上捕捉错误，如果错误不是error类型，则将错误包装在error对象中。结果数组将具有已解析的值或可以检查的Error对象。
catch内部的instanceof，是为了防止你使用一些外部库可能会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。
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();
