Nested maps in Golang

Question

func main() {
    var data = map[string]string{}
    data["a"] = "x"
    data["b"] = "x"
    data["c"] = "x"
    fmt.Println(data)
}

It runs.

func main() {
    var data = map[string][]string{}
    data["a"] = append(data["a"], "x")
    data["b"] = append(data["b"], "x")
    data["c"] = append(data["c"], "x")
    fmt.Println(data)
}

It also runs.

func main() {
    var w = map[string]string{}
    var data = map[string]map[string]string{}
    w["w"] = "x"
    data["a"] = w
    data["b"] = w
    data["c"] = w
    fmt.Println(data)
}

It runs again!

func main() {
    var data = map[string]map[string]string{}
    data["a"]["w"] = "x"
    data["b"]["w"] = "x"
    data["c"]["w"] = "x"
    fmt.Println(data)
}

But it fails!?

Is there a problem with nested maps in Go? Or is there no multiple bracket support for nested maps?

icza · Accepted Answer · 2018-02-02T09:04:53.190

The zero value for map types is nil. It is not yet initialized. You cannot store values in a nil map, that's a runtime panic.

In your last example you initialize the (outer) data map, but it has no entries. When you index it like data["a"], since there is no entry with "a" key in it yet, indexing it returns the zero value of the value type which is nil for maps. So attempting to assign to data["a"]["w"] is a runtime panic.

You have to initialize a map first before storing elements in it, for example:

var data = map[string]map[string]string{}

data["a"] = map[string]string{}
data["b"] = make(map[string]string)
data["c"] = make(map[string]string)

data["a"]["w"] = "x"
data["b"]["w"] = "x"
data["c"]["w"] = "x"
fmt.Println(data)

Output (try it on the Go Playground):

map[a:map[w:x] b:map[w:x] c:map[w:x]]

Note that when you declare a variable of map type and initialize it with a composite literal (as in var data = map[string]string{}), that also counts as initializing.

Note that you may also initialize your nested maps with a composite literal:

var data = map[string]map[string]string{
    "a": map[string]string{},
    "b": map[string]string{},
    "c": map[string]string{},
}

data["a"]["w"] = "x"
data["b"]["w"] = "x"
data["c"]["w"] = "x"
fmt.Println(data)

Output is the same. Try it on the Go Playground.

I realized i was coding golang with php habits :) It's hard to get used to coding in full type-safe. But i like it, thanks you so much for your answer. — Özgür Yalçın, Jun 01 '17 at 11:09
In the case that the map is being populated iteratively, you can check for a nil value prior to assignment: `if data["c"] == nil { data["c"] = map[string]string{}}` This helps avoid losing data from your map. — J0hnG4lt, Sep 01 '17 at 16:30

score 17 · Answer 2 · edited May 14 '19 at 21:09

While the most straightforward answer to this question is to initialize your nested maps as previously described, there is another potential option depending on your access pattern. If you need a truly hierarchical system of maps, then the previous answers are just fine. However, if you simply need to look up values in the map using multiple facets, read on!

It is totally acceptable for maps to use structs as keys (in fact, anything that is comparable can be used). Thus, you can use a single map with struct keys like this example from the Golang blog, which is a hit counter that tracks page hits by country:

type Key struct {
  Path, Country string
}

hits := make(map[Key]int)

// set: Vietnamese person visiting the home page
hits[Key{"/", "vn"}]++

// get: see how many Chinese persons read the spec
n := hits[Key{"/ref/spec", "cn"}]

I don't see maps like this often enough, instead many people reach for the nested variant first, which I think may not always be the right fit.

Excellent answer! While it doesn't answer the question as state, it actually offers a solution that's much more robust without the risk of panic on uninitialized entries. — Jean Spector, Nov 01 '21 at 13:02

Vladimir Filin · Answer 3 · 2018-12-05T12:40:03.737

In addition to icza's answer. Map initialization can be written in short form:

var data = map[string]map[string]string{
    "a": map[string]string{
        "w": "x"},
    "b": map[string]string{
        "w": "x"},
    "c": map[string]string{
        "w": "x"},
    "d": map[string]string{},
}
fmt.Println(data)

Output is the same. Try it on the Go Playground. The key "d" added to demonstrate the mapping with an empty map.

score 2 · Answer 4 · answered Dec 11 '20 at 15:28

The below solution might be useful for you.

var data = map[string]interface{}{
        "publishInfo": map[string]interface{}{
            "title":       publishInfo.Title,
            "description": publishInfo.Desc,
            "thumbnail":   publishInfo.ImageSrc,
            "url":         publishInfo.URL,
            "tags":        publishInfo.Tags,
        },
        "revision": draftInfo.Revision,
    }

Nested maps in Golang

4 Answers4

Linked

Related