Question

我有一个数组，其值是由＆＃39; /＆＃39;和＆＃39; mapSeries＆＃39;分隔的序列。 Promise（带有映射的连续迭代的辅助函数），循环遍历每个序列中的每个值。

现在，该声明以嵌套＆＃39; for＆＃39;开头。将一个序列拆分成字符串的循环，然后将这些值推送到一个空数组，以传递给地图系列＆＃39;答应..

经过测试，结果证明这只有在原始数组有一个序列时才有效，因为多个序列并行运行。

如何将此编写为对每个序列进行连续运行的承诺，然后对给定序列中的每个元素进行连续编写？

这里是for循环的尝试（适用于单个序列）：

var sequences = ['one/two/three', 'alpha/beta'];
var elements = [];
for (i=0; i<sequences.length; i++) {
  var series = sequences[i].split("/");
  for (j=0; j<series.length; j++) {
    elements.push(series[j]);
  }
    var items = mapSeries(elements, function(element) {
        // do stuff with 'one', then 'two', then 'three'
        // when done..next series
        // do stuff with 'alpha', then 'beta'
    })
    elements = []; // reset elements array for next series
} // for sequences.length

这是对Promise的尝试（element.charAt的错误......）：

var sequences = ['one/two/three', 'alpha/beta'];
var elements = [];
var items = mapSeries(sequences, function(sequence) {
    sequence = sequence.split("/");
    return mapSeries(sequence, function(series) {
        elements.push(series);
        return elements;
    }).then(function(elements) {
        return mapSeries(elements, function(element){
            var element = element.charAt(0).toLowerCase() + element.slice(1); // first letter lowercase
            // do stuff with 'one', then 'two', then 'three'
            // when done..next series
            // do stuff with 'alpha', then 'beta'
        });
    });
    elements = []; // reset elements array for next series
});

mapSeries辅助函数：

function mapSeries(things, fn) {
  var results = [];
  return Promise.each(things, function(value, index, length) {
    var ret = fn(value, index, length);
    results.push(ret);
    return ret;
  }).thenReturn(results).all();
}

Answer 1

一些快速，丑陋，未经测试的例子，但我希望你能得到这个想法：

var sequences = ['one/two/three', 'alpha/beta'];
var elements = [];
var promise = null;

for (var i = 0; i < sequences.length; i++) {
    (function(series){
        function doStuff() {
            for (var j = 0; j < series.length; j++) {
                elements.push(series[j]);
            }

            return mapSeries(elements, function(element) {
                // async stuff
            })
        }

        if (promise) {
            promise = promise.then(doStuff)
        } else {
            promise = doStuff()
        }
    })( sequences[i].split("/") )
}

promise.then(function(){
    // ...    
})

Answer 2

这部分代码似乎没用，因为elements与sequence相同，推送不是异步的，所以你也可以使用for循环：

sequence = sequence.split("/");
return mapSeries(sequence, function(series) {
    elements.push(series);
    return elements;
})

此外，您可能还有一个错误

elements = []; // reset elements array for next series

永远不会执行

- 它是在return语句之后;并且不会等待异步结果。

您的代码应该只是省略那些elements数组，而只是

var sequences = ['one/two/three', 'alpha/beta'];
var items = mapSeries(sequences, function(sequence) {
    return mapSeries(sequence.split("/"), function(elements) {
        return mapSeries(elements, function(element) {
            // do async stuff with the element, and return a promise
        });
    });
});

顺便说一下，我推荐使用Bluebird的“原生”map method而不是自定义mapSeries，而concurrency option设置为1。

转换嵌套＆＃39;为＆＃39;为了承诺而循环成为承诺？嵌套承诺？

2 个答案: