Copia de Cabecera de Slice y Sorpresa de Append

Dos funciones comparten lo que parecen ser slices independientes hasta que un append sobrescribe los elementos del otro.

Esta página muestra cómo la copia de cabecera de slice crea aliasing, cómo append reutiliza la capacidad y los patrones de copia que previenen la corrupción de datos en producción.

Resumen

Un slice de Go es una pequeña cabecera: puntero, longitud y capacidad.

La asignación y el paso por valor copian la cabecera, no el array subyacente.

Cuando dos cabeceras apuntan al mismo array, append en un slice puede mutar elementos visibles a través del otro si existe capacidad libre.

Estos errores son insidiosos porque los programas rara vez entran en pánico; devuelven datos incorrectos bajo tamaños y patrones de carga específicos.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

// Limita la capacidad al exponer una vista interior
sub := s[low:high:high] // cap == len, append reasigna
 
// Copia defensiva antes de pasar al llamador
out := append([]T(nil), s...)
 
// Copia solo el prefijo
prefix := append([]T(nil), s[:n]...)

Cuándo usar esto:

• Al devolver sub-slices de APIs de paquetes
• Al analizar protocolos en vistas sobre un buffer de lectura
• Al agrupar buffers []byte reutilizados entre solicitudes
• Cualquier append después de s[:n] en almacenamiento compartido
• En revisiones de código del manejo de []byte en capas HTTP/gRPC

Ejemplo Funcional

package main
 
import "fmt"
 
func main() {
    base := []int{1, 2, 3, 4, 5}
    window := base[1:3] // len 2, cap 4 (comparte el array subyacente)
    fmt.Println("antes", base, window, "cap", cap(window))
 
    window = append(window, 99) // escribe en el array subyacente de base
    fmt.Println("después ", base, window)
 
    safe := append([]int(nil), base[1:3]...)
    safe = append(safe, 99)
    fmt.Println("seguro ", base, safe)
}

Lo que esto demuestra:

• window comparte el array de base; append con capacidad libre muta base
• cap(window) mayor que len(window) es la señal de peligro
• Copiar antes de append aísla las mutaciones
• Registrar len, cap y el slice subyacente completo detecta el defecto en las pruebas

Análisis Profundo

Cómo Funciona

• Cabecera de Slice: puntero | len | cap
• s[low:high] establece len=high-low, cap=cap(s)-low - a menudo mayor que len
• append reutiliza el array subyacente cuando len < cap; de lo contrario, asigna un nuevo array
• Un sub-slice con cap compartida significa que append puede sobrescribir índices más allá de la len del sub-slice pero dentro de la cap del padre

Patrones Seguros

Notas de Go

// Analizador que mantiene un buffer []byte
func parseFrame(buf []byte) (payload []byte, rest []byte) {
    n := int(buf[0])
    payload = append([]byte(nil), buf[1:1+n]...) // copia el payload
    rest = buf[1+n:]
    return payload, rest
}

Errores Comunes

• Asumir que append siempre asigna - Reutiliza la capacidad cuando es posible. Solución: verifica cap o copia primero.
• Devolver s[:n] desde un buffer interno - Los llamadores hacen append en tu pool. Solución: copia o limita la capacidad con tres índices.
• Aliasing de bytes.Buffer.Bytes() - Los bytes permanecen válidos hasta la próxima mutación del buffer. Solución: copia si almacenas a largo plazo.
• Crecimiento de capacidad de sub-slice de sub-slice - La capacidad puede extenderse hasta el final del array original. Solución: expresión de slice completa s[low:high:high].
• append concurrente en slice compartido - Carrera de datos incluso sin pánico. Solución: mutex, copia en escritura o buffer por goroutine.
• Descifrado JSON en slice existente - Reutiliza el array subyacente cuando no es nulo. Solución: s = nil antes de descifrar si necesitas una nueva asignación.

Alternativas

Preguntas Frecuentes

Relacionado

• Detalles Internos de Slice - modelo de puntero, len, cap y append
• Depuración de Go: Fallos Observables y Bordes Afilados - familia de corrupción silenciosa
• Escenarios de Carrera de Datos y Correcciones del Detector de Carreras - acceso concurrente a slices
• Conceptos Básicos de Depuración en Go - registrar len y cap
• Mejores Prácticas de Tipos de Datos - reglas de copia antes de entregar

Versiones de Stack: Esta página fue escrita para Go 1.26.x (predeterminado GC Green Tea, go fix modernizers - verifica el parche en la compilación), chi (última - verifica en la compilación), gin (última - verifica en la compilación), echo (última - verifica en la compilación), google.golang.org/grpc (última - verifica en la compilación), sigs.k8s.io/controller-runtime (última - verifica en la compilación), kubebuilder (última - verifica en la compilación), tinygo (última - verifica objetivos de placa en la compilación), wazero (última - verifica en la compilación) y golangci-lint (última - verifica el conjunto de linters en la compilación).