Patrones y Prácticas Recomendadas de Go
Un resumen condensado de las 25 prácticas de patrones y modismos más importantes de Go extraídas de cada página de esta sección.
//
Busca en todas las páginas de la documentación
Un resumen condensado de las 25 prácticas de patrones y modismos más importantes de Go extraídas de cada página de esta sección.
Composición primero: Modela el comportamiento con structs, métodos, incrustación (embedding) y funciones en lugar de jerarquías de subclases copiadas de Java o C#.
Interfaces definidas por el consumidor: Declara interfaces donde se usa el comportamiento (paquete de servicios), no junto a cada implementación concreta.
Mantén las interfaces pequeñas: Una o dos métodos por límite (Store, Clock, Publisher) hacen que las falsificaciones (fakes) sean triviales y las APIs estables.
Acepta interfaces, devuelve structs: Los parámetros del constructor dependen del comportamiento mínimo; New devuelve *Concrete para que los llamadores no queden atados a la forma de tu interfaz.
Estado no exportado: Los tipos de biblioteca ocultan campos detrás de métodos y opciones para que los invariantes no se puedan romper después de la construcción.
Nombra los constructores idiomáticamente: Usa New para valores nuevos, Open/Dial para recursos, y empareja con Close/Shutdown cuando se requiera limpieza.
Documenta la política del valor cero: Indica claramente si var T es utilizable (bytes.Buffer) o requiere New() (Store con mapas privados).
Opciones funcionales para el crecimiento: Aplica el patrón de opciones cuando los constructores de lo contrario se expandirían a través de muchos parámetros ortogonales.
Valida en New: Devuelve errores de los constructores y opciones cuando la configuración puede fallar; evita pánicos diferidos en el primer uso.
Valores predeterminados dentro de New: Establece valores predeterminados sensatos antes de aplicar opciones para que los llamadores solo sobrescriban lo que necesitan.
Manejadores HTTP delgados: Analiza el transporte, llama a un método de servicio, mapea errores a códigos de estado; sin SQL ni reglas de negocio con bifurcaciones.
Los servicios poseen las reglas: La política de cancelación, autorización, idempotencia y flujos de trabajo de varios pasos viven en los métodos de servicio.
Los repositorios poseen la E/S: Las llamadas SQL, SDK y el mapeo de filas permanecen detrás de interfaces de estilo OrderRepo en paquetes de almacenamiento internos.
Contexto en todas partes en E/S: Pasa context.Context como el primer parámetro en manejadores, servicios y métodos de repositorio que puedan bloquear.
Middleware solo para cortes transversales: El registro (logging), los IDs de solicitud, la recuperación y el análisis de credenciales de autenticación pertenecen al middleware, no a la lógica de precios.
Claves de contexto tipadas: Usa constantes privadas type ctxKey int en lugar de claves de cadena para evitar colisiones entre paquetes de middleware.
Llama a next en el middleware: Invoca next.ServeHTTP a menos que el middleware haya escrito completamente la respuesta; documenta el orden del middleware en main.
sync.Once para configuración única: Protege la inicialización diferida costosa (expresiones regulares compiladas, registro predeterminado) cuando la inyección de dependencias no es práctica.
Evita E/S en init(): No marques bases de datos, leas secretos ni analices configuraciones en init(); cablea recursos en main o constructores explícitos.
Limita los globales de paquetes: Prefiere inyectar *sql.DB, registradores (loggers) y registros de métricas desde main en lugar de singletons Default().
Incrusta deliberadamente: Incrusta para promocionar métodos en decoradores delgados (http.Handler), no para simular árboles de herencia.
Errores, no panic: Devuelve error para validación y fallos esperados; reserva panic para errores de programador y ayudantes Must* de inicio.
Mapea errores en el borde: Los servicios devuelven errores de dominio; los adaptadores HTTP/gRPC traducen con errors.Is y errors.As.
Prueba con falsificaciones (fakes): Implementa interfaces de consumidor en _test.go para ejercitar servicios sin Docker o credenciales de nube.
El patrón menos ingenioso gana: Busca opciones, repositorios o middleware cuando aparece un segundo eje de cambio, no antes.
Mantén los manejadores (handlers) delgados y empuja las reglas a los servicios detrás de interfaces pequeñas; la mayoría de las otras prácticas apoyan ese límite.
Cuando más de un constructor exportado en tu módulo necesita configuraciones opcionales que de lo contrario romperían a los llamadores con cada nuevo campo.
Aplica reglas de importación en la revisión: los paquetes de dominio no deben importar controladores SQL ni enrutadores HTTP; cablea en cmd/ e internal/.
Raramente en código de aplicación; prefiere la inyección.
Las cachés inmutables diferidas a nivel de biblioteca con sync.Once son la principal excepción.
El middleware y la composición de manejadores aquí se aplican directamente a los servidores stdlib y chi; gin/echo siguen las mismas ideas con tipos diferentes.
Versiones de Stack: Esta página fue escrita para Go 1.26.x (Green Tea GC por defecto, go fix modernizers - verificar parche en la compilación), chi (última versión - verificar en la compilación), gin (última versión - verificar en la compilación), echo (última versión - verificar en la compilación), google.golang.org/grpc (última versión - verificar en la compilación), sigs.k8s.io/controller-runtime (última versión - verificar en la compilación), kubebuilder (última versión - verificar en la compilación), tinygo (última versión - verificar objetivos de placa en la compilación), wazero (última versión - verificar en la compilación) y golangci-lint (última versión - verificar en la compilación).
Revisado por Chris St. John·Última actualización: 16 jul 2026