Slices: la estructura idiomática

Un sector es la estructura de datos más utilizada en Go: una vista dinámica sobre una matriz subyacente. Sintaxis: []T. A diferencia de las matrices, la longitud es no forma parte del tipo y puedes cultivarlo con append.

Anatomía de una rebanada

Internamente, un sector es una estructura de tres campos:

• un puntero al primer elemento de la matriz subyacente
• una longitud (len): número de elementos visibles
• una capacidad (cap): elementos disponibles desde el inicio de la vista hasta el final de la matriz subyacente

s := []int{10, 20, 30}
fmt.Println(len(s), cap(s)) // 3 3

Creación

a := []int{1, 2, 3}          // literal
b := make([]int, 3)          // [0 0 0]   len=3 cap=3
c := make([]int, 3, 10)      // len=3 cap=10 (reserved)
var d []int                  // nil slice: len=0 cap=0, still usable with append

append: asignar siempre el resultado

append agrega elementos y devuelve una nueva porción (potencialmente asignar una nueva matriz si la capacidad es insuficiente):

s := []int{1, 2, 3}
s = append(s, 4)              // [1 2 3 4]
s = append(s, 5, 6, 7)        // append multiple elements
s = append(s, altra...)       // concatenate another slice (spread)

Expresión de segmento s[a:b]

Extrae una subsección de a (inclusive) a b (exclusivo):

s := []int{10, 20, 30, 40, 50}
sub := s[1:4]              // [20 30 40]
inizio := s[:2]            // [10 20]
fine := s[3:]              // [40 50]
intera := s[:]             // [10 20 30 40 50]

Los subporciones comparten la matriz subyacente con la porción original: Las mutaciones a través de sub[i] = ... también son visibles en s.

Error: compartir matrices

s := []int{1, 2, 3, 4}
sub := s[0:2]
sub[0] = 99
fmt.Println(s)             // [99 2 3 4] — modified!

Para obtener una copia independiente, utilice copy o append:

out := make([]int, len(sub))
copy(out, sub)

Pruébalo

s := []int{1, 2, 3}
// (a) s = append(s, 4)
// (b) append(s, 4)

Resumen

• []T: vista dinámica sobre una matriz; triple (ptr, len, cap).
• make([]T, len, cap) para preasignar; var s []T para una porción nula utilizable.
• s = append(s, ...): SIEMPRE asigna el resultado.
• s[a:b] comparte la matriz subyacente: copy(...) para copias independientes.
• Un segmento nil = OK para leer/intervalo/añadir; bastante diferente de un mapa nulo.