Patrones Go
Medido: la frontera actual y los modelos pequeños de Claude ya escriben las mecánicas de concurrencia comunes aquí (grupos de workers, etapas de pipeline, cierre de canales) correctamente en un solo disparo sin esta habilidad — un estudio controlado encontró cero margen de mejora en corrección, 184/184 aprobados en ambos brazos (el
evals/RESULTS.md§2 del repositorio). Recurre a esta habilidad para las decisiones de diseño — interfaces, cableado de dependencias, modelado de errores, estructura de paquetes — como lista de verificación de revisión, o al usar modelos más débiles; no porque un modelo actual se bloquearía de otro modo.
Ámbito: Archivos Go, go.mod y go.sum.
Origen: Derivado de Everything Claude Code (MIT, (c) 2026 Affaan Mustafa).
Esta habilidad proporciona patrones Go integrales que extienden principios de diseño comunes con modismos específicos de Go.
Opciones Funcionales
Usa el patrón de opciones funcionales para configuración flexible de constructores:
type Option func(*Server)
func WithPort(port int) Option {
return func(s *Server) { s.port = port }
}
func NewServer(opts ...Option) *Server {
s := &Server{port: 8080}
for _, opt := range opts {
opt(s)
}
return s
}
Beneficios:
- Evolución de API compatible hacia atrás
- Parámetros opcionales con valores predeterminados
- Configuración autodocumentada
Interfaces Pequeñas
Define interfaces donde se usan, no donde se implementan.
Principio: Acepta interfaces, devuelve estructuras
// Bien: Interfaz pequeña y enfocada definida en el punto de uso
type UserStore interface {
GetUser(id string) (*User, error)
}
func ProcessUser(store UserStore, id string) error {
user, err := store.GetUser(id)
// ...
}
Beneficios:
- Pruebas y simulación más fáciles
- Acoplamiento débil
- Dependencias claras
Inyección de Dependencias
Usa funciones constructoras para inyectar dependencias:
func NewUserService(repo UserRepository, logger Logger) *UserService {
return &UserService{
repo: repo,
logger: logger,
}
}
Patrón:
- Funciones constructoras (prefijo New*)
- Dependencias explícitas como parámetros
- Devuelve tipos concretos
- Valida dependencias en el constructor
Patrones de Concurrencia
Grupo de Workers
func workerPool(jobs <-chan Job, results chan<- Result, workers int) {
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for job := range jobs {
results <- processJob(job)
}
}()
}
// Cierra resultados una vez que todos los workers terminen — en una
// goroutine separada para que esta función regrese inmediatamente y el
// llamador pueda iterar sobre resultados mientras los workers siguen
// produciendo. Un wg.Wait() en línea aquí causa un interbloqueo: los
// workers se bloquean enviando a resultados hasta que un lector lo drena,
// pero el lector solo se ejecuta después de que workerPool regresa.
go func() {
wg.Wait()
close(results)
}()
}
Propagación de Contexto
Pasa siempre el contexto como primer parámetro:
func FetchUser(ctx context.Context, id string) (*User, error) {
// Verifica cancelación de contexto
select {
case <-ctx.Done():
return nil, ctx.Err()
default:
}
// ... lógica de obtención
}
Manejo de Errores
Envoltura de Errores
if err != nil {
return fmt.Errorf("error al obtener usuario %s: %w", id, err)
}
Errores Personalizados
type ValidationError struct {
Field string
Msg string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("%s: %s", e.Field, e.Msg)
}
Errores Centinela
var (
ErrNotFound = errors.New("no encontrado")
ErrInvalid = errors.New("entrada inválida")
)
// Verifica con errors.Is
if errors.Is(err, ErrNotFound) {
// maneja no encontrado
}
Organización de Paquetes
Estructura
proyecto/
├── cmd/ # Aplicaciones principales
│ └── servidor/
│ └── main.go
├── internal/ # Código de aplicación privado
│ ├── dominio/ # Lógica de negocio
│ ├── manejador/ # Manejadores HTTP
│ └── repositorio/ # Acceso a datos
└── pkg/ # Bibliotecas públicas
Convenciones de Nomenclatura
- Nombres de paquetes: minúsculas, una sola palabra
- Evita repetición:
usuario.Usuarionousuario.ModeloUsuario - Usa
internal/para código privado - Mantén el paquete
mainmínimo
Patrones de Pruebas
Pruebas Basadas en Tablas
func TestValidar(t *testing.T) {
tests := []struct {
name string
input string
wantErr bool
}{
{"válido", "[email protected]", false},
{"inválido", "no-un-correo", true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := Validar(tt.input)
if (err != nil) != tt.wantErr {
t.Errorf("error obtenido %v, wantErr %v", err, tt.wantErr)
}
})
}
}
Ayudantes de Prueba
// Importa el controlador puro-Go: _ "modernc.org/sqlite" (registra como "sqlite").
// NO uses "sqlite3" (mattn/go-sqlite3) — necesita CGO y rompe compilaciones
// estáticas CGO_ENABLED=0. El bundle greenfield-go-stack exige puro-Go/sin CGO.
func dbPrueba(t *testing.T) *sql.DB {
t.Helper()
db, err := sql.Open("sqlite", ":memory:")
if err != nil {
t.Fatalf("error al abrir db de prueba: %v", err)
}
// Una base de datos ":memory:" es privada para una sola conexión, y
// database/sql es un pool perezoso: sin esto, cada conexión del pool
// obtiene su PROPIA base de datos vacía, por lo que una tabla creada en
// una conexión falta en la siguiente. Fijar el pool a una conexión hace
// que toda la prueba comparta una DB en memoria. Advertencia: con una
// sola conexión, mientras una tx está abierta (db.Begin), esa tx retiene
// la única conexión — dirige TODO el trabajo a través de la tx hasta
// Commit/Rollback; un db.Query concurrente en el pool se bloquearía
// esperándola. Si una prueba realmente necesita múltiples conexiones
// activas, usa un DSN de caché compartida en su lugar
// ("file:basedeprueba?mode=memory&cache=shared") y mantén >=1 conexión
// abierta para que la DB en memoria no se pierda.
db.SetMaxOpenConns(1)
t.Cleanup(func() { db.Close() })
return db
}
Cuándo Usar Esta Habilidad
- Diseñando APIs y paquetes Go
- Implementando sistemas concurrentes
- Estructurando proyectos Go
- Escribiendo código Go idiomático
- Refactorizando bases de código Go