延迟的顺序承诺循环

Question

我试图依次加载一个“请求”数组，每个请求之间都间隔一个延迟。

我正在使用Promise，但是由于某些原因，我在并行而不是按顺序执行请求时遇到了问题。

我按照下面编写了一些测试代码。 有用！ 它发出请求，进行处理，timesOut 3秒钟，然后转到第二个请求。

 var batches = [of_objects]; var sequence = Promise.resolve(); var self = this; sequence //Create request for first batch .then( function(){ return self._createRequestPromise(batches[0]); }) //callback so we can update, returns nothing .then(callback) //add 3 sec timeout before next request .then(function(){ return new Promise(function (resolve, reject){ setTimeout(resolve, 3000); }); }) //Create request for second batch .then( function(){ return self._createRequestPromise(batches[1]); }) //callback so we can update, returns nothing .then(callback) //add 3 sec timeout before next request .then(function(){ return new Promise(function (resolve, reject){ setTimeout(resolve, 3000); }); }); return sequence; 

但是，一旦我尝试进行任何形式的循环，我的请求就会同时触发。 然后发生超时呼叫。

我不确定自己在做什么错或误解。

 //object I need to use to construct requests var batches = [of_objects]; var sequence = Promise.resolve(); var self = this; batches.forEach(function(batch){ sequence //Function returns promise .then( function(){ return self._createRequestPromise(batch); //this runs first 5x }) //callback so we can update, returns nothing .then(callback) //add 3 sec timeout before next request .then(function(){ return new Promise(function (resolve, reject){ setTimeout(resolve, 3000); //this runs after 5x }); }); }); return sequence; 

Answer 1

问题是您没有将sequence更新为包括任何连续的操作，因此所有这些操作都与原始的已解决承诺链接在一起。 没有延迟任何延迟的功能，因此它们可以立即执行。

您应该能够简单地通过在每个循环上更新sequence变量来解决此问题，因此您可以将链的末端链接起来：

//object I need to use to construct requests
var batches = [of_objects];
var sequence = Promise.resolve();
var self = this;

batches.forEach(function (batch){
    sequence = sequence            // <-- here
        //Function returns promise
        .then( function(){
            return self._createRequestPromise(batch); //this runs first 5x
        })
        //callback so we can update, returns nothing
        .then(callback)
        //add 3 sec timeout before next request
        .then(function(){
            return new Promise(function (resolve, reject){
                setTimeout(resolve, 3000); //this runs after 5x
            });
        });
});

return sequence;

就我个人而言，我尝试避免覆盖变量，因此在不进行变量重新分配的情况下执行此操作的另一种方法是使用.reduce() ：

//object I need to use to construct requests
var batches = [of_objects];
var self = this;

return batches.reduce(function (last, batch){
    return last
        //Function returns promise
        .then( function(){
            return self._createRequestPromise(batch); //this runs first 5x
        })
        //callback so we can update, returns nothing
        .then(callback)
        //add 3 sec timeout before next request
        .then(function(){
            return new Promise(function (resolve, reject){
                setTimeout(resolve, 3000); //this runs after 5x
            });
        });
}, Promise.resolve());