用 Mongoose 保存在 mongoDb 中，保存了意外的元素

Question

当我用 mongoose 在 mongoDB 中写入时，操作被成功处理，我的文档被保存，但也写下了各种奇怪的其他内容。这似乎是猫鼬代码。什么可能导致这种情况？

我在特定数组中添加内容：

resultReference.ref[arrayLocation].allEvents.push(theEvent);

{id: 11, allEvents: [] } 是 ref 元素的结构，并将 theEvent 推入 allEvents 数组中。然后我 resultReference.save()

我使用express、mongoose 和 mongoHQ 作为数据库。我在本地 mongo 服务器上尝试过，这种烦恼仍然存在。我已经在控制台中打印了要在 save() 之前编写的文档，并且不存在这种奇怪的代码。

{
id  11
allEvents   
[
0   
{
_events 
{
maxListeners    0
}
_doc    
{
_id {"$oid": "4eb87834f54944e263000003"}
title   "Test"
allDay  false
start   2011-11-10 13:00:00 UTC
end 2011-11-10 15:00:00 UTC
url "/test/4eb87834f54944e263000002"
color   "#99CCFF"
ref "4eb87834f54944e263000002"
}
_activePaths    
{
paths   
{
title   "modify"
allDay  "modify"
start   "modify"
end "modify"
url "modify"
color   "modify"
ref "modify"
}
states  
{
init    
{ }
modify  
{
title   true
allDay  true
start   true
end true
url true
color   true
ref true
}
require 
{ }
}
stateNames  
[
0   "require"
1   "modify"
2   "init"
]
}
_saveError  null
_validationError    null
isNew   true
_pres   
{
save    
[
0   
function (next) {
    // we keep the error semaphore to make sure we don't
    // call `save` unnecessarily (we only need 1 error)
    var subdocs = 0
      , error = false
      , self = this;

    var arrays = this._activePaths
    .map('init', 'modify', function (i) {
      return self.getValue(i);
    })
    .filter(function (val) {
      return (val && val instanceof DocumentArray && val.length);
    });

    if (!arrays.length)
      return next();

    arrays.forEach(function (array) {
      subdocs += array.length;
      array.forEach(function (value) {
        if (!error)
          value.save(function (err) {
            if (!error) {
              if (err) {
                error = true;
                next(err);
              } else
                --subdocs || next();
            }
          });
      });
    });
  }
1   "function checkForExistingErrors(next) {
if (self._saveError){
next(self._saveError);
self._saveError = null;
} else {
next();
}
}"
2   "function validation(next) {
return self.validate.call(self, next);
}"
]
}
_posts  
{
save    
[ ]
}
save    
function () {
      var self = this
        , hookArgs // arguments eventually passed to the hook - are mutable
        , lastArg = arguments[arguments.length-1]
        , pres = this._pres[name]
        , posts = this._posts[name]
        , _total = pres.length
        , _current = -1
        , _asyncsLeft = proto[name].numAsyncPres
        , _next = function () {
            if (arguments[0] instanceof Error) {
              return handleError(arguments[0]);
            }
            var _args = Array.prototype.slice.call(arguments)
              , currPre
              , preArgs;
            if (_args.length && !(arguments[0] === null && typeof lastArg === 'function'))
              hookArgs = _args;
            if (++_current < _total) {
              currPre = pres[_current]
              if (currPre.isAsync && currPre.length < 2)
                throw new Error("Your pre must have next and done arguments -- e.g., function (next, done, ...)");
              if (currPre.length < 1)
                throw new Error("Your pre must have a next argument -- e.g., function (next, ...)");
              preArgs = (currPre.isAsync
                          ? [once(_next), once(_asyncsDone)]
                          : [once(_next)]).concat(hookArgs);
              return currPre.apply(self, preArgs);
            } else if (!proto[name].numAsyncPres) {
              return _done.apply(self, hookArgs);
            }
          }
        , _done = function () {
            var args_ = Array.prototype.slice.call(arguments)
              , ret, total_, current_, next_, done_, postArgs;
            if (_current === _total) {
              ret = fn.apply(self, args_);
              total_ = posts.length;
              current_ = -1;
              next_ = function () {
                if (arguments[0] instanceof Error) {
                  return handleError(arguments[0]);
                }
                var args_ = Array.prototype.slice.call(arguments, 1)
                  , currPost
                  , postArgs;
                if (args_.length) hookArgs = args_;
                if (++current_ < total_) {
                  currPost = posts[current_]
                  if (currPost.length < 1)
                    throw new Error("Your post must have a next argument -- e.g., function (next, ...)");
                  postArgs = [once(next_)].concat(hookArgs);
                  return currPost.apply(self, postArgs);
                }
              };
              if (total_) return next_();
              return ret;
            }
          };
      if (_asyncsLeft) {
        function _asyncsDone (err) {
          if (err && err instanceof Error) {
            return handleError(err);
          }
          --_asyncsLeft || _done.apply(self, hookArgs);
        }
      }
      function handleError (err) {
        if ('function' == typeof lastArg)
          return lastArg(err);
        if (errorCb) return errorCb.call(self, err);
        throw err;
      }
      return _next.apply(this, arguments);
    }
errors  null
}
]
}
]

Answer 1

发生这种情况的原因是因为我没有以正确的顺序将模式保存在猫鼬中。这意味着在父模式之前声明您的子模式以获得正确的行为。