Come funzionano le mappe in Go?

Question

Accepted Answer

Una **map** è la tabella hash integrata di Go — una collezione non ordinata di **coppie chiave-valore** con lookup O(1) in media. È il modo standard per associare chiavi a valori.

## Creazione e utilizzo delle mappe

```go
// create with make
ages := make(map[string]int)    // map from string keys to int values
ages["Ann"] = 30                 // set
age := ages["Ann"]               // get → 30

// or with a literal
scores := map[string]int{
    "math":    90,
    "science": 85,
}

delete(scores, "math")           // remove a key
len(scores)                       // number of entries
```

## L'idioma comma-ok — distinguere "assente" da "zero"

```go
// ⚠️ a missing key returns the ZERO VALUE, not an error
value := scores["missing"]       // 0 — but was it stored as 0, or absent? Ambiguous!

// ✅ the comma-ok form tells you if the key EXISTS
value, ok := scores["missing"]
if ok {
    fmt.Println("found:", value)
} else {
    fmt.Println("not present")    // key doesn't exist
}
```

Questo è essenziale: accedere a una chiave assente restituisce il valore zero del tipo (0, "", nil), quindi **non è possibile distinguere** "chiave assente" da "chiave presente con valore zero" dal solo valore — il booleano `, ok` disambigua.

## Iterazione (l'ordine è CASUALE)

```go
for key, value := range scores {
    fmt.Println(key, value)
}
// ⚠️ iteration order is RANDOMIZED — never rely on map order!
// To iterate in order: collect keys into a slice, sort it, then iterate.
```

Go deliberatamente randomizza l'ordine di iterazione delle mappe (per prevenire che il codice dipenda da esso) — se hai bisogno di iterazione ordinata, ordina tu stesso le chiavi.

## La trappola della mappa nil

```go
var m map[string]int        // nil map (declared but not initialized)
v := m["x"]                 // ✅ reading is OK → 0
m["x"] = 1                  // 💥 PANIC: assignment to entry in nil map
// must initialize first: m = make(map[string]int)
```

Una mappa nil può essere letta ma **genera panic in scrittura** — devi `make()` (o usare un letterale) prima di archiviare.

## Le chiavi devono essere confrontabili

```text
Valid keys: comparable types (string, int, bool, structs of comparable fields, pointers)
Invalid keys: slices, maps, functions (not comparable) → compile error
```

## Perché è importante

Le mappe sono una struttura dati Go fondamentale e costantemente utilizzata per associazioni chiave-valore e lookup veloci (cache, indici, conteggio, raggruppamento).

Diversi comportamenti sono essenziali da conoscere e sono fonti comuni di bug: l'**idioma comma-ok** (l'unico modo affidabile per verificare l'esistenza della chiave, poiché una chiave assente restituisce il valore zero), l'**ordine di iterazione randomizzato** (non dipendere mai da esso — ordina le chiavi per output ordinato), e il **panic di scrittura della mappa nil** (sempre inizializzare prima di scrivere).

Comprendere questi aspetti — più il fatto che le chiavi devono essere tipi confrontabili — è necessario per un Go corretto quotidiano e riflette il tipo di dettaglio pratico che distingue gli sviluppatori Go solidi e appare frequentemente nei colloqui.