如何在MongoDB中对数组内对象进行部分匹配过滤用户集合

问题背景 #

我在MongoDB中有一个User文档集合，结构对应以下TypeScript接口：

interface User {
    otherProperties: any;
    education: Education[];
    skills: Skill[];
}

interface Education {
    specialization: string;
    provider: string;
    type: string;
    description: string;
}

interface Skill {
    name: string;
    type: string;
    experience: number;
    description: string;
}

需要基于以下结构的过滤输入查询用户，其中每个过滤项都是Education或Skill的部分属性：

interface UserFilter {
    education: Partial<Education>[];
    skills: Partial<Skill>[];
}

当前使用$elemMatch仅能实现完整对象匹配，当过滤条件为部分属性（如某个skill过滤项缺少name）时无法正常工作。现有代码示例：

const users = await database.users.find({
    $or: {
        skills: {
            $elemMatch: { // 每个匹配规则重复该结构
                name: matcher.name,
                type: matcher.type,
                experience: { $gte: matcher.experience },
            },
        },
        education: { // 每个匹配规则重复该结构
            $elemMatch: {
                specialization: matcher.specialization,
                type: matcher.type,
                provider: matcher.provider,
            },
        }
    }
})

示例需求 #

当过滤条件为：

{
    education: [
        {
            specialization: 'computer science',
            type: 'undergraduate'
        },
        {
            specialization: 'business',
            provider: 'university of york'
        },
    ],
    skills: [
        {
            name: 'c++',
            type: 'language'
        },
        {
            name: 'python',
            experience: 5,
        },
    ],
}

需匹配同时满足所有以下条件的用户：

1. education数组中至少有一个元素符合specialization: 'computer science'且type: 'undergraduate'
2. education数组中至少有一个元素符合specialization: 'business'且provider: 'university of york'
3. skills数组中至少有一个元素符合name: 'c++'且type: 'language'
4. skills数组中至少有一个元素符合name: 'python'且experience ≥ 5

满足条件的用户示例：

{
    otherProperties: {},
    education: [
        {
            specialization: 'computer science',
            type: 'undergraduate',
            provider: 'university of york',
            description: '...'
        },
        {
            specialization: 'business',
            provider: 'university of york',
            type: 'undergraduate',
            description: '...'
        },
    ],
    skills: [
        {
            name: 'c++',
            type: 'language',
            experience: 5,
            description: '...'
        },
        {
            name: 'python',
            experience: 5,
            type: 'language',
            description: '...'
        },
        {
            name: 'html',
            experience: 1,
            type: 'language',
            description: '...'
        },
    ],
}

缺少python技能的用户则不应被匹配：

{
    otherProperties: {},
    education: [
        {
            specialization: 'computer science',
            type: 'undergraduate',
            provider: 'university of york',
            description: '...'
        },
        {
            specialization: 'business',
            provider: 'university of york',
            type: 'undergraduate',
            description: '...'
        },
    ],
    skills: [
        {
            name: 'c++',
            type: 'language',
            experience: 5,
            description: '...'
        },
        {
            name: 'html',
            experience: 1,
            type: 'language',
            description: '...'
        },
    ],
}

解决方案 #

核心思路是将每个部分属性过滤项转换为独立的$elemMatch条件，再用$and组合所有条件，确保每个过滤规则都能找到对应的匹配元素。

代码实现 #

编写工具函数自动生成查询条件：

function buildUserFilterQuery(filter) {
    const queryConditions = [];

    // 处理education过滤规则
    if (filter.education?.length) {
        filter.education.forEach(eduFilter => {
            const elemMatch = {};
            Object.entries(eduFilter).forEach(([key, value]) => {
                elemMatch[key] = value;
            });
            queryConditions.push({ education: { $elemMatch: elemMatch } });
        });
    }

    // 处理skills过滤规则，针对experience做特殊处理
    if (filter.skills?.length) {
        filter.skills.forEach(skillFilter => {
            const elemMatch = {};
            Object.entries(skillFilter).forEach(([key, value]) => {
                if (key === 'experience') {
                    elemMatch[key] = { $gte: value };
                } else {
                    elemMatch[key] = value;
                }
            });
            queryConditions.push({ skills: { $elemMatch: elemMatch } });
        });
    }

    return queryConditions.length ? { $and: queryConditions } : {};
}

// 使用示例
const filterInput = {
    education: [
        { specialization: 'computer science', type: 'undergraduate' },
        { specialization: 'business', provider: 'university of york' },
    ],
    skills: [
        { name: 'c++', type: 'language' },
        { name: 'python', experience: 5 },
    ],
};

const query = buildUserFilterQuery(filterInput);
const users = await database.users.find(query);

逻辑说明 #

1. 遍历过滤输入中的每个education和skills项，为每个项生成对应的$elemMatch条件：
   • 普通属性直接做精确匹配
   • 针对experience字段使用$gte做范围匹配（可根据需求扩展其他比较规则）
2. 所有条件通过$and组合，确保用户文档必须满足全部过滤项要求：
   • 每个education过滤项都要在用户的education数组中找到至少一个匹配元素
   • 每个skills过滤项都要在用户的skills数组中找到至少一个匹配元素

扩展提示 #

如果需要支持模糊匹配、多范围查询等复杂规则，可在工具函数中添加对应逻辑，例如：

• 字符串属性支持$regex模糊匹配
• 数值属性扩展$lte、$eq等比较符

内容的提问来源于stack exchange，提问作者Henry Gill