MongoDB 常用命令汇总
- mongodb数据库结构与传统关系型数据库对比
- MongoDB 创建数据库
- 创建/切换数据库
- 查看当前数据库名称
- 查看所有数据库
- MongoDB 删除数据库
- 删除集合
- MongoDB 插入文档
- 实例
- MongoDB 查询文档
- 语法
- 实例
- MongoDB 与 RDBMS Where 语句比较(大于、小于...)
- MongoDB AND 条件
- 实例
- MongoDB OR 条件
- 实例
- AND 和 OR 联合使用
- MongoDB 条件操作符
- 描述
- MongoDB (>) 大于操作符 - $gt
- MongoDB（>=）大于等于操作符 - $gte
- MongoDB (<) 小于操作符 - $lt
- MongoDB (<=) 小于等于操作符 - $lte
- MongoDB 使用 (<) 和 (>) 查询 - $lt 和 $gt
- 模糊查询(正则)
- $elemMatch操作符查询内嵌文档(数组对象)
- 尝试使用其他方式查询
- MongoDB中的聚合管道aggregate（`$lookup多表关联查询、$unwind、$match、$project`）
- MongoDB 索引
- createIndex() 方法
- 语法
- 实例
- 实例
- MongoDB 覆盖索引查询
- 使用覆盖索引查询
- MongoDB 高级索引
- 索引数组字段
- 索引子文档字段
- MongoDB 索引限制
- 额外开销
- 内存(RAM)使用
- 查询限制
- 索引键限制
- 插入文档超过索引键限制
- 最大范围
- MongoDB ObjectId
- 创建新的ObjectId
- 创建文档的时间戳
- ObjectId 转换为字符串
- MongoDB Limit与Skip方法
- MongoDB Limit() 方法
- 语法
- 实例
- MongoDB Skip() 方法
- 语法
你越是认真生活，你的生活就会越美好——弗兰克·劳埃德·莱特
《人生果实》经典语录
mongodb – 菜鸟教程文档
内容来自菜鸟教程文档，这里整理成一篇文章，一方面加深自己印象，另一方面方便查找对应语法，而且自己的内容，想怎么调整就怎么调整
mongodb数据库结构与传统关系型数据库对比
mongodb数据库结构：数据库->集合->文档
传统关系型数据库：数据库->表 ->列
启动MongoDB服务(安装可以参考mongodb中文文档里步骤)
mongo
MongoDB 创建数据库
创建/切换数据库
use jianhongDbs
如果数据库jianhongDbs不存在，则创建jianhongDbs数据库，否则切换到jianhongDbs数据库。
查看当前数据库名称
db
查看所有数据库
show dbs
可以看到，我们刚创建的数据库jianhongDbs并不在数据库的列表中， 要显示它，我们需要向jianhongDbs数据库插入一些数据。
// 这里表示在当前数据库下的jianhongDbs集合插入一条数据
db.jianhongDbs.insert({"name":"菜鸟教程"})
show dbs
MongoDB 中默认的数据库为test，如果你没有创建新的数据库，集合将存放在 test 数据库中。
PS:
在 MongoDB 中，集合只有在内容插入后才会创建!就是说，创建集合(数据表)后要再插入一个文档(记录)，集合才会真正创建。
MongoDB 删除数据库
db.dropDatabase()
删除当前数据库，默认为 test，你可以使用 db 命令查看当前数据库名。
删除集合
db.collection.drop()
> use runoob
switched to db runoob
> db.createCollection("runoob") # 先创建集合runoob，类似数据库中的表
> show tables # show collections 命令会更加准确点
runoob
> db.runoob.drop()
true
> show tables
MongoDB 插入文档
mongodb数据库结构：数据库->集合->文档
将数据插入到 MongoDB 的集合中。
文档的数据结构和 JSON 基本一样。
所有存储在集合中的数据都是 BSON 格式。
BSON 是一种类似 JSON 的二进制形式的存储格式，是 Binary JSON 的简称。
MongoDB 使用 insert() 或 save() 方法向集合中插入文档，语法如下：
db.COLLECTION_NAME.insert(document)
或
db.COLLECTION_NAME.save(document)
- save()：如果
_id 主键存在则更新数据，如果不存在就插入数据。该方法新版本中已废弃，可以使用 db.collection.insertOne() 或 db.collection.replaceOne() 来代替。 - insert(): 若插入的数据主键已经存在，则会抛 org.springframework.dao.DuplicateKeyException 异常，提示主键重复，不保存当前数据。
3.2 版本之后新增了db.collection.insertOne()和 db.collection.insertMany()。
db.collection.insertOne()用于向集合插入一个新文档，语法格式如下：
db.collection.insertOne(
<document>,
{
writeConcern: <document>
}
)
db.collection.insertMany() 用于向集合插入多个文档，语法格式如下：
db.collection.insertMany(
[ <document 1> , <document 2>, ... ],
{
writeConcern: <document>,
ordered: <boolean>
}
)
参数说明：
- document：要写入的文档。
- writeConcern：写入策略，默认为 1，即要求确认写操作，0 是不要求。
- ordered：指定是否按顺序写入，默认 true，按顺序写入。
实例
以下文档可以存储在 MongoDB 的 runoob 数据库 的 col 集合中：
db.col.insert({title: 'MongoDB 教程',
description: 'MongoDB 是一个 Nosql 数据库',
by: '菜鸟教程',
url: 'http://www.runoob',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100
})
以上实例中 col 是我们的集合名，如果该集合不在该数据库中， MongoDB 会自动创建该集合并插入文档。
查看集合内的文档：
db.col.find()
// { "_id" : ObjectId("56064886ade2f21f36b03134"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "菜鸟教程", "url" : "http://www.runoob", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }
我们也可以将数据定义为一个变量，如下所示：
document=({title: 'MongoDB 教程2',
description: 'MongoDB 是一个 Nosql 数据库',
by: '菜鸟教程',
url: 'http://www.runoob',
tags: ['mongodb', 'database', 'NoSQL'],
likes: 100
});
执行后显示结果如下
执行插入操作：
db.col.insert(document)
插入文档你也可以使用db.col.save(document)命令。如果不指定 _id 字段 save() 方法类似于 insert() 方法。如果指定 _id 字段，则会更新该 _id 的数据。
db.col.save(document)
指定_id为第三条数据的_id
document = {
"_id" : ObjectId("5feb521ae93dfe96489f733b"),
"title" : "MongoDB 教程3",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob",
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100.0
}
db.col.save(document)
db.col.find()
PS
- mongodb数据库结构：
数据库->集合->文档: - 每生成一条文档，假如没有指定
_id的值，系统会自动生成，为ObjectId类型
MongoDB 查询文档
MongoDB 查询文档
MongoDB 查询文档使用 find() 方法。
find() 方法以非结构化的方式来显示所有文档。
语法
MongoDB 查询数据的语法格式如下：
db.collection.find(query, projection)
- query ：可选，使用查询操作符指定查询条件
- projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）。
// 查询结果不返回config、history_config内容
const result = await ctx.model.Activity.findOne({ statistics_id }, { config: 0, history_config: 0 });
如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：
>db.col.find().pretty()
pretty() 方法以格式化的方式来显示所有文档。
实例
以下实例我们查询了集合 col 中的数据：
node代码里操作mongo数据
find返回的数据是数组格式 即使符合条件的文档只有一个
> db.col.find().pretty()
{
"_id" : ObjectId("56063f17ade2f21f36b03133"),
"title" : "MongoDB 教程",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob",
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100
}
除了 find() 方法之外，还有一个 findOne() 方法，它只返回一个文档对象。
MongoDB 与 RDBMS Where 语句比较(大于、小于…)
我没接触过RDBMS Where
| 操作 | 格式 | 范例 | RDBMS中的类似语句 |
|---|---|---|---|
| 等于 | {<key>:<value>} | db.col.find({"by":"菜鸟教程"}).pretty() | where by = '菜鸟教程' |
| 小于 | {<key>:{$lt:<value>}} | db.col.find({"likes":{$lt:50}}).pretty() | where likes < 50 |
| 小于或等于 | {<key>:{$lte:<value>}} | db.col.find({"likes":{$lte:50}}).pretty() | where likes <= 50 |
| 大于 | {<key>:{$gt:<value>}} | db.col.find({"likes":{$gt:50}}).pretty() | where likes > 50 |
| 大于或等于 | {<key>:{$gte:<value>}} | db.col.find({"likes":{$gte:50}}).pretty() | where likes >= 50 |
| 不等于 | {<key>:{$ne:<value>}} | db.col.find({"likes":{$ne:50}}).pretty() | where likes != 50 |
MongoDB AND 条件
MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规 SQL 的 AND 条件。
语法格式如下：
>db.col.find({key1:value1, key2:value2}).pretty()
实例
以下实例通过 by 和 title 键来查询 菜鸟教程 中 MongoDB 教程 的数据
> db.col.find({"by":"菜鸟教程", "title":"MongoDB 教程"}).pretty()
{
"_id" : ObjectId("56063f17ade2f21f36b03133"),
"title" : "MongoDB 教程",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob",
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100
}
以上实例中类似于 WHERE 语句：WHERE by='菜鸟教程' AND title='MongoDB 教程'
MongoDB OR 条件
MongoDB OR 条件语句使用了关键字 $or,语法格式如下：
>db.col.find(
{
$or: [
{key1: value1}, {key2:value2}
]
}
).pretty()
实例
以下实例中，我们演示了查询键 by 值为 菜鸟教程 或 键 title 值为 MongoDB 教程的文档。
>db.col.find(
{
$or:
[
{
"by":"菜鸟教程"
},
{
"title": "MongoDB 教程"
}
]
}).pretty()
// 输出结果如下
{
"_id" : ObjectId("56063f17ade2f21f36b03133"),
"title" : "MongoDB 教程",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob",
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100
}
AND 和 OR 联合使用
以下实例演示了 AND 和 OR 联合使用，类似常规 SQL 语句为：'where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')'
>db.col.find(
{
"likes":
{
$gt:50
},
$or:
[
{
"by": "菜鸟教程"
},
{
"title": "MongoDB 教程"
}
]
}).pretty()
// 输出结果如下
{
"_id" : ObjectId("56063f17ade2f21f36b03133"),
"title" : "MongoDB 教程",
"description" : "MongoDB 是一个 Nosql 数据库",
"by" : "菜鸟教程",
"url" : "http://www.runoob",
"tags" : [
"mongodb",
"database",
"NoSQL"
],
"likes" : 100
}
MongoDB 条件操作符
描述
条件操作符用于比较两个表达式并从mongoDB集合中获取数据。
在本章节中，我们将讨论如何在MongoDB中使用条件操作符。
MongoDB中条件操作符有：
- (>) 大于 - $gt
- (<) 小于 - $lt
- (>=) 大于等于 - $gte
- (<= ) 小于等于 - $lte
知道完整英文单词更容易记忆
$gt -------- greater than >
$gte --------- gt equal >=
$lt -------- less than <
$lte --------- lt equal <=
$ne ----------- not equal !=
$eq -------- equal =
我们使用的数据库名称为"runoob" 我们的集合名称为"col"，以下为我们插入的数据。
为了方便测试，我们可以先使用以下命令清空集合 "col" 的数据：
db.col.remove({})
插入以下数据
db.col.insert([
{
title: 'PHP 教程',
description: 'PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。',
by: '菜鸟教程',
url: 'http://www.runoob',
tags: ['php'],
likes: 200
},
{title: 'Java 教程',
description: 'Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。',
by: '菜鸟教程',
url: 'http://www.runoob',
tags: ['java'],
likes: 150
},
{title: 'MongoDB 教程',
description: 'MongoDB 是一个 Nosql 数据库',
by: '菜鸟教程',
url: 'http://www.runoob',
tags: ['mongodb'],
likes: 100
}
])
使用find()命令查看数据：
db.col.find()
MongoDB (>) 大于操作符 - $gt
如果你想获取 “col” 集合中"likes" 大于 100 的数据，你可以使用以下命令：
db.col.find({likes : {$gt : 100}})
输出结果：
MongoDB（>=）大于等于操作符 - $gte
如果你想获取"col"集合中 "likes" 大于等于 100 的数据，你可以使用以下命令：
db.col.find({likes : {$gte : 100}})
输出结果
MongoDB (<) 小于操作符 - $lt
如果你想获取"col"集合中 "likes" 小于 150 的数据，你可以使用以下命令：
db.col.find({likes : {$lt : 150}})
输出结果
MongoDB (<=) 小于等于操作符 - $lte
如果你想获取"col"集合中 "likes" 小于等于 150 的数据，你可以使用以下命令：
db.col.find({likes : {$lte : 150}})
输出结果：
MongoDB 使用 (<) 和 (>) 查询 - $lt 和 $gt
如果你想获取"col"集合中 "likes" 大于100，小于 200 的数据，你可以使用以下命令：
db.col.find({
"likes":
{
"$gt": 100,
"$lt": 200
}
})
输出结果：
模糊查询(正则)
查询 title 包含"教"字的文档：
db.col.find({title:/教/})
查询 title 字段以"教"字开头的文档：
db.col.find({title: /^教/})
查询 titl e字段以"教"字结尾的文档：
db.col.find({title: /教$/})
$elemMatch操作符查询内嵌文档(数组对象)
$elemMatch
操作符输出文档中field数组中至少一个元素满足全部指定的匹配条件
{<field>:{$elemMatch:{ query1,query2, ... }}}
在test表插入两条数据方便测试，从里面查询出menbers字段里含有name为张三且age为27岁的数据
db.test.insert([
{
"members":[
{
"name":"张三",
"age":27,
"gender":"M"
},
{
"name":"李四",
"age":23,
"gender":"F"
},
]
},
{
"members":[
{
"name":"张三",
"age":37,
"gender":"F"
},
{
"name":"李四",
"age":33,
"gender":"M"
},
]
}
]);
插入后数据如图
从里面查询出menbers字段里含有name为张三，age为27岁且gender为M的数据
db.test.find(
{
"members":
{
"$elemMatch":
{
"name":"张三",
"age": 27
}
}
})
可以查询到
尝试使用其他方式查询
// 查询的结果是空集
db.test.find(
{
"members":
{
"name": "张三",
"age": 27,
}
})
单纯用find查询需要完全匹配 才可以查询到
db.test.find(
{
"members":
{
"name": "张三",
"age": 27,
"gender": "M"
}
})
上面的方法如果改变键值顺序 也查询不到结果
db.test.find(
{
"members":
{
"name": "张三",
"gender": "M",
"age": 27,
}
})
通过find 下面这样也可以查询到
db.test.find(
{
"members.name": "张三"
}
)
// 这里键值顺序调整也不影响
db.test.find(
{
"members.name": "张三",
"members.age": 27
}
)
db.test.find(
{
"members.gender": "F",
"members.age": 33
}
)
这里要注意
"members.gender": "F" 是menbers字段里第一个元素的键值
"members.age": 33是menbers字段里第二个元素的键值
也可以查询出来，也就是通过这种方式，只要查询条件中每一条单独的查询在数组对象中有符合的元素，就能够查询出来
这点$elemMatch操作符不同 $elemMatch操作符要求数组对象中至少有一个元素可以符合查询的全部条件
MongoDB中的聚合管道aggregate（$lookup多表关联查询、$unwind、$match、$project）
单独整理了一篇文章
MongoDB中的聚合管道aggregate（$lookup多表关联查询、$unwind、$match、$project）
MongoDB 索引
索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。
这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。
索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构
createIndex() 方法
MongoDB使用 createIndex() 方法来创建索引。
PS:
注意在 3.0.0 版本前创建索引方法为 db.collection.ensureIndex()，之后的版本使用了 db.collection.createIndex() 方法，ensureIndex() 还能用，但只是 createIndex() 的别名。
语法
createIndex()方法基本语法格式如下所示：
db.collection.createIndex(keys, options)
语法中 Key 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可。
实例
db.col.createIndex({"title":1})
createIndex() 方法中你也可以设置使用多个字段创建索引（关系型数据库中称作复合索引）。
db.col.createIndex({"title":1,"description":-1})
createIndex() 接收可选参数，可选参数列表如下：
| Parameter | Type | Description |
|---|---|---|
| background | Boolean | 建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，即增加 "background" 可选参数。 "background" 默认值为false。 |
| unique | Boolean | 建立的索引是否唯一。指定为true创建唯一索引。默认值为false. |
| name | string | 索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称。 |
| dropDups | Boolean | 3.0+版本已废弃。在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false. |
| sparse | Boolean | 对文档中不存在的字段数据不启用索引；这个参数需要特别注意，如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false. |
| expireAfterSeconds | integer | 指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间。 |
| v | index version | 索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本。 |
| weights | document | 索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重。 |
| default_language | string | 对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语 |
| language_override | string | 对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language. |
实例
在后台创建索引：
db.values.createIndex({open: 1, close: 1}, {background: true})
通过在创建索引时加 background:true 的选项，让创建工作在后台执行
索引相关命令
// 1、查看集合索引
db.col.getIndexes()
// 2、查看集合索引大小
db.col.totalIndexSize()
// 3、删除集合所有索引
db.col.dropIndexes()
// 4、删除集合指定索引
db.col.dropIndex("索引名称")
MongoDB 覆盖索引查询
官方的MongoDB的文档中说明，覆盖查询是以下的查询：
- 所有的查询字段是索引的一部分
- 所有的查询返回字段在同一个索引中
由于所有出现在查询中的字段是索引的一部分， MongoDB 无需在整个数据文档中检索匹配查询条件和返回使用相同索引的查询结果。
因为索引存在于RAM中，从索引中获取数据比通过扫描文档读取数据要快得多。
使用覆盖索引查询
为了测试覆盖索引查询，使用以下 users 集合:
{
"_id": ObjectId("53402597d852426020000002"),
"contact": "987654321",
"dob": "01-01-1991",
"gender": "M",
"name": "Tom Benzamin",
"user_name": "tombenzamin"
}
我们在 users 集合中创建联合索引，字段为 gender 和 user_name :
db.users.ensureIndex({gender:1,user_name:1})
现在，该索引会覆盖以下查询：
b.users.find({gender:"M"},{user_name:1,_id:0})
也就是说，对于上述查询，MongoDB的不会去数据库文件中查找。相反，它会从索引中提取数据，这是非常快速的数据查询。
由于我们的索引中不包括 _id 字段，_id在查询中会默认返回，我们可以在MongoDB的查询结果集中排除它。
下面的实例没有排除_id，查询就不会被覆盖：
db.users.find({gender:"M"},{user_name:1})
最后，如果是以下的查询，不能使用覆盖索引查询：
- 所有索引字段是一个数组
- 所有索引字段是一个子文档
MongoDB 高级索引
考虑以下文档集合（users ）:
{
"address": {
"city": "Los Angeles",
"state": "California",
"pincode": "123"
},
"tags": [
"music",
"cricket",
"blogs"
],
"name": "Tom Benzamin"
}
以上文档包含了 address 子文档和 tags 数组。
索引数组字段
假设我们基于标签来检索用户，为此我们需要对集合中的数组 tags 建立索引。
在数组中创建索引，需要对数组中的每个字段依次建立索引。所以在我们为数组 tags 创建索引时，会为 music、cricket、blogs三个值建立单独的索引。
使用以下命令创建数组索引：
db.users.ensureIndex({"tags":1})
创建索引后，我们可以这样检索集合的 tags 字段：
db.users.find({tags:"cricket"})
为了验证我们使用使用了索引，可以使用 explain 命令：
db.users.find({tags:"cricket"}).explain()
以上命令执行结果中会显示 “cursor” : “BtreeCursor tags_1” ，则表示已经使用了索引。
索引子文档字段
假设我们需要通过city、state、pincode字段来检索文档，由于这些字段是子文档的字段，所以我们需要对子文档建立索引。
为子文档的三个字段创建索引，命令如下：
db.users.ensureIndex({"address.city":1,"address.state":1,"address.pincode":1})
一旦创建索引，我们可以使用子文档的字段来检索数据：
db.users.find({"address.city":"Los Angeles"})
查询表达不一定遵循指定的索引的顺序，mongodb 会自动优化。所以上面创建的索引将支持以下查询：
db.users.find({"address.state":"California","address.city":"Los Angeles"})
同样支持以下查询：
db.users.find({"address.city":"Los Angeles","address.state":"California","address.pincode":"123"})
MongoDB 索引限制
额外开销
每个索引占据一定的存储空间，在进行插入，更新和删除操作时也需要对索引进行操作。所以，如果你很少对集合进行读取操作，建议不使用索引。
内存(RAM)使用
由于索引是存储在内存(RAM)中,你应该确保该索引的大小不超过内存的限制。
如果索引的大小大于内存的限制，MongoDB会删除一些索引，这将导致性能下降。
查询限制
索引不能被以下的查询使用：
- 正则表达式及非操作符，如 $nin, $not, 等。
- 算术运算符，如 $mod, 等。
- $where 子句
所以，检测你的语句是否使用索引是一个好的习惯，可以用explain来查看。
索引键限制
从2.6版本开始，如果现有的索引字段的值超过索引键的限制，MongoDB中不会创建索引。
插入文档超过索引键限制
如果文档的索引字段值超过了索引键的限制，MongoDB不会将任何文档转换成索引的集合。与mongorestore和mongoimport工具类似。
最大范围
集合中索引不能超过64个
索引名的长度不能超过128个字符
一个复合索引最多可以有31个字段
MongoDB ObjectId
在前面几个章节中我们已经使用了MongoDB 的对象 Id(ObjectId)。
在本章节中，我们将了解的ObjectId的结构。
ObjectId 是一个12字节 BSON 类型数据，有以下格式：
- 前4个字节表示时间戳
- 接下来的3个字节是机器标识码
- 紧接的两个字节由进程id组成（PID）
- 最后三个字节是随机数。
MongoDB中存储的文档必须有一个"_id"键。这个键的值可以是任何类型的，默认是个ObjectId对象。
在一个集合里面，每个文档都有唯一的"_id"值，来确保集合里面每个文档都能被唯一标识。
MongoDB采用ObjectId，而不是其他比较常规的做法（比如自动增加的主键）的主要原因，因为在多个 服务器上同步自动增加主键值既费力还费时。
创建新的ObjectId
使用以下代码生成新的ObjectId：
newObjectId = ObjectId()
上面的语句返回以下唯一生成的id：
ObjectId("601772a5bca8c8819192f6f8")
你也可以使用生成的id来取代MongoDB自动生成的ObjectId：
myObjectId = ObjectId("5349b4ddd2781d08c09890f4")
创建文档的时间戳
由于 ObjectId 中存储了4 个字节的时间戳，所以你不需要为你的文档保存时间戳字段，你可以通过 getTimestamp 函数来获取文档的创建时间:
ObjectId("601772a5bca8c8819192f6f8").getTimestamp()
以上代码将返回 ISO 格式的文档创建时间：
ISODate("2021-02-01T03:16:53Z")
ObjectId 转换为字符串
在某些情况下，您可能需要将ObjectId转换为字符串格式。你可以使用下面的代码：
new ObjectId().str
以上代码将返回Guid格式的字符串：：
6017737abca8c8819192f6fc
MongoDB Limit与Skip方法
MongoDB Limit() 方法
如果你需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。
语法
limit()方法基本语法如下所示：
db.COLLECTION_NAME.find().limit(NUMBER)
实例
集合 col 中的数据如下：
{
"_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "菜鸟教程", "url" : "http://www.runoob", "tags" : [ "php" ], "likes" : 200
}
{
"_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "菜鸟教程", "url" : "http://www.runoob", "tags" : [ "java" ], "likes" : 150
}
{
"_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "菜鸟教程", "url" : "http://www.runoob", "tags" : [ "mongodb" ], "likes" : 100
}
以下实例为显示查询文档中的两条记录：
// 只输出title字段 只输出两条记录
db.col.find({},{"title":1,_id:0}).limit(2)
结果如下
注：如果你们没有指定limit()方法中的参数则显示集合中的所有数据。
MongoDB Skip() 方法
我们除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。多用于分页。
语法
skip() 方法脚本语法格式如下：
db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
以下实例只会显示第二条文档数据
db.col.find({},{"title":1,_id:0}).limit(1).skip(1)
注:skip()方法默认参数为 0 。
更新中~~
谢谢你阅读到了最后~
期待你关注、收藏、评论、点赞~
让我们一起 变得更强
推荐阅读
MongoDB中的多表关联查询、聚合管道（$lookup、$unwind）
mongodb、mongoose相关
前端linux基础，这一篇就够了
更多推荐
MongoDB 常用命令汇总
发布评论