如何使用可變函數調用創建順序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
});