¿Cómo trabajar con slices en Go?

Las slices en Go no son arreglos, sino que hacen referencia a un segmento (o a todo) del arreglo base. Son estructuras de datos dinámicas.

Creación de slices:

• Desde un arreglo:

// definir un arreglo
arr := [5]int{1, 2, 3, 4, 5}
// crear un slice de una parte del arreglo
s1 := arr[1:4] // s1 contiene los elementos arr[1], arr[2], arr[3]
// crear otro slice
s2 := arr[:3]  // s2 contiene los elementos arr[0], arr[1], arr[2]
// crear un slice que apunta a todo el arreglo
s3 := arr[2:]  // s3 contiene los elementos arr[2], arr[3], arr[4]
// crear un slice que apunta a todo el arreglo
s4 := arr[:]

• Usando make:

// Crear un slice con longitud 5 y capacidad 5
s := make([]int, 5)
// Crear un slice con longitud 5 y capacidad 10
s_cap := make([]int, 5, 10)

• Literal:

s := []int{1, 2, 3}

Propiedades principales del slice:

• len(s): devuelve la longitud actual del slice.
• cap(s): devuelve la capacidad del slice (el número máximo de elementos que puede contener antes de una reallocación).

Agregar elementos (append):

s := []int{1, 2}
s = append(s, 3)      // agrega un elemento
s = append(s, 4, 5)   // agrega varios elementos
s2 := []int{6, 7}
s = append(s, s2...) // agrega los elementos de otro slice

append puede causar una reallocación del arreglo base si la capacidad no es suficiente.

Eliminar elementos:

Eliminar elementos de un slice se logra creando un nuevo slice con los elementos restantes o copiando.

s := []int{1, 2, 3, 4, 5}
// Eliminar elemento en índice i
i := 2 // eliminar el elemento en el índice 2 (que es 3)
s = append(s[:i], s[i+1:]...)

Copiar slices:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // copia los elementos de src a dst

copy copia el mínimo de la longitud de los dos slices.

Iterar sobre un slice:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i es el índice, v es el valor
}
for i := range s {
    // solo el índice
}
for _, v := range s {
    // solo el valor
}

Los slices son tipos de referencia:

Los cambios en un slice se reflejan en el arreglo base y en otros slices que referencian la misma memoria.

arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[1:4] // [2, 3, 4]
s2 := arr[2:5] // [3, 4, 5]

s1[0] = 99
// Ahora arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (el elemento arr[2] cambió)