如何按順序執行承諾數組？

Question

我有一系列需要按順序運行的承諾。

var promises = [promise1, promise2, ..., promiseN]; 

調用RSVP.all將並行執行它們：

RSVP.all(promises).then(...); 

但是，我怎麼能運行它們的順序？

我可以手動堆疊起來這樣

RSVP.resolve() 
    .then(promise1) 
    .then(promise2) 
    ... 
    .then(promiseN) 
    .then(...); 

但問題是，承諾的數目而變化並且應許的陣列被動態創建的。

Answer 1

如果你已經有他們在一個數組中，那麼他們已經在執行。如果你有承諾，那麼它已經在執行。這不是承諾的問題（I.E他們不像C＃Task在這方面與.Start()方法）。 .all不會執行任何事情 它只是返回一個承諾。

如果你有承諾，返回功能的陣列：

var tasks = [fn1, fn2, fn3...]; 

tasks.reduce(function(cur, next) { 
    return cur.then(next); 
}, RSVP.resolve()).then(function() { 
    //all executed 
}); 

或值：

var idsToDelete = [1,2,3]; 

idsToDelete.reduce(function(cur, next) { 
    return cur.then(function() { 
     return http.post("/delete.php?id=" + next); 
    }); 
}, RSVP.resolve()).then(function() { 
    //all executed 
}); 

Answer 2

在回答第二次嘗試中，我嘗試更加說明：

首先，一些必要的背景，從RSVP README：

當您從第一個處理程序返回一個承諾時，真正可怕的部分會出現......這允許您展開嵌套的回調，並且是承諾的主要功能，可防止具有大量異步代碼的程序中的「向右漂移」 。

這正是你如何使承諾連續的，通過返回承諾之前的承諾then。

把這樣一組承諾想象成一棵樹是很有幫助的，其中分支表示順序進程，葉子表示併發進程。

構建這種承諾樹的過程類似於構建其他樹種的常見任務：維護指針或引用您目前正在添加樹枝的樹中的位置，並迭代添加事物。

正如@Esailija在他的回答中指出的那樣，如果您有一組不帶參數的promise返回函數，您可以使用reduce爲您整齊地構建樹。如果你曾經爲自己實施過減免，那麼你會明白@ Esailija的回答在幕後做了什麼減少，是保持對當前承諾的參考（cur），並且每個承諾都會在其then中返回下一個承諾。

如果你沒有一個很好的齊次數組（相對於它們返回的參數），答應返回函數，或者如果你需要一個比簡單線性序列更復雜的結構，你可以構造

var root_promise = current_promise = Ember.Deferred.create(); 
// you can also just use your first real promise as the root; the advantage of 
// using an empty one is in the case where the process of BUILDING your tree of 
// promises is also asynchronous and you need to make sure it is built first 
// before starting it 

current_promise = current_promise.then(function(){ 
    return // ...something that returns a promise...; 
}); 

current_promise = current_promise.then(function(){ 
    return // ...something that returns a promise...; 
}); 

// etc. 

root_promise.resolve(); 

您可以通過使用RSVP.all添加多個「葉子」的建設同時或連續工藝的組合：通過保持在許樹要添加新的承諾，位置的參考你的承諾承諾「分支」。我低調的存在 - 太複雜的答案就是一個例子。

你也可以使用Ember.run.scheduleOnce（'afterRender'）來確保在下一個承諾被觸發之前在一個承諾中完成的事情被呈現 - 我的downvoted-for-too-複雜的答案也顯示那個例子。

Answer 3

我打算在這裏留下這個答案，因爲這會幫助我，當我到這裏尋找解決方案時，我的問題。

我之後的事情基本上是mapSeries ......我碰巧是映射保存在一組值的......我想要的結果...

所以，這裏就我，FWIW，幫助別人尋找在未來類似的事情....

（請注意，上下文是灰燼應用程序）

App = Ember.Application.create(); 

App.Router.map(function() { 
    // put your routes here 
}); 

App.IndexRoute = Ember.Route.extend({ 
    model: function() { 
      var block1 = Em.Object.create({save: function() { 
       return Em.RSVP.resolve("hello"); 
      }}); 
    var block2 = Em.Object.create({save: function() { 
      return Em.RSVP.resolve("this"); 
     }}); 
    var block3 = Em.Object.create({save: function() { 
     return Em.RSVP.resolve("is in sequence"); 
    }}); 

    var values = [block1, block2, block3]; 

    // want to sequentially iterate over each, use reduce, build an array of results similarly to map... 

    var x = values.reduce(function(memo, current) { 
     var last; 
     if(memo.length < 1) { 
      last = current.save(); 
     } else { 
      last = memo[memo.length - 1]; 
     } 
     return memo.concat(last.then(function(results) { 
      return current.save(); 
     })); 
    }, []); 

    return Ember.RSVP.all(x); 
    } 
}); 

Answer 4

隨着2017年的ECMAScript異步功能，這將這樣進行：

async function executeSequentially() { 
    const tasks = [fn1, fn2, fn3] 

    for (const fn of tasks) { 
     await fn() 
    } 
} 

您可以使用BabelJS使用異步函數現在

Answer 5

我有類似的問題，我做了它運行功能也一一依次遞歸函數。

var tasks = [fn1, fn2, fn3]; 

var executeSequentially = function(tasks) { 
    if (tasks && tasks.length > 0) { 
    var task = tasks.shift(); 

    return task().then(function() { 
     return executeSequentially(tasks); 
    }); 
    } 

    return Promise.resolve(); 
}; 

如果你需要從這些功能收集輸出：

var tasks = [fn1, fn2, fn3]; 

var executeSequentially = function(tasks) { 
    if (tasks && tasks.length > 0) { 
    var task = tasks.shift(); 

    return task().then(function(output) { 
     return executeSequentially(tasks).then(function(outputs) { 
     outputs.push(output); 

     return Promise.resolve(outputs); 
     }); 
    }); 
    } 

    return Promise.resolve([]); 
}; 

Answer 6

一切都需要解決一個for循環:)

var promises = [a,b,c]; 
var chain; 

for(let i in promises){ 
    if(chain) chain = chain.then(promises[i]); 
    if(!chain) chain = promises[i](); 
} 

function a(){ 
    return new Promise((resolve)=>{ 
    setTimeout(function(){ 
     console.log('resolve A'); 
     resolve(); 
    },1000); 
    }); 
} 
function b(){ 
    return new Promise((resolve)=>{ 
    setTimeout(function(){ 
     console.log('resolve B'); 
     resolve(); 
    },500); 
    }); 
} 
function c(){ 
    return new Promise((resolve)=>{ 
    setTimeout(function(){ 
     console.log('resolve C'); 
     resolve(); 
    },100); 
    }); 
} 

Answer 7

ES7的方式在2017年

<script> 
    var funcs = [ 
    _ => new Promise(resolve => setTimeout(_ => resolve("1"), 1000)), 
    _ => new Promise(resolve => setTimeout(_ => resolve("2"), 1000)), 
    _ => new Promise(resolve => setTimeout(_ => resolve("3"), 1000)), 
    _ => new Promise(resolve => setTimeout(_ => resolve("4"), 1000)), 
    _ => new Promise(resolve => setTimeout(_ => resolve("5"), 1000)), 
    _ => new Promise(resolve => setTimeout(_ => resolve("6"), 1000)), 
    _ => new Promise(resolve => setTimeout(_ => resolve("7"), 1000)) 
    ]; 
    async function runPromisesInSequence(promises) { 
    for (let promise of promises) { 
     console.log(await promise()); 
    } 
    } 
    </script> 
    <button onClick="runPromisesInSequence(funcs)">Do the thing</button> 

This w不順利執行給定的函數（一個接一個），而不是並行執行。參數promises是一組函數，返回Promise。

與上面的代碼Plunker例如：http://plnkr.co/edit/UP0rhD?p=preview

Answer 8

我寫了這個庫，也許它可以幫助你 https://github.com/LvChengbin/sequence

你可以從NPM安裝：

npm i @lvchengbin/sequence --save 

然後你可以像這樣實施：

Sequence.all([ 
    () => promise1, 
    () => promise2, 
    () => promise3 
]).then(results => { 
    // here you will get all results of the promises in the list 
}).catch(results => { 
    // any of promises failed, and you can get all results of them 
}); 

如果要執行列表中的所有步驟，不管其中是否成功或失敗，你可以使用Sequence.chain

Sequence.all([ 
    () => promise1, 
    () => promise2, 
    () => promise3 
]).then(results => { 
    // here you will get all results of the promises in the list, and you can know which one has succeeded and which one has failed with 
    if(results[ 0 ].status === Sequence.SUCCEEDED) { 
     console.log(results[ 0 ].value); 
    } 
}) 

您還可以創建一個空序列，後來追加的步驟。

const sequence = new Sequence(); 

sequence.append(promise1); 
sequence.append([ promise1, promise2 ]); 
sequence.on('success', (result, index, results) => { 
    // this function will execute for each item succeeded. 
}); 
sequence.on('failed', (result, index, results) => { 
    // this function will execute for each item failed. 
}); 

sequence.on('end',() => { 
    // this function will be executed after all steps in the sequence finished. but you can also append more steps later. 
}); 

如果需要，可以執行這樣的每個步驟指定一個interval：

Sequence.all([], 1000); 

Sequence.chain([], 1000); 

Sequence.any([], 1000); 

new Sequence([], { interval : 1000 }); 

所有上面的代碼將執行序列中的各個步驟以1秒的時間間隔。