09 Arrays y Slices en Go

🧠 Introducción

En Go, los arrays y slices son estructuras fundamentales para almacenar colecciones de datos. Aunque pueden parecer similares, tienen diferencias importantes en cuanto a tamaño, flexibilidad y comportamiento. Vamos a ver en qué se diferencian y cómo usarlos correctamente.

1. 🔢 Arrays: Tamaño Fijo

Un array es una colección de elementos del mismo tipo con tamaño fijo. Una vez creado, su tamaño no puede cambiar.

🧱 Definición:

var nums [4]int
fmt.Println(nums) // [0 0 0 0]

• Los arrays tienen valores por defecto (0 en enteros, "" en strings, etc.).

✅ Inicialización:

nums := [4]int{1, 2, 3, 4}
fmt.Println(nums) // [1 2 3 4]

🔍 Acceso y modificación:

fmt.Println(nums[0]) // 1
nums[1] = 10
fmt.Println(nums)    // [1 10 3 4]

📏 Longitud:

fmt.Println(len(nums)) // 4

2. 📐 Arrays Multidimensionales

Puedes crear arrays de múltiples dimensiones como tablas o matrices.

var matriz [3][3]int
matriz[0][0] = 1
matriz[1][1] = 2
matriz[2][2] = 3
fmt.Println(matriz)

Resultado:

[[1 0 0]
 [0 2 0]
 [0 0 3]]

3. 🌊 Slices: Flexibilidad Total

Un slice es como un array dinámico: su tamaño puede crecer o reducirse.

🔨 Crear un slice con make:

s := make([]int, 5)
fmt.Println(s) // [0 0 0 0 0]

🔄 Crear un slice desde un array:

arr := [5]int{1, 2, 3, 4, 5}
s := arr[:3]
fmt.Println(s) // [1 2 3]

4. ➕ Agregar elementos con append

s := []int{1, 2, 3}
s = append(s, 4, 5)
fmt.Println(s) // [1 2 3 4 5]

5. 📊 Propiedades de un slice

Todo slice tiene:

• Puntero al array base.
• Longitud (len): número de elementos.
• Capacidad (cap): espacio total disponible sin crear un nuevo array.

s := make([]int, 5)
fmt.Println(len(s)) // 5
fmt.Println(cap(s)) // 5

s = append(s, 6)
fmt.Println(len(s)) // 6
fmt.Println(cap(s)) // 10 (duplicado)

6. 🪞 Asignación: Cuidado con las referencias

Si asignas un slice a otro, comparten el mismo array.

s1 := []int{1, 2, 3}
s2 := s1
s2[0] = 99
fmt.Println(s1) // [99 2 3]
fmt.Println(s2) // [99 2 3]

7. 🧠 Nuevos arrays al exceder capacidad

Cuando usas append y superas la capacidad, Go crea un nuevo array automáticamente.

s1 := make([]int, 3)
s1[0], s1[1], s1[2] = 1, 2, 3
s2 := append(s1, 4)

s2[0] = 99
fmt.Println(s1) // [1 2 3]
fmt.Println(s2) // [99 2 3 4]

8. 🧹 Slices y el Garbage Collector

Go libera automáticamente la memoria de los arrays que ya no están referenciados, lo cual optimiza el uso de recursos.

✅ Conclusión

• Arrays: tamaño fijo, útiles para datos estáticos.
• Slices: flexibles, pueden crecer dinámicamente y son los más usados en la práctica.
• Go gestiona la capacidad de los slices automáticamente.
• Cuidado con las referencias: dos slices pueden compartir el mismo array base.

🛠️ Práctica recomendada

1. Crea un array de 5 enteros e imprímelo.
2. Usa un slice para almacenar los primeros 3 elementos de ese array.
3. Modifica un valor en el slice y observa si afecta al array original.
4. Crea un slice con make() y usa append() para agregar más de 10 elementos.
5. Imprime la longitud y capacidad del slice después de cada append().

🚀 Siguientes pasos

Ahora que dominas arrays y slices, te sugiero continuar con:

• 🧱 Structs en Go: Cómo agrupar diferentes tipos de datos en un solo tipo.
• 🔄 Maps: Colecciones clave-valor.
• 🧠 Funciones avanzadas con slices: Pasar slices a funciones, modificar en funciones, y retornarlos.