Arrays, Slices & Maps at a Glance

Arrays são valores de tamanho fixo; slices e maps são coleções semelhantes a referências embutidas na linguagem.

A maioria do código Go usa slices e maps diariamente, então len, cap e as regras de compartilhamento são importantes.

Resumo

Um array [N]T tem o tamanho como parte do tipo.

Um slice []T é um cabeçalho (ponteiro, len, cap) sobre um array subjacente.

Um map map[K]V é uma tabela hash com ordem de iteração indefinida.

Slices e maps são passados copiando o cabeçalho, então as mutações são visíveis para os chamadores.

Receita

Cartão de referência rápida - pronto para copiar e colar.

package main
 
import "fmt"
 
func main() {
    nums := make([]int, 0, 4)
    nums = append(nums, 1, 2, 3)
 
    ages := map[string]int{"ada": 36}
    ages["grace"] = 34
 
    fmt.Println(nums, len(nums), cap(nums), ages)
}

Quando usar isso:

• Use slices para sequências ordenadas e que podem crescer.
• Use maps para busca por chave quando as chaves são comparáveis.
• Use arrays apenas quando o tamanho é uma restrição de protocolo fixa (criptografia, embarcados).
• Pré-aloque com make([]T, 0, n) quando souber o tamanho aproximado.

Exemplo de Trabalho

package main
 
import "fmt"
 
func addSuffix(names []string, suffix string) {
    for i := range names {
        names[i] += suffix
    }
}
 
func main() {
    original := []string{"go", "rust"}
    view := original[0:2:2] // expressão de slice completa limita a capacidade de append
    addSuffix(view, "!")
 
    counts := map[string]int{}
    for _, name := range original {
        counts[name]++
    }
 
    fmt.Println(original, counts)
 
    keys := make([]string, 0, len(counts))
    for k := range counts {
        keys = append(keys, k)
    }
    fmt.Println("keys (unordered):", keys)
}

O que isso demonstra:

• Cabeçalhos de Slice são copiados, mas compartilham arrays de suporte - addSuffix muta original.
• Expressão de slice completa s[low:high:max] limita a capacidade de crescimento do append.
• Maps precisam de make ou literais antes de escrever.
• Coletar chaves de map requer um slice separado; a ordem não é estável.

Mergulho Profundo

Como Funciona

• append de Slice aumenta a capacidade alocando um novo array quando len == cap (tipicamente dobrando).
• Fatiar s[low:high] define len como high-low e cap como cap(s)-low.
• Buckets de Map são internos; a ordem de iteração é randomizada a cada passagem.
• Arrays são atribuídos por valor (cópia completa); slices e maps atribuem cabeçalhos (armazenamento compartilhado).

Arrays vs Slices vs Maps

len e cap

Notas Go

// Deletar entrada de map
delete(m, key)
 
// Limpar map em Go 1.21+
clear(m)
 
// Copiar slices
dst := make([]int, len(src))
copy(dst, src)

Armadilhas

• Surpresa de alias de append - a := []int{1,2,3}; b := a[:2]; append(b, 99) pode sobrescrever a[2] se a capacidade permitir. Correção: use slice completo a[:2:2] ou append a uma cópia.
• Escrita em map nil - Atribuir a um map não inicializado causa panic. Correção: use make primeiro.
• Esperar iteração de map ordenada - A ordem muda entre os loops. Correção: ordene o slice de chaves antes de exibir.
• Usar array como substituto de slice - [5]int não é []int sem fatiar arr[:]. Correção: fatie com [:].
• Cópias de array grandes - Passar arrays grandes copia todos os elementos. Correção: passe um ponteiro *[N]T ou use um slice.
• Escritas concorrentes em map - Maps não são seguros para escrita concorrente sem sincronização. Correção: use sync.Map ou um mutex.

Alternativas

FAQs

v, ok := m[key]
if !ok { /* ausente */ }

Relacionados

• Valores Zero e Inicialização - maps e slices nil
• Ponteiros & o Operador de Endereço - Compartilhamento via cabeçalhos de slice
• Tipos Numéricos, Strings, Runes & Slices de Bytes - []byte como slices de bytes
• Structs, Embedding & Promoção de Campos - Structs contendo slices e maps

Links Relacionados Externos

• A Tour of Go - Introdução interativa oficial ao Go.
• Go by Example - Exemplos de código práticos anotados.
• Effective Go - Guia oficial para escrever Go claro e idiomático.
• The Go Programming Language (ebook) - Donovan & Kernighan.
• Learning Go (2nd Edition) - Jon Bodner.

Versões da Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, modernizadores go fix - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação), e golangci-lint (última versão - verifique o conjunto de linters na compilação). WTI5a1pXZDFhV1JsY3k1cGIzeGpaMmx2TkRJMmZESXdNall3Tnc9PQ==