Como trabalhar com slices em Go?

As slices em Go não são arrays, mas referenciam um segmento (ou todo) do array base. São estruturas de dados dinâmicas.

Criação de slices:

• A partir de um array:

// definir um array
arr := [5]int{1, 2, 3, 4, 5}
// criar um slice de uma parte do array
s1 := arr[1:4] // s1 contém os elementos arr[1], arr[2], arr[3]
// criar outro slice
s2 := arr[:3]  // s2 contém os elementos arr[0], arr[1], arr[2]
// criar um slice que aponta para todo o array
s3 := arr[2:]  // s3 contém os elementos arr[2], arr[3], arr[4]
// criar um slice que aponta para todo o array
s4 := arr[:]

• Usando make:

// Criar um slice com comprimento 5 e capacidade 5
s := make([]int, 5)
// Criar um slice com comprimento 5 e capacidade 10
s_cap := make([]int, 5, 10)

• Literal:

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

Propriedades principais do slice:

• len(s): devolve o comprimento atual do slice.
• cap(s): devolve a capacidade do slice (o número máximo de elementos que pode conter antes de realocação).

Adicionar elementos (append):

s := []int{1, 2}
s = append(s, 3)      // adiciona um elemento
s = append(s, 4, 5)   // adiciona vários elementos
s2 := []int{6, 7}
s = append(s, s2...) // adiciona elementos de outro slice

append pode causar realocação do array base se a capacidade não for suficiente.

Remover elementos:

Remover elementos de um slice é feito criando um novo slice com os elementos restantes ou copiando.

s := []int{1, 2, 3, 4, 5}
// Remover elemento no índice i
i := 2 // remover elemento no índice 2 (que é 3)
s = append(s[:i], s[i+1:]...)

Copiar slices:

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

copy copia o mínimo entre os comprimentos dos dois slices.

Iterar sobre um slice:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - índice, v - valor
}
for i := range s {
    // apenas o índice
}
for _, v := range s {
    // apenas o valor
}

Slices são tipos de referência:

Alterações num slice refletem no array base e em outros slices que referenciam a mesma memória.

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
// Agora arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (o elemento arr[2] mudou)