Dominar el manejo de colecciones es fundamental en cualquier lenguaje de programación, y en Go existen dos estructuras esenciales para trabajar con listas de datos: los arrays y los slices. Comprender sus diferencias, cómo acceder a sus elementos y cómo agregar nuevos valores te permitirá escribir código más eficiente y flexible.
¿Qué diferencia a un array de un slice en Go?
Un array en Go es una estructura de tamaño fijo e inmutable en cuanto a su dimensión. Se declara indicando la cantidad máxima de elementos entre corchetes junto al tipo de dato [0:10]:
go
var array [4]int
fmt.Println(array)
Al ejecutar este código, se imprime [0 0 0 0], ya que el zero value del tipo int es cero. No es posible agregar más elementos, pero sí editar los valores existentes por índice [0:38]:
go
array[0] = 1
array[1] = 2
fmt.Println(array) // [1 2 0 0]
Dos funciones clave para arrays y slices son len y cap [1:12]:
len(array): devuelve cuántos elementos contiene.cap(array): indica la capacidad máxima.
En el caso de un array de cuatro posiciones, ambas funciones retornan 4.
Un slice, en cambio, se declara sin especificar la cantidad de elementos, lo que lo convierte en una estructura mutable [1:35]:
go
slice := []int{0, 1, 2, 3, 4, 5, 6}
fmt.Println(slice)
fmt.Println(len(slice)) // 7
fmt.Println(cap(slice)) // 7
¿Cómo funciona el slicing para acceder a elementos?
El slicing es la técnica que permite interactuar con rangos específicos de elementos dentro de un array o un slice [2:10]. Existen varias formas de aplicarlo:
go
fmt.Println(slice[0]) // Elemento en índice 0 → 0
fmt.Println(slice[:3]) // Desde el inicio hasta índice 3 (exclusivo) → [0 1 2]
fmt.Println(slice[2:4]) // Desde índice 2 (inclusivo) hasta 4 (exclusivo) → [2 3]
fmt.Println(slice[4:]) // Desde índice 4 (inclusivo) en adelante → [4 5 6]
La regla fundamental es sencilla:
- El primer número del rango es inclusivo: ese índice sí se incluye.
- El segundo número es exclusivo: ese índice no aparece en el resultado.
Por ejemplo, slice[2:4] imprime los índices 2 y 3, pero no el 4 [2:52]. Tener esto claro evita errores comunes al manipular colecciones.
¿Cómo agregar elementos a un slice con append?
Dado que los slices son mutables, puedes añadir elementos con la función append [3:38].
¿Cómo agregar un elemento individual?
go
slice = append(slice, 7)
fmt.Println(slice) // [0 1 2 3 4 5 6 7]
La función recibe el slice original y el nuevo valor, retornando un slice actualizado.
¿Cómo agregar otra lista completa?
Cuando necesitas combinar dos slices, se utiliza el operador de tres puntos (...) para descomponer el segundo slice en elementos individuales [4:07]:
go
newSlice := []int{8, 9, 10}
slice = append(slice, newSlice...)
fmt.Println(slice) // [0 1 2 3 4 5 6 7 8 9 10]
Esos tres puntos funcionan como un spread operator: en lugar de insertar una lista dentro de otra, extraen cada elemento y los agregan de forma independiente. Es equivalente a escribir append(slice, 8, 9, 10) manualmente.
¿Cuándo usar arrays y cuándo slices?
- Usa arrays cuando la cantidad de elementos es conocida y no cambiará. Su inmutabilidad los hace más eficientes a nivel de rendimiento.
- Usa slices cuando necesites flexibilidad para agregar o modificar la cantidad de elementos en tiempo de ejecución.
Ahora que conoces cómo declarar, acceder y modificar estas estructuras, el siguiente paso natural es aprender a recorrer sus elementos con el keyword range. ¿Qué estructura utilizas más en tus proyectos con Go?
