09_MongoDB

1.简介

1.1 Mongodb 是什么

MongoDB 是一个基于分布式文件存储的数据库，官方地址 https://www.mongodb.com/

1.2 数据库是什么

数据库（DataBase）是按照数据结构来组织、存储和管理数据的 应用程序。

没错，数据库就是一个应用程序。是不是和我所理解的应用程序差别很大，我所理解的应用程序是有界面、严重依赖鼠标、键盘只是用于输入必要信息、完全不用输入代码的程序。

像数据库这样的应用程序，其实我也做过，vue、html、react甚至是编程语言的任意第三方库，都相当于是应用程序，只不过数据库的抽象程度非常高，不容易掌握。

1.3 数据库的作用

数据库的主要作用就是 管理数据 ，对数据进行 增（c）、删（d）、改（u）、查（r）

1.4 数据库管理数据的特点

相比于纯文件管理数据（纯文本管理数据，最起码有IO瓶颈、IO冲突等问题，像pandas这样的数据处理库，是没有办法解决的），数据库管理数据有如下特点：

1. 速度更快
2. 扩展性更强
3. 安全性更强

数据库其实是一个应用程序，原来我是不知道的。我对数据库只有模糊的印象，别人说要用，我就用，因为数据库太难学，所以一直没用。

为什么要使用数据库？因为数据库可以帮助我解决很多问题，不管是开发还是部署，都已经有了成熟的方案，照着做就行了。而且数据库里面有各种数据结构，所以响应速度非常快。我只需要知道怎么使用“数据库”这种软件就行了。

1.5 为什么选择 Mongodb

操作语法与 JavaScript 类似，容易上手，学习成本低。

2.核心概念

Mongodb 中有三个重要概念需要掌握

• 数据库（database） 数据库是一个数据仓库，数据库服务下可以创建很多数据库，数据库中可以存放很多集合
• 集合（collection） 集合类似于 JS 中的数组，在集合中可以存放很多文档
• 文档（document） 文档是数据库中的最小单位，类似于 JS 中的对象

什么是“数据库服务”？

MongoDB就是一个数据库服务，例如在本机的MongoDB中，可以创建多个数据库。

JSON 文件示例：

xxxxxxxxxx
45
1
{
2
    "accounts": [
3
        {
4
            "id": "3-YLju5f3",
5
            "title": "买电脑",
6
            "time": "2023-02-08",
7
            "type": "-1",
8
            "account": "5500",
9
            "remarks": "为了上网课"
10
        },
11
        {
12
            "id": "3-YLju5f4",
13
            "title": "请女朋友吃饭",
14
            "time": "2023-02-08",
15
            "type": "-1",
16
            "account": "214",
17
            "remarks": "情人节聚餐"
18
        },
19
        {
20
            "id": "mRQiD4s3K",
21
            "title": "发工资",
22
            "time": "2023-02-19",
23
            "type": "1",
24
            "account": "4396",
25
            "remarks": "终于发工资啦!~~"
26
        }
27
    ],
28
    "users":[
29
        {
30
            "id": 1,
31
            "name": "zhangsan",
32
            "age": 18
33
        },
34
        {
35
            "id": 2,
36
            "name": "lisi",
37
            "age": 20
38
        },
39
        {
40
            "id": 3,
41
            "name": "wangwu",
42
            "age": 22
43
        }
44
    ]
45
}

大家可以通过 JSON 文件来理解 Mongodb 中的概念

• 一个 JSON 文件 好比是一个 数据库 ，一个 Mongodb 服务下可以有 N 个数据库
• JSON 文件中的 一级属性的数组值 好比是 集合
• 数组中的对象好比是 文档
• 对象中的属性有时也称之为 字段

一般情况下

• 一个项目使用一个数据库
• 一个集合会存储同一种类型的数据

3.下载安装与启动

下载地址： https://www.mongodb.com/try/download/community

建议选择 zip 类型， 通用性更强。不过我是下载的msi，直接安装即可，下面的配置步骤都是针对zip类型安装来的。

配置步骤如下:

1> 将压缩包移动到 C:\Program Files 下，然后解压

2> 创建 C:\data\db 目录，mongodb 会将数据默认保存在这个文件夹

3> 以 mongodb 中 bin 目录作为工作目录，启动命令行

4> 运行命令 mongod

看到最后的 waiting for connections 则表明服务已经启动成功

然后可以使用 mongo 命令连接本机的 mongodb 服务，里面可以输入mongo的命令。

注意：

• 为了方便后续方便使用 mongod 命令，可以将 bin 目录配置到环境变量 Path 中
• 千万不要选中服务端窗口的内容 ，选中会停止服务，可以 敲回车 取消选中
• 如果想要在命令行中使用MongoDB，需要先启动服务mongod，然后另外开一个命令行，输入mongo来连接MongoDB的服务。

4.命令行交互

命令行交互一般是学习数据库的第一步，不过这些命令在后续用的比较少，所以大家了解即可。

4.1 数据库命令

1. 显示所有的数据库

xxxxxxxxxx
1
1
show dbs

2. 切换到指定的数据库，如果数据库不存在会自动创建数据库

xxxxxxxxxx
1
1
use 数据库名

3. 显示当前所在的数据库

xxxxxxxxxx
1
1
db

4. 删除当前数据库（首先要切换到要删除的数据库，并且删除的命令不需要指定数据库名称）

xxxxxxxxxx
2
1
use 库名
2
db.dropDatabase()

4.2 集合命令

1. 创建集合

xxxxxxxxxx
1
1
db.createCollection('集合名称')

2. 显示当前数据库中的所有集合

xxxxxxxxxx
1
1
show collections

3. 删除某个集合

xxxxxxxxxx
1
1
db.集合名.drop()

4. 重命名集合

xxxxxxxxxx
1
1
db.集合名.renameColletion('newName')

4.3 文档命令

1. 插入文档

xxxxxxxxxx
4
1
db.集合名.insert(文档对象)
2
​
3
// 例子
4
db.users.insert({name:'张三',age:18})

2. 查询文档。查询条件如果为空，表示查询所有数据。

xxxxxxxxxx
4
1
db.集合名.find(查询条件)
2
​
3
// 例子
4
db.users.find({name:'张三'})

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

3. 更新文档

xxxxxxxxxx
4
1
db.集合名.update(查询条件,新的文档)
2
​
3
// 例子
4
db.users.update({name:'张三'},{$set:{age:19}})

4. 删除文档

xxxxxxxxxx
4
1
db.集合名.remove(查询条件)
2
​
3
// 例子
4
db.users.remove({name:'张三'})

4.4 应用场景

4.4.1 新增

• 用户注册
• 发布视频
• 发布商品
• 发朋友圈
• 发评论
• 发微博
• 发弹幕
• .......

4.4.2 删除

• 删除评论
• 删除商品
• 删除文章
• 删除视频
• 删除微博
• ......

有些情况下，可以做伪删除，帮助用户如果需要数据的时候，可以恢复。比如说在一个数据对象里面，添加is_deleted属性，如果删除，则设置为true，这样在返回数据结果的时候，加上这个条件即可。

4.4.3 更新

• 更新个人信息
• 修改商品价格
• 修改文章内容
• ......

4.4.4 查询

• 商品列表
• 视频列表
• 朋友圈列表
• 微博列表
• 搜索功能
• ......

记住使用场景对我来说非常有用，因为我的项目经验有限，什么时候需要使用MongoDB，什么时候使用关系型数据库，这些都还不知道，所以我把使用场景记下来，等遇到的时候，想起来就行了。

ORM模型，现在看来只适合于关系型数据库，不管是sequelize还是prisma，在里面我都没有看到引入MongoDB或者其它的No SQL。另外我看了一下MongoDB的文档，里面的查询语言本身和ORM模型的语言很类似，所以就没有人来编写它的ORM模型。（2023-11-15记录：这个理解是错误的，因为MongoDB最好的ORM模型就是mongoose，谁说没有的）

关系型数据库和No SQL没有谁更重要的问题，而是谁更适合某些场景，在下面这些场景下，使用No SQL是最好的选择。

MongoDB 主要应用于以下场景：

• 内容管理：MongoDB 可以用于存储网站的文章、博客、图片、视频等内容。
• 社交网络：MongoDB 可以用于存储社交网络用户的信息、帖子、评论等数据。
• 物联网：MongoDB 可以用于存储物联网设备的数据，如传感器数据、位置信息等。
• 游戏：MongoDB 可以用于存储游戏用户的数据，如角色信息、装备信息等。
• 大数据分析：MongoDB 可以用于存储大数据，并提供灵活的查询和分析能力。

以下是一些具体的例子：

• 亚马逊的电子商务平台 Amazon.com 使用 MongoDB 存储商品信息、订单信息、用户信息等。
• Facebook 使用 MongoDB 存储用户信息、帖子信息、评论信息等。
• Uber 使用 MongoDB 存储司机信息、乘客信息、订单信息等。
• 腾讯游戏使用 MongoDB 存储游戏用户信息、游戏数据等。
• 阿里巴巴使用 MongoDB 存储电商交易数据、物流数据等。

以下是MongoDB的主要应用场景以及一些示例：

1. 内容管理系统（CMS）：

   • 示例： 一个新闻网站可以使用MongoDB来存储文章、图片、视频和评论等内容，每个内容项都可以表示为一个文档。这样的CMS系统可以轻松地扩展以处理大量的新闻和媒体内容。

2. 社交媒体应用程序：

   • 示例： 社交媒体平台可以使用MongoDB存储用户资料、帖子、评论、关注关系等数据。由于MongoDB支持嵌套文档，可以将用户的活动流存储在其个人资料文档中，使实时推送和社交互动更高效。

3. 实时分析和大数据处理：

   • 示例： 一家电子商务公司可以使用MongoDB来存储销售数据、用户行为和产品信息。通过MongoDB的聚合功能，可以实时分析销售趋势、用户偏好和库存情况，以做出及时的经营决策。

4. 物联网（IoT）和传感器数据：

   • 示例： IoT设备可以生成大量数据，如温度、湿度、位置等。MongoDB可以用于存储和查询这些数据，以监控设备状态、执行预测维护和生成实时报告。

5. 实时应用程序：

   • 示例： 在线游戏和聊天应用程序需要快速响应用户的操作和实时更新。MongoDB可以用于存储用户配置、游戏状态和聊天消息，以实现实时互动。

6. 日志和事件存储：

   • 示例： 大型服务器集群生成大量的日志和事件数据。MongoDB可以用于存储和检索这些数据，以进行系统监控、性能分析和故障排除。

7. 地理空间数据：

   • 示例： 地图应用程序和位置服务可以使用MongoDB来存储地理空间数据，如地点、地区边界和路线。这些数据可以用于位置搜索、导航和地理信息分析。

5.Mongoose

5.1 介绍

Mongoose 是一个对象文档模型库，官网 http://www.mongoosejs.net/，前面是中文网，不忍直视。还是直接看英文网：https://mongoosejs.com/。

5.2 作用

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

其实一直搞不懂为什么SQL有自己的语言，在项目中使用的时候却要使用ORM模型。

原因其实很简单，我如何才能针对不同的需求简洁、快速地写出不同的SQL语句呢？我如果想要使用原生SQL语句做到，还要在模板字符串里面写SQL语句，SQL语句复杂的时候有多长你知道吗？一个简单的关联查询就会很长了，更不要说复杂的增删改查了。模板字符串不方便的，是真不方便，里面预留出的${}真的能够应付不同的需求吗？我看未必，所以就每一个数据库，都会有很多ORM模型设计出来，使用ORM真的很方便。

5.3 使用流程

5.3.1 基本使用

创建一个文件夹，使用npm init -y来初始化包，在里面安装mongoose。

看到下面的内容，可能会感觉有些奇怪，mongoose是在单个js文件里面使用的啊，为什么要初始化一个包呢？

因为要用到mongoose，需要导入才能使用。

1. 安装 mongoose

npm i mongoose

​x
1
// 1、 安装mongoose
2
// 2、 导入mongoose
3
const mongoose = require("mongoose");
4
​
5
// 3、连接MongoDB服务。注意：连接的是具体的数据库，如果此数据库不存在，则创建。
6
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
7
​
8
// 4、设置回调
9
// 设置连接成功的回调
10
mongoose.connection.on("open", () => {
11
  console.log("连接成功！");
12
});
13
// 设置连接失败的回调
14
mongoose.connection.on("error", () => {
15
  console.log("连接失败！");
16
});
17
// 设置连接关闭的回调
18
mongoose.connection.on("close", () => {
19
  console.log("连接关闭！");
20
});

测试之前，一定要把MongoDB服务启动，命令行中输入mongod启动。执行这个文件，看效果：

在上述代码最后加上这段代码，演示一下连接关闭的效果：

xxxxxxxxxx
4
1
// 关闭mongodb连接
2
setTimeout(() => {
3
    mongoose.disconnect();
4
}, 2000);

注意：一般在项目中，是不需要关闭连接的，因为项目上线后就是为了不断使用的。

5.3.2 连接mongodb补充说明

在mongodb@5.x版本中，官方推荐在绑定open方法时，使用once来绑定。http://www.mongoosejs.net/docs/index.html

xxxxxxxxxx
4
1
// 设置连接成功的回调
2
mongoose.connection.once("open", () => {
3
  console.log("连接成功！");
4
});

为什么要改成使用once来绑定open事件呢？因为once表示open事件里面的回调函数只执行一次，而on表示open事件里面的回调函数每次触发都会执行。假如说mongodb连接掉线了，那么mongoose会尝试重新连接，重新连接上之后，使用on绑定的事件都会执行一次，而once在之前已经执行过了，此时就不会再次执行了。

那么open事件的回调函数里面会放一些只需要执行一次的代码，在后面的学习中可以看到。

5.3.3 使用mongoose向mongodb数据库插入文档

注意：

在学习的时候，由于MongoDB是5.x版本，所以相应的mongoose也是5.x版本。现在MongoDB最新版是8.x版本，所以mongoose也是8.x版本。

定义文档结构的时候，我一直都没有使用new关键字，而是直接定义，项目并没有报错：

xxxxxxxxxx
5
1
let BookSchema = mongoose.Schema({
2
 name: String,
3
 author: String,
4
 price: Number,
5
});

现在看了官方文档之后，发现定义文档结构的时候，都使用了new关键字，所以以后一定要加上这个关键字，避免意想不到的bug。

下面的笔记中我看到的位置都会加上new关键字，但是难免有没有改到的地方，那么看到了就要注意。

xxxxxxxxxx
69
1
// 2、 导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  console.log("连接成功！");
11
  // 5、创建文档的结构对象。schema英文意思是：A schema is an outline of a plan or theory。可以翻译为模式、图式。这里翻译为结构。
12
  // 作用：设置集合（collections）中的文档（document）的属性以及属性值的类型。
13
  let BookSchema = new mongoose.Schema({
14
    name: String,
15
    author: String,
16
    price: Number,
17
  });
18
​
19
  // 6、创建模型对象
20
  // 模型对象的作用：对文档操作的封装对象。意味着对文档的任何操作（CRUD），可以通过模型对象来完成。我有一个疑问：为什么是通过操作文档模型来增删改查呢？而不是通过操作集合来实现呢？这个暂时不知道，也许等我设计一个ORM时就清楚这么做的好处了。
21
  // 2023-11-20 也许刚开始我是真的不懂，本来就是操作模型对象（相当于集合）来增删改查，文档的结构对象只是定义模型对象的一个参数而已，定义出来就好了。
22
  // 第一个参数是集合的名称（如果没有就创建），第二个参数是文档的结构对象。
23
  let BookModel = mongoose.model("books", BookSchema);
24
​
25
  // 7、调用模型对象，进行具体操作，比如说：新增、修改、删除、查询
26
  // 新增。模型对象的create方法接收两个参数，第一个参数是数据对象，第二个参数是回调函数。
27
    
28
  // mongoose@5.x版本用法
29
  //   BookModel.create(
30
  //     {
31
  //       name: "西游记",
32
  //       author: "吴承恩",
33
  //       price: 19.9,
34
  //     },
35
  //     (err, data) => {
36
  //       if (err) {
37
  //         console.log(err);
38
  //         return;
39
  //       }
40
  //       // data是插入成功之后的文档对象
41
  //       // 如果没有出错，则输出插入后的文档对象。这一步一般在实际项目中不需要，因为实际项目中需要返回的是code编码给前端。
42
  //       console.log(data);
43
  //     }
44
  //   );
45
​
46
  // mongoose@7.5.3用法，直接使用链式调用。
47
  BookModel.create({
48
    name: "西游记",
49
    author: "吴承恩",
50
    price: 19.9,
51
  }).then((err, data) => {
52
    if (err) {
53
      console.log(err);
54
      return;
55
    }
56
    // data是插入成功之后的文档对象
57
    // 如果没有出错，则输出插入后的文档对象。这一步一般在实际项目中不需要，因为实际项目中需要返回的是code编码给前端。
58
    console.log(data);
59
  });
60
});
61
// 设置连接失败的回调
62
mongoose.connection.on("error", () => {
63
  console.log("连接失败！");
64
});
65
// 设置连接关闭的回调
66
mongoose.connection.on("close", () => {
67
  console.log("连接关闭！");
68
});
69
​

执行查看效果：

这里的_id是mongodb为我们生成的一个唯一编号。__v是mongoose为我们生成的一个版本编号，一般用不到。

查询数据库，也可以看到数据插入成功了。

5.4 mongoose字段类型

文档结构可选的常用字段类型列表

5.5 字段值验证

Mongoose 有一些内建验证器，可以对字段值进行验证。在创建文档的结构对象时，除了指定属性值类型外，还可以进行验证。

xxxxxxxxxx
9
1
let BookSchema = new mongoose.Schema({
2
    // name: String,
3
    name: {
4
      type: String,
5
      required: true,// 设置必填项
6
    },
7
    author: String,
8
    price: Number,
9
  });

5.5.1 必填项

xxxxxxxxxx
4
1
title: {
2
    type: String,
3
    required: true // 设置必填项
4
},

5.5.2 默认值

xxxxxxxxxx
4
1
author: {
2
    type: String,
3
    default: '匿名' //默认值
4
},

5.5.3 枚举值

xxxxxxxxxx
4
1
gender: {
2
    type: String,
3
    enum: ['男','女'] //设置的值必须是数组中的值
4
},

5.5.4 唯一值

xxxxxxxxxx
4
1
username: {
2
    type: String,
3
    unique: true
4
},

unique 需要 重建集合 才能有效果。什么叫“重建”？重建就是先删除集合再创建集合，重新创建。

永远不要相信用户的输入，字段值验证是非常必须的。

5.6 CURD

为了保证数据的完整性，可以先将bilibili数据库删除掉，执行下面的代码。

xxxxxxxxxx
4
1
# 打开mongo命令行
2
​
3
use bilibili
4
db.dropDatabase()

 

数据库的基本操作包括四个，增加（create），删除（delete），修改（update），查（read）。为了方便学习，先将老师提供的data.js执行一下，插入一些数据。

xxxxxxxxxx
173
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 7、新增
22
  BookModel.insertMany([
23
    {
24
      name: "西游记",
25
      author: "吴承恩",
26
      price: 19.9,
27
      is_hot: true,
28
    },
29
    {
30
      name: "红楼梦",
31
      author: "曹雪芹",
32
      price: 29.9,
33
      is_hot: true,
34
    },
35
    {
36
      name: "三国演义",
37
      author: "罗贯中",
38
      price: 25.9,
39
      is_hot: true,
40
    },
41
    {
42
      name: "水浒传",
43
      author: "施耐庵",
44
      price: 20.9,
45
      is_hot: true,
46
    },
47
    {
48
      name: "活着",
49
      author: "余华",
50
      price: 19.9,
51
      is_hot: true,
52
    },
53
    {
54
      name: "狂飙",
55
      author: "徐纪周",
56
      price: 68,
57
      is_hot: true,
58
    },
59
    {
60
      name: "大魏能臣",
61
      author: "黑男爵",
62
      price: 9.9,
63
      is_hot: false,
64
    },
65
    {
66
      name: "知北游",
67
      author: "洛水",
68
      price: 59,
69
      is_hot: false,
70
    },
71
    {
72
      name: "道君",
73
      author: "跃千愁",
74
      price: 59,
75
      is_hot: false,
76
    },
77
    {
78
      name: "七煞碑",
79
      author: "游泳的猫",
80
      price: 29,
81
      is_hot: false,
82
    },
83
    {
84
      name: "独游",
85
      author: "酒精过敏",
86
      price: 15,
87
      is_hot: false,
88
    },
89
    {
90
      name: "大泼猴",
91
      author: "甲鱼不是龟",
92
      price: 26,
93
      is_hot: false,
94
    },
95
    {
96
      name: "黑暗王者",
97
      author: "古羲",
98
      price: 39,
99
      is_hot: false,
100
    },
101
    {
102
      name: "不二大道",
103
      author: "文刀手予",
104
      price: 89,
105
      is_hot: false,
106
    },
107
    {
108
      name: "大泼猴",
109
      author: "甲鱼不是龟",
110
      price: 59,
111
      is_hot: false,
112
    },
113
    {
114
      name: "长安的荔枝",
115
      author: "马伯庸",
116
      price: 45,
117
      is_hot: true,
118
    },
119
    {
120
      name: "命运",
121
      author: "蔡崇达",
122
      price: 59.8,
123
      is_hot: true,
124
    },
125
    {
126
      name: "如雪如山",
127
      author: "张天翼",
128
      price: 58,
129
      is_hot: true,
130
    },
131
    {
132
      name: "三体",
133
      author: "刘慈欣",
134
      price: 23,
135
      is_hot: true,
136
    },
137
    {
138
      name: "秋园",
139
      author: "杨本芬",
140
      price: 38,
141
      is_hot: true,
142
    },
143
    {
144
      name: "百年孤独",
145
      author: "范晔",
146
      price: 39.5,
147
      is_hot: true,
148
    },
149
    {
150
      name: "在细雨中呼喊",
151
      author: "余华",
152
      price: 25,
153
      is_hot: true,
154
    },
155
  ]).then((data) => {
156
    console.log(data);
157
  }).catch(err => {
158
      if (err) {
159
         console.log(err);
160
         return;
161
      }
162
  })
163
});
164
​
165
// 设置连接失败的回调
166
mongoose.connection.on("error", () => {
167
  console.log("error");
168
});
169
​
170
// 设置连接关闭的回调
171
mongoose.connection.on("close", () => {
172
  console.log("close");
173
});

注意：mongoose.model()会使用集合名称的复数，在数据库中创建集合。上面的代码中，使用了"novel"，实际在数据库中，就是novels。

注意：因为在mongoose@7.5.x版本中，一些方法不再有第二个参数，而是使用then的链式调用，所以一般我都写的是@7.5.x版本的方法，@5.x版本的方法不再给出示例了，其实也很简单，就是把@5.x版本中的第二个参数放到then中即可。

但是then里面的参数到底是(err,data)=>{}还是(data)=>{}，还是要看官方文档，也可以自己试一下。

我看了一下，应该是这样写是不行的：

xxxxxxxxxx
7
1
.then((err,data) => {
2
  if(err){
3
      throw err;
4
      return;
5
  }
6
  console.log(data);
7
})

这样会报错没有办法获取到throw err的err值，所以必须写一个catch。

但是写了catch还是会报错，所以一般我写的时候，可以先这样写：

xxxxxxxxxx
7
1
.then((err,data) => {
2
  if(err){
3
      console.log(err);
4
      return;
5
  }
6
    console.log(data);
7
})

如果没有反应，输出不了data，可以改成这样：

xxxxxxxxxx
6
1
.then(data => {
2
    console.log(data);
3
})
4
.catch(err => {
5
    console.log(err);
6
})

如果还是不行，就直接看文档。

 

与mongoose的版本还是有关系的，如果不知道，还是看文档。

5.6.1 增加

插入一条

create()方法。

xxxxxxxxxx
9
1
SongModel.create({
2
    title:'给我一首歌的时间',
3
    author: 'Jay'
4
}).then(function(err, data){
5
    //错误
6
    console.log(err);
7
    //插入后的数据对象
8
    console.log(data);
9
})

批量插入

insertMany()方法。

xxxxxxxxxx
37
1
//1.引入mongoose
2
const mongoose = require('mongoose');
3
​
4
//2.链接mongodb数据库 connect 连接
5
mongoose.connect('mongodb://127.0.0.1:27017/project');
6
​
7
//3.设置连接的回调
8
mongoose.connection.on('open',()=>{
9
//4.声明文档结构
10
const PhoneSchema = new mongoose.Schema({
11
        brand:String,
12
        color:String,
13
        price:Number,
14
        tags:Array
15
    })
16
​
17
    //6.创建模型对象
18
    const PhoneModel = mongoose.model('phone',PhoneSchema);
19
    
20
    PhoneModel.insertMany([
21
        {
22
            brand:'华为',
23
            color:'灰色',
24
            price:2399,
25
            tags:['电量大','屏幕大','信号好']
26
        },
27
        {
28
            brand:'小米',
29
            color:'白色',
30
            price:2099,
31
            tags:['电量大','屏幕大','信号好']
32
        }
33
    ]).then((err,data)=>{
34
        if(err) throw err;
35
        console.log('写入成功');
36
    })
37
})

5.6.2 删除

1、删除一条数据

xxxxxxxxxx
51
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 删除。deleteOne方法有两个参数，第一个参数是条件，第二个参数是回调函数。
22
​
23
  // mongoose@5.x版本
24
  //   BookModel.deleteOne({ _id: "651792320e77f77eb6f3c909" }, (err, data) => {
25
  //     if(err){
26
  //         console.log(err);
27
  //         return;
28
  //     }
29
  //     console.log(data);
30
  //   });
31
​
32
  // mongoose@7.5.3版本
33
  BookModel.deleteOne({ _id: "651792320e77f77eb6f3c909" }).then((err, data) => {
34
    if (err) {
35
      console.log(err);
36
      return;
37
    }
38
    console.log(data);
39
  })
40
});
41
​
42
// 设置连接失败的回调
43
mongoose.connection.on("error", () => {
44
  console.log("error");
45
});
46
​
47
// 设置连接关闭的回调
48
mongoose.connection.on("close", () => {
49
  console.log("close");
50
});
51
​

2、批量删除

xxxxxxxxxx
40
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 批量删除
22
  BookModel.deleteMany({is_hot:false}).then((err,data) => {
23
    if(err){
24
        console.log(err);
25
        return;
26
    }
27
    console.log(data);
28
  })
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});
40
​

5.6.3 更新

1、更新一条数据

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 更新一条数据。第一个参数是查找条件，第二个参数是需要修改的值。
22
  BookModel.updateOne({ name: "红楼梦" }, { price: 9.9 }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});

2、批量更新数据

xxxxxxxxxx
40
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 批量更新
22
  BookModel.updateMany({ author: "余华" }, { is_hot: true }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});
40
​

5.6.4 查询

1、查询一条数据

findOne()方法：

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 读取一条数据
22
  BookModel.findOne({ name: "狂飙" }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});

findById()方法：

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 根据id获取单条数据
22
  BookModel.findById("651792320e77f77eb6f3c90e").then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});

2、批量查询数据

不加条件查询，获取所有数据：

xxxxxxxxxx
40
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 批量获取数据
22
  // 不加条件，获取所有数据
23
  BookModel.find().then((err, data) => {
24
    if (err) {
25
      console.log(err);
26
      return;
27
    }
28
    console.log(data);
29
  });
30
});
31
​
32
// 设置连接失败的回调
33
mongoose.connection.on("error", () => {
34
  console.log("error");
35
});
36
​
37
// 设置连接关闭的回调
38
mongoose.connection.on("close", () => {
39
  console.log("close");
40
});

加条件查询：

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 批量获取数据
22
  BookModel.find({ author: "余华" }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});

5.7 条件控制

注意：虽然下面的例子大部分是MongoDB原生语言的例子，但mongoose使用的时候，条件部分是一样的。我会给出部分例子，照着写就行了。

需要留意条件的写法，条件可以看成是一种值，采用对象的方式来写，条件为key，具体的范围为值。

5.7.1 运算符

在 mongodb 不能使用 > < >= <= !== 等运算符，需要使用替代符号

• > 使用 $gt
• < 使用 $lt
• >= 使用 $gte
• <= 使用 $lte
• !== 使用 $ne

xxxxxxxxxx
1
1
db.students.find({id:{$gt:3}});       // id号比3大的所有记录

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 找出价格小与20元的书
22
  BookModel.find({ price: { $lt: 20 } }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});

效果：

5.7.2 逻辑运算

注意括号的写法。

$or 逻辑或的情况

xxxxxxxxxx
1
1
db.students.fond({$or:[{age：18}，{age:24}]});

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 找出曹雪芹或者余华的书
22
  BookModel.find({ $or: [{ author: "余华" }, { author: "曹雪芹" }] }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});

$and 逻辑与的情况

xxxxxxxxxx
1
1
db.students.find({$and:[{age:{$lt:20}},{age:{$gt:15}}]});

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 价格大于40且小于60的书
22
  BookModel.find({ $and: [{ price: { $gt: 40 } }, { price: { $lt: 60 } }] }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});

5.7.3 正则匹配

条件中可以直接使用 JS 的正则语法，通过正则可以进行模糊查询。

xxxxxxxxxx
1
1
db.students.find({name:/imissyou/});

xxxxxxxxxx
39
1
// 2、导入mongoose
2
const mongoose = require("mongoose");
3
​
4
// 3、连接MongoDB服务
5
mongoose.connect("mongodb://127.0.0.1:27017/bilibili");
6
​
7
// 4、设置回调
8
// 设置连接成功的回调
9
mongoose.connection.once("open", () => {
10
  // 5、创建文档的结构对象
11
  let BookSchema = new mongoose.Schema({
12
    name: String,
13
    author: String,
14
    price: Number,
15
    is_hot: Boolean,
16
  });
17
​
18
  // 6、创建模型对象
19
  let BookModel = mongoose.model("novel", BookSchema);
20
​
21
  // 正则表达式，搜索书籍名称中带有 三 的图书
22
  BookModel.find({ name: new RegExp("三") }).then((err, data) => {
23
    if (err) {
24
      console.log(err);
25
      return;
26
    }
27
    console.log(data);
28
  });
29
});
30
​
31
// 设置连接失败的回调
32
mongoose.connection.on("error", () => {
33
  console.log("error");
34
});
35
​
36
// 设置连接关闭的回调
37
mongoose.connection.on("close", () => {
38
  console.log("close");
39
});