dictionary - 戈朗 : How to create unknown (dynamic) Map length

Question

我可以通过

创建一个“静态” map

type m map[int]map[int]map[int]bool

但是“键”的长度是动态的:

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

或

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

如何在 Go 中创建此 map ？或者存在任何方式？

补充:分层重要

提前致谢!

Answer 1

map type :

A map is an unordered group of elements of one type, called the element type, indexed by a set of unique keys of another type, called the key type.

映射类型必须具有特定的值类型和特定的键类型。你想要的不符合这个条件:你想要一个 map ，其中的值是有时另一个 map (相同类型)，有时它是一个bool.

您的选择:

1。使用包装器值类型

这里的想法是不要只使用一个简单的 (bool) 值类型，而是使用一个包装器来保存您的两个潜在值:map 和简单的值(bool):

type Value struct {
    Children MapType
    V        bool
}

type MapType map[int]*Value

var m MapType

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

2。有一棵树

这是 #1 的变体，但通过这种方式我们清楚地表明它是一棵树。

实现层次结构的最简洁的方法是使用树，其中的节点可能如下所示:

type KeyType int
type ValueType string

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

这样做的好处是您可以选择值类型(在您的情况下为 bool，但您可以将其更改为任何类型 - 我使用 string 进行演示).

为了轻松构建/管理您的树，我们可以向我们的 Node 类型添加一些方法:

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

输出(在 Go Playground 上尝试):

&{map[0:0x104382f0] root}
&{map[] third}
&{map[] fourth}
&{map[] fourthMod}

3。使用递归类型定义

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

type X map[int]X

如其名:它是一个带有 int 键的 map，以及与 map 本身类型相同的值。

这种递归类型的一大缺点是它不能在值类型中存储任何“有用”的数据。它只能存储“事实”是否存在与 bool 类信息相同的值(bool 类型:true 或 false)，这在极少数情况下可能就足够了，但在大多数情况下都不够。

让我们看一个构建“树”的例子:

var x X
x = map[int]X{}
x[0] = map[int]X{}
x[0][9] = map[int]X{}
x[0][9][3] = map[int]X{}
x[0][4] = map[int]X{}
fmt.Println(x)

输出:

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

如果我们想测试是否存在基于一系列键的“值”，我们有两个选择:要么使用特殊的 v, ok := m[i] 索引(报告指定键的值是否存在)，或测试该值是否不是 nil，例如m[i] != nil.

让我们看一些测试上面构建的 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

在 Go Playground 上试试这些.

注意:即使 x[0][4] 是最后的“叶子”，索引更像 x[0][4][9 ][9][9] 不会导致 panic ，因为 nil 映射可以被索引并产生值类型的零值(即 nil如果值类型是映射类型)。