¿Cómo funcionan los maps en Go?

Question

Accepted Answer

Un **map** es la tabla hash incorporada de Go — una colección desordenada de **pares clave-valor** con búsqueda promedio O(1). Es la forma estándar de asociar claves con valores.

## Crear y usar 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
```

## El idioma coma-ok — distinguir "faltante" de "cero"

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

Esto es esencial: acceder a una clave faltante devuelve el valor cero del tipo de valor (0, "", nil), por lo que **no puedes distinguir** "clave ausente" de "clave presente con valor cero" solo por el valor — el booleano `, ok` lo aclara.

## Iteración (el orden es ALEATORIO)

```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 aleatoriza el orden de iteración de maps (para evitar que el código dependa de él) — si necesitas iteración ordenada, ordena las claves tú mismo.

## La trampa del map nulo

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

Un map nulo se puede leer pero **entra en pánico al escribir** — debes `make()` (o usar un literal) antes de almacenar.

## Las claves deben ser comparables

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

## Por qué es importante

Los maps son una estructura de datos Go fundamental y constantemente utilizada para asociaciones clave-valor y búsquedas rápidas (cachés, índices, conteos, agrupaciones).

Varios comportamientos son esenciales conocer y son fuentes comunes de errores: el **idioma coma-ok** (la única forma confiable de verificar la existencia de clave, ya que una clave faltante devuelve el valor cero), el **orden de iteración aleatorio** (nunca dependas de él — ordena claves para salida ordenada), y el **pánico de escritura en map nulo** (siempre inicializa antes de escribir).

Comprender estos elementos — más que las claves deben ser tipos comparables — es necesario para Go correcto diario y refleja el tipo de detalle práctico que distingue a los desarrolladores de Go sólidos y aparece frecuentemente en entrevistas.