假设我有一个Promise.all()处理两个诺言的。如果一个承诺产生了错误,而另一个承诺解决了,我希望能够根据Promise.all()解决后的情况来处理错误。
Promise.all()
我认为ES6 Promises缺少解决方法,这是有充分理由的。但是我不禁认为该.settle()方法会使我更容易解决此问题。
.settle()
我是用错误的方式解决问题还是用解决方法扩展ES6 Promises在这里正确的事情?
我正在考虑使用的示例.settle():
Promise.all([Action1,Action2]) .settle(function(arrayOfSettledValues) //if 1 failed but not 2, handle //if 2 failed but not 1, handle //etc.... )
您不能直接使用Promise.all()生成.settle()类型行为来获取所有结果,无论是否由于Promise.all()“快速失败”而拒绝,并在第一个promise拒绝后立即返回,并且仅返回该拒绝原因,而没有其他结果。
因此,需要一些不同的东西。通常,解决该问题的最简单方法是,仅在.then()创建诺言数组的任何操作中添加处理程序,以便它捕获所有否决项并将它们转变为具有可测试的特定值的诺言。但是,这种解决方案的类型取决于实现,因为它完全取决于您要返回的值的类型,因此这不是完全通用的。
.then()
如果您想要一个通用的解决方案,那么类似的东西.settle()将非常有用。
您不能使用以下结构:
Promise.all([...]).settle(...).then(...);
注意(于2019年添加):似乎Promise标准工作已被Promise.allSettled()选为“类似定居点”行为的标准实现。您可以在此答案的末尾看到更多信息。
Promise.allSettled()
因为Promise.all()当您通过第一个诺言时会拒绝,所以它会拒绝,并且仅返回该拒绝。该.settle()逻辑工作方式:
Promise.settle([...]).then(...);
而且,如果您有兴趣,这里是一个相当简单的实现Promise.settle():
Promise.settle()
// ES6 version of settle Promise.settle = function(promises) { function PromiseInspection(fulfilled, val) { return { isFulfilled: function() { return fulfilled; }, isRejected: function() { return !fulfilled; }, isPending: function() { // PromiseInspection objects created here are never pending return false; }, value: function() { if (!fulfilled) { throw new Error("Can't call .value() on a promise that is not fulfilled"); } return val; }, reason: function() { if (fulfilled) { throw new Error("Can't call .reason() on a promise that is fulfilled"); } return val; } }; } return Promise.all(promises.map(function(p) { // make sure any values are wrapped in a promise return Promise.resolve(p).then(function(val) { return new PromiseInspection(true, val); }, function(err) { return new PromiseInspection(false, err); }); })); }
在此实现中,Promise.settle()将始终解析(从不拒绝),并使用PromiseInspection对象数组进行解析,该对象数组允许您测试每个单独的结果,以查看它是已解决还是被拒绝以及每个值或原因是什么。它通过.then()为传入的每个promise 附加一个处理程序来处理该promise的拒绝或拒绝,并将结果放入PromiseInspection对象,该对象随后成为promise的resolved值。
PromiseInspection
然后,您将使用这种实现方式;
Promise.settle([...]).then(function(results) { results.forEach(function(pi, index) { if (pi.isFulfilled()) { console.log("p[" + index + "] is fulfilled with value = ", pi.value()); } else { console.log("p[" + index + "] is rejected with reasons = ", pi.reason()); } }); });
仅供参考,我写了另一个.settle我自己的版本,.settleVal()当您不需要实际的拒绝原因时,您只想知道给定的阵列插槽是否被拒绝,我经常发现它更易于使用。在此版本中,您传入一个默认值,该默认值应替代任何拒绝的承诺。然后,您只获得返回值的平面数组,并拒绝所有设置为默认值的值。例如,你经常可以挑选rejectVal的null或0或""或{}它使结果更容易对付。功能如下:
.settle
.settleVal()
rejectVal
null
0
""
{}
// settle all promises. For rejected promises, return a specific rejectVal that is // distinguishable from your successful return values (often null or 0 or "" or {}) Promise.settleVal = function(rejectVal, promises) { return Promise.all(promises.map(function(p) { // make sure any values or foreign promises are wrapped in a promise return Promise.resolve(p).then(null, function(err) { // instead of rejection, just return the rejectVal (often null or 0 or "" or {}) return rejectVal; }); })); };
然后,您可以像这样使用它:
Promise.settleVal(null, [...]).then(function(results) { results.forEach(function(pi, index) { if (pi !== null) { console.log("p[" + index + "] is fulfilled with value = ", pi); } }); });
这并不是一个完整的替代品,.settle()因为有时您可能想知道拒绝它的实际原因,或者您不容易将拒绝的值与未拒绝的值区分开。但是,我发现有90%以上的时间使用起来更简单。
这是我最新的简化方法.settle(),它instanceof Error在返回数组中保留了一个区分分辨值和拒绝错误的方法:
instanceof Error
// settle all promises. For rejected promises, leave an Error object in the returned array Promise.settleVal = function(promises) { return Promise.all(promises.map(function(p) { // make sure any values or foreign promises are wrapped in a promise return Promise.resolve(p).catch(function(err) { let returnVal = err; // instead of rejection, leave the Error object in the array as the resolved value // make sure the err is wrapped in an Error object if not already an Error object if (!(err instanceof Error)) { returnVal = new Error(); returnVal.data = err; } return returnVal; }); })); };
Promise.settleVal(null, [...]).then(function(results) { results.forEach(function(item, index) { if (item instanceof Error) { console.log("p[" + index + "] rejected with error = ", item); } else { console.log("p[" + index + "] fulfilled with value = ", item); } }); });
.settle()只要instanceof Error它永远不是您的诺言的可解决的价值(实际上是不应该的),这可以完全替代所有情况。
if (!Promise.allSettled) { Promise.allSettled = function(promises) { let wrappedPromises = Array.from(promises).map(p => this.resolve(p).then( val => ({ state: 'fulfilled', value: val }), err => ({ state: 'rejected', reason: err }) ) ); return this.all(wrappedPromises); } }
用法如下:
let promises = [...]; // some array of promises, some of which may reject Promise.allSettled(promises).then(results => { for (let r of results) { if (r.state === 'fulfilled') { console.log('fulfilled:', r.val); } else { console.log('rejected:', r.err); } } });
请注意,Promise.allSettled()尽管后续.then()处理程序可能抛出或返回被拒绝的诺言以使整个链被拒绝,但它本身始终会解决,永远不会拒绝。
截至2019年6月,此功能尚未在当前的桌面Chrome浏览器中使用,但计划在即将发布的版本中使用(例如,在2019年晚些时候)。