Un array tiene un tamaño fijo que es parte de su tipo; un slice es una vista flexible y de tamaño dinámico de un array subyacente. En la práctica casi siempre usas slices — los arrays son raros en el Go cotidiano.
arr []
arr[] =
fmt.Println((arr))
El tamaño del array es fijo en tiempo de compilación y es parte de su tipo ([5]int ≠ [3]int). Los arrays también son tipos por valor — asignar o pasar uno copia el array completo. Esta rigidez es por qué rara vez se usan directamente.
s := []int{1, 2, 3} // a slice (no size in the brackets)
s = append(s, 4) // grow it — append returns a new slice
fmt.Println(len(s), cap(s)) // length and capacity
nums := make([]int, 0, 10) // make a slice: length 0, capacity 10 (pre-allocated)
Un slice no tiene tamaño fijo — lo creces con append. Es la secuencia dinámica estándar.
A slice is a small struct: { pointer to underlying array, length, capacity }
- len = number of elements currently in the slice
- cap = size of the underlying array from the slice's start
append: if len < cap, reuses the array; if len == cap, allocates a BIGGER array & copies
original := []int{1, 2, 3, 4, 5}
sub := original[1:3] // [2, 3] — a VIEW into the same backing array
sub[0] = 99 // ⚠️ also changes original[1] → [1, 99, 3, 4, 5]!
Slicing (s[low:high]) no copia — crea un nuevo encabezado de slice apuntando al mismo array subyacente. Modificar uno puede afectar al otro — una fuente común de bugs sutiles. Usa copy() para una copia independiente.
a := []int{1, 2, 3}
b := append(a, 4) // may or may not share a's array depending on capacity
// safe pattern: always use the RETURNED slice from append
a = append(a, 4)
Los slices son una de las características más usadas y más incomprendidas de Go.
Comprender que los arrays son tipos por valor de tamaño fijo (rara vez usados directamente) mientras que los slices son vistas flexibles parecidas a referencias en un array de respaldo (la herramienta cotidiana) es fundamental.
Crucialmente, conocer el comportamiento del array subyacente compartido — que slicing crea una vista, no una copia, así que las modificaciones pueden afectar otros slices, y que append puede o no reasignar — previene una clase de bugs sutiles de aliasing difíciles de depurar que atrapan incluso a desarrolladores experimentados.
Dominar slices (len vs cap, append, copy, las trampas de compartir) es conocimiento esencial cotidiano de Go y un tema frecuente en entrevistas, ya que casi todo el trabajo con colecciones los usa.