MongoDB是否支持比较两个文档并获取差异属性的功能？

MongoDB没有直接内置的文档差异比较功能，但可以通过聚合管道结合操作符或自定义JavaScript函数实现需求，以下是两种适配你场景的方案：

方案1：使用JavaScript递归函数（适用于任意嵌套结构） #

该方案通过MongoDB 4.4+支持的$function操作符，定义递归函数遍历文档的所有字段（包括嵌套文档和数组），自动收集值不同的属性。

假设你的两个文档在集合中通过version字段区分（比如version: "v1"和version: "v2"），执行以下聚合查询：

db.your_collection_name.aggregate([
  // 筛选出需要比较的两个文档
  { $match: { $or: [{ version: "v1" }, { version: "v2" }] } },
  // 将两个文档分别提取为doc1和doc2
  {
    $group: {
      _id: null,
      doc1: { $push: { $cond: [{ $eq: ["$version", "v1"] }, "$$ROOT", null] } },
      doc2: { $push: { $cond: [{ $eq: ["$version", "v2"] }, "$$ROOT", null] } }
    }
  },
  { $project: { doc1: { $arrayElemAt: ["$doc1", 0] }, doc2: { $arrayElemAt: ["$doc2", 0] } } },
  // 定义递归比较函数，收集差异
  {
    $set: {
      differences: {
        $function: {
          body: function(doc1, doc2) {
            function compare(obj1, obj2, path = "") {
              let diffs = [];
              // 获取两个对象所有键的并集
              const keys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
              for (const key of keys) {
                const currentPath = path ? `${path}.${key}` : key;
                const val1 = obj1[key];
                const val2 = obj2[key];

                // 处理数组（按索引逐一比较元素）
                if (Array.isArray(val1) && Array.isArray(val2)) {
                  for (let i = 0; i < Math.max(val1.length, val2.length); i++) {
                    diffs = diffs.concat(compare(val1[i], val2[i], `${currentPath}[${i}]`));
                  }
                }
                // 处理嵌套文档
                else if (typeof val1 === "object" && val1 !== null && typeof val2 === "object" && val2 !== null) {
                  diffs = diffs.concat(compare(val1, val2, currentPath));
                }
                // 比较基础类型值
                else if (val1 !== val2) {
                  diffs.push({
                    "Property Name": currentPath,
                    "Document 1": val1,
                    "Document 2": val2
                  });
                }
              }
              return diffs;
            }
            return compare(doc1, doc2);
          },
          args: ["$doc1", "$doc2"],
          lang: "js"
        }
      }
    }
  },
  // 展开差异数组
  { $unwind: "$differences" },
  // 整理成预期的表格格式
  {
    $project: {
      _id: 0,
      "Property Name": "$differences.Property Name",
      "Document 1": "$differences.Document 1",
      "Document 2": "$differences.Document 2"
    }
  }
])

注意事项： #

• 需要MongoDB 4.4或更高版本支持$function
• 对于超大型文档，JavaScript递归可能存在性能瓶颈，需根据实际数据量评估
• 数组比较逻辑是按索引匹配，若你的业务需要按元素内容匹配而非索引，需修改递归函数的数组处理逻辑

方案2：静态字段映射（适用于结构固定的文档） #

如果你的文档结构固定，不需要处理动态嵌套，可以直接通过聚合操作符手动映射所有字段路径，避免使用JavaScript，性能更优。

针对你的示例文档结构，执行以下聚合查询：

db.your_collection_name.aggregate([
  { $match: { $or: [{ version: "v1" }, { version: "v2" }] } },
  {
    $group: {
      _id: null,
      v1: { $push: { $cond: [{ $eq: ["$version", "v1"] }, "$$ROOT", null] } },
      v2: { $push: { $cond: [{ $eq: ["$version", "v2"] }, "$$ROOT", null] } }
    }
  },
  { $project: { v1: { $arrayElemAt: ["$v1", 0] }, v2: { $arrayElemAt: ["$v2", 0] } } },
  // 生成所有需要比较的字段路径及对应值
  {
    $project: {
      fields: {
        $concatArrays: [
          // 顶层字段
          {
            $map: {
              input: { $objectToArray: { $mergeObjects: ["$v1", "$v2"] } },
              as: "f",
              in: {
                path: "$$f.k",
                v1: { $ifNull: ["$v1.$$f.k", null] },
                v2: { $ifNull: ["$v2.$$f.k", null] }
              }
            }
          },
          // address嵌套字段
          {
            $map: {
              input: { $objectToArray: { $mergeObjects: ["$v1.address", "$v2.address"] } },
              as: "f",
              in: {
                path: { $concat: ["address.", "$$f.k"] },
                v1: { $ifNull: ["$v1.address.$$f.k", null] },
                v2: { $ifNull: ["$v2.address.$$f.k", null] }
              }
            }
          },
          // phoneNumbers数组内的字段（假设数组长度为1）
          {
            $map: {
              input: { $objectToArray: { $mergeObjects: ["$v1.phoneNumbers.0", "$v2.phoneNumbers.0"] } },
              as: "f",
              in: {
                path: { $concat: ["phoneNumbers.", "$$f.k"] },
                v1: { $ifNull: ["$v1.phoneNumbers.0.$$f.k", null] },
                v2: { $ifNull: ["$v2.phoneNumbers.0.$$f.k", null] }
              }
            }
          }
        ]
      }
    }
  },
  { $unwind: "$fields" },
  // 过滤出值不同的字段
  { $match: { $expr: { $ne: ["$fields.v1", "$fields.v2"] } } },
  // 整理成预期格式
  {
    $project: {
      _id: 0,
      "Property Name": "$fields.path",
      "Document 1": "$fields.v1",
      "Document 2": "$fields.v2"
    }
  }
])

优缺点： #

• 优点：无需JavaScript，性能更稳定，适合结构固定的场景
• 缺点：需要提前明确文档的嵌套层级和字段，无法自动处理新增的嵌套结构

总结 #

如果文档结构动态多变，优先选择方案1；如果结构固定且追求性能，选择方案2。两种方式都能在MongoDB端直接输出你需要的差异表格结果。

内容的提问来源于stack exchange，提问作者Nayan Katkani