db.collection.find() (mongosh method方法)

Embedded Field Specification嵌入式现场规范

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

• dot notation, for example "field.nestedfield": <value>点符号，例如"field.nestedfield": <value>
• nested form, for example 嵌套形式，例如{ field: { nestedfield: <value> } }

_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.请参见投影示例。

Session Idle Timeout会话空闲超时

MongoDB drivers and mongosh associate all operations with a server session, with the exception of unacknowledged write operations. MongoDB驱动程序和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. When the MongoDB server closes the session, it also kills any in-progress operations and open cursors associated with the session. 如果会话空闲时间超过30分钟，MongoDB服务器会将该会话标记为已过期，并可能随时将其关闭。当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 Mongo.startSession() and periodically refresh the session using the refreshSessions command. 对于可能空闲超过30分钟的操作，请使用Mongo.startSession()将该操作与显式会话相关联，并使用refreshSessions命令定期刷新会话。See Session Idle Timeout for more information.有关更多信息，请参阅会话空闲超时。

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集合中的文档，其中嵌入文档name中的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 Predicates.有关查询运算符的列表，请参阅查询谓词。

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):以下操作从birth在new Date('1940-01-01')和new Date('1960-01-01')之间的bios集合文档返回（不包括在内）：

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

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

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. The query does not match documents with the following name fields:name字段必须与嵌入的文档完全匹配。查询与具有以下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 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. See also $elemMatch.有关更多示例，请参阅$all。另请参见$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:有关查询数组的更多信息和示例，请参阅：

• Query an Array查询数组
• Query an Array of Embedded Documents查询嵌入式文档数组

For a list of array specific query operators, see 有关特定于数组的查询运算符的列表，请参阅Array Query Predicate Operators.数组查询谓词运算符。

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集合中的文档，其中奖励award（数组）至少包含一个元素，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:有关查询数组的更多信息和示例，请参阅：

• Query an Array查询数组
• Query an Array of Embedded Documents查询嵌入式文档数组

For a list of array specific query operators, see Array Query Predicate Operators.有关特定于数组的查询运算符的列表，请参阅数组查询谓词运算符。

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

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字段

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

You can also specify embedded fields using the nested form. For example:您还可以使用嵌套表单指定嵌入字段。例如：

db.bios.find(
   { },
   { _id: 0, name: { last: 1 }, contribs: { $slice: 2 } }
)

Use Aggregation Expression使用聚合表达式

db.collection.find() projection can accept aggregation expressions and syntax.投影可以接受聚合表达式和语法。

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 }

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

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.sort()对应于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”的升序排序决定。

Available mongosh Cursor Methods可用的mongosh游标方法

limit with options限制选项

The following query limits the number of documents in the result set with the limit options parameter:以下查询使用limit选项参数限制结果集中的文档数量：

db.users.find(
   { username : "rajiv"}, // query
   { age : 1 }, // projection
   { limit : 1 } // options
)

allowDiskUse with options选项中有allowDisk

The following query uses the options parameter to enable allowDiskUse:以下查询使用options参数启用allowDiskUse：

db.users.find(
   { username : "david" },
   { age : 1 },
   { allowDiskUse : true }
)

explain with options选项中有explain

The following query uses the options parameter to get the executionStats explain output:以下查询使用options参数获取executionStats解释输出：

var cursor = db.users.find(
   { username: "amanda" },
   { age : 1 },
   { explain : "executionStats" }
)
cursor.next()

Specify Multiple options in a query在查询中指定多个选项

The following query uses multiple options in a single query. 以下查询在单个查询中使用多个options。This query uses limit set to 2 to return only two documents, and showRecordId set to true to return the position of the document in the result set:此查询将limit设置为2仅返回两个文档，并将showRecordId设置为true的返回文档在结果集中的位置：

db.users.find(
   {},
   { username: 1, age: 1 },
   {
     limit: 2,
     showRecordId: true
   }
)