Cópia de Cabeçalho de Slice e Surpresa no Append

Duas funções compartilham o que parecem ser slices independentes até que um append sobrescreva os elementos do outro.

Esta página mostra como a cópia do cabeçalho de slice cria aliasing, como append reutiliza a capacidade e os padrões de cópia que previnem a corrupção de dados em produção.

Resumo

Um slice Go é um pequeno cabeçalho: ponteiro, comprimento e capacidade.

Atribuição e passagem por valor copiam o cabeçalho, não o array subjacente.

Quando dois cabeçalhos apontam para o mesmo array, append em um slice pode mutar elementos visíveis através do outro se houver capacidade extra disponível.

Esses bugs são insidiosos porque os programas raramente entram em pânico - eles retornam dados errados sob tamanhos e padrões de carga específicos.

Receita

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

// Limita a capacidade ao expor uma visualização interna
sub := s[low:high:high] // cap == len, append realoca
 
// Cópia defensiva antes de passar para o chamador
out := append([]T(nil), s...)
 
// Copia apenas o prefixo
prefix := append([]T(nil), s[:n]...)

Quando usar isso:

• Retornar sub-slices de APIs de pacotes
• Analisar protocolos em visualizações sobre um buffer de leitura
• Agrupar buffers []byte reutilizados entre requisições
• Qualquer append após s[:n] em armazenamento compartilhado
• Revisão de código de manipulação de []byte nas camadas HTTP/gRPC

Exemplo de Trabalho

package main
 
import "fmt"
 
func main() {
    base := []int{1, 2, 3, 4, 5}
    window := base[1:3] // len 2, cap 4 (compartilha o array subjacente)
    fmt.Println("antes", base, window, "cap", cap(window))
 
    window = append(window, 99) // escreve no array subjacente de base
    fmt.Println("depois ", base, window)
 
    safe := append([]int(nil), base[1:3]...)
    safe = append(safe, 99)
    fmt.Println("seguro ", base, safe)
}

O que isso demonstra:

• window compartilha o array de base; append com capacidade extra muta base
• cap(window) maior que len(window) é o sinal de perigo
• Copiar antes de append isola mutações
• Registrar len, cap e o slice subjacente completo captura o defeito em testes

Mergulho Profundo

Como Funciona

• Cabeçalho do slice: ponteiro | len | cap
• s[low:high] define len=high-low, cap=cap(s)-low - frequentemente maior que len
• append reutiliza o array subjacente quando len < cap; caso contrário, aloca um novo array
• Sub-slice com cap compartilhada significa que append pode sobrescrever índices além do len do sub-slice, mas dentro da cap do pai

Padrões Seguros

Notas Go

// Analisador mantendo um buffer []byte
func parseFrame(buf []byte) (payload []byte, rest []byte) {
    n := int(buf[0])
    payload = append([]byte(nil), buf[1:1+n]...) // copia o payload
    rest = buf[1+n:]
    return payload, rest
}

Armadilhas

• Assumir que append sempre aloca - Ele reutiliza a capacidade quando possível. Correção: verifique cap ou copie primeiro.
• Retornar s[:n] de um buffer interno - Chamadores fazem append no seu pool. Correção: copie ou limite a capacidade com três índices.
• Aliasing em bytes.Buffer.Bytes() - Bytes permanecem válidos até a próxima mutação do buffer. Correção: copie se for armazenar por muito tempo.
• Crescimento da capacidade de sub-slice de sub-slice - A capacidade pode se estender até o final do array original. Correção: expressão de slice completa s[low:high:high].
• Append concorrente em slice compartilhado - Data race mesmo sem panic. Correção: mutex, copy-on-write ou buffer por goroutine.
• Unmarshal JSON em slice existente - Reutiliza o array subjacente quando não é nil. Correção: s = nil antes do unmarshal se precisar de alocação nova.

Alternativas

FAQs

Relacionados

• Internos de Slice - modelo de ponteiro, len, cap e append
• Depurando Go: Falhas Observáveis e Pontos Críticos - família de corrupção silenciosa
• Cenários de Data Race e Correções do Detector de Race - acesso concorrente a slices
• Noções Básicas de Depuração Go - registrar len e cap
• Melhores Práticas de Tipos de Dados - regras de cópia antes de entrega

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