参考：博客 https://www.cnblogs.com/chentianwei/p/10268346.html
参考： mongoose官网（https://mongoosejs.com/docs/models.html）
参考： 英文：Boosting Node.js和MongoDB with Mongoose
简介：mongoose
Mongoose is a fully developed object document mapping (ODM) library for Node.js and MongoDB.
ODM的概念对应sql的ORM,就是ruby on rails中的activerecord那因层。
activerecord包括migrations, Validations, associations, Query interface, 对应mvc框架中的Models。
ORM， Object-Relational Mappiing。
ODM的作用，定义数据库的数据格式schema, 然后通过它取数据，把数据库中的document映射成程序中的一个对象。这个对象有save, update的系列方法，有tilte, author等系列属性。
在调用这些方法时，odm会根据你调用时使用的条件，转化成mongoDb Shell语言，帮你发送出去。
自然，在程序内使用链式调用，比手写数据库语句更灵活也方便。
例子：
//先安装好MongoDb和Node.js $ npm install mongoose // getting-started.js var mongoose = require('mongoose'); mongoose.connect('mongodb://localhost:27017/test'); db.on('error', console.error.bind(console, "connection error")) db.once('open', function() { //当连接成功后，写Schema, model, 写实例并保存到数据库。 })
在db.once内的例子1
var userSchema = new mongoose.Schema({ user: { username: String, password: String } }) var User = mongoose.model('user', userSchema) var frank = new User({ user: { username: 'Frank', password: '123456' } }) frank.save((err, frank) => { console.log('save success!') console.log(frank.user) })
在db.once()的例子2
//构建一个Schema var kittySchema = new mongoose.Schema({ name: String }); // 写一个方法 kittySchema.methods.speak = function () { var greeting = this.name ? "Meow name is " + this.name : "I don't have a name"; console.log(greeting); } // 生成一个model var Kitten = mongoose.model('Kitten', kittySchema); // 实例化一个对象 var fluffy = new Kitten({ name: 'fluffy' }); // 通过mongoose写入数据库 fluffy.save((err, fluffy) => { if (err) { return console.error(err) } fluffy.speak() })
⚠️：此时已经将fluffy对象保存到mongodb://localhost:27017/test的Kitten model内。
即将一个document，保存到test数据库的kittens collection中。
model自动创建了kittens这个collection。（自动添加了s）
⚠️注意：此时mongoDb还没有创建kittens
在创建一个实例并执行save方法，test数据库才会创建了kittens collections和documents。
可以对比使用node.js mongodb driver的代码。
var MongoClient = require('mongodb').MongoClient, assert=require('assert'); var url = 'mongodb://localhost:27017/myproject'; MongoClient.connect(url,function(err,db){ assert.equal(null,err); console.log("成功连接到服务器"); insertDocuments(db,function(){ db.close(); }); // db.close(); }); var insertDocuments = function(db,callback){ var collection = db.collection('documents'); collection.insertMany([ {a:1}, {a:2}, {a:3} ],function(err,result){ assert.equal(err,null); assert.equal(3,result.result.n); assert.equal(3,result.ops.length); console.log("成功插入3个文档到集合！"); callback(result);
});
}
上面代码是专为Node.js提供的驱动程序代码和mongDB shell语言类似。
而，用mongoose定位于使用关系型的数据结构schema，来构造你的app data。
它包括内置的类型构件， 验证， 查询，业务逻辑勾子和更多的功能，开箱即用out of the box!
mongoose把你使用Node.js驱动代码自己写复杂的验证，和逻辑业务的麻烦，简单化了。
mongoose建立在MongoDB driver之上，让程序员可以model 化数据。
二者各有优缺点：
mongoose需要一段时间的学习和理解。在处理某些特别复杂的schema时，会遇到一些限制。
但直接使用Node.js的驱动代码，在你进行数据验证时会写大量的代码，而且会忽视一些安全问题。
Node.js practical 第七章
不喜欢使用mongoose进行复杂的query，而是使用native driver。
Mongoose的缺点是某些查询的速度较慢。
当然Mongoose的优点很多。因为ODM(object document mapping)是现代软件编程的重要部分！
特别是企业级的engineering。
主要优势，就是从database中，提取每件事：程序代码只和object和它们的methods交互。
ODM允许指定：不同类型的对象和把业务逻辑放在类内（和那些对象相关）之间的关系relationships.
另外，内建的验证和类型type casting可以扩展和客制。
当Mongoose和Express.js一起使用时， Mongoose让stack真正地拥护MVC理念。
Mongoose 使用类似Mongo shell, native MongoDB driver的交互方式。
Buckle up！本章将要讨论：
- Mongoose installation
- Connection establishment in a standalone Mongoose script
- Mongoose schemas
- Hooks for keeping code organized
- Custom static and instance methods
- Mongoose models
- Relationships and joins with population
- Nested documents
- Virtual fields
- Schema type behavior amendment
- Express.js + Mongoose = true MVC
安装
var mongoose = require('mongoose'); mongoose.connect('mongodb://localhost:27017/test', {useNewUrlParser: true}); //一个mongoose连接实例 var db = mongoose.connection; db.once('open', () => { //... })
和native driver不一样，我们无需等待established connection， 只需要把所有的代码放入open()回调内。
不放入open()也可以，默认使用buffer。使用open()，确保连接了服务器。
⚠️官方文档原文的解释：
Mongoose lets you start using your models immediately, without waiting for mongoose to establish a connection to MongoDB.
无论是否连接上服务器的MongoDB数据库，都可以马上使用model。
mongoose.connect('mongodb://localhost:27017/myapp', {useNewUrlParser: true});
var Schema = mongoose.Schema
var MyModel = mongoose.model('Test', new Schema({ name: String })); // Works MyModel.findOne(function(error, result) { /* ... */ });
That's because mongoose buffers model function calls internally. This buffering is convenient, but also a common source of confusion. Mongoose will not throw any errors by default if you use a model without connecting.
这是因为mongoose内部地缓冲了模型函数调用。这个缓冲非常的方便，但也是一个常见的source困惑。
因为如果在没有连接的情况下，你使用model，Mongoose默认不会抛出❌，
//一个脚本 const mongoose = require('mongoose') var MyModel = mongoose.model('Test', new Schema({ name: String})); //查询的代码会挂起来，指定mongoose成功的连接上。 MyModel.findOne(function(error, result) { /*...*/}); setTimeout(function() { mongoose.connect('mongodb://localhost:27017/myapp', {useNewUrlParser: true}) }, 6000)
在一个mongoose脚本建立一个连接
连接的URI结构：（一个string）
mongodb://username:password@host:port/database_name
默认可以如下使用，host是localhost, port是27017, 数据库名字是test, 不设置username和password:
mongoose.connect('mongodb://localhost:27017/test', {useMongoClient: true})
mongoose.Promise = global.Promise
Promise这行让mongoose可以使用native ES6 promise 。也可以使用其他的promise implementation 。
Mongoose.prototype.Promise //The Mongoose Promise constructor。
Options对象
connect(url, options)。 options是一个对象，里面是关于连接的属性设置。具体见官方文档。完全支持原生Node.js driver。
Model
下一步： 一个重要的差别（不同于Mongoskin和其他轻量型MongoDB库）：
创建一个model, 使用model()函数并传递一个string和一个schema
const Book = mongoose.model("Book", {name: String})
⚠️这里没有使用new mongoose.Schema()
现在配置语句结束，我们创建a document代表Book model 的实例:
const oneBook = new Book({name: 'Practical Node.js'})
Mongoose documents有非常方便的内置方法：validate, isNew, update
(https://mongoosejs.com/docs/api.html#Document)
⚠️留心这些方法只能用在document上，不能用在collection或model上。
docuement是a model的实例， 而a model有点抽象，类似real MongoDB collection。
但是， 它由一个schema支持, 并且作为一个Node.js class（及额外的方法和属性）存在。
Models are fancy constructors compiled from Schema definitions.
通常，我们不直接地使用Mongoose collections， 我们只通过models操作数据。
一些主要的model方法和native MongDB driver类似： find(), insert(), save()等等。
为了把一个docuemnt存入数据库，使用document.save()
这个方法是异步的asynchronous。因此添加一个callback或者promise或者async/await函数。
执行下面的脚本代码⚠️先打开MongoDB,server。
const mongoose = require('mongoose')
mongoose.connect('mongodb://localhost:27017/test')
mongoose.Promise = global.Promise
const Book = mongoose.model("Book", {name: String})
const oneBook = new Book({name: "Hello world!"})
oneBook.save((err, result) => {
if (err) {
console.err(err)
process.exit(1)
} else {
console.log("Saved:", result)
process.exit(0)
}
})
Mongoose Schemas
Everything in Mongoose starts with a Schema. Each schema maps to a MongoDB collection and defines the shape of the documents within that collection.
Mongoose开始于一个schema. 每个scheme映射到一个MongoDB collection并定义这个collection中的document的外形。
var mongoose = require('mongoose'); var blogSchema = new mongoose.Schema({ title: String, comments: [{body: String, date: Date}], date: { type: Date, default: Date.now}, hidden: Boolean }) //add()方法，用于添加属性，参数是一个key/value对象, 或者是另一个Schema. //add()可以链式调用。 blogSchema.add({author: String})
每个key在我们的documents内定义了一个属性并给予一个相关的SchemaType。
key也可以是嵌套的对象。
SchemaTypes:
- String, Number, Date, Boolean
- Buffer: a Node.js binary type(图片images, PDFs, archives等等)
- Mixed： 一种"anything goes"类型。任意类型的数据
- ObjectId： _id key 的类型。
- Array
- map
Schema不只定义document的结构和属性，也定义document的实例方法，静态Model方法， 混合的compond indexes, 文档hooks 调用middleware。
创建model
为了使用我们的schema定义，需要转化blogSchema进入一个Model:
var Blog = mongoose.model('Blog', blogSchema)
Models的实例是documents。Documents有内建的实例方法。
Instance methods
通过schema定义客制化的实例方法：
var animalSchema = new Schema({ name: String, type: String }) // 分配一个函数给methods对象 animalSchema.methods.findSimilarTypes = function(callback) { return this.model("Animal").find({ type: this.type }, callback) }
var Animal = mongoose.model('Animal', animalSchema) var dog = new Animal({type: 'dog'}) // 存入数据库
dog.save((err, dog) => { console.log("save success!") }) // dog document使用自定义的方法 dog.findSimilarTypes(function(err, dogs) { console.log("yes", dogs); // yes [ { _id: 5c45ba13aaa2f74d3b624619, type: 'dog', __v: 0 } ] });
Statics
给一个Model增加一个静态方法。
把一个函数分配给animalSchema的statics对象。
如果把一个Model看成一个类，那么静态方法就是这个类的类方法。
animalSchema.statics.findByName = function(name, callback) { return this.find({name: new RegExp(name, "i") }, callback) } var Animal = mongoose.model("Aniaml", animalSchema) Animal.findByName("fido", function(err, animals) { console.log("result: ", animals) })
⚠️，声明statics，不能使用箭头函数。因为箭头函数明确地防止绑定this。
也可以使用Schema.static(name, funtion)方法
var schema = new mongoose.Schema(..); schema.static('findByName', function(name, callback) => { return this.find({name: name}, callback) })
使用{name: fn, name:fun, ...}作为唯一参数：
如果把一个hash（内含多个name/fn 对儿），作为唯一的参数传递给static(), 那么每个name/fn对儿将会被增加为statics静态方法。
bookSchema.static({ // Static methods for generic, not instance/document specific logic
getZeroInventoryReport: function(callback) {
// Run a query on all books and get the ones with zero inventory
// Document/instance methods would not work on "this"
return callback(books)
},
getCountOfBooksById: function(bookId, callback){
// Run a query and get the number of books left for a given book
// Document/instance methods would not work on "this"
return callback(count)
}
})
Query Helpers
可以增加query helper functions, 类似实例方法（❌？这句不是很明白，哪里类似了？），
但是for mongoose queries。
Query helper methods 让你扩展mongoose的链式查询builder API。chainable query builder API.
animalSchema.query.byName = function(name) { return this.where({ name: new RegExp(name, 'i') }); }; var Animal = mongoose.model('Animal', animalSchema); Animal.find().byName('fido').exec(function(err, animals) { console.log(animals); });
⚠️由上可见query helper方法是Model调用的。所以原文 like instance methods 这句不明白。
indexes
MongDB支持第二个indexes.
使用mongoose，定义indexes的方法有2个：
- 在定义一个Schema时
- 使用Schema对象的index()方法。（主要用于组合式索引）
var animalSchema = new mongoose.Schema({ name: String, type: String, tags: { type: [String], index: true} }) animalSchema.index({ name: 1, type: -1})
Virtuals
document的一个属性。
Options
Schemas有一些选项配置，可以用构建起或者用set()
new mongoose.Schema({..}, options) // or var schema = new mongoose.Schema({..}) schema.set(option, value)
Pluggable
Mongoose schemas是插件方式的， 即可以通过其他程序的schemas进行扩展。
(具体使用点击连接)
Hooks for Keeping Code Organized
假如：在有大量关联的对象的复杂应用内，我们想要在保存一个对象前，执行一段逻辑。
使用hook，来储存这段逻辑代码是一个好方法。例如，我们想要在保存一个book document前上传一个PDF到web site：
//在一个schema上使用pre()钩子：
booSchema.pre('save', (next) => { // Prepare for saving // Upload PFD return next() })
pre(method, [options], callback)
第一个参数是method的名字
⚠️：钩子和方法都必须添加到schemas上，在编译他们到models 之前。也就是说，在调用mongoose.model()之前。
官方guide: SchemaTypes摘要
SchemaTypes处理definition of path defaults ， 验证， getters, setters, 查询的默认field selection， 和Mongoose document属性的其他一些普遍特征。
你可以把一个Mongoose Schema看作是Mongoose model的配置对象。
于是，一个SchemaType是一个配置对象，作为一个独立的属性。
const schema = new Schema({ name: String }); schema.path('name') instanceof mongoose.SchemaType; // true schema.path('name') instanceof mongoose.Schema.Types.String; // true schema.path('name').instance; // 'String'
// 一个userSchema的userSchema.path("name"): SchemaString { enumValues: [], regExp: null, path: 'name', instance: 'String', validators: [], getters: [], setters: [], options: { type: [Function: String] }, _index: null }
我觉得：一个path类似关系型数据库中的table中的一个field定义。
所以一个SchemaType，表达了一个path的数据类型， 它是否是getters/setters的模式。
一个SchemaType不等于一个Type。它只是Mongoose的一个配置对象。
mongoose.ObjectId !== mongoose.Types.ObjectId
它只是在一个schema内，对一个path的配置。
常用的SchemaTyps:
var schema = new mongoose.Schema({ name: String, binary: Buffer, living: Boolean, updated: { type: Date, default: Date.now}, age: { type: Number, min: 18, max: 65}, mixed: Schema.Types.Mixed, _someId: Schema.Types.ObjectId, array: [] })
数组的SchemaTypes:
var schema = new Schema({ ofString: [String], ofNumber: [Number], ofDates: [Date], ofBuffer: [Buffer], ofBoolean: [Boolean], ofMixed: [Schema.Types.Mixed], ofObjectId: [Schema.Types.ObjectId], ofArrays: [[]], ofArrayOfNumbers: [[Number]],
//嵌套对象 nested: { stuff: { type: String, lowercase: true, trim: true} }, map: Map, mapOfString: { type: Map, of: String } })
SchemaType Options:
var schema1 = new Schema({ test: String // `test` is a path of type String }); var schema2 = new Schema({ // The `test` object contains the "SchemaType options" test: { type: String, lowercase: true } // `test` is a path of type string });
你可以增加任何属性(你想要给你的SchemaType options)。 有许多插件客制化SchemaType options。
Mongoose有几个内置的SchemaType options(具体见https://mongoosejs.com/docs/schematypes.html)
indexes
可以用schema type options定义MongoDB indexes:
var schema2 = new Schema({ test: { type: String, index: true, unique: true // Unique index. If you specify `unique: true` // specifying `index: true` is optional if you do `unique: true` } });
不同的SchemaType有不同的options，具体见官方guide。
Mongoose Models
正如许多ORMs/ODMs, 在mongoose中，cornerstone object is a model。对象的基石是模块。
把一个schema编译进入一个model, 使用:
mongoose.model(name, schema)
第一个参数name，是一个字符串，大写字母开头，通常这个string和对象字面量（声明的变量名）一样。
默认，Mongoose会使用这个model name的复数形式去绑定到一个collection name。
Models用于创建documents(实际的data)。使用构建器:
new ModelName(data)
Models又内建的静态类方法类似native MongoDB方法，如find(), findOne(), update(), insertMany()
一些常用的model 方法：
- Model,create(docs) 等同new Model(docs).save()
- Model.remove(query, [callback(error)])。不能使用hooks。
- Model.find(query, [fields], [options], [callback(error, docs)])
- Model.update()
- Model.populate(docs, options, [callback(err, doc)]), 填入。
- Model.findOne
- Model.findById
注意⚠️，一部分model方法不会激活hooks， 比如deleteOne()，remove()。他们会直接地执行。
最常用的实例方法：
- save()
- toJSON([option]): 把document转化为JSON
- toObject(): 把document转化为普通的JavaScript对象。
- isModified([path]): True/false
- doc.isNew: True/false
- doc.id: 返回document id
- doc.set()：参数包括path, val, [type], ⚠️path其实就是field名字key/value对儿的key。
- doc.validate(): 手动地检测验证（自动在save()前激活）
大多数时候，你需要从你的document得到数据。
使用res.send()把数据发送到一个客户端。
document对象需要使用toObject()和toJSON()转化格式，然后再发送。
Document
Retrieving
具体见：querying一章。
updating
可以使用findById(), 然后在回调函数内修改查询到的实例的属性值。
Tank.findById(id, function (err, tank) { if (err) return handleError(err); tank.size = 'large'; //或者使用tank.set({ size: 'large' }) tank.save(function (err, updatedTank) { if (err) return handleError(err); res.send(updatedTank); }); });
如果只是想要把新的数据更新到数据库，不返回，则可以使用Model#updateOne()
Tank.update({_id: id}, { $set: {size: 'large'}}, callback)
如果如findById加上save(),返回新的数据，有更方便的方法： findByIdAndupdate()
配合使用res.send()
Tank.findByIdAndUpdate(id, { $set: { size: 'large' }}, { new: true }, function (err, tank) {
if (err) return handleError(err);
res.send(tank);
});
⚠️，findByIdAndUpdate不会执行hooks或者验证，所以如果需要hooks和full documente validation，用第一种query然后save() it。
Validating
Documents在被保存前需要验证，具体见validation
重写
.set(doc)方法，参数是另一document的话，相当于重写。
Relationships and Joins with Population
使用Model.populate()或者 Query.populate()
虽然，Node开发者不能查询Mongo DB（on complex relationships）, 但是通过Mongoose的帮助，开发者可以在application layer做到这点。
在大型的程序中，documents之间又复杂的关系，使用mongoose就变得很方便了。
例如，在一个电子商务网站，一个订单通过产品id，关联产品。为了得到更多的产品信息，开发者需要写2个查询： 一个取order,另一个取订单的产品。
使用一个Mongoose query就能做到上面的2个查询的功能。
Populate
Mongoose通过连接订单和产品让2者的关系变得简单：Mongoose提供的一个功能，population。
这里population涉及的意思类似related,即相关的，有联系的。
populations是关于增加更多的data到你的查询，通过使用relationships。
它允许我们从一个不同的collection取数据来fill填document的一部分。
比如我们有posts和users，2个documents。Users可以写posts。这里有2类方法实现这个写功能：
- 使用一个collection，users collection有posts 数组field。这样就只需要一个单独的query，但是这种结构导致某些方法的被限制。因为posts不能被indexed or accessed separately from users.
- 或者使用2个collections（and models）。在这个案例，这种结构会更灵活一些。但是需要至少2个查询，如果我们想要取一个user和它的posts。
于是Mongoose提供了population，在这里有用武之地了。
在user schema内引用posts。之后populate这些posts。为了使用populate(), 我们必须定义ref和model的名字：
const mongoose = require('mongoose')
const Schema = mongoose.Schema
const userSchema = new Schema({
_id: Number,
name: String,
posts: [{
type: Schema.Types.ObjectId,
ref: 'Post'
}]
})
⚠️，Schema.Types.ObjectId是一种SchemaType。
实际的postSchema只加了一行代码：
const postSchema = Schema({ _creator: { type: Number, ref: 'User'}, title: String, text: String })
下面的几行代码是我们创建models, 然后yes!!! 只用一个findOne()类方法即可得到全部的posts的数据。
执行exec()来run:
const Post = mongoose.model("Post", postSchema)
const User = mongoose.model('User', userSchema)
//添加一些数据，并存入MongoDB数据库
User.findOne({name: /azat/i})
.populate('posts')
.exec((err, user) => {
if (err) return handleError(err)
console.log('The user has % post(s)', user.posts.length)
})
⚠️ ObjectId, Number, String, and Buffer are valid data types to use as references,
meaning they will work as foreign keys in the relational DB terminology.
知识点：
- 正则表达式：找到所有匹配azat的string，大小写敏感， case-insensitively。
- console.log中的 %, 一种字符串插入符号的写法，把user.posts.length插入这个字符串。
也可以只返回一部分填入的结果。例如，我们能够限制posts的数量为10个:
⚠️在mongoose， path指 定义一个Schema中的type类型的名字
.populate({ path: 'posts', options: { limit: 10, sort: 'title'} })
有时候，只会返回指定的fileds,而不是整个document，使用select：
.populate({ path: 'posts', select: 'title', options: { limit: 10, sort: 'title' } })
另外，通过一个query来过滤填入的结果！
.populate({ path: 'posts', select: '_id title text', match: {text: /node\.js/i}, options: { limit: 10, sort: '_id'} })
查询选择的属性使用select, 值是一个字符串，用空格分开每个field name。
建议只查询和填入需要的fields，因为这样可以防止敏感信息的泄漏leakage，降低系统风险。
populate方法可以find()连接使用，即多个document的查询。
问题：
1. user.posts.length，这是user.posts是一个数组吗？所以可以使用length方法。
答：是的，在定义userSchema时，posts field的数据类型是数组。
2.exec()的使用：
Model.find()返回<Query>, 然后使用Query.populate()并返回<Query>this, 然后使用Query.exec()返回Promise
3 type和ref
type代表SchemType。ref属性是SchemaType Options的一种。和type属性配合使用。
4.上面的案例，如何保存有关联的数据？
var user = new User({name: "John", _id: 2}) var post = new Post({title: "New land", text: "Hello World!"}) user.posts = post._id post._creator = user._id user.save() post.save() User.findOne({_id: 2}).populate("posts") .exec((error, user) => { console.log(user.posts.length) })
还需要看官网的Populate一章。讲真，这本书讲的都很浅显，有的没有说清楚。
理解：User和Post各自有一个含有选项ref的path。因此双方建立了关联。
官方guide Populate()
Population是指： 在一个document内，用来自其他collection(s)的document，自动地取代指定paths的值。
我们可以populate一个单独的document，多个documents， 普通的object，多个普通的objects, 或者从一个query返回的所有objects。
基础
const mongoose = require('mongoose')
const Schema = mongoose.Schema
mongoose.connect('mongodb://localhost:27017/test', {useNewUrlParser: true})
// var db = mongoose.connection
const personScheam = Schema({
_id: Schema.Types.ObjectId,
name: String
age: Number,
stories: [{ type: Schema.Types.ObjectId, ref: "Story"}]
})
const storySchema = Schema({
author: { type: Schema.Types.ObjectId, ref: "Person"},
title: String,
fans: [{ type: Schema.Types.ObjectId, ref: "Person"}]
})
const Story = mongoose.model("Story", storySchema)
const Person = mongoose.model("Person", personScheam)
注意⚠️
- 使用ref选项的path的类型必须是ObjectId, Number, String, Buffer之一。
- 通常使用ObjectId, 除非你是一个高级用户或有充分如此做的原因
saving refs
保存refs到其他documents和你保存属性的方式一样，指需要分配_id值：
const author = new Person({ _id: new mongoose.Types.ObjectId, name: "Ian Fleming", age: 50 }) author.save((err) => { if (err) return handleError(err) const story1 = new Story({ title: "Casino Royale", author: author._id }) story1.save((err, story1) => { if (err) return handleError(err) console.log("Success stores", story1.title) }) })
上面的代码，因为story1有外键author（即通过_id建立了两个documents的关联）, 所以story1能直接populate author的数据。
Population
现在填入story的author，使用query builder:
Story.findOne({ title: "Casino Royale"})
.populate('author')
.exec((err, story) => {
if (err) return handleError(err)
console.log("The author is %s", story.author.name)
})
通过在返回结果前运行一个独立的query，（findOne()方法返回的是一个Query对象）
填入的paths不再是它们的原始的_id, 它们的值被替换为从数据库返回的document。
Arrays of refs和 非Arrays of refs的工作方式一样。都是在query对象上调用populate方法，并返回一个array of documents来替代原始的_ids。
Setting Populated Fields
也可以手动填入一个对象，来替换_id。把一个document对象赋值给author属性。
这个对象必须是你的ref选项所涉及的model的一个实例:
//假设之前已经向数据库存入了一个person和一个story, story有person的外键： Story.findOne({ title: "Casino Royale"}, (error, story) => { if (error) { return handleError(error) } Person.findOne({name: "Ian Fleming"}).exec((err, person) => { story.author = person
console.log(story.author.name) }) })
//控制台会输出author的名字
这是不使用populate的方法。和使用populate的效果一样，都是替换掉了_id。
hat If There's No Foreign Document?
Mongoose populate不像传统的SQL joins。类似left join in SQL。
Person.deleteMany({ name: "Ian Fleming" }, (err, result) => {
if (err) {
console.log("err: ",err)
} else {
console.log("res: ", result)
}
});
//因为没有了Person中的document, story.author.name是null。
Story.findOne({ title: "Casino Royale"})
.populate('author')
.exec((err, story) => {
if (err) return handleError(err)
console.log("The author is %s", story.author.name)
})
如果storySchema的authors path是数组形式的， 则populate()会返回一个空的array
Field Selection
如果只想从返回的populated documents得到指定的fields, 可以向populate()传入第二个参数: field name\
populate(path, [select])
Story.findOne({ title: "Casino Royale"})
.populate('author', 'name')
.exec((err, story) => {
if (err) return handleError(err)
console.log("The author is %s", story.author.name)
//返回The authors age is undefined
console.log('The authors age is %s', story.author.age)
})
Populating Multiple Paths
如果我们想要同时填入多个paths, 把populate方法连起来：
Story. find(...). populate('fans'). populate('author'). exec();
Query conditions and other options
如果我们想要填入populate的fans数组基于他们的age, 同时只选择他们的名字，并返回最多5个fans, 怎么做？
Story.find(...) .populate({ path: 'fans', match: {age: { $gte: 21 }}, // 使用"-_id"，明确表示不包括"_id"field。 select: "name -_id", options: { limit: 5} }) .exec()
Refs to chlidren
本章Populate官网教程提供的案例，auhtor对象的stories field并没有被设置外键。
因此不能使用author.stories得到stories的列表。
这里有2个观点：perspectives:
第一， 你想要author对象知道哪些stories 是他的。通常，你的schema应该解决one-to-many关系，通过在many端加一个父pointer指针。但是，如果你有好的原因想要一个数组的child指针，你可以使用push()方法，把documents推到这个数组上：
author.stories.push(story1)
author.save(callback)
这样，我们就可以执行一个find和populate的联合
Person. findOne({ name: 'Ian Fleming' }). populate('stories'). // only works if we pushed refs to children exec(function (err, person) { if (err) return handleError(err); console.log(person); });
是否真的要设置2个方向的pointers是一个可争论的地方。
第二，作为代替， 我们可以忽略populating，并直接使用find()方法，找到stories：
Story. find({ author: author._id }). exec(function (err, stories) { if (err) return handleError(err); console.log('The stories are an array: ', stories); });
Populating an existing document
如果我们有一个正存在的mongoose document并想要填入一些它的paths,
可以使用document#populate() , 返回Document this。
doc.populate(path|options, callback) // or doc.populate(options).execPopulate()
Populating multiple existing documents
如果我们有多个documents或者plain objects， 我们想要填入他们，使用Model.populate()方法。
这和document#populate(), query#populate()方式类似。
populate(docs, options, [callback(err, doc)]) 返回Promise.
- docs <Document|Array>，一个单独的对象或者一个数组的对象。
- options <Object| Array> 一个hash的key/value对儿。可使用的顶级options:
- path: 值是要填入的path的名字
- select: 选择要从数据库得到的fields
- match: 可选的查询条件用于匹配
- model: 可选的model的名字，用于填入。（已知是用在不同数据库的model实例的填入）
- options: 可选的查询条件，比如like, limit等等。
- justOne: 可选的boolean，如果是true，则设置path为一个数组array。默认根据scheam推断。
// populates an array of objects
// find()返回一个query,里面的result是一个array of documents, 因此opts也应该是一个array of document
User.find(match, function (err, users) { var opts = [{ path: 'company', match: { x: 1 }, select: 'name' }] var promise = User.populate(users, opts); promise.then(console.log).end(); })
填入一个object, 和上面填入一个array of objects, 和填入很多plain objects。具体见文档
Populating across multiple levels跨越多层的填入
一个model的内的实例可以互相关联。即Self Joins
(这在Rails中的例子也是自身model上加一个foreign_key)
一个user schema可以跟踪user的朋友：
⚠️，关键使用ref选项，引用"User"自身！！！
var userSchema = new Schema({ name: String, friends: [{ type: Scheam.Types.ObjectId, ref: 'User'}] })
Populate让你得到一个user的朋友的列表。
但是如果你也想要一个user的朋友的朋友哪？加一个populate选项的嵌套：
User. findOne({ name: 'Val' }). populate({ path: 'friends', // Get friends of friends - populate the 'friends' array for every friend populate: { path: 'friends' } });
一个完整的例子：
//populate.js const mongoose = require('mongoose') const Schema = mongoose.Schema mongoose.connect('mongodb://localhost:27017/test', {useNewUrlParser: true}) const userSchema = new Schema({ _id: Number, name: String, friends: [{ type: Number, ref: 'User' }] }) const User = mongoose.model("User", userSchema) //存入下面的数据 var user = new User({ name: "chen", _id: 3, friends: [4] }).save() var user2 = new User({ name: "haha", _id: 4, friends: [3, 5] }).save() var user3 = new User({ name: "ming", _id: 5, friends: [5] }).save()
执行查询，使用populate选项：
User.findOne({_id: 3})
.populate({
path: 'friends',
populate: {path: 'friends'}
})
.exec((err, result) => {
console.log(result)
})
//返回
{ posts: [],
friends:
[ { posts: [],
friends:
[ { posts: [], friends: [ 4 ], _id: 3, name: 'chen', __v: 0 },
{ posts: [], friends: [ 5 ], _id: 5, name: 'ming', __v: 0 } ],
_id: 4,
name: 'haha',
__v: 0 } ],
_id: 3,
name: 'chen',
__v: 0 }
Populating across Databases跨越数据库的填入
使用model选项
之前的练习：
//引进mongoose const mongoose = require('mongoose') //得到Schema构建器 const Schema = mongoose.Schema //mongoose实例连接到本地端口27017的数据库test mongoose.connect('mongodb://localhost:27017/test', {useNewUrlParser: true}) //得到connection对象实例， 因为实际的原因，一个Connection等于一个Db var db = mongoose.connection
// with mongodb:// URI, 创建一个Connection实例
// 这个connection对象用于创建和检索models。
// Models总是在一个单一的connection中使用（scoped）。
var db = mongoose.createConnection('mongodb://user:pass@localhost:port/database');
假如，events和conversations这2个collection储存在不同的MongoDB instances内。
var eventSchema = new Schema({ name: String, // The id of the corresponding conversation // ⚠️没有使用ref conversation: Schema.Typs.ObjectId }); var conversationSchema = new Schema({ numMessages: Number });
var db1 = mongoose.createConnection('localhost:27000/db1'); var db2 = mongoose.createConnection('localhost:27001/db2'); //⚠️，我的电脑上不能同时开2个mongd，提示❌
exception in initAndListen: DBPathInUse: Unable to lock the lock file: /data/db/mongod.lock (Resource temporarily unavailable). Another mongod instance is already running on the /data/db directory, terminating
var Event = db1.model('Event', eventSchema); var Conversation = db2.model('Conversation', conversationSchema);
这种情况下，不能正常使用populate()来填入数据，需要告诉populate使用的是哪个model：
Event. find(). populate({ path: 'conversation', model: Conversation }). exec(function(error, docs) { /* ... */ });
实践的例子： 跨MongoDB databases实例。
// Populating across Databases const mongoose = require('mongoose') const Schema = mongoose.Schema mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true }) var db2 = mongoose.createConnection('mongodb://localhost:27017/db2', { useNewUrlParser: true }) // 创建2个Schema。 var eventSchema = new Schema({ name: String, conversation: Schema.Types.ObjectId }); var conversationSchema = new Schema({ numMessages: Number });
// 在test 数据库上创建一个Event类的实例。 var Event = mongoose.model('Event', eventSchema) var event = new Event({name: "click"}).save() // 在db2 数据库上创建一个Conversation类的实例 var Conversation = db2.model('Conversation', conversationSchema); var conversation = new Conversation({numMessages: 50}).save()
// 我在mongDb shell中给event document增加了一个field（conversation: XX）,值是conversation实例的_id
启动上面的脚本后，我修改脚本去掉创建实例的2行代码，然后添加一个find和populate, 然后重启脚本：
Event.find() .populate({ path: 'conversation', model: Conversation}) .exec((error, docs) => { console.log(docs) })
成功，填入conversation： （这个例子就是在不同database的一对一关联）
[ { _id: 5c4ad1f2916c8325ae15a6ac, name: 'click', __v: 0, conversation: { _id: 5c4ad1f2916c8325ae15a6ad, numMessages: 50, __v: 0 } } ]
上面的练习，
- 如果在find()内去掉model，再次运行脚本，返回的数组内的conversation field的值是 null
- 如果在find()内去掉model, 然后在eventSchema内加上ref，再次运行脚本。返回null。
上面的练习，把2个model放在同database下，可以正确运行的✅。
即eventSchema没有使用 ref, 但在find().populate()内使用了model: "Conversation", 可以填入对应的conversation实例。
因为官方文档：Query.prototype.populate()的参数[model]的解释是这样的：
«Model» The model you wish to use for population.
If not specified, populate will look up the model by the name in the Schema's ref field.
即，
如果populate方法内指定了model选项，则从这个model中找对应的document。
如果没有指定model，才会在eventSchema中找ref选项，因为ref的值就是一个model的名字。
结论就是，不论是model选项还是 ref选项，它们都是把2个document连接起来的辅助。
Dynamic References via refPath
Populate Virtuals
Populate Virtuals: The Count Option
Populate in Middleware
Nested Documents
上一章population。 这是一种传统的方法，来设计你的数据库。它minic模仿了关系型数据库设计并使用普通的forms和严格的数据原子化atomization。
The document storage model in NoSQL databases is well suited to use nested documents。
如果你指定最频繁运行的查询是什么，使用nested documents是更好的选择。
你可以优化你的数据库让它倾向某一个查询。
例如，大多数典型的使用案例是读用户数据。那么代替使用2个collections(posts and users)，
我们可以用单一的collections(users), 内部嵌套posts。
绝对使用哪种方式更多的是建筑学的问题，它的答案由具体使用决定。
例如，
- 如果有类似blog的功能，多个用户会读取作者的posts，就需要独立的查询作者的posts。分开的collection会更好。
- 如果posts只在作者的个人页面使用，那么最好就用nested documents。
使用Schema.Types.Mixed类型
const userSchema = new mongoose.Schema({ name: String, posts: [mongoose.Schema.Types.Mixed] }) // Attach methods, hooks, etc. const User = mongoose.model('User', userSchema)
更灵活的Schema设计，分成2个Schema：
const postSchema = new mongoose.Schema({ title: String, text: String }) // Attach methods, hooks, etc., to post schema const userSchema = new mongoose.Schema({ name: String, posts: [postSchema] }) // Attach methods, hooks, etc., to user schema const User = mongoose.model('User', userSchema)
增加子文档到arrays:
因为使用了数组，所以可以使用push， unshift, 等方法（在JavaScript／Node.js）或者MongoDB$push操作符号来更新user document：
User.updateOne( {_id: userId}, {$push: {posts: newPost}}, (error, results) => { // 处理错误和检测结果 } )
也可以使用save()：
var childSchema = new Schema({name: String}) var parentSchema = new Schema({ children: [childSchema], name: String }) var Parent = mongoose.model('Parent', parentSchema) var parent = new Parent({ children: [{name: 'Matt'}, {name: 'Sarah'}] }) parent.children[0].name = 'Matthew'
parent.children.push({ name: 'Liesl'})
parent.save((error, result) => { if (error) return console.log(error) console.log(result) })
得到：
{ _id: 5c47d630d93ce656805231f8, children: [ { _id: 5c47d630d93ce656805231fa, name: 'Matthew' }, { _id: 5c47d630d93ce656805231f9, name: 'Sarah' } ,
{ _id: 5c47d9b07517b756fb125221, name: 'Liesl' } ], __v: 0 }
注意⚠️，新增了3个child, 和parent一起存在mongoDB的test数据库的parents collections内
查询一个子document
每个子document默认有一个_id。
Mongoose document arrays有一个特别的id方法用于搜索一个doucment array来找到一个有给定_id值的document。
var doc = parent.children.id(_id)
移除使用remove方法，相当于在子文档内使用.pull()
parent.children.pull(_id) //等同 parent.children.id(_id).remove()
//对于：a single nested subdocument: parent.child.remove() //等同 parent.child = null
官方文档Queries
Mongoose models提供用于CRUD操作的静态帮助函数。这些函数返回一个mongoose Query 对象。
- Model.deleteOne(), deleteMany()
- Model.find()
- Model.findById(), 及衍生出findByIdAndDelete(), findByIdAndRemove, findByIdAndUpdate
- Model.findOne(), 及衍生出findOneAndDelete(), findOneAndRemove, findOneAndUpdate
- Model.replace() ,类似update(), 用传入的doc取代原来的document
- Model.updateOne(), Model.updateMany()。
一个Query对象可以使用.then()函数。
query with callback
当使用一个query并传入一个callback()， 你指定你的query作为一个JSON document。
这个JSON document的语法和MongoDB shell相同。
var Person = mongoose.model('Person', yourSchema); // find each person with a last name matching 'Ghost', selecting the `name` and `occupation` fields Person.findOne({ 'name.last': 'Ghost' }, 'name occupation', function (err, person) { if (err) return handleError(err); console.log('%s %s is a %s.', person.name.first, person.name.last, person.occupation); });
⚠️在Mongoose内，所有的callback都使用这个模式callback(error, result)
- 如果有error存在，则error参数包含a error document。 result的值是null
- 如果query是成功的，error参数是null, 并且result被填入populated查询的结果。
findOne()的例子：
Adventure.findOne({ type: 'iphone' }, function (err, adventure) {});
// same as above
Adventure.findOne({ type: 'iphone' }).exec(function (err, adventure) {});
// specify options, in this case lean Adventure.findOne({ type: 'iphone' }, 'name', { lean: true }, callback); // same as above Adventure.findOne({ type: 'iphone' }, 'name', { lean: true }).exec(callback); // chaining findOne queries (same as above) Adventure.findOne({ type: 'iphone' }).select('name').lean().exec(callback);
lean选项为true，从queries返回的documents是普通的javaScript 对象，而不是MongooseDocuments。
countDocuments()的例子
在一个collection中，计算符合filter的documents的数量.
query but no callback is passed
一个Query 可以让你使用chaining syntax，而不是specifying a JSON object
例子：
Person. find({ 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) //等同于使用query builder:
Person. 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);
Queries不是promises
可以使用.then函数, 但是调用query的then()能够执行这个query多次。
const q = MyModel.updateMany({}, { isDeleted: true }, function() {
console.log('Update 1');
});
q.then(() => console.log('Update 2'));
q.then(() => console.log('Update 3'));
上个例子，执行了3次updateMany()。
- 第一次使用了callback。
- 后2次，使用了then()。
注意⚠️不要在query混合使用回调函数和promises。
Virtual Fields (Virtuals)
不存在于数据库，但是像regular field in a mongoose document。就是mock，fake。
Virtual fields的用途：
- dynamic data
- creating aggregate fields
例子，一个personSchema,有firstName, lastName2个fields，和一个Virtual fields（fullName），这个Virtual fullName无需真实存在。
另一个例子，兼容以前的database。每次有一个新的schema, 只需增加一个virtual来支持旧的documents。
例如， 我们有上千个用户记录在数据库collection，我们想要开始收集他们的位置。因此有2个方法：
1. 运行一个migration script，为所有old user documents增加一个location field, 值是none。
2. 使用virtual field 并在运行时，apply defaults。
再举一个例，加入有一个大的document，我们需要得到这个document的部分数据，而不是所有的数据，就可以使用virtual field来筛选要显示的数据：
//从Schema中筛选出一些fields,放入虚拟field"info" userSchema.virtual('info') .get(function() { return { service: this.service, username: this.username, date: this.date, // ... } })
定义a virtual :
- personSchema.virtual('fullName')创建一个virtual type。
- 使用a getter function, get(fn)， 返回<VirtualType>this。 （不要使用箭头函数, this是一个instance/document）
完整的例子：
const mongoose = require('mongoose')
mongoose.connect('mongodb://localhost:27017/myproject', {useNewUrlParser: true})
var personSchema = new mongoose.Schema({
name: {
first: String,
last: String
}
})
//定义一个virtualType
personSchema.virtual('fullName').get(function () {
return this.name.first + ' ' + this.name.last;
});
var Person = mongoose.model('Person', personSchema)
// var axl = new Person({
// name: {
// first: 'Axl',
// last: 'Rose'
// }
// }).save((error, result) => {
// if (error) return console.log(error)
// console.log(result)
// })
Person.findOne({"name.first": 'Axl'}, (error, result) => {
console.log(result.fullName)
})
上面的例子使用了Schema#virtual()方法。定义了一个虚拟field，并VirtualType#get()方法定义了一个getter。自然也可以定义一个setter,使用set()方法：（关于get,set见?一章）
//为virtual field “fullName”添加了写入write的set()函数 personSchema.virtual('fullName').set(function(v) { var parts = v.split(" ") this.name.first = parts[0] this.name.last = parts[1] }) //把一个名字字符串存入到fullName filed。本质是存到了name.first和name.last Person.findOne({"name.first": 'Axl'}, (error, person) => { person.fullName = "chen hao" person.save() })
结论： get和set方法就是read／write的存取方法。
⚠️： 因为virtuals不能储存在MongoDB，所以不能查询他们query。
toJSON和toObject（方法／构建器选项）对Virtuals fields的影响
默认，这2个方法不会影响到虚拟fileds。可以通过传{virtuals: true}来让这2个方法对virtual fields生效。
例子:
因为使用选项{getters: true}, 所有getters都会使用，包括virtual getters和path getters。
path getters指对Schema对象中的path（其实就是fields的另类称呼）设置一个get(callback)函数：
const mongoose = require('mongoose')
mongoose.connect('mongodb://localhost:27017/myproject', {useNewUrlParser: true})
var schema = new mongoose.Schema({ name: String });
schema.path('name').get(function (v) {
return v + ' is my name';
});
schema.set('toObject', { getters: true });
var People = mongoose.model('People', schema);
var m = new People({ name: 'Max Headroom' });
console.log(m)
Document.propotype.toObject()
把document转化为一个普通的javaScript object, 并准备储存到数据库。返回一个js object。
toObject()方法的本质就是对document的一些设定，根据这些设定，把数据转化为js object.
参数只有[options]， 有7个选项：
- {getters: false} 默认是false，如果true，使用所有的getters。
- {minimize: true} 默认是true, 即忽略输出中的任何空对象。假如这个document, 有一个field的值是null，则这个filed不会转化为js object的一部分。
- [options.versionKey=true] 默认是true, 即生成的js object形式的document内包含一个_v 属性
- 其他的4具体见文档
toObject使用的地方：
1. Schema构建器的选项
model对象本身是schema对象的副本。
而Schema()构建器的options内包括toJson和toObject选项，默认情况下构建器不会使用这2个选项。
所以如果你在Schema构建器上使用toObject选项（如上面的例子），则生成的doc必然使用toObject选项设置的规则，其中minimize和versionKey是默认true。
2. 对某个document使用.
Schema Type Behavior Amendment
Schema不是静态的类型定义。
Mongoose可以让开发者在Schema内，定义／写入 getters(get), setters(set)和defaults(default)
get是在一个field被读时引用。 set是当一个field被赋值时引用。
开发者通过他们可以修改实际的database document的值。
Mongoose有4个方法：set(), get(), default() and validate()
- set(): 例如把一个string全部小写化, 当这个value被分配时。
- get(): 增加一个"thousands"符号给一个数字，当这个number被提取时。
- default(): 生成一个新的ObjectId
- validate(): 用于检测email pattern; 在save()前被激活。
利用上面的4个方法，我们可以在Mongoose Schema的fields中定义（和type在同一层：）
postSchema = new mongoose.Schema({ slug: { type: String, set: function(slug) { return slug.toLowerCase() } }, numberOfLikes: { type: Number, get: function(value) { return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",") } }, authorId: { type: ObjectId, default: function() { return new mongoose.Types.ObjectId() } }, email: { type: String, unique: true, validate: [ function(email) { return (email.match(/[a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/i) != null)}, 'Invalid email' ] } })
因为会根据需求动态的定义Schema，所以Mongoose提供了另外的方法来修补Schema behavior:
chain methods--这需要2步：
- 使用Schema.path(name)来得到SchemaType。
- 使用Schema.get(fn)来设置getter方法。
⚠️和定义virtual fields的方式类似。
SchemaType.get(fn), 返回<this>。 为这个schema type的所有实例附加一个getter。
例如单独的为numberOfPosts field创建一个getter方法：
userSchema .path('numberOfPosts') .get(function() { return this.posts.length })
提示：
什么是path?
path就是一个名字，特指Schema内的嵌套的field name和它的父对象。
例如, 我们有ZIP代码(zip)作为contact.address的一个child,
比如user.contact.address.zip, 然后contact.address.zip就是一个path。
官方文档Validation
mongoose提供了validation功能，以下是几条验证的rules:
- Validation定义在SchemaType内。和type同层。
- Validation是一个middleware。默认Mongoose注册它，作为每个schema的pre('save')钩子。
- 你可以手动地运行validation，使用doc.validate(callback)或者doc.validateSync()
- Validators 不会在未定义values的field上进行验证。但是，唯一一个例外是required验证器
- Validation是一种异步的递归；当你调用Model#save, 子doc验证也会被执行。如果发生一个error, 你的Model#save回调会接收它。
- Validation可以客制化。
例子：
这个例子因为生成的cat实例的name没有赋值，在save时，无法通过validation。
const mongoose = require('mongoose')
const Schema = mongoose.Schema
const { expect } = require('chai')
mongoose.connect('mongodb://localhost:27017/test', {useNewUrlParser: true})
var schema = new Schema({
name: {
type: String,
required: true
}
})
var Cat = mongoose.model("Cat", schema)
var cat = new Cat()
cat.save((err) => {
console.log(err)
expect(err.errors['name'].message).to.equal("Path `name` is required.")
})
err是一个javascript object：
通过err.errors.name.message得到 'Path `name` is required.'
{ ValidationError: Cat validation failed: name: Path `name` is required. at ValidationError.inspect (/Users/chen /node_practice/driver/node_modules/mongoose/lib/error/validation.js:59:24) at formatValue (internal/util/inspect.js:523:31) //...一大坨路径 errors: { name: { ValidatorError: Path `name` is required. at new ValidatorError (/Users/chentianwei/node_practice/driver/node_modules/mongoose/lib/error/validator.js:29:11) at validate (/Users/chentianwei/node_practice/driver/node_modules/mongoose/lib/schematype.js:926:13) //...一大坨路径 message: 'Path `name` is required.', name: 'ValidatorError', properties: { validator: [Function], message: 'Path `name` is required.', type: 'required', path: 'name', value: undefined }, kind: 'required', path: 'name', value: undefined, reason: undefined, [Symbol(mongoose:validatorError)]: true } }, _message: 'Cat validation failed', name: 'ValidationError' }
参数
第一个参数：required可以是《Boolean| Function | Object》
第二个参数：[message]，string, 提供错误信息。
客制化验证器
SchemaType#validate()
客制化的验证器也可以是异步的。让validator 函数返回一个promise（或者使用async function）, mongoose会等待promise去处理。
也可以使用回调函数作为参数。
（具体案例见文档）
Validations Errors
如果验证失败，会返回错误的信息，其中包括一个errors对象。这个errors对象内部包含ValidatorError对象，kind, path, value, message， reason属性。
如果你在验证器内使用throw new Error(//...), 如果产生❌，reason属性会包含这个❌的信息。
见上面的☝️代码块。
案例
const mongoose = require('mongoose')
const Schema = mongoose.Schema
const { expect } = require('chai')
mongoose.connect('mongodb://localhost:27017/test', {useNewUrlParser: true})
var toySchema = new Schema({
color: String,
name: String
})
//给color设置验证函数，color的值指定在red, white, gold内选择。
var validator = function(value) {
return /red|white|gold/i.test(value)
}
toySchema.path('color').validate(validator, 'Color `{VALUE}` not valid', 'Invalid color')
// 给name设置验证函数，如果传入的值不能通过判断，就抛出一个Error对象。并提供错误的信息。
toySchema.path('name').validate(function(v) {
if (v !== 'Turbo Man') {
throw new Error('Need to get a Turbo Man for Christams')
}
return true
}, 'Name `{VALUE}` is not valid')
// 声明Toy类
var Toy = mongoose.model('Toy', toySchema)
// 实例化toy
var toy = new Toy({color: 'Green', name: 'Power Ranger'})
// 保存，回调函数内进行测试。
toy.save(function(err) {
console.log(err.errors.color)
expect(err.errors.color.message).to.equal('Color `Green` not valid')
expect(err.errors.color.path).to.equal('color')
// 如果验证器throw an error, "reason"属性会包括错误的信息及stack trace
console.log(err.errors.name)
expect(err.errors.name.message).to.equal('Need to get a Turbo Man for Christams')
expect(err.errors.name.value).to.equal('Power Ranger')
})
Update Validations验证
默认情况下，更新验证不会使用，需要指定runValidators选项。
在doc更新时，激活验证。如 updateOne(), findOneAndUpdate()等。
var opts = { runValidators: true }; Toy.updateOne({}, { color: 'bacon' }, opts, function (err) { assert.equal(err.errors.color.message, 'Invalid color'); });
官方文档Middleware
Middleware (also called pre and post hooks) are functions which are passed control during execution of asynchronous functions。
中间件被指定在schema层，写plugins时非常有用！
Mongoose 有4种中间件：document, model, aggregate, query。
document中间件被以下函数支持：
- validate
- save
- remove
- init
Query中间件被以下Model和Query函数支持：
- count
- deleteMany, deleteOne
- find系列，findOne等
- update, updateOne, updateMany
Model中间件被以下model 函数支持：
- insertMany
Pre
Pre middleware functions are executed one after another, when each middleware calls next.
当pre中间件调用next函数后，就会执行后续的pre中间件。
var schema = new Schema(..) schema.pre('save', function(next) { // do stuff next() })
代替使用next，可以使用一个函数返回一个promise，也可以用async/await
关于return的使用
调用next()不会停止中间件函数内的后续代码的执行。除非使用return next()
var schema = new Schema(..); schema.pre('save', function(next) { if (foo()) { console.log('calling next!'); // `return next();` will make sure the rest of this function doesn't run next(); } // 如果用return next()，下面的代码就不会执行了。 console.log('after next'); });
Use Cases使用案例
中间件用于细化逻辑。下面是一些其他的点子：
- 复杂的验证
- 移除依赖的文档
- asynchronous defaults
- asynchronous tasks that a certain action triggers
错误处理
如果pre hook发送❌，之后的中间件或者勾住的函数不会执行。作为代替，Mongoose会传递一个error给回调函数， and/or拒绝返回的promise。
schema.pre('save', function(next) {
const err = new Error('something went wrong');
// If you call `next()` with an argument, that argument is assumed to be
// an error.
next(err);
});
// later...
// Changes will not be persisted to MongoDB because a pre hook errored out
myDoc.save(function(err) {
console.log(err.message); // something went wrong
});
Post 中间件
在可以hooked method和它的pre中间件完成后，post中间件被执行。
schema.post('init', function(doc) {
console.log('%s has been initialized from the db', doc._id);
});
异步的Post Hooks
如果你的post hook function接受至少2个参数， mongoose会假设第2个参数是一个next()函数，你调用它来激活下一个中间件。
schema.post('save', function(doc, next) {
setTimeout(function() {
console.log('post1')
next(); //执行下一个post hook
}, 10)
})
// 只有第一个post中间件调用next()， 才会执行下一个post中间件
schema.post('save', function(doc, next) {
console.log('post2');
next();
});
注意⚠️： mongoose有内建的pre('save')钩子会调用validate()函数。
一句话就是pre('validate')和post('validate')会在pre('save')钩子之前被调用。
Express.js + Mongoose = True MVC
为了避免重建所有其他的和ODM不相关的部分，如template, routes等等，根据上一章的Blog进行重构。
使用Mongoose。
在MongoDB和请求handlers之间产生一个抽象层。
代码参考：https://github.com/azat-co/blog-express/tree/mongoose
安装：
$npm install mongoose
修改app.js：
因为mongoose是模仿关系型数据库的一个关系型的数据模型，我们需要在主程序文件夹建立一个models文件夹，用于储存数据结构和关系。
然后在app.js内加上
const mongoose = require('mongoose')
const models = require('./models')
然后
建立连接声明，因为Mongoose使用models，不会直接使用Mongodb的collections所以去掉：
const collections = { articles: db.collection('articles'), users: db.collection('users') }
加上连接：
const db = mongoose.connect(dbUrl, {useMongoClient: true})
修改代码：
通过req对象得到mongoose models， 然后就能在每个Express.js route内操作MongoDb的数据.
app.use((req, res, next) => { if (!models.Article || !models.User) { // <--- ADD return next(new Error('No models.')) // <--- UPDATE } req.models = models // <--- ADD return next() })
OK了，从mongoskin到Mongoose完成。
下一步，建立shcmeas，并export。
为了说明代码复用，我们从routes/article.js抽出find方法到models/article.js。
所有的database methods都这么做。
//GET /api/articles API route exports.list = (req, res, next) => { req.collections.articles.find({}).toArray((error, articles) => { if (error) return next(error) res.send({articles: articles}) }) }
抽出find,变成：
articleSchema.static({ list: function(callback) {
//第2个参数null是表示不设置projection this.find({}, null, {sort: {_id: -1}}, callback) } })
然后编译schema and methods 进入a model。
module.exports = mongoose.model('Article', articleSchema)
完整的article.js代码：
const mongoose = require('mongoose')
const articleSchema = new mongoose.Schema({
title: {
type: String,
required: true, //一个验证器，不能为空
// validate验证器，第2个参数是message
validate: [function(value){
return value.length <= 120
}, 'Title is too long(120 max)'],
default: 'New Post' //默认值
},
text: String,
published: {
type: Boolean,
default: false
},
slug: {
type: String,
// 对SchemaType的path(slug)的设置：
set: function(value) {
return value.toLowerCase().replace(' ', '-')
}
}
})
articleSchema。static({
list: function(callback) {
this.find({}, null, {sort: {_id: -1}}, callback)
}
})
module.exports = mongoose.model('Article', articleSchema)
然后，
同样增加user.js和index.js。
随着models下.js文件的增多，使用index.js来控制输出models文件夹下的所有脚本文件，就变得很方便了。
exports.Article = require('./article')
exports.User = require('./user')
下一步修改routes 文件
同样，把routes/article.js 的代码中的Mongoskin collection改成Mongoose models。
exports.show = (req, res, next) => { if (!req.params.slug) return next(new Error('No article slug.')) // req.collections.articles.findOne({slug: req.params.slug}, (error, article) => { //使用Mongoose models: req.models.Article.findOne({slug: req.params.slug}, (error, article) => { if (error) return next(error) if (!article.published && !req.session.admin) return res.status(401).send() res.render('article', article) }) }
这个show函数，用于显示一个具体的article详细内容的页面。
// 进口routes文件夹内的所有脚本的输出。 const routes = require('./routes/index.js') app.get('/articles/:slug', routes.article.show)
⚠️提示：
这里的next()函数是。express实例app的方法use中的callback内的参数。
app.use([path], callback[, callback...])
回调callback可以多次的调用。为了方便，使用next函数，代表完成这个回调，并进行下一个callback。
routes/article.js相当于Rails中的controller，
app.js中的app.get(url, callback)相当于Rails中的routes内的一条route.
思考：
express实例app是一根实例。
- 储存了一大堆中间件的实例方法：app.use()
- 它存储了Mongoose的Schema->Models
- 处理服务器路径routes, 使用app.get，app.post等方法来操作数据库。
route->control方法->model（MongoDB）
之后还要改list方法， add, edit, del, postArticle, admin方法。具体见代码：
(完整代码：https://github.com/azat-co/blog-express/blob/mongoose/routes/article.js)
关于express.edit。
有方便的语法糖findByIdAndUpdate。但是有些hook不会被激活，需要确定它的使用。
因此使用传统的findById()加save()方法，可以激活所有的hook, 更安全。
关于express.del
使用Model.deleteOne。
然后修改routes/index.js
exports.article = require('./article')
exports.user = require('./user')
exports.index = (req, res, next) => {
req.models.Article.find({published: true}, null, {sort: {_id: -1}}, (error, articles) => {
if (error) return next(error)
res.render('index', {articles: articles})
})
}
⚠️： null这个参数的位置本身是用于指定筛选出的fields，
如果不筛选则使用null，表示不进行筛选fields。所有的fields的数据都会取出。
最后，routes/user.js
具体还要约定第6章。
exports.authenticate = (req, res, next) => { if (!req.body.email || !req.body.password) { return res.render('login', {error: 'Please enter your email and password.'}) } req.models.User.findOne({ email: req.body.email, password: req.body.password }, function (error, user) { if (error) return next(error) if (!user) return res.render('login', {error: 'Incorrect email&password combination.'}) req.session.user = user req.session.admin = user.admin res.redirect('/admin') }) }
总结
本章探讨使用Mongoose, 如何安装，建立连接到数据库。如何使用mongose schemas和SchemaType, 使用models, 如何使用它的query语法。如何使用hooks。 如何使用populate或nested documente。如何使用virtual fields.
并重构了Blog。使用Mongoose和一个MVC结构。
下章，讲解建立RESTFUL APIs使用Express, Hapi(忽略)。 现在的趋势是大前端加轻量后端。
这个趋势让开发团队集中在最重要的方面：终端用户--用户的交互体验。同时对商业来说，降低重复循环和更少的维护和开发费用。
测试驱动也很重要：使用Mocha, 它广泛用于Node.js测试。
1289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
