使用 Mongoose 保存多个文档并在保存最后一个文档时执行某些操作

Question

我想使用 Mongoose 将 8 个对象保存到 MongoDB 数据库。保存最后一个文档时，我想报告（即发送事件）所有文档都已保存。

我现在这样做的方式非常混乱（尤其是对于我要保存的文档越来越多）。

这就是我现在拥有的方式（本示例仅适用于 4 人）。有没有更清洁的方法可以推荐？

person1.save(function(err, result){
    if (err) console.log(err);
    else{
        person2.save(function(err, result){
            if (err) console.log(err);
            else{
                person3.save(function(err, result){
                    if (err) console.log(err);
                    else{
                        person4.save(function(err, result){
                            if (err) console.log(err);
                            else{
                                done();
                            }
                        });
                    }
                });
            }
        });
    }
});

Answer 1

协调异步操作的有用库是async。在您的情况下，代码如下所示：

var people = [ person1, person2, person3, person4, ... ];

async.eachSeries(people, function(person, asyncdone) {
  person.save(asyncdone);
}, function(err) {
  if (err) return console.log(err);
  done(); // or `done(err)` if you want the pass the error up
});

Answer 2

使用承诺和 Array.map()

const userPromises = persons.map(user => {
  return new Promise((resolve, reject) => {
    person.save((error, result) => {
      if (error) {
        reject(error)
      }
      resolve(result);
    })
  })
});

Promise.all(userPromises).then((results) => {
  //yay!
  //results = [first, second, etc...]
}, (error) => {
  //nay!
})

Answer 3

我建议有一个数组并通过迭代保存。将具有相同的性能，但代码会更干净。

你可以拥有

var Person = mongoose.model('Person');
var people = [];

people[0] = new Person({id: 'someid'});
people[0].set('name', 'Mario');
people[1] = new Person({id: 'someid'});
people[1].set('name', 'Mario');
people[2] = new Person({id: 'someid'});
people[2].set('name', 'Mario');

var errors = [];
for(person in people){
 people[person].save(function(err, done){
  if(err) errors.push(err);
  if (person === people.length){ yourCallbackFunction(errors){
    if (errors.length!=0) console.log(errors);
    //yourcode here
   };
  }
 });
}

Answer 4

最好的方法是使用异步waterfall。 部分代码 sn-p 可能如下所示。请参考上面的链接。 它打破了异步性质并转换为一个接一个的进程（如果我没记错的话）。

 waterfall([
    function(callback){
 callback(null, 'one', 'two');
},
   function(arg1, arg2, callback){
    callback(null, 'three');
  },
  function(arg1, callback){
 // arg1 now equals 'three' 
  callback(null, 'done');
  }
], function (err, result) {
  // result now equals 'done' 
});

Answer 5

我会使用 Underscore Each 来迭代一系列 People 模型。这将使您的代码更简洁，并有助于避免您在代码中遇到的"boomerang effect"。

来自documentation：

.each(list, iteratee, [context]) 别名：forEach

遍历一个元素列表，将每个元素依次生成一个 iteratee 函数。如果传递了一个，则迭代对象绑定到上下文对象。每次调用 iteratee 时都使用三个参数：（元素、索引、列表）。如果 list 是 JavaScript 对象，iteratee 的参数将是 (value, key, list)。返回链表。

例如：

var people = [person1, person2];
var length = people.length;
var hasError = false;

var doSomething =  function() {
    console.log("I'm done");
}

var doSomethingElse =  function() {
    console.log('There was an error');
}

_.each(people, function(person, i) {

    if (!hasError) {

        person.save(function(err, result) {
            if (err) {
                console.log(err);
                hasError = true;
            }
        );

        if (i === length) {
            doSomething();
        }

    } else {

        // There was an error
        doSomethingElse();
    }

});