Definición e Implementación de Interfaces

Las interfaces de Go describen el comportamiento a través de conjuntos de métodos que los tipos concretos satisfacen implícitamente.

Define interfaces pequeñas en el consumidor, acéptalas en los parámetros de las funciones y devuelve estructuras concretas de los constructores.

Resumen

Un valor de interfaz contiene un par de tipo dinámico y valor dinámico.

La satisfacción se verifica en tiempo de compilación al asignar; no existe una palabra clave implements.

Las interfaces pequeñas (a menudo uno o dos métodos) mantienen los mocks ligeros y fomentan la composición sobre abstracciones amplias.

Aceptar interfaces, devolver estructuras es la regla principal de la API: depende del comportamiento mínimo en los parámetros; expón tipos concretos de las funciones New para que los llamadores no queden atrapados detrás de tus definiciones de interfaz.

Evita exportar interfaces grandes de los paquetes productores; se convierten en contratos de compatibilidad dolorosos.

Receta

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

// El paquete consumidor define lo que necesita.
type Storage interface {
    Get(ctx context.Context, key string) ([]byte, error)
    Put(ctx context.Context, key string, value []byte) error
}
 
// El productor devuelve un tipo concreto.
type MemStore struct {
    mu sync.RWMutex
    m  map[string][]byte
}
 
func NewMemStore() *MemStore {
    return &MemStore{m: make(map[string][]byte)}
}
 
func (s *MemStore) Get(ctx context.Context, key string) ([]byte, error) { /* ... */ }
func (s *MemStore) Put(ctx context.Context, key string, value []byte) error { /* ... */ }
 
func LoadConfig(ctx context.Context, store Storage, key string) ([]byte, error) {
    return store.Get(ctx, key)
}

Cuándo usar esto:

• Intercambiar implementaciones en pruebas (memoria vs. falso vs. integración).
• Las bibliotecas no deben importar SDKs de nube concretos en los puntos de llamada.
• Múltiples tipos comparten comportamientos superpuestos (io.Reader, io.Writer).
• Defines puntos de extensión en frameworks (manejador HTTP Handler, ServerStream de gRPC).

Ejemplo de Trabajo

package notify
 
import (
    "context"
    "fmt"
)
 
type Sender interface {
    Send(ctx context.Context, to, body string) error
}
 
type Service struct {
    sender Sender
}
 
func New(sender Sender) *Service {
    return &Service{sender: sender}
}
 
type LogSender struct{}
 
func (LogSender) Send(ctx context.Context, to, body string) error {
    fmt.Printf("to=%s body=%q\n", to, body)
    return nil
}
 
type SMTPClient struct {
    host string
}
 
func NewSMTP(host string) *SMTPClient {
    return &SMTPClient{host: host}
}
 
func (c *SMTPClient) Send(ctx context.Context, to, body string) error {
    // marcar c.host, enviar mensaje ...
    return nil
}
 
func (s *Service) Welcome(ctx context.Context, email string) error {
    return s.sender.Send(ctx, email, "welcome")
}

Lo que esto demuestra:

• La interfaz Sender vive con el consumidor Service, no con el paquete SMTP.
• Dos remitentes concretos satisfacen la misma interfaz sin declaración explícita.
• New acepta Sender para inyección; devuelve el tipo concreto *Service.
• Context se transmite a través de los métodos de la interfaz para cancelación/tiempos de espera.

Profundización

Cómo Funciona

• El tipo de interfaz con el conjunto de métodos M es satisfecho por cualquier tipo cuyo conjunto de métodos incluya M.
• La interfaz vacía any contiene todos los tipos; úsala solo en los límites de decodificación.
• El nil no de interfaz es nil sin tipo; el nil de interfaz requiere que tanto el tipo como el valor estén vacíos.
• Incrustar interfaces promueve métodos; útil para composiciones de estilo io.ReadCloser.

Reglas de Diseño de Interfaces

Patrones de la Biblioteca Estándar

Notas de Go

// Dividir interfaces cuando los métodos no están relacionados.
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }
type ReadWriter interface {
    Reader
    Writer
}

Prefiere incrustar en lugar de interfaces únicas infladas.

Trampas

• Mega-interfaces exportadas: Agregar métodos rompe a todos los implementadores. Solución: dividir interfaces o mantener interfaces no exportadas satisfechas por estructuras exportadas.
• Devolver una interfaz desde el constructor: Oculta el tipo concreto, fomenta errores de nil tipados. Solución: devolver *Concrete a menos que la abstracción sea el producto.
• Satisfacción de puntero vs. valor: La falta de métodos solo de puntero en el valor falla la asignación. Solución: devolver punteros de los constructores cuando sea necesario.
• Comparar una interfaz con nil incorrectamente: Un puntero nil tipado dentro de una interfaz no es == nil. Solución: devolver tipos concretos o documentar comprobaciones con patrones de reflexión/errors.Is.
• Nombres de métodos duplicados en interfaces incrustadas: Las promociones ambiguas fallan la compilación. Solución: renombrar métodos o incrustar solo una interfaz.
• Contaminación de interfaz en rutas críticas: El costo menor de asignación/itable suele estar bien; perfila antes de eliminar interfaces. Solución: optimizar solo con evidencia.
• Pruebas con testify/mock en interfaces amplias: Expectativas frágiles. Solución: estrechar interfaces o mocks escritos a mano.

Alternativas

Preguntas Frecuentes

Relacionados

• Funciones e Interfaces: El Modelo de Composición de Go - por qué existen las interfaces implícitas
• Interfaz Nil vs Puntero Nil - nil tipado dentro de valores de interfaz
• Métodos: Receptores de Valor vs. Puntero - conjuntos de métodos y satisfacción
• Funciones Variádicas y Tipos de Función - cuándo un tipo func supera a una interfaz
• Mejores Prácticas para Funciones, Métodos e Interfaces - tamaño de interfaz y reglas de exportación

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