如何用MongoDB从嵌套对象数组中获取单个子对象

我用Node.js基于Express和Mongoose搭建服务器，现有MongoDB文档结构如下：

[
    {
        "_id": "63dbaf5daabee478202ae59f",
        "experimentId": "85a91abe-ef2f-416f-aa13-ec1bdf5d9766",
        "experimentData": [
            {
                "scanId": 1652890241,
                "scanData": [
                    {
                        "areaName": "A1",
                        "areaData": [],
                        "_id": "63dbaf94aabee478202ae5a5"
                    },
                    ...
                ],
                "_id": "63dbaf6caabee478202ae5a3"
            },
            ...
        ],
        "__v": 2
    },
   ...
]

希望查询返回scanData数组中指定areaName的单个对象，格式如下：

{
  "areaName": "A1",
  "areaData": [],
  "_id": "63dbb006e322869df811eea4"
}

当前实现的代码只能返回整个scanData数组，无法提取单个对象：

// * Get all shapes in a well/area
// ! uses the experiment id, scan id and areaName
router.get("/:id/scan/:scanId/area/:areaName", async (req, res) => {
    try {
        const experiment = await Experiment.findOne({
            experimentId: req.params.id,
            experimentData: {
                $elemMatch: {
                    scanId: req.params.scanId,
                    scanData: {
                        $elemMatch: {
                            areaName: req.params.areaName
                        }
                    }
                }
            }
        }, {'experimentData.scanData.$': 1})
        console.log(experiment)
        if (!experiment || experiment.length === 0) res.status(404).json({})
        else {
            res.send(experiment.experimentData[0])
        }
    } catch (err) {
        res.status(500).json({ message: err.message })
    }
})

尝试过$aggregate但返回空数组，寻求解决办法。

方法1：使用MongoDB聚合管道（推荐） #

由于是双层嵌套数组筛选，find方法的$elemMatch只能匹配到第一层嵌套数组的元素，无法直接定位第二层的单个对象。使用聚合管道可以逐层拆解筛选：

router.get("/:id/scan/:scanId/area/:areaName", async (req, res) => {
    try {
        const { id: experimentId, scanId, areaName } = req.params;
        // URL参数是字符串，需转换为数字匹配数据库类型
        const numericScanId = parseInt(scanId, 10);

        const result = await Experiment.aggregate([
            // 定位到目标experimentId的文档
            { $match: { experimentId } },
            // 拆解experimentData数组，筛选出匹配scanId的元素
            { $unwind: "$experimentData" },
            { $match: { "experimentData.scanId": numericScanId } },
            // 拆解scanData数组，筛选出匹配areaName的元素
            { $unwind: "$experimentData.scanData" },
            { $match: { "experimentData.scanData.areaName": areaName } },
            // 将目标对象提升为根文档，得到所需格式
            { $replaceRoot: { newRoot: "$experimentData.scanData" } }
        ]);

        if (result.length === 0) {
            return res.status(404).json({});
        }
        res.send(result[0]);
    } catch (err) {
        res.status(500).json({ message: err.message });
    }
});

代码说明：

1. $match：先缩小范围到目标实验文档，减少后续处理的数据量
2. $unwind：将嵌套数组拆分为独立文档，方便逐层筛选
3. 两次嵌套的$match分别定位到目标扫描数据和目标区域数据
4. $replaceRoot直接提取目标对象，返回符合要求的格式

方法2：查询后用JavaScript处理 #

如果聚合管道调试有困难，也可以先获取包含目标数据的文档，再通过JS逻辑提取单个对象：

router.get("/:id/scan/:scanId/area/:areaName", async (req, res) => {
    try {
        const { id: experimentId, scanId, areaName } = req.params;
        const numericScanId = parseInt(scanId, 10);

        const experiment = await Experiment.findOne({
            experimentId,
            "experimentData.scanId": numericScanId,
            "experimentData.scanData.areaName": areaName
        });

        if (!experiment) {
            return res.status(404).json({});
        }

        // 逐层遍历找到目标区域对象
        const targetArea = experiment.experimentData
            .find(item => item.scanId === numericScanId)
            ?.scanData.find(data => data.areaName === areaName);

        res.send(targetArea || {});
    } catch (err) {
        res.status(500).json({ message: err.message });
    }
});

注意事项：

• 必须确保scanId的类型一致：URL参数默认是字符串，需转换为数字匹配数据库中的字段类型
• 聚合管道在数据库层面完成筛选，性能更优；JS处理适合数据量较小的场景，代码更直观

内容的提问来源于stack exchange，提问作者Joan Krastanov