db.collection.find()

打开交互式教程

嵌入式字段规范

对于嵌入文档中的字段，您可以使用以下任一方式指定字段：

• 点符号，例如 "field.nestedfield": <value>

• 嵌套表单，例如 { field: { nestedfield: <value> } }

_id 字段投影

默认情况下，返回的文档中包含 _id 字段，除非您在投影中显式指定 _id: 0 来隐藏该字段。

包括或排除

projection 不能同时包含包含和排除规范，但 _id 字段除外：

• 在显式包含字段的投影中，_id 字段是您可以显式排除的唯一字段。

• 在明确排除字段的投影中，_id字段是您可以明确包含的唯一字段；但是，默认情况下包含_id字段。

请参阅投影示例。

会话空闲超时

MongoDB 驱动程序和 mongosh 将所有操作与服务器会话相关联，未确认的写入操作除外。对于未与会话显式关联的操作（即使用 Mongo.startSession()），MongoDB 驱动程序和 mongosh 会创建隐式会话并将其与该操作关联。

如果会话空闲时间超过 30 分钟，MongoDB Server 会将该会话标记为已过期，并可能随时将其关闭。当 MongoDB Server 关闭会话时，它还会终止任何正在进行的操作并打开与会话关联的游标。这包括使用超过 30 分钟的 noCursorTimeout() 或 maxTimeMS() 配置的游标。

对于空闲时间可能超过 30 分钟的操作，请使用 Mongo.startSession() 将该操作与显式会话关联起来，并使用 refreshSessions 命令定期刷新会话。有关更多信息，请参阅会话空闲超时。

相等查询

• 以下操作将返回 BIOS 集合中的文档，其中，_id 等于 5：

  db.bios.find( { _id: 5 } )

• 以下操作返回 bios 集合中的文档，其中 name 嵌入式文档中的字段 last 等于 "Hopper"：

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

  注意

  要访问嵌入式文档中的字段，请使用点符号 ("<embedded document>.<field>")。

使用操作符查询

要查找符合一组选择条件的文档，请使用 <criteria> 参数调用 find()。

MongoDB 提供各种查询运算符来指定标准。

• 以下操作使用 $in 操作符返回 bios 集合中的文档，其中 _id 等于 5 或 ObjectId("507c35dd8fada716c89d0013")：

  db.bios.find(
     { _id: { $in: [ 5, ObjectId("507c35dd8fada716c89d0013") ] } }
  )

• 以下操作使用 $gt 运算符返回 bios 集合中 birth 晚于 new Date('1950-01-01') 的所有文档：

  db.bios.find( { birth: { $gt: new Date('1950-01-01') } } )

• 以下操作使用 $regex 操作符返回 BIOS 集合中的文档，其中，name.last 字段以字母 N 开头（或为 "LIKE N%"）

  db.bios.find(
     { "name.last": { $regex: /^N/ } }
  )

有关查询运算符的列表，请参阅查询选择器。

对范围进行查询

结合比较操作符来指定字段的范围。以下操作从 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') } } )

有关查询运算符的列表，请参阅查询选择器。

多重条件查询

以下操作返回 BIOS 集合中的所有文档，其中 birth 字段为 greater than new Date('1950-01-01')，death 字段不存在：

db.bios.find( {
   birth: { $gt: new Date('1920-01-01') },
   death: { $exists: false }
} )

有关查询运算符的列表，请参阅查询选择器。

查询嵌入文档的精确匹配项

以下操作返回 BIOS 集合 中的文档，其中嵌入式文档 name 恰好 是 { first: "Yukihiro", last: "Matsumoto" }，包括顺序：

db.bios.find(
    { name: { first: "Yukihiro", last: "Matsumoto" } }
)

name 字段必须与嵌入式文档完全匹配。该查询与具有以下 name 字段的文档不匹配：

{
   first: "Yukihiro",
   aka: "Matz",
   last: "Matsumoto"
}
{
   last: "Matsumoto",
   first: "Yukihiro"
}

嵌入式文档的查询字段

以下操作返回 BIOS 集合中的文档，其中嵌入文档 name 包含值为 "Yukihiro" 的字段 first 和值为 last 的字段 "Matsumoto"。查询使用点符号访问嵌入文档中的字段：

db.bios.find(
   {
     "name.first": "Yukihiro",
     "name.last": "Matsumoto"
   }
)

该查询与文档相匹配，其中，name 字段包含嵌入式文档，字段 first 的值为 "Yukihiro"，字段 last 的值为 "Matsumoto"。例如，查询将匹配包含的 name 字段为以下任一值的文档：

{
  first: "Yukihiro",
  aka: "Matz",
  last: "Matsumoto"
}
{
  last: "Matsumoto",
  first: "Yukihiro"
}

有关更多信息和示例，另请参阅针对嵌入式/嵌套文档的查询。

查询数组元素

以下示例查询 bios 集合中的 contribs 数组。

• 以下操作返回 bios 集合中的文档，其中，数组字段 contribs 包含元素 "UNIX"：

  db.bios.find( { contribs: "UNIX" } )

• 以下操作返回 bios 集合中的文档，其中，数组字段 contribs 包含元素 "ALGOL" 或 "Lisp"：

  db.bios.find( { contribs: { $in: [ "ALGOL", "Lisp" ]} } )

• 以下操作使用 $all 查询操作符返回 BIOS 集合中的文档，其中数组字段 contribs 同时包含元素 "ALGOL" 和 "Lisp"：

  db.bios.find( { contribs: { $all: [ "ALGOL", "Lisp" ] } } )

  请参阅$all，查看更多示例。另请参阅 $elemMatch。

• 以下操作使用 $size 操作符返回 BIOS 集合中的文档，其中 contribs 的数组大小为 4：

  db.bios.find( { contribs: { $size: 4 } } )

有关查询数组的更多信息和示例，请参阅：

• 查询数组

• 查询嵌入式文档数组

有关特定于数组的查询运算符列表，请参阅数组。

查询文档数组

以下示例查询 bios 集合中的 awards 数组。

• 以下操作返回 BIOS 集合中的文档，其中awards数组包含一个award字段等于"Turing Award"的元素：

  db.bios.find(
     { "awards.award": "Turing Award" }
  )

• 以下操作返回 bios 集合中的文档，其中 awards 数组至少包含一个元素，award 字段等于 "Turing Award"，且 year字段大于 1980：

  db.bios.find(
     { awards: { $elemMatch: { award: "Turing Award", year: { $gt: 1980 } } } }
  )

  使用 $elemMatch 操作符可在一个数组元素上指定多个条件。

有关查询数组的更多信息和示例，请参阅：

• 查询数组

• 查询嵌入式文档数组

有关特定于数组的查询运算符列表，请参阅数组。

指定待返回的字段

以下操作会查找 bios 集合中的所有文档，并仅返回 name 字段、contribs 字段和 _id 字段：

db.bios.find( { }, { name: 1, contribs: 1 } )

显式排除的字段

以下操作查询 BIOS 集合并返回除name嵌入式文档中的first字段和birth字段之外的所有字段：

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

显式排除 字段<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \"_id role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">

以下操作会在 bios 集合中查找文档，并仅返回 name 字段和 contribs 字段：

db.bios.find(
   { },
   { name: 1, contribs: 1, _id: 0 }
)

关于数组和嵌入式文档

以下操作查询 BIOS 集合并返回 name 嵌入文档中的 last 字段和 contribs 数组中的前两个元素：

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

您还可以使用嵌套形式指定嵌入式字段。例如：

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

使用聚合表达式

db.collection.find() 投影可以接受 聚合表达式和语法。

使用聚合表达式和事务语法，您可以投影新字段或使用新值投影现有字段。例如，以下操作使用聚合表达式来重写 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 }
   }
)

要将 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 }

使用变量名称

以下示例使用变量 myCursor 迭代游标并打印匹配的文档：

var myCursor = db.bios.find( );
myCursor

使用 方法<a class=\" \" href=\" \"next() title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">

以下示例使用游标方法 next() 访问文档：

var myCursor = db.bios.find( );
var myDocument = myCursor.hasNext() ? myCursor.next() : null;
if (myDocument) {
    var myName = myDocument.name;
    print (tojson(myName));
}

要打印，您还可以使用 printjson() 方法而不是 print(tojson())：

if (myDocument) {
   var myName = myDocument.name;
   printjson(myName);
}

使用 方法<a class=\" \" href=\" \"forEach() title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">

以下示例使用游标方法 forEach() 遍历游标并访问文档：

var myCursor = db.bios.find( );
myCursor.forEach(printjson);

为结果集中的文档排序

sort() 方法对结果集中的文档排序。以下操作返回 bios 集合中按 name 字段升序排序的文档：

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

sort() 相当于 SQL 中的 ORDER BY 语句。

限制要返回的文档数量

limit() 方法限制结果集中的文档数量。以下操作最多返回 biaos 集合中的 5 个文档：

db.bios.find().limit( 5 )

limit() 相当于 SQL 中的 LIMIT 语句。

设置结果集的启动点

skip() 方法控制结果集的起点。以下操作会跳过 bios 集合中的前 5 份文档并返回所有剩余文档：

db.bios.find().skip( 5 )

指定排序规则。

排序规则允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音符号规则。

collation() 方法指定了 db.collection.find() 操作的排序规则。

db.bios.find( { "name.last": "hopper" } ).collation( { locale: "en_US", strength: 1 } )

组合游标方法

以下声明链接游标方法limit()和sort()：

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

这两个语句是等效的；也就是说，链接 limit() 和 sort() 方法的顺序并不重要。 两个语句均返回前五个文档，由“名称”的升序排序决定。

可用的mongosh 游标方法

限制和选项

以下查询使用 limit 选项参数限制结果集中的文档数：

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

allowDiskUse 及其选项

以下查询使用 options 参数启用 allowDiskUse：

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

解释和选项

以下查询使用 options 参数获取 executionStats 解释输出：

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

在查询中指定多个选项

以下查询在单个查询中使用多个 options。此查询使用设置为 2 的 limit 来仅返回两个文档，并使用设置为 true 的 showRecordId 来返回文档在结果集中的位置：

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