Dictionary Golang：如何创建未知（动态）贴图长度

我可以通过

但“键”的长度将是动态的：

 |---unknown len--|
m[1][2][3][4][2][0] = true

或

如何在Go中创建此地图？或者有什么办法存在

添加：层次结构非常重要

---

提前谢谢

如果您不需要层次映射结构，只想使用具有可变长度的键，一种方法可以是简单地使用字符串作为键和一个单独的映射

m := make(map[string]bool)
k := fmt.Sprintf("%v_%v_%v", 1, 2, 3)

m[k] = true

fmt.Println(m[k])

---

您不能这样做，因为这种类型在Go的类型系统中不可表示

你必须重新设计

例如，使用方法

lookup（vals…int）bool

的类型

arbirilykeydmap

。

---

可能你也需要设置和删除的方法。

好的，我玩得很开心。这是一个比我以前做的更好的实现：

type mymap map[int]*myentry

type myentry struct {
    m mymap
    b bool
}

func (mm mymap) get(idx ...int) *myentry {
    if len(idx) == 0 {
        return nil
    }
    entry, ok := mm[idx[0]]
    if !ok {
        return nil
    } else if len(idx) == 1 {
        return entry
    }
    for i := 1; i < len(idx); i++ {
        if entry == nil || entry.m == nil {
            return nil
        }
        entry = entry.m[idx[i]]
    }
    return entry
}

func (mm mymap) setbool(v bool, idx ...int) {
    if len(idx) == 0 {
        return
    }
    if mm[idx[0]] == nil {
        mm[idx[0]] = &myentry{m: make(mymap), b: false}
    } else if mm[idx[0]].m == nil {
        mm[idx[0]].m = make(mymap)
    }
    if len(idx) == 1 {
        mm[idx[0]].b = v
        return
    }
    entry := mm[idx[0]]
    for i := 1; i < len(idx); i++ {
        if entry.m == nil {
            entry.m = make(mymap)
            entry.m[idx[i]] = &myentry{m: make(mymap), b: false}
        } else if entry.m[idx[i]] == nil {
            entry.m[idx[i]] = &myentry{m: make(mymap), b: false}
        }
        entry = entry.m[idx[i]]
    }
    entry.b = v
}

func (m mymap) getbool(idx ...int) bool {
    if val := m.get(idx...); val != nil {
        return val.b
    }
    return false
}

func (m mymap) getmap(idx ...int) mymap {
    if val := m.get(idx...); val != nil {
        return val.m
    }
    return nil
}

键入mymap map[int]*myentry
类型myentry结构{
我的地图
布尔
}
func（mm mymap）get（idx…int）*myentry{
如果len（idx）==0{
归零
}
条目，确定：=mm[idx[0]]
如果！好的{
归零
}如果len（idx）==1，则为else{
返回条目
}
对于i:=1；i

像这样的事情应该会让你开始

映射是一组无序的一种类型的元素，称为元素类型，由另一种类型的一组唯一键（称为键类型）索引

映射类型必须具有特定的值类型和特定的键类型。您想要的不符合此条件：您想要一个映射，其中的值有时是另一个映射（相同类型），有时是一个

bool

您的选择：

1.使用包装器值类型 这里的想法不仅仅是使用一个简单的（

bool

）值类型，而是使用一个包含两个潜在值的包装器：一个

map

和一个简单值（

bool

）：

这基本上是user3591723所建议的，所以我不会进一步详细说明

2.用一棵树 这是#1的一个变体，但通过这种方式，我们可以清楚地传达它是一棵树

实现层次结构最干净的方法是使用树，其中的节点可以如下所示：

type KeyType int
type ValueType string

type Node struct {
    Children map[KeyType]*Node
    Value    ValueType
}

这样做的好处是，您可以选择值类型（在您的案例中是

bool

，但您可以将其更改为任何类型-我用于表示的

string

）

为了方便地构建/管理您的树，我们可以向

节点添加一些方法

类型：

func (n *Node) Add(key KeyType, v ValueType) {
    if n.Children == nil {
        n.Children = map[KeyType]*Node{}
    }
    n.Children[key] = &Node{Value: v}
}

func (n *Node) Get(keys ...KeyType) *Node {
    for _, key := range keys {
        n = n.Children[key]
    }
    return n
}

func (n *Node) Set(v ValueType, keys ...KeyType) {
    n = n.Get(keys...)
    n.Value = v
}

使用它：1。建一棵树，2。查询一些值，3。更改值：

root := &Node{Value: "root"}
root.Add(0, "first")
root.Get(0).Add(9, "second")
root.Get(0, 9).Add(3, "third")
root.Get(0).Add(4, "fourth")

fmt.Println(root)
fmt.Println(root.Get(0, 9, 3))
fmt.Println(root.Get(0, 4))

root.Set("fourthMod", 0, 4)
fmt.Println(root.Get(0, 4))

输出（在上尝试）：

3.使用递归类型定义 这可能令人惊讶，但可以使用递归定义在Go中定义具有无限或动态“深度”的

map

类型：

type X map[int]X

它是这样说的：它是一个

map

，带有

int

键，值的类型与map本身相同

这种递归类型的最大缺点是它不能在值类型中存储任何“有用”的数据。它只能存储“事实”，即是否存在与类

bool

信息相同的值（

bool

类型：

true

或

false

），这在极少数情况下可能足够了，但在大多数情况下不足够

让我们看一个构建“树”的示例：

输出：

map[0:map[9:map[3:map[]] 4:map[]]]

x[0][9][3] exists: true ; alternative way: true
x[0][9][4] exists: false ; alternative way: false
x[0][4] exists: true ; alternative way: true
x[0][4][9][9][9] exists: false ; alternative way: false

如果我们想测试是否存在基于一系列键的“值”，我们有两个选项：要么使用特殊的

v，ok:=m[i]

索引（它报告指定键的值是否存在），要么测试该值是否不是

nil

，例如

m[i]！=无

让我们看一些测试上述构建映射的示例：

var ok bool
_, ok = x[0][9][3]
fmt.Println("x[0][9][3] exists:", ok, "; alternative way:", x[0][9][3] != nil)
_, ok = x[0][9][4]
fmt.Println("x[0][9][4] exists:", ok, "; alternative way:", x[0][9][4] != nil)
_, ok = x[0][4]
fmt.Println("x[0][4] exists:", ok, "; alternative way:", x[0][4] != nil)
_, ok = x[0][4][9][9][9]
fmt.Println("x[0][4][9][9][9] exists:", ok, "; alternative way:", x[0][4][9][9][9] != nil)

输出：

map[0:map[9:map[3:map[]] 4:map[]]]

x[0][9][3] exists: true ; alternative way: true
x[0][9][4] exists: false ; alternative way: false
x[0][4] exists: true ; alternative way: true
x[0][4][9][9][9] exists: false ; alternative way: false

试穿这些衣服

---

注意：即使

x[0][4]

是最后一片“叶子”，像

x[0][4][9][9][9]

这样的索引也不会引起恐慌，因为

nil

映射可以被索引并产生值类型的零值（如果值类型是映射类型，则为

nil

。

如果您只执行

map[int]映射[int]…map[int]type

为什么要使用map？这最好通过

[[]..[]type

切片来处理，因为键未定义。只有map在尝试访问未定义的键时才会给出“非致命错误”。出于好奇，你在用这个做什么？是的，我在单词示例中显示：我有两个词：“帮助”“你好”，我可以得到一个地图是

m[h][e][l][p]=true

，另一个地图是

m[h][e][l][l][o]=true

。如果我尝试另一个键，例如

map[h][e]

结果必须是错误的，不是致命的错误。）这是我的错误，对不起……分层很重要！非常感谢！试着理解你的想法。）我不知道它是否工作正常，或者我是否添加了一些我不需要的东西，我写这篇文章的速度非常快。我认为这是一段相当难看的代码。我也不期望

map[0:map[9:map[3:map[]] 4:map[]]]

var ok bool
_, ok = x[0][9][3]
fmt.Println("x[0][9][3] exists:", ok, "; alternative way:", x[0][9][3] != nil)
_, ok = x[0][9][4]
fmt.Println("x[0][9][4] exists:", ok, "; alternative way:", x[0][9][4] != nil)
_, ok = x[0][4]
fmt.Println("x[0][4] exists:", ok, "; alternative way:", x[0][4] != nil)
_, ok = x[0][4][9][9][9]
fmt.Println("x[0][4][9][9][9] exists:", ok, "; alternative way:", x[0][4][9][9][9] != nil)

x[0][9][3] exists: true ; alternative way: true
x[0][9][4] exists: false ; alternative way: false
x[0][4] exists: true ; alternative way: true
x[0][4][9][9][9] exists: false ; alternative way: false