Comment fonctionnent les maps en Go ?

Question

Accepted Answer

Un **map** est la table de hachage intégrée de Go — une collection non ordonnée de **paires clé-valeur** avec une recherche moyenne en O(1). C'est le moyen standard d'associer des clés à des valeurs.

## Creating and using maps

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

## The comma-ok idiom — distinguishing "missing" from "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
}
```

C'est essentiel : accéder à une clé manquante retourne la valeur zéro du type (0, "", nil), vous **ne pouvez pas distinguer** « clé absente » de « clé présente avec valeur zéro » par la seule valeur — le booléen `, ok` lève l'ambiguïté.

## Iterating (order is RANDOM)

```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 randomise délibérément l'ordre d'itération des maps (pour empêcher le code d'en dépendre) — si vous avez besoin d'une itération ordonnée, triez vous-même les clés.

## The nil map trap

```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)
```

Une map nil peut être lue mais **panique à l'écriture** — vous devez la créer avec `make()` (ou un littéral) avant de stocker.

## Keys must be comparable

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

## Pourquoi c'est important

Les maps sont une structure de données Go fondamentale et constamment utilisée pour les associations clé-valeur et les recherches rapides (caches, index, comptage, regroupement).

Plusieurs comportements sont essentiels à connaître et sont des sources courantes d'erreurs : l'**idiome comma-ok** (le seul moyen fiable de vérifier l'existence d'une clé, puisqu'une clé manquante retourne la valeur zéro), l'**ordre d'itération randomisé** (ne jamais compter dessus — triez les clés pour une sortie ordonnée), et la **panique d'écriture sur map nil** (toujours initialiser avant d'écrire).

Comprendre cela — plus le fait que les clés doivent être des types comparables — est nécessaire pour un Go correct au quotidien et reflète le type de détail pratique qui distingue les développeurs Go solides et apparaît fréquemment aux entretiens.