2019-08-06 10:51:46

docs/mongodb/10.md

+# MongoDB 插入文档
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-insert-document/](https://beginnersbook.com/2017/09/mongodb-insert-document/)
+
+在本教程中，我们将了解如何将文档插入集合中。我们将在多个示例的帮助下理解这一点。
+
+**将文档插入集合的语法：**
+
+```
+db.collection_name.insert()
+```
+
+让我们举一个例子来理解这一点。
+
+## MongoDB 使用 insert（）示例插入文档
+
+这里我们将文档插入名为“beginnersbook”的集合中。下面示例中的字段“course”是一个包含多个键值对的数组。
+
+```
+db.beginnersbook.insert(  
+   {  
+     name: "Chaitanya",  
+     age: 30,
+     email: "[email protected]",
+     course: [ { name: "MongoDB", duration: 7 }, { name: "Java", duration: 30 } ]
+   }  
+)
+```
+
+您应该看到一条成功的写消息，如下所示：
+
+```
+WriteResult({ "nInserted" : 1 })
+```
+
+> 如果集合不存在，则 insert（）方法创建集合，但如果集合存在，则将文档插入其中
+
+![MongoDB Insert Document](img/9b65c605e4e8c649415808ade5d59ed4.jpg)
+
+**验证：**
+您还可以通过键入以下命令验证文档是否已成功插入：
+
+```
+db.collection_name.find()
+```
+
+在上面的示例中，我们将文档插入名为“beginnersbook”的集合中，因此命令应为：
+
+```
+> db.beginnersbook.find()
+{ "_id" : ObjectId("59bce797668dcce02aaa6fec"), "name" : "Chaitanya", "age" : 30, 
+"email" : "[email protected]", "course" : [ { "name" : "MongoDB", 
+"duration" : 7 }, { "name" : "Java", "duration" : 30 } ] }
+```
+
+## MongoDB 示例：在集合中插入多个文档
+
+要在集合中插入多个文档，我们定义一个文档数组，稍后我们在数组变量上使用 insert（）方法，如下例所示。这里我们在名为“students”的集合中插入三个文档。此命令将在“学生”集合中插入数据，如果集合不存在，则它将创建集合并插入这些文档。
+
+```
+var beginners =
+ [
+    {
+	"StudentId" : 1001,
+	"StudentName" : "Steve",
+        "age": 30
+    },
+    {
+	"StudentId" : 1002,
+	"StudentName" : "Negan",
+        "age": 42
+    },
+    {
+	"StudentId" : 3333,
+	"StudentName" : "Rick",
+        "age": 35
+    },
+];
+db.students.insert(beginners);
+```
+
+你会看到这个输出：
+
+```
+BulkWriteResult({
+        "writeErrors" : [ ],
+        "writeConcernErrors" : [ ],
+        "nInserted" : 3,
+        "nUpserted" : 0,
+        "nMatched" : 0,
+        "nModified" : 0,
+        "nRemoved" : 0,
+        "upserted" : [ ]
+})
+```
+
+如您所见，它在 **nInserted** 前面显示数字 3。这意味着此命令已插入 3 个文档。
+![MongoDB Insert multiple Documents](img/9a5c6a3e1a01602180cec27df3971249.jpg)
+
+验证文档是否在集合中。运行此命令：
+
+```
+db.students.find()
+```
+
+> **你知道吗？** 您可以以 JSON 格式打印输出数据，以便您可以轻松阅读。要以 JSON 格式打印数据，请运行命令 **db.collection_name.find（）。forEach（printjson）**
+
+所以在我们的例子中命令是这样的：
+
+```
+db.students.find().forEach(printjson)
+```
+
+在下面的屏幕截图中，您可以看到差异。首先，我们使用普通的 find（）方法打印文档，然后使用 JSON 格式打印相同集合的文档。 JSON 格式的文档简洁易读。
+![Printing documents in JSON format](img/f3d7706a23f29e28fcb2f62ce23d6699.jpg)
+我们还可以使用 MongoDB 2.6 中引入的 New Bulk API 插入多个文档。我们将在 Bulk API 教程中了解到这一点。
\ No newline at end of file

docs/mongodb/11.md

+# MongoDB 使用 find（）方法查询文档
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-query-document-using-find-method/](https://beginnersbook.com/2017/09/mongodb-query-document-using-find-method/)
+
+在我之前的教程中，我使用 find（）方法查询集合中的所有文档。在本教程中，我们将看到 find（）方法的用法，以根据给定的条件查询集合中的文档。让我们开始吧。
+
+## 以 JSON 格式查询所有文档
+
+假设我们在名为`beginnersbookdb`的数据库中有一个集合`students`。要获取所有文档，我们使用此命令：
+
+```
+db.students.find()
+```
+
+但是，我们获得的输出不是任何格式且不太可读。为了提高可读性，我们可以使用以下命令格式化 JSON 格式的输出：
+
+```
+db.students.find().forEach(printjson);
+```
+
+或者只是使用 pretty（） - 它做同样的事情。
+
+```
+db.students.find().pretty()
+```
+
+正如您在下面的屏幕截图中看到的那样，文档是 JSON 格式的。
+![MongoDB query document in JSON format](img/55e0d2574b9291b44b1f052dcfe3cdd2.jpg)
+
+## 根据条件查询文档
+
+我们可以根据条件获取所选文档，而不是从集合中获取所有文档。
+
+**平等标准：**
+例如：我想从学生集合中获取“史蒂夫”的数据。这个命令应该是：
+
+```
+db.students.find({StudentName : "Steve"}).pretty()
+```
+
+此命令返回与给定条件匹配的文档。
+![MongoDB Query Document Equality Criteria](img/d112e65729b8b6715f8df222fb07f6a3.jpg)
+
+**大于标准：**
+语法：
+
+```
+db.collection_name.find({"field_name":{$gt:criteria_value}}).pretty()
+```
+
+例如：我想获取有年龄的学生的详细信息＆gt; 32 那么查询应该是：
+
+```
+db.students.find({"age":{$gt:32}}).pretty()
+```
+
+我有两个符合条件的文件，如下面的屏幕截图所示：
+![MongoDB Query Document GreaterThan Criteria](img/41a6a4b2a583e6152d27031bee10cbef.jpg)
+
+**小于标准：**
+语法：
+
+```
+db.collection_name.find({"field_name":{$lt:criteria_value}}).pretty()
+```
+
+示例：查找 ID 小于 3000 的所有学生。此标准的命令为：
+
+```
+db.students.find({"StudentId":{$lt:3000}}).pretty()
+```
+
+输出：
+
+```
+> db.students.find({"StudentId":{$lt:3000}}).pretty()
+{
+        "_id" : ObjectId("59bcecc7668dcce02aaa6fed"),
+        "StudentId" : 1001,
+        "StudentName" : "Steve",
+        "age" : 30
+}
+{
+        "_id" : ObjectId("59bcecc7668dcce02aaa6fee"),
+        "StudentId" : 1002,
+        "StudentName" : "Negan",
+        "age" : 42
+}
+```
+
+**不等于标准：**
+语法：
+
+```
+db.collection_name.find({"field_name":{$ne:criteria_value}}).pretty()
+```
+
+示例：查找 id 不等于 1002 的所有学生。此条件的命令为：
+
+```
+db.students.find({"StudentId":{$ne:1002}}).pretty()
+```
+
+Output:
+
+```
+> db.students.find({"StudentId":{$ne:1002}}).pretty()
+{
+        "_id" : ObjectId("59bcecc7668dcce02aaa6fed"),
+        "StudentId" : 1001,
+        "StudentName" : "Steve",
+        "age" : 30
+}
+{
+        "_id" : ObjectId("59bcecc7668dcce02aaa6fef"),
+        "StudentId" : 3333,
+        "StudentName" : "Rick",
+        "age" : 35
+}
+```
+
+以下是另外两个标准：
+
+**大于等于标准：**
+
+```
+db.collection_name.find({"field_name":{$gte:criteria_value}}).pretty()
+```
+
+**小于等于标准：**
+
+```
+db.collection_name.find({"field_name":{$lte:criteria_value}}).pretty()
+```
+
+> 我们在所有命令末尾添加的 pretty（）方法不是必需的。它仅用于格式化目的。
\ No newline at end of file

docs/mongodb/12.md

+# MongoDB - 更新集合中的文档
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-update-document/](https://beginnersbook.com/2017/09/mongodb-update-document/)
+
+在 MongoDB 中，我们有两种方法来更新集合中的文档。 1）update（）方法 2）save（）方法。虽然这两种方法都更新了现有文档，但它们正在不同的场景中使用。当我们需要更新现有文档的值时使用 update（）方法，而 save（）方法用于将现有文档替换为已在其中传递的文档。
+
+要更新 MongoDB 中的文档，我们在命令中提供条件，并更新与该条件匹配的文档。要了解标准在 MongoDB 命令中的工作方式，请参阅上一个教程： [MongoDB 查询文档](https://beginnersbook.com/2017/09/mongodb-query-document-using-find-method/)
+
+## 使用 update（）方法更新文档
+
+**语法：**
+
+```
+db.collection_name.update(criteria, update_data)
+```
+
+**示例：**
+例如：假设我在数据库“beginnersbookdb”中有一个名为“got”的集合。 “得到”里面的文件是：
+
+```
+> db.got.find().pretty()
+{
+        "_id" : ObjectId("59bd2e73ce524b733f14dd65"),
+        "name" : "Jon Snow",
+        "age" : 32
+}
+{
+        "_id" : ObjectId("59bd2e8bce524b733f14dd66"),
+        "name" : "Khal Drogo",
+        "age" : 36
+}
+{
+        "_id" : ObjectId("59bd2e9fce524b733f14dd67"),
+        "name" : "Sansa Stark",
+        "age" : 20
+}
+{
+        "_id" : ObjectId("59bd2ec5ce524b733f14dd68"),
+        "name" : "Lord Varys",
+        "age" : 42
+}
+```
+
+现在假设我想更新名为“Kit Harington”的 Jon Snow 的名字。对此的命令是：
+
+```
+db.got.update({"name":"Jon Snow"},{$set:{"name":"Kit Harington"}})
+```
+
+**输出：**
+![MongoDB Update Document](img/46fb27fc47fdb6655124f718fd32e4d2.jpg)
+
+如您所见，该文档已更新。
+
+> **你知道吗？** 默认情况下，更新方法更新单个文档。在上面的示例中，我们只有一个文档与条件匹配，但是如果有更多文档，那么也只会更新一个文档。要启用 update（）方法来更新多个文档，您必须将此方法的“multi”参数设置为 true，如下所示。
+
+**使用 update（）方法更新多个文档：**
+
+```
+db.got.update({"name":"Jon Snow"},
+ {$set:{"name":"Kit Harington"}},{multi:true})
+
+```
+
+## 使用 save（）方法更新文档
+
+**语法：**
+
+```
+db.collection_name.save( {_id:ObjectId(), new_document} )
+```
+
+让我们采用我们在上面看到的相同的例子。现在我们要将“Kit Harington”的名称更新为“Jon Snow”。要使用 save（）方法，您应该知道该文档的唯一 _id 字段。
+
+> 一个非常重要的**注意事项**是当你在使用 save（）
+> 方法时不提供 **_id** 字段时，它调用 insert（）方法并插入传递的文件作为新文档进入集合
+
+要获取文档的 _id，可以键入以下命令：
+
+```
+db.got.find().pretty()
+```
+
+这里有一个集合名称。这种查找唯一 _id 的方法仅在您拥有少量文档时才有用，否则在大量文档中滚动和搜索该 _id 是很繁琐的。
+
+如果您有大量文档，那么要获取特定文档的 _id，请使用 find（）方法中的条件。例如：要使用 save（）方法获取要更新的文档的 _id，请键入以下命令：
+
+```
+> db.got.find({"name": "Kit Harington"}).pretty()
+{
+        "_id" : ObjectId("59bd2e73ce524b733f14dd65"),
+        "name" : "Kit Harington",
+        "age" : 32
+}
+```
+
+现在我们知道该文档的唯一 _id 字段。让我们使用 save（）方法编写命令。
+
+```
+> db.got.save({"_id" : ObjectId("59bd2e73ce524b733f14dd65"), "name":
+ "Jon Snow", "age": 30})
+>
+```
+
+你应该看到这个输出：
+
+```
+WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
+```
+
+**验证更新：**
+![MongoDB save() method to update document](img/5858855ca8662da8ebaf5513bccea6c6.jpg)
\ No newline at end of file

docs/mongodb/13.md

+# MongoDB 从集合中删除文档
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-delete-document/](https://beginnersbook.com/2017/09/mongodb-delete-document/)
+
+在本教程中，我们将学习如何从集合中删除文档。 remove（）方法用于从 MongoDB 中的集合中删除文档。
+
+**remove（）方法的语法：**
+
+```
+db.collection_name.remove(delete_criteria)
+```
+
+> 要了解如何在 MongoDB 命令中指定条件，请参阅本教程： [MongoDB 查询文档](https://beginnersbook.com/2017/09/mongodb-query-document-using-find-method/)。
+
+## 使用 remove（）方法删除文档
+
+假设我的 MongoDB 数据库中有一个名为`beginnersbookdb`的集合`students`。 `students`集合中的文件是：
+
+```
+> db.students.find().pretty()
+{
+        "_id" : ObjectId("59bcecc7668dcce02aaa6fed"),
+        "StudentId" : 1001,
+        "StudentName" : "Steve",
+        "age" : 30
+}
+{
+        "_id" : ObjectId("59bcecc7668dcce02aaa6fef"),
+        "StudentId" : 3333,
+        "StudentName" : "Rick",
+        "age" : 35
+}
+```
+
+现在我想删除这个学生 ID 等于 3333 的学生。要做到这一点，我会使用 remove（）方法编写一个命令，如下所示：
+
+```
+db.students.remove({"StudentId": 3333})
+```
+
+输出：
+
+```
+WriteResult({ "nRemoved" : 1 })
+```
+
+验证文档是否实际删除。键入以下命令：
+
+```
+db.students.find().pretty()
+```
+
+它将列出学生收集的所有文件。
+
+以下是上述所有步骤的屏幕截图：
+![MongoDB Delete Document](img/cd532cb0aa6ad13fb988fc0cc0713986.jpg)
+
+## 如何只删除一个符合条件的文档？
+
+当集合中存在多个符合条件的文档时，如果运行 remove 命令，则将删除所有这些文档。但是，有一种方法可以将删除限制为仅一个文档，这样即使有更多文档符合删除条件，也只会删除一个文档。
+
+```
+db.collection_name.remove(delete_criteria, justOne)
+```
+
+这里 justOne 是一个布尔参数，只取 1 和 0，如果你给 1，那么它会将文件删除限制为只有 1 个文件。这是一个可选参数，如上所述，我们使用 remove（）方法而不使用此参数。
+
+例如，我在集合中有以下记录。
+
+```
+> db.walkingdead.find().pretty()
+{
+        "_id" : ObjectId("59bf280cb8e797a22c654229"),
+        "name" : "Rick Grimes",
+        "age" : 32,
+        "rname" : "Andrew Lincoln"
+}
+{
+        "_id" : ObjectId("59bf2851b8e797a22c65422a"),
+        "name" : "Negan",
+        "age" : 35,
+        "rname" : "Jeffrey Dean Morgan"
+}
+{
+        "_id" : ObjectId("59bf28a5b8e797a22c65422b"),
+        "name" : "Daryl Dixon",
+        "age" : 32,
+        "rname" : "Norman Reedus"
+}
+```
+
+假设我想删除年龄等于 32 的文档。此集合中有两个文档符合此条件。但是，为了将删除限制为 1，我们将 justOne 参数设置为 true。
+
+```
+db.walkingdead.remove({"age": 32}, 1)
+```
+
+输出：如您所见，只有一个文档被删除。
+
+```
+WriteResult({ "nRemoved" : 1 })
+```
+
+![Deleting only one document MongoDB](img/0ebf2b7da351882f068ed5a133b5aa1f.jpg)
+
+## 删除所有文件
+
+如果要从集合中删除所有文档但不想删除集合本身，则可以使用 remove（）方法，如下所示：
+
+```
+db.collection_name.remove({})
+```
+
+> 如果您想删除该集合以及所有文档，请参阅本指南： [MongoDB Drop Collection](https://beginnersbook.com/2017/09/mongodb-drop-collection/)
\ No newline at end of file

docs/mongodb/14.md

+# MongoDB 投影
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-projection/](https://beginnersbook.com/2017/09/mongodb-projection/)
+
+在之前的教程中，我们学习了[如何在查询文档](https://beginnersbook.com/2017/09/mongodb-query-document-using-find-method/)时使用条件来从集合中获取所选文档。在本教程中，我们将学习 MongoDB 的另一个有趣话题，即 **MongoDB Projection** 。当我们想要获取文档的选定字段而不是所有字段时使用。
+
+例如，我们有一个集合，其中存储了包含以下字段的文档：student_name，student_id，student_age 但我们只想查看所有学生的 student_id，那么在这种情况下我们可以使用 projection 来获取 student_id。
+
+**语法：**
+
+```
+db.collection_name.find({},{field_key:1 or 0})
+```
+
+现在不要担心语法，我们将看到一个例子来理解这一点。
+
+## MongoDB 投影示例
+
+让我们举一个例子来理解 MongoDB 中的 Projection。我们有一个名为`studentdata`的集合，其中包含以下文档。
+
+```
+> db.studentdata.find().pretty()
+{
+        "_id" : ObjectId("59bf63380be1d7770c3982af"),
+        "student_name" : "Steve",
+        "student_id" : 2002,
+        "student_age" : 22
+}
+{
+        "_id" : ObjectId("59bf63500be1d7770c3982b0"),
+        "student_name" : "Carol",
+        "student_id" : 2003,
+        "student_age" : 22
+}
+{
+        "_id" : ObjectId("59bf63650be1d7770c3982b1"),
+        "student_name" : "Tim",
+        "student_id" : 2004,
+        "student_age" : 23
+}
+```
+
+要仅获取所有文档的 student_id，我们将使用以下投影：
+
+```
+> db.studentdata.find({}, {"_id": 0, "student_id": 1})
+{ "student_id" : 2002 }
+{ "student_id" : 2003 }
+{ "student_id" : 2004 }
+```
+
+![MongoDB Projection Example](img/1f703d63b52c3f71e86de1fc965f5e92.jpg)
+
+> 值 1 表示显示字段，0 表示不显示该字段。当我们在 Projection 中将字段设置为 1 时，除了 _id 之外，其他字段会自动设置为 0，因此为了避免 _id，我们需要在投影中将其专门设置为 0。反之亦然，当我们将少数字段设置为 0，其他字段自动设置为 1 时（参见下面的示例）
+
+另一种做同样事情的方法：
+
+```
+> db.studentdata.find({}, {"_id": 0, "student_name": 0, "student_age": 0})
+{ "student_id" : 2002 }
+{ "student_id" : 2003 }
+{ "student_id" : 2004 }
+```
+
+**重要提示：**
+有些人在查询中使用 Projection 时可能会收到此错误：
+
+```
+Error: error: {
+  "ok" : 0,
+  "errmsg" : "Projection cannot have a mix of inclusion and exclusion.",
+  "code" : 2,
+  "codeName" : "BadValue"
+}
+```
+
+当您将某些字段设置为 0 而其他字段设置为 1 时会发生这种情况，换句话说，您将混合包含和排除组合在一起，唯一的例外是 _id 字段。例如：以下 Query 将产生此错误：
+
+```
+db.studentdata.find({}, {"_id": 0, "student_name": 0, "student_age": 1})
+```
+
+这是因为我们将 student_name 设置为 0，将其他字段 student_age 设置为 1.我们不能混用这些。您可以将不想显示的字段设置为 0，或将字段设置为 1 以显示。
\ No newline at end of file

docs/mongodb/15.md

+# MongoDB - limit（）和 skip（）方法
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-limit-and-skip-method/](https://beginnersbook.com/2017/09/mongodb-limit-and-skip-method/)
+
+在本教程中，我们将学习如何在 MongoDB 查询中使用 limit（）和 skip（）方法。
+
+## MongoDB 中的 limit（）方法
+
+此方法限制响应特定查询而返回的文档数。
+语法：
+
+```
+db.collection_name.find().limit(number_of_documents)
+```
+
+让我们举一个例子来了解如何使用这种方法。可以说，我有一个集合`studentdata`，其中包含以下文件：
+
+```
+> db.studentdata.find().pretty()
+{
+        "_id" : ObjectId("59bf63380be1d7770c3982af"),
+        "student_name" : "Steve",
+        "student_id" : 2002,
+        "student_age" : 22
+}
+{
+        "_id" : ObjectId("59bf63500be1d7770c3982b0"),
+        "student_name" : "Carol",
+        "student_id" : 2003,
+        "student_age" : 22
+}
+{
+        "_id" : ObjectId("59bf63650be1d7770c3982b1"),
+        "student_name" : "Tim",
+        "student_id" : 2004,
+        "student_age" : 23
+}
+```
+
+让我们说我想找出所有学生的名单，ID 为＆gt;我会用一个标准写一个这样的查询：
+
+> 要了解在查询文档时如何指定条件，请阅读： [MongoDB 查询文档](https://beginnersbook.com/2017/09/mongodb-query-document-using-find-method/)
+
+```
+db.studentdata.find({student_id : {$gt:2002}}).pretty()
+```
+
+![MongoDB limit method in Query](img/32fef9988e1185247d3d2880e58c4d48.jpg)
+
+**使用 limit（）方法限制结果中的文件：**
+让我说我不希望所有符合条件的文件。我只想选择一些文件，然后我可以使用 limit（）方法来限制文件的数量。例如，如果我只想输出一个文档，那么我会这样做：
+
+```
+> db.studentdata.find({student_id : {$gt:2002}}).limit(1).pretty()
+{
+        "_id" : ObjectId("59bf63500be1d7770c3982b0"),
+        "student_name" : "Carol",
+        "student_id" : 2003,
+        "student_age" : 22
+}
+```
+
+## MongoDB Skip（）方法
+
+skip（）方法用于在 Query 结果中跳过给定数量的文档。
+
+要理解 skip（）方法的使用，让我们采用上面我们看到的相同示例。在上面的例子中，我们可以看到，通过使用 limit（1），我们设法只获得一个文档，这是第一个与给定条件匹配的文档。如果您不希望第一个文档符合您的条件，该怎么办？例如，我们有两个文件，其 student_id 值大于 2002 但是当我们使用 limit（1）将结果限制为 1 时，我们得到了第一个文档，为了得到符合此条件的第二个文档，我们可以使用 skip（1） ）这里将跳过第一份文件。
+
+**不使用 skip（）：**
+
+```
+> db.studentdata.find({student_id : {$gt:2002}}).limit(1).pretty()
+{
+        "_id" : ObjectId("59bf63500be1d7770c3982b0"),
+        "student_name" : "Carol",
+        "student_id" : 2003,
+        "student_age" : 22
+}
+```
+
+**使用跳过：**
+
+```
+> db.studentdata.find({student_id : {$gt:2002}}).limit(1).skip(1).pretty()
+{
+        "_id" : ObjectId("59bf63650be1d7770c3982b1"),
+        "student_name" : "Tim",
+        "student_id" : 2004,
+        "student_age" : 23
+}
+```
\ No newline at end of file

docs/mongodb/16.md

+# MongoDB sort（）方法
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-sort-method/](https://beginnersbook.com/2017/09/mongodb-sort-method/)
+
+在本教程中，我们将学习如何使用 sort（）方法对文档进行排序。
+
+## 使用 sort（）方法对文档进行排序
+
+使用 sort（）方法，您可以根据文档的特定字段按升序或降序对文档进行排序。
+
+**sort（）方法的语法：**
+
+```
+db.collecttion_name.find().sort({field_key:1 or -1})
+```
+
+1 表示升序，-1 表示降序。默认值为 1\.
+**
+例如：**集合`studentdata`包含以下文档：
+
+```
+> db.studentdata.find().pretty()
+{
+        "_id" : ObjectId("59bf63380be1d7770c3982af"),
+        "student_name" : "Steve",
+        "student_id" : 2002,
+        "student_age" : 22
+}
+{
+        "_id" : ObjectId("59bf63500be1d7770c3982b0"),
+        "student_name" : "Carol",
+        "student_id" : 2003,
+        "student_age" : 22
+}
+{
+        "_id" : ObjectId("59bf63650be1d7770c3982b1"),
+        "student_name" : "Tim",
+        "student_id" : 2004,
+        "student_age" : 23
+}
+```
+
+假设我想以**降序**显示所有文档的`student_id`：
+
+> 要仅显示特定的文档字段，我使用的是 [MongoDB 投影](https://beginnersbook.com/2017/09/mongodb-projection/)
+
+```
+> db.studentdata.find({}, {"student_id": 1, _id:0}).sort({"student_id": -1})
+{ "student_id" : 2004 }
+{ "student_id" : 2003 }
+{ "student_id" : 2002 }
+```
+
+要以**升序**显示所有学生的 student_id 字段：
+
+```
+> db.studentdata.find({}, {"student_id": 1, _id:0}).sort({"student_id": 1})
+{ "student_id" : 2002 }
+{ "student_id" : 2003 }
+{ "student_id" : 2004 }
+```
+
+**默认值：**默认为升序，所以如果我在 sort（）方法中没有提供任何值，那么它将按升序对记录进行排序，如下所示：
+
+```
+> db.studentdata.find({}, {"student_id": 1, _id:0}).sort({})
+{ "student_id" : 2002 }
+{ "student_id" : 2003 }
+{ "student_id" : 2004 }
+```
+
+**您还可以根据您不想显示的字段对文档进行排序：**例如，您可以根据 student_id 对文档进行排序，并显示 student_age 和 student_name 字段。
+
+![MongoDB Sort Documents](img/3f3a87402f177880235c5d54006d05ef.jpg)
\ No newline at end of file

docs/mongodb/17.md

+# MongoDB 索引教程与示例
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-indexing-tutorial-with-example/](https://beginnersbook.com/2017/09/mongodb-indexing-tutorial-with-example/)
+
+MongoDB 中的**索引**是一种特殊的数据结构，它保存创建索引的少量文档字段的数据。索引提高了数据库中搜索操作的速度，因为不是搜索整个文档，而是对仅包含少量字段的索引执行搜索。另一方面，由于索引使用了额外的写入和额外数据空间，索引太多会妨碍插入，更新和删除操作的性能。
+
+## 如何在 MongoDB 中创建索引
+
+**语法：**
+
+```
+db.collection_name.createIndex({field_name: 1 or -1})
+```
+
+值 1 表示升序，-1 表示降序。
+
+例如，我有一个集合`studentdata`。此集合中的文档包含以下字段：
+student_name，student_id 和 student_age
+
+假设我想按升序在 student_name 字段上创建索引：
+
+```
+db.studentdata.createIndex({student_name: 1})
+```
+
+**输出：**
+
+```
+{
+        "createdCollectionAutomatically" : false,
+        "numIndexesBefore" : 1,
+        "numIndexesAfter" : 2,
+        "ok" : 1
+}
+```
+
+![MongoDB create index](img/e72447552a10b2a820090df108f423b4.jpg)
+
+我们在 student_name 上创建了索引，这意味着当有人根据 student_name 搜索文档时，搜索速度会更快，因为索引将用于此搜索。因此，在字段中创建将在集合中频繁搜索的索引非常重要。
+
+## MongoDB - 查找集合中的索引
+
+我们可以使用 getIndexes（）方法来查找在集合上创建的所有索引。此方法的语法是：
+
+```
+db.collection_name.getIndexes()
+```
+
+因此，要获取`studentdata`集合的索引，命令将是：
+
+```
+> db.studentdata.getIndexes()
+[
+        {
+                "v" : 2,
+                "key" : {
+                        "_id" : 1
+                },
+                "name" : "_id_",
+                "ns" : "test.studentdata"
+        },
+        {
+                "v" : 2,
+                "key" : {
+                        "student_name" : 1
+                },
+                "name" : "student_name_1",
+                "ns" : "test.studentdata"
+        }
+]
+```
+
+输出显示我们在此集合中有两个索引。在 _id 上创建的默认索引以及我们在 student_name 字段上创建的索引。
+
+## MongoDB - 删除集合中的索引
+
+您可以删除特定索引或所有索引。
+
+**删除特定索引：**
+为此，使用了 dropIndex（）方法。
+
+```
+db.collection_name.dropIndex({index_name: 1})
+```
+
+让我们删除我们在集合`studentdata`中的`student_name`字段上创建的索引。这个命令：
+
+```
+db.studentdata.dropIndex({student_name: 1})
+```
+
+![MongoDB Drop Index](img/47fafb49e9afce059bd06e823ad2d118.jpg)
+nIndexesWas：显示执行此命令之前有多少索引
+ok：1：表示命令执行成功。
+
+**删除所有索引：**
+要删除集合的所有索引，我们使用 dropIndexes（）方法。
+dropIndexs（）方法的语法：
+
+```
+db.collection_name.dropIndexes()
+```
+
+假设我们想要删除`studentdata`集合的所有索引。
+
+```
+db.studentdata.dropIndexes()
+```
+
+![MongoDb Dropping all indexes](img/8ab0ef03956d2779bf59fe3a97a9e34e.jpg)
+
+消息“为集合删除的非 _id 索引”表示默认索引 _id 仍将保留，不能删除。这意味着使用此方法我们只能删除我们创建的索引，我们不能删除在 _id 字段上创建的默认索引。
\ No newline at end of file

docs/mongodb/2.md

+# NoSQL 数据库简介
+
+> 原文： [https://beginnersbook.com/2017/09/introduction-to-nosql/](https://beginnersbook.com/2017/09/introduction-to-nosql/)
+
+数据库管理系统提供存储和检索数据的机制。有不同种类的数据库管理系统：
+1\. RDBMS（关系数据库管理系统）
+2\. OLAP（在线分析处理）
+3\. NoSQL（不仅是 SQL）
+
+在本指南中，我们将讨论 NoSQL。 **NoSQL 数据库**的创建是为了克服关系数据库的局限性。
+
+## 什么是 NoSQL 数据库？
+
+NoSQL 数据库与 MQSql 等关系数据库不同。在关系数据库中，您需要创建表，定义模式，设置字段的数据类型等，然后才能实际插入数据。在 NoSQL 中你不必担心，你可以动态插入，更新数据。
+
+NoSQL 数据库的一个优点是它们非常容易扩展，并且它们在我们在数据库上执行的大多数类型的操作中要快得多。在某些情况下，您更喜欢关系数据库而不是 NoSQL，但是当您处理大量数据时，NoSQL 数据库是您的最佳选择。
+
+## 关系数据库的局限性
+
+1.在关系数据库中，我们需要首先定义数据的结构和模式，然后才能处理数据。
+
+2.关系数据库系统通过强制执行 [ACID 属性](https://beginnersbook.com/2015/04/acid-properties-in-dbms/)（原子性，一致性，隔离性和持久性）来提供数据的一致性和完整性。在某些情况下，这有点像银行系统一样有用。但是，在大多数其他情况下，这些属性是显着的性能开销，并且可能使您的数据库响应非常慢。
+
+3.大多数应用程序以 [JSON](https://beginnersbook.com/2015/04/json-tutorial/) 格式存储数据，而 RDBMS 不为您提供更好的方法来对此数据执行创建，插入，更新，删除等操作。另一方面，NoSQL 以 JSON 格式存储数据，这与当今世界的大多数应用程序兼容。
+
+## NoSQL 的优点是什么？
+
+使用 NoSQL 数据库（如 MongoDB 和 Cassandra）有几个优点。主要优点是高可扩展性和高可用性。
+
+**高可扩展性：** NoSQL 数据库（如 MongoDB）使用分片进行水平扩展。分片是对数据进行分区并将其放置在多台机器上，以保持数据的顺序。垂直扩展意味着向现有机器添加更多资源，而水平扩展意味着添加更多机器来处理数据。垂直缩放并不容易实现，另一方面，水平缩放很容易实现。水平扩展数据库示例：MongoDB，Cassandra 等。由于此功能，NoSQL 可以处理大量数据，因为数据增长 NoSQL 扩展自身以高效处理该数据。
+
+**高可用性：** MongoDB 中的自动复制功能使其具有高可用性，因为如果发生任何故障，数据会将自身复制到先前的一致状态。
+
+## NoSQL 数据库的类型
+
+以下是 NoSQL 数据库的类型以及属于该类别的数据库系统的名称。 MongoDB 属于基于 NoSQL 文档的数据库类别。
+**Key Value Store：** Memcached，Redis，Coherence
+**表格：** Hbase，Big Table，Accumulo
+**基于文档：** MongoDB，CouchDB ，Cloudant
+
+## RDBMS 与 NoSQL
+
+**[RDBMS：](https://beginnersbook.com/2015/04/rdbms-concepts/)** 它是一种结构化数据，提供更多功能但性能更低。
+**NoSQL：**结构化或半结构化数据，功能更少，性能更高。
+
+![RDBMS NoSQL Comparison](img/32452f3f64b9550b6b6f8c9323969c28.jpg)
+
+### 所以当我在 NoSQL 中说较少的功能时缺少什么：
+
+1\. NoSQL 中没有约束
+2\. NoSQL 不支持连接
+这些支持实际上阻碍了数据库的可伸缩性，因此在使用像 MongoDB 这样的 NoSQL 数据库时，可以在应用程序中实现这些功能水平。
+
+## 什么时候去 NoSQL
+
+当您想要在关系数据库上选择 NoSQL 时：
+
+1.  当您想要存储和检索大量数据时。
+2.  您存储的数据之间的关系并不重要
+3.  数据不是结构化的，而是随着时间而变化
+4.  数据库级别不需要约束和联接支持
+5.  数据不断增长，您需要定期扩展数据库以处理数据。
\ No newline at end of file

docs/mongodb/3.md

+# MongoDB 简介
+
+> 原文： [https://beginnersbook.com/2017/09/introduction-to-mongodb/](https://beginnersbook.com/2017/09/introduction-to-mongodb/)
+
+MongoDB 是一个面向文档的开源数据库，它以文档（键和值对）的形式存储数据。正如我们上一篇教程（ [NoSQL 介绍](https://beginnersbook.com/2017/09/introduction-to-nosql/)）中所讨论的那样，基于文档的数据库是 NoSQL 数据库的一种类型。
+
+**什么是文件？**
+如果您来自关系数据库背景，那么您可以将它们视为 RDBMS 中的行。关系数据库和 MongoDB 之间的映射将在下一个教程中介绍，所以如果你想知道 MongoDB 中的行，表，列的等价物，你一定要检查它：[将关系数据库映射到 MongoDB](https://beginnersbook.com/2017/09/mapping-relational-databases-to-mongodb/) 。
+
+![Document in MongoDB](img/41c34bfe53ecaa2e664b510cb6a305ce.jpg)
+
+```
+{
+   name: "Chaitanya",
+   age: 30,
+   website: "beginnersbook.com",
+   hobbies: ["Teaching", "Watching TV"]
+}
+```
+
+这是 [JSON](https://beginnersbook.com/2015/04/json-tutorial/) 之类的结构。数据以密钥和值对的形式存储的位置。
+
+## MongoDB 的历史
+
+MongoDB 是由 Eliot 和 Dwight（DoubleClick 的创始人）于 2007 年创建的，当时他们在使用关系数据库时遇到了可扩展性问题。开发 MongoDB 的组织最初称为 10gen。
+
+2009 年 2 月，他们改变了商业模式，并将 MongoDB 作为开源项目发布。该组织于 2013 年更名，现称为 MongoDB Inc.
+
+## MongoDB 的功能
+
+![MongoDB Features](img/e074ded6d5b1125ffcea7fed15210fc2.jpg)
+1\. MongoDB 提供**高性能**。与关系数据库相比，MongoDB 中的大多数操作都更快。
+2\. MongoDB 提供**自动复制**功能，允许您在发生故障时快速恢复数据。
+3.由于共享，MongoDB 中可以进行水平缩放。分片是对数据进行分区并将其放置在多台机器上，以保持数据的顺序。
+**水平缩放与垂直缩放：**
+垂直缩放意味着向现有机器添加更多资源，而水平缩放意味着添加更多机器来处理数据。垂直缩放并不容易实现，另一方面，水平缩放很容易实现。水平扩展数据库示例：MongoDB，Cassandra 等
+4\. **负载均衡**：水平扩展允许 MongoDB 平衡负载。
+5\. **高可用性**：自动复制提高了 MongoDB 数据库的可用性。
+6\. **索引：**索引是文档中的单个字段。索引用于快速定位数据，而无需搜索 MongoDB 数据库中的每个文档。这提高了在 MongoDB 数据库上执行的操作的性能。
\ No newline at end of file

docs/mongodb/4.md

+# 将关系数据库映射到 MongoDB
+
+> 原文： [https://beginnersbook.com/2017/09/mapping-relational-databases-to-mongodb/](https://beginnersbook.com/2017/09/mapping-relational-databases-to-mongodb/)
+
+如果您来自关系数据库背景，那么您可能很难将 RDBMS 术语与 MongoDB 相关联。在本指南中，我们将看到关系数据库和 MongoDB 之间的映射。
+
+## 将关系数据库映射到 MongoDB
+
+MongoDB 中的![RDBMS MongoDB Mapping](img/a3620ea12fb29b5883897e9191e35f36.jpg)
+**集合**等同于 RDBMS 中的表。
+**MongoDB 中的文档**等同于 RDBMS 中的行。
+**MongoDB 中的字段**等同于 RDBMS 中的列。
+
+> 字段（键和值对）存储在文档中，文档存储在集合中，集合存储在数据库中。
+
+**这是文档在 MongoDB 中的样子：**正如您所看到的，这与 RDBMS 中的行类似。唯一的区别是它们是 JSON 格式。
+![Document in MongoDB](img/41c34bfe53ecaa2e664b510cb6a305ce.jpg)
+
+## 表与集合
+
+在这里，我们将看到关系数据库中的表如何在 MongoDB 中查找。如您所见，列被表示为键值对（ [JSON](https://beginnersbook.com/2015/04/json-tutorial/) 格式），行表示为文档。 MongoDB 自动在每个文档中插入一个唯一的 _id（12 字节字段）字段，这个字段用作每个文档的主键。
+![Format mapping relational database_to_MongoDB](img/89a5286980f7a35c19c8fbb3fad64b62.jpg)
+关于 MongoDB 的另一个很酷的事情是它支持动态模式，这意味着集合中的一个文档可以有 4 个字段，而另一个文档只有 3 个字段。这在关系数据库中是不可能的。
\ No newline at end of file

docs/mongodb/5.md

+# 如何安装和配置 MongoDB for Windows
+
+> 原文： [https://beginnersbook.com/2017/09/how-to-install-and-configure-mongodb-for-windows/](https://beginnersbook.com/2017/09/how-to-install-and-configure-mongodb-for-windows/)
+
+这是**在 Windows** 上安装 MongoDB 的完整分步指南。
+
+## 在 Windows 上安装 MongoDB
+
+步骤 1：转到 [MongoDB 下载页面](https://www.mongodb.com/download-center#community)并单击下载，如屏幕截图所示。像这样的.msi 文件 **mongodb-win32-x86_64-2008plus-ssl-3.4.7-signed** 将在你的系统中下载。双击该文件以运行安装程序。
+![MongoDB Website Download Page](img/53dce56ebbd437bd38d0493245bd87f1.jpg)
+
+步骤 2：弹出 MongoDB 安装窗口时单击“下一步”。
+![MongoDB installation window](img/c50865495989cc2bb1ad5b271a6453f2.jpg)
+
+步骤 3：接受 MongoDB 用户协议，然后单击“下一步”。
+![Accept the MongoDB user Agreement](img/eb2e906400d5fe4d9f996a24e438c3a2.jpg)
+
+步骤 4：当安装程序要求您选择安装类型时，选择完成。
+![Choose Complete installation](img/0964c4a7af600f1ca7c53efc6616e512.jpg)
+
+步骤 5：单击 Install 开始安装。
+![Click Install](img/2612b861f7e6082dd0ea3ca04232d85b.jpg)
+
+第 6 步：就是这样。 MongoDB 安装完成后，单击 Finish。
+
+**我们没有在这里完成。** 在开始使用 MongoDB 之前，我们需要做几个步骤。
+
+## MongoDB 配置
+
+**步骤 1** ：找到已安装 MongoDB 的文件夹。如果您已按照上述步骤操作，则可以在此位置找到该文件夹​​：
+
+```
+C:\Program Files\MongoDB
+```
+
+在这里，您需要创建 MongoDB 配置所需的几个文件夹。
+1.在此处创建两个文件夹，将它们命名为**数据**和 **log** 。
+2.在**数据**中创建另一个文件夹，并将其命名为 **db** ，这是所有数据的存储位置。
+这就是关闭窗口。
+
+**步骤 2** ：打开命令提示符（右键单击并以管理员身份运行）。导航到 MongoDB 的 **bin** 文件夹，如屏幕截图所示。根据您安装 MongoDB 的位置，bin 文件夹的路径可能会有所不同。
+![command prompt mongodb configure](img/0340f456cc1f6e4b707502ed7428a06e.jpg)
+
+**步骤 3** ：配置数据＆amp;通过键入此命令将日志文件夹和 MongoDB 设置为服务。 **注意：**这是一行命令。
+
+```
+mongod --directoryperdb --dbpath "C:\Program Files\MongoDB\data\db" 
+--logpath "C:\Program Files\MongoDB\log\mongo.log" --logappend --rest --install
+```
+
+![MongoDB Configure data log file](img/5a7090cf71279fb8da4b69c69f841f8e.jpg)
+
+**第 4 步**：现在您可以通过输入以下命令启动 MongoDB 作为服务：
+
+```
+net start MongoDB
+```
+
+您应该看到一条消息“MongoDB 服务已成功启动”。
+![Start MongoDB as Service](img/38403ee09bc71f00f49ecb3628de16fd.jpg)
+
+这就是一切都完成了。现在我们应该在 MongoDB shell 中工作，我们可以通过在 bin 目录中键入此命令来运行它。
+
+```
+mongo
+```
+
+![Running the MongoDB shell](img/d758e8206d7bda1f9d3cf4a4371375af.jpg)
+
+在下一个教程中，我们将学习如何在 MongoDB shell 中工作。
+
+如果要退出 shell，可以通过键入 quit（）或使用 Ctrl-C 来执行此操作，然后可以使用以下命令停止 MongoDB 服务：
+
+```
+net stop MongoDB
+```
\ No newline at end of file

docs/mongodb/6.md

+# 在 MongoDB 中创建数据库
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-create-database/](https://beginnersbook.com/2017/09/mongodb-create-database/)
+
+在本教程中，我们将了解如何在 MongoDB 中创建和使用数据库。
+
+## MongoDB 创建数据库
+
+键入以下命令启动 MongoDB 服务：
+
+```
+net start MongoDB
+```
+
+你应该看到这样的消息：
+
+```
+The MongoDB service is starting..
+The MongoDB service was started successfully.
+```
+
+导航到 MongoDB 的 bin 目录，如下面的屏幕截图所示：
+![Starting MongoDB Service](img/2556208cf367af085fb92f0b52c1a875.jpg)
+
+现在我们应该在 MongoDB shell 中工作。要运行 MongoDB shell，请键入以下命令：
+
+```
+mongo
+```
+
+进入 MongoDB shell 后，通过键入以下命令在 MongoDB 中创建数据库：
+
+```
+use database_name
+```
+
+例如，我正在创建一个数据库“beginnersbook”，所以命令应该是：
+
+```
+use beginnersbook
+```
+
+**注意：**如果您提到的数据库名称已存在，则此命令将连接到数据库。但是，如果数据库不存在，那么这将创建具有给定名称的数据库并将您连接到它。
+![Creating Database in MongoDB](img/a7f47f673ea69ce91cc363513ab36ca1.jpg)
+
+在任何时候，如果要检查当前连接的数据库，只需键入命令 **db** 。此命令将显示您当前连接的数据库名称。当您使用多个数据库时，这是非常有用的命令，因此在创建集合或在数据库中插入文档之前，您可能希望确保您位于正确的数据库中。
+
+```
+> db
+beginnersbook
+```
+
+![Currently Connected Database using DB command](img/f1b05a5d5d36976425d66f3713f8fdbf.jpg)
+
+要列出所有数据库，请使用命令 **show dbs** 。此命令列出磁盘上的所有数据库及其大小。
+
+```
+> show dbs
+admin  0.000GB
+local  0.000GB
+```
+
+![show dbs command list all databases](img/79efbf9779eb82b452ecdbcc0afec447.jpg)
+
+> 如您所见，我们创建的数据库“beginnersbook”不存在于所有数据库的列表中。这是因为在将文档保存到数据库之前不会创建数据库
+
+现在我们正在创建一个集合**用户**并在其中插入文档。
+
+> 我们将在下一个教程中学习如何创建集合和文档。
+
+```
+> db.user.insert({name: "Chaitanya", age: 30})
+WriteResult({ "nInserted" : 1 })
+> show dbs
+admin          0.000GB
+beginnersbook  0.000GB
+local          0.000GB
+```
+
+![Database is created](img/1aa044e0a46e8ff5679da3c85bb9034f.jpg)
+您现在可以看到创建了数据库“beginnersbook”。
\ No newline at end of file

docs/mongodb/7.md

+# 删除 MongoDB 中的数据库
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-drop-database/](https://beginnersbook.com/2017/09/mongodb-drop-database/)
+
+在上一个教程中，我们学习了[如何在 MongoDB](https://beginnersbook.com/2017/09/mongodb-create-database/) 中创建数据库。在这里，我们将看到如何在 MongoDB 中删除数据库。我们使用 db.dropDatabase（）命令删除数据库。删除数据库时应该非常小心，因为这将删除该数据库中的所有数据，包括存储在数据库中的集合和文档。
+
+## MongoDB 删除数据库
+
+删除数据库的语法是：
+
+```
+db.dropDatabase()
+```
+
+我们在此命令中未指定任何数据库名称，因为此命令将删除当前选定的数据库。让我们看看在 MongoDB 中删除数据库的步骤。
+
+1.使用 **show dbs** 命令查看数据库列表。
+
+```
+> show dbs
+admin          0.000GB
+beginnersbook  0.000GB
+local          0.000GB
+```
+
+它显示了我创建的两个默认数据库和一个数据库“beginnersbook”。
+
+2.键入以下命令切换到需要删除的数据库。
+
+```
+use database_name
+```
+
+例如，我想删除数据库“beginnersbook”。
+
+```
+> use beginnersbook
+switched to db beginnersbook
+```
+
+> 注意：将上述命令中的数据库名称从`beginnersbook`更改为需要删除的数据库。
+
+3.现在，当前选择的数据库是`beginnersbook`，因此命令`db.dropDatabase()`将删除此数据库。
+
+```
+> db.dropDatabase()
+{ "dropped" : "beginnersbook", "ok" : 1 }
+
+```
+
+该命令成功执行并显示操作“已删除”和状态“ok”，这意味着数据库已被删除。
+![MongoDB drop database](img/a3940253e0a1ab2557a22062878d594c.jpg)
+
+4.验证是否已成功删除数据库。再次执行 show dbs 命令以查看删除后的数据库列表。
+![Verifying that database is dropped](img/4f8279b21fa0ed203219ec6689aab0e2.jpg)
+正如您所看到的那样，数据库“beginnersbook”不在列表中，这意味着它已成功删除。
\ No newline at end of file

docs/mongodb/8.md

+# 在 MongoDB 中创建集合
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-create-collection/](https://beginnersbook.com/2017/09/mongodb-create-collection/)
+
+我们知道 MongoDB 中的数据是以文档的形式存储的。这些文档存储在 Collection 和 Collection 中，存储在 Database 中。在上一篇教程中，我们学习了[如何在 MongoDB](https://beginnersbook.com/2017/09/mongodb-create-database/) 中创建数据库。在本指南中，我将向您展示在 MongoDB 中创建集合的两种方法。
+
+## 方法 1：动态创建 MongoDB 中的集合
+
+MongoDB 很酷的一点是，在将文档插入其中之前不需要创建集合。使用单个命令，您可以在集合中插入文档，MongoDB 即时创建该集合。
+语法： **db.collection_name.insert（{key：value，key：value ...}）**
+
+例如：
+我们在数据库`beginnersbookdb`中没有集合`beginnersbook`。此命令将动态创建名为“beginnersbook”的集合，并使用指定的键和值对在其中插入文档。
+
+```
+> use beginnersbookdb
+switched to db beginnersbookdb
+
+db.beginnersbook.insert({
+  name: "Chaitanya",
+  age: 30,
+  website: "beginnersbook.com"
+})
+```
+
+您将在命令提示符中看到此响应。
+
+```
+WriteResult({ "nInserted" : 1 })
+```
+
+![Creating collection on the fly MongoDB](img/4af1b49d42ba5be9f275db69de7368f0.jpg)
+
+要检查文档是否已成功插入，请键入以下命令。它显示给定集合中的所有文档。
+语法： **db.collection_name.find（）**
+
+```
+> db.beginnersbook.find()
+{ "_id" : ObjectId("59bcb8c2415346bdc68a0a66"), "name" : "Chaitanya",
+ "age" : 30, "website" : "beginnersbook.com" }
+```
+
+![verifying that collection is created successfully](img/5f6f93f1b24241ef9444c2762b29b7a3.jpg)
+
+要检查是否已成功创建集合，请使用以下命令。
+
+```
+show collections
+```
+
+此命令显示当前所选数据库中所有集合的列表。
+
+```
+> show collections
+beginnersbook
+```
+
+## 方法 2：在插入文档之前使用选项创建集合
+
+我们还可以在实际插入数据之前创建集合。此方法为您提供了在创建集合时可以设置的选项。
+
+句法：
+
+```
+db.createCollection(name, options)
+```
+
+**名称**是集合名称
+和**选项**是一个可选字段，我们可以用它来指定集合中的某些参数，如大小，文档的最大数量等。
+
+首先让我们看看这个命令如何用于创建没有任何参数的集合：
+
+```
+> db.createCollection("students")
+{ "ok" : 1 }
+```
+
+![Collection without options](img/e241f5e4015d0c33e5e3df72f8851796.jpg)
+
+让我们看看我们在创建集合时可以提供的选项：
+**上限**：类型：布尔值。
+此参数仅为 true 和 false。这指定了集合可以拥有的最大条目的上限。一旦集合达到该限制，它就会开始覆盖旧条目。
+这里需要注意的是，当您将 capped 选项设置为 true 时，您还必须指定 size 参数。
+
+**大小**：类型：数字。
+指定集合的​​最大大小（上限集合），以字节为单位。
+
+**max** ：类型：数字。
+指定集合可容纳的最大文档数。
+
+**autoIndexId** ：type：boolean
+此参数的默认值为 false。如果将其设置为 true，则会自动为每个文档创建索引字段 _id。我们将在 MongoDB 索引教程中了解索引。
+
+让我们看一个上限集合的例子：
+
+```
+db.createCollection("teachers", { capped : true, size : 9232768} )
+{ "ok" : 1 }
+
+```
+
+此命令将创建名为“teachers”的集合，其最大大小为 9232768 字节。一旦此集合达到该限制，它将开始覆盖旧条目。
+![Creating capped collection in MongoDB](img/66d9227f4239464042ea28e41271666a.jpg)
\ No newline at end of file

docs/mongodb/9.md

+# 删除 MongoDB 中的集合
+
+> 原文： [https://beginnersbook.com/2017/09/mongodb-drop-collection/](https://beginnersbook.com/2017/09/mongodb-drop-collection/)
+
+在上一个教程中，我们学习了[如何在 MongoDB](https://beginnersbook.com/2017/09/mongodb-create-collection/) 中创建集合。在本指南中，我们将了解如何在 MongoDB 中删除集合。
+
+要删除集合，首先连接到要删除集合的数据库，然后键入以下命令以删除集合：
+
+```
+db.collection_name.drop()
+```
+
+> 注意：删除集合后，所有文档以及与它们关联的索引也将被删除。为了保留索引，我们使用 remove（）函数，该函数仅删除集合中的文档，但不删除集合本身及其上创建的索引。我们将在后面的教程中学习索引和 remove（）函数。
+
+## MongoDB drop collection 示例
+
+例如，我想在我的数据库“beginnersbook.com”中删除集合名称“teachers”。为此，我将按给定的顺序编写以下命令。
+
+```
+> use beginnersbookdb
+switched to db beginnersbookdb
+
+> show collections
+beginnersbook
+students
+teachers
+
+> db.teachers.drop()
+true
+
+> show collections
+beginnersbook
+students
+```
+
+正如您所看到的，命令 db.teachers.drop（）返回 true，这意味着该集合已成功删除。我们在删除后使用 show collections 命令验证了同样的事情，如上所示。
+![MongoDB drop collection](img/793435b6345e7030794aaffda5e14891.jpg)
\ No newline at end of file

docs/mongodb/SUMMARY.md

++   [NoSQL 数据库简介](2.md)
++   [MongoDB 简介](3.md)
++   [将关系数据库映射到 MongoDB](4.md)
++   [如何安装和配置 MongoDB for Windows](5.md)
++   [在 MongoDB 中创建数据库](6.md)
++   [删除 MongoDB 中的数据库](7.md)
++   [在 MongoDB 中创建集合](8.md)
++   [删除 MongoDB 中的集合](9.md)
++   [MongoDB 插入文档](10.md)
++   [MongoDB 使用 find（）方法查询文档](11.md)
++   [MongoDB - 更新集合中的文档](12.md)
++   [MongoDB 从集合中删除文档](13.md)
++   [MongoDB 投影](14.md)
++   [MongoDB - limit（）和 skip（）方法](15.md)
++   [MongoDB sort（）方法](16.md)
++   [MongoDB 索引教程与示例](17.md)