查询文档
您可以使用以下方法查询MongoDB中的文档：
您的编程语言的驱动程序。
MongoDB Atlas 用户界面。要了解更多信息，请参阅使用 MongoDB Atlas 查询文档。
➤ 使用右上角的 Select your language（选择语言）下拉菜单，设置以下示例的语言或选择 MongoDB Compass。
本页面提供的示例展示使用 db.collection.find() 方法在 mongosh 中执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面中的示例展示了使用 MongoDB Compass 执行的查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页提供了使用 MongoDB C# 驱动程序 中的 MongoCollection.Find() 方法进行查询操作的示例。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示使用 Collection.Find 函数在 MongoDB Go Driver 中执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示使用 com.mongodb.reactivestreams.client.MongoCollection.find 方法在 MongoDB Java Reactive Streams 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
此页面中的示例展示了使用 MongoDB Java 同步驱动程序中的 com.mongodb.client.MongoCollection.find 方法执行的查询操作。
提示
此驱动程序提供了 com.mongodb.client.model.Filters 辅助方法，以便于创建过滤器文档。此页面中的示例使用这些方法创建过滤器文档。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示了使用 motor.motor_asyncio.AsyncIOMotorCollection.find 方法在 Motor 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示使用 Collection.find()方法在 MongoDB Node.js 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示使用 MongoDB::Collection::find() 方法在 MongoDB Perl 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示在 MongoDB PHP Library 中使用 MongoDB\\Collection::find() 方法执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页提供了在 PyMongo Python 驱动程序中使用 pymongo.collection.Collection.find 方法进行查询操作的示例。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示在 MongoDB Ruby 驱动程序中使用 Mongo::Collection#find() 方法执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
本页面提供的示例展示使用 collection.find() 方法在 MongoDB Scala 驱动程序中执行查询操作。
此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：
db.inventory.insertMany([ { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }, { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }, { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }, { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }, { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" } ]);
[ { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" }, { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" }, { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" }, { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" }, { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" } ]
有关在 MongoDB Compass 中插入文档的说明，请参阅插入文档。
var documents = new BsonDocument[] { new BsonDocument { { "item", "journal" }, { "qty", 25 }, { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm"} } }, { "status", "A" } }, new BsonDocument { { "item", "notebook" }, { "qty", 50 }, { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in"} } }, { "status", "A" } }, new BsonDocument { { "item", "paper" }, { "qty", 100 }, { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in"} } }, { "status", "D" } }, new BsonDocument { { "item", "planner" }, { "qty", 75 }, { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm"} } }, { "status", "D" } }, new BsonDocument { { "item", "postcard" }, { "qty", 45 }, { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm"} } }, { "status", "A" } }, }; collection.InsertMany(documents);
docs := []interface{}{ bson.D{ {"item", "journal"}, {"qty", 25}, {"size", bson.D{ {"h", 14}, {"w", 21}, {"uom", "cm"}, }}, {"status", "A"}, }, bson.D{ {"item", "notebook"}, {"qty", 50}, {"size", bson.D{ {"h", 8.5}, {"w", 11}, {"uom", "in"}, }}, {"status", "A"}, }, bson.D{ {"item", "paper"}, {"qty", 100}, {"size", bson.D{ {"h", 8.5}, {"w", 11}, {"uom", "in"}, }}, {"status", "D"}, }, bson.D{ {"item", "planner"}, {"qty", 75}, {"size", bson.D{ {"h", 22.85}, {"w", 30}, {"uom", "cm"}, }}, {"status", "D"}, }, bson.D{ {"item", "postcard"}, {"qty", 45}, {"size", bson.D{ {"h", 10}, {"w", 15.25}, {"uom", "cm"}, }}, {"status", "A"}, }, } result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList( Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"), Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"), Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"), Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }") ));
collection.insertMany(asList( Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"), Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"), Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"), Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"), Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }") ));
await db.inventory.insert_many( [ { "item": "journal", "qty": 25, "size": {"h": 14, "w": 21, "uom": "cm"}, "status": "A", }, { "item": "notebook", "qty": 50, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "A", }, { "item": "paper", "qty": 100, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "D", }, { "item": "planner", "qty": 75, "size": {"h": 22.85, "w": 30, "uom": "cm"}, "status": "D", }, { "item": "postcard", "qty": 45, "size": {"h": 10, "w": 15.25, "uom": "cm"}, "status": "A", }, ] )
await db.collection('inventory').insertMany([ { item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }, { item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }, { item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }, { item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }, { item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' } ]);
$db->coll("inventory")->insert_many( [ { item => "journal", qty => 25, size => { h => 14, w => 21, uom => "cm" }, status => "A" }, { item => "notebook", qty => 50, size => { h => 8.5, w => 11, uom => "in" }, status => "A" }, { item => "paper", qty => 100, size => { h => 8.5, w => 11, uom => "in" }, status => "D" }, { item => "planner", qty => 75, size => { h => 22.85, w => 30, uom => "cm" }, status => "D" }, { item => "postcard", qty => 45, size => { h => 10, w => 15.25, uom => "cm" }, status => "A" } ] );
$insertManyResult = $db->inventory->insertMany([ [ 'item' => 'journal', 'qty' => 25, 'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'], 'status' => 'A', ], [ 'item' => 'notebook', 'qty' => 50, 'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'], 'status' => 'A', ], [ 'item' => 'paper', 'qty' => 100, 'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'], 'status' => 'D', ], [ 'item' => 'planner', 'qty' => 75, 'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'], 'status' => 'D', ], [ 'item' => 'postcard', 'qty' => 45, 'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'], 'status' => 'A', ], ]);
db.inventory.insert_many( [ { "item": "journal", "qty": 25, "size": {"h": 14, "w": 21, "uom": "cm"}, "status": "A", }, { "item": "notebook", "qty": 50, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "A", }, { "item": "paper", "qty": 100, "size": {"h": 8.5, "w": 11, "uom": "in"}, "status": "D", }, { "item": "planner", "qty": 75, "size": {"h": 22.85, "w": 30, "uom": "cm"}, "status": "D", }, { "item": "postcard", "qty": 45, "size": {"h": 10, "w": 15.25, "uom": "cm"}, "status": "A", }, ] )
client[:inventory].insert_many([{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }, { item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }, { item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }, { item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }, { item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' } ])
collection.insertMany(Seq( Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""), Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""), Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""), Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""), Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""") )).execute()
选择集合中的所有文档
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
要选择集合中的所有文档，请将空的文档作为查询筛选器参数传递给 find 方法。查询筛选器参数决定选择条件：
db.inventory.find( {} )
var filter = Builders<BsonDocument>.Filter.Empty; var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{}, )
FindPublisher<Document> findPublisher = collection.find(new Document());
FindIterable<Document> findIterable = collection.find(new Document());
cursor = db.inventory.find({})
const cursor = db.collection('inventory').find({});
$cursor = $db->coll("inventory")->find( {} );
$cursor = $db->inventory->find([]);
cursor = db.inventory.find({})
client[:inventory].find({})
var findObservable = collection.find(Document())
该操作使用 {} 的过滤谓词，对应以下 SQL 声明：
SELECT * FROM inventory
有关此方法的语法的更多信息，请参阅 find()。
有关 MongoDB Compass 查询栏的更多信息，请参阅查询栏。
有关此方法的语法的更多信息，请参阅 Find()。
有关该方法语法的更多信息，请参阅 com.mongodb.reactivestreams.client.MongoCollection.find。
有关此方法的语法的更多信息，请参阅 com.mongodb.client.MongoCollection.find。
要查看 find() 方法支持的选项，请参阅 find()。
有关此方法的语法的更多信息，请参阅 Find()。
有关此方法的语法的更多信息，请参阅 find()。
有关此方法的语法的更多信息，请参阅 find。
有关此方法的语法的更多信息，请参阅 Find()。
有关该方法语法的更多信息，请参阅 collection.find()。
指定相等条件
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请使用 Eq 方法构建过滤器：
Builders<BsonDocument>.Filter.Eq(<field>, <value>);
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq 方法创建查询过滤器文档：
and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(eq( <field1>, <value1>), eq( <field2>, <value2>) ...)
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
[ <field1> => <value1>, ... ]
要指定相等条件，请在查询筛选器文档中使用 <field>:<value> 表达式：
{ <field1>: <value1>, ... }
要指定相等条件，请在查询筛选器文档中使用 <field> => <value> 表达式：
{ <field1> => <value1>, ... }
要指定相等条件，请使用 com.mongodb.client.model.Filters.eq_ 方法创建查询筛选器文档：
and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)
以下示例从 inventory 中选择集合所有 status 等于 "D" 的文档：
db.inventory.find( { status: "D" } )
将以下过滤器复制到 Compass 查询栏中，然后单击 Find：
{ status: "D" }
var filter = Builders<BsonDocument>.Filter.Eq("status", "D"); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{{"status", "D"}}, )
findPublisher = collection.find(eq("status", "D"));
findIterable = collection.find(eq("status", "D"));
cursor = db.inventory.find({"status": "D"})
const cursor = db.collection('inventory').find({ status: 'D' });
$cursor = $db->coll("inventory")->find( { status => "D" } );
$cursor = $db->inventory->find(['status' => 'D']);
cursor = db.inventory.find({"status": "D"})
client[:inventory].find(status: 'D')
findObservable = collection.find(equal("status", "D"))
该操作使用 { status: "D" } 的过滤谓词，对应以下 SQL 声明：
SELECT * FROM inventory WHERE status = "D"
注意
MongoDB Compass 查询栏根据集合文档中的键（包括嵌入式子文档中的键）自动完成当前查询。
使用查询操作符指定条件
除了相等过滤条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 FilterDefinitionBuilder 方法创建过滤器文档。例如：
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询运算符来指定筛选条件。使用 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))
除了相等条件外，MongoDB 还提供各种查询操作符来指定过滤条件。使用 com.mongodb.client.model.Filters_ 辅助方法促进过滤器文档的创建。例如：
and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))
以下示例从 inventory 集合中检索所有文档。其中 status 等于 "A" 或 "D"：
db.inventory.find( { status: { $in: [ "A", "D" ] } } )
将以下过滤器复制到 Compass 查询栏中，然后单击 Find：
{ status: { $in: [ "A", "D" ] } }
var filter = Builders<BsonDocument>.Filter.In("status", new[] { "A", "D" }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}})
findPublisher = collection.find(in("status", "A", "D"));
findIterable = collection.find(in("status", "A", "D"));
cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})
const cursor = db.collection('inventory').find({ status: { $in: ['A', 'D'] } });
$cursor = $db->coll("inventory")->find( { status => { '$in' => [ "A", "D" ] } } );
$cursor = $db->inventory->find(['status' => ['$in' => ['A', 'D']]]);
cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})
client[:inventory].find(status: { '$in' => [ 'A', 'D' ]})
findObservable = collection.find(in("status", "A", "D"))
该操作使用 { status: { $in: [ "A", "D" ] } } 的过滤谓词，对应以下 SQL 声明：
SELECT * FROM inventory WHERE status in ("A", "D")
有关 MongoDB 查询运算符的完整列表，请参阅查询和投影运算符文档。
指定AND 条件
复合查询可以为集合文档中的多个字段指定条件。逻辑 AND 连接词隐式地连接复合查询的子句，以便该查询选择集合中与所有条件匹配的文档。
以下示例检索 inventory 集合中 status 等于 "A" 且qty 小于 ($lt) 30 的所有文档：
db.inventory.find( { status: "A", qty: { $lt: 30 } } )
将以下过滤器复制到 Compass 查询栏中，然后单击 Find：
{ status: "A", qty: { $lt: 30 } }
var builder = Builders<BsonDocument>.Filter; var filter = builder.And(builder.Eq("status", "A"), builder.Lt("qty", 30)); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"status", "A"}, {"qty", bson.D{{"$lt", 30}}}, })
findPublisher = collection.find(and(eq("status", "A"), lt("qty", 30)));
findIterable = collection.find(and(eq("status", "A"), lt("qty", 30)));
cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})
const cursor = db.collection('inventory').find({ status: 'A', qty: { $lt: 30 } });
$cursor = $db->coll("inventory")->find( { status => "A", qty => { '$lt' => 30 } } );
$cursor = $db->inventory->find([ 'status' => 'A', 'qty' => ['$lt' => 30], ]);
cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})
client[:inventory].find(status: 'A', qty: { '$lt' => 30 })
findObservable = collection.find(and(equal("status", "A"), lt("qty", 30)))
该操作使用 { status: "A", qty: { $lt: 30 } } 的过滤谓词，对应以下 SQL 声明：
SELECT * FROM inventory WHERE status = "A" AND qty < 30
有关其他 MongoDB 比较运算符，请参阅比较运算符。
指定OR 条件
可以使用 $or 操作符指定复合查询，该复合查询使用逻辑 OR 连接词连接每个每个子句，以便该查询选择集合中至少匹配一个条件的文档。
以下示例检索集合中 status 等于 "A" 或 qty 小于 ($lt) 30 的所有文档：
db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )
将以下过滤器复制到 Compass 查询栏中，然后单击 Find：
{ $or: [ { status: "A" }, { qty: { $lt: 30 } } ] }
var builder = Builders<BsonDocument>.Filter; var filter = builder.Or(builder.Eq("status", "A"), builder.Lt("qty", 30)); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"$or", bson.A{ bson.D{{"status", "A"}}, bson.D{{"qty", bson.D{{"$lt", 30}}}}, }}, })
findPublisher = collection.find(or(eq("status", "A"), lt("qty", 30)));
findIterable = collection.find(or(eq("status", "A"), lt("qty", 30)));
cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})
const cursor = db.collection('inventory').find({ $or: [{ status: 'A' }, { qty: { $lt: 30 } }] });
$cursor = $db->coll("inventory")->find( { '$or' => [ { status => "A" }, { qty => { '$lt' => 30 } } ] } );
$cursor = $db->inventory->find([ '$or' => [ ['status' => 'A'], ['qty' => ['$lt' => 30]], ], ]);
cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})
client[:inventory].find('$or' => [{ status: 'A' }, { qty: { '$lt' => 30 } } ])
findObservable = collection.find(or(equal("status", "A"), lt("qty", 30)))
该操作使用 { $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] } 的过滤谓词，对应以下 SQL 声明：
SELECT * FROM inventory WHERE status = "A" OR qty < 30
指定 和 条件<a class=\" \" href=\"AND \" title=\" \"><svg xmlns=\" \"OR width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">
在以下示例中，复合查询文档选择集合中 status 等于 "A" 且 qty 小于 ($lt) 30 或 item 以字符 p 开头的文档：
db.inventory.find( { status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] } )
将以下过滤器复制到 Compass 查询栏中，然后单击 Find：
{ status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] }
var builder = Builders<BsonDocument>.Filter; var filter = builder.And( builder.Eq("status", "A"), builder.Or(builder.Lt("qty", 30), builder.Regex("item", new BsonRegularExpression("^p")))); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"status", "A"}, {"$or", bson.A{ bson.D{{"qty", bson.D{{"$lt", 30}}}}, bson.D{{"item", bson.Regex{Pattern: "^p", Options: ""}}}, }}, })
findPublisher = collection.find( and(eq("status", "A"), or(lt("qty", 30), regex("item", "^p"))) );
findIterable = collection.find( and(eq("status", "A"), or(lt("qty", 30), regex("item", "^p"))) );
cursor = db.inventory.find( {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]} )
const cursor = db.collection('inventory').find({ status: 'A', $or: [{ qty: { $lt: 30 } }, { item: { $regex: '^p' } }] });
$cursor = $db->coll("inventory")->find( { status => "A", '$or' => [ { qty => { '$lt' => 30 } }, { item => { '$regex' => "^p" } } ] } );
$cursor = $db->inventory->find([ 'status' => 'A', '$or' => [ ['qty' => ['$lt' => 30]], // Alternatively: ['item' => new \MongoDB\BSON\Regex('^p')] ['item' => ['$regex' => '^p']], ], ]);
cursor = db.inventory.find( {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]} )
client[:inventory].find(status: 'A', '$or' => [{ qty: { '$lt' => 30 } }, { item: { '$regex' => BSON::Regexp::Raw.new('^p') } } ])
findObservable = collection.find(and( equal("status", "A"), or(lt("qty", 30), regex("item", "^p"))) )
该操作使用以下筛选谓词：
{ status: 'A', $or: [ { qty: { $lt: 30 } }, { item: { $regex: '^p' } } ] }
对应如下 SQL 语句：
SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")
注意
MongoDB 支持正则表达式 $regex 查询，以执行字符串模式匹配。
使用 MongoDB Atlas 查询文档
本部分的示例使用的是示例电影数据集。要了解如何将示例数据集加载到您的 MongoDB Atlas 部署中，请参阅加载示例数据。
要在 MongoDB Atlas 中投影查询返回的字段，请按照以下步骤操作：
在 MongoDB Atlas 用户界面中，前往您项目的Clusters 页面。<a class=\" \" href=\" \" title=\" \"><svg xmlns=\" \" width=\" \" height=\" \" fill=\" \" viewbox=\" \" class=\" \" role=\" \" aria-label=\" \"><path fill=\" \" d=\" \"> <path fill=\" \" d=\" \">
如果尚未显示，请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。
如果尚未显示，请从导航栏的 Projects 菜单中选择您的项目。
如果尚未出现，请单击侧边栏中的 Clusters（部署）。
会显示集群页面。
其他查询教程
有关其他查询示例，请参阅：
行为
Cursor
db.collection.find() 方法会返回指向匹配文档的游标。
MongoDB Compass Find 操作根据查找查询打开指向集合中匹配文档的游标。
有关如何在 MongoDB Compass 中进行采样的更多信息，请参阅 Compass 常见问题解答。
MongoCollection.Find() 方法会返回指向匹配文档的游标。有关迭代游标的信息，请参阅 MongoDB C# 驱动程序文档。
Collection.Find 函数会返回一个指向匹配文档的游标。有关更多信息，请参阅游标文档。
Collection.find() 方法会返回一个游标。
MongoDB::Collection::find() 方法会返回指向匹配文档的游标。有关迭代游标的信息，请参阅 MongoDB Perl 驱动程序文档。
MongoDB\\Collection::find() 方法会返回指向匹配文档的游标。有关迭代游标的信息，请参阅 MongoDB PHP 库文档。
pymongo.collection.Collection.find 方法会返回指向匹配文档的游标。有关如何迭代游标的信息，请参阅 PyMongo 文档。
Mongo::Collection#find() 方法会返回 CollectionView，它是 Enumerable。游标是在枚举 View 时创建的；例如，通过调用 #to_a() 或 #each()。您还可以通过在 Enumerator 上调用 #to_enum() 来获取 View。有关迭代游标的信息，请参阅 Ruby 驱动程序 API 文档。
collection.find()方法会返回 findObservable 。
读取隔离性
版本 3.2 中的新增功能。
关于对副本集和副本集分片的读取，读关注 (read concern) 允许客户端为其读取操作选择隔离级别。有关更多信息，请参阅读关注 (read concern) 。
查询结果格式
使用 MongoDB 驱动程序或 mongosh 运行查找操作时，命令会返回一个管理查询结果的游标。查询结果不会以大量文档的形式返回。
要了解如何迭代游标中的文档，请参阅驱动程序的文档。如果使用的是 mongosh，请参阅在 mongosh 中迭代游标。
其他方法和选项
以下方法也可以从集合中读取文档：
注意
db.collection.findOne() 方法还执行读取操作以返回单个文档。在内部，db.collection.findOne() 方法是限值为 1 的 db.collection.find() 方法。
以下方法也可以从集合中读取文档：
注意
MongoCollection.FindOne() 方法还执行读取操作以返回单个文档。在内部，MongoCollection.FindOne() 方法是限值为 1 的 MongoCollection.Find() 方法。
以下方法也可以从集合中读取文档：
在聚合管道中，
$match管道阶段提供对 MongoDB 查询的访问。请参阅 Collection.Aggregate。
以下方法也可以从集合中读取文档：
在聚合管道中，
$match管道阶段提供对 MongoDB 查询的访问。有关更多信息，请参阅 com.mongodb.reactivestreams.client.MongoCollection.aggregate。
以下方法也可以从集合中读取文档：
在聚合管道中，
$match管道阶段提供对 MongoDB 查询的访问。请参阅 Java 同步驱动程序聚合示例。
以下方法也可以从集合中读取文档：
注意
Collection.findOne() 方法还执行读取操作以返回单个文档。在内部，Collection.findOne()方法是 Collection.find() 方法，限制为 1。
以下方法也可以从集合中读取文档：
注意
MongoDB::Collection::find_one() 方法还执行读取操作以返回单个文档。在内部，MongoDB::Collection::find_one() 方法是限值为 1 的 MongoDB::Collection::find() 方法。
以下方法也可以从集合中读取文档：
注意
MongoDB\\Collection::findOne() 方法还执行读取操作以返回单个文档。在内部，MongoDB\\Collection::findOne() 方法是带有 1 限制的 MongoDB\\Collection::find() 方法。
以下方法也可以从集合中读取文档：
在聚合管道中，
$match管道阶段提供对 MongoDB 查询的访问。请参阅 PyMongo 聚合示例。
注意
pymongo.collection.Collection.find_one 方法还执行读取操作以返回单个文档。在内部，pymongo.collection.Collection.find_one 方法是限值为 1 的 pymongo.collection.Collection.find 方法。