Node.js 奇怪的猫鼬行为-文档不会保存到数据库中

在下面的代码中，我尝试用一些测试数据填充我的devdb。我想先删除所有文档，然后添加新的测试文档：

var mongoose = require('mongoose')
    , Plan = mongoose.model('Plan')
    , Async = require('async')

Async.series([
    function(callback){
        // delete all records
        Plan.find(function(err,docs){
            for (d in docs)
              Plan.remove(d, function(err) {
                  if (err) console.log("error removing records " + err)
              });
        });
        callback();
    },
    function(callback){
        var planArray = [
          {title: 'Plan A', body: 'Restaurant Financial Plan'},
          {title: 'Plan B', body: 'Coffeeshop Financial Plan'},
          {title: 'Plan C', body: 'bar Financial Plan'}
        ]

        var arrayLength = planArray.length;
        for (var i = 0; i < arrayLength; i++) {
          var p = new Plan(planArray[i])
          p.save(function(err, saved){
            if (err)
              {console.log("error creating fixture " + err)}
            else {
              console.log(saved)
            }
          })
        }
        callback();
    }
])

var mongoose=require（'mongoose'））
，Plan=mongoose.model（'Plan'））
，Async=require（'Async'）
异步系列([
函数（回调）{
//删除所有记录
计划查找（功能（错误、文档）{
用于（文档中的d）
计划。删除（d），功能（err）{
if（err）console.log（“删除记录时出错”+err）
});
});
回调（）；
},
函数（回调）{
变量平面阵列=[
{标题：“A计划”，正文：“餐厅财务计划”}，
{标题：“B计划”，正文：“咖啡店财务计划”}，
{标题：“计划C”，正文：“bar财务计划”}
]
var arrayLength=平面阵列.length；
对于（变量i=0；i

有趣（奇怪）的行为是： -代码运行并删除所有文档，但不添加新的测试文档。 -控制台上没有错误，console.log（已保存）会将每个新文档成功打印到控制台。 -如果删除第一个异步函数（删除所有记录），那么新文档将保存到数据库中

是猫鼬的怪癖还是我对异步流的误解？

我猜是后者——对异步流的误解。在完成查找和删除文档之前，将调用第一个函数的回调。因此，当您仍在查找和删除它们时，您已经在第二个函数中添加了更多的函数，但是第一个函数将查找和删除这些函数

只有在删除所有文档后，才需要调用第一个回调。尝试将

异步。每个
都放在
计划中。查找
回调：

Async.series([
    function(callback){
        // delete all records
        Plan.find(function(err, docs){
            Async.each(
                docs, // your array
                function removeDoc(d, cb) { // iterator function
                    Plan.remove(d, function (err) {
                        if (err) console.log("error removing records " + err);
                        return cb();
                    });
                }, 
                callback // executed after the iterator is done
            );
    },
    ...

顺便说一句，我相信
Plan.remove（{}，function（err）{…}）
删除所有文档——不需要迭代每个文档，除非您正在做其他事情。
调用callback（）后，第二个函数开始执行，即。E在查找和删除呼叫之前。您必须等待完成查找和删除以及调用callback（）。
从async查看队列方法：
有一些问题。首先，您有一个
for
循环，该循环触发异步删除，但在调用第一个回调之前，这些操作可能没有完成。最好使用
Async.each

此外，似乎还发生了一些函数命名冲突。因此，有关这方面的完整示例，请参见以下内容：

var mongoose = require('mongoose'),
    Async = require('async'),
    Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/test');

var planSchema = new Schema({
  title: String,
  body: String
});

var Plan = mongoose.model('Plan',planSchema);

Async.series([
  function(call1) {
    Plan.find(function(err,docs) {
      if (err)
        throw err;

      if ( docs.length > 0 ) {
        Async.each( docs, function(d, call2) {
          Plan.remove(d, function(err) {
            if (err)
              throw err;
            console.log( "deleting: " + d );
            call2();
          });
        });
      }
    });
    call1();
  },
  function(call3) {

    var planArray = [
      { title: 'Plan A', body: 'Plan A' },
      { title: 'Plan B', body: 'Plan B' }
    ];

    var arrayLength = planArray.length;

    for ( var i = 0; i < arrayLength; i++ ) {
      var p = new Plan(planArray[i]);
      p.save(function(err,saved) {
        if (err)
          throw err;

        console.log( "saving: " + saved );

      });

    }
    call3();
  }
]);

var mongoose=require（'mongoose'），
Async=require（'Async'），
Schema=mongoose.Schema；
猫鼬mongodb://localhost/test');
var planSchema=新模式({
标题：字符串，
正文：字符串
});
var Plan=mongoose.model（'Plan'，planSchema）；
异步系列([
函数（call1）{
计划查找（功能（错误、文档）{
如果（错误）
犯错误；
如果（docs.length>0）{
Async.each（文档、函数（d、call2）{
计划。删除（d），功能（err）{
如果（错误）
犯错误；
控制台日志（“删除：+d”）；
call2（）；
});
});
}
});
call1（）；
},
函数（call3）{
变量平面阵列=[
{标题：“计划A”，正文：“计划A”}，
{标题：'Plan B'，正文：'Plan B'}
];
var arrayLength=平面阵列.length；
对于（变量i=0；i
Jorge，这很好用。另外-关于.remove{}删除所有文档而不进行迭代是正确的。我的questoin-猫鼬文档中没有记录这一点。你怎么知道的？太好了！至于
.remove（{}）
，您是对的——它只是在上的模型概述中间接提到的。
.remove
调用中的第一个参数指定将删除哪些文档。Mongoose将删除所有符合这些条件的内容。这也是MongoDB中本机
.remove（）
函数的行为。