Arrays, Slices y Maps de un Vistazo

Los arrays son valores de tamaño fijo; los slices y maps son colecciones similares a referencias integradas en el lenguaje.

La mayoría del código Go utiliza slices y maps a diario, por lo que len, cap y las reglas de compartición son importantes.

Resumen

Un array [N]T tiene el tamaño como parte del tipo.

Un slice []T es una cabecera (puntero, len, cap) sobre un array subyacente.

Un map map[K]V es una tabla hash con orden de iteración indefinido.

Los slices y maps se pasan copiando la cabecera, por lo que las mutaciones son visibles para los llamadores.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

package main
 
import "fmt"
 
func main() {
    nums := make([]int, 0, 4)
    nums = append(nums, 1, 2, 3)
 
    ages := map[string]int{"ada": 36}
    ages["grace"] = 34
 
    fmt.Println(nums, len(nums), cap(nums), ages)
}

Cuándo usar esto:

• Usa slices para secuencias ordenadas y crecientes.
• Usa maps para búsqueda por clave cuando las claves sean comparables.
• Usa arrays solo cuando el tamaño sea una restricción de protocolo fija (criptografía, embebidos).
• Preasigna con make([]T, 0, n) cuando conozcas el tamaño aproximado.

Ejemplo de Trabajo

package main
 
import "fmt"
 
func addSuffix(names []string, suffix string) {
    for i := range names {
        names[i] += suffix
    }
}
 
func main() {
    original := []string{"go", "rust"}
    view := original[0:2:2] // la expresión de slice completo limita la capacidad de crecimiento
    addSuffix(view, "!")
 
    counts := map[string]int{}
    for _, name := range original {
        counts[name]++
    }
 
    fmt.Println(original, counts)
 
    keys := make([]string, 0, len(counts))
    for k := range counts {
        keys = append(keys, k)
    }
    fmt.Println("claves (desordenadas):", keys)
}

Lo que esto demuestra:

• Las cabeceras de slice se copian pero comparten los arrays subyacentes; addSuffix muta original.
• La expresión de slice completo s[low:high:max] limita la capacidad de crecimiento de append.
• Los maps necesitan make o literales antes de escribir.
• La recolección de claves de map requiere un slice separado; el orden no es estable.

Profundización

Cómo Funciona

• append de slice aumenta la capacidad asignando un nuevo array cuando len == cap (típicamente duplicando).
• El slicing s[low:high] establece len a high-low y cap a cap(s)-low.
• Los buckets de map son internos; el orden de iteración se aleatoriza en cada pasada.
• Los arrays se asignan por valor (copia completa); los slices y maps asignan cabeceras (almacenamiento compartido).

Arrays vs Slices vs Maps

len y cap

Notas de Go

// Eliminar entrada de map
delete(m, key)
 
// Limpiar map en Go 1.21+
clear(m)
 
// Copiar slices
dst := make([]int, len(src))
copy(dst, src)

Trampas

• Sorpresa del alias de append - a := []int{1,2,3}; b := a[:2]; append(b, 99) puede sobrescribir a[2] si la capacidad lo permite. Solución: usa slice completo a[:2:2] o append a una copia.
• Escritura en map nil - La asignación a un map no inicializado falla. Solución: make primero.
• Esperar iteración de map ordenada - El orden cambia entre bucles. Solución: ordena el slice de claves antes de mostrar.
• Usar array como sustituto de slice - [5]int no es []int sin hacer slice arr[:]. Solución: haz slice con [:].
• Copias de arrays grandes - Pasar arrays grandes copia todos los elementos. Solución: pasa un puntero *[N]T o usa un slice.
• Escrituras concurrentes en maps - Los maps no son seguros para escrituras concurrentes sin sincronización. Solución: sync.Map o mutex.

Alternativas

Preguntas Frecuentes

v, ok := m[key]
if !ok { /* falta */ }

Relacionado

• Valores Cero e Inicialización - maps y slices nil
• Punteros y el Operador de Dirección - Compartir a través de cabeceras de slice
• Tipos Numéricos, Strings, Runes y Slices de Bytes - []byte como slices de bytes
• Structs, Embebido y Promoción de Campos - Structs que contienen slices y maps

Enlaces Externos Relacionados

• A Tour of Go - Introducción interactiva oficial a Go.
• Go by Example - Ejemplos de código prácticos anotados.
• Effective Go - Guía oficial para escribir Go claro e idiomático.
• The Go Programming Language (ebook) - Donovan & Kernighan.
• Learning Go (2nd Edition) - Jon Bodner.

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado GC Green Tea, modernizadores go fix - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación) y golangci-lint (última - verificar conjunto de linters en la compilación). WTI5a1pXZDFhV1JsY3k1cGIzeGpaMmx2TkRJMmZESXdNall3Tnc9PQ==