MongoDB 查询中 $elemMatch 未按 "AND" 条件匹配

2026-11-04技术老齐

结论

$elemMatch 只保证其中的条件由数组里的同一个元素满足。多组查询条件需要分别生成 $elemMatch，再组合成 AND。

先按位置配对重复传入的 key 和 value，为每组参数生成独立的 $elemMatch，然后放入 $and：

{
  $and: [
    { specs: { $elemMatch: { k: "brand", v: "adidas" } } },
    { specs: { $elemMatch: { k: "color", v: "red" } } }
  ]
}

这些条件可以根据 req.query 动态生成，不需要在代码中写死属性名称和属性值。

原查询的问题

请求为：

/api/product?key=brand&value=adidas&key=color&value=red

经过 Express 的 query parser 后，重复参数通常会被解析成类似下面的结果：

req.query.key
// ["brand", "color"]

req.query.value
// ["adidas", "red"]

原查询也就接近：

{
  specs: {
    $elemMatch: {
      k: ["brand", "color"],
      v: ["adidas", "red"]
    }
  }
}

数组参数可能会因 Express 的 query parser 配置和 Mongoose 的查询转换行为，被当作类似 $in 的条件处理。此时，查询的含义是：

找到一个 specs 元素，其 k 属于给定 key 集合，并且 v 属于给定 value 集合。

这个查询没有保留 brand 对应 adidas、color 对应 red 的配对关系。因此，{ k: "color", v: "red" } 也可能满足整个 $elemMatch，从而返回 Nike 商品。

动态构建 `$and` 查询

接口需要兼容单个参数和重复参数。只有一组查询条件时，Express 可能返回字符串；有多组条件时，则可能返回数组。

router.get('/api/product', async (req, res, next) => {
  try {
    const keys = Array.isArray(req.query.key)
      ? req.query.key
      : req.query.key !== undefined
        ? [req.query.key]
        : [];

    const values = Array.isArray(req.query.value)
      ? req.query.value
      : req.query.value !== undefined
        ? [req.query.value]
        : [];

    if (keys.length === 0) {
      return res.status(400).json({
        message: 'At least one key/value pair is required'
      });
    }

    if (keys.length !== values.length) {
      return res.status(400).json({
        message: 'The number of key parameters must match the number of value parameters'
      });
    }

    const conditions = keys.map((key, index) => ({
      specs: {
        $elemMatch: {
          k: key,
          v: values[index]
        }
      }
    }));

    const products = await Product.find({
      $and: conditions
    });

    return res.json(products);
  } catch (error) {
    return next(error);
  }
});

以下请求：

/api/product?key=brand&value=adidas&key=color&value=red

会生成：

{
  $and: [
    {
      specs: {
        $elemMatch: {
          k: "brand",
          v: "adidas"
        }
      }
    },
    {
      specs: {
        $elemMatch: {
          k: "color",
          v: "red"
        }
      }
    }
  ]
}

第一个 $elemMatch 由 brand 元素满足，第二个可以由另一个 color 元素满足。document 中必须同时存在这两个元素，查询才会将其返回。

使用 `$all`

这类查询要求数组包含多个分别满足条件的元素，也可以用 $all 配合多个 $elemMatch：

const elemMatches = keys.map((key, index) => ({
  $elemMatch: {
    k: key,
    v: values[index]
  }
}));

const products = await Product.find({
  specs: {
    $all: elemMatches
  }
});

对应的查询是：

{
  specs: {
    $all: [
      { $elemMatch: { k: "brand", v: "adidas" } },
      { $elemMatch: { k: "color", v: "red" } }
    ]
  }
}

它与动态 $and 的查询目标相同，也更直接地表达了“specs 数组必须包含所有指定属性”。

更稳妥的参数格式

两个平行数组通过索引配对。如果客户端漏传一个 value，后面的参数可能全部错位。可以改用显式分组的接口格式：

/api/product?filters[0][k]=brand&filters[0][v]=adidas&filters[1][k]=color&filters[1][v]=red

如果 query parser 支持解析嵌套 query parameters，可以直接构造查询条件：

const filters = Array.isArray(req.query.filters)
  ? req.query.filters
  : [];

const conditions = filters.map(({ k, v }) => ({
  specs: {
    $elemMatch: { k, v }
  }
}));

const products = await Product.find({
  $and: conditions
});

解析结果取决于 Express 的 query parser 配置，使用前需要确认 req.query.filters 的实际结构。

注意事项

specs.v 使用 Schema.Types.Mixed，URL query parameter 默认是字符串。如果数据库保存的是数字或布尔值，例如：

{ k: "size", v: 42 }

请求中的 value=42 通常会被解析为字符串 "42"，未必能匹配数值 42。接口需要按照属性定义转换类型，也可以在数据模型中保存属性的类型信息。

还需要限制过滤条件的数量并验证参数类型，避免空条件、对象参数或大量 $elemMatch 增加查询开销。现有复合索引为：

ProductSchema.index({ "specs.k": 1, "specs.v": 1 });

这个索引适用于单组 k、v 配对查询。实际查询是否使用索引，以及多条件查询的扫描范围，仍需在目标环境中通过 explain("executionStats") 确认。