当前位置：首页 > news >正文

培训网站搭建什么是网站快照

news 2025/11/4 3:08:54

培训网站搭建,什么是网站快照,泉州企业免费建站,一个域名可以做中英文两个网站吗一、简介： 官方简介：https://www.mongodb.com/zh-cn/docs/v7.0/introduction/#std-label-intro-to-mongodb 1、定义： Mongodb是一个基于分布式文件存储的数据库。 2、核心概念： ① 数据库（通常一个项目只有一个数据…

一、简介：

官方简介：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
}