如何有效地展平地图？

如何解决如何有效地展平地图？

我的应用程序需要使用map[string]interface{}的大量嵌套实例，并将它们转换为扁平化的地图。

例如：

{
                "foo": {
                    "jim":"bean"
                },"fee": "bar","n1": {
                    "alist": [
                        "a","b","c",{
                            "d": "other","e": "another"
                        }
                    ]
                },"number": 1.4567,"bool":   true
}

之后：

json.Unmarshal([]byte(input),&out)
result = Flatten(m.(map[string]interface{}))

成为：

{
                "foo.jim":      "bean","fee":          "bar","n1.alist.0":   "a","n1.alist.1":   "b","n1.alist.2":   "c","n1.alist.3.d": "other","n1.alist.3.e": "another","number":       1.4567,"bool":         true,}

当前我正在使用以下代码：

func Flatten(m map[string]interface{}) map[string]interface{} {
    o := map[string]interface{}{}
    for k,v := range m {
        switch child := v.(type) {
        case map[string]interface{}:
            nm := Flatten(child)
            for nk,nv := range nm {
                o[k+"."+nk] = nv
            }
        case []interface{}:
            for i := 0; i < len(child); i++ {
                o[k+"."+strconv.Itoa(i)] = child[i]
            }
        default:
            o[k] = v
        }
    }
    return o
}

此代码的内存效率非常低，当拼合〜800张地图时，将使用〜8 GiB内存。 我尝试传递指针而不是副本，但这不会改变内存使用率。我是否必须执行某种类型的手动内存管理？ Go应该垃圾收集所有未使用的内存，但是可能是我没有以某种方式释放它。

解决方法

正如安迪·施威格（Andy Schweig）在注释中建议的那样，该注释传递给您在遍历数据时进行更新的映射，这将显着减少内存使用量（注意：未经测试）。像这样：

func Flatten2(prefix string,src map[string]interface{},dest map[string]interface{}) {
    if len(prefix) > 0 {
        prefix += "."
    }
    for k,v := range src {
        switch child := v.(type) {
        case map[string]interface{}:
            Flatten2(prefix+k,child,dest)
        case []interface{}:
            for i := 0; i < len(child); i++ {
                dest[prefix+k+"."+strconv.Itoa(i)] = child[i]
            }
        default:
            dest[prefix+k] = v
        }
    }
}

在the playground中尝试。

我必须进行某种类型的手动内存管理吗？

Go运行时旨在为您处理内存管理（请参见garbage collection的FAQ文章）。尽管垃圾收集器非常好，但它只能释放未使用的内存，并且您的原始例程在运行时会创建许多映射，直到处理完该级别的映射后才能释放这些映射。

您可以通过environmental variables或使用debug package来设置一些标志，但是很少需要这些标志（它们会带来意想不到的后果）。

关于在哪里进一步优化此功能的任何建议？

如果不访问数据集以及了解您的要求和有关如何测量内存使用情况的信息（这可能比看起来要复杂的多），就很难发表评论。 Profiling您的应用程序可能会为您提供一些需要改进的地方。一种可能的改进是对dest使用一个预先分配的切片而不是一个映射（但是我不知道您对结果做什么，所以这可能不合适）。

,

我刚刚写了一些代码来做到这一点，享受吧！

package lib

import (
    "container/list"
    "strings"
)

type pair struct {
    key   []string
    value interface{}
}

// FlattenMap flattens a given Map.
func FlattenMap(input map[string]interface{}) *map[string]interface{} {
    var returnValue = make(map[string]interface{})

    var stack = list.New()
    stack.PushBack(pair{key: []string{"."},value: input})

    for {
        element := stack.Back()
        if element == nil {
            break
        }
        stack.Remove(element)

        thePair,ok := element.Value.(pair)
        if !ok {
            panic("can't cast element to pair")
        }

        switch v := thePair.value.(type) {
        case map[string]interface{}:
            for key,val := range v {
                parentKey := thePair.key[0]
                if parentKey == "." {
                    stack.PushBack(pair{key: []string{key},value: val})
                } else {
                    newKeys := append(thePair.key,key)
                    stack.PushBack(pair{key: newKeys,value: val})
                }

            }
        default:
            returnValue[strings.Join(thePair.key,".")] = v
        }
    }

    return &returnValue
}