Golang更新JSON嵌套字段异常问题咨询及最优方案求助

问题结论 #

该需求完全可以实现，你遇到的问题是原代码嵌套层级处理逻辑错误导致的。

原代码问题分析 #

• 核心错误：将嵌套字段的路径拼接为点分字符串（如data.field_three）作为顶级key存入最终map，没有逐层进入嵌套map结构操作对应层级的key
• 逻辑冗余：已经通过switch断言了map[string]interface{}类型，后续又用反射重复判断map类型，逻辑混乱
• 递归参数设计错误：递归时传入全路径key而非当前层级的map对象，导致操作层级完全错乱

修复后的完整代码 #

package main

import (
	"encoding/json"
	"fmt"
	"reflect"
)

var currentConfig = `
{
    "field_one": "value",
    "data": {
        "field_two": [
            "data1",
            "data2"
        ],
        "field_three": "check",
        "field_four": 12
    },
    "field_five": [
            "data1",
            "data2"
        ],
    "data2": {
        "field_six":{
            "field_seven": 100
        }
    }
}`

var updateRequest = `
{
    "data": {
        "field_three": "updated check"
    },
    "field_five": ["data3"],
    "data2": {
        "field_six":{
            "field_eight": 300
        }
    }
}`

func main() {
	config := make(map[string]interface{})
	err := json.Unmarshal([]byte(currentConfig), &config)
	if err != nil {
		panic(err)
	}
	updateFields := make(map[string]interface{})
	err1 := json.Unmarshal([]byte(updateRequest), &updateFields)
	if err1 != nil {
		panic(err1)
	}

	MergeConfig(updateFields, config)
	// 格式化输出结果
	res, _ := json.MarshalIndent(config, "", "    ")
	fmt.Println(string(res))
}

// MergeConfig 按规则合并更新配置到当前配置
func MergeConfig(updateMap map[string]interface{}, currentMap map[string]interface{}) {
	for key, updateVal := range updateMap {
		currentVal, exists := currentMap[key]
		// 不存在直接新增
		if !exists {
			currentMap[key] = updateVal
			continue
		}

		// 按类型处理逻辑
		switch updateValTyped := updateVal.(type) {
		case map[string]interface{}:
			// 当前值也是嵌套map，递归合并子字段
			currentMapTyped, ok := currentVal.(map[string]interface{})
			if !ok {
				// 类型不一致，已有值不覆盖直接跳过
				continue
			}
			MergeConfig(updateValTyped, currentMapTyped)
		case []interface{}:
			// 当前值也是数组，追加更新的元素
			currentArrTyped, ok := currentVal.([]interface{})
			if !ok {
				continue
			}
			currentMap[key] = append(currentArrTyped, updateValTyped...)
		default:
			// 普通类型，已有值直接跳过不覆盖
			concreteValType := reflect.TypeOf(updateValTyped)
			if concreteValType.Kind() == reflect.Map {
				// 兼容其他map类型递归
				currentMapTyped, ok := currentVal.(map[string]interface{})
				if ok {
					MergeConfig(updateValTyped.(map[string]interface{}), currentMapTyped)
				}
			}
			continue
		}
	}
}

运行后输出完全符合预期：

{
    "data": {
        "field_four": 12,
        "field_three": "check",
        "field_two": [
            "data1",
            "data2"
        ]
    },
    "data2": {
        "field_six": {
            "field_eight": 300,
            "field_seven": 100
        }
    },
    "field_five": [
        "data1",
        "data2",
        "data3"
    ],
    "field_one": "value"
}

更优实现方案 #

• 固定结构场景：提前定义配置对应的struct，直接将JSON反序列化为struct对象，合并逻辑直接操作struct字段，类型安全，性能比操作interface{}高3~5倍，代码维护成本也更低
• 通用动态场景：使用成熟的开源合并库，支持自定义合并规则，仅需配置「不覆盖已有值」「数组追加」两个选项即可实现需求，无需自己实现递归逻辑
• 复杂差异场景：使用JSON Patch规范实现，先计算更新请求和当前配置的差异，再按自定义规则应用差异，适合需要审计合并过程的业务场景

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