Maps: key-value look-ups

Why maps?

With a slice you find items by position. Often you want to find them by a name instead: the price of "chai", the marks of roll number 23, the city for PIN code 411001. A map is a collection of key-value pairs where you look up a value by its key, very fast, even with millions of entries.

Creating and using a map

prices := map[string]int{
	"chai":   15,
	"samosa": 20,
}
prices["vada pav"] = 25        // add
prices["chai"] = 18            // update
delete(prices, "samosa")       // remove
fmt.Println(prices["chai"], len(prices)) // 18 2
fmt.Println(prices)            // map[chai:18 vada pav:25]

counts := make(map[string]int)  // an empty map, ready to use

Missing keys and "comma ok"

Reading a key that is not in the map does not crash. It gives the zero value of the value type: 0, "", false. That is handy for counting, but it means you cannot tell "price is 0" from "item not on the menu". The comma ok form answers that.

price, ok := prices["dosa"]
if !ok {
	fmt.Println("dosa is not on the menu")
} else {
	fmt.Println("dosa costs", price)
}

if p, ok := prices["chai"]; ok {
	fmt.Println("chai:", p)
}

Counting with a map

words := strings.Fields("chai samosa chai chai vada")
count := map[string]int{}
for _, w := range words {
	count[w]++   // missing keys start at 0
}
fmt.Println(count) // map[chai:3 samosa:1 vada:1]

Iteration order is random

for k, v := range m visits every pair, but the order is not specified and Go deliberately changes it between runs, so nobody relies on it. When you need a stable order (for a report or a test), collect the keys, sort them, then loop over the sorted keys.

keys := make([]string, 0, len(count))
for k := range count {
	keys = append(keys, k)
}
slices.Sort(keys)
for _, k := range keys {
	fmt.Println(k, count[k])
}
// Go 1.23+: keys := slices.Sorted(maps.Keys(count))

Three rules that cause crashes

• A nil map can be read but not written. var m map[string]int; m["a"] = 1 panics with "assignment to entry in nil map". Always create maps with make or a literal.
• Maps are not safe for concurrent use. If one goroutine writes while another reads or writes, Go may stop the program with "fatal error: concurrent map writes", which cannot be recovered. Protect the map with a sync.Mutex (module 6) or use sync.Map for special cases.
• Keys must be comparable with ==. Strings, numbers, bools, arrays and structs of those work; slices, maps and functions cannot be keys.

Maps share data

Like slices, a map value is a small reference to the real data. Passing a map to a function and changing it inside changes the caller's map too. Copy it (maps.Clone in Go 1.21+) if you need a separate version.

Maps of slices and of structs

byCity := map[string][]string{}
byCity["Pune"] = append(byCity["Pune"], "Asha")  // nil slice + append works
byCity["Pune"] = append(byCity["Pune"], "Ravi")
fmt.Println(byCity) // map[Pune:[Asha Ravi]]

type Stock struct{ Qty int }
stock := map[string]Stock{"rice": {Qty: 10}}
// stock["rice"].Qty--    // compile error: cannot assign to struct field in map
s := stock["rice"]
s.Qty--
stock["rice"] = s          // read, change, write back