On this page本页内容
db.collection.find(query, projection)
This is a 这是一种mongosh method. mongosh方法。This is not the documentation for 这不是Node.js or other programming language specific driver methods.Node.js或其他特定于编程语言的驱动程序方法的文档。
In most cases, 在大多数情况下，mongosh methods work the same way as the legacy mongo shell methods. mongosh方法的工作方式与传统mongoShell方法相同。However, some legacy methods are unavailable in 不过，一些传统方法在mongosh.mongosh中不可用。
For the legacy 有关传统mongo shell documentation, refer to the documentation for the corresponding MongoDB Server release:mongo shell文档，请参阅相应MongoDB服务器版本的文档：
For MongoDB API drivers, refer to the language specific MongoDB driver documentation.有关MongoDB API驱动程序，请参阅特定语言的MongoDB驱动程序文档。
Selects documents in a collection or view and returns a cursor to the selected documents.选择集合或视图中的文档，并将游标返回到所选文档。
query | document | {}).{}）。
|
projection | document |
|
query criteria. query条件匹配的文档的游标。find() method "returns documents," the method is actually returning a cursor to the documents.find()方法“返回文档”时，该方法实际上是将游标返回到文档。 |
Starting in MongoDB 4.4, as part of making 从MongoDB 4.4开始，作为使find() and findAndModify() projection consistent with aggregation's $project stage,find()和findAndModify()投影与聚合的$project阶段一致的一部分，
find() and findAndModify() projection can accept aggregation expressions and syntax.find()和findAndModify()投影可以接受聚合表达式和语法。The projection parameter determines which fields are returned in the matching documents. projection参数决定在匹配文档中返回哪些字段。The projection parameter takes a document of the following form:projection参数采用以下形式的文档：
{ <field1>: <value>, <field2>: <value> ... }
<field>: <1 or true> | true.true。
|
<field>: <0 or false> | |
"<field>.$": <1 or true> | $ array projection operator, you can specify the projection to return the first element that match the query condition on the array field; e.g. "arrayField.$" : 1. (Not available for views.) $数组投影运算符，可以指定投影以返回与数组字段上的查询条件匹配的第一个元素；例如"arrayField.$" : 1。（不适用于视图。）true.true。 |
<field>: <array projection> | $elemMatch, $slice, specifies the array element(s) to include, thereby excluding those elements that do not meet the expressions. $elemMatch，$slice指定要包含的数组元素，从而排除那些不符合表达式的元素。 |
<field>: <$meta expression> | $meta operator expression, specifies the inclusion of available per-document metadata. $meta运算符表达式，指定包含可用的每个文档元数据。 |
<field>: <aggregation expression> |
|
For fields in an embedded documents, you can specify the field using either:对于嵌入文档中的字段，可以使用以下方法之一指定字段：
"field.nestedfield": <value>{ field: { nestedfield: <value> } }_idThe 默认情况下，_id field is included in the returned documents by default unless you explicitly specify _id: 0 in the projection to suppress the field._id字段包含在返回的文档中，除非您在投影中明确指定_id:0以抑制该字段。
A 投影不能同时包含include和exclude规范，projection cannot contain both include and exclude specifications, with the exception of the _id field:_id字段除外：
_id field is the only field that you can explicitly exclude._id字段是唯一可以显式排除的字段。_id field is the only field that you can explicitly include; however, the _id field is included by default._id字段是唯一可以显式包含的字段；然而，默认情况下包含_id字段。See Projection Examples.请参见投影示例。
Executing 在db.collection.find() in mongosh automatically iterates the cursor to display up to the first 20 documents. mongosh中执行db.collection.find()会自动迭代游标以显示前20个文档。Type 键入it to continue iteration.it以继续迭代。
To access the returned documents with a driver, use the appropriate cursor handling mechanism for the driver language.要使用驱动程序访问返回的文档，请使用驱动程序语言的适当游标处理机制。
To specify the read concern for 要指定db.collection.find(), use the cursor.readConcern() method.db.collection.find()的读取关注点，请使用cursor.readConcern()方法。
MongoDB treats some data types as equivalent for comparison purposes. 出于比较目的，MongoDB将某些数据类型视为等效数据类型。For instance, numeric types undergo conversion before comparison. 例如，数字类型在比较之前进行转换。For most data types, however, comparison operators only perform comparisons on documents where the BSON type of the target field matches the type of the query operand. 但是，对于大多数数据类型，比较运算符仅对目标字段的BSON类型与查询操作数类型匹配的文档执行比较。Consider the following collection:考虑以下集合：
{ "_id": "apples", "qty": 5 }
{ "_id": "bananas", "qty": 7 }
{ "_id": "oranges", "qty": { "in stock": 8, "ordered": 12 } }
{ "_id": "avocados", "qty": "fourteen" }
The following query uses 以下查询使用$gt to return documents where the value of qty is greater than 4.$gt返回qty值大于4的文档。
db.collection.find( { qty: { $gt: 4 } } )
The query returns the following documents:查询返回以下文档：
{ "_id": "apples", "qty": 5 }
{ "_id": "bananas", "qty": 7 }
The document with _id equal to "avocados" is not returned because its qty value is of type string while the $gt operand is of type integer._id等于"avocados"的文档不会返回，因为其qty值的类型为string，而$gt操作数的类型为整数。
The document with _id equal to "oranges" is not returned because its qty value is of type object._id等于_id的文档不会返回，因为其qty值属于object类型。
To enforce data types in a collection, use Schema Validation.要强制集合中的数据类型，请使用架构验证。
New in version 4.0.在版本4.0中新增。
For cursors created inside a session, you cannot call 对于在会话内创建的游标，不能在会话外调用getMore outside the session.getMore。
Similarly, for cursors created outside of a session, you cannot call 同样，对于在会话外部创建的游标，不能在会话内部调用getMore inside a session.getMore。
Starting in MongoDB 3.6, MongoDB drivers and 从MongoDB 3.6开始，MongoDB驱动程序和mongosh associate all operations with a server session, with the exception of unacknowledged write operations. mongosh将所有操作与服务器会话相关联，但未确认的写入操作除外。For operations not explicitly associated with a session (i.e. using 对于未显式与会话关联的操作（即使用Mongo.startSession()), MongoDB drivers and mongosh create an implicit session and associate it with the operation.Mongo.startSession()），MongoDB驱动程序和mongosh创建一个隐式会话并将其与操作关联。
If a session is idle for longer than 30 minutes, the MongoDB server marks that session as expired and may close it at any time. 如果会话空闲时间超过30分钟，MongoDB服务器会将该会话标记为已过期，并可随时关闭该会话。When the MongoDB server closes the session, it also kills any in-progress operations and open cursors associated with the session. 当MongoDB服务器关闭会话时，它还会终止与会话相关联的任何正在进行的操作和打开的游标。This includes cursors configured with 这包括配置了noCursorTimeout() or a maxTimeMS() greater than 30 minutes.noCursorTimeout()或大于30分钟的maxTimeMS()的游标。
For operations that may be idle for longer than 30 minutes, associate the operation with an explicit session using 对于空闲时间可能超过30分钟的操作，请使用Mongo.startSession() and periodically refresh the session using the refreshSessions command. Mongo.startSession()将该操作与显式会话相关联，并使用refreshSessions命令定期刷新会话。See Session Idle Timeout for more information.有关详细信息，请参阅会话空闲超时。
db.collection.find() can be used inside multi-document transactions.可以在多文档事务中使用。
getMore inside the transaction.getMore。getMore outside the transaction.getMore。In most cases, multi-document transaction incurs a greater performance cost over single document writes, and the availability of multi-document transactions should not be a replacement for effective schema design. 在大多数情况下，与单文档写入相比，多文档事务会带来更大的性能成本，并且多文档事务的可用性不应取代有效的模式设计。For many scenarios, the denormalized data model (embedded documents and arrays) will continue to be optimal for your data and use cases. 对于许多场景，非规范化的数据模型（嵌入式文档和数组）将继续是您的数据和用例的最佳选择。That is, for many scenarios, modeling your data appropriately will minimize the need for multi-document transactions.也就是说，对于许多场景，适当地建模数据将最小化多文档事务的需要。
For additional transactions usage considerations (such as runtime limit and oplog size limit), see also Production Considerations.有关其他事务使用注意事项（如运行时限制和oplog大小限制），请参阅生产注意事项。
Starting in MongoDB 4.2, if the client that issued the 从MongoDB 4.2开始，如果发出db.collection.find() disconnects before the operation completes, MongoDB marks the db.collection.find() for termination (i.e. killOp on the operation).db.collection.find()的客户端在操作完成之前断开连接，MongoDB会将db.collection.find()标记为终止（即操作上的killOp）。
The examples in this section use documents from the bios collection where the documents generally have the form:本节中的示例使用bios集合中的文档，其中的文档通常具有以下格式：
{
"_id" : <value>,
"name" : { "first" : <string>, "last" : <string> },
// embedded document
"birth" : <ISODate>,
"death" : <ISODate>,
"contribs" : [ <string>, ... ],
// Array of Strings
"awards" : [
{ "award" : <string>, year: <number>, by: <string> } // Array of embedded documents
...
]
}
To create and populate the 要创建和填充bios collection, see The bios Example Collection.bios集合，请参阅bios示例集合。
The 不带参数的find() method with no parameters returns all documents from a collection and returns all fields for the documents. find()方法返回集合中的所有文档，并返回文档的所有字段。For example, the following operation returns all documents in the bios collection:例如，以下操作返回bios集合中的所有文档：
db.bios.find()
The following operation returns documents in the bios collection where 以下操作返回_id equals 5:bios集合中的文档，其中_id等于5：
db.bios.find( { _id: 5 } )
The following operation returns documents in the bios collection where the field 以下操作返回last in the name embedded document equals "Hopper":bios集合中的文档，其中嵌入文档name中的字段last等于"Hopper"：
db.bios.find( { "name.last": "Hopper" } )
To access fields in an embedded document, use dot notation (要访问嵌入文档中的字段，请使用点符号（"<embedded document>.<field>")."<embedded document>.<field>"）。
To find documents that match a set of selection criteria, call 要查找与一组选择条件匹配的文档，请使用find() with the <criteria> parameter.<criteria>参数调用find()。
MongoDB provides various query operators to specify the criteria.MongoDB提供了各种查询运算符来指定条件。
The following operation uses the 以下操作使用$in operator to return documents in the bios collection where _id equals either 5 or ObjectId("507c35dd8fada716c89d0013"):$in运算符返回bios集合中的文档，其中_id等于5或ObjectId("507c35dd8fada716c89d0013")：
db.bios.find(
{ _id: { $in: [ 5, ObjectId("507c35dd8fada716c89d0013") ] } }
)
The following operation uses the 以下操作使用$gt operator returns all the documents from the bios collection where birth is greater than new Date('1950-01-01'):$gt运算符返回bios集合中birth大于new Date('1950-01-01')的所有文档：
db.bios.find( { birth: { $gt: new Date('1950-01-01') } } )
The following operation uses the 以下操作使用$regex operator to return documents in the bios collection where name.last field starts with the letter N (or is "LIKE N%")$regex运算符返回bios集合中的文档，其中name.last字段以字母N开头（或是"LIKE N%"）
db.bios.find(
{ "name.last": { $regex: /^N/ } }
)
For a list of the query operators, see Query Selectors.有关查询运算符的列表，请参阅查询选择器。
Combine comparison operators to specify ranges for a field. 组合比较运算符以指定字段的范围。The following operation returns from the bios collection documents where 以下操作从birth is between new Date('1940-01-01') and new Date('1960-01-01')(exclusive):bios集合文档返回，其中birth介于new Date('1940-01-01')和new Date('1960-01-01')之间（不包括两者）：
db.bios.find( { birth: { $gt: new Date('1940-01-01'), $lt: new Date('1960-01-01') } } )
For a list of the query operators, see Query Selectors.有关查询运算符的列表，请参阅查询选择器。
The following operation returns all the documents from the bios collection where 以下操作返回birth field is greater than new Date('1950-01-01') and death field does not exists:bios集合中birth大于new Date('1950-01-01')且death字段不存在的所有文档：
db.bios.find( {
birth: { $gt: new Date('1920-01-01') },
death: { $exists: false }
} )
For a list of the query operators, see Query Selectors.有关查询运算符的列表，请参阅查询选择器。
The following examples query the 以下示例查询name embedded field in the bios collection.bios集合中的name嵌入字段。
The following operation returns documents in the bios collection where the embedded document 以下操作返回name is exactly { first: "Yukihiro", last: "Matsumoto" }, including the order:bios集合中的文档，其中嵌入的文档name正好是{ first: "Yukihiro", last: "Matsumoto" }，包括顺序：
db.bios.find(
{ name: { first: "Yukihiro", last: "Matsumoto" } }
)
The name field must match the embedded document exactly. name字段必须与嵌入文档完全匹配。The query does not match documents with the following 查询与具有以下name fields:name字段的文档不匹配：
{
first: "Yukihiro",
aka: "Matz",
last: "Matsumoto"
}
{
last: "Matsumoto",
first: "Yukihiro"
}
The following operation returns documents in the bios collection where the embedded document 以下操作将返回name contains a field first with the value "Yukihiro" and a field last with the value "Matsumoto". bios集合中的文档，其中嵌入的文档name包含first字段，其值为"Yukihiro"，还有last字段，其值为"Matsumoto"。The query uses dot notation to access fields in an embedded document:查询使用点表示法访问嵌入文档中的字段：
db.bios.find(
{
"name.first": "Yukihiro",
"name.last": "Matsumoto"
}
)
The query matches the document where the 该查询匹配name field contains an embedded document with the field first with the value "Yukihiro" and a field last with the value "Matsumoto". name字段包含嵌入文档的文档，该文档的字段first的值为"Yukihiro"，字段last的值为"Matsumoto"。For instance, the query would match documents with 例如，查询将使用包含以下任一值的name fields that held either of the following values:name字段匹配文档：
{
first: "Yukihiro",
aka: "Matz",
last: "Matsumoto"
}
{
last: "Matsumoto",
first: "Yukihiro"
}
For more information and examples, see also Query on Embedded/Nested Documents.有关更多信息和示例，请参阅查询嵌入式/嵌套文档。
The following examples query the 以下示例查询contribs array in the bios collection.bios集合中的contribs数组。
The following operation returns documents in the bios collection where the array field 以下操作返回contribs contains the element "UNIX":bios集合中的文档，其中数组字段contribs包含元素"UNIX"：
db.bios.find( { contribs: "UNIX" } )
The following operation returns documents in the bios collection where the array field 以下操作返回contribs contains the element "ALGOL" or "Lisp":bios集合中的文档，其中数组字段contribs包含元素"ALGOL"或"Lisp"：
db.bios.find( { contribs: { $in: [ "ALGOL", "Lisp" ]} } )
The following operation use the 以下操作使用$all query operator to return documents in the bios collection where the array field contribs contains both the elements "ALGOL" and "Lisp":$all查询运算符返回bios集合中的文档，其中数组字段contribs包含元素"ALGOL"和"Lisp"：
db.bios.find( { contribs: { $all: [ "ALGOL", "Lisp" ] } } )
For more examples, see 有关更多示例，请参阅$all. $all。See also 另请参见$elemMatch.$elemMatch。
The following operation uses the 以下操作使用$size operator to return documents in the bios collection where the array size of contribs is 4:$size运算符返回bios集合中contribs数组大小为4的文档：
db.bios.find( { contribs: { $size: 4 } } )
For more information and examples of querying an array, see:有关查询数组的详细信息和示例，请参阅：
For a list of array specific query operators, see Array.有关特定于数组的查询运算符的列表，请参阅数组。
The following examples query the 以下示例查询awards array in the bios collection.bios集合中的awards数组。
The following operation returns documents in the bios collection where the 以下操作返回awards array contains an element with award field equals "Turing Award":bios集合中的文档，其中awards数组包含一个award字段等于"Turing Award"的元素：
db.bios.find(
{ "awards.award": "Turing Award" }
)
The following operation returns documents in the bios collection where the 以下操作返回awards array contains at least one element with both the award field equals "Turing Award" and the year field greater than 1980:bios集合中的文档，其中awards数组至少包含一个元素，award字段等于"Turing Award"，year字段大于1980：
db.bios.find(
{ awards: { $elemMatch: { award: "Turing Award", year: { $gt: 1980 } } } }
)
Use the 使用$elemMatch operator to specify multiple criteria on an array element.$elemMatch运算符在数组元素上指定多个条件。
For more information and examples of querying an array, see:有关查询数组的详细信息和示例，请参阅：
For a list of array specific query operators, see Array.有关特定于数组的查询运算符的列表，请参阅数组。
The projection parameter specifies which fields to return. projection参数指定要返回的字段。The parameter contains either include or exclude specifications, not both, unless the exclude is for the 除非排除用于_id field._id字段，否则该参数包含包括或排除规范文档，而不是两者。
Unless the 除非在投影文档中用_id field is explicitly excluded in the projection document _id: 0, the _id field is returned._id:0明确排除_id字段，否则将返回_id字段。
The following operation finds all documents in the bios collection and returns only the 以下操作查找name field, contribs field and _id field:bios集合中的所有文档，并仅返回name字段、contribs字段和_id字段：
db.bios.find( { }, { name: 1, contribs: 1 } )
Unless the 除非在投影文档中用_id field is explicitly excluded in the projection document _id: 0, the _id field is returned._id:0明确排除_id字段，否则将返回_id字段。
The following operation queries the bios collection and returns all fields exceptthe 以下操作查询first field in the name embedded document and the birth field:bios集合并返回除name嵌入文档中的第一个字段和birth之外的所有字段：
db.bios.find(
{ contribs: 'OOP' },
{ 'name.first': 0, birth: 0 }
)
_id Field_id字段Unless the 除非在投影文档中用_id field is explicitly excluded in the projection document _id: 0, the _id field is returned._id:0中明确排除_id字段，否则将返回_id字段。
The following operation finds documents in the bios collection and returns only the 以下操作在name field and the contribs field:bios集合中查找文档，并仅返回name字段和contribs字段：
db.bios.find(
{ },
{ name: 1, contribs: 1, _id: 0 }
)
The following operation queries the bios collection and returns the 以下操作查询last field in the name embedded document and the first two elements in the contribs array:bios集合，并返回name嵌入文档中的last字段和contribs数组中的前两个元素：
db.bios.find(
{ },
{ _id: 0, 'name.last': 1, contribs: { $slice: 2 } } )
Starting in MongoDB 4.4, you can also specify embedded fields using the nested form, e.g.从MongoDB 4.4开始，您还可以使用嵌套形式指定嵌入字段，例如。
db.bios.find(
{ },
{ _id: 0, name: { last: 1 }, contribs: { $slice: 2 } }
)
Starting in MongoDB 4.4, 从MongoDB 4.4开始，db.collection.find() projection can accept aggregation expressions and syntax.db.collection.find()投影可以接受聚合表达式和语法。
With the use of aggregation expressions and syntax, you can project new fields or project existing fields with new values. 使用聚合表达式和语法，可以投影新字段或使用新值投影现有字段。For example, the following operation uses aggregation expressions to override the value of the 例如，以下操作使用聚合表达式覆盖name and awards fields as well as to include new fields reportDate, reportBy, and reportNumber.name和awards字段的值，并包括新字段reportDate、reportBy和reportNumber。
db.bios.find(
{ },
{
_id: 0,
name: {
$concat: [
{ $ifNull: [ "$name.aka", "$name.first" ] },
" ",
"$name.last"
]
},
birth: 1,
contribs: 1,
awards: { $cond: { if: { $isArray: "$awards" }, then: { $size: "$awards" }, else: 0 } },
reportDate: { $dateToString: { date: new Date(), format: "%Y-%m-%d" } },
reportBy: "hellouser123",
reportNumber: { $literal: 1 }
}
)
To set the 要将reportRun field to the value 1 The operation returns the following documents:reportRun字段设置为值1，该操作将返回以下文档：
{ "birth" : ISODate("1924-12-03T05:00:00Z"), "contribs" : [ "Fortran", "ALGOL", "Backus-Naur Form", "FP" ], "name" : "John Backus", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1927-09-04T04:00:00Z"), "contribs" : [ "Lisp", "Artificial Intelligence", "ALGOL" ], "name" : "John McCarthy", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1906-12-09T05:00:00Z"), "contribs" : [ "UNIVAC", "compiler", "FLOW-MATIC", "COBOL" ], "name" : "Grace Hopper", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1926-08-27T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Kristen Nygaard", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1931-10-12T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Ole-Johan Dahl", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1956-01-31T05:00:00Z"), "contribs" : [ "Python" ], "name" : "Guido van Rossum", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1941-09-09T04:00:00Z"), "contribs" : [ "UNIX", "C" ], "name" : "Dennis Ritchie", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1965-04-14T04:00:00Z"), "contribs" : [ "Ruby" ], "name" : "Matz Matsumoto", "awards" : 1, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1955-05-19T04:00:00Z"), "contribs" : [ "Java" ], "name" : "James Gosling", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "contribs" : [ "Scala" ], "name" : "Martin Odersky", "awards" : 0, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
The find() method returns a cursor to the results.find()方法将游标返回到结果。
In 在mongosh, if the returned cursor is not assigned to a variable using the var keyword, the cursor is automatically iterated to access up to the first 20 documents that match the query. mongosh中，如果返回的游标没有使用var关键字分配给变量，游标将自动迭代以访问与查询匹配的前20个文档。You can set the 您可以设置DBQuery.shellBatchSize variable to change the number of automatically iterated documents.DBQuery.shellBatchSize变量以更改自动迭代文档的数量。
To manually iterate over the results, assign the returned cursor to a variable with the 要手动迭代结果，请将返回的游标分配给带有var keyword, as shown in the following sections.var关键字的变量，如以下部分所示。
The following example uses the variable 以下示例使用变量myCursor to iterate over the cursor and print the matching documents:myCursor遍历游标并打印匹配的文档：
var myCursor = db.bios.find( );
myCursor
next() Methodnext()方法The following example uses the cursor method 以下示例使用游标方法next() to access the documents:next()访问文档：
var myCursor = db.bios.find( ); var myDocument = myCursor.hasNext() ? myCursor.next() : null; if (myDocument) { var myName = myDocument.name; print (tojson(myName)); }
To print, you can also use the 要进行打印，您还可以使用printjson() method instead of print(tojson()):printjson()方法代替print(tojson())：
if (myDocument) { var myName = myDocument.name; printjson(myName); }
forEach() MethodforEach()方法The following example uses the cursor method 以下示例使用游标方法forEach() to iterate the cursor and access the documents:forEach()迭代游标并访问文档：
var myCursor = db.bios.find( );
myCursor.forEach(printjson);
mongosh and the drivers provide several cursor methods that call on the cursor returned by the find() method to modify its behavior.mongosh和驱动程序提供了几个游标方法，它们调用find()方法返回的游标来修改其行为。
The sort() method orders the documents in the result set. sort()方法对结果集中的文档进行排序。The following operation returns documents in the bios collection sorted in ascending order by the 以下操作返回按name field:name字段升序排序的bios集合中的文档：
db.bios.find().sort( { name: 1 } )
sort() corresponds to the 对应于SQL中的ORDER BY statement in SQL.ORDER BY语句。
The limit() method limits the number of documents in the result set. limit()方法限制结果集中的文档数量。The following operation returns at most 以下操作在5 documents in the bios collection:bios集合中最多返回5个文档：
db.bios.find().limit( 5 )
limit() corresponds to the 对应于SQL中的LIMIT statement in SQL.LIMIT语句。
The skip() method controls the starting point of the results set. skip()方法控制结果集的起点。The following operation skips the first 以下操作跳过5 documents in the bios collection and returns all remaining documents:bios集合中的前5个文档，并返回所有剩余文档：
db.bios.find().skip( 5 )
Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.排序规则允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音标记的规则。
The collation() method specifies the collation for the db.collection.find() operation.collation()方法指定db.collection.find()操作的排序规则。
db.bios.find( { "name.last": "hopper" } ).collation( { locale: "en_US", strength: 1 } )
The following statements chain cursor methods 以下语句链接游标方法limit() and sort():limit()和sort()：
db.bios.find().sort( { name: 1 } ).limit( 5 )
db.bios.find().limit( 5 ).sort( { name: 1 } )
The two statements are equivalent; i.e. the order in which you chain the 这两种说法是等价的；也就是说，链接limit() and the sort() methods is not significant. limit()和sort()方法的顺序并不重要。Both statements return the first five documents, as determined by the ascending sort order on 'name'.这两个语句都返回前五个文档，这由“name”的升序排序决定。
mongosh Cursor Methodsmongosh游标方法