db.collection.find()

On this page本页内容

Definition定义

db.collection.find(query, projection)

mongo Shell Method

This page documents the mongo shell method, and does not refer to the MongoDB Node.js driver (or any other driver) method. 本页记录了mongo shell方法，未提及MongoDB Node.js驱动程序（或任何其他驱动程序）方法。For corresponding MongoDB driver API, refer to your specific MongoDB driver documentation instead.有关相应的MongoDB驱动程序API，请参阅特定的MongoDB驱动程序文档。

Selects documents in a collection or view and returns a cursor to the selected documents.选择集合或视图中的文档，并将游标返回到所选文档。

Parameter参数Type类型Description描述
query document Optional.可选。Specifies selection filter using query operators. 使用查询运算符指定选择筛选器。To return all documents in a collection, omit this parameter or pass an empty document ({}).要返回集合中的所有文档，请省略此参数或传递一个空文档（{}）。
projection document

Optional. 可选择的Specifies the fields to return in the documents that match the query filter. 指定要在与查询筛选器匹配的文档中返回的字段。To return all fields in the matching documents, omit this parameter. 若要返回匹配文档中的所有字段，请忽略此参数。For details, see Projection.有关详细信息，请参阅投影。

Returns:A cursor to the documents that match the query criteria. 指向与query条件匹配的文档的游标。When the find() method “returns documents,” the method is actually returning a cursor to the documents.当find()方法“返回文档”时，该方法实际上是将游标返回到文档。

Behavior行为

Projection预测

Language Consistency语言一致性

Starting in MongoDB 4.4, as part of making find and findAndModify projection consistent with aggregation’s $project stage,从MongoDB 4.4开始，作为使find和findAndModify投影与聚合的$project阶段保持一致的一部分，

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> ... }
Projection预测Description描述
<field>: <1 or true> Specifies the inclusion of a field.指定字段的包含。
<field>: <0 or false> Specifies the exclusion of a field.指定字段的排除。
"<field>.$": <1 or true> With the use of the $ 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. 使用$数组投影运算符，可以指定投影以返回与数组字段上的查询条件匹配的第一个元素；亦即"arrayField.$" : 1。(Not available for views.)（不适用于视图。）
<field>: <array projection> Using the array projection operators $elemMatch, $slice, specifies the array element(s) to include, thereby excluding those elements that do not meet the expressions. 使用数组投影运算符$elemMatch、$slice，指定要包含的数组元素，从而排除那些不符合表达式的元素。(Not available for views.)（不适用于视图。）
<field>: <$meta expression> Using the $meta operator expression, specifies the inclusion of available per-document metadata. 使用$meta运算符表达式，指定包含每个文档可用的元数据。(Not available for views.)（不适用于视图。）
<field>: <aggregation expression>

Specifies the value of the projected field.指定投影字段的值。

Starting in MongoDB 4.4, with the use of aggregation expressions and syntax, including the use of literals and aggregation variables, you can project new fields or project existing fields with new values. 从MongoDB 4.4开始，通过使用聚合表达式和语法，包括使用文字和聚合变量，可以投影新字段或使用新值投影现有字段。For example,例如

  • If you specify a non-numeric, non-boolean literal (such as a literal string or an array or an operator expression) for the projection value, the field is projected with the new value; e.g.:如果为投影值指定非数字、非布尔文字（例如文字字符串、数组或运算符表达式），则会使用新值投影字段；例如。：
    • { field: [ 1, 2, 3, "$someExistingField" ] }
    • { field: "New String Value" }
    • { field: { status: "Active", total: { $sum: "$existingArray" } } }
  • To project a literal value for a field, use the $literal aggregation expression; e.g.:要为字段投影文字值，请使用$literal聚合表达式；例如。：
    • { field: { $literal: 5 } }
    • { field: { $literal: true } }
    • { field: { $literal: { fieldWithValue0: 0, fieldWithValue1: 1 } } }

In versions 4.2 and earlier, any specification value (with the exception of the previously unsupported document value) is treated as either true or false to indicate the inclusion or exclusion of the field.在版本4.2和更早版本中，任何规范值（以前不支持的文档值除外）都被视为true或false，以指示包含或排除该字段。

New in version 4.4.版本4.4中的新功能。

Embedded Field Specification嵌入式字段规范

For fields in an embedded documents, you can specify the field using either:对于嵌入文档中的字段，可以使用以下任一方法指定字段：

  • dot notation; e.g. 点符号；如。"field.nestedfield": <value>
  • nested form; e.g. 嵌套形式；如。{ field: { nestedfield: <value> } } (Starting in MongoDB 4.4从MongoDB 4.4开始)

_id Field Projection场投影

The _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以抑制该字段。

Inclusion or Exclusion包含还是排除

A projection cannot contain both include and exclude specifications, with the exception of the _id field:projection不能同时包含包含和排除规范，但_id字段除外：

  • In projections that explicitly include fields, the _id field is the only field that you can explicitly exclude.在显式包含字段的投影中，_id字段是唯一可以显式排除的字段。
  • In projections that explicitly excludes fields, the _id field is the only field that you can explicitly include; however, the _id field is included by default.在显式排除字段的投影中，_id字段是唯一可以显式包括的字段；但是，默认情况下会包含_id字段。

See Projection Examples.请参阅投影示例。

Cursor Handling游标处理

Executing db.collection.find() in the mongo shell automatically iterates the cursor to display up to the first 20 documents. 在mongo shell中执行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.要使用驱动程序访问返回的文档，请使用驱动程序语言的适当游标处理机制。

See also参阅

Read Concern阅读关注

To specify the read concern for db.collection.find(), use the cursor.readConcern() method.指定db.collection.find()的读取关注点，使用cursor.readConcern()方法。

Type Bracketing类型括号

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操作数的类型为integer。

The document with _id equal to "oranges" is not returned because its qty value is of type object.不返回_id等于"oranges"的文档，因为其qty值为object类型。

Note

To enforce data types in a collection, use Schema Validation.要在集合中强制数据类型，请使用架构验证。

Sessions会议

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。

Session Idle Timeout会话空闲超时

Starting in MongoDB 3.6, MongoDB drivers and the mongo shell associate all operations with a server session, with the exception of unacknowledged write operations. 从MongoDB 3.6开始，MongoDB驱动程序和mongo shell将所有操作与服务器会话相关联，但未确认的写入操作除外。For operations not explicitly associated with a session (i.e. using Mongo.startSession()), MongoDB drivers and the mongo shell creates an implicit session and associates it with the operation.对于与会话没有显式关联的操作（即使用Mongo.startSession()），MongoDB驱动程序和Mongo shell会创建一个隐式会话，并将其与操作关联。

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或maxTimeMS（大于30分钟）的游标。

For operations that may be idle for longer than 30 minutes, associate the operation with an explicit session using Session.startSession() and periodically refresh the session using the refreshSessions command. 对于空闲时间可能超过30分钟的操作，请使用Session.startSession()将该操作与显式会话关联，并使用refreshSessions命令定期刷新会话。See Session Idle Timeout for more information.有关更多信息，请参阅会话空闲超时。

Transactions事务

db.collection.find() can be used inside multi-document transactions.可以在多文档事务中使用。

  • For cursors created outside of a transaction, you cannot call getMore inside the transaction.对于在事务外部创建的游标，不能在事务内部调用getMore。
  • For cursors created in a transaction, you cannot call getMore outside the transaction.对于在事务中创建的游标，不能在事务外部调用getMore。

Important

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大小限制），请参阅生产注意事项。

Client Disconnection客户端断开

Starting in MongoDB 4.2, if the client that issued the db.collection.find() disconnects before the operation completes, MongoDB marks the db.collection.find() for termination (i.e. killOp on the operation).从MongoDB 4.2开始，如果发布db.collection.find()的客户端在操作完成之前断开连接，MongoDB会标记db.collection.find()终止（即操作上killOp）。

Examples示例

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示例集合。

Find All Documents in a Collection查找集合中的所有文档

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()

Find Documents that Match Query Criteria查找符合查询条件的文档

Query for Equality对平等的质疑

  • 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集合中的文档，其中嵌入文档名称中的last字段等于"Hopper"：

    db.bios.find( { "name.last": "Hopper" } )

    Note

    To access fields in an embedded document, use dot notation ("<embedded document>.<field>").要访问嵌入文档中的字段，请使用点符号（"<embedded document>.<field>"）。

Query Using Operators使用运算符进行查询

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.有关查询运算符的列表，请参阅查询选择器。

Query for Ranges查询范围

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集合文档返回，其中出生日期介于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.有关查询运算符的列表，请参阅查询选择器。

Query for Multiple Conditions查询多个条件

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.有关查询运算符的列表，请参阅查询选择器。

Query Embedded Documents查询嵌入文档

The following examples query the name embedded field in the bios collection.以下示例查询bios集合中的name嵌入字段。

Query Exact Matches on Embedded Documents查询嵌入文档上的精确匹配

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"
}

Query Fields of an Embedded Document嵌入文档的查询字段

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.有关更多信息和示例，请参阅查询嵌入/嵌套文档。

Query Arrays查询数组

Query for an Array Element查询数组元素

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.有关特定于数组的查询运算符的列表，请参阅数组。

Query an Array of Documents查询一系列文档

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.有关特定于数组的查询运算符的列表，请参阅数组。

Projections投影

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.参数包含include或exclude规范，而不是两者，除非exclude是针对_id字段的。

Note

Unless the _id field is explicitly excluded in the projection document _id: 0, the _id field is returned.除非投影文档_id:0中明确排除了_id字段，否则将返回_id字段。

Specify the Fields to Return指定要返回的字段

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 } )

Note

Unless the _id field is explicitly excluded in the projection document _id: 0, the _id field is returned.除非投影文档_id:0中明确排除了_id字段，否则将返回_id字段。

Explicitly Excluded Fields明确排除的字段

The following operation queries the bios collection and returns all fields except the first field in the name embedded document and the birth field:以下操作查询bios集合并返回所有字段，但name嵌入文档中的first字段和birth字段除外：

db.bios.find(
   { contribs: 'OOP' },
   { 'name.first': 0, birth: 0 }
)

Explicitly Exclude the _id Field明确排除_id字段

Note

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 }
)

On Arrays and Embedded Documents关于数组和嵌入式文档

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 } }
)

Use Aggregation Expression使用聚合表达式

Starting in MongoDB 4.4, db.collection.find() projection can accept aggregation expressions and syntax.从MongoDB 4.4开始，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 }

See also参阅

Project Fields to Return from Query要从查询返回的项目字段

Iterate the Returned Cursor迭代返回的游标

The find() method returns a cursor to the results.find()方法返回指向结果的游标。

In the mongo shell, 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. 在mongo shell中，如果返回的游标没有使用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关键字的变量，如以下部分所示。

With Variable Name使用变量名

The following example uses the variable myCursor to iterate over the cursor and print the matching documents:以下示例使用变量myCursor在游标上迭代并打印匹配的文档：

var myCursor = db.bios.find( );

myCursor

With next() Method使用next()方法

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);
}

With forEach() Method使用forEach()方法

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);

Modify the Cursor Behavior修改游标行为

The mongo shell and the drivers provide several cursor methods that call on the cursor returned by the find() method to modify its behavior.mongo shell和驱动程序提供了几个游标方法，这些方法调用find()方法返回的cursor来修改其行为。

Order Documents in the Result Set在结果集中对文档进行排序

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:以下操作返回bios集合中按name字段升序排序的文档：

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

sort() corresponds to the ORDER BY statement in SQL.对应于SQL中的ORDER BY语句。

Limit the Number of Documents to Return限制要返回的文档数量

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 LIMIT statement in SQL.对应于SQL中的limit语句。

Set the Starting Point of the Result Set设置结果集的起点

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 )

Specify Collation指定排序规则

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 } )

Combine Cursor Methods组合游标方法

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”的升序顺序决定。