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]int | Slice []int | |
|---|---|---|
| O tamanho faz parte do tipo | sim | não |
| Atribuição e chamada de função | copia todos os elementos | copia só o cabeçalho de 24 bytes |
| Onde ficam os elementos | dentro da variável | em 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:
| Abordagem | Alocações por execução |
|---|---|
var s []int e depois append | 12 |
make([]int, 0, n) e depois append | 1 |
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.
- O valor zero é
nil. Ler de um mapa nil é permitido e devolve o valor zero; escrever nele causa pânico com "assignment to entry in nil map". Crie mapas commakeou um literal. - A ordem de iteração é não especificada e aleatorizada de propósito. Ordene as chaves quando precisar de ordem.
- Um mapa não é seguro para uso concorrente quando alguma goroutine escreve. Use um mutex,
sync.Mapnos seus casos restritos, ou uma goroutine dona. - Um elemento de mapa não é endereçável:
m["a"].n++não compila quando os valores são structs. Leia a struct, altere-a e guarde-a de volta, ou guarde ponteiros. make(map[K]V, n)dá uma dica de tamanho que evita crescimento inicial.clear(m)(Go 1.21) remove todas as chaves, mas a memória a que o mapa cresceu em geral é mantida. Para realmente liberar memória depois que um mapa encolheu muito, crie um novo mapa e copie as entradas vivas.
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
- Ignorar o resultado de
append. - Modificar um slice dentro de uma função e esperar que o
appendseja visível para quem chamou. - Manter um sub-slice pequeno de um buffer grande em uma estrutura de vida longa.
- Remover elementos de um slice de ponteiros e deixar o ponteiro antigo para trás.
- Fazer append em um laço quente sem pré-alocação quando o tamanho é conhecido.
- Escrever em um mapa nil, ou ler e escrever em um mapa a partir de várias goroutines.
- Supor que
capdepois deappendé igual em toda versão do Go. - Comparar slices com
==(useslices.Equal).
10. O que mencionar em uma entrevista
- Um slice é um cabeçalho (ponteiro, tamanho, capacidade); passá-lo copia o cabeçalho, não os elementos.
appendpode reaproveitar o array ou alocar um novo, então use seu resultado e não dependa de qual dos dois.s[i:j:k]limita a capacidade e é a cura para sobrescrita acidental por um sub-slice.- Pré-aloque com
make([]T, 0, n)quando souber o tamanho; meça as alocações. - Um sub-slice mantém vivo o array inteiro; copie pedaços pequenos de buffers grandes.
- Mapas parecem referências, têm ordem aleatória, não são seguros para escritas concorrentes e não encolhem sozinhos.
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
- Rob Pike, Go Slices: usage and internals e Andrew Gerrand, Arrays, slices (and strings): The mechanics of append.
- The Go Authors, Go maps in action e The Go Programming Language Specification: appending to and copying slices.
- The Go Authors, package slices (
Clone,Clip,Grow,Delete) e Effective Go: slices. - Teiva Harsanyi, 100 Go Mistakes and How to Avoid Them (Manning, 2022), capítulos sobre slices e mapas.
Pratique este tema: Go