在 SegmentFault，解决技术问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
一线的工程师、著名开源项目的作者们，都在这里：
获取验证码
已有账号？
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
如题，在跟着，写一个博客系统，不过我想把里面用mongodb写的部分改成mongoose的方法。取文章这里遇到了些问题，
原文是这样写的。
Post.getTen = function(name, page, callback) {
//打开数据库
mongodb.open(function (err, db) {
if (err) {
return callback(err);
//读取 posts 集合
db.collection('posts', function (err, collection) {
if (err) {
mongodb.close();
return callback(err);
var query = {};
if (name) {
query.name =
//使用 count 返回特定查询的文档数 total
collection.count(query, function (err, total) {
//根据 query 对象查询，并跳过前 (page-1)*10 个结果，返回之后的 10 个结果
collection.find(query, {
skip: (page - 1)*10,
}).toArray(function (err, docs) {
mongodb.close();
if (err) {
return callback(err);
//解析 markdown 为 html
docs.forEach(function (doc) {
doc.post = markdown.toHTML(doc.post);
callback(null, docs, total);
获得总数是用来判断是否为最后一页的，但是我用mongoose写的话不知道该如何获取查询到查询结果的总数，写到这样不知道如何写了
Post.getFive = function(name,page,callback){
var querystr = {};
querystr.name =
var query = Post.find(querystr).skip((page-1)*5).limit(5);
query.sort({time:-1});
query.exec(function(err,results){
console.log(err);
results.forEach(function (doc) {
doc.post = markdown.toHTML(doc.post);
console.log(total);
callback(null, results, total);
求大神指点下。。。
来源: MongoDB 技术问答
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
Mongoose 里面是使用 Model#count 来获得数量的。看起来你这里的 Post 应该就是个 model 吧，使用 Post.count 加上合适的条件就行了。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
刚好自学碰到，贴一下我写的code
router.get('/', function(req, res) {
var page = req.query.p ? parseInt(req.query.p) : 1;
Posts.count({}, function(err, count) {
Posts.find({}, null, {skip: (page-1)*3, limit: 3}, function(err, posts) {
res.render('index', {
title: '主页',
user: req.session.user,
posts: posts,
page: page,
isFirstPage: page == 1,
isLastPage: (page-1)*3 + posts.length == count,
success: req.flash('success').toString(),
error: req.flash('error').toString()
其实官方文档上有类似的
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：mongoose如何在方法中动态创建collection集合 - CNode技术社区
如题！下面这种方式试过不会生成，除非插入一条数据 但是我不愿意这么做
app.post '/api/collections', (req, res, next)
# 1.创建本业务collection集合
body = _.pick(req.body, 'name', 'identifier', 'attributes', 'description')
unless body.identifier
body.identifier = hashids.encode(new Date().getTime())
console.log body
Collection.save body, (err, obj) -&
return next(err) if err
# 2.根据attributes创建用户业务数据集合
console.log &\n动态生成数据表：#{obj}&
schema = new mongoose.Schema
schema.add(obj.attributes)
model = mongoose.model(obj.identifier, schema) # 生成数据集合
res.status(200).json(obj)
# instance.save (err, obj) -&
return next(err) if err
CNode 社区为国内最专业的 Node.js 开源技术社区，致力于 Node.js 的技术研究。
服务器赞助商为
，存储赞助商为
，由提供应用性能服务。
新手搭建 Node.js 服务器，推荐使用无需备案的Mongoose初使用总结 - 简书
Mongoose初使用总结
连接mongoose
mongoose连接数据库有两种方式第一种：
'use strict';
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/test');
const con = mongoose.
con.on('error', console.error.bind(console, '连接数据库失败'));
con.once('open',()=&{
//成功连接
var mongoose = require('mongoose');
db = mongoose.createConnection('localhost', 'test');
var schema = new mongoose.Schema({ name: String });
var collectionName = 'kittens';
var M = db.model('Kitten', schema, collectionName);
var silence = new M({ name: "Silence"});
silence.save(function(err){
mongoose.createConnection()和mongoose.connect()区别
首先，我们需要定义一个连接，如果你的app只用到一个数据库，你应该使用 mongoose.connect。如果你还需要连接其他数据库，使用mongoose.createConnection。所有的 connect and createConnection 使用 mongodb:// URI, or the parameters host, database, port, options.等参数
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/my_database');
一旦连接，Connection对象会触发open事件，如果你使用 mongoose.connect, Connection对象就是默认的 mongoose.connection，而使用 mongoose.createConnection 返回值就是 Connection.
Mongoose会缓存所有命令直到连接上数据库，这意味着你不必等待它连接MongoDB再定义 models，执行 queries 等。
Mongoose基本概念
Schema: 表定义模板
Model: 类似关系数据库表，封装成具有一些集合操作的对象
instance: 类似记录，由Model创建的实体，也具有影响数据库的操作
//定义一个schema
let Schema = mongoose.Schema({
category:String,
name:String
Schema.methods.eat = function(){
console.log("I've eatten one "+this.name);
//继承一个schema
let Model = mongoose.model("fruit",Schema);
//生成一个document
let apple = new Model({
category:'apple',
name:'apple'
//存放数据
apple.save((err,apple)=&{
if(err) return console.log(err);
apple.eat();
//查找数据
Model.find({name:'apple'},(err,data)=&{
console.log(data);
// from mongoose author
var mongoose = require('mongoose');
var Schema = mongoose.S//引用出来，不需要每次调用 mongoose.Schema()这个丑陋的API.
var blogSchema = new Schema({
author: String,
//直接写法，会被转化成相应的SchemaType
comments: [{ body: String, date: Date }],
//定义SchemaType写法
date: { type: Date, default: Date.now },
hidden: Boolean,
votes: Number,
Schema 之所以能够定义documents, 是因为他可以限制你输入的字段及其类型. mongoose支持的基本类型有:
SchemaType
type属性指定SchemaType类型，不同的SchemaType类型还有其他不同的属性配置
var schema2 = new Schema({
type: String,
lowercase: true // Always convert `test` to lowercase
这是所有类型公有的：
required: 必选验证器。
default: 默认值。Any或function，如果该值是一个函数，则该函数的返回值将用作默认值。
select: boolean值, 指定是否被投影
`validate: 验证器
get: get方法，using Object.defineProperty().
set: set方法 using Object.defineProperty().
alias: 别名。
这里设置索引分两种,一种设在Schema filed, 另外一种设在 Schema.index 里.
//在field 设置
var animalSchema = new Schema({
name: String,
type: String,
tags: { type: [String], index: true }
//在Schema.index中设置.
animalSchema.index({ name: 1, type: -1 });
//1 表示正序, -1 表示逆序
实际上,两者效果是一样的. 看每个人的喜好了. 不过推荐直接在Schema level中设置, 这样分开能够增加可读性. 不过,可以说，当应用启动的时候, ，Mongoose会自动为Schema中每个定义了索引的调用ensureIndex，确保生成索引.并在所有的secureIndex调用成功或出现错误时，在 Model 上发出一个'index'事件。 开发环境用这个很好, 但是建议在生产环境不要使用这个.使用下面的方法禁用ensureIndex。通过将 Schema 的autoIndex选项设置为false或通过将选项config.autoIndex设置为false将连接全局设置为禁用此行为 有可能严重拖慢查询或者创建速度,所以一般而言,我们需要将该option 关闭.
mongoose.connect('mongodb://user:pass@localhost:port/database', { config: { autoIndex: false } });
//真心推荐
mongoose.createConnection('mongodb://user:pass@localhost:port/database', { config: { autoIndex: false } });
animalSchema.set('autoIndex', false);
new Schema({..}, { autoIndex: false }); //懒癌不推荐
// Will cause an error because mongodb has an _id index by default that
// is not sparse
animalSchema.index({ _id: 1 }, { sparse: true });
var Animal = mongoose.model('Animal', animalSchema);
Animal.on('index', function(error) {
// "_id index cannot be sparse"
console.log(error.message);
定义Schema.methods
// 定义一个schema
var freshSchema = new Schema({ name: String, type: String });
// 添加一个fn.
animalSchema.methods.findSimilarTypes = function (cb) {
//这里的this指的是具体document上的this
//this.model 返回Model对象
return this.model ('Animal').find({ type: this.type }, cb);
// 实际上,我们可以通过schema绑定上,数据库操作的所有方法.
// 该method实际上是绑定在 实例的 doc上的
这里同样很简单,只需要 mongoose.model() 即可.
//生成,model 类. 实际上就相当于我们的一个collection
var Animal = mongoose.model('Animal', animalSchema);
var dog = new Animal({ type: 'dog' });
但是, 这里有个问题. 我们在Schema.methods.fn 上定义的方法,只能在 new Model() 得到的实例中才能访问. 那如果我们想,直接在Model上调用 相关的查询或者删除呢？
绑定Model方法
同样很简单,使用 Statics 即可.
// 给model添加一个findByName方法
animalSchema.statics.findByName = function (name, cb) {
//这里的this 指的就是Model
return this.find({ name: new RegExp(name, 'i') }, cb);
var Animal = mongoose.model('Animal', animalSchema);
Animal.findByName('fido', function (err, animals) {
console.log(animals);
Mongoose 还有一个super featrue-- virtual property 该属性是直接设置在Schema上的. 但是,需要注意的是,VR 并不会真正的存放在db中. 他只是一个提取数据的方法.
//schema基本内容
var personSchema = new Schema({
first: String,
last: String
// 生成Model
var Person = mongoose.model('Person', personSchema);
//现在我们有个需求,即,需要将first和last结合输出.
//一种方法是,使用methods来实现
//schema 添加方法
personSchema.methods.getName = function(){
return this.first+" "+this.
// 生成一个doc
var bad = new Person({
name: { first: 'jimmy', last: 'Gay' }
bad.getName();
但是,像这样,仅仅这是为了获取一个属性, 实际上完全可以使用虚拟属性来实现.
//schema 添加虚拟属性
personSchema.virtual('fullName').get(function(){
return this.first+" "+this.
//和上面的方法的结果是完全一致的
而且,经过测试, 使用fn实现的返回,比VR 要慢几十倍. 一下是测试结果:
console.time(1);
bad.getName();
console.timeEnd(1);
console.time(2);
console.timeEnd(2);
2: 0.253ms
最后再补充一下,Schema中初始化的相关参数.Schema参数 在 new Schema([options]) 中,我们需要设置一些相关的参数.
safe: 用来设置安全模式. 实际上,就是定义入库时数据的写入限制. 比如写入时限等.
//使用安全模式. 表示在写入操作时,如果发生错误,也需要返回信息.
var safe =
new Schema({ .. }, { safe: safe });
// 自定义安全模式. w为写入的大小范围. wtimeout设置写入时限. 如果超出10s则返回error
var safe = { w: "majority", wtimeout: 10000 };
new Schema({ .. }, { safe: safe });
toObject: 用来表示在提取数据的时候, 把documents 内容转化为Object内容输出. 一般而言只需要设置getters为true即可.
var schema = new Schema({ name: String });
schema.path('name').get(function (v) {
return v + ' is my name';
schema.set('toObject', { getters: true });
var M = mongoose.model('Person', schema);
var m = new M({ name: 'Max Headroom' });
console.log(m); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom is my name' }
toJSON： 该是和toObject一样的使用. 通常用来把 documents 转化为Object. 但是, 需要显示使用toJSON()方法,
var schema = new Schema({ name: String });
schema.path('name').get(function (v) {
return v + ' is my name';
schema.set('toJSON', { getters: true, virtuals: false });
var M = mongoose.model('Person', schema);
var m = new M({ name: 'Max Headroom' });
console.log(m.toObject()); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom' }
console.log(m.toJSON()); // { _id: 504e0cd7dd992d9be2f20b6f, name: 'Max Headroom is my name' }
// since we know toJSON is called whenever a js object is stringified:
console.log(JSON.stringify(m)); // { "_id": "504e0cd7dd992d9be2f20b6f", "name": "Max Headroom is my name" }
model的创建
model的创建实际上就是方法的copy. 将schema上的方法,copy到model上. 只是copy的位置不一样, 一部分在prototype上, 一部分在constructor中.
//from mongoosejs
var schema = new mongoose.Schema({ name: 'string', size: 'string' });
var Tank = mongoose.model('Tank', schema);
这里,我们一定要搞清楚一个东西. 实际上, mongoose.model里面定义的第一个参数,比如’Tank’, 并不是数据库中的, collection. 他只是collection的单数形式, 实际上在db中的collection是’Tanks’.
想两边名称保持一致，可参考
model 的子文档操作
本来mongodb是没有关系的. 但是, mongoose提供了children字段. 让我们能够轻松的在表间建立关系. 现在,我们来创建一个子域:
var childSchema = new Schema({ name: 'string' });
var parentSchema = new Schema({
children: [childSchema]
//指明sub-doc的schema
//在创建中指明doc
var Parent = mongoose.model('Parent', parentSchema);
var parent = new Parent({ children: [{ name: 'Matt' }, { name: 'Sarah' }] })
parent.children[0].name = 'Matthew';
parent.save(callback);
现在, 我们就已经创建了3个table. 一个parent 包含了 两个child 另外,如果我们想要查询指定的doc。 则可以使用 id()方法.
var doc = parent.children.id(id);
子文档的CRUD, 实际上就是数组的操作, 比如push,unshift,remove,pop,shift等
parent.children.push({ name: 'Liesl' });
mongoose还给移除提供了另外一个方法–remove:
var doc = parent.children.id(id).remove();
如果你忘记添加子文档的话，可以在外围添加, 但是字段必须在Schema中指定
var newdoc = parent.children.create({ name: 'Aaron' });
document的CRUD操作
document 的创建 关于document的创建,有两种方法, 一种是使用document实例创建,另外一种是使用Model类创建.
document的创建
var Tank = mongoose.model('Tank', yourSchema);
var small = new Tank({ size: 'small' });
//使用实例创建
small.save(function (err) {
if (err) return handleError(err);
//使用Model类创建
Tank.create({ size: 'small' }, function (err, small) {
if (err) return handleError(err);
document的查询
Mongoose查找文档很容易，它支持MongoDB的丰富的查询语法。 可以使用每个models find，findById，findOne或where 等静态方法进行查找文档。事实上,在mongoose中,query数据 提供了两种方式.
callback: 使用回调函数, 即, query会立即执行,然后返回到回调函数中.
Person.findOne({ 'name.last': 'Ghost' }, 'name occupation', function (err, person) {
if (err) return handleError(err);
// get data
query: 使用查询方法,返回的是一个Query对象. 该对象是一个Promise, 所以可以使用 chain 进行调用.最后必须使用exec(cb)传入回调进行处理. cb 是一个套路, 第一个参数永远是err. 第二个就是返回的数据。
Tank.find({ size: 'small' }).where('createdDate').gt(oneYearAgo).exec(callback);
以下两种等价写法：
// With a JSON doc
occupation: /host/,
'name.last': 'Ghost',
age: { $gt: 17, $lt: 66 },
likes: { $in: ['vaporizing', 'talking'] }
limit(10).
sort({ occupation: -1 }).
select({ name: 1, occupation: 1 }).
exec(callback);
// Using query builder
find({ occupation: /host/ }).
where('name.last').equals('Ghost').
where('age').gt(17).lt(66).
where('likes').in(['vaporizing', 'talking']).
limit(10).
sort('-occupation').
select('name occupation').
exec(callback);
Query Helpers
你能够添加 query helper functions,跟定义在Schema实例方法一样，但是返回query对象作为mongoose queries使用（说句白了就是封装mongoose查询方法）. Query helper methods 使你能够扩展mongoose's chainable query builder API.
animalSchema.query.byName = function(name) {
return this.find({ name: new RegExp(name, 'i') });
var Animal = mongoose.model('Animal', animalSchema);
Animal.find().byName('fido').exec(function(err, animals) {
console.log(animals);
上面4个API, 3个使用方式都是一样的, 另外一个不同的是where. 他一样是用来进行query. 只是,写法和find系列略有不同.
where简介 where的API为: Model.where(path, [val]) path实际上就是字段, 第二个参数.val表示可以用来指定,path = val的数据内容, 你也可以不写, 交给后面进行筛选. 看一下对比demo吧:
User.find({age: {$gte: 21, $lte: 65}}, callback);
User.where('age').gte(21).lte(65).exec(callback);
从上面的query中,我们可以看到有许多fn, 比如gte,lte,$gte,$lte. 这些是db提供给我们用来查询的快捷函数. 我们可以参考, mongoose给的参考:
另外还有一些游标集合的处理方法: 常用的就3个, limit,skip,sort.
limit:用来获取限定长度的内容.
query.limit(20); //只返回前20个内容
skip: 返回，跳过指定doc后的值.
query.skip(2);
sort: 用来设置根据指定字段排序. 可以设置为1:升序, -1:降序.
query.sort({name:1,age:-1});
实际上, 关于query,我们需要了解的也就差不多了.
document删除
reomve操作仅在通过回调时执行。 要强制执行没有回调，您必须先调用remove（），然后使用exec（）方法执行它。我们可以在document上执行remove方法也可以在Model上。
Model.find().remove({ name: 'Anne Murray' }, callback)
Model.remove({ name: 'Anne Murray' }, callback)
//没有添加回调情况
Model.find().remove({ name: 'Anne Murray' }).remove(callback)
Model.remove({ name: 'Anne Murray' }).exce(callback)
document更新
使用Model.update([(conditions, doc, [options], [callback])]不返回更新对象到应用程序。如果要更新数据库中的单个文档并将其返回到应用程序，请改用findOneAndUpdate。
参数说明：
conditions: 就是query. 通过query获取到指定doc
doc: 就是用来替换doc内容的值.
options: 这块需要说一些下.safe (boolean) 是否开启安全模式 (default for true)upsert (boolean) 如果没有匹配到内容,是否自动创建 ( default for false)multi (boolean) 如果有多个doc,匹配到,是否一起更改 ( default for false)strict (boolean) 使用严格模式(default for false)overwrite (boolean) 匹配到指定doc,是否覆盖 (default for false)runValidators (boolean): 表示是否用来启用验证. 实际上,你首先需要写一个验证. 关于如果书写,验证大家可以参考下文, validate篇(default for false)
new（使用findOneAndUpdate时才有参数）：bool - 如果为true，则返回修改后的文档而不是原始文件。 默认为false。
Model.update({age:18}, { $set: { name: 'jason borne' }}, {multi:true}, function (err, raw) {
if (err) return handleError(err);
console.log('raw 就是mongodb返回的更改状态的falg ', raw);
//比如: { ok: 1, nModified: 2, n: 2 }
其中的$set是,用来指明更新的字段。
Validation
验证器在SchemaType中定义。Validation 是一种中间件，Mongoose 触发 validation 同 a pre('save')钩子一样 。你能够手动触发 validation 通过doc.validate(callback) or doc.validateSync()。
cat.save(function(error) {
//自动执行,validation
//手动触发 validatio
//上面已经设置好user的字段内容.
user.validate(function(error) {
//error 就是验证不通过返回的错误信息
assert.equal(error.errors['phone'].message,
'555.0123 is not a valid phone number!');
内置验证器
Mongoose 有一些列内置验证器.
所有的SchemaTypes都有required验证器
min,max: 用来给Number类型的数据设置限制.var breakfastSchema = new Schema({
type: Number,
min: [6, 'Too few eggs'],
enum,match,maxlength,minlength: 这些验证是给string类型的. enum 就是枚举,表示该属性值,只能出席那那些. match是用来匹配正则表达式的. maxlength&minlength 显示字符串的长度.new Schema({
type: String,
enum: ['Coffee', 'Tea']
type: String,
match:/^a/,
maxlength:12,
minlength:6
自定义验证器
如果内置验证器不够，您可以定义自定义验证器以满足您的需要。
// 创建验证器
function validator (val) {
return val == 'something';
new Schema({ name: { type: String, validate: validator }});
// 附带自定义错误信息
var custom = [validator, 'Uh oh, {PATH} does not equal "something".']
new Schema({ name: { type: String, validate: custom }});
//添加多验证器
var many = [
{ validator: validator, msg: 'uh oh' }
, { validator: anotherValidator, msg: 'failed' }
new Schema({ name: { type: String, validate: many }});
// 直接通过SchemaType.validate方法定义验证器:
var schema = new Schema({ name: 'string' });
schema.path('name').validate(validator, 'validation of `{PATH}` failed with value `{VALUE}`');
验证错误对象
验证失败后返回的错误包含一个包含实际ValidatorError对象的错误对象。 每个ValidatorError都有kind，path，value和message属性。
var toySchema = new Schema({
color: String,
name: String
var Toy = db.model('Toy', toySchema);
var validator = function (value) {
return /blue|green|white|red|orange|periwinkle/i.test(value);
Toy.schema.path('color').validate(validator,
'Color `{VALUE}` not valid', 'Invalid color');
var toy = new Toy({ color: 'grease'});
toy.save(function (err) {
// err is our ValidationError object
// err.errors.color is a ValidatorError object
assert.equal(err.errors.color.message, 'Color `grease` not valid');
assert.equal(err.errors.color.kind, 'Invalid color');
assert.equal(err.errors.color.path, 'color');
assert.equal(err.errors.color.value, 'grease');
assert.equal(err.name, 'ValidationError');
更新验证器
在Model.update那一节有个参数–runValidators. 还没有详细说. 这里, 展开一下. 实际上, validate一般只会应用在save上, 如果你想在update使用的话, 需要额外的trick，而runValidators就是这个trick.Mongoose还支持update（）和findOneAndUpdate（）操作的验证。 在Mongoose 4.x中，更新验证器默认关闭 - 您需要指定runValidators选项。
var opts = { runValidators: true };
Test.update({}, update, opts, function(error) {
//额外开启runValidators的验证
// There will never be a validation error here
更多验证器用法请参考
population
ongodb 本来就是一门非关系型数据库。 但有时候,我们又需要联合其他的table进行数据查找。 mongoose提供的 population. 用来连接多表数据查询. 一般而言, 我们只要提供某一个collection的_id , 就可以实现完美的联合查询. population 用到的关键字是: ref 用来指明外联的数据库的名字. 一般,我们需要在schema中就定义好.
var mongoose = require('mongoose')
, Schema = mongoose.Schema
var personSchema = Schema({
stories : [{ type: Schema.Types.ObjectId, ref: 'Story' }]
var storySchema = Schema({
_creator : { type: Number, ref: 'Person' },
: [{ type: Number, ref: 'Person' }]
= mongoose.model('Story', storySchema);
var Person = mongoose.model('Person', personSchema);
Note: ObjectId, Number, String, and Buffer are valid for use as refs.
使用populate query方法进行关联
.findOne({ title: 'Once upon a timex.' })
.populate('_creator')
.exec(function (err, story) {
if (err) return handleError(err);
console.log('The creator is %s', story._creator.name);
// prints "The creator is Aaron"
mongoose里的中间件,有两个, 一个是pre, 一个是post.
pre: 在指定方法执行之前绑定。 中间件的状态分为 parallel和series.
post: 相当于事件监听的绑定
这里需要说明一下, 中间件一般仅仅只能限于在几个方法中使用. (但感觉就已经是全部了)
doc 方法上: init,validate,save,
model方法上: count,find,findOne,findOneAndRemove,findOneAndUpdate,update
我们来看一下,pre中间件是如何绑定的.
var schema = new Schema(..);
schema.pre('save', function(next) {
// do stuff
next(); //执行完毕，执行下一中间件
var schema = new Schema(..);
// 设置第二参数为true，意味这是一个并行中间件
// as the second parameter if you want to use parallel middleware.
schema.pre('save', true, function(next, done) {
// calling next kicks off the next middleware in parallel
setTimeout(done, 100);
post会在指定事件后触发,就像事件监听器一样，post钩子没什么控制流程，即它是异步的。
schema.post('save', function(doc) {
//在save完成后 触发.
console.log('%s has been saved', doc._id);
当save方法调用时, 便会触发post绑定的save事件.假如你绑定了多个post。 也可以需要指定一下中间件顺序.
// Takes 2 parameters: this is an asynchronous post hook
schema.post('save', function(doc, next) {
setTimeout(function() {
console.log('post1');
// Kick off the second post hook
// Will not execute until the first middleware calls `next()`
schema.post('save', function(doc, next) {
console.log('post2');