如何使用可变函数调用创建顺序promise循环

Question

我需要以某种方式循环传递给_start的work数组然后对于数组中的每个项目，我需要以某种方式调用具有相同名称的相应函数。

我无法控制work的项目数量或项目数量，我知道总会有相应的功能。

我不想同时调用所有函数，一旦第一个函数在3秒后解析，我就想调用第二个函数，一旦第二个函数在3秒后解析，我就想调用第三个函数。 一旦第三个函数在另外3秒后解析，我想调用_done（）。

在这个例子中，每个函数需要3秒才能完成_done不会被调用9秒。

function _start(data){
    // Insert some kinda native magic loop
}


function _one(){
    return new Promise((resolve, reject) => {
        setTimeout(function(){ 
            resolve(1); 
        }, 3000);
    })
};


function _two(){
    return new Promise((resolve, reject) => {
        setTimeout(function(){ 
            resolve(2); 
        }, 3000);
    })
};

function _done(){
    console.log('All done in 9 seconds)
}


(function(){
    var work = ['_one', '_two', '_two'];
    _start(work);
})();

Answer 1

鉴于顺序由数组指定，您可以使用reduce将promises聚合到一个链中

const _start = (...actions) => {
  return actions.reduce((chain, action) => {
    const func = this[action];
    return chain.then(() => func());
  }, Promise.resolve());
}
...
_start('_one', '_two', '_three').then(() => console.log('All done'));

看到它在行动 -例子追加额外then到链只是为了输出的承诺的任何结果（可能outwith这个问题的范围，但你可能有，如果让数据传回需要考虑的东西）。

更新

可以看到你打算从声明_start的不同上下文中调用_start ，这很好，但是你需要确保在手之前设置正确的上下文，即

const self = this;
(function() {
  _start.bind(self)('_one', '_two', '_two');
})();

Answer 2

一个创造睡眠承诺的功能：

const sleep = n => () => new Promise(resolve => setTimeout(resolve, n));

一些输入承诺后休眠的函数：

const sleepAfter = n => p => p.then(sleep(n));

链接一堆承诺的函数，由函数表示：

const chain = (...promises) => promises.reduce((ret, promise) => ret.then(promise), 
  Promise.resolve());

运行一堆函数产生承诺，睡在两者之间：

const _start = promises => chain(promises.map(sleepAfter(3000)));

现在只是：

_start(_one, _two, _three).then(_done);

Answer 3

试试这个：

_one().then((firstResponse) {
      return_two();
}) .then((secondResponse) => {
 *second and first respone are already done*

});

Answer 4

then使用promises

_one().then((responseOne) => {
    return _two();
}).then((responseTwo) => {
    // _one & _two are done
});