08 — Maps

func iteration() {
    m := map[string]int{"a": 1, "b": 2, "c": 3, "d": 4}

    // Iteration order is RANDOMIZED (intentionally — prevents code
    // from depending on order, which would break on different Go versions):
    for k, v := range m {
        fmt.Println(k, v)  // order varies each run
    }

    // Ordered iteration — extract and sort keys:
    keys := make([]string, 0, len(m))
    for k := range m {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Println(k, m[k])  // deterministic: a, b, c, d
    }

    // Safe deletion during iteration:
    for k := range m {
        delete(m, k)  // ✅ safe — Go explicitly allows this
    }
    fmt.Println(len(m))  // 0

    // ⚠️ Adding keys during iteration is UNspecified:
    // new keys may or may not be iterated — don't rely on this behavior
}

💡 Tips & Tricks

• Performance: make(map[K]V, hint) pre-allocates buckets when you know the approximate size — avoids the incremental growth/rehashing phase. The hint is not a limit; the map grows as needed.
• Safety: never use a plain map across goroutines — concurrent writes cause a fatal (unrecoverable) error. Use sync.RWMutex + map for the general case, sync.Map for write-rarely/read-many.
• Idiom: use struct keys for compound keys — map[struct{ X, Y int }]Cell is cleaner and faster (one hash lookup) than nested maps map[int]map[int]Cell (two lookups).
• Idiom: the comma-ok idiom (v, ok := m[key]) is essential when the zero value is a valid stored value — m["missing"] returns 0, indistinguishable from a stored 0. Always use comma-ok when absence is meaningful.
• Performance: store *Struct in maps when you need to mutate fields — map values aren't addressable, so map[int]Struct requires copy-out/modify/assign-back for each field update. map[int]*Struct allows in-place mutation.
• Idiom: clear a map with clear(m) (Go 1.21+) — deletes all entries in one call. Faster than re-allocating with m = make(map[K]V), and keeps the same underlying buckets.

⚠️ Edge Cases & Gotchas

• Writing to nil map panics: var m map[string]int; m["a"] = 1 → panic: assignment to entry in nil map. Always make or use a literal.
• Reading nil map returns zero value: var m map[string]int; v := m["a"] → 0 (no panic). Can mask uninitialized-map bugs.
• Concurrent map access is fatal: not a recoverable panic — the program crashes. The runtime detects concurrent writes and aborts immediately.
• Map values are not addressable: &m["a"] is illegal (entries can move during rehashing). Copy out, modify, assign back — or store *Struct.
• m[key].field = value is a compile error: can't take the address of a map value. Use the copy-out pattern or store pointers.
• Map iteration order is randomized: never depend on iteration order — it changes between runs. Sort keys for stable output.
• Deleting during iteration is safe: for k := range m { delete(m, k) } is explicitly allowed. Adding keys during iteration is unspecified.
• Slices, maps, functions can't be keys: they're not comparable. Use a string or struct representation as the key.
• clear(m) (Go 1.21+): deletes all entries but keeps the map allocated (buckets retained). m = make(map[K]V) creates a new map (old GC'd). clear is faster if you'll reuse the map.
• make(map, hint) hint is not exact: the actual bucket count is the next power of 2 ≥ hint. make(map[K]V, 100) → 128 buckets.
• Pointer keys compare by address, not value: map[*int]string — two &x and &y where x == y are different keys (different addresses). Use int as the key, not *int.

🧠 Quick Quiz

m := map[string]*int{}
x := 1
y := 1
m["a"] = &x
m["b"] = &y
fmt.Println(*m["a"] == *m["b"])
fmt.Println(m["a"] == m["b"])