Dictionary 如何将整个嵌套结构转换为映射

我有一个场景，我必须将整个结构转换成一个映射。 我知道我们有一个库structs.Map，它将结构转换为映射。但我想知道是否有一种方法可以将struct中的多个struct转换为map[string]接口。 例如，我们有下面的例子

package main

import (
    "log"

    "github.com/fatih/structs"
)

type Community struct {
    Name        string   `json:"name,omitempty"`
    Description string   `json:"description,omitempty"`
    Sources     []Source `json:"sources,omitempty"`
    Moderators  []string `json:"moderators,omitempty"`
}

type Source struct {
    SourceName string  `json:"sourceName,omitempty"`
    Region []State `json:"region,omitempty"`
}

type State struct {
    State1 string `json:"state1,omitempty"`
    State2 string `json:"state2,omitempty"`
}

func main() {

    compareData := Community{
        Name:        "A",
        Description: "this belong to A community",
        Sources: []Source{
            {
                SourceName: "SourceA",
                Region: []State{
                    {
                        State1: "State1",
                    },
                    {
                        State2: "State2",
                    },
                },
            },
        },
    }
    m := structs.Map(compareData)
    log.Println(m)
}

这将给出如下结果，即它再次为内部结构创建映射

map[Description:this belong to A community 
Moderators:[] 
Name:A Sources:[map[SourceName:SourceA Region:[map[State1:State1 State2:] map[State1: State2:State2]]]]]

我的期望是只获得一个map[string]接口{}

map[
Description:this belong to A community 
Moderators:[] 
Name:A 
SourceName:SourceA 
State1:State1 
State2:State2
]

我创建单个映射的目的是基于键将值与其他映射进行比较。 我的结构也会根据不同的响应而变化，因此我希望有一个映射，可以在其中获取所有键值对，以便进行比较。如果有人对此有建议，请告诉我。

您可以使用该软件包

用法示例：

package main

import (
    "fmt"
    "github.com/mitchellh/mapstructure"
)

func main() {

    type Emails struct {
        Mail []string
    }

    type Person struct {
        Name   string
        Age    int
        Emails Emails
        Extra  map[string]string
    }



    // This input can come from anywhere, but typically comes from
    // something like decoding JSON where we're not quite sure of the
    // struct initially.
    mails := []string{"foo@bar.com", "foo2@bar.com"}
    input := Person{
        Name:   "foo",
        Age:    25,
        Emails: Emails{Mail: mails},
        Extra:  map[string]string{"family": "bar"},
    }

    result := map[string]interface{}{}

    err := mapstructure.Decode(input, &result)
    if err != nil {
        panic(err)
    }

    fmt.Printf("%#v", result)
}

---

用于比较原始结构或由其创建的嵌套映射。映射中的键必须是唯一的，因此

Name:a

与

Name:SourceA

并排的

map[string]接口{}

永远不会发生。我认为最好的方法是在结构中使用嵌套比较，不仅仅是转换为mapyes键必须是唯一的这只是一个例子，我写了一个单一的地图