Un map en Go es una implementación de una tabla hash que asocia claves de tipo K con valores de tipo V. Para que esto sea posible, el tipo de la clave debe ser comparable, es decir, debe poder evaluarse mediante el operador ==. Esto incluye tipos básicos como int, string o bool, e incluso structs siempre que todos sus campos también sean comparables. El motor de Go utiliza una función de hash para transformar la clave en un índice, lo que permite que el acceso a un elemento —ya sea para leer, escribir o eliminar— tenga una complejidad promedio de $O(1)$.
Debes usar un mapa cuando necesites una estructura de búsqueda rápida por una clave única y no te importe el orden de los elementos (la iteración sobre un mapa no es determinista). Es fundamental entender que el valor por defecto de un mapa es nil. Si intentas escribir en un mapa nil, el programa sufrirá un panic y se detendrá abruptamente. Sin embargo, un mapa nil es perfectamente seguro para la lectura: si buscas una clave que no existe en un mapa nil, Go simplemente te devolverá el valor cero del tipo de valor sin errores.
package main
import "fmt"
func main() {
// Inicialización mediante make: reserva memoria para la tabla hash.
// Es la forma estándar de crear un mapa listo para recibir datos.
usuarios := make(map[int]string)
// Asignación directa de claves y valores.
usuarios[101] = "Alice"
usuarios[102] = "Bob"
usuarios[103] = "Charlie"
// Uso de un literal para inicialización rápida con datos conocidos.
config := map[string]bool{
"debug": true,
"verbose": false,
}
// La "coma-ok idiom" es la forma correcta de verificar existencia.
// El segundo valor (ok) es un booleano que confirma si la clave está presente.
id := 102
if nombre, ok := usuarios[id]; ok {
fmt.Printf("Encontrado: ID %d -> %s\n", id, nombre)
}
// Eliminar una clave. Si la clave no existe, delete no hace nada y no lanza error.
delete(usuarios, 101)
// len() devuelve la cantidad de entradas presentes en el mapa.
fmt.Printf("Total usuarios: %d\n", len(usuarios))
fmt.Printf("Configuración activa: %v\n", config)
// Iteración sobre el mapa para recorrer todas las entradas.
fmt.Print("Lista de usuarios: ")
for id, nombre := range usuarios {
fmt.Printf("[%d:%s] ", id, nombre)
}
fmt.Println()
// Demostración de lectura en un mapa nil (seguro).
var mapaNil mapstringint
fmt.Printf("Lectura en nil (valor cero): %d\n", mapaNil["cualquier_clave"])
}
En el código anterior, observa cómo make(map[int]string) es crucial para que usuarios sea un mapa operativo; sin make o un literal, usuarios sería nil y la asignación usuarios[101] = "Alice" causaría un error crítico.
Cuando realizas la comprobación nombre, ok := usuarios[id], estás utilizando una técnica esencial en Go para distinguir entre un valor que existe (pero es el valor cero, como 0 o "") y una clave que simplemente no está en el mapa. Si usaras solo nombre := usuarios[id], no podrías saber si Alice es realmente un usuario con ID 101 o si el 0 que recibes es el valor por defecto de un entero.
La función delete es extremadamente segura: si intentas ejecutar delete(usuarios, 999) y la clave 999 no existe, el runtime simplemente ignora la operación, permitiéndote escribir lógica de limpieza sin necesidad de verificar la existencia previa. Finalmente, nota que al iterar con range, los valores se procesan de forma eficiente, pero recuerda que el orden de impresión de los usuarios cambiará cada vez que ejecutes el programa debido a la naturaleza interna de las tablas hash.
El error frecuente
El error más común en entornos de producción es intentar inicializar un mapa mediante la declaración de su tipo sin asignar una instancia, intentando escribir en él posteriormente.
// ERROR: El mapa se declara pero su valor es nil var m map[string]int // Esto causará un panic: assignment to entry in nil map m["clave"] = 10
Para evitar esto, siempre inicializa tus mapas con make o mediante un literal {} si conoces los valores iniciales.
N° 52