Mongodb学习（Windows版本）

一、简介：

官方简介：https://www.mongodb.com/zh-cn/docs/v7.0/introduction/#std-label-intro-to-mongodb

1、定义：

Mongodb是一个基于分布式文件存储的数据库。

2、核心概念：

① 数据库（通常一个项目只有一个数据库）：

数据库服务下可以创建很多数据库，数据库可以存放很多集合。

理解：一个json文件就是一个数据库

② 集合：

集合可以存放很多文档，一个集合会存储同一种类型的数据。

理解：json文件中一个属性对应一个数组，一个数组就是一个集合。

③ 文档：

数据库的最小单位。

理解：json文件中一个数组中有多个对象，一个对象就是一个文档。

Tips：对象中的属性（key），也被称为字段

二、下载安装与启动：

1、mogodb三个版本的区别如下：

2、版本选择：

mongodb 6.0版本及以上缺少客户端程序，需要自己下载安装配置客户端程序 。如果不想下载，请安装 mongodb 5.0版本及以下。

3、下载安装启动 mongodb 服务器端程序（社区版）：

① 下载链接：

https://www.mongodb.com/try/download/community

② 选择平台、版本：

③ 配置安装：

（1） 官方教程链接：

https://www.mongodb.com/zh-cn/docs/v7.0/installation/#std-label-tutorial-installation

（2）个人教程：

a、将安装包解压后，放在 C:\Program Files下

Program Files文件夹专门用来存放程序文件，也可以放在别的文件夹下

b、设置mongodb数据默认的存放位置：

创建目录： C:\data\db

④ 启动mongodb的服务端程序：

（1）以bin目录为工作目录，启动命令行：

（2）输入mongod命令（或者双击 mongod.exe）：

看到waiting for connections代表启动成功

⑤ 注意事项：

（1）不要选中服务端窗口的内容，选中会停止服务！

（2）可以在本窗口中 按回车键（Enter） 进行恢复

4、下载安装启动 mongodb的客户端程序：

① 下载链接：

https://www.mongodb.com/try/download/shell

② 安装：

（1） 官方教程链接：

https://www.mongodb.com/zh-cn/docs/mongodb-shell/

（2）个人教程：

a、将安装包解压后，放在 C:\Program Files下

Program Files文件夹专门用来存放程序文件，也可以放在别的文件夹下

③ 启动mongodb的客户端程序：

（1）以bin目录为工作目录，启动命令行：

（2）输入 mongosh 命令（或者双击 mongosh.exe）：

看到下面的内容表示启动成功

（3）测试客户端与服务端的连接：

显示所有的数据库：show dbs

5、配置mongodb的客户端程序的便捷启动：

将 bin目录配置到环境变量 path 中：

① 找到系统的环境变量：

② 新增环境变量：

一直点击确定，直到没有弹窗

③ 测试是否配置成功：

（1）关闭所有的命令窗口：防止端口被占用引发冲突

（2）打开新的命令行窗口：WIN + R -》 cmd

（3）输入 mongod：

（4）打开新的命令行窗口：WIN + R -》 cmd

（5）输入 mongosh：

三、命令行交互（在客户端进行交互）：

1、数据库命令：

① 显示所有数据库：show dbs

只显示有数据的数据库

② 切换到指定的数据库：use 数据库名

如果数据库不存在，会自动创建数据为空的数据库。

③ 显示当前所在的数据库：db

④ 删除数据库：db.dropDatabase()

（1）删除当前所在的数据库：

直接执行db.dropDatabase()

（2）删除其它数据库：

先执行use 数据库名称（切换到指定的数据库），再直接执行db.dropDatabase()

2、集合命令：

① 创建集合：db.createCollection('集合名称')

mongoose会使用集合名称的复数，来命名集合

② 显示当前数据库中的所有集合：show collections

③ 删除某个集合：db.集合名.drop()

④ 重命名某个集合：db.集合名.renameCollection('集合新名称')

3、文档命令：

① 插入文档：db.集合名.insert(文档对象)

② 查询文档：

（1）查询所有的文档：db.集合名.find()

_id是mongodb自动生成的唯一编号，用来唯一标识文档

（2）按条件查询文档：db.集合名.find(查询条件)

③ 更新文档：

常用更新操作符：

（1）更新一个文档（匹配的第一个）：db.集合名.updateOne(查询条件, {更新操作符: 文档数据})

（2）更新多个文档（匹配的所有的）：db.集合名.updateMany(查询条件, {更新操作符: 文档数据})

④ 删除文档：

（1）删除一个文档（匹配的第一个）：db.集合名.deleteOne(删除条件)

（2）删除多个文档（匹配的所有的）：db.集合名.deleteMany(删除条件)

（3）删除当前集合下的所有文档：db.集合名.deleteMany({})

（4）查找并删除：db.集合名.findOneAndDelete(查询条件, 删除条件)

四、Mongoose：对象文档模型库

1、官网：

https://mongoosejs.net/

2、作用：

方便使用代码操作 mongodb 数据库

3、安装 Mongoose：

npm i mongoose

4、连接数据库：

终端要一直运行服务端程序！！！

① 引用 mongoose 模块：

const mongoose = require('mongoose')

② 数据库建立连接：

端口号默认是 27017

（1）创建默认全局连接：

mongoose.connect('mongodb://域名:端口号/数据库名称')

（2）创建独立连接实例：

mongoose.createConnection(mongodb://域名:端口号/数据库名称')

③ 数据库关闭连接：

（1）独立连接关闭：

实例对象.close()

（2）全局连接关闭（默认）：

mongoose.disconnect() 或者 mongoose.close()

④ 访问数据库连接实例：

（1）独立连接对象：

mongoose.createConnection() 函数调用后，返回新的连接对象

（2）全局连接对象（默认）：

存储在 mongoose.connection

⑤ 设置数据库连接回调：

（1）连接成功的回调：

a、 once：回调函数只会在第一次连接成功时执行

适合一次性操作（如初始化）

db.once('open', () => {
  console.log('首次连接成功');
});

b、 on：回调函数每次连接成功都会执行

适合错误处理（需要持续监控）、连接状态变化（需持久响应）

db.on('open', () => {
  console.log('数据库连接已建立（每次重连都会触发）');
});

（2）连接失败的回调：

先执行 连接断开 的回调，再执行 连接失败 的回调

db.on('error', () => {
    console.log('数据库连接失败')
})

（3）连接断开的回调：

db.on('disconnected', () => {
    console.log('数据库断开连接')
})

（4）连接关闭的回调：

先执行 连接断开 的回调，再执行 连接关闭 的回调

db.on('close', () => {
    console.log('数据库关闭连接')
})

⑤ 完整练习代码：

// 1、引入mongoose
const mongoose = require('mongoose')

// 2、全局连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 测试数据库连接失败
// mongoose.connect('mongodb://127.0.0.1:27018/a')
// 3、获取全局连接的实例
const db = mongoose.connection;
// 获取独立连接的实例
// let db = mongoose.createConnection('mongodb://127.0.0.1:27017/a')
// 4、设置回调
db.once('open', () => {
    console.log('数据库连接成功')
})

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

// 数据库关闭连接
// setTimeout(() => {
//     db.close()
// }, 5000)

5、文档的字段类型：

① 字符串： String

② 数字： Number

③ 布尔值： Boolean

④ 数组： Array 或者 []

⑤ 日期： Date

⑥ Buffer对象： Buffer

⑦ 任意类型： mongoose.Schema.Types.Mixed

⑧ 对象 ID： mongoose.Schema.Types.ObjectId

主要用于定义外键，即将另外一个文档的 id 存到 本文档中，进行联合查询

⑨ 高精度数字： mongoose.Schema.Types.Decimal128

6、验证器：

文档属性值（字段值）的验证

① 设置必填项：required: true

② 设置默认值：default: 数据

③ 设置枚举：enum: [数据1， 数据2，...]

属性值（字段值）必须是当前枚举中的数据

④ 唯一值：unique: true

如果在已有的集合中进行设置，则无用；需要新建集合才生效

属性值不允许重复！必须是唯一的！

⑤ 完整语法：

属性名：{
	type: 属性值的类型,
	验证器
}

⑥ 以 新增文档 为例的完整代码：

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: {
            type: String,
            required: true
        },
        age: {
            type: Number,
            default: 18,
        },
        sex: {
            type: String,
            enum: ['男', '女']
        },
        grade: {
            type: String,
            unique: true
        },
        hobby: Array
    })
    let person = mongoose.model('persons', personType)
    // 使用 `Promise` 语法新增数据
    person.create({
        name: 'red',
        age: undefined,
        sex: '男',
        grade:'大二',
        hobby: ['吃饭']
    }).then((data) => {
        // 新增后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('新增数据失败',err)
    })
    console.log('数据库连接成功')
})

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

7、文档的操作：

在数据库 连接成功的回调函数 中编写代码

① 创建文档的结构对象：

文档的结构：集合中文档的属性及属性值的类型

let 文档结构对象名 = new mongoose.Schema({
    属性名1: 属性值的类型1,
    属性名2: 属性值的类型2,
    ...
})

② 创建模型对象：

模型对象：对文档进行封装后，可以操作的对象

let 模型对象名 = mongoose.model(集合名，文档的结构对象名)

③ 创建文档：

如果属性名写错了，则忽略该属性

（1）使用 async/await 语法新增数据：

async function 新增文档的函数名(模型对象名) {
    try {
        const user = await 模型对象名.create(数据对象);
        // 新增后的文档对象
        console.log(user);
    } catch (err) {
        console.log('新增数据失败',err)
    }
}

（2）使用 Promise 语法新增数据：

模型对象名.create(数据对象).then((data) => {
    // 新增后的文档对象
    console.log(data);
}).catch((err) => {
    console.log('新增数据失败',err)
})

（3）完整的代码：

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: String,
        age: Number,
        sex: String,
        hobby: Array
    })
    let person = mongoose.model('persons', personType)
    // 新增数据
    // createData(person)

    // 使用 `Promise` 语法新增数据
    person.create({
        name: 'lisi',
        age: 23,
        sex: '女',
        hobby: ['打球']
    }).then((data) => {
        // 新增后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('新增数据失败',err)
    })
    console.log('数据库连接成功')
})
// 使用 `async/await` 语法新增数据
async function createData(person) {
    try {
        const user = await person.create({
            name: 'zhangsan',
            age: 20,
            sex: '男',
            hobby: ['吃饭', '睡觉', '打豆豆']
        });
        // 新增后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('新增数据失败',err)
    }
}

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

④ 删除文档：

（1）使用 async/await 语法删除数据：

a、删除一个文档（匹配的第一个）：

async function deleteData(person) {
    try {
        const user = await person.deleteOne(删除的条件);
        // 删除后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('删除数据失败',err)
    }
}

b、删除多个文档（匹配的所有的）：

async function deleteData(person) {
    try {
        const user = await person.deleteMany(删除的条件);
        // 删除后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('删除数据失败',err)
    }
}

（2）使用 Promise 语法删除数据：

a、删除一个文档（匹配的第一个）：

模型对象名.deleteOne(删除条件).then((data) => {
    // 删除后的文档对象
    console.log(data);
}).catch((err) => {
    console.log('删除数据失败',err)
})

b、删除多个文档（匹配的所有的）：

模型对象名.deleteMany(删除条件).then((data) => {
    // 删除后的文档对象
    console.log(data);
}).catch((err) => {
    console.log('删除数据失败',err)
})

（3）完整的代码：

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: {
            type: String,
            required: true
        },
        age: {
            type: Number,
            default: 18,
        },
        sex: {
            type: String,
            enum: ['男', '女']
        },
        grade: {
            type: String,
            unique: true
        },
        hobby: Array
    })
    let person = mongoose.model('persons', personType)

    // 删除数据
    deleteData(person)

    // 使用 `Promise` 语法删除数据
    // 删除一条
    // person.deleteOne({age: 0}).then((data) => {
    // 删除多条
    // person.deleteMany({age: 25}).then((data) => {
    //     // 删除后的文档对象
    //     console.log(data);
    //     // 断开数据库连接。项目运行过程中，不会添加该代码
    //     mongoose.disconnect()
    // }).catch((err) => {
    //     console.log('删除数据失败',err)
    // })
    console.log('数据库连接成功')
})
// 使用 `async/await` 语法删除数据
async function deleteData(person) {
    try {
        // 删除一条
        // const user = await person.deleteOne({age: 0});
        // 删除多条
        const user = await person.deleteMany({age: 25});
        // 删除后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('删除数据失败',err)
    }
}

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

⑤ 更新文档：

（1）使用 async/await 语法更新数据：

a、更新一个文档（匹配的第一个）：

async function updateData(person) {
    try {
        const user = await person.updateOne(查找数据的条件, 新数据);
        // 更新后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('更新数据失败',err)
    }
}

b、更新多个文档（匹配的所有的）：

async function updateData(person) {
    try {
        const user = await person.updateMany(查找数据的条件, 新数据);
        // 更新后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('更新数据失败',err)
    }
}

（2）使用 Promise 语法更新数据：

a、更新一个文档（匹配的第一个）：

模型对象名.updateOne(查找数据的条件, 新数据).then((data) => {
    // 更新后的文档对象
    console.log(data);
}).catch((err) => {
    console.log('更新数据失败',err)
})

b、更新多个文档（匹配的所有的）：

模型对象名.updateMany(查找数据的条件, 新数据).then((data) => {
    // 更新后的文档对象
    console.log(data);
}).catch((err) => {
    console.log('更新数据失败',err)
})

（3）完整的代码：

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: {
            type: String,
            required: true
        },
        age: {
            type: Number,
            default: 18,
        },
        sex: {
            type: String,
            enum: ['男', '女']
        },
        grade: {
            type: String,
            unique: true
        },
        hobby: Array
    })
    let person = mongoose.model('persons', personType)

    // 更新数据
    // updateData(person)

    // 使用 `Promise` 语法更新数据
    // 更新一条
    // person.updateOne({sex: '女'}, {name: '小绿'}).then((data) => {
    // 更新多条
    person.updateMany({sex: '男'}, {name: '小哥'}).then((data) => {
        // 更新后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('更新数据失败',err)
    })
    console.log('数据库连接成功')
})
// 使用 `async/await` 语法更新数据
async function updateData(person) {
    try {
        // 更新一条
        // const user = await person.updateOne({sex: '女'}, {name: '小红'});
        // 更新多条
        const user = await person.updateMany({sex: '男'}, {name: '小华'});
        // 更新后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('更新数据失败',err)
    }
}

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

⑥ 查询文档：

（1）使用 async/await 语法查询数据：

a、查询一个文档（匹配的第一个）：

async function findData(person) {
    try {
        const user = await person.findOne(查询的条件);
        // 查询后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('查询数据失败',err)
    }
}

b、根据_Id查询文档（_id是mongoose自动生成的）：

async function findData(person) {
    try {
        const user = await person.findById(_id的值);
        // 查询后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('查询数据失败',err)
    }
}

c、查询匹配的多个文档（匹配的所有的）：

async function findData(person) {
    try {
        const user = await person.find(查询的条件);
        // 查询后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('查询数据失败',err)
    }
}

d、查询当前集合下的所有文档：

async function findData(person) {
    try {
        const user = await person.find();
        // 查询后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('查询数据失败',err)
    }
}

（2）使用 Promise 语法查询数据：

a、查询一个文档（匹配的第一个）：

模型对象名.findOne(查找数据的条件).then((data) => {
    // 查找的文档对象
    console.log(data);
}).catch((err) => {
    console.log('查找数据失败',err)
})

b、根据_Id查询文档（_id是mongoose自动生成的）：

模型对象名.findById(_id的值).then((data) => {
    // 查找的文档对象
    console.log(data);
}).catch((err) => {
    console.log('查找数据失败',err)
})

c、查询匹配的多个文档（匹配的所有的）：

模型对象名.find(_查询的条件).then((data) => {
    // 查找的文档对象
    console.log(data);
}).catch((err) => {
    console.log('查找数据失败',err)
})

d、查询当前集合下的所有文档：

模型对象名.find().then((data) => {
    // 查找的文档对象
    console.log(data);
}).catch((err) => {
    console.log('查找数据失败',err)
})

（3）完整的代码：

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: {
            type: String,
            required: true
        },
        age: {
            type: Number,
            default: 18,
        },
        sex: {
            type: String,
            enum: ['男', '女']
        },
        grade: {
            type: String,
            unique: true
        },
        hobby: Array
    })
    let person = mongoose.model('persons', personType)

    // 查询数据
    // findData(person)

    // 使用 `Promise` 语法查询数据
    // 查询一条
    // person.findOne({sex: '女'}).then((data) => {
    // 根据id查询
    // person.findById('68491e76d4d339bb1ac779a9').then((data) => {
    // 查询多条
    // person.find({sex: '男'}).then((data) => {
    // 查询所有数据
    person.find().then((data) => {
        // 查询后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('查询数据失败',err)
    })
    console.log('数据库连接成功')
})
// 使用 `async/await` 语法查询数据
async function findData(person) {
    try {
        // 查询一条
        // const user = await person.findOne({sex: '女'});
        // 根据id查询
        // const user = await person.findById('68491e76d4d339bb1ac779a9');
        // 查询多条
        // const user = await person.find({sex: '男'});
        // 查询所有数据
        const user = await person.find();
        // 查询后的文档对象
        console.log(user);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    } catch (err) {
        console.log('查询数据失败',err)
    }
}

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

8、条件控制：

① 运算符：

（1）大于：$gt

（2）小于：$lt

（3）大于等于：$gte

（4）小于等于：$lte

（5）不恒等于：$ne

（6）使用语法：

{字段名: {运算符: 数值}}

（7）完整的代码：

查询 age大于等于18， age小于等于20 的数据

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: {
            type: String,
            required: true
        },
        age: {
            type: Number,
            default: 18,
        },
        sex: {
            type: String,
            enum: ['男', '女']
        },
        grade: {
            type: String,
            unique: true
        },
        hobby: Array
    })
    let person = mongoose.model('persons', personType)

    // 使用 `Promise` 语法查询数据
    person.find({
        age: {
            $gte: 18,
            $lte: 20
        }
    }).then((data) => {
        // 查询后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('查询数据失败',err)
    })
    console.log('数据库连接成功')
})

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

② 逻辑运算：

（1）逻辑或：$or

（2）逻辑与：$and

（3）使用语法：

{逻辑运算符: [条件1, 条件2, ...]}

（4）完整代码：

查询 age大于等于18，age小于等于20；name是 小绿或者小哥 的数据

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: {
            type: String,
            required: true
        },
        age: {
            type: Number,
            default: 18,
        },
        sex: {
            type: String,
            enum: ['男', '女']
        },
        grade: {
            type: String,
            unique: true
        },
        hobby: Array
    })
    let person = mongoose.model('persons', personType)

    // 使用 `Promise` 语法查询数据
    person.find({
        age: {
            $gte: 18,
            $lte: 20
        },
        $or: [{
            name: '小绿'
        }, {
            name: '小哥'
        }]
    }).then((data) => {
        // 查询后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('查询数据失败',err)
    })
    console.log('数据库连接成功')
})

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

③ 正则匹配：

（1）使用语法：

a、字面量形式：

{字段名: /正则语法/}

b、对象形式：

{字段名: new RegExp(正则语法)}

（2）完整代码：

查询 age大于等于18，age小于等于20；name是 小绿或者小哥；grade的值带有 二 的数据

// 1、引入mongoose
const mongoose = require('mongoose')
// 2、连接数据库
mongoose.connect('mongodb://127.0.0.1:27017/a')
// 3、获取连接的实例
const db = mongoose.connection;
// 4、设置回调
db.once('open', () => {
    let personType = new mongoose.Schema({
        name: {
            type: String,
            required: true
        },
        age: {
            type: Number,
            default: 18,
        },
        sex: {
            type: String,
            enum: ['男', '女']
        },
        grade: {
            type: String,
            unique: true
        },
        hobby: Array
    })
    let person = mongoose.model('persons', personType)

    // 使用 `Promise` 语法查询数据
    person.find({
        age: {
            $gte: 18,
            $lte: 20
        },
        $or: [{
            name: 'orange'
        }, {
            name: '小哥'
        }],
        // grade: /二/,
        grade: new RegExp('二')
    }).then((data) => {
        // 查询后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('查询数据失败',err)
    })
    console.log('数据库连接成功')
})

db.on('error', () => {
    console.log('数据库连接失败')
})
db.on('disconnected', () => {
    console.log('数据库断开连接')
})
db.on('close', () => {
    console.log('数据库关闭连接')
})

9、个性化读取：

exec()函数：用于精确的控制查询的执行

① 字段筛选：select({字段名: 取值})

取值0：不需要的字段；取值1：需要的字段

如果使用字段筛选，_id默认是需要的字段，其它字段默认是不需要的字段
示例：返回当前集合中的name列表

person.find().select({name: 1, _id: 0}).then((data) => {
    // 查询后的文档对象
    console.log(data);
    // 断开数据库连接。项目运行过程中，不会添加该代码
    mongoose.disconnect()
}).catch((err) => {
    console.log('查询数据失败',err)
})

② 数据排序：sort({字段名: 取值})

取值1：升序；取值-1：倒序

如果使用字段筛选，_id默认是需要的字段，其它字段默认是不需要的字段
示例：根据age进行从小到大排序，然后返回当前集合中的name列表

// 将查询和构建分离
letnames = person.find().select({name: 1, _id: 0})
names.sort({age: 1})
names.exec().then((data) => {
    // 查询后的文档对象
    console.log(data);
    // 断开数据库连接。项目运行过程中，不会添加该代码
    mongoose.disconnect()
}).catch((err) => {
    console.log('查询数据失败',err)
})

③ 数据截取：

（1）限制返回数据的个数：limit(数量)

示例：根据age进行从小到大排序，然后返回当前集合中的前3位的name列表

person.find().select({name: 1, _id: 0}).sort({age: 1}).limit(3).exec().then((data) => {
        // 查询后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('查询数据失败',err)
    })
    console.log('数据库连接成功')

（2）限制数据从第几个数据开始返回：skip(数量)

示例：根据age进行从小到大排序，然后跳过第一位，返回当前集合中的前3位的name列表

person.find().select({name: 1, _id: 0}).sort({age: 1}).skip(1).limit(3).then((data) => {
        // 查询后的文档对象
        console.log(data);
        // 断开数据库连接。项目运行过程中，不会添加该代码
        mongoose.disconnect()
    }).catch((err) => {
        console.log('查询数据失败',err)
    })

10、代码模块化（CommonJs规范）：

① 初始的 index.js文件：初始化

// 引入数据库连接处理
const db = require('./db/index.js')
const func = require('./model/index.js')
db.dbFunc(func.createPerson)

② 数据库 index.js文件：数据库连接操作

// 数据库连接处理
const mongoose = require('mongoose')
const DBData = {
    IP: '127.0.0.1',
    PORT: '27017',
    DBNAME: 'a'
}
mongoose.connect(`mongodb://${DBData.IP}:${DBData.PORT}/${DBData.PORT}`)
const db = mongoose.connection;

let dbFunc = function(success, error) {
    if (typeof error !== 'function') {
        error = () => { console.log('数据库连接失败') }
    }
    db.once('open', () => {
        success()
    })
    db.on('error', () => {
        error()
    })
    db.on('disconnected', () => {
        console.log('数据库断开连接')
    })
    db.on('close', () => {
        console.log('数据库关闭连接')
    })
}
module.exports = {
    dbFunc,
    DBData
}

③ 模型库 schema.js文件：定义结构对象

// 结构对象
const personType = {
    name: {
        type: String,
        required: true
    },
    age: {
        type: Number,
        default: 18,
    },
    sex: {
        type: String,
        enum: ['男', '女']
    }
}

const bookType = {
    title: {
        type: String,
    },
    author: {
        type: String,
        default: '匿名',
    },
}
module.exports = {
    personType,
    bookType
}

④ 模型库 index.js文件：数据库连接成功的操作

let mongoose = require('mongoose')
const {personType} = require('./schema.js')
const createPerson = function() {
    let personObj = new mongoose.Schema(personType)
    let person = mongoose.model('persons', personObj)
    person.create({
        name: 'purple',
        age: 25,
        sex: '女'
    }).then((data) => {
        console.log('新增的数据', data)
        mongoose.disconnect()
    }).catch((err) => {
        console.log('新增数据失败',err)
    })
}
module.exports = {
    createPerson
}

五、mongodb 图形化工具：

1、MongoDB Compass（官方工具）：

https://www.mongodb.com/try/download/compass

2、Robo 3T（免费）：

https://github.com/Studio3T/robomongo/releases

3、Navicate（付费）：

https://www.navicat.com.cn/products