Map: chiavi e valori

Una map è una tabella hash chiave→valore: map[K]V. Le map sono di riferimento: passate a una funzione condividono lo stesso storage. Vanno inizializzate prima di poterci scrivere (con make o letterale).

Creazione

// con letterale
prices := map[string]int{"pane": 2, "latte": 3}

// con make
counters := make(map[string]int)
counters["a"] = 1

// nil map (leggibile, NON scrivibile)
var m map[string]int
fmt.Println(m["x"])    // 0 — ok
// m["y"] = 1          // PANIC

Operazioni base

m := map[string]int{"a": 1}

m["b"] = 2              // insert/update
v := m["a"]             // get; se mancante: zero value
delete(m, "a")          // remove (ok anche se la chiave non esiste)
n := len(m)             // numero di entry

Comma-ok: distinguere "mancante" da "valore zero"

v, ok := m["x"]
if !ok {
    fmt.Println("chiave assente")
} else {
    fmt.Println("trovata:", v)
}

È l'unico modo per sapere se una chiave esiste, perché m["x"] ritorna lo zero value anche se la chiave non c'è. Pattern fondamentale.

Iterazione: ordine randomizzato

for k, v := range m {
    fmt.Println(k, v)
}

Chiavi: solo tipi comparable

Le chiavi devono essere comparable: string, numeri, bool, puntatori, channel, interfacce, array di tipi comparable, struct di campi comparable. Slice, map e function non sono comparable → non possono essere chiavi.

m := map[[2]int]string{}   // ok: array è comparable
// m := map[[]int]string{} // ERRORE: slice non è comparable

Pattern: contatori

Uno degli usi più comuni di map:

words := []string{"a", "b", "a", "c", "b", "a"}
freq := map[string]int{}
for _, w := range words {
    freq[w]++   // l'accesso a una chiave mancante è 0 → 0+1 = 1
}
// freq = {"a": 3, "b": 2, "c": 1}

Prova tu

var m map[string]int
m["a"] = 1

Recap

• map[K]V: chiave-valore, riferimento, hash-backed.
• Inizializza con make o letterale; nil map → panic in scrittura.
• v, ok := m[k] è l'unico modo per distinguere "assente" da "zero value".
• delete(m, k) rimuove; ok anche se k non esiste.
• Iterazione range: ordine randomizzato.
• Chiavi: solo tipi comparable (no slice/map/func).
• Pattern contatori: freq[k]++ sfrutta lo zero value implicito.