构建日期：2023年3月13日

mongoose版本：v7.0.1

mongoose是一个对象文档模型（ODM）库，它对 Node 原生的 MongoDB 模块进行了进一步的优化封装，并提供了更多的功能。

一般有如下步骤：

  1. 连接数据库
  2. 定义Schema（集合结构【表结构】）
  3. 通过Schema创建模型对象
  4. 使用模型对象操作数据库（增删改查）

mongoose连接数据库

连接数据库的方法有两种，一种是使用 connect() 方法，一种是使用 createConnection() 方法。这两种方法在使用的时候是有一些区别的：

  1. 如果连接的数据库只有一个，可以选择使用 connect() 方法
  2. 如果连接的数据库有多个或者有多个权限不同的连接，只能使用 createConnection() 方法
使用connect()方法
const mongoose = require('mongoose')
// 此处连接的是test数据库，默认连接的也是test数据库
mongoose.connect('mongodb://127.0.0.1:27017/test')
    .then(() => {
    	console.log('连接成功')
	})
    .catch(err => {
    	console.log('连接失败：' + err)
	})
使用createConnection()方法
const mongoose = require('mongoose')
// 此处连接的是test数据库，默认连接的也是test数据库
const conn = mongoose.createConnection('mongodb://127.0.0.1:27017/test')

mongoose定义Schema

schema可以理解为mongodb中的集合结构（表结构）的定义，每个schema映射mongodb中的一个collection（表），不能直接操作数据库。

const mongoose = require('mongoose')

// 定义表结构，和数据库意义对应
const Schema = mongoose.Schema		//引入模式对象
const userSchema = new Schema({		//创建约束对象
    user_id: {
        type: String,
        required: true,  //必填项
        unique: true    //唯一
    },
    name: {
        type: String,
        required: true
    },
    email: String,
    password: String,
    date: {
        type: Date,
        default: Date.now()
    },
    info: Schema.Types.Mixed, //任意类型
})

mongoose创建模型对象

定义好了schema，接下来就是生成Model。model是由schema用于生成某个集合对应的模型对象，可以对数据库进行操作。

一个model对应一个集合（一张表）

如果是使用的 connect() 方法这种方式连接的数据库，创建模型对象的方法：

const mongoose = require('mongoose')
//参数1:模型名称(首字母大写), 参数2:Schema，参数3:集合名称，如果没有这个参数，则默认对应集合名称是参数1的复数形式
const userModel = mongoose.model('User', userSchema)	//创建模型对象

如果是 createConnection() 方法这种方式连接的数据看，创建模型对象的方法：

//参数1:模型名称(首字母大写), 参数2:Schema，参数3:集合名称，如果没有这个参数，则默认对应集合名称是参数1的复数形式
const userModel = conn.model('User', userSchema)

mongoose完整例子

connec()完整例子
const mongoose = require('mongoose')
// 1.连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/test')
    .then(() => {
    	console.log('连接成功')
    
    	// 2.定义Schema
        const Schema = mongoose.Schema		//引入模式对象
        const userSchema = new Schema({		//创建约束对象
            user_id: {
                type: String,
                required: true,  //必填项
                unique: true    //唯一
            },
            name: {
                type: String,
                required: true
            },
            email: String,
            password: String,
            date: {
                type: Date,
                default: Date.now()
            },
            info: Schema.Types.Mixed, //任意类型
        })
        
		// 3.通过Schema创建模型对象
        const userModel = mongoose.model('User', userSchema)
        
        // 4.使用模型对象操作数据库
		userModel.find({})
    .catch(err => {
    	console.log('连接失败：' + err)
	})
createConnection()完整例子
const mongoose = require('mongoose')

// 1.连接数据库
const conn = mongoose.createConnection('mongodb://127.0.0.1:27017/test')

// 2.定义Schema
const Schema = mongoose.Schema		//引入模式对象
const userSchema = new Schema({		//创建约束对象
    user_id: {
        type: String,
        required: true,  //必填项
        unique: true    //唯一
    },
    name: {
        type: String,
        required: true
    },
    email: String,
    password: String,
    date: {
        type: Date,
        default: Date.now()
    },
    info: Schema.Types.Mixed, //任意类型
})

// 3.通过Schema创建模型对象
const userModel = conn.model('User', userSchema)

// 4.使用模型对象操作数据库
userModel.find({})

mongoose操作数据库

创建好了模型对象，接下来就可以使用模型对象调用方法操作数据库了（增删改查）。

// 查询
// 参数1：查询条件，如果没有查询条件，则查询所有
// 参数2：查询字段，如果不想查询某个字段，则添加-
userModel.find({}) //查询所有
userModel.find({}, 'user_id name -_id') //查询 user_id name 但是不查询_id
Model.findById()
Model.findByIdAndDelete()
Model.findByIdAndRemove()
Model.findByIdAndUpdate()
Model.findOne()
Model.findOneAndDelete()
Model.findOneAndRemove()
Model.findOneAndReplace()
Model.findOneAndUpdate()

// 删除
Model.deleteMany({})		//如果没有删除条件，默认删除所有数据
Model.deleteOne({})  		//如果没有删除条件，默认删除第一条数据

// 更新
Model.updateMany()
Model.updateOne()

// 增加
userModel.create()

mongoose数据高级查询

or的使用

方法一：使用 $or 指定条件

const condition = {
    $or: [
        { name: 'zhangsan' },
        { email: 'zhangsan@qq.com' }
    ]
}
userModel.find(condition).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})

方法二：使用 or() 方法

userModel.find({}).or([
    { name: 'zhangsan' },
    { email: 'zhangsan@qq.com' }
]).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})
and的使用

方法一：使用 $and 指定条件

const condition = {
    $and: [
        { name: 'zhangsan' },
        { pwd: '123456' }
    ]
}
userModel.find(condition).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})

方法二：使用 and() 方法

userModel.find({}).and([
	{ name: 'zhangsan' },
	{ pwd: '123456' }
]).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})
or和and联合使用

方法一：使用 $or 和 $and 指定条件

const condition = {
    $and: [
        {
            $or: [
                { name: 'zhangsan' },
                { email: 'zhangsan@qq.com' }
            ]
        },
        { pwd: '123456' }
    ]
}
userModel.find(condition).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})

方法二：使用 or() 和 and() 方法

userModel.find({}).or([
	{ name: 'zhangsan' },
	{ email: 'zhangsan@qq.com' }
]).and([
    { password: '123456' }
]).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})
where的使用

方法一：使用 $where 指定条件

const condition = {
    $where: function() {
        return this.age > 18
    }
}
userModel.find(condition).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})

方法二：使用 where() 方法

userModel.find({}).where('age').gt(18).then(data => {
    console.log(data)
}).catch(err => {
    console.log(err)
})
常用查询条件

运算符

含义

$or

或关系

$nor

或关系取反

$gt

大于

$gte

大于等于

$lt

小于

$lte

小于等于

$ne

不等于

$in

在多个值范围内

$nin

不在多个值范围内

$all

匹配数组中多个值

$regex

正则，用于模糊查询

$size

匹配数组大小

$maxDistance

范围查询，距离（基于LBS）

$mod

取模运算

$near

邻域查询，查询附近的位置（基于LBS）

$exists

字段是否存在

$elemMatch

匹配内数组内的元素

$within

范围查询（基于LBS）

$box

范围查询，矩形范围（基于LBS）

$center

范围醒询，圆形范围（基于LBS）

$centerSphere

范围查询，球形范围（基于LBS）

$slice

查询字段集合中的元素（比如从第几个之后，第N到第M个元素

常用方法

方法

作用

Model.sort()

排序（1升序，-1降序）

Model.skip()

跳过

Model.limit()

限制

Model.select()

显示字段

Model.exec()

执行

Model.count()

计数

Model.countDocuments()

计算给定集合中的文档数

Model.estimatedDocumentCount()

获取文档总条数

Model.where()

条件

Model.equals()

等于

Model.distinct()

去重