MongoDB更新集合项时如何保留未传入的原有字段？

现有MongoDB集合中的文档如下：

{  
  "test": {    
    "a1": "a1"  
  }
}

调用collection.updateOne并使用$set传入如下对象时：

await collection.updateOne(doc, {$set: {"test": {"a2": "a2"}}}, {upsert: true});

原有的test对象会被替换为：

{  
  "test": {    
    "a2": "a2"  
  }
}

其中a1字段会被删除，因为传入的对象中不包含该字段。

希望实现：传入{"test": {"a2": "a2"}}时，文档被更新为：

{  
  "test": {    
    "a1": "a1",    
    "a2": "a2"  
  }
}

即仅更新传入的字段，保留未传入的原有字段。

已编写递归解析对象/数组的函数buildUpdateQuery来构建更新查询：

// 递归解析数组和对象，重构更新查询
function buildUpdateQuery(object, prefix = '') {
    let updateQuery = {};
    for (let [key, value] of Object.entries(object))
    {
        let newPrefix = prefix ? `${ prefix }.${ key }` : key;
        if (Array.isArray(value)) 
        {
            for (let i = 0; i < value.length; i++) 
            {
                let arrayPrefix = `${newPrefix}.${i}`;
                if (typeof value[i] === 'object' && value[i] !== null)
                    updateQuery = {...updateQuery, ...buildUpdateQuery(value[i], arrayPrefix)};
                else
                    updateQuery[arrayPrefix] = value[i];
            }
        }
        else if (typeof value === 'object' && value !== null)
            updateQuery = {...updateQuery, ...buildUpdateQuery(value, newPrefix)};
        else
            updateQuery[newPrefix] = value;
    }
    return updateQuery;
}

// 使用mongodb和express实现的接口函数
export const set = async (req, res /*key, object*/) =>   
{
    try
    {
        const [collection, key] = req.body.key.split("|");
        if (collection === undefined || key === undefined)
            return res ? res.send('fail') : 'fail'
        const doc = buildUpdateQuery(req.body.object);
        let r = await db.collection(collection).updateOne({ [key]: { $exists: true } }, { $set: doc }, { upsert: true });
        r = r.modifiedCount ? 'ok' : 'fail';
        return res ? res.send(r) : r
    }
    catch (error)
    {
        console.log(`\n[set]\n${ JSON.stringify(req.body, null, 2) }\n\n`, error);
        return res ? res.send('fail') : 'fail'
    }
}

调用set函数传入：

{"key": "vars|test", "object": {"test": {"a2": "a2"}}}

doc会被处理为{test.a2: 'a2'}，能成功将{"test": {"a1": "a1"}}更新为{"test": {"a1": "a1", "a2":"a2"}}。

但担心该函数可能存在解析错误，导致集合数据异常。已知可以先查询文档再修改，但不想要该方案。

请问：MongoDB是否有内置方法实现该需求？如果没有，buildUpdateQuery函数是否正确，或者有更优的实现方案？

一、MongoDB内置方案 #

MongoDB本身没有直接接收嵌套对象并自动展开成点路径$set的内置方法，但可以通过手动指定点路径实现需求，比如直接写$set: {"test.a2": "a2"}，这就是你当前函数做的事情。

不过从MongoDB 5.0开始，提供了$mergeObjects操作符，可在聚合管道更新中实现对象合并：

await collection.updateOne(
  doc,
  [{$set: {test: {$mergeObjects: ["$test", {"a2": "a2"}]}}}],
  {upsert: true}
);

这个操作符会将现有test对象与传入的新对象合并，保留原有字段，同时新增或覆盖传入的字段。注意这是基于聚合管道的更新写法，和普通$set逻辑不同，且要求MongoDB版本≥5.0。如果你的环境满足版本要求，这是更简洁的内置解决方案。

二、buildUpdateQuery函数的正确性与优化 #

现有函数的正确性 #

你的buildUpdateQuery核心逻辑是正确的：递归遍历嵌套对象和数组，将其展开为MongoDB支持的点路径格式，确保$set仅更新指定嵌套字段，不会替换整个父对象。

但存在几个潜在问题：

1. 数组处理歧义：当前函数会将数组元素逐个展开为点路径（如arr.0、arr.1），这会导致原数组中未被覆盖的元素保留。比如原数组是[1,2,5]，传入{arr: [3,4]}，更新后数组会变成[3,4,5]，而非替换为[3,4]。如果你的需求是有时需要替换整个数组，有时需要更新元素，当前函数无法区分这两种场景。
2. 性能损耗：每次递归都用扩展运算符...合并对象，当嵌套层级较深或对象体积较大时，会产生额外的性能开销。
3. 查询条件隐患：updateOne的查询条件{ [key]: { $exists: true } }结合upsert: true，如果没有匹配文档，会插入{[key]: true}的文档，而非包含传入object结构的预期文档，需要根据业务逻辑调整查询条件。

更优实现方案 #

优化后的函数解决了上述问题，同时提升性能：

// 递归解析数组和对象，重构更新查询（优化版）
function buildUpdateQuery(object, prefix = '', result = {}) {
  for (const [key, value] of Object.entries(object)) {
    const currentPath = prefix ? `${prefix}.${key}` : key;

    if (Array.isArray(value)) {
      // 可选逻辑1：直接替换整个数组
      result[currentPath] = value;
      // 可选逻辑2：更新数组中的单个元素（取消注释启用）
      // value.forEach((item, index) => {
      //   const arrayPath = `${currentPath}.${index}`;
      //   if (typeof item === 'object' && item !== null) {
      //     buildUpdateQuery(item, arrayPath, result);
      //   } else {
      //     result[arrayPath] = item;
      //   }
      // });
    } else if (typeof value === 'object' && value !== null) {
      buildUpdateQuery(value, currentPath, result);
    } else {
      result[currentPath] = value;
    }
  }
  return result;
}

优化点说明：

• 通过传递引用的方式复用同一个结果对象，避免多次扩展对象的性能损耗。
• 提供数组处理的可选逻辑，可根据需求选择替换整个数组或更新单个元素。
• 代码结构更简洁，递归逻辑更清晰。

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