Como os maps funcionam em Go?

Question

Accepted Answer

Um **map** é a tabela de hash built-in do Go — uma coleção desordenada de **pares chave-valor** com busca O(1) em média. É a forma padrão de associar chaves a valores.

## Criando e usando 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
```

## O idiom comma-ok — distinguindo "faltante" de "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
}
```

Isso é essencial: acessar uma chave faltante retorna o valor zero do tipo (0, "", nil), então você **não consegue dizer** "chave ausente" de "chave presente com valor zero" apenas pelo valor — o boolean `, ok` desambigua.

## Iterando (a ordem é ALEATÓRIA)

```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 deliberadamente randomiza a ordem de iteração de maps (para evitar que o código dependa disso) — se você precisar de iteração ordenada, ordene as chaves você mesmo.

## A armadilha do map 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)
```

Um map nil pode ser lido mas **entra em pânico ao escrever** — você deve `make()` (ou usar um literal) antes de armazenar.

## As chaves devem ser comparáveis

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

## Por que isso importa

Maps são uma estrutura de dados Go fundamental e constantemente usada para associações chave-valor e buscas rápidas (caches, índices, contagem, agrupamento).

Vários comportamentos são essenciais de conhecer e são fontes comuns de bugs: o **idiom comma-ok** (a única forma confiável de verificar a existência de uma chave, já que uma chave faltante retorna o valor zero), a **ordem de iteração randomizada** (nunca dependa disso — ordene as chaves para saída ordenada), e o **pânico de escrita do map nil** (sempre inicialize antes de escrever).

Entender esses — além de que chaves devem ser tipos comparáveis — é necessário para Go correto no dia a dia e reflete o tipo de detalhe prático que distingue desenvolvedores Go sólidos e frequentemente aparece em entrevistas.