CS Fundamentals Trainer · Guias

Slices, arrays e mapas em Go: cabeçalhos, crescimento, aliasing e retenção de memória

Como os slices realmente funcionam e por que surpreendem: o cabeçalho de três palavras, tamanho e capacidade, como o append cresce (com capacidades medidas), aliasing por arrays compartilhados e argumentos de função, pré-alocação (12 alocações contra 1), retenção de memória por sub-slices e ponteiros removidos, e as regras de mapas e range.

9 min de leitura

Slices são o tipo mais usado em Go e a fonte de seus bugs mais repetidos. A sintaxe lembra um array dinâmico, mas um slice é só uma pequena descrição de um pedaço de um array que mora em outro lugar. Quando você enxerga isso, as surpresas famosas (um append que muda outro slice, uma função que modifica os dados de quem a chamou, 20 MB de memória presos por 200 bytes de dados) deixam de ser surpresas. Este guia explica o cabeçalho, como o append cresce, como o aliasing acontece, como pré-alocar, como a memória fica retida e onde entram os mapas e o range. Os números foram medidos com Go 1.24 em uma máquina de 64 bits; são exemplos, e os degraus exatos de crescimento podem mudar entre versões.

1. Arrays são valores, slices são visões

Um array como [3]int tem o tamanho no próprio tipo e é um valor: atribuí-lo ou passá-lo copia todos os elementos. Um slice como []int é um cabeçalho de três palavras: um ponteiro para o primeiro elemento que ele enxerga, um tamanho (length) e uma capacidade (capacity). Em uma máquina de 64 bits o cabeçalho tem 24 bytes, qualquer que seja o número de elementos.

Array [3]intSlice []int
O tamanho faz parte do tiposimnão
Atribuição e chamada de funçãocopia todos os elementoscopia só o cabeçalho de 24 bytes
Onde ficam os elementosdentro da variávelem um array separado, compartilhado
Valor zero[0 0 0]nil (tamanho 0, capacidade 0)
Comparável com ==sim (se os elementos forem)não, só com nil
arr := [3]int{1, 2, 3}
arr2 := arr          // a full copy
arr2[0] = 9
fmt.Println(arr, arr2) // [1 2 3] [9 2 3]

A regra prática: use slices quase sempre, e lembre que duas variáveis de slice podem olhar para os mesmos elementos.

2. Tamanho, capacidade e fatiamento

len(s) é quantos elementos você pode ler. cap(s) é quantos elementos existem desde o primeiro que o slice enxerga até o fim do array subjacente. Fatiar s[i:j] cria um novo cabeçalho sobre o mesmo array, com tamanho j-i e capacidade cap(s)-i.

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

b enxerga 2, 3, mas tem espaço para mais dois elementos, 4 e 5, porque eles estão no array depois dele. Essa capacidade sobrando é a raiz da maioria das surpresas com slices. A forma de três índices s[i:j:k] define a capacidade como k-i, então você pode cortar o espaço: a[1:3:3] tem tamanho 2 e capacidade 2.

3. Como o append faz um slice crescer

append escreve na capacidade sobrando quando há alguma. Quando não há, aloca um array maior, copia os elementos e devolve um cabeçalho que aponta para o novo array. O array antigo fica como estava, e por isso você deve escrever s = append(s, x) e nunca ignorar o resultado.

A regra de crescimento é: aproximadamente dobrar enquanto o slice é pequeno, depois crescer mais devagar (cerca de 1,25 vez, mais uma constante) a partir de 256 elementos, e sempre arredondar o tamanho em bytes para uma das classes de tamanho do alocador. Anexando um elemento por vez a um []int vazio no Go 1.24, as capacidades foram:

1 2 4 8 16 32 64 128 256 512 848 1280 1792 2560

Um []byte começa em 8, porque a menor classe de tamanho é de 8 bytes. Anexar cinco elementos de uma vez a um []int nil deu capacidade 6, não 5, pelo mesmo motivo. Trate os números exatos como detalhe de implementação: seu programa deve estar correto para qualquer capacidade.

4. Aliasing: quando dois slices compartilham um array

Dois slices fazem aliasing quando seus arrays se sobrepõem. Se um append é visível por outro slice depende de haver espaço ou não.

a := []int{1, 2, 3, 4, 5}
b := a[1:3]
b = append(b, 99)       // room for it: writes into a's array
fmt.Println(a, b)       // [1 2 3 99 5] [2 3 99]

c := a[1:3:3]           // capacity 2: no room
c = append(c, 77)       // allocates a new array
fmt.Println(a, c)       // [1 2 3 99 5] [2 3 77]

O mesmo acontece quando você passa um slice para uma função. A função recebe uma cópia do cabeçalho, então alterar um elemento é visível para quem chamou, mas o append pode ou não ser:

f := func(s []int) { s[0] = 100; s = append(s, 5); s[1] = 200 }

t := make([]int, 2, 2) // full: append reallocates
f(t)
fmt.Println(t)         // [100 0]

t2 := make([]int, 2, 3) // one spare slot: append writes in place
f(t2)
fmt.Println(t2, t2[:3]) // [100 200] [100 200 5]

Código que se comporta de forma diferente conforme a capacidade é um bug esperando outra entrada. Dois hábitos seguros: devolva o novo slice das funções que fazem append, e use a expressão de slice completa (ou uma cópia) sempre que entregar um sub-slice que não deve ser estendido sobre os seus dados.

5. Pré-aloque quando souber o tamanho

Crescer com append aloca e copia toda vez que a capacidade acaba. Se você sabe, ou consegue estimar, o tamanho final, peça-o de antemão com make([]T, 0, n), ou chame slices.Grow(s, n) em um slice existente. Medido com testing.AllocsPerRun para 1.000 appends de um int:

AbordagemAlocações por execução
var s []int e depois append12
make([]int, 0, n) e depois append1

A economia também está na cópia e no lixo que os arrays intermediários deixam. Não exagere: pré-alocar uma capacidade enorme "por via das dúvidas" desperdiça memória, e um slice curto que nunca vai crescer não precisa de ajuda.

6. Retenção de memória: um slice pequeno pode segurar um array grande

Um slice mantém vivo todo o seu array subjacente, até a parte que ele não enxerga. Essa é a causa usual de "meu programa usa muito mais memória que os meus dados":

var keep [][]byte
for i := 0; i < 20; i++ {
    big := make([]byte, 1<<20)       // 1 MiB buffer
    keep = append(keep, big[:10])    // we only wanted 10 bytes
}
// measured retained heap: 20 MB, for 200 bytes of useful data

A correção é copiar o que você precisa para que o array grande possa ser liberado: slices.Clone(big[:10]) ou append([]byte(nil), big[:10]...). Com essa mudança, o heap retido medido caiu para quase nada. Strings se comportam do mesmo jeito: uma substring compartilha os bytes da original, então strings.Clone(sub) desanexa um pedaço pequeno cortado de uma string grande.

Há uma segunda forma do problema, com ponteiros. Se você remove um elemento do meio com append(s[:i], s[i+1:]...), a última vaga antiga ainda guarda um ponteiro, e o coletor de lixo vê o objeto apontado como alcançável. Desde o Go 1.22, slices.Delete zera a cauda que libera (um teste mostrou a vaga depois do novo tamanho como nil). Código mais antigo, ou remoção escrita à mão, deve fazer clear(tail) por conta própria. slices.Clip(s) apara a capacidade sobrando quando você quer impedir que um slice cresça sobre memória que não precisa mais.

7. Mapas

Uma variável de mapa é um ponteiro para uma estrutura do runtime. Copiá-la, ou passá-la a uma função, compartilha o mesmo mapa, então uma função pode adicionar chaves que quem chamou vê, sem nenhum ponteiro.

8. range e cópias

for i, v := range x avalia x uma vez. Sobre um array, percorre uma cópia do array; sobre um slice, usa o cabeçalho do slice, então mudanças posteriores nos elementos são visíveis:

arr := [3]int{1, 2, 3}
for i, v := range arr { arr[2] = 10; if i == 2 { fmt.Println(v) } } // 3

sl := []int{1, 2, 3}
for i, v := range sl { sl[2] = 10; if i == 2 { fmt.Println(v) } }  // 10

v é sempre uma cópia do elemento, então alterar v não muda nada no slice; use s[i]. Desde o Go 1.22 cada iteração tem seus próprios i e v, então closures e goroutines que os capturam veem seus próprios valores (módulo go 1.22 ou posterior).

9. Erros comuns

  1. Ignorar o resultado de append.
  2. Modificar um slice dentro de uma função e esperar que o append seja visível para quem chamou.
  3. Manter um sub-slice pequeno de um buffer grande em uma estrutura de vida longa.
  4. Remover elementos de um slice de ponteiros e deixar o ponteiro antigo para trás.
  5. Fazer append em um laço quente sem pré-alocação quando o tamanho é conhecido.
  6. Escrever em um mapa nil, ou ler e escrever em um mapa a partir de várias goroutines.
  7. Supor que cap depois de append é igual em toda versão do Go.
  8. Comparar slices com == (use slices.Equal).

10. O que mencionar em uma entrevista

Resumo rápido

Array: valor, copiado. Slice: uma visão de três palavras sobre um array compartilhado. len é o que você vê, cap é o que você poderia alcançar. append escreve no lugar se couber e realoca se não. Copie quando precisar desanexar, pré-aloque quando souber o tamanho e zere os ponteiros que descartar.

Fontes

Pratique este tema: Go

Mais guias