CODEWITHSUNDEEP
go
Parag
Parag

Reputation: 685

Go equivalent of Python's Dictionary

I am looking for a way to store multiple values for each key (just like we can in python using dictionary) using Go. Is there a way this can be achieved in Go?

Upvotes: 7

Views: 14532

Answers (2)

sberry
sberry

Reputation: 132018

Based on your response in comments I would suggest something like the following using a struct (though if you are only interested in a single value like name for each item in your slice then you could just use a map[int][]string{}

type Thing struct {
    name string
    age  int
}

myMap := map[int][]Thing{}

If you want to add things then you just do...

myMap[100] = append(myMap[100], Thing{"sberry": 37})

Or if you want to create it in place:

myMap := map[int][]Thing{
        100: []Thing{Thing{"sberry", 37}},
        2:   []Thing{Thing{"johndoe", 22}},
    }

EDIT: Adding a "nameIn" function based on comments as demo:

func nameIn(things []Thing, name string) bool {
    for _, thing := range things {
        if thing.name == name {
            return true
        }
    }
    return false
}

if nameIn(myMap[100], "John") {
    ...

If the slices are really big and speed is concern then you could keep a reverse lookup map like map[string]int where an entry would be John: 100, but you will need to most likely use some user defined functions to do your map modifications so it can change the reverse lookup as well. This also limits you by requiring unique names.

Most likely the nameIn would work just fine.

Upvotes: 9

captncraig
captncraig

Reputation: 23078

In go, the key/value collection is called a map. You create it with myMap := map[keyType]valType{}

Usually something like mapA := map[string]int{}. If you want to store multiple values per key, perhaps something like:

mapB := map[string][]string{} where each element is itself a slice of strings. You can then add members with something like:

mapB["foo"] = append(mapB["foo"], "fizzbuzz")

For a great read see Go maps in action

Upvotes: 5

Related Questions