Funciones Variádicas y Tipos de Función

Go trata las funciones como valores que puedes nombrar, pasar y retornar, y permite que el último parámetro absorba una lista de argumentos variable con ...T.

Juntos, las firmas variádicas y los tipos de función potencian middleware, opciones y pequeños puntos de extensión sin la sobrecarga de interfaces.

Resumen

Un parámetro variádico (args ...int) es azúcar sintáctico para un slice dentro de la función.

Los llamadores pasan cero o más argumentos, o expanden un slice existente con fn(slice...).

Un tipo de función (type Handler func(...)) documenta contratos invocables y permite funciones de orden superior que aceptan comportamiento como datos.

Usa variádicos para constructores como fmt.Sprintf, ayudantes de registro y opciones funcionales.

Usa tipos de función para middleware HTTP, envoltorios de reintento y predicados.

Prefiere interfaces pequeñas cuando necesites múltiples métodos relacionados o mocking entre paquetes.

Receta

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

type Option func(*Server)
 
func WithPort(p int) Option {
    return func(s *Server) { s.port = p }
}
 
func New(opts ...Option) *Server {
    s := &Server{port: 8080}
    for _, opt := range opts {
        opt(&s)
    }
    return s
}
 
type Middleware func(http.Handler) http.Handler
 
func Logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

Cuándo usar esto:

• Se acumulan perillas de configuración opcionales (WithTimeout, WithLogger, ...).
• Un único punto de hook necesita inyección de comportamiento (Retry, Authorize).
• Envuelves manejadores o interceptores RPC en una cadena.
• Utilidades que agregan un número desconocido de argumentos (sum, concat).

Ejemplo de Trabajo

package retry
 
import (
    "context"
    "errors"
    "time"
)
 
type AttemptFunc func(ctx context.Context) error
 
func Do(ctx context.Context, attempts int, backoff time.Duration, fn AttemptFunc) error {
    var err error
    for i := 0; i < attempts; i++ {
        if err = fn(ctx); err == nil {
            return nil
        }
        if ctx.Err() != nil {
            return ctx.Err()
        }
        time.Sleep(backoff)
        backoff *= 2
    }
    return err
}
 
func ExampleUsage(ctx context.Context, call func(context.Context) error) error {
    return Do(ctx, 3, 100*time.Millisecond, func(ctx context.Context) error {
        if err := call(ctx); err != nil {
            return err
        }
        return nil
    })
}
 
var ErrPermanent = errors.New("retry: permanent failure")

Lo que esto demuestra:

• AttemptFunc nombra el contrato invocable en lugar de repetir func(context.Context) error.
• Do de orden superior acepta comportamiento y se encarga de la política de bucle/retraso.
• Cancelación de contexto comprobada entre intentos: los valores de función aún respetan los límites.
• Cierre (Closure) en ExampleUsage adapta una call más simple a AttemptFunc.

Inmersión Profunda

Cómo Funciona

• Los parámetros variádicos se compilan en parámetros de slice; ... en el sitio de llamada divide un slice en argumentos discretos.
• Los valores de función son punteros a código más el entorno capturado para cierres.
• Los tipos de función nombrados son distintos de su firma subyacente para conjuntos de métodos; no puedes asignar func(int) int a type Op func(int) int sin conversión, pero la conversión está permitida cuando las firmas coinciden.
• Los valores de función nil deben verificarse antes de la llamada; invocar nil provoca un pánico como una llamada a método de interfaz nil.

Reglas Variádicas de un Vistazo

Tipos de Función vs Interfaces

Notas de Go

var fn func()
if fn != nil {
    fn()
}

Siempre protege los callbacks opcionales.

Las cadenas de middleware deben tratar nil como identidad: if mw == nil { return next }.

Trampas

• Llamar a un valor de función nil - Provoca pánico en tiempo de ejecución. Solución: verifica if fn != nil antes de invocar, o requiere no nulo en la documentación de la API.
• Variádico con slice vacío vs nil - Dentro de la función, args == nil es falso para una llamada de cero argumentos (slice vacío no nulo). Solución: usa len(args) == 0 cuando distinguir ausente vs vacío importe.
• Expandir un tipo de slice incorrecto - []byte no se puede dividir en ...int. Solución: convierte o cambia la firma.
• Capturar estado mutable en opciones - Las opciones se ejecutan en orden; las opciones posteriores pueden observar mutaciones anteriores inesperadamente. Solución: documenta la dependencia del orden o valida en New.
• Sorpresas en la conversión de tipos de función - Los tipos nombrados difieren de los tipos de función subyacentes idénticos. Solución: conversión explícita Op(fn) cuando sea necesario.
• Estabilidad de la API pública variádica - Agregar parámetros no variádicos rompe a los llamadores; agregar nuevo comportamiento opcional a través de opciones funcionales no lo hace. Solución: prefiere opciones para constructores en evolución.
• Pasar funciones variádicas a reflect - Fácil de invocar incorrectamente sin CallSlice. Solución: cíñete a llamadas tipadas a menos que estés construyendo herramientas genéricas.

pbqrthvqrf.vb|ptvb492|202607

Alternativas

Preguntas Frecuentes

Relacionado

• Literales de Función y Cierres - captura de variables en valores de función
• Conceptos Básicos de Funciones y Métodos - primeros ejemplos de variádicos y tipos de función
• Definición e Implementación de Interfaces - cuándo las interfaces superan a los tipos de función
• Métodos: Receptores por Valor vs Puntero - métodos en tipos de función (HandlerFunc)
• Mejores Prácticas para Funciones, Métodos e Interfaces - convenciones de middleware y opciones

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