如何避免Promise.all的承诺构造函数反模式 [英] How do you avoid the promise constructor antipattern with Promise.all

问题描述

如果您在使用多个承诺时避免承诺构造函数反模式，而 Promise.all ？

有以下代码：

  getFoo = function（）{
 return new Promise（function（resolve，reject） 
 var promises = []; 
 promises.push（new Promise（function（resolve，reject）=> {
 getBar1（）然后（function（bar1）{
 processBar1（bar1）; 
 resolve（bar1）; 
}）; 
}））; 
 promises.push（new Promise（function（resolve，reject）=& 
 getBar2（）。then（function（bar2）{
 processBar2（bar2）; 
 resolve（bar2）; 
}）; 
}））; 
 Promise.all（promises）.spread（function（bar1，bar2）{
 var result = processBothBars（bar1，bar2）; 
 resolve（result）; 
}）; 
}）; 
} 
  

它呈现了反模式的一些基本问题，错误被吞噬，和金字塔的厄运。

我正在使用蓝鸟BTW。

解决方案

你可以把新的承诺一起摆脱。

  getFoo = function（）{
 var promises = []; 
 promises.push（getBar1（）。then（function（bar1）{
 processBar1（bar1）; 
 return bar1; 
}））; 
 promises.push（getBar2（）。then（function（bar2）{
 processBar2（bar2）; 
 return bar2; 
}））; 
 return Promise.all（promises）.spread（function（bar1，bar2）{
 var result = processBothBars（bar1，bar2）; 
 return result; 
}）; 
} 
  

  // start mockfunction getBar1 （）{return Promise.resolve（{name：'bar1'，processed：false}）;} function getBar2（）{return Promise.resolve（{name：'bar2'，processed：false}）;} function processBar1（bar1 ）{bar1.processed = true;} function processBar2（bar2）{bar2.processed = true;} function processBothBars（bar1，bar2）{return [bar1，bar2] .filter（function（bar）{return bar.processed;} ）.map（function（bar）{return bar.name;}）;} Promise.prototype.spread = function（fn）{return this.then（function（arr）{return fn.apply（this，arr）;} ）;}; // end mockvar getFoo = function（fail）{var promises = []; promises.push（getBar1（）。then（function（bar1）{processBar1（bar1）; if（fail）{throw'getBar1 Failed！';} return bar1;}））; promises.push（getBar2（）。then（function（bar2）{processBar2（bar2）; return bar2;}））;返回Promise.all（promises）.spread（function（bar1，bar2）{var result = processBothBars（bar1，bar2）; return result;}）;} getFoo（）然后（function（result）{console.log ）; // ['bar1'，'bar2']}）; getFoo（true）.then（function（result）{console.log（result）; //不会发生}）catch（function（e） {console.error（e）; //错误：getBar1 Failed！}）;  

.then 返回承诺，所以没有必要创建一个包装它的新的，除非你想防止错误达到外部承诺。 p>

How do you avoid the promise constructor antipattern when using multiple promises and Promise.all?

Say I have the following code:

getFoo = function() {
    return new Promise(function(resolve, reject) {
        var promises = [];
        promises.push(new Promise(function(resolve, reject) => {
            getBar1().then(function(bar1) {
                processBar1(bar1); 
                resolve(bar1);
            });
        }));
        promises.push(new Promise(function(resolve, reject) => {
            getBar2().then(function(bar2) {
                processBar2(bar2); 
                resolve(bar2);
            });
        }));
        Promise.all(promises).spread(function(bar1, bar2) {
            var result = processBothBars(bar1, bar2);
            resolve(result);
        });
    });
}

It presents some of the fundamental issues of the antipattern, errors get swallowed up, and pyramids of doom.

I am using bluebird BTW.

解决方案

You can just get rid of new Promise all together.

getFoo = function() {
    var promises = [];
    promises.push(getBar1().then(function(bar1) {
        processBar1(bar1);
        return bar1;
    }));
    promises.push(getBar2().then(function(bar2) {
        processBar2(bar2);
        return bar2;
    }));
    return Promise.all(promises).spread(function(bar1, bar2) {
        var result = processBothBars(bar1, bar2);
        return result;
    });
}

// start mock
function getBar1() {
    return Promise.resolve({name:'bar1',processed: false});
}
function getBar2() {
    return Promise.resolve({name:'bar2',processed: false});
}
function processBar1(bar1) {
  bar1.processed = true;
}
function processBar2(bar2) {
  bar2.processed = true;
}
function processBothBars (bar1, bar2) {
  return [bar1, bar2].filter(function (bar) {
    return bar.processed;
  }).map(function (bar) {
    return bar.name;
  });
}
Promise.prototype.spread = function (fn) {
  return this.then(function (arr) {
      return fn.apply(this, arr);
  });
};
// end mock

var getFoo = function (fail) {
    var promises = [];
    promises.push(getBar1().then(function (bar1) {
        processBar1(bar1);
        if (fail) {
          throw 'getBar1 Failed!';
        }
        return bar1;
    }));
    promises.push(getBar2().then(function (bar2) {
        processBar2(bar2);
        return bar2;
    }));
    return Promise.all(promises).spread(function (bar1, bar2) {
        var result = processBothBars(bar1, bar2);
        return result;
    });
}
getFoo().then(function (result) {
    console.log(result); // ['bar1', 'bar2']
});
getFoo(true).then(function (result) {
    console.log(result); // doesn't happen
}).catch(function (e) {
    console.error(e); // Error: getBar1 Failed!
});

.then returns a promise, so there's no need to create a new one that wraps it unless you want to prevent errors from reaching the outer promise.

这篇关于如何避免Promise.all的承诺构造函数反模式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！