Docs 菜单
Docs 主页
/
数据库手册
/
增删改查操作
/
查询

查询返回的项目字段

➤ 使用右上角的 Select your language（选择语言）下拉菜单，设置以下示例的语言。

默认情况下，MongoDB 中的查询会返回匹配文档中的所有字段。要限制 MongoDB 发送到应用程序的数据量，可以添加 投影文档来指定或限制要返回的字段。

本页提供的示例展示使用 mongosh 中的 db.collection.find()方法进行投影查询操作

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供的示例展示了如何使用 MongoDB Compass 执行带投影的查询操作。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用MongoDB C#驱动程序中的 MongoCollection.Find() 方法进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用MongoDB Go驱动程序中的 Collection.Find 函数进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用 com.mongodb.reactivestreams 进行带有投影的查询操作的示例。 MongoDB Java Reactive Streams 驱动程序中的客户端方法。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用 com.mongodb 进行带有投影的查询操作的示例。 MongoDB Java同步驱动程序中的客户端方法。

提示

此驱动程序提供了 com.mongodb.client.model.Filters 辅助方法，以便于创建筛选器文档。此页面中的示例使用这些方法创建筛选器文档。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用motor.motor_asyncio.AsyncIOMotorCollection.find 电机 驱动程序中的 方法进行投影查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供的示例展示了使用 Collection.find() 进行投影的查询操作MongoDB Node.js驱动程序中的方法。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页面提供的示例展示使用 MongoDB\\Collection::find() 方法在 MongoDB PHP 库中进行投影查询操作。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

pymongo.collection.Collection.find本页提供了使用PyMongo Python驾驶员中的 方法进行带有投影的查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页面提供了使用 MongoDB Ruby 驱动程序中的 Mongo::Collection#find() 方法进行投影查询操作的示例。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

本页提供了使用集合.find()进行带有投影的查询操作的示例MongoDB Scala驱动程序中的方法。

此页面上的示例使用的是 inventory 集合。连接到 MongoDB 实例中的测试数据库，然后创建 inventory 集合：

db.inventory.insertMany( [
  { item: "journal", status: "A", size: { h: 14, w: 21, uom: "cm" }, instock: [ { warehouse: "A", qty: 5 } ] },
  { item: "notebook", status: "A",  size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "C", qty: 5 } ] },
  { item: "paper", status: "D", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "A", qty: 60 } ] },
  { item: "planner", status: "D", size: { h: 22.85, w: 30, uom: "cm" }, instock: [ { warehouse: "A", qty: 40 } ] },
  { item: "postcard", status: "A", size: { h: 10, w: 15.25, uom: "cm" }, instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);
[
    { "item": "journal", "status": "A", "size": { "h": 14, "w": 21, "uom": "cm" }, "instock": [ { "warehouse": "A", "qty": 5 } ] },
    { "item": "notebook", "status": "A", "size": { "h": 8.5, "w": 11, "uom": "in" }, "instock": [ { "warehouse": "C", "qty": 5 } ] },
    { "item": "paper", "status": "D", "size": { "h": 8.5, "w": 11, "uom": "in" }, "instock": [ { "warehouse": "A", "qty": 60 } ] },
    { "item": "planner", "status": "D", "size": { "h": 22.85, "w": 30, "uom": "cm" }, "instock": [ { "warehouse": "A", "qty": 40 } ] },
    { "item": "postcard", "status": "A", "size": { "h": 10, "w": 15.25, "uom": "cm" }, "instock": [ { "warehouse": "B", "qty": 15 }, { "warehouse": "C", "qty": 35 } ] }
]

有关在 MongoDB Compass 中插入文档的说明，请参阅插入文档。

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "status", "A" },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "status", "A" },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "C" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "status", "D" },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 60 } } }
            }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "status", "D" },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 40 } } }
            }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "status", "A" },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 35 } } }
            }
    }
};
collection.InsertMany(documents);
docs := []any{
	bson.D{
		{"item", "journal"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "notebook"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "EC"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "paper"},
		{"status", "D"},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
		}},
	},
	bson.D{
		{"item", "planner"},
		{"status", "D"},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 40},
			},
		}},
	},
	bson.D{
		{"item", "postcard"},
		{"status", "A"},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
			bson.D{
				{"warehouse", "EC"},
				{"qty", 35},
			},
		}},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList(
    Document.parse("{ item: 'journal', status: 'A', size: { h: 14, w: 21, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 5 }]}"),
    Document.parse("{ item: 'notebook', status: 'A',  size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'C', qty: 5}]}"),
    Document.parse("{ item: 'paper', status: 'D', size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'A', qty: 60 }]}"),
    Document.parse("{ item: 'planner', status: 'D', size: { h: 22.85, w: 30, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 40}]}"),
    Document.parse("{ item: 'postcard', status: 'A', size: { h: 10, w: 15.25, uom: 'cm' }, "
            + "instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));
collection.insertMany(asList(
    Document.parse("{ item: 'journal', status: 'A', size: { h: 14, w: 21, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 5 }]}"),
    Document.parse("{ item: 'notebook', status: 'A',  size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'C', qty: 5}]}"),
    Document.parse("{ item: 'paper', status: 'D', size: { h: 8.5, w: 11, uom: 'in' }, instock: [ { warehouse: 'A', qty: 60 }]}"),
    Document.parse("{ item: 'planner', status: 'D', size: { h: 22.85, w: 30, uom: 'cm' }, instock: [ { warehouse: 'A', qty: 40}]}"),
    Document.parse("{ item: 'postcard', status: 'A', size: { h: 10, w: 15.25, uom: 'cm' }, "
            + "instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));
await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "status": "A",
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "instock": [{"warehouse": "A", "qty": 5}],
        },
        {
            "item": "notebook",
            "status": "A",
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "instock": [{"warehouse": "C", "qty": 5}],
        },
        {
            "item": "paper",
            "status": "D",
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "instock": [{"warehouse": "A", "qty": 60}],
        },
        {
            "item": "planner",
            "status": "D",
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "instock": [{"warehouse": "A", "qty": 40}],
        },
        {
            "item": "postcard",
            "status": "A",
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "instock": [{"warehouse": "B", "qty": 15}, {"warehouse": "C", "qty": 35}],
        },
    ]
)
await db.collection('inventory').insertMany([
  {
    item: 'journal',
    status: 'A',
    size: { h: 14, w: 21, uom: 'cm' },
    instock: [{ warehouse: 'A', qty: 5 }]
  },
  {
    item: 'notebook',
    status: 'A',
    size: { h: 8.5, w: 11, uom: 'in' },
    instock: [{ warehouse: 'C', qty: 5 }]
  },
  {
    item: 'paper',
    status: 'D',
    size: { h: 8.5, w: 11, uom: 'in' },
    instock: [{ warehouse: 'A', qty: 60 }]
  },
  {
    item: 'planner',
    status: 'D',
    size: { h: 22.85, w: 30, uom: 'cm' },
    instock: [{ warehouse: 'A', qty: 40 }]
  },
  {
    item: 'postcard',
    status: 'A',
    size: { h: 10, w: 15.25, uom: 'cm' },
    instock: [
      { warehouse: 'B', qty: 15 },
      { warehouse: 'C', qty: 35 }
    ]
  }
]);
$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'status' => 'A',
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'instock' => [
            ['warehouse' => 'A', 'qty' => 5],
        ],
    ],
    [
        'item' => 'notebook',
        'status' => 'A',
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'instock' => [
            ['warehouse' => 'C', 'qty' => 5],
        ],
    ],
    [
        'item' => 'paper',
        'status' => 'D',
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'instock' => [
            ['warehouse' => 'A', 'qty' => 60],
        ],
    ],
    [
        'item' => 'planner',
        'status' => 'D',
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'instock' => [
            ['warehouse' => 'A', 'qty' => 40],
        ],
    ],
    [
        'item' => 'postcard',
        'status' => 'A',
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'instock' => [
            ['warehouse' => 'B', 'qty' => 15],
            ['warehouse' => 'C', 'qty' => 35],
        ],
    ],
]);
db.inventory.insert_many(
    [
        {
            "item": "journal",
            "status": "A",
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "instock": [{"warehouse": "A", "qty": 5}],
        },
        {
            "item": "notebook",
            "status": "A",
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "instock": [{"warehouse": "C", "qty": 5}],
        },
        {
            "item": "paper",
            "status": "D",
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "instock": [{"warehouse": "A", "qty": 60}],
        },
        {
            "item": "planner",
            "status": "D",
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "instock": [{"warehouse": "A", "qty": 40}],
        },
        {
            "item": "postcard",
            "status": "A",
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "instock": [{"warehouse": "B", "qty": 15}, {"warehouse": "C", "qty": 35}],
        },
    ]
)
client[:inventory].insert_many([{ item: 'journal',
                                  status: 'A',
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  instock: [ { warehouse: 'A', qty: 5 }] },
                                { item: 'notebook',
                                  status: 'A',
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  instock: [ { warehouse: 'C', qty: 5 }] },
                                { item: 'paper',
                                  status: 'D',
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  instock: [ { warehouse: 'A', qty: 60 }] },
                                { item: 'planner',
                                  status: 'D',
                                  size: { h: 22.85, w: 30, uom: 'cm' },
                                  instock: [ { warehouse: 'A', qty: 40 }] },
                                { item: 'postcard',
                                  status: 'A',
                                  size: { h: 10, w: 15.25, uom: 'cm' },
                                  instock: [ { warehouse: 'B', qty: 15 },
                                             { warehouse: 'C', qty: 35 }] }])
collection.insertMany(Seq(
  Document("""{ item: "journal", status: "A", size: { h: 14, w: 21, uom: "cm" }, instock: [ { warehouse: "A", qty: 5 } ] }"""),
  Document("""{ item: "notebook", status: "A",  size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "C", qty: 5 } ] }"""),
  Document("""{ item: "paper", status: "D", size: { h: 8.5, w: 11, uom: "in" }, instock: [ { warehouse: "A", qty: 60 } ] }"""),
  Document("""{ item: "planner", status: "D", size: { h: 22.85, w: 30, uom: "cm" }, instock: [ { warehouse: "A", qty: 40 } ] }"""),
  Document("""{ item: "postcard", status: "A", size: { h: 10, w: 15.25, uom: "cm" },
                instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }""")
)).execute()

返回匹配文档中的所有字段

如果未指定投影文档，db.collection.find() 方法将返回匹配文档中的所有字段。

如果未指定投影文档，Compass 将返回匹配文档中的所有字段。

如果您未指定投影过滤器，则 MongoCollection.Find() 方法将返回匹配文档中的所有字段。

如果未指定投影，则com.mongodb.reactivestreams.client.MongoCollection.find方法返回匹配文档中的所有字段。

如果未指定投影，则 com.mongodb.client.MongoCollection.find 方法将返回匹配文档中的所有字段。

如果未指定投影文档，find() 方法将在匹配的文档中生成所有字段。

如果未指定投影文档，则find() 方法将返回匹配文档中的所有字段

如果您未指定投影文档，则 find 方法将返回匹配文档中的所有字段。

如果未指定投影文档，则 find() 方法将返回匹配文档中的所有字段。

如果未指定投影，则 collection.find() 方法返回匹配文档中的所有字段。

如下示例将返回 inventory 集合中的所有文档的所有字段，其中的 status 等于 "A"：

db.inventory.find( { status: "A" } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"status", "A"}},
)
FindPublisher<Document> findPublisher = collection.find(eq("status", "A"));
FindIterable<Document> findIterable = collection.find(eq("status", "A"));
cursor = db.inventory.find({"status": "A"})
const cursor = db.collection('inventory').find({
  status: 'A'
});
$cursor = $db->inventory->find(['status' => 'A']);
cursor = db.inventory.find({"status": "A"})
client[:inventory].find(status: 'A')
var findObservable = collection.find(equal("status", "A"))

此操作对应于以下 SQL 语句：

SELECT * from inventory WHERE status = "A"

仅返回指定字段和 _id 字段

通过在投影文档中将<field>设置为1，投影可以显式包含多个字段。以下操作会返回与查询匹配的所有文档。 在结果集中，匹配文档中仅返回item 、 status和默认情况下的_id字段。

db.inventory.find( { status: "A" }, { item: 1, status: 1 } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1 }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(include("item", "status"));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status"));
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1})
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1 });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1})
client[:inventory].find({ status: 'A' },
                       projection: { item: 1, status: 1 })
findObservable = collection.find(equal("status", "A")).projection(include("item", "status"))

此操作对应于以下 SQL 语句：

SELECT _id, item, status from inventory WHERE status = "A"

抑制 _id 字段

您可通过在投影中将其设为 0 以便从结果中删除 _id 字段，如以下示例所示：

db.inventory.find( { status: "A" }, { item: 1, status: 1, _id: 0 } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, _id: 0 }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Exclude("_id");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"_id", 0},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), excludeId()));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), excludeId()));
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0})
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, _id: 0 });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, '_id' => 0]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "_id": 0})
client[:inventory].find({ status: 'A' },
                        projection: { item: 1, status: 1, _id: 0 })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), excludeId()))

此操作对应于以下 SQL 语句：

SELECT item, status from inventory WHERE status = "A"

注意

除 _id 字段之外，您无法在投影文档中合并包含与排除声明。

返回除已排除字段之外的所有字段

您可以使用投影来排除特定字段，而不必在匹配文档中列出要返回的字段。以下示例将在匹配文档中返回除 status 和 instock 字段之外的所有字段：

db.inventory.find( { status: "A" }, { status: 0, instock: 0 } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { status: 0, instock: 0 }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Exclude("status").Exclude("instock");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"status", 0},
	{"instock", 0},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(exclude("item", "status"));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(exclude("item", "status"));
cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0})
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ status: 0, instock: 0 });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['status' => 0, 'instock' => 0]],
);
cursor = db.inventory.find({"status": "A"}, {"status": 0, "instock": 0})
client[:inventory].find({ status: 'A' },
                        projection: { status: 0, instock: 0 })
findObservable = collection.find(equal("status", "A")).projection(exclude("item", "status"))

注意

除 _id 字段之外，您无法在投影文档中合并包含与排除声明。

返回嵌入式文档中的特定字段

您可以返回嵌入式文档中的特定字段。使用点符号引用嵌入式字段，并在投影文档中设为 1。

以下示例将返回：

  • _id 字段（默认返回）、

  • item 字段。

  • status 字段。

  • size 文档中的 uom 字段。

uom 字段仍会嵌入在 size 文档中。

db.inventory.find(
   { status: "A" },
   { item: 1, status: 1, "size.uom": 1 }
)

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, "size.uom": 1 }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"size.uom", 1},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "size.uom"));
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, 'size.uom': 1 });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'size.uom' => 1]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})
client[:inventory].find({ status: 'A' },
                        projection: { 'item' => 1, 'status' => 1, 'size.uom' => 1 })
findObservable = collection.find(equal("status", "A")).projection(include("item", "status", "size.uom"))

您还可以使用嵌套表单指定嵌入式字段。例如：{ item: 1, status: 1, size: { uom: 1 } }。

抑制嵌入式文档中的特定字段

您可以隐藏嵌入式文档中的特定字段。使用点符号引用投影文档中的嵌入式字段，并设为 0。

以下示例将指定一个投影来排除 size 文档内的 uom 字段。所有其他字段均会在匹配的文档中返回：

db.inventory.find(
   { status: "A" },
   { "size.uom": 0 }
)

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { "size.uom": 0 }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Exclude("size.uom");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"size.uom", 0},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(exclude("size.uom"));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(exclude("size.uom"));
cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ 'size.uom': 0 });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['size.uom' => 0]],
);
cursor = db.inventory.find({"status": "A"}, {"size.uom": 0})
client[:inventory].find({ status: 'A' },
                        projection: { 'size.uom' => 0 })
findObservable = collection.find(equal("status", "A")).projection(exclude("size.uom"))

您还可以使用嵌套表单指定嵌入式字段。例如：{ size: { uom: 0 } }。

对数组中嵌入式文档的投影

使用点符号来投影嵌入数组中的文档内的特定字段。

以下示例指定要返回的投影：

  • _id 字段（默认返回）、

  • item 字段。

  • status 字段。

  • 嵌入到 instock 数组中的文档内的 qty 字段。

db.inventory.find( { status: "A" }, { item: 1, status: 1, "instock.qty": 1 } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, "instock.qty": 1 }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Include("instock.qty");
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock.qty", 1},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A")).projection(include("item", "status", "instock.qty"));
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, 'instock.qty': 1 });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock.qty' => 1]],
);
cursor = db.inventory.find({"status": "A"}, {"item": 1, "status": 1, "instock.qty": 1})
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1, 'status' => 1, 'instock.qty' => 1 })
findObservable = collection.find(equal("status", "A")).projection(include("item", "status", "instock.qty"))

已返回数组中特定于项目的数组元素

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，{ "instock.0": 1 } 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。

例如，以下操作不会使用第一个元素项目数组：

Builders<BsonDocument>.Projection.Include("instock.0")

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，include("instock.0") 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，include("instock.0") 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，include("instock.0") 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，{ "instock.0": 1 } 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，[ "instock.0" => 1 ] 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，{ "instock.0": 1 } 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，{ "instock.0" => 1 } 投影不会投影包含第一个元素的数组。

对于包含数组的字段，MongoDB 提供了用来操作数组的以下投影操作符：$elemMatch、$slice 和$。

如下示例使用 $slice 投影操作符返回 instock 数组中的最后一个元素：

db.inventory.find( { status: "A" }, { item: 1, status: 1, instock: { $slice: -1 } } )

  1. 将以下表达式复制到 Filter 字段中：

    { status: "A" }

  2. 单击 Options 打开其他查询选项。

  3. 将以下表达式复制到 Project 字段中：

    { item: 1, status: 1, instock: { $slice: -1 } }

  4. 单击 Find（连接）。

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var projection = Builders<BsonDocument>.Projection.Include("item").Include("status").Slice("instock", -1);
var result = collection.Find<BsonDocument>(filter).Project(projection).ToList();
projection := bson.D{
	{"item", 1},
	{"status", 1},
	{"instock", bson.D{
		{"$slice", -1},
	}},
}
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
	options.Find().SetProjection(projection),
)
findPublisher = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));

要指定投影文档，请链接 com.mongodb。客户端.FindIterable。投影方法转换为 find方法。该示例使用 com.mongodb。客户端.model.Projections 类，用于创建投影文档。

findIterable = collection.find(eq("status", "A"))
        .projection(fields(include("item", "status"), slice("instock", -1)));
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
const cursor = db
  .collection('inventory')
  .find({
    status: 'A'
  })
  .project({ item: 1, status: 1, instock: { $slice: -1 } });
$cursor = $db->inventory->find(
    ['status' => 'A'],
    ['projection' => ['item' => 1, 'status' => 1, 'instock' => ['$slice' => -1]]],
);
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "instock": {"$slice": -1}}
)
client[:inventory].find({ status: 'A' },
                        projection: {'item' => 1,
                                     'status' => 1,
                                     'instock' => { '$slice' => -1 } })
findObservable = collection.find(equal("status", "A"))
  .projection(fields(include("item", "status"), slice("instock", -1)))

要投影要包含在返回的数组中的特定元素，只能使用 $elemMatch、$slice 和 $。例如，使用数组索引，您无法投影特定的数组元素；例如，include("instock.0") 投影不会投影包含第一个元素的数组。

使用聚合表达式投影字段

您可以在查询投影中指定聚合表达式。通过使用聚合表达式，您可以投影新字段并修改现有字段的值。

例如，以下操作使用聚合表达式覆盖 status 字段的值，并投影新字段 area 和 reportNumber。

注意

以下示例使用 MongoDB Shell 语法。有关使用聚合的投影的驱动程序示例，请参阅您的驱动程序文档。

db.inventory.find(
   { },
   {
      _id: 0,
      item: 1,
      status: {
         $switch: {
            branches: [
               {
                  case: { $eq: [ "$status", "A" ] },
                  then: "Available"
               },
               {
                  case: { $eq: [ "$status", "D" ] },
                  then: "Discontinued"
               },
            ],
            default: "No status found"
         }
      },
      area: {
         $concat: [
            { $toString: { $multiply: [ "$size.h", "$size.w" ] } },
            " ",
            "$size.uom"
         ]
      },
      reportNumber: { $literal: 1 }
   }
)
[
   {
      item: 'journal',
      status: 'Available',
      area: '294 cm',
      reportNumber: 1
   },
   {
      item: 'planner',
      status: 'Discontinued',
      area: '685.5 cm',
      reportNumber: 1
   },
   {
      item: 'notebook',
      status: 'Available',
      area: '93.5 in',
      reportNumber: 1
   },
   {
      item: 'paper',
      status: 'Discontinued',
      area: '93.5 in',
      reportNumber: 1
   },
   {
      item: 'postcard',
      status: 'Available',
      area: '152.5 cm',
      reportNumber: 1
   }
]

其他注意事项

  • 当您使用$project聚合阶段时，它通常应该是管道中的最后一个阶段，用于指定要返回给客户端的字段。

    在管道的开头或中间使用 $project 阶段来减少传递到后续管道阶段的字段数量不太可能提高性能，因为数据库会自动执行此优化。

  • MongoDB 对投影执行额外的限制。有关详细信息，请参阅投影限制。

提示

后退

嵌入式文档数组

来年

Null 或缺失字段

在此页面上