Question

我可以创建一个＆＃34;静态＆＃34;地图通过

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

但是＆＃34;键的长度＆＃34;将是动态的：

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

或

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

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

已添加：分层重要

提前致谢！

Answer 1

map type：

map是一种无序的一组元素，称为元素类型，由一组另一种类型的唯一键索引，称为键类型。

地图类型必须具有特定的值类型和特定的键类型。您想要的不符合以下条件：您想要一个地图，其中值有时另一个地图（相同类型），有时它＆＃39; sa {{ 1}}。

您的选择：

1。使用包装器值类型

这里的想法是不使用简单的（bool）值类型，而是使用包含两个潜在值的包装器：bool和简单值（{{1} }）：

map

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

2。有一棵树

这是＃1的变体，但这样我们清楚地传达它是一棵树。

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

bool

这样做的好处是您可以选择值类型（在您的情况下为type Value struct { Children MapType V bool } type MapType map[int]*Value var m MapType，但您可以将其更改为任何类型 - 我使用type KeyType int type ValueType string type Node struct { Children map[KeyType]*Node Value ValueType }进行演示）。

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

string

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

Node

输出（在Go Playground上尝试）：

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
}

3。使用递归类型定义

可能会令人惊讶，但可以使用递归定义在Go中定义具有无限或动态＆＃34;深度＆＃34;的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))类型：

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

它的含义是：map带有type X map[int]X个键，以及与地图本身相同类型的值。

这种递归类型的一个重大缺点是，它无法存储任何有用的＆＃34;值类型中的数据。它只能存储＆＃34;事实＆＃34;是否存在与map类似的信息（int类型：bool或bool）相同的值，这在极少数情况下可能已足够，但不在最

让我们看一个构建＆＃34;树的示例＆＃34;：

true

输出：

false

如果我们想测试是否有＆＃34;值＆＃34;基于一系列键，我们有两个选项：使用特殊的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

在Go Playground上尝试这些。

注意：即使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)是最后一个＆＃34; leaf＆＃34;，像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这样进一步索引也不会导致恐慌{{1}可以对map进行索引并生成值类型的零值（如果值类型是映射类型，则为x[0][4]。）

Answer 2

好的，我玩这个有点好玩。这是一个比我之前做得更好的实现：

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
}

Playground link

这样的事情应该让你开始

Answer 3

如果您不需要分层地图结构并且只想使用可变长度的键，则可以简单地使用字符串作为键和单个映射。

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

m[k] = true

fmt.Println(m[k])

Answer 4

你不能这样做，因为这种类型在Go的类型系统中无法表示。

你必须重新设计。

E.g。带有方法arbitrarilyKeyedMap的类型lookup(vals ...int) bool。可能你也需要设置和删除的方法。

Golang：如何创建未知（动态）Map长度

4 个答案:

1。使用包装器值类型

2。有一棵树

3。使用递归类型定义