Qual é a diferença entre arrays e slices?

Question

Accepted Answer

Um **array** tem um tamanho fixo que faz parte de seu tipo; um **slice** é uma visão flexível e dinamicamente dimensionável em um array subjacente. Na prática você quase sempre usa **slices** — arrays são raros no Go cotidiano.

## Arrays — tamanho fixo

```go
var arr [5]int               // an array of exactly 5 ints (size is part of the type)
arr[0] = 10
fmt.Println(len(arr))        // 5 — size is fixed forever

// [3]int and [5]int are DIFFERENT types — can't assign one to the other
```

O tamanho de um array é fixo em tempo de compilação e faz parte de seu tipo (`[5]int` ≠ `[3]int`). Arrays também são **tipos por valor** — atribuir ou passar um copia todo o array. Essa rigidez é o motivo pelo qual raramente são usados diretamente.

## Slices — dinâmicos e flexíveis

```go
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)
```

Um slice não tem tamanho fixo — você o aumenta com `append`. É a sequência dinâmica padrão.

## Como slices funcionam internamente

```text
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
```

## Slicing cria uma visão (array subjacente compartilhado — uma cilada)

```go
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]`) não copia — cria um novo header de slice apontando para o **mesmo** array subjacente. Modificar um pode afetar o outro — uma fonte comum de bugs sutis. Use `copy()` para uma cópia independente.

## A surpresa de realocação do append

```go
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)
```

## Por que isso importa

Slices são uma das características mais usadas e mais mal compreendidas do Go.

Entender que arrays são tipos por valor com tamanho fixo (raramente usados diretamente) enquanto **slices** são visões flexíveis e de referência em um array subjacente (a ferramenta cotidiana) é fundamental.

Crucialmente, conhecer o **comportamento de array subjacente compartilhado** — que slicing cria uma visão, não uma cópia, então modificações podem afetar outros slices, e que `append` pode ou não realocação — previne uma classe de bugs sutis de aliasing difíceis de depurar que pegam até desenvolvedores experientes.

Dominar slices (len vs cap, append, copy, as ciladas de compartilhamento) é conhecimento essencial do Go cotidiano e um tópico frequente em entrevistas, já que quase todo trabalho com coleções os usa.