重新排列Golang中的地图

假设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组合为一个嵌套映射，并可能索引一个新键

[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)

}

---

纽基的想法是什么？newkey[1]和newkey[2]的内部是什么？我建议您先进行战斗，然后用您的代码更新这个问题。。。最小、完整且可验证的示例，否则您的问题可能会被关闭