ES6 Promises - 类似 async.each 的东西？

Question

试图弄清楚如何找到功能与 async.eachSeries 完全相同的东西，我需要一个按顺序运行（而不是并行）的异步操作列表，但在本机 ES6 中找不到方法，可以有人建议吗？

附言考虑过生成器/产量，但还没有经验，所以我没有意识到它到底能对我有多大帮助。

编辑 1

每个请求，这里是一个例子：

假设这段代码：

let model1 = new MongooseModel({prop1: "a", prop2: "b"});
let model2 = new MongooseModel({prop1: "c", prop2: "d"});

let arr = [model1 , model2];

现在，我想以一系列而不是并行的方式运行它，因此使用“异步”NPM 很容易：

async.eachSeries(arr, (model, next)=>{
    model.save.then(next).catch(next);
}, err=>{
    if(err) return reject(error);
    resolve();
})

我的问题是：使用 ES6，我可以在本地实现吗？没有 NPM 'async' 包？

编辑 2

使用 async/await 可以轻松完成：

let model1 = new MongooseModel({prop1: "a", prop2: "b"});
let model2 = new MongooseModel({prop1: "c", prop2: "d"});    

let arr = [model1 , model2];

for(let model of arr){
    await model.save();
}

Answer 1

您可以通过在then 回调中返回来进行链接。例如：

new Promise(function(resolve, reject){ 
  resolve(1)
}).then(function(v){
  console.log(v);
  return v + 1;
}).then(function(v){
  console.log(v)
});

将打印：

1
2

这在异步解析 Promise 时当然有效：

new Promise(function(resolve, reject){
  setTimeout(function(){
    resolve(1);
  }, 1000)
}).then(function(result){
   return new Promise(function(resolve, reject){
     setTimeout(function(){
       console.log(result);
       resolve(result + 1);
     }, 1000)
   });
}).then(function(results){
  console.log(results);
});

印刷：

1
2

Answer 2

假设您想对数据数组调用某个异步函数，并且希望它们按顺序调用，而不是并行调用。

async.eachSeries()的界面是这样的：

eachSeries(arr, iterator, [callback])

下面是如何用 Promise 模拟它：

// define helper function that works kind of like async.eachSeries
function eachSeries(arr, iteratorFn) {
    return arr.reduce(function(p, item) {
        return p.then(function() {
            return iteratorFn(item);
        });
    }, Promise.resolve());
}

这假定iteratorFn 将要处理的项目作为参数并返回一个承诺。

这是一个用法示例（假设您有一个已承诺的 fs.readFileAsync()）并有一个名为 speak() 的函数，该函数在完成时返回一个承诺：

 var files = ["hello.dat", "goodbye.dat", "genericgreeting.dat"];
 eachSeries(files, function(file) {
     return fs.readFileAsync(file).then(function(data) {
         return speak(data);
     });
 });

这让 Promise 基础架构可以为您排序所有内容。

---

您也可以手动排序（虽然我不确定为什么）：

function eachSeries(arr, iteratorFn) {
    return new Promise(resolve, reject) {
        var index = 0;

        function next() {
            if (index < arr.length) {
                try {
                    iteratorFn(arr[index++]).then(next, reject);
                } catch(e) {
                    reject(e);
                }
            } else {
                resolve();
            }
        }
        // kick off first iteration
        next();
    });
}

或者，手动将 Promise 链接在一起的更简单的版本：

function eachSeries(arr, iteratorFn) {
    var index = 0;

    function next() {
        if (index < arr.length) {
            return iteratorFn(arr[index++]).then(next);
        }
    }
    return Promise.resolve().then(next);
}

请注意其中一个手动版本必须如何将iteratorFn() 与try/catch 括起来，以确保它是抛出安全的（将异常转换为拒绝）。 .then() 是自动抛出安全的，因此其他方案不必手动捕获异常，因为 .then() 已经为您捕获了它们。

Answer 3

对于喜欢简短回答的人：

[func1, func2].reduce((p, f) => p.then(f), Promise.resolve());

Answer 4

//为运行较低nodejs版本（Azure :/）的系统上传这个 不是最短但我能想到的最好的

例如，让我们说“functionWithPromise”返回一些承诺并期望一些项目。

functionWithPromise(item);

promisesArray =[];

//syncornized
itemsArray.forEach(function (item){
   promisesArray.push(functionWithPromise(item));
});

Promise.all(promisesArray).then(function (values){
//profit
});

Answer 5

作为answer provided by @jib...的扩展，您还可以将一组项目映射到异步函数，如下所示：

[item1, item2]
    .map(item => async (prev_result) => await something_async(item))
    .reduce((p, f) => p.then(f), Promise.resolve())
    .then(() => console.log('all done'));

注意prev_result 将如何成为先前对something_async 的评估返回的值，这大致相当于async.eachSeries 和async.waterfall 之间的混合。