# Slices

Na maior parte das vezes que precisar armazenar valores, você vai utilizar Slices, eles possuem uma grande vantagem em relação aos Arrays, eles são expansíveis. O compilador não considera o tamanho do slice como uma parte do seu tipo. A forma como eles são declarados é muito similar ao array, porém não definimos o tamanho

var x = []int

Da mesma forma que arrays, podemos criar slices bidimensionais

var x = [][]int

Para declarar um slice com valores definidos

var x = []int{1, 2, 3, 4, 5}

# Adicionando elementos a um slice

Para adicionar elementos a um slice, podemos utilizar a função append.

var x = []int{1, 2, 3, 4, 5}
x = append(x, 6)  
fmt.Println(x) // [1 2 3 4 5 6]

Podemos adicionar mais de um elemento ao slice

var x = []int{1, 2, 3, 4, 5}
x = append(x, 6, 7, 8)
fmt.Println(x) // [1 2 3 4 5 6 7 8]

# Tamanho e capacidade

Da mesma forma que um array, um slice possui um tamanho e uma capacidade. O tamanho é o número de elementos que o slice contém, e a capacidade é o número de elementos que o slice pode conter. Lembrando que no array o tamanho e a capacidade são iguais.

var x = []int{1, 2, 3, 4, 5}
fmt.Println(len(x)) // 5
fmt.Println(cap(x)) // 5

Veja o que acontece quando adicionamos um elemento ao slice, além da capacidade.

var x = []int{1, 2, 3, 4, 5}
fmt.Println("Tamanho:", len(x), "Capacidade:", cap(x))
x = append(x, 6)
fmt.Println("Tamanho:", len(x), "Capacidade:", cap(x))

O runtime aumenta a capacidade do slice.

Tamanho: 5 Capacidade: 5
Tamanho: 6 Capacidade: 10

# Remover todos os elementos

Para remover todos os elementos de um slice é possível utilizar a função clear

var x = []int{1, 2, 3, 4, 5}
fmt.Println(x, len(x))
clear(x)
fmt.Println(x, len(x))

[1 2 3 4 5] 5
[0 0 0 0 0] 5

# Comparação de Slices

Depois da versão 1.21 o pacote slices inclui a função Equal que compara dois slices. Os dois slices são considerados iguais quando possuem o mesmo tamanho e os mesmos valores. Obrigatoriamente os slices devem ser do mesmo tipo.

var x = []int{1, 2, 3, 4, 5}
var y = []int{1, 2, 3, 4, 5}
fmt.Println(slices.Equal(x, y)) // true

var z = []int{1, 2, 3, 4, 6}
fmt.Println(slices.Equal(x, z)) // false

Caso os slices sejam de tipos diferentes, o compilador irá retornar um erro de compilação.

var x = []float64{1, 2, 3, 4, 5}
var y = []string{"1", "2", "3", "4", "5"}
fmt.Println(slices.Equal(x, y))

# command-line-arguments
slices/main.go:14:30: in call to slices.Equal, type []float64 of y does not match inferred type []int for S
slices/main.go:16:30: in call to slices.Equal, type []string of s does not match inferred type []int for S

# Referências

1. Capítulo 4 - Tipos Compostos A Linguagem de Programação Go
2. Chapter 3 - Composite Types Learning Go: An Idiomatic Approach to Real-World Go Programming