08-MongoDB
码路教育 7/25/2022
# 一，MongoDB开篇
# 1.1 什么是MongoDB?
MongoDB和MySQL一样都是数据库, 都是存储数据的仓库, 不同的是MySQL是关系型数据库, 而MongoDB是非关系型数据库，MongoDB中的存储的数据是类JSON。
# 1.2 什么是非关系型数据库?
在'关系型数据库'中, 数据都是存储在表中的, 对存储的内容有严格的要求, 因为在创建表的时候我们就
- 已经规定了表中有多少个字段,
- 已经规定了每个字段将来要存储什么类型数据,
- 已经规定了每个字段将来是否可以为空, 是否必须唯一等等
在'非关系型数据库'中, 没有表概念, 所以存储数据更加灵活因为不需要创建表, 所以
- 也没有规定有哪些字段,
- 也没有规定每个字段数据类型,
- 也没有规定每个字段将来是否可以为空,是否必须唯一等等
'关系型数据库'由于操作的都是结构化的数据, 所以我们需要使用结构化语言SQL来操作
'非关系型数据库'由于数据没有严格的结构要求, 所以无需使用SQL来操作
# 1.3 什么是MongoDB?
1.存储文档(BSON)的非关系型数据库
1）例如在MySQL中:
|--------------------------------------------------------|
| name(varchar(255) not null) | age(int unique) |
|--------------------------------------------------------|
我们可以把 'zs', 33 保存到表中
但是我们不能将 33, 'zs' 保存到表中
但我们不能能将 null, 33 保存到表中
但是我们不能将 'zs', 33, '男' 保存到表中
但是我们不能再次将 'zs', 33 保存到表中
2）例如在MongoDB中:
我们可以把 {name: 'zs', age: 33}; 保存到集合中
我们也可以把 {name: 33, age: 'zs'}; 保存到集合中
我们也可以把 {name: null, age: 33}; 保存到集合中
我们也可以把 {name: 'zs', age: 33, gender:'男'}; 保存到集合中
但是我们可以再次将 {name: 'zs', age: 33}; 保存到集合中
2.'非关系型数据库'可以看做是'关系型数据库'的功能阉割版本,
通过减少用不到或很少用的功能，从而提升数据库的性能
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 1.4 MongoDB是如何存储文档的?
1.MySQL中所有的数据都是存储在表中的, 而MongoDB中所有的数据都是存储在集合中的
1）MySQL
|--行1
|--表1-- |--行2
数据库--| |--行3
|--表2
|--... ...
2）MongoDB
|--文档1
|--集合1--|--文档2
数据库--| |--文档3
|--集合2
|--... ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1.5 企业开发如何选择?
关系型数据库和非关系型数据库之间并不是替代关系, 而是互补关系 所以在企业开发中大部分情况是结合在一起使用
对于数据模型比较简单、数据性能要求较高、数据灵活性较强的数据, 我们存储到非关系型数据库中 相反则存储到关系型数据库中
具体使用: 会在项目中实现
比较重要的数据，存储在mysql中，不是那么重要的数据，存储在MongoDB中。
# 二，MongoDB安装
# 2.1 安装MongoDB
- 下载地址： https://www.mongodb.org/dl/win32
- MongoDB版本号: 偶数为稳定版(推荐), 基数为开发版
- MongoDB对32位操作系统支持不佳, 不推荐在32位系统上使用, 并且官方已经停更32位安装包
# 2.2 MongoDB安装步骤
- 全程下一步，修改安装路径
- 配置环境变量, 将MongoDB的bin目录配置到系统变量Path中
- 可以去服务列表中打开服务，相当于开始服务器。
# 2.3 安装可视化工具
下载地址： https://www.mongodbmanager.com/
# 四，monogodb原⽣驱动
此次练习需要用到的依赖如下：
"dependencies": {
"express": "^4.17.3",
"mongodb": "^4.4.0",
"mongoose": "^6.2.4",
"sequelize": "^6.17.0"
}
1
2
3
4
5
6
2
3
4
5
6
通过npm i直接安装上面的依赖。
# 4.1 连接数据库
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
console.log("db:", db);
// 获取集合
const grade1 = db.collection('grade1')
await grade1.insertOne({
name: "张三3",
age: 20,
hobby: ['吃饭', '睡觉', '打豆豆'],
score: 90
})
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 4.2 插入多条数据
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
let r = await grade1.insertMany([{
name: '张三',
age: 20,
hobby: ['吃饭', '睡觉', '打豆豆'],
score: 90
},
{
name: '李四',
age: 40,
hobby: ['妹子', '篮球'],
score: 93
},
{
name: '王五',
age: 20,
hobby: ['妹子', '睡觉'],
score: 70
},
{
name: '赵六',
age: 16,
hobby: ['妹子'],
score: 50
},
{
name: '张丽',
age: 38,
hobby: ['妹子'],
score: 56
},
{
name: '小红',
age: 40,
hobby: ['妹子'],
score: 87
},
{
name: '小马',
age: 20,
hobby: ['妹子'],
score: 79
},
{
name: '小王',
age: 59,
hobby: ['妹子'],
score: 102
},
{
name: '小黑',
age: 16,
hobby: ['妹子'],
score: 60
},
{
name: '小哥',
age: 18,
hobby: ['篮球'],
score: 49
},
])
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
# 4.3 查找某一条数据
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
r = await grade1.findOne({
name: '张三'
})
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 4.4 查找多条数据
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// 查找所有的数据
// r = await grade1.find().toArray()
// console.log("r:", r);
r = await grade1.find({
name: '张三'
}).toArray()
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 4.5 比较运算符
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// 比较运算符
r = await grade1.find({
age: {
// gt大于 lt小于 gte 大于等于 lte小于等于
$gte: 20,
},
}).toArray()
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 4.6 逻辑运算符
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// 逻辑运算符 $and $or $ne $nor 不等于
// 查询姓名叫王五并且年龄为20岁的人
// r = await grade1.find({
// name: '王五',
// age: 20,
// }).toArray()
// console.log("r:", r);
// -----------------------------
// 查询姓名叫张三或者年龄为20岁的人
// r = await grade1.find({
// $or: [
// {
// name: '张三',
// },
// {
// age: 20,
// },
// ],
// }).toArray()
// console.log("r:", r);
// -----------------------------
// // 查询年龄不大于20岁并且age不小于16的人员
r = await grade1.find({
$nor: [{
age: {
$gt: 20,
},
},
{
age: {
$lt: 16,
},
},
],
}).toArray()
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# 4.7 指定正则
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// 正则表达式
r = await grade1.find({
name: {
$regex: /^张/,
},
}).toArray()
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 4.8 $all $in $size
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// $all $in $size
// 查找指定字段包含所有指定内容的数据
// r = await grade1.find({
// hobby: {
// $all: ['妹子'],
// },
// }).toArray()
// console.log("r:", r);
// ----------------------------------
// 查找指定字段只有指定内容其一的数据
// r = await grade1.find({
// hobby: {
// $in: ['妹子', '睡觉'],
// },
// }).toArray()
// console.log("r:", r);
// ----------------------------------
// 查找指定字段的数据有三条的
r = await grade1.find({
hobby: {
$size: 3,
},
}).toArray()
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 4.9 分页
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// 分页查询 limit()
// 查询前两条数据
// r = await grade1.find().limit(2).toArray()
// console.log("r:", r);
// --------------------------------
// 跳过前2条数据,获取后4条数据
// r = await grade1.find().skip(2).limit(4).toArray()
// console.log("r:", r);
// --------------------------------
// 根据age字段进行排序 1表示正序 -1 表示倒序
// r = await grade1.find().sort({
// age: -1,
// }).toArray()
// console.log("r:", r);
// --------------------------------
// 分页
const pageIndex = 1 //当前的索引
const pageSize = 3 //当前一页显示的数据
r = await grade1
.find()
.skip((pageIndex - 1) * pageSize)
.limit(pageSize)
.toArray()
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 4.10 聚合函数
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// 聚合函数 $sum $min $max $avg
// 相同年龄的人数
// r = await grade1.aggregate([
// {
// $group: {
// _id: '$age',
// count: {
// $sum: 1,
// },
// },
// },
// ]).toArray()
// console.log("r:", r);
// --------------------------------
// r = await grade1.aggregate([
// {
// $group: {
// _id: '$age',
// avgScore: {
// $avg: '$score',
// },
// },
// },
// ]).toArray()
// console.log("r:", r);
// --------------------------------
r = await grade1.aggregate([{
$group: {
_id: '$age',
avgScore: {
$max: '$score',
},
},
}, ]).toArray()
console.log("r:", r);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# 4.11 更新文档
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
r = await grade1.updateOne({
name: "张三",
}, {
$set: {
name: "小张三"
}
})
console.log('更新成功', r)
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 4.12 删除文档
const MongoClient = require('mongodb').MongoClient
;
(async function() {
const client = new MongoClient('mongodb://127.0.0.1:27017')
// 链接服务端
await client.connect()
console.log('链接成功')
// 获取数据库
const db = client.db('school')
// 获取集合
const grade1 = db.collection('grade1')
// 当你做删除的时候 一定要问一下自己 是否要删除
r = await grade1.deleteOne({
name: '张三'
})
console.log(r.result);
// 关闭客户端的链接
client.close()
})()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 4.13 班级学生管理
对应的依赖：
"dependencies": {
"@koa/router": "^10.1.1",
"express": "^4.17.3",
"koa": "^2.13.4",
"koa-bodyparser": "^4.3.0",
"koa-static": "^5.0.0",
"mongodb": "^4.4.0",
"mongoose": "^6.2.4",
"sequelize": "^6.17.0"
}
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
如下内容直接copy使用：
// dbConfig.js
module.exports = {
url: 'mongodb://127.0.0.1:27017',
dbName: 'classes',
}
1
2
3
4
5
2
3
4
5
// testData.js
const mongodb = require('./index.js');
mongodb.once('connect', async () => {
const students = mongodb.col('students');
try {
// 插入测试数据
await students.deleteMany();
await students.insertMany([{
"name": '张三',
"age": 20,
"score": 90,
"class": 1
},
{
"name": '李四',
"age": 24,
"score": 90,
"class": 4
},
{
"name": '王五',
"age": 28,
"score": 95,
"class": 2
},
{
"name": '张三',
"age": 20,
"score": 93,
"class": 1
},
{
"name": '张三2',
"age": 40,
"score": 40,
"class": 1
},
{
"name": '张三3',
"age": 20,
"score": 90,
"class": 1
},
{
"name": '张三4',
"age": 20,
"score": 90,
"class": 1
},
{
"name": '张三6',
"age": 20,
"score": 90,
"class": 1
},
{
"name": '张三7',
"age": 20,
"score": 90,
"class": 1
},
{
"name": '张三',
"age": 20,
"score": 90,
"class": 1
}
])
console.log('测试数据插入成功');
} catch (error) {
console.log(error.stack);
}
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
// index.js
const dbConfig = require('./dbConfig')
const MongoClient = require('mongodb').MongoClient
const EventEmitter = require('events')
class Mongo {
constructor(dbConfig) {
this.dbConfig = dbConfig
this.emitter = new EventEmitter()
// 创建客户端
this.client = new MongoClient(this.dbConfig.url)
// 建立连接
this.client.connect((err) => {
if (err) throw err
console.log('连接数据库成功')
this.emitter.emit('connect')
})
}
once(eventName, cb) {
// 只会连接一次
this.emitter.once(eventName, cb)
}
// 获取集合的方法
col(colName, dbName = this.dbConfig.dbName) {
return this.client.db(dbName).collection(colName)
}
}
module.exports = new Mongo(dbConfig)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 班级学生管理.js
const Koa = require("koa");
const bodyParser = require('koa-bodyparser')
const Router = require("@koa/router")
const static = require('koa-static');
const mongod = require("./db/index.js")
const ObjectId = require("mongodb").ObjectId;
const app = new Koa();
const router = new Router();
app.use(bodyParser());
// 托管静态资源（静态网页）
app.use(static(__dirname + '/public'))
router.get("/", ctx => {
ctx.body = "首页面"
})
// 获取所有的学生
router.get("/api/classList", async ctx => {
let {
pageSize,
pageIndex
} = ctx.query;
pageSize = Number(pageSize)
pageIndex = Number(pageIndex)
console.log("pageSize:", pageSize);
console.log("pageIndex:", pageIndex);
// 得到students集合
let students = mongod.col("students");
// 得到所有的学生
let classList = await students.find().skip((pageIndex - 1) * pageSize).limit(pageSize).toArray();
console.log("classList:", classList);
let total = await students.countDocuments();
ctx.body = {
ok: 1,
data: classList,
total
}
})
// 删除某个学生
router.post("/api/deleteUser", async ctx => {
let _id = ctx.request.body._id;
// console.log("_id:", _id);
let students = mongod.col("students");
let res = await students.deleteOne({
_id: ObjectId(_id)
})
console.log("res:", res);
if (res.deletedCount === 1) {
ctx.body = {
ok: 1,
msg: "删除成功"
}
}
})
app.use(router.routes())
router.allowedMethods();
app.listen(3000, () => {
console.log("server is running on 3000");
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
浏览器中测试如下：
# 五，Mongoose
对于原生node操作mongodb的使用，直接百度，用的时候，直接查，不需要记：但是一般情况下，我们写项目时，会直接使用mongoose
# 5.1 mongoose使用
什么是Mongoose?
- 像操作JS对象一个，去操作集合
- 参考文档：http://www.mongoosejs.net/
- 参考文档：https://mongoosejs.com/
Mongoose和MongoDB映射关系
- 在Mongoose中JS中的一个模型就对应数据库中的一个集合
- 在Mongoose中JS中的一个对象就对应集合中的一个文档
- 在Mongoose中JS中的一个对象的属性就对应文档的一个字段
对应核心代码如下：
// 1. 定义集合规则
cosnt 规则名称 = new Schema({
name: String,
age: Number
});
// 2. 利用规则创建一个集合
let User = mongoose.model('User', userSchema);
// 3. 创建一个文档
let u = new User({
name: 'zs',
age: 18
});
// 4. 操作集合和文档
// 只要是通过Mongoose定义的模型, 那么Mongoose就会自动给这个模型添加很多操作集合和文档的方法以后我们就可以直接通过模型操作集合, 通过模型创建出来的对象操作数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
实现代码如下：
// 1.导入mongoose
const mongoose = require('mongoose');
/*
mongodb://MongoDB服务器IP地址:MongoDB服务器端口号/需要打开的数据库名称
* */
// 2.利用mongoose链接MongoDB服务器
mongoose.connect('mongodb://127.0.0.1:27017/demo');
// 3.监听链接成功还是失败
let db = mongoose.connection;
db.on('error', (err) => {
console.log(err, '连接失败');
});
db.once('open', function() {
console.log('连接成功');
});
db.once('close', function() {
console.log('断开连接');
});
// 1.定义集合中存储数据规则
let userSchema = new mongoose.Schema({
name: String,
age: Number
});
// 2.利用规则创建集合
// 注意点: 只要创建好了模型, 那么以后就可以使用模型来操作这个集合
// 注意点: mongoose会自动将我们指定的集合名称变成复数
let User = mongoose.model('User', userSchema);
// 3.利用集合创建文档
// 注意点: 只要创建好了对象, 那么以后就可以使用对象来操作文档
let u = new User({
name: 'zs',
age: 18
});
// 4.操作文档
u.save((err, product) => {
if (!err) {
console.log('文档保存成功');
console.log(product);
}
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 5.2 CRUD操作
// 1.导入mongoose
const mongoose = require('mongoose');
// 2.利用mongoose链接MongoDB服务器
mongoose.connect('mongodb://127.0.0.1:27017/blog');
// 3.监听链接成功还是失败
let db = mongoose.connection;
db.on('error', (err) => {
console.log(err, '连接失败');
});
db.once('open', function() {
console.log('连接成功');
});
db.once('close', function() {
console.log('断开连接');
});
// 1.定义集合中存储数据规则
let userSchema = new mongoose.Schema({
name: String,
age: Number
});
// 2.利用规则创建集合
let User = mongoose.model('User', userSchema);
// 增加
/*
User.create({name:'zs', age:666}, (err, result)=>{
if(!err){
console.log('插入成功');
console.log(result);
}
});
*/
/*
User.create([
{name:'ls', age:18},
{name:'ls', age:22},
{name:'ww', age:21},
{name:'zl', age:23},
{name:'xq', age:33},
],
(err, result)=>{
if(!err){
console.log('插入成功');
console.log(result);
}
});
*/
/*
(async ()=>{
let result = await User.create([
{name:'ls', age:18},
{name:'ls', age:22},
{name:'ww', age:21},
{name:'zl', age:23},
{name:'xq', age:33},
]);
console.log(result);
})();
*/
// 查询
/*
User.find({},{},(err, docs)=>{
if(!err){
console.log(docs);
}
});
*/
/*
User.find({},{_id:0, name:1, age:1},(err, docs)=>{
if(!err){
console.log(docs);
}
});
*/
/*
User.find({name:'ls'},{_id:0, name:1, age:1},(err, docs)=>{
if(!err){
console.log(docs);
}
});
*/
/*
User.find({},{_id:0, name:1, age:1},{ skip: 5, limit: 5},(err, docs)=>{
if(!err){
console.log(docs);
}
});
*/
/*
(async ()=>{
let result = await User.find({},{_id:0, name:1, age:1},{ skip: 5, limit: 5});
console.log(result);
})();
*/
// 修改
/*
User.update({name:'ls'},{$set:{age:888}},(err, docs)=>{
if(!err){
console.log('更新成功');
console.log(docs);
}
});
*/
/*
User.update({name:'ls'},{$set:{age:888}}, {multi: true},(err, docs)=>{
if(!err){
console.log('更新成功');
console.log(docs);
}
});
*/
/*
(async ()=>{
let result = await User.update({name:'ls'},{$set:{age:123}}, {multi: true});
console.log(result);
})();
*/
// 删除
/*
User.remove({name:'ww'}, {}, (err, docs)=>{
if(!err){
console.log('删除成功');
console.log(docs);
}
});
*/
/*
User.deleteOne({name:'xq'}, (err, docs)=>{
if(!err){
console.log('删除成功');
console.log(docs);
}
});
*/
(async () => {
let result = await User.deleteOne({
name: 'xq'
});
console.log(result);
})();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147