1. index.js

源码：index.js

1.1. Mongoose#Aggregate()

Mongoose 的 Aggregate 构造函数

1.2. Mongoose#CastError(type, value, path, [reason])

Mongoose 的 CastError 构造函数

参数:

• type <String> The name of the type
• value <Any> The value that failed to cast
• path <String> The path a.b.c in the doc where this cast error occurred
• [reason] <Error> The original error that was thrown

1.3. Mongoose#Collection()

Mongoose 的 Collection 构造函数

1.4. Mongoose#connect(uri(s), [options], [options.useMongoClient], [callback])

打开默认的 mongoose 连接

参数：

• uri(s) <String>
• [options] <Object>
• [options.useMongoClient] <Boolean> 默认为 false，设置为 true 来使用一个新的 mongoose 连接逻辑。
• [callback] <Function>

返回值：

• <MongooseThenable> pseudo-promise wrapper around this

参见：

• Mongoose#createConnection

如果提供了参数，它们也会被适当地代理到 Connection#open 或者 Connection#openSet。

传递的选项优先于连接字符串中包含的选项。

示例：

mongoose.connect('mongodb://user:pass@localhost:port/database');

// 副本集(replica sets)
var uri = 'mongodb://user:pass@localhost:port,anotherhost:port,yetanother:port/mydatabase';
mongoose.connect(uri);

// 使用选项
mongoose.connect(uri, options);

// 连接到多个 mongos
var uri = 'mongodb://hostA:27501,hostB:27501';
var opts = { mongos: true };
mongoose.connect(uri, opts);

// 可选的回调， 当初始化连接完成时被触发
var uri = 'mongodb://nonexistent.domain:27000';
mongoose.connect(uri, function(error) {
  // 如果 error 是真值，那初始化连接失败
})

  Mongoose.prototype.connect = function() {
    var conn = this.connection;
    if ((arguments.length === 2 || arguments.length === 3) &&
        typeof arguments[0] === 'string' &&
        typeof arguments[1] === 'object' &&
        arguments[1].useMongoClient === true) {
      return conn.openUri(arguments[0], arguments[1], arguments[2]);
    }
    if (rgxReplSet.test(arguments[0]) || checkReplicaSetInUri(arguments[0])) {
      return new MongooseThenable(this, conn.openSet.apply(conn, arguments));
    }

    return new MongooseThenable(this, conn.open.apply(conn, arguments));
  };
  Mongoose.prototype.connect.$hasSideEffects = true;

1.5. Mongoose#Connection()

Mongoose 的 Connection 构造函数

1.6. Mongoose#createConnection([uri], [options], [options.config], [options.config.autoIndex], [options.useMongoClient])

创建一个 Connection 实例。

参数：

• [uri] <String> a mongodb:// URI
• [options] <Object> options to pass to the driver
• [options.config] <Object> mongoose-specific options
• [options.config.autoIndex] <Boolean> set to false to disable automatic index creation for all models associated with this connection.
• [options.useMongoClient] <Boolean> false by default, set to true to use new mongoose connection logic

返回值：

• <Connection, Promise> the created Connection object, or promise that resolves to the connection if useMongoClient option specified.

参见：

• Connection#open
• Connection#openSet

Each connection instance maps to a single database. This method is helpful when mangaging multiple db connections.

If arguments are passed, they are proxied to either Connection#open or Connection#openSet appropriately. This means we can pass db, server, and replset options to the driver. Note that the safe option specified in your schema will overwrite the safe db option specified here unless you set your schemas safe option to undefined. See this for more information.

Options passed take precedence over options included in connection strings.

示例：

// with mongodb:// URI
db = mongoose.createConnection('mongodb://user:pass@localhost:port/database');

// and options
var opts = { db: { native_parser: true }}
db = mongoose.createConnection('mongodb://user:pass@localhost:port/database', opts);

// replica sets
db = mongoose.createConnection('mongodb://user:pass@localhost:port,anotherhost:port,yetanother:port/database');

// and options
var opts = { replset: { strategy: 'ping', rs_name: 'testSet' }}
db = mongoose.createConnection('mongodb://user:pass@localhost:port,anotherhost:port,yetanother:port/database', opts);

// with [host, database_name[, port] signature
db = mongoose.createConnection('localhost', 'database', port)

// and options
var opts = { server: { auto_reconnect: false }, user: 'username', pass: 'mypassword' }
db = mongoose.createConnection('localhost', 'database', port, opts)

// initialize now, connect later
db = mongoose.createConnection();
db.open('localhost', 'database', port, [opts]);

  Mongoose.prototype.createConnection = function(uri, options) {
    var conn = new Connection(this);
    this.connections.push(conn);

    var rsOption = options && (options.replset || options.replSet);

    if (options && options.useMongoClient) {
      return conn.openUri(uri, options);
    }

    if (arguments.length) {
      if (rgxReplSet.test(arguments[0]) || checkReplicaSetInUri(arguments[0])) {
        conn._openSetWithoutPromise.apply(conn, arguments);
      } else if (rsOption &&
          (rsOption.replicaSet || rsOption.rs_name)) {
        conn._openSetWithoutPromise.apply(conn, arguments);
      } else {
        conn._openWithoutPromise.apply(conn, arguments);
      }
    }

    return conn;
  };
  Mongoose.prototype.createConnection.$hasSideEffects = true;

1.7. Mongoose#disconnect([fn])

断开所有连接。

参数：

• [fn] <Function> called after all connection close.

返回值：

• MongooseThenable pseudo-promise wrapper around this

  Mongoose.prototype.disconnect = function(fn) {
    var _this = this;

    var Promise = PromiseProvider.get();
    return new MongooseThenable(this, new Promise.ES6(function(resolve, reject) {
      var remaining = _this.connections.length;
      if (remaining <= 0) {
        fn && fn();
        resolve();
        return;
      }
      _this.connections.forEach(function(conn) {
        conn.close(function(error) {
          if (error) {
            fn && fn(error);
            reject(error);
            return;
          }
          if (!--remaining) {
            fn && fn();
            resolve();
          }
        });
      });
    }));
  };
  Mongoose.prototype.disconnect.$hasSideEffects = true;

1.8. Mongoose#Document()

Mongoose 的 Document 构造函数

1.9. Mongoose#DocumentProvider()

Mongoose 的 DocumentProvider 构造函数

1.10. Mongoose#Error()

MongooseError 构造函数。

1.11. Mongoose#get(key)

获取 mongoose 选项。

参数：

• key <String>

示例：

mongoose.get('test') // returns the 'test' value

1.12. Mongoose#getPromiseConstructor()

返回当前的 ES6 样式的 promise 构造函数。在 Mongoose 4.x 中，等价于 mongoose.Promise.ES6，但是一旦我们去掉了 .ES6 位，就会改变。

1.13. Mongoose#model(name, [schema], collection, [skipInit])

定义一个模型或检索它。

参数：

• name <String, Function>model name or class extending Model
• [schema]
• collection <String> name (optional, inferred from model name)
• [skipInit] <Boolean> whether to skip initialization (defaults to false)

Models defined on the mongoose instance are available to all connection created by the same mongoose instance.

示例：

var mongoose = require('mongoose');

// 使用 mongoose 示例定义一个 Actor 模型
mongoose.model('Actor', new Schema({ name: String }));

// 创建一个新连接
var conn = mongoose.createConnection(..);

// 检索 Actor 模型
var Actor = conn.model('Actor');

When no collection argument is passed, Mongoose produces a collection name by passing the model name to the utils.toCollectionName method. This method pluralizes the name. If you don't like this behavior, either pass a collection name or set your schemas collection name option.

示例：

var schema = new Schema({ name: String }, { collection: 'actor' });

// or

schema.set('collection', 'actor');

// or

var collectionName = 'actor'
var M = mongoose.model('Actor', schema, collectionName)

Mongoose.prototype.model = function(name, schema, collection, skipInit) {
  var model;
  if (typeof name === 'function') {
    model = name;
    name = model.name;
    if (!(model.prototype instanceof Model)) {
      throw new mongoose.Error('The provided class ' + name + ' must extend Model');
    }
  }

  if (typeof schema === 'string') {
    collection = schema;
    schema = false;
  }

  if (utils.isObject(schema) && !(schema.instanceOfSchema)) {
    schema = new Schema(schema);
  }
  if (schema && !schema.instanceOfSchema) {
    throw new Error('The 2nd parameter to `mongoose.model()` should be a ' +
      'schema or a POJO');
  }

  if (typeof collection === 'boolean') {
    skipInit = collection;
    collection = null;
  }

  // handle internal options from connection.model()
  var options;
  if (skipInit && utils.isObject(skipInit)) {
    options = skipInit;
    skipInit = true;
  } else {
    options = {};
  }

  // look up schema for the collection.
  if (!this.modelSchemas[name]) {
    if (schema) {
      // cache it so we only apply plugins once
      this.modelSchemas[name] = schema;
    } else {
      throw new mongoose.Error.MissingSchemaError(name);
    }
  }

  if (schema) {
    this._applyPlugins(schema);
  }

  var sub;

  // connection.model() may be passing a different schema for
  // an existing model name. in this case don't read from cache.
  if (this.models[name] && options.cache !== false) {
    if (schema && schema.instanceOfSchema && schema !== this.models[name].schema) {
      throw new mongoose.Error.OverwriteModelError(name);
    }

    if (collection) {
      // subclass current model with alternate collection
      model = this.models[name];
      schema = model.prototype.schema;
      sub = model.__subclass(this.connection, schema, collection);
      // do not cache the sub model
      return sub;
    }

    return this.models[name];
  }

  // ensure a schema exists
  if (!schema) {
    schema = this.modelSchemas[name];
    if (!schema) {
      throw new mongoose.Error.MissingSchemaError(name);
    }
  }

  // Apply relevant "global" options to the schema
  if (!('pluralization' in schema.options)) schema.options.pluralization = this.options.pluralization;


  if (!collection) {
    collection = schema.get('collection') || format(name, schema.options);
  }

  var connection = options.connection || this.connection;
  model = this.Model.compile(model || name, schema, collection, connection, this);

  if (!skipInit) {
    model.init();
  }

  if (options.cache === false) {
    return model;
  }

  this.models[name] = model;
  return this.models[name];
};
Mongoose.prototype.model.$hasSideEffects = true;

1.14. Mongoose#Model()

Mongoose Model 构造函数。

1.15. Mongoose#modelNames()

返回一个在 Mongoose 实例上创建的模型名称数组。

返回值：

• <Array>

注意：

不包括使用 connection.model() 创建的模型的名称。

Mongoose.prototype.modelNames = function() {
  var names = Object.keys(this.models);
  return names;
};
Mongoose.prototype.modelNames.$hasSideEffects = true;

1.16. Mongoose()

Mongoose 构造函数。

mongoose 模块的导出对象（exports）是该类的一个实例。大多数应用程序只会使用这个实例。

function Mongoose() {
  this.connections = [];
  this.models = {};
  this.modelSchemas = {};
  // default global options
  this.options = {
    pluralization: true
  };
  var conn = this.createConnection(); // default connection
  conn.models = this.models;

  Object.defineProperty(this, 'plugins', {
    configurable: false,
    enumerable: true,
    writable: false,
    value: [
      [saveSubdocs, { deduplicate: true }],
      [validateBeforeSave, { deduplicate: true }],
      [shardingPlugin, { deduplicate: true }]
    ]
  });
}

1.17. Mongoose#Mongoose()

Mongoose 构造函数

mongoose 模块的导出对象（exports）是该类的一个实例。大多数应用程序只会使用这个实例。

示例：

  var mongoose = require('mongoose');
  var mongoose2 = new mongoose.Mongoose();

1.18. Mongoose#plugin(fn, [opts])

声明一个在所有模式上执行的全局插件。

参数：

• fn <Function> plugin callback
• [opts] <Object> optional options

返回值：

• <Mongoose> this

参见：

• plugins

等效于在创建的每个模式上调用 .plugin(fn)。

Mongoose.prototype.plugin = function(fn, opts) {
  this.plugins.push([fn, opts]);
  return this;
};
Mongoose.prototype.plugin.$hasSideEffects = true;

1.19. function Object() { [native code] }#Promise()

Mongoose Promise 构造函数。

1.20. Mongoose#PromiseProvider()

mongoose promises 的储存层

1.21. Mongoose#Query()

Mongoose Query 构造函数。

1.22. Mongoose#Schema()

Mongoose Schema 构造函数

示例：

var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var CatSchema = new Schema(..);

1.23. Mongoose#SchemaType()

Mongoose SchemaType 构造函数

1.24. Mongoose#set(key, value)

设置 mongoose 的选项

参数：

• key <String>
• value <String, Function, Boolean<

示例：

mongoose.set('test', value) // 设置 'test' 选项为 `value`

mongoose.set('debug', true) // enable logging collection methods + arguments to the console

mongoose.set('debug', function(collectionName, methodName, arg1, arg2...) {}); // use custom function to log collection methods + arguments

Mongoose.prototype.set = function(key, value) {
  if (arguments.length === 1) {
    return this.options[key];
  }

  this.options[key] = value;
  return this;
};
Mongoose.prototype.set.$hasSideEffects = true;

()

为用户空间（user-land）暴露连接状态

Mongoose.prototype.STATES = STATES;

1.25. Mongoose#VirtualType()

Mongoose VirtualType 构造函数

1.26. Mongoose#connection

mongoose 模块的默认连接。

示例：

var mongoose = require('mongoose');
mongoose.connect(...);
mongoose.connection.on('error', cb);

这是为使用 mongoose.model 创建的每个模型所默认使用的连接。

```
<!--endsec-->

##### 返回值：

  * &lt;[Connection][]&gt;

## Mongoose#mongo

Mongoose 使用的[原生的 node-mongodb 驱动器](https://github.com/mongodb/node-mongodb-native)。

<!--sec data-title="源码" data-id="sec_Mongoose_mongo" data-show=true data-collapse=true ces-->
```js
Mongoose.prototype.mongo = require('mongodb');

1.27. Mongoose#mquery

Mongoose 使用的 mquery 查询构建器。

Mongoose.prototype.mquery = require('mquery');

1.28. Mongoose#SchemaTypes

各种各样的 Mongoose SchemaTypes。

注意：

用于向后兼容的 mongoose.Schema.Types 的别名。

Mongoose.prototype.SchemaTypes = Schema.Types;

参见：

• Schema.SchemaTypes

1.29. Mongoose#Types

各种各样的 Mongoose Types.

示例：

var mongoose = require('mongoose');
var array = mongoose.Types.Array;

类型：

• ObjectId
• Buffer
• SubDocument
• Array
• DocumentArray

使用这个暴露来对 ObjectId 类型进行访问，我们可以根据需要构造 id。

var ObjectId = mongoose.Types.ObjectId;
var id1 = new ObjectId;

Mongoose.prototype.Types = Types;

1.30. Mongoose#version

Mongoose 版本

Mongoose.prototype.version = pkg.version;

2. types/array.js

2.1. MongooseArray#$shift()

在每一个文档 save() 的情况下，自动地 shift 这个数组最多一次。

参见：

• mongodb

注意：

Calling this mulitple times on an array before saving sends the same command as calling it once.This update is implemented using the MongoDB $pop method which enforces this restriction.

doc.array = [1,2,3];

 var shifted = doc.array.$shift();
 console.log(shifted); // 1
 console.log(doc.array); // [2,3]

 // no affect
 shifted = doc.array.$shift();
 console.log(doc.array); // [2,3]

 doc.save(function (err) {
   if (err) return handleError(err);

   // we saved, now $shift works again
   shifted = doc.array.$shift();
   console.log(shifted ); // 2
   console.log(doc.array); // [3]
 })

2.2. MongooseArray#remove()

pull 的别名。

参见：

• MongooseArray#pull
• mongodb

2.3. MongooseArray.$pop()

在每一个文档 save() 的情况下，自动地 pop 这个数组最多一次。

参见：

• mongodb

注意：

Calling this mulitple times on an array before saving sends the same command as calling it once.This update is implemented using the MongoDB $pop method which enforces this restriction.

doc.array = [1,2,3];

 var popped = doc.array.$pop();
 console.log(popped); // 3
 console.log(doc.array); // [1,2]

 // no affect
 popped = doc.array.$pop();
 console.log(doc.array); // [1,2]

 doc.save(function (err) {
   if (err) return handleError(err);

   // we saved, now $pop works again
   popped = doc.array.$pop();
   console.log(popped); // 2
   console.log(doc.array); // [1]
 })

2.4. MongooseArray.addToSet([args...])

如果不存在，则将值添加到数组中。

参数：

• [args...]

返回值：

• <Array> the values that were added

示例：

console.log(doc.array) // [2,3,4]
var added = doc.array.addToSet(4,5);
console.log(doc.array) // [2,3,4,5]
console.log(added)     // [5]

2.5. MongooseArray.indexOf(obj)

Return the index of obj or -1 if not found.

参数：

obj <Object> the item to look for

返回值：

• <Number>

2.6. MongooseArray.inspect()

Helper for console.log

2.7. MongooseArray.nonAtomicPush([args...])

Pushes items to the array non-atomically.

参数：

• [args...]

注意：

marks the entire array as modified, which if saved, will store it as a $set operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it.

2.8. MongooseArray.pop()

Wraps Array#pop with proper change tracking.

参见：

• MongooseArray#$pop

注意：

marks the entire array as modified which will pass the entire thing to $set potentially overwritting any changes that happen between when you retrieved the object and when you save it.

2.9. MongooseArray.pull([args...])

Pulls items from the array atomically. Equality is determined by casting the provided value to an embedded document and comparing using

the Document.equals() function.

参数：

• [args...]

参见：

• mongodb

示例：

doc.array.pull(ObjectId)
doc.array.pull({ _id: 'someId' })
doc.array.pull(36)
doc.array.pull('tag 1', 'tag 2')

To remove a document from a subdocument array we may pass an object with a matching _id.

doc.subdocs.push({ _id: 4815162342 })
doc.subdocs.pull({ _id: 4815162342 }) // removed

Or we may passing the _id directly and let mongoose take care of it.

doc.subdocs.push({ _id: 4815162342 })
doc.subdocs.pull(4815162342); // works

The first pull call will result in a atomic operation on the database, if pull is called repeatedly without saving the document, a $set operation is used on the complete array instead, overwriting possible changes that happened on the database in the meantime.

2.10. MongooseArray.push([args...])

Wraps Array#push with proper change tracking.

参数：

• [args...] <Object>

2.11. MongooseArray.set()

Sets the casted val at index i and marks the array modified.

返回值：

• <Array> this

示例：

// given documents based on the following
var Doc = mongoose.model('Doc', new Schema({ array: [Number] }));

var doc = new Doc({ array: [2,3,4] })

console.log(doc.array) // [2,3,4]

doc.array.set(1,"5");
console.log(doc.array); // [2,5,4] // properly cast to number
doc.save() // the change is saved

// VS not using array#set
doc.array[1] = "5";
console.log(doc.array); // [2,"5",4] // no casting
doc.save() // change is not saved

2.12. MongooseArray.shift()

Wraps Array#shift with proper change tracking.

示例：

doc.array = [2,3];
var res = doc.array.shift();
console.log(res) // 2
console.log(doc.array) // [3]

注意：

marks the entire array as modified, which if saved, will store it as a $set operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it.

2.13. MongooseArray.sort()

使用适当的变化跟踪包装了 Array#sort 。

注意：

将整个数组标记为修改，如果保存，将作为 $set 操作存储它，可能会覆盖在检索对象和保存它时发生的任何更改。

2.14. MongooseArray.splice()

Wraps Array#splice with proper change tracking and casting.

注意：

marks the entire array as modified, which if saved, will store it as a $set operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it.

2.15. MongooseArray.toObject(options)

Returns a native js Array.

参数：

• options <Object>

返回值：

• <Array>

2.16. MongooseArray.unshift()

Wraps Array#unshift with proper change tracking.

注意：

marks the entire array as modified, which if saved, will store it as a $set operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it.

3. types/subdocument.js

源码：types/subdocument.js

3.1. Subdocument#ownerDocument()

Returns the top level document of this sub-document.

返回值：

• <Document>

Subdocument.prototype.ownerDocument = function() {
  if (this.$__.ownerDocument) {
    return this.$__.ownerDocument;
  }

  var parent = this.$parent;
  if (!parent) {
    return this;
  }

  while (parent.$parent || parent.__parent) {
    parent = parent.$parent || parent.__parent;
  }
  this.$__.ownerDocument = parent;
  return this.$__.ownerDocument;
};

3.2. Subdocument#parent()

Returns this sub-documents parent document.

Subdocument.prototype.parent = function() {
  return this.$parent;
};

3.3. Subdocument#remove([options], [callback])

Null-out this subdoc

参数：

• [options] <Object>
• [callback] <Function> optional callback for compatibility with Document.prototype.remove

Subdocument.prototype.remove = function(options, callback) {
  if (typeof options === 'function') {
    callback = options;
    options = null;
  }

  registerRemoveListener(this);

  // If removing entire doc, no need to remove subdoc
  if (!options || !options.noop) {
    this.$parent.set(this.$basePath, null);
  }

  if (typeof callback === 'function') {
    callback(null);
  }
};

4. types/embedded.js

源码：types/embedded.js

4.1. EmbeddedDocument#inspect()

Helper for console.log

EmbeddedDocument.prototype.inspect = function() {
  return this.toObject({
    transform: false,
    retainKeyOrder: true,
    virtuals: false,
    flattenDecimals: false
  });
};

4.2. EmbeddedDocument#invalidate(path, err)

Marks a path as invalid, causing validation to fail.

参数：

• path <String> the field to invalidate
• err error which states the reason path was invalid

返回值：

• <Boolean>

EmbeddedDocument.prototype.invalidate = function(path, err, val, first) {
  if (!this.__parent) {
    Document.prototype.invalidate.call(this, path, err, val);
    if (err.$isValidatorError) {
      return true;
    }
    throw err;
  }

  var index = this.__index;
  if (typeof index !== 'undefined') {
    var parentPath = this.__parentArray._path;
    var fullPath = [parentPath, index, path].join('.');
    this.__parent.invalidate(fullPath, err, val);
  }

  if (first) {
    this.$__.validationError = this.ownerDocument().$__.validationError;
  }

  return true;
};

4.3. EmbeddedDocument#ownerDocument()

Returns the top level document of this sub-document.

返回值：

• <Document>

EmbeddedDocument.prototype.ownerDocument = function() {
  if (this.$__.ownerDocument) {
    return this.$__.ownerDocument;
  }

  var parent = this.__parent;
  if (!parent) {
    return this;
  }

  while (parent.__parent || parent.$parent) {
    parent = parent.__parent || parent.$parent;
  }

  this.$__.ownerDocument = parent;
  return this.$__.ownerDocument;
};

4.4. EmbeddedDocument#parent()

Returns this sub-documents parent document.

EmbeddedDocument.prototype.parent = function() {
  return this.__parent;
};

4.5. EmbeddedDocument#parentArray()

Returns this sub-documents parent array.

EmbeddedDocument.prototype.parentArray = function() {
  return this.__parentArray;
};

4.6. EmbeddedDocument#remove([options], [fn])

Removes the subdocument from its parent array.

参数：

• [options] <Object>
• [fn] <Function>

EmbeddedDocument.prototype.remove = function(options, fn) {
  if ( typeof options === 'function' && !fn ) {
    fn = options;
    options = undefined;
  }
  if (!this.__parentArray || (options && options.noop)) {
    fn && fn(null);
    return this;
  }

  var _id;
  if (!this.willRemove) {
    _id = this._doc._id;
    if (!_id) {
      throw new Error('For your own good, Mongoose does not know ' +
          'how to remove an EmbeddedDocument that has no _id');
    }
    this.__parentArray.pull({_id: _id});
    this.willRemove = true;
    registerRemoveListener(this);
  }

  if (fn) {
    fn(null);
  }

  return this;
};

4.7. EmbeddedDocument.markModified(path)

Marks the embedded doc modified.

EmbeddedDocument.prototype.markModified = function(path) {
  this.$__.activePaths.modify(path);
  if (!this.__parentArray) {
    return;
  }

  if (this.isNew) {
    // Mark the WHOLE parent array as modified
    // if this is a new document (i.e., we are initializing
    // a document),
    this.__parentArray._markModified();
  } else {
    this.__parentArray._markModified(this, path);
  }
};

参数：

• path <String> the path which changed

示例：

var doc = blogpost.comments.id(hexstring);
doc.mixed.type = 'changed';
doc.markModified('mixed.type');

5. types/buffer.js

源码：types/buffer.js

5.1. MongooseBuffer.copy(target)

Copies the buffer.

参数：

* target <[Buffer][]>

返回值：

* <[Number][]> The number of bytes copied.

注意：

Buffer#copy does not mark target as modified so you must copy from a MongooseBuffer for it to work as expected. This is a work around since copy modifies the target, not this. *

5.2. MongooseBuffer.equals(other)

Determines if this buffer is equals to other buffer

参数：

• other <Buffer>

返回值：

• <Boolean>

5.3. MongooseBuffer.subtype(subtype)

Sets the subtype option and marks the buffer modified.

参数：

• subtype

参见：

• http://bsonspec.org/#/specification

SubTypes:

var bson = require('bson') bson.BSON_BINARY_SUBTYPE_DEFAULT bson.BSON_BINARY_SUBTYPE_FUNCTION bson.BSON_BINARY_SUBTYPE_BYTE_ARRAY bson.BSON_BINARY_SUBTYPE_UUID bson.BSON_BINARY_SUBTYPE_MD5 bson.BSON_BINARY_SUBTYPE_USER_DEFINED

doc.buffer.subtype(bson.BSON_BINARY_SUBTYPE_UUID);

5.4. MongooseBuffer.toBSON()

Converts this buffer for storage in MongoDB, including subtype

返回值：

• <Binary>

5.5. MongooseBuffer.toObject([subtype])

Converts this buffer to its Binary type representation.

参数：

• [subtype]

返回值：

• <Binary>

参见：

• http://bsonspec.org/#/specification

SubTypes:

var bson = require('bson') bson.BSON_BINARY_SUBTYPE_DEFAULT bson.BSON_BINARY_SUBTYPE_FUNCTION bson.BSON_BINARY_SUBTYPE_BYTE_ARRAY bson.BSON_BINARY_SUBTYPE_UUID bson.BSON_BINARY_SUBTYPE_MD5 bson.BSON_BINARY_SUBTYPE_USER_DEFINED

doc.buffer.toObject(bson.BSON_BINARY_SUBTYPE_USER_DEFINED);

5.6. MongooseBuffer.write()

Writes the buffer.

6. types/objectid.js

源码：types/objectid.js

6.1. ObjectId()

ObjectId type constructor

示例：

var id = new mongoose.Types.ObjectId;

7. types/decimal128.js

源码：types/decimal128.js

7.1. exports()

ObjectId type constructor

示例：

var id = new mongoose.Types.ObjectId;

8. types/documentarray.js

源码：types/documentarray.js

8.1. MongooseDocumentArray.create(obj)

Creates a subdocument casted to this schema.

参数：

• obj <Object> the value to cast to this arrays SubDocument schema

This is the same subdocument constructor used for casting.

8.2. MongooseDocumentArray.id(id)

Searches array items for the first document with a matching _id.

参数：

• id

  返回值：

• the subdocument or null if not found.

示例：

var embeddedDoc = m.array.id(some_id);

8.3. MongooseDocumentArray.inspect()

Helper for console.log

8.4. MongooseDocumentArray.toObject([options])

Returns a native js Array of plain js objects

参数：

• [options] <Object> optional options to pass to each documents toObject method call during conversion

返回值：

• <Array>

注意：

Each sub-document is converted to a plain object by calling its #toObject method.

9. promise.js

源码：promise.js

9.1. Promise#addBack(listener)

Adds a single function as a listener to both err and complete.

参数：

• listener <Function>

返回值：

• <Promise> this

It will be executed with traditional node.js argument position when the promise is resolved.

promise.addBack(function (err, args...) {
  if (err) return handleError(err);
  console.log('success');
})

mpromise#onResolve 的别名。

Deprecated. Use onResolve instead.

9.2. Promise#addCallback(listener)

Adds a listener to the complete (success) event.

参数：

• listener <Function>

返回值：

• <Promise> this

mpromise#onFulfill 的别名。

Deprecated. Use onFulfill instead.

9.3. Promise#addErrback(listener)

Adds a listener to the err (rejected) event.

参数：

• listener <Function>

返回值：

• <Promise> this

  mpromise#onReject 的别名。

Deprecated. Use onReject instead.

9.4. Promise#catch(onReject)

ES6-style .catch() shorthand

参数：

• onReject <Function>

返回值：

• <Promise>

9.5. Promise#end()

Signifies that this promise was the last in a chain of then()s: if a handler passed to the call to then which produced this promise throws, the exception will go uncaught.

参见：

• mpromise#end

示例：

var p = new Promise;
p.then(function(){ throw new Error('shucks') });
setTimeout(function () {
  p.fulfill();
  // error was caught and swallowed by the promise returned from
  // p.then(). we either have to always register handlers on
  // the returned promises or we can do the following...
}, 10);

// this time we use .end() which prevents catching thrown errors
var p = new Promise;
var p2 = p.then(function(){ throw new Error('shucks') }).end(); // <--
setTimeout(function () {
  p.fulfill(); // throws "shucks"
}, 10);

9.6. Promise#error(err)

Rejects this promise with err.

参数：

• err

返回值：

• <Promise> this

If the promise has already been fulfilled or rejected, not action is taken.

Differs from #reject by first casting err to an Error if it is not instanceof Error.

Promise.prototype.error = function(err) {
  if (!(err instanceof Error)) {
    if (err instanceof Object) {
      err = util.inspect(err);
    }
    err = new Error(err);
  }
  return this.reject(err);
};

9.7. Promise#on(event, listener)

Adds listener to the event.

参数：

• event <String>

• listener <Function>

返回值：

• <Promise> this

参见：

• mpromise#on

If event is either the success or failure event and the event has already been emitted, thelistener is called immediately and passed the results of the original emitted event.

9.8. Promise(fn)

Promise constructor.

参数：

• fn <Function> a function which will be called when the promise is resolved that accepts fn(err, ...){} as signature

继承：

• mpromise

事件：

• err: Emits when the promise is rejected

• complete: Emits when the promise is fulfilled

Promises are returned from executed queries.示例：

var query = Candy.find({ bar: true });
var promise = query.exec();

DEPRECATED. Mongoose 5.0 will use native promises by default (or bluebird, if native promises are not present) but still support plugging in your own ES6-compatible promises library. Mongoose 5.0 will notsupport mpromise.

function Promise(fn) {
  MPromise.call(this, fn);
}

9.9. Promise#reject(reason)

Rejects this promise with reason.

参数：

• reason

返回值：

• <Promise> this

参见：

• mpromise#reject

If the promise has already been fulfilled or rejected, not action is taken.

9.10. Promise#resolve([err], [val])

Resolves this promise to a rejected state if err is passed or a fulfilled state if no err is passed.

参数：

• [err] <Error> error or null
• [val] <Object> value to fulfill the promise with

If the promise has already been fulfilled or rejected, not action is taken.

err will be cast to an Error if not already instanceof Error.

注意：

overrides mpromise#resolve to provide error casting.

Promise.prototype.resolve = function(err) {
  if (err) return this.error(err);
  return this.fulfill.apply(this, Array.prototype.slice.call(arguments, 1));
};

9.11. Promise#then(onFulFill, onReject)

Creates a new promise and returns it. If onFulfill or onReject are passed, they are added as SUCCESS/ERROR callbacks to this promise after the nextTick.

参数：

• onFulFill <Function>

• onReject <Function>

返回值：

• <Promise> newPromise

参见：

• promises-A+
• mpromise#then

Conforms to promises/A+ specification.

示例：

var promise = Meetups.find({ tags: 'javascript' }).select('_id').exec();
promise.then(function (meetups) {
  var ids = meetups.map(function (m) {
    return m._id;
  });
  return People.find({ meetups: { $in: ids } }).exec();
}).then(function (people) {
  if (people.length < 10000) {
    throw new Error('Too few people!!!');
  } else {
    throw new Error('Still need more people!!!');
  }
}).then(null, function (err) {
  assert.ok(err instanceof Error);
});

9.12. Promise.complete(args)

Fulfills this promise with passed arguments.

参数：

• args

mpromise#fulfill 的别名。

Deprecated. Use fulfill instead.

9.13. Promise.ES6(resolver)

ES6-style promise constructor wrapper around mpromise.

Promise.ES6 = function(resolver) {
  var promise = new Promise();

  // No try/catch for backwards compatibility
  resolver(
    function() {
      promise.complete.apply(promise, arguments);
    },
    function(e) {
      promise.error(e);
    });

  return promise;
};

参数：

• resolver <Function>

返回值：

• <Promise> new promise

9.14. Promise.fulfill(args)

Fulfills this promise with passed arguments.

参数：

• args

参见：

• https://github.com/aheckmann/mpromise#fulfill

10. virtualtype.js

源码：virtualtype.js

10.1. VirtualType()

VirtualType constructor

This is what mongoose uses to define virtual attributes via Schema.prototype.virtual.

示例：

var fullname = schema.virtual('fullname');
fullname instanceof mongoose.VirtualType // true

function VirtualType(options, name) {
  this.path = name;
  this.getters = [];
  this.setters = [];
  this.options = options || {};
}

10.2. VirtualType#get(fn)

Defines a getter.

参数：

• fn <Function>

返回值：

• this

示例：

var virtual = schema.virtual('fullname');
virtual.get(function () {
  return this.name.first + ' ' + this.name.last;
});

VirtualType.prototype.get = function(fn) {
  this.getters.push(fn);
  return this;
};

10.3. VirtualType#set(fn)

Defines a setter.

参数：

• fn <Function>

返回值：

• this

示例：

var virtual = schema.virtual('fullname');
virtual.set(function (v) {
  var parts = v.split(' ');
  this.name.first = parts[0];
  this.name.last = parts[1];
});

VirtualType.prototype.set = function(fn) {
  this.setters.push(fn);
  return this;
};

10.4. VirtualType#applyGetters(value, scope)

Applies getters to value using optional scope.

参数：

• value <Object>

• scope <Object>

返回值：

• the value after applying all getters

VirtualType.prototype.applyGetters = function(value, scope) {
  var v = value;
  for (var l = this.getters.length - 1; l >= 0; l--) {
    v = this.getters[l].call(scope, v, this);
  }
  return v;
};

10.5. VirtualType#applySetters(value, scope)

Applies setters to value using optional scope.

参数：

• value <Object>

• scope <Object>

返回值：

• the value after applying all setters

VirtualType.prototype.applySetters = function(value, scope) {
  var v = value;
  for (var l = this.setters.length - 1; l >= 0; l--) {
    v = this.setters[l].call(scope, v, this);
  }
  return v;
};

11. utils.js

源码：utils.js

11.1. exports.pluralization

Pluralization rules.

exports.pluralization = [
  [/(m)an$/gi, '$1en'],
  [/(pe)rson$/gi, '$1ople'],
  [/(child)$/gi, '$1ren'],
  [/^(ox)$/gi, '$1en'],
  [/(ax|test)is$/gi, '$1es'],
  [/(octop|vir)us$/gi, '$1i'],
  [/(alias|status)$/gi, '$1es'],
  [/(bu)s$/gi, '$1ses'],
  [/(buffal|tomat|potat)o$/gi, '$1oes'],
  [/([ti])um$/gi, '$1a'],
  [/sis$/gi, 'ses'],
  [/(?:([^f])fe|([lr])f)$/gi, '$1$2ves'],
  [/(hive)$/gi, '$1s'],
  [/([^aeiouy]|qu)y$/gi, '$1ies'],
  [/(x|ch|ss|sh)$/gi, '$1es'],
  [/(matr|vert|ind)ix|ex$/gi, '$1ices'],
  [/([m|l])ouse$/gi, '$1ice'],
  [/(kn|w|l)ife$/gi, '$1ives'],
  [/(quiz)$/gi, '$1zes'],
  [/s$/gi, 's'],
  [/([^a-z])$/, '$1'],
  [/$/gi, 's']
];
var rules = exports.pluralization;

These rules are applied while processing the argument to toCollectionName.

11.2. exports.uncountables

Uncountable words.

exports.uncountables = [
  'advice',
  'energy',
  'excretion',
  'digestion',
  'cooperation',
  'health',
  'justice',
  'labour',
  'machinery',
  'equipment',
  'information',
  'pollution',
  'sewage',
  'paper',
  'money',
  'species',
  'series',
  'rain',
  'rice',
  'fish',
  'sheep',
  'moose',
  'deer',
  'news',
  'expertise',
  'status',
  'media'
];
var uncountables = exports.uncountables;

These words are applied while processing the argument to toCollectionName.

12. drivers/node-mongodb-native/collection.js

源码：drivers/node-mongodb-native/collection.js

12.1. function Object() { [native code] }#$format()

Formatter for debug print args

12.2. function Object() { [native code] }#$print(

Debug print helper

12.3. NativeCollection#getIndexes(callback)

Retreives information about this collections indexes.

参数：

• callback <Function>

13. drivers/node-mongodb-native/connection.js

源码：drivers/node-mongodb-native/connection.js

13.1. NativeConnection#useDb(name)

Switches to a different database using the same connection pool.

参数：

• name <String> The database name

返回值：

• <Connection> New Connection Object

Returns a new connection object, with the new db.

NativeConnection.prototype.useDb = function(name) {
  // we have to manually copy all of the attributes...
  var newConn = new this.constructor();
  newConn.name = name;
  newConn.base = this.base;
  newConn.collections = {};
  newConn.models = {};
  newConn.replica = this.replica;
  newConn.hosts = this.hosts;
  newConn.host = this.host;
  newConn.port = this.port;
  newConn.user = this.user;
  newConn.pass = this.pass;
  newConn.options = this.options;
  newConn._readyState = this._readyState;
  newConn._closeCalled = this._closeCalled;
  newConn._hasOpened = this._hasOpened;
  newConn._listening = false;

  // First, when we create another db object, we are not guaranteed to have a
  // db object to work with. So, in the case where we have a db object and it
  // is connected, we can just proceed with setting everything up. However, if
  // we do not have a db or the state is not connected, then we need to wait on
  // the 'open' event of the connection before doing the rest of the setup
  // the 'connected' event is the first time we'll have access to the db object

  var _this = this;

  if (this.db && this._readyState === STATES.connected) {
    wireup();
  } else {
    this.once('connected', wireup);
  }

  function wireup() {
    newConn.db = _this.db.db(name);
    newConn.onOpen();
    // setup the events appropriately
    listen(newConn);
  }

  newConn.name = name;

  // push onto the otherDbs stack, this is used when state changes
  this.otherDbs.push(newConn);
  newConn.otherDbs.push(this);

  return newConn;
};

13.2. NativeConnection.STATES

Expose the possible connection states.

NativeConnection.STATES = STATES;

14. browser.js

源码：browser.js

14.1. function Object() { [native code] }#Promise()

The Mongoose Promise constructor.

14.2. exports.Document()

The Mongoose browser Document constructor.

14.3. exports.Error()

The MongooseError constructor.

14.4. exports.PromiseProvider()

Storage layer for mongoose promises

14.5. exports.Schema()

The Mongoose Schema constructor

示例：

var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var CatSchema = new Schema(..);

14.6. exports.VirtualType()

The Mongoose VirtualType constructor

14.7. exports#SchemaTypes

The various Mongoose SchemaTypes.

注意：

Alias of mongoose.Schema.Types for backwards compatibility.

exports.SchemaType = require('./schematype.js');

参见：

• Schema.SchemaTypes

14.8. exports#Types

The various Mongoose Types.

示例：

var mongoose = require('mongoose');
var array = mongoose.Types.Array;

类型：

• ObjectId
• Buffer
• SubDocument
• Array
• DocumentArray

Using this exposed access to the ObjectId type, we can construct ids on demand.

var ObjectId = mongoose.Types.ObjectId;
var id1 = new ObjectId;

exports.Types = require('./types');

15. ES6Promise.js

源码：ES6Promise.js

15.1. ES6Promise(fn)

ES6 Promise wrapper constructor.

参数：

• fn <Function> a function which will be called when the promise is resolved that accepts fn(err, ...){} as signature

Promises are returned from executed queries.

示例：

var query = Candy.find({ bar: true });
var promise = query.exec();

DEPRECATED. Mongoose 5.0 will use native promises by default (or bluebird, if native promises are not present) but still support plugging in your own ES6-compatible promises library. Mongoose 5.0 will not support mpromise.

function ES6Promise() {
  throw new Error('Can\'t use ES6 promise with mpromise style constructor');
}

ES6Promise.use = function(Promise) {
  ES6Promise.ES6 = Promise;
};

module.exports = ES6Promise;

15.2. schema.js

源码：schema.js

15.3. Schema#add(obj, prefix)

Adds key path / schema type pairs to this schema.

参数：

• obj <Object>

• prefix <String>

示例：

var ToySchema = new Schema;
ToySchema.add({ name: 'string', color: 'string', price: 'number' });

Schema.prototype.add = function add(obj, prefix) {
  prefix = prefix || '';
  var keys = Object.keys(obj);

  for (var i = 0; i < keys.length; ++i) {
    var key = keys[i];

    if (obj[key] == null) {
      throw new TypeError('Invalid value for schema path `' + prefix + key + '`');
    }

    if (Array.isArray(obj[key]) && obj[key].length === 1 && obj[key][0] == null) {
      throw new TypeError('Invalid value for schema Array path `' + prefix + key + '`');
    }

    if (utils.isObject(obj[key]) &&
        (!obj[key].constructor || utils.getFunctionName(obj[key].constructor) === 'Object') &&
        (!obj[key][this.options.typeKey] || (this.options.typeKey === 'type' && obj[key].type.type))) {
      if (Object.keys(obj[key]).length) {
        // nested object { last: { name: String }}
        this.nested[prefix + key] = true;
        this.add(obj[key], prefix + key + '.');
      } else {
        if (prefix) {
          this.nested[prefix.substr(0, prefix.length - 1)] = true;
        }
        this.path(prefix + key, obj[key]); // mixed type
      }
    } else {
      if (prefix) {
        this.nested[prefix.substr(0, prefix.length - 1)] = true;
      }
      this.path(prefix + key, obj[key]);
    }
  }
};

15.4. Schema#clone()

Returns a deep copy of the schema

返回值：

• the cloned schema

Schema.prototype.clone = function() {
  var s = new Schema(this.paths, this.options);
  // Clone the call queue
  var cloneOpts = { retainKeyOrder: true };
  s.callQueue = this.callQueue.map(function(f) { return f; });
  s.methods = utils.clone(this.methods, cloneOpts);
  s.statics = utils.clone(this.statics, cloneOpts);
  s.query = utils.clone(this.query, cloneOpts);
  s.plugins = Array.prototype.slice.call(this.plugins);
  s._indexes = utils.clone(this._indexes, cloneOpts);
  s.s.hooks = this.s.hooks.clone();
  return s;
};

15.5. Schema#eachPath(fn)

Iterates the schemas paths similar to Array#forEach.

参数：

• fn <Function> callback function

返回值：

• this The callback is passed the pathname and schemaType as arguments on each iteration.

Schema.prototype.eachPath = function(fn) {
  var keys = Object.keys(this.paths),
      len = keys.length;

  for (var i = 0; i < len; ++i) {
    fn(keys[i], this.paths[keys[i]]);
  }

  return this;
};

15.6. Schema#get(key)

Gets a schema option.

参数：