mongoose安装和使用（超详细）

一.简介

介绍

Mongoose 是一个让我们可以通过Node来操作MongoDB数据库的一个模块
Mongoose 是一个对象文档模型（ODM）库，它是对Node原生的MongoDB模块进行了进一步的优化封装
大多数情况下，他被用来把结构化的模式应用到一个MongoDB集合，并提供了验证和类型装换等好处
基于MongoDB驱动，通过关系型数据库的思想来实现非关系型数据库

优势/好处

为文档创建模式结构（Schema），也可以说是约束
对模型中的对象/文档进行验证
数据可以通过类型装换装换为对象模型
可以使用中间件来应用业务逻辑挂钩
相比MongoDB驱动更容易

new Object

Schema（模式对象）

——Schema 对象定义约束了数据库中的文档结构

Model

——Model 对象作为集合中的所有文档的表示，相当于MongoDB中的collection，它的每一个实例就是一个document文档

Document

——Document表示集合中的具体文档，相当于collection中的一个具体文档

关系：Schema生成Model，Model创造Document

模式（Schemas）

每个 schema 都会映射到一个 MongoDB collection 并定义这个collection里的文档结构
创建一个 schema 对象

const mongoose = require('mongoose')
//调用 Schema
const Scheme = mongoose.Schema

//创建 schema 对象
var stuSchema = new Schema({
name: String,
age: Number,
gender:{
type: String,
default:'male' //定义默认类型
},
addr: String
})

在Schema定以后添加字段时需要使用 add() 方法

var stuSchema = new Schema({
{...},
{ timestamps:true }
})

【_id】

当未定义_id字段时 mongoose 会为每一个文档自动添加一个不重复的_id，类型为ObiectId（在查询语句中需要通过 findById() 才能查询）

二.安装使用mongoose

前提：安装MongoDB，Nodejs

1.下载安装Mongoose

npm i mongoose

2.项目中引入mongoose

var mongoose = require(‘mongoose’)

3.连接数据库

mongoose.connect(‘mongodb://数据库ip地址 : 端口号( 默认端口27017可以省略 )/数据库名’)

数据库连接成功事件

补充
将成功回调的on改成once
事件回调函数只执行一次
mongoose.connection.once(‘open’ , () => {})

数据库断开事件

mongoose.connection.once(‘close’ , () => {})

4.创建Schema（模式）对象

var stuSchema = new Schema({})

通过Schema创建Model
Model 代表的是数据库中的集合，通过Model才能对数据库进行操作

5.映射

var stuModel = mongoose.model(‘student’,stuSchema)

参数

要映射的集合名
创建的约束（Schema对象）

6.通过映射返回的值对数据库进行增、删、改、查

7.断开数据库连接（一般不使用）

const mongoose = require('mongoose');

// 连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/user');

// 设置连接成功的回调
mongoose.connection.once('open', () => {
if (mongoose.connection.readyState === 1) {
console.log("连接成功");

// 创建文档的结构对象
let BookSchema = new mongoose.Schema({
name: {
type: String,
required: true
},
author: String,
price: Number
});

// 创建模型对象
let BookModel = mongoose.model('books', BookSchema);

// 数据插入
BookModel.create(
{
name: '西游记',
author: '哈哈',
price: 19.9,
},
{
name: '红楼梦',
author: '曹雪芹',
price: 19.9,
},
{
name: '水浒传',
author: '111',
price: 19.9,
},
{
name: '三国演义',
author: '2222',
price: 19.9,
},
(err, data) => {
if (err) {
console.log(err);
return;
}
console.log(data);
// 插入数据后关闭连接
mongoose.disconnect();
}
);
// 数据删除
// BookModel.remove({name:/西游记/},function(err){})
}
});

// 设置连接错误的回调
mongoose.connection.on('error', () => {
console.log("连接失败");
});

// 设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log("连接关闭");
});

创建文档的结构对象

设置集合中文档的属性以及属性值的类型

Let BookSchema= new mongoose.Schema({
name: String
author: String;
price:Number
})

创建模型对象对稳定操作的封装对象

Let BookModel= mongoose.model( ' books '，BookSchema）
集合名称，结构对象

文档新增

create()

操作模型
Model.create(doc(s), [callback])
参数：

[doc(s)]：文档对象或文档对象数组

[callback]：回调函数

// 数据插入
stuModel.create({name:"小明",grades:68},{name:"小红",grades:80},(err,doc1,doc2) => {
if(!err){
   console.log(doc1)
   //{ _id: 6017be2d77c8dd01242624bb, name: '小明', grades: 68, __v: 0 }
   console.log(doc2)
               //{ _id: 6017be2d77c8dd01242624bc, name: '小红', grades: 80, __v: 0 }
   }
})

save()

操作的是文档
Model.prototype.save([options], [options.safe], [options.validateBeforeSave], [fn])

//链式调用通过new 一个Model创建一个 document
new stuModel({name:"小明",grades:68}).save((err,docs) => {
if(!err){
console.log(docs)
//{ _id: 6017bd1cf4cc8544d8ed2a8a, name: '小明', grades: 68, __v: 0 }
}
})

insertMany()

Model.insertMany(doc(s), [options], [callback])
返回值为一个数组

//链式调用通过new 一个Model创建一个 document
stuModel.insertMany({name:"小明",grades:68},{name:"小芳",grades:94},(err,docs) => {
if(!err){
   console.log(docs)
   /*[{ _id: 6017befb5c36d64d08b72576, name: '小明', grades: 68, __v: 0 },
{ _id: 6017befb5c36d64d08b72577, name: '小芳', grades: 94, __v: 0 }]*/
   }
})

文档查询

【find()】

Model.find(conditions, [projection], [options], [callback])
参数

conditions：查询条件

[projection]：控制返回字段

[options]：配置查询参数

[callback]：回调函数–function(err,docs){}

// 数据查询
// BookModel.find((err, docs) => {
// if (!err) {
// console.log(docs)
// }
// })

findById()

Model.findById(conditions, [fields], [options], [callback])

var mongoose = require('mongoose')
mongoose.connect('mongodb://localhost:27017/student',(err) => {
if(!err){
var schema = new mongoose.Schema({name:String,grades:Number})
var stuModel = mongoose.model('grades',schema)
//保存查询数据的_id
var aIDArr = []

//查询所有数据
stuModel.find((err,docs) => {
if(!err){
   docs.forEach((item,index,arr)=>{
aIDArr.push(item._id)
})
//显示第 0 个元素的所有字段
stuModel.findById(aIDArr[0],(err,doc)=>{
if(!err){
console.log(doc)
}
})
// { _id: 6017befb5c36d64d08b72576, name: '小明', grades: 68, __v: 0 }

//显示第 0 个元素且只输出name字段
stuModel.findById(aIDArr[0],{name:1,_id:0},(err,doc)=>{
if(!err){
console.log(doc)
}
})
// { name: '小明' }

//显示第 0 个元素且输出最少的字段(_id默认输出)
stuModel.findById(aIDArr[0],{lean:true},(err,doc)=>{
if(!err){
console.log(doc)
}
})
// { _id: 6017befb5c36d64d08b72576 }
   }
})
}
})

注：conditions写一个id值就可以了，返回单个文档

【findOne()】

返回查询到的数据的第一个

// 返回查询到的数据的第一个
BookModel.findOne({price:{$gt:10}},(err,doc) => {
if(!err){
console.log(doc)
}
})

复杂查询【$where】

$where 可以使用任意的 JavaScript 作为查询的一部分，包含JavaScript 表达式的字符串或者函数

// 字符串 es5中this与obj指向一样，es6中只能用obj
BookModel.find({$where:"this.name == this.author" || "obj.name == obj.author"},(err,doc) => {
if(!err){
console.log(doc)
}
})
//函数
BookModel.find({$where:function() {
return this.name == this.author || obj.name == obj.author
}},(err,doc) => {
if(!err){
console.log(doc)
}
})

常用查询条件

stuModel.find({grades:{$gt:90}},(err,docs)=>{
console.log(docs);
})

特定类型查询

const mongoose = require('mongoose')
mongoose.connect('mongodb://localhost:27017/student')
var Schema =new mongoose.Schema({ name:String,grades:Number,test:{type:Number,default:0}})
var stuModel = mongoose.model('grades', Schema);

// 按test从小到大排序
stuModel.find().sort('test').exec((err,docs)=>{
console.log(docs)
})
// 按test从大到小排列
stuModel.find().sort('-test').exec((err,docs)=>{
console.log(docs)
})
// 跳过1个，显示其他
stuModel.find().skip(1).exec((err,docs)=>{
console.log(docs)
})
// 显示2个
stuModel.find().limit(2).exec((err,docs)=>{
console.log(docs)
})
// 显示name、grades字段，不显示_id字段
stuModel.find().select('name grades -_id').exec((err,docs)=>{
console.log(docs)
})
// 跳过第1个后，只显示2个数据，按照grades由大到小排序，且不显示_id字段
stuModel.find().skip(1).limit(2).sort('-grades').select('-_id').exec((err,docs)=>{
console.log(docs)
/*[{ name: '小明', grades: 78, __v: 0, test: 1 },
{ name: '小花', grades: 76, test: 4, __v: 0 }]*/
})
// 显示集合stuModel中的文档数量
stuModel.find().count((err,count)=>{
console.log(count)
//6
})
// 返回集合stuModel中的grades的值
stuModel.find().distinct('grades',(err,distinct)=>{
console.log(distinct)
//[ 46, 52, 60, 76, 78, 94 ]
})

文档更新

【update()】

Model.update(conditions, doc, [options], [callback])
参数

conditions：查询条件

doc：需要修改的数据（插入的数据）

[options]：控制选项

safe (boolean)：默认为true。安全模式。
upsert (boolean)：默认为false。如果不存在则创建新记录。
multi (boolean)：默认为false。是否更新多个查询记录。
runValidators：如果值为true，执行Validation验证。
setDefaultsOnInsert：如果upsert选项为true，在新建时插入文档定义的默认值。
strict (boolean)：以strict模式进行更新。
overwrite (boolean)：默认为false。禁用update-only模式，允许覆盖记录。

[callback]：回调函数
若设置了查询条件，当数据库不满足时默认什么也不发生
update() 方法中的回调函数不能省略，否则数据不会更新，当回调无有用信息时可以使用exec()简化

stuModel.update({grades:{$gt:80}},{test:40},function(err,raw){
//{ n: 1, nModified: 1, ok: 1 }
console.log(raw);
})
如果要同时更新多个记录，需要设置options里的multi为true。
temp.update({name:/a/},{age: 10},{multi:true},function(err,raw){
//{ n: 2, nModified: 2, ok: 1 }
console.log(raw);
})

【updateOne()】

Model.updateOne(conditions, doc, [options], [callback])
与update()相似，唯一区别为updateOne() 默认更新一个文档，即使设置{multi:true}也无法只更新一个文档

【updateMany()】

Model.updateMany(conditions, doc, [options], [callback])
与update()相似，唯一区别为updateMany() 默认更新多个文档，即使设置{multi:false}也无法只更新一个文档

【find()+save()】【findOne() + save()】

用于复杂更新

const mongoose = require('mongoose')
mongoose.connect('mongodb://localhost:27017/student',err=>{
if(!err){
var Schema =new mongoose.Schema({ name:String,grades:Number,test:{type:Number,default:0}})
var stuModel = mongoose.model('grades',Schema)

//查询成绩小于60的数据，并在其名字后添加‘：差生’字段
stuModel.find({grades:{$lt:60}},(err,docs)=>{
console.log(docs);
/*[{test: 0,_id: 6017c455ba09d355a49ec8eb,name: '小红',grades: 52,__v: 0},
{test: 0,_id: 6017c455ba09d355a49ec8ec,name: '小刚',grades: 46,__v: 0}]*/

docs.forEach((item,index,arr) => {
item.name += '：差生'
//将修改后的数据保存
item.save()
})
console.log(docs)
/*[{test: 0,_id: 6017c455ba09d355a49ec8eb,name: '小红：差生',grades: 52,__v: 0},
{test: 0,_id: 6017c455ba09d355a49ec8ec,name: '小刚：差生',grades: 46,__v: 0}]*/
})
}
})