Maps : clés et valeurs

Une map est une table de hachage clé → valeur : map[K]V. Les cartes proviennent de référence : Basculez vers une fonction partageant le même stockage. Ils doivent être initialisés avant que vous puissiez leur écrire (avec make ou littéral).

Création

// 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

Opérations de 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

Virgule-ok : distinguer "manquant" de "valeur nulle"

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

C'est le seul moyen de savoir si une clé existe, car m["x"] renvoie la valeur zéro même si la clé n'est pas là. Modèle fondamental.

Itération : ordre aléatoire

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

Clés : types comparables uniquement

Les clés doivent être comparables : string, chiffres, bool, pointeurs, canaux, interfaces, tableaux de types comparables, structures de champs comparable. La tranche, la carte et la fonction ne sont pas comparables → elles ne le peuvent pas être des clés.

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

Modèle : compteurs

L'une des utilisations les plus courantes de la carte :

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}

Essayez-le vous-même

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

Récapitulatif

• map[K]V : clé-valeur, référence, basée sur un hachage.
• Initialiser avec make ou littéral ; carte nulle → panique à l'écriture.
• v, ok := m[k] est le seul moyen de distinguer « absent » de « valeur nulle ».
• delete(m, k) supprimer ; ok même si k n'existe pas.
• Itération range : ordre randomisé.
• Clés : types comparables uniquement (pas de slice/map/func).
• Modèle de compteur : freq[k]++ exploite la valeur zéro implicite.