官网地址：https://www.mongodb.com/docs/manual/reference/method/Date/

实例：系统上运行的进程及节点集，一个实例可以有多个库，默认端口 27017。如果要在一台机器上启动多个实例，需要设置不同端口和不同的dbpath。
库：多个集合组成数据库，每个数据库都是独立的，有自己的用户、权限信息，独立的存储文件集合。
集合：即是一组文档的集合，集合内的文档结构可以不同，相当于mysql中的表。
文档：mongodb 的最小数据单元，其基本概念为：多个键值对有序组合在一起的数据单元。相当于mysql中的行。

(>) 大于 - $gt
(<) 小于 - $lt
(>=) 大于等于 - $gte
(<=) 小于等于 - $lte
(!=) 不等于 - $ne

一、操作

【Linux 系统下】

进入MongoDB数据库
在 mongodb 的 bin 目录执行 ./mongo
在这里插入图片描述

退出
exit

代码	含义
`show databases` / `show dbs`	显示所有数据库
`use 库名`	使用并切换到指定的数据库
`db`	查看当前使用的数据库
`use 不存在的数据库名`	创建数据库
`show tables`	显示当前数据库下的所有表
`db.不存在的表名`	创建表
=============	=====================
`db.dropDatabase()`	删除当前数据库，默认test，注意要先切换到待删除数据库。

二、新增

1. 创建集合（表）

语法格式：db.createCollection(name, options)
name: 要创建的集合名称
options: 可选参数, 指定有关内存大小及索引的选项

db.createCollection("mycoll", {capped:true, size:100000,max:1000})

options 可以是如下参数：

字段	类型	描述
capped	布尔	（可选）如果为 true，则创建固定集合。固定集合是指有着固定大小的集合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必须指定 size 参数。
autoIndexId	布尔	（可选）如为 true，自动在 _id 字段创建索引。默认为 false。
size	数值	（可选）为固定集合指定一个最大值（以字节计）。如果 capped 为 true，也需要指定该字段。
max	数值	（可选）指定固定集合中包含文档的最大数量。

2. 插入文档

db.collection.insertOne({**:"**"})   # 将单个文档插入到集合中
db.collection.insertMany({**:"**"}:{**:"**"})  #将多个文件插入集合中
db.collection.insert({**:"**"})       #将单个文档或多个文档插入到集合中

--例子：
db.user.insert({name:"张三",age:23,gender:"男"})

使用 save 方法，如果参数中有id，就更新库中对应ID的值，没有ID就新增一条

db.collection.save()

3. 新增字段

在表 market_entity 中新增字段 adj_close_price , 并且给所有的记录都设置默认值 0.0 ，multi 为 true 表示全部新增，不写表示默认为 false ，只有第一行新增

db.getCollection('market_entity').update({},{$set:{adj_close_price:'0.0'}},{multi:true})

db.table.update({}, {$set: {"key": "value"}})

三、查看

1. 查看所有文档

db.col.find()

2. 只查看一条文档

只返回符合条件的第一条文档

db.col.findOne();

3. 带条件查找

pretty() 格式化查找结果

db.col.find({"name":"张三"})

//多条件  and 查找
db.col.find({"name":"张三","age":"12"}).pretty()
//or 查找
db.col.find({$or: [{key1: value1}, {key2:value2}]}).pretty()

//查询后只返回第一条,不支持prett()
db.col.findOne();

$lt : 小于
$lte : 小于或等于
$gt : 大于
$gte : 大于或等于
$ne : 不等于

db.students.find({"age":{$lte:27}})

`$and` 多条件查询

db.collectionName.find({$and:[{query1},{query2}...{queryn}]})

db.students.find({"$and":[{"age":"21"},{"sex":"1"}]})

`and` 和 `or` 组合

语法：db.collectionName.find({query1,query2,query3,...,$or:[{query4},{query5},{query6},...]]})

query1-n ：都是查询的条件，前面的查询条件和后面的查询条件是or的关系
$or : 前面部分的查询条件是and的关系，后面的是or的关系

db.students.find({age:{$gt:24},sex:0,$or:[{sex:1},{age:27}]})

`$in` `$nin` 查询

db.collectionName.find({<key>:{$in:[value1,value2...valuen]}})

db.students.find({"age":{"$in":["21","18"]}})

db.collectionName.find({<key>:{$nin:[value1,value2...valuen]}})

和$in操作符相反，选择不符合条件的所有文档

db.students.find({"age":{"$nin":["21","18"]}})

`$not` 取反

要和其他操作符配合使用

db.collectionName.find({<key>:{"$not":{"$in":[value1,value2...valuen]}}})

db.students.find({"age":{"$not":{"$in":["21","18"]}}})

以 `ID` 作为查询条件

_id 和 ObjectId("5ab9de223afa6504457050e2") 是固定写法

db.students.find({_id:ObjectId("5ab9de223afa6504457050e2")})

以特定值开头

db.collectionName.find({<key>:/^value/})

斜杠 / 和 ^ 不能省略

db.students.find({name:/^张/})

是否包含某个值

db.collectionName.find({<key>:/value/})

前后的两个斜杠 / 不能省略

db.students.find({name:/ng/})

只显示 `num` 条

db.collectionName.find({query}).limit(num)

//显示前两条
db.students.find().limit(2)

跳过 `num` 条

db.collectionName.find({query}).skip(num)

//跳过2条，从第3条开始显示
db.students.find().skip(2)

分页

db.collectionName.find({query}).skip(pageIndex*pageSize).limit(pageSize)

//跳过10条，从第11条开始显示20条
db.students.find().skip(10).limit(20)

以某个字段的数据类型筛选

db.collectionName.find({<key>:{$type:<value>}})

类型	数字	备注
Double	1
String	2
Object	3
Array	4
Binary data	5
Undefined	6	已废弃。
Object id	7
Boolean	8
Date	9
Null	10
Regular Expression	11
JavaScript	13
Symbol	14
JavaScript (with scope)	15
32-bit integer	16
Timestamp	17
64-bit integer	18
Min key	255	Query with -1.
Max key	127

//如果想获取 "students" 集合中 name 为 String 的数据，你可以使用以下命令：
db.students.find({"name":{$type:2}})

`$slice`

$slice 会限制数组元素的个数

$slice:[a,b]
a是正数时，起始位置是a+1，
a是负数时，起始位置a(倒数数组)
b是输出个数

查询输出数组前三个：

db.movies.find({title:"Youth Without Youth"},{languages:{$slice:3}}).pretty();

查询输出数组后两个

db.movies.find({title:"Youth Without Youth"},{languages:{$slice:-2}}).pretty();

查询输出从数组第四个开始，输出前三个

db.movies.find({title:"Youth Without Youth"},{languages:{$slice:[3,3]}}).pretty();

查询输出从数组倒数第五个开始，输出前四个

db.movies.find({title:"Youth Without Youth"},{languages:{$slice:[-5,4]}}).pretty();

`$all` 和字段值顺序无关的查询

是针对数组字段操作的，可以完成类似模糊查询的效果，并且和字段值的顺序无关。

db.collectionName.find({<key>:{$all:[value1,value2...valuen]}})

 //查询结果  无值
> db.students.find({"frut":["apple","orange"]})

//查询结果  增加了$all操作符的，orange是第三个元素
> db.students.find({"frut":{"$all":["apple","orange"]}})

{ "_id" : ObjectId("5adb4b83f82775fbd989b859"), "frut" : [ "apple", "banana", "orange" ] }

4. 查询返回结果的数量

db.col.find().count()

5. 返回指定字段

返回的字段中默认带有ID

//没有查询条件，返回 `deviceName` ，结果默认带ID
db.sys_device.find({},{deviceName:1})

//返回 `placeName` 和 `doorName` ,去掉ID
db.sys_device.find({placeName:1,_id:0,doorName:1})

//返回除 `doorName` 以外的所有字段
db.sys_device.find({},{doorName:0})

//除了_id字段，不能在一个projection中联合使用包含和排除语意。如下，会报错
db.sys_device.find({},{doorName:0,placeName:1})

6. 时间范围查询

db.sys_device.find({createTime:{$gte:"2022-12-31"}},{createTime:1})
//表中数据结构 
{ "_id" : ObjectId("63b54955cca77025bbdee70e"), "createTime" : "2023-01-04 17:39:33" }
{ "_id" : ObjectId("63b549cfcca77025bbdee70f"), "createTime" : "2023-01-05 10:53:38" }

7. 排序

1 升序 -1降序

db.collection.find().sort({name:1})

8. `$size` 根据数组个数查询

db.collectionName.find({<key>:{$size:number}})

 //查询结果，查询只有2个元素的文档
> db.students.find({"frut":{"$size":2}})
{ "_id" : ObjectId("5adb3dbda62a80dd1239bb40"), "frut" : [ "apple", "banana" ] }
{ "_id" : ObjectId("5adb3dbda62a80dd1239bb41"), "frut" : [ "apple", "banana" ] }

//查询结果，查询只有3个元素的文档
> db.students.find({"frut":{"$size":3}})
{ "_id" : ObjectId("5adb4b83f82775fbd989b859"), "frut" : [ "apple", "banana", "orange" ] }

9. `$elemMatch` 根据数组中元素判断

db.collectionName.find({<key>:{$elemMatch:{query}}})

//原始数据
> db.students.find()

            { "_id" : ObjectId("5adb555ca62a80dd1239bb44"), "userName" : "Bob", "values" : [ 1, 2, 3, 4, 5, 6 ] }
            { "_id" : ObjectId("5adb5568a62a80dd1239bb45"), "userName" : "Bob", "values" : 1 }
            { "_id" : ObjectId("5adb556ea62a80dd1239bb46"), "userName" : "Bob", "values" : 2 }
            { "_id" : ObjectId("5adb5571a62a80dd1239bb47"), "userName" : "Bob", "values" : 3 }
            { "_id" : ObjectId("5adb5575a62a80dd1239bb48"), "userName" : "Bob", "values" : 4 }
            { "_id" : ObjectId("5adb5578a62a80dd1239bb49"), "userName" : "Bob", "values" : 5 }
            { "_id" : ObjectId("5adb557ca62a80dd1239bb4a"), "userName" : "Bob", "values" : 6 }


//如果不做限制，数组字段和数字字段都查出来
> db.students.find({"values":{"$gt":1,"$lt":4}})

            { "_id" : ObjectId("5adb555ca62a80dd1239bb44"), "userName" : "Bob", "values" : [ 1, 2, 3, 4, 5, 6 ] }
            { "_id" : ObjectId("5adb556ea62a80dd1239bb46"), "userName" : "Bob", "values" : 2 }
            { "_id" : ObjectId("5adb5571a62a80dd1239bb47"), "userName" : "Bob", "values" : 3 }

//如果我只想针对数组字段操作，可以这样
> db.students.find({"values":{"$elemMatch":{"$gt":1,"$lt":4}}})

            { "_id" : ObjectId("5adb555ca62a80dd1239bb44"), "userName" : "Bob", "values" : [ 1, 2, 3, 4, 5, 6 ] }

10. 内嵌文档查询

语法：<outKey>.<innerKey>
参数说明：
outKey：外部文档（父文档）要操作的字段名称
innerKey：内部文档（子文档）要操作的字段名称

//原始数据
> db.names.find()

            { "_id" : ObjectId("5adb5915a62a80dd1239bb4b"), "name" : { "firstName" : "liu", "lastName" : "lei" } }
            { "_id" : ObjectId("5adb5937a62a80dd1239bb4c"), "name" : { "lastName" : "lei", "firstName" : "liu" } }
            { "_id" : ObjectId("5adb5944a62a80dd1239bb4d"), "name" : { "firstName" : "zhang", "lastName" : "san" } }
            { "_id" : ObjectId("5adb5951a62a80dd1239bb4e"), "name" : { "firstName" : "li", "lastName" : "si" } }
            { "_id" : ObjectId("5adb595ba62a80dd1239bb4f"), "name" : { "firstName" : "wang", "lastName" : "wu" } }



//一般查询：查询结果，大家看好了，其实第一条和第二条两个内容是完全一样的，只是顺序不一样，如果按一般方式查询，只能获取一条记录
> db.names.find({"name":{"firstName":"liu","lastName":"lei"}})

            { "_id" : ObjectId("5adb5915a62a80dd1239bb4b"), "name" : { "firstName" : "liu", "lastName" : "lei" } }


> db.names.find({"name.firstName":"liu","name.lastName":"lei"})

            { "_id" : ObjectId("5adb5915a62a80dd1239bb4b"), "name" : { "firstName" : "liu", "lastName" : "lei" } }
            { "_id" : ObjectId("5adb5937a62a80dd1239bb4c"), "name" : { "lastName" : "lei", "firstName" : "liu" } }

四、修改

1. 集合重命名（表）

db.collection1.renameCollection("collection2")

2. 修改文档

将 name 为张三的文档的年龄改为 25

db.collection.update({name:"张三"},{$set:{age:25}})

save()
如果集合内有ID相同的记录，则替换这条记录。如果集合内没有对应的ID，则新增这条记录

db.collection.save();

`$inc` 数值字段修改

db.collectionName.update({query},{"$inc":{<key>:number}})

-- 正数加，负数减
db.students.update({"name":"FangShiYu"},{"$inc":{"age":1}})

`$push` 字段内容修改

针对指定的字段插入文档列表，如果该字段不存在，会建立该字段并插入文档内容，如果存在，就向该字段的列表里追加文档内容。例如：留言板

> documents={document}
> db.collectionName.update({query},{"$push":{<key>:document}})

> query={"name":"tom","say":"i love u!"}
> db.messages.update({"name":"peny"},{"$push":{"comments":query}})

-- 再次追加
> query={"name":"jim","say":"i want to know you!"}
> db.messages.update({"name":"peny"},{"$push":{"comments":query}})

-- 结果
{ 
	"_id" : ObjectId("5abdc29b678c8239350e8a20"), 
	"name" : "peny", 
	"age" : 22, 
	"sex" : 0, 
	"comments" : 
		[
			{ "name" : "tom", "say" : "i love u!" }, 
			{ "name" : "jim", "say" : "i want to know you!" } 
		] 
}

`$each` 追加多个

$each 必须与 $push 配合使用
追加的时候若集合中没有该字段就新建后追加，若存在就直接追加

> documents=[{document1},{document2},{document3}....{documentn}]
> db.collectionName.update({query},{"$push":{<key>:{"$each":documents}}})

> query=[{"name":"tom","say":"hello!"},{"name":"jackey","say":"i love u!"},{"name":"jerry","say":"i want u"}]
> db.messages.update({"name":"peny"},{"$push":{"comments":{"$each":query}}})

--结果
{ 
	"_id" : ObjectId("5abdc844678c8239350e8a21"), 
	"name" : "peny", 
	"age" : 22, 
	"sex" : 0, 
	"comments" : [ 
		{ "name" : "tom", "say" : "hello!" }, 
		{ "name" : "jackey", "say" : "i love u!" }, 
		{ "name" : "jerry", "say" : "i want u" }] 
}

`$slice` 控制保存条数

控制记录保存的条数，如果以前有多条会把以前的清空保存条件所规定的记录，如果操作的字段不存在，就会创建该字段

正数保留最早的number条记录，负数保留最新的number条记录

> documents=[{document1},{document2},{document3}....{documentn}]
> db.collectionName.update({query},{$push:{<key>:{$each:documents,$slice:number}}})

//原始记录
{ "_id" : ObjectId("5abdceca678c8239350e8a22"), "name" : "peny", "age" : 18, "sex" : 0 }

------------------------------------------------------------------------------

> var query=[{"name":"lilei","say":"hello"},{"name":"hanmeimei","say":"i miss u"},{"name":"tom","say":"i watch u"},{"name":"ghost","say":"i want u"}];
//因原记录中没有，所以新增
> db.messages.update({},{$push:{"comments":{$each:query,$slice:2}}})

--结果
{"_id":ObjectId("5abdceca678c8239350e8a22"),"name":"peny","age":18,"sex":0,"comments":[{"name":"lilei","say":"hello"},{"name":"hanmeimei","say":"i miss u"}]}

-----------------------------------------------------------------------------------------

--继续操作
> var query=[{"name":"张三","say":"i watch u"},{"name":"李四","say":"i want u"}];
//正数，保留最早的两条记录
> db.messages.update({},{$push:{"comments":{$each:query,$slice:2}}})

--结果
{"_id":ObjectId("5abdceca678c8239350e8a22"),"name":"peny","age":18,"sex":0,"comments":[{"name":"lilei","say":"hello"},{"name":"hanmeimei","say":"i miss u"}]}


-----------------------------------------------------------------------------------------

--继续操作
> var query=[{"name":"张三","say":"i watch u"},{"name":"李四","say":"i want u"}];
//负数，保留最新的两条记录
> db.messages.update({},{$push:{"comments":{$each:query,$slice:-2}}})

--结果
{"_id":ObjectId("5abdceca678c8239350e8a22"),"name":"peny","age":18,"sex":0,"comments":[{"name":"王五","say":"i watch u"},{"monster":"赵六","say":"i want u"}]}

`$addToSet` 插入数组时过滤重复记录

当插入一个数组时，如果数组中有重复记录，只会直插入一条，不会重复插入，会过滤掉重复的记录

documents=[{document1},{document2},{document3}...{documentn}]
db.collectionName.update({query},{"$addToSet":{<key>:{"$each":documents}}})

//原数据
{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0" }

//定义要插入的文档数组，里面有重复记录，只有最后一个文档不同
> var documents=[{"name":"bob","say":"hi"},{"name":"bob","say":"hi"},{"name":"bob","say":"hi"},{"name":"bob","say":"hello"}];
> db.messages.update({"name":"peny"},{"$addToSet":{"comments":{"$each":documents}}});

//结果
{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0", "comments" : [ { "name" : "bob", "say" : "hi" }, { "name" : "bob", "say" : "hello" } ] }

`$pop` 在数组中进行删除

从数组中进行向前删除或者向后删除，+1正数表示从尾部开始删除，-1负数表示从头开始删除。

db.collectionName.update({query},{"$pop":{<key>:1(从后开始删除)/-1(从头开始删除)}})

//原始数据
{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0", "comments" : [ { "name" : "bob", "say" : "hi" }, { "name" : "bob", "say" : "hello" }, { "name" : "bob", "say" : "hi1" } ] }

//执行删除操作，并且执行成功
> db.messages.update({"name":"peny"},{"$pop":{"comments":-1}})


//执行结果，把comments数组的第一个元素删除了
{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0", "comments" : [ { "name" : "bob", "say" : "hello" }, { "name" : "bob", "say" : "hi1" } } ] }

`$pull` 根据数组字段删除

根据指定条件删除数组字段里面的指定文档数据，pop只能删除头部或者尾部的数据

db.collectionName.update({query},{"$pull":{<key>:{query2}}})

//原始数据
{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0", "comments" : [ { "name" : "bob", "say" : "hello" }, { "name" : "bob", "say" : "hi1" }, { "name" : "bob", "say" : "hi2" }, { "name" : "bob", "say" : "hi3" }] }

//执行删除操作，并且执行成功
> db.messages.update({"name":"peny"},{"$pull":{"comments":{"say":"hi2"}}})


//结果数据，已经删除了说话内容是“hi2”的文档
{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0", "comments" : [ { "name" : "bob", "say" : "hello" }, { "name" : "bob", "say" : "hi1" }, { "name" : "bob", "say" : "hi3" } ] }

`index` 数组下标操作

db.collectionName.update({query},{"$set":{<key>.index.<key2>:<vlaue>}})

{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0", "comments" : [ { "name" : "bob", "say" : "hello" }, { "name" : "bob", "say" : "hi1" }, { "name" : "bob", "say" : "hi3" }] }


//需要修改【comments】字段里面下标为【2】的【say】字段的值
> db.messages.update({"name":"peny"},{"$set":{"comments.2.say":"i am modifing!"}})


//修改结果
{ "_id" : ObjectId("5ac5b03525eb395526dc108d"), "name" : "peny", "age" : 18, "sex" : "0", "comments" : [ { "name" : "bob", "say" : "hello" }, { "name" : "bob", "say" : "hi1" }, { "name" : "bob", "say" : "i am modifing!" }] }

`$` 修改数组中所有符合条件的数据

db.collectionName.update({query},{"$set":{<key>.$.<key2>:<vlaue>}})

//原始数据
{ "_id" : ObjectId("5ac70d2f7a05450cf60c6887"), "name" : "peny", "age" : 18, "sex" : 0, "comments" : [ { "name" : "bob", "say" : "hello" }, { "name" : "bob", "say" : "i'm changing" }, { "name" : "tom", "say" : "i love y" } ] }


//修改名称【name】是【bob】的文档，把【say】字段的内容修改为【I'm a robbot】
> db.students.update({"comments.name":"bob"},{"$set":{"comments.$.say":"I'm robbot"}})


//修改结果
{ "_id" : ObjectId("5ac70d2f7a05450cf60c6887"), "name" : "peny", "age" : 18, "sex" : 0, "comments" : [ { "name" : "bob", "say" : "I'm robbot" }, { "name" : "bob", "say" : "i'm changing" }, { "name" : "tom", "say" : "i love y" } ] }

`$min` `$max` 数值比较

如果给定值(value1)小于字段的当前值，则更新字段值为给定值。$min运算符可以比较不同类型的数字。

{ $min: { <field1>: <value1>, ... } }

--数据
	{ "_id" : 1, "highScore" : 90, "lowScore" : 50 }

db.score.update({_id:1}, {$min : {lowScore : 10}})

--结果
	{ "_id" : 1, "highScore" : 90, "lowScore" : 10 }

3. 修改字段

`update` 方法

db.表名.update({},{$rename:{"原字段":"新字段"}},false,true)

第一个false：可选，如果根据过滤条件找不到记录时，true为插入新的记录，默认是false，不插入。
第二个true表示：可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新

db.students.update({},{$rename:{"name":"studentName"}},false,true);

db.getCollection("表名").update({},{$rename:{"原字段":"新字段"}},{multi:true})

db.getCollection("students").update({},{$rename:{"name":"studentName"}},{multi:true});

【修改多个】

db.表名.update({},{$rename:{"原字段1":"新字段1","原字段2":"新字段2"}},false,true)

db.students.update({},{$rename:{"name":"studentName", "age":"studentAge"}},false,true);

【内嵌字段】

db.表名.update({},{$rename:{"外部字段.原字段":"外部字段.新字段"}},false,true)

{
  "_id": 1,
  "alias": [ "LiMing", "Ming" ],
  "contact": { "qq" : "123456", "mobile" : "123-567-8899" }
}


db.students.update({}, {$rename:{"contact.mobile": "contact.phone" }},false,true)

-- 或者
db.getCollection("students").update({},{$rename:{"name":"studentName"}},{multi:true});

`updateMany` 方法

db.表名.updateMany({},{$rename:{"原字段":"新字段"}})

db.students.updateMany({},{$rename:{"name":"studentName"}});

【修改多个】
db.表名.updateMany({},{$rename:{"原字段1":"新字段1","原字段2":"新字段2"}})

db.students.updateMany({},{$rename:{"name":"studentName", "age":"studentAge"}});

五、删除

1. 集合删除

删除集合：同样需要先切换到该集合

db.collection.drop()

2. 删除文档

删除后不能撤销

//按条件删除
db.sys_device.remove({"name":"张三"})
//没有条件删除全部
db.sys_device.remove({})
//删除符合条件的第一条数据
db.students.remove({sex:1},{justOne:true})

3. 删除字段

-- 删除整个文档的   false:当记录不存在的时候是否增加记录    true:是否需要修改多条记录
db.table.update({},{$unset:{content:""}},false, true)

参考：https://www.cnblogs.com/PatrickLiu/p/8669020.html

MongoDB常用操作

一、操作

二、新增

1. 创建集合（表）

2. 插入文档

3. 新增字段

三、查看

1. 查看所有文档

2. 只查看一条文档

3. 带条件查找

$and 多条件查询

and 和 or 组合

$in $nin 查询

$not 取反

以 ID 作为查询条件

以特定值开头

是否包含某个值

只显示 num 条

跳过 num 条

分页

以某个字段的数据类型筛选

$slice

$all 和字段值顺序无关的查询