Golang中合并相同ID的Map并重构嵌套结构的实现方案

需求描述 #

我们需要处理一组JSON格式的数据，输入结构如下：

[
  map[id:id_1 fname:Form Factor ffname:Smartphone fuid:fid_1],
  map[fname:Form Factor ffname:Feature Phone fuid:fid_2 id:id_1],
  map[id:id_2 fname:Operating System ffname:Android fuid:fid_3],
  map[id:id_3 ffname:Test fuid:fid_3 fname:TestUpdated]
]

目标是将相同id值的元素合并，同时把每个元素中的fuid和ffname组合成以newkey[索引]为键的嵌套Map，输出结构如下：

[
  map[id:id_1 fname:Form Factor newkey[1]:{fuid:fid_1 ffname:Smartphone} newkey[2]:{fuid:fid_2 ffname:Feature Phone}],
  map[id:id_2 fname:Operating System ffname:Android fuid:fid_3],
  map[id:id_3 ffname:Test fuid:fid_3 fname:TestUpdated]
]

现有代码 #

用户已经写了一段基础实现，但觉得可以优化，代码如下：

func reorder() {
	fdata, err := getData()
	if err != nil {
		fmt.Println(err)
	}
	var a ([]map[string]interface{})
	err = json.Unmarshal(fdata, &a)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(a)

	type f1 struct {
		id     interface{}
		fname  interface{}
	}
	type f2 struct {
		fid    interface{}
		ffname interface{}
	}
	type f3 struct {
		f1 struct {
			id     interface{}
			fname  interface{}
		}
		f2 struct {
			fid    interface{}
			ffname interface{}
		}
	}

	c := make(map[int]*f3, 0)
	var d *f3
	for l, p := range a {
		d = &f3{
			f1: struct {
				id     interface{}
				fname  interface{}
			}{
				id:    p["id"],
				fname: p["fname"],
			},
			f2: struct {
				fid    interface{}
				ffname interface{}
			}{
				fid:    p["fid"],
				ffname: p["ffname"],
			},
		}
		c[l] = d
	}

	e := make(map[f1][]map[int]f2)
	for _, h := range c {
		for o, k := range c {
			if h.f1.id == k.f1.id {
				if h.f2.fid != k.f2.fid {
					e[h.f1] = append(e[h.f1], map[int]f2{
						o: k.f2,
					})
					fmt.Println(e)
				}
			} else {
				if o == 0 {
					var g []map[int]f2
					g = append(g, map[int]f2{
						o: k.f2,
					})
					e[h.f1] = g
				}
			}
		}
	}
	fmt.Println("final transformed map..")
	fmt.Println(e)
}

问题 #

请问需要对现有代码做出哪些修改才能满足需求？同时是否有更优的实现方式？

解答 #

现有代码的问题与修改方向

你的现有代码存在几个关键问题，导致无法正确输出目标结构：

1. 结构体设计冗余且不合理：用f1、f2、f3多层结构体嵌套，反而增加了处理复杂度；而且用f1作为map的key，由于f1的字段是interface{}类型，当字段值是不可比较类型时（比如slice）会直接panic，非常不安全。
2. 双重循环逻辑错误：遍历c两次会导致重复处理元素，而且判断逻辑混乱，无法正确按id分组，最终输出的e结构和目标结构完全不符。
3. 没有构建目标格式的结果：最终输出的是map[f1][]map[int]f2，但我们需要的是[]map[string]interface{}类型的数组，和输入的顶层结构一致。

针对这些问题，你需要做的修改包括：

• 放弃复杂的结构体嵌套，改用map[string]interface{}直接处理数据，更灵活且符合JSON的动态特性。
• 以id的值作为分组key，而不是结构体，确保key的安全性和正确性。
• 遍历输入数组时，直接按id分组，收集每个id对应的fuid和ffname，最后构建目标格式的结果。

更优的实现方式

下面是一个更简洁高效的实现，直接按id分组并构建目标结构：

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

func reorder() {
	fdata, err := getData()
	if err != nil {
		fmt.Println(err)
		return
	}

	var input []map[string]interface{}
	if err := json.Unmarshal(fdata, &input); err != nil {
		fmt.Println(err)
		return
	}

	// 用id作为key，存储分组后的临时数据
	grouped := make(map[string]map[string]interface{})

	for _, item := range input {
		id, ok := item["id"].(string)
		if !ok {
			// 如果id不是字符串类型，可以根据实际情况处理，比如跳过或转换
			continue
		}

		// 如果该id还没有分组，初始化基础结构
		if _, exists := grouped[id]; !exists {
			grouped[id] = map[string]interface{}{
				"id":    id,
				"fname": item["fname"],
			}
		}

		currentGroup := grouped[id]
		// 收集fuid和ffname，构建嵌套map
		ffEntry := map[string]interface{}{
			"fuid":   item["fuid"],
			"ffname": item["ffname"],
		}

		// 计算newkey的索引：统计当前group中已有的newkey数量+1
		keyCount := 0
		for k := range currentGroup {
			if strings.HasPrefix(k, "newkey[") {
				keyCount++
			}
		}
		newKey := fmt.Sprintf("newkey[%d]", keyCount+1)
		currentGroup[newKey] = ffEntry
	}

	// 将grouped中的值转换为数组，得到最终结果
	var result []map[string]interface{}
	for _, v := range grouped {
		result = append(result, v)
	}

	// 打印结果（如果需要JSON输出，可以用json.MarshalIndent格式化）
	fmt.Println("final transformed result:")
	for _, item := range result {
		fmt.Println(item)
	}
}

这个实现的优势在于：

• 逻辑清晰：直接按id分组，逐步构建目标结构，没有冗余的循环和结构体。
• 灵活性高：用map[string]interface{}适配JSON的动态结构，不需要提前定义固定结构体。
• 性能更好：只需要遍历输入数组一次，分组操作是O(n)时间复杂度，比原代码的O(n²)高效很多。

需要注意的是，如果你的id类型不是字符串，可以根据实际情况调整类型断言的部分；另外，如果某个元素没有fname、fuid或ffname字段，也可以添加对应的空值处理逻辑，避免panic。

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