如何在Go语言的嵌套map中保持插入顺序

标准库的map是无序的，没法保证插入顺序。要让你的map[string]map[string]map[string]string嵌套结构保留插入顺序，得用有序键值容器替换每层的普通map，下面是两种可行方案：

方案1：自定义有序结构体（无外部依赖） #

为每层结构定义包含键切片和值映射的结构体，手动维护插入顺序，完全基于标准库实现：

// 最内层有序结构
type InnerOrderedMap struct {
    Keys   []string
    Values map[string]string
}

// 中间层有序结构
type MiddleOrderedMap struct {
    Keys   []string
    Values map[string]*InnerOrderedMap
}

// 最外层有序结构
type OuterOrderedMap struct {
    Keys   []string
    Values map[string]*MiddleOrderedMap
}

操作示例 #

// 初始化外层有序结构
outer := &OuterOrderedMap{
    Keys:   []string{},
    Values: make(map[string]*MiddleOrderedMap),
}

// 插入数据的方法
func (o *OuterOrderedMap) Put(outerKey, middleKey, innerKey, value string) {
    // 处理外层键，不存在则加入键切片
    if _, exists := o.Values[outerKey]; !exists {
        o.Keys = append(o.Keys, outerKey)
        o.Values[outerKey] = &MiddleOrderedMap{
            Keys:   []string{},
            Values: make(map[string]*InnerOrderedMap),
        }
    }
    middle := o.Values[outerKey]

    // 处理中间层键
    if _, exists := middle.Values[middleKey]; !exists {
        middle.Keys = append(middle.Keys, middleKey)
        middle.Values[middleKey] = &InnerOrderedMap{
            Keys:   []string{},
            Values: make(map[string]string),
        }
    }
    inner := middle.Values[middleKey]

    // 处理最内层键
    if _, exists := inner.Values[innerKey]; !exists {
        inner.Keys = append(inner.Keys, innerKey)
    }
    inner.Values[innerKey] = value
}

// 按插入顺序遍历数据
func (o *OuterOrderedMap) Iterate() {
    for _, outerKey := range o.Keys {
        middle := o.Values[outerKey]
        for _, middleKey := range middle.Keys {
            inner := middle.Values[middleKey]
            for _, innerKey := range inner.Keys {
                // 这里可以拿到按插入顺序排列的键值对，用于和数据库数据对比
                println(outerKey, middleKey, innerKey, inner.Values[innerKey])
            }
        }
    }
}

方案2：泛型实现通用有序Map（简化代码） #

如果Go版本在1.18及以上，可以用泛型实现通用的有序Map，复用在嵌套结构中，减少重复代码：

import "slices"

// 通用有序Map结构体
type OrderedMap[K comparable, V any] struct {
    keys []K
    vals map[K]V
}

// 创建新的有序Map
func NewOrderedMap[K comparable, V any]() *OrderedMap[K, V] {
    return &OrderedMap[K, V]{
        keys: []K{},
        vals: make(map[K]V),
    }
}

// 插入键值对，保留顺序
func (m *OrderedMap[K, V]) Put(key K, val V) {
    if _, exists := m.vals[key]; !exists {
        m.keys = append(m.keys, key)
    }
    m.vals[key] = val
}

// 获取指定键的值
func (m *OrderedMap[K, V]) Get(key K) (V, bool) {
    val, exists := m.vals[key]
    return val, exists
}

// 获取按插入顺序排列的键切片
func (m *OrderedMap[K, V]) Keys() []K {
    return slices.Clone(m.keys)
}

嵌套使用示例 #

// 定义嵌套的有序Map类型
type NestedOrderedMap = *OrderedMap[string, *OrderedMap[string, *OrderedMap[string, string]]]

// 初始化嵌套结构
nestedMap := NewOrderedMap[string, *OrderedMap[string, *OrderedMap[string, string]]]()
middleMap := NewOrderedMap[string, *OrderedMap[string, string]]()
innerMap := NewOrderedMap[string, string]()

// 插入数据
innerMap.Put("inner_key_1", "value_1")
middleMap.Put("middle_key_1", innerMap)
nestedMap.Put("outer_key_1", middleMap)

// 按顺序遍历
for _, outerKey := range nestedMap.Keys() {
    middle, _ := nestedMap.Get(outerKey)
    for _, middleKey := range middle.Keys() {
        inner, _ := middle.Get(middleKey)
        for _, innerKey := range inner.Keys() {
            val, _ := inner.Get(innerKey)
            // 处理键值对，顺序和插入一致
        }
    }
}

关键注意点 #

• 两种方案都能保证插入顺序，遍历的时候直接用键切片就能按插入顺序获取数据，方便和数据库查询结果做对比。
• 自定义结构体方案无任何外部依赖，适合对依赖管控严格的项目；泛型方案代码更简洁，但要求Go 1.18+版本。

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