Múltiples Retornos, Retornos Nombrados y Retornos Desnudos

Las funciones de Go pueden devolver múltiples valores, usualmente un resultado y un error, y opcionalmente pueden nombrar esos resultados en la firma.

Los retornos nombrados permiten sentencias return desnudas y se integran con defer, pero su uso excesivo oculta el flujo de datos y frustra a los lectores.

Resumen

Los valores de retorno múltiples son el principal mecanismo de Go para señalar fallos sin excepciones.

Los llamadores reciben tuplas (T, error) y manejan los errores explícitamente en cada paso.

Los parámetros de resultado nombrados declaran variables con ámbito en todo el cuerpo de la función, inicializadas a sus valores cero al entrar.

Un return desnudo (sin operandos) devuelve los valores actuales de esos resultados nombrados.

Usa los retornos nombrados con moderación: brillan en funciones cortas con defer que ajustan un error, y perjudican la legibilidad en funciones largas con muchas ramas.

Prefiere los retornos sin nombre cuando la lógica sea más fácil de seguir con sentencias explícitas de return valor, err.

Receta

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

func ReadConfig(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("leer configuración %s: %w", path, err)
    }
    return data, nil
}
 
// Retornos nombrados + defer: ajusta err al salir (patrón idiomático).
func WriteAtomic(path string, data []byte) (err error) {
    f, err := os.CreateTemp(filepath.Dir(path), "tmp-*")
    if err != nil {
        return err
    }
    defer func() {
        closeErr := f.Close()
        if err == nil {
            err = closeErr
        }
    }()
    if _, err = io.Copy(f, bytes.NewReader(data)); err != nil {
        return err
    }
    return os.Rename(f.Name(), path)
}

Cuándo usar esto:

• Cualquier función que pueda fallar debe devolver error como último valor.
• Los bloques defer necesitan actualizar el error saliente después de la limpieza (defer + err nombrado).
• Las herramientas de documentación deben mostrar los nombres de los resultados en godoc para analizadores muy pequeños.
• Quieres evitar repetir tipos de tuplas largos en muchas sentencias return.

Ejemplo de Trabajo

package config
 
import (
    "encoding/json"
    "fmt"
    "os"
)
 
type Settings struct {
    Port int    `json:"port"`
    Host string `json:"host"`
}
 
func Load(path string) (s Settings, err error) {
    raw, err := os.ReadFile(path)
    if err != nil {
        return s, fmt.Errorf("config: leer: %w", err)
    }
    if err = json.Unmarshal(raw, &s); err != nil {
        return s, fmt.Errorf("config: decodificar: %w", err)
    }
    if s.Port == 0 {
        return s, fmt.Errorf("config: puerto requerido")
    }
    return s, nil
}

Lo que esto demuestra:

• Retorno final explícito con valores incluso cuando los resultados están nombrados; los lectores ven lo que sale de la función.
• Errores envueltos preservan las causas con %w para errors.Is / errors.As.
• Validación devuelve el Settings cero junto con un error; los llamadores deben verificar err antes de usar s.
• El err nombrado podría combinarse con defer en cargadores más complejos; aquí los retornos explícitos siguen siendo más claros.

Profundización

Cómo Funciona

• El compilador trata los parámetros de resultado como variables locales declaradas al inicio de la función.
• Los resultados nombrados se inicializan a sus valores cero (0, "", nil) antes de que se ejecute la primera sentencia.
• return sin argumentos no asigna nada nuevo; sale con los valores nombrados actuales.
• Los resultados sin nombre requieren que cada return liste explícitamente los valores; el compilador impone la aridad.

Retornos Nombrados vs. Sin Nombre

Defer y el Patrón err Nombrado

func do() (err error) {
    defer func() {
        if err != nil {
            err = fmt.Errorf("do: %w", err)
        }
    }()
    // ...
    return nil
}

La clausura diferida observa la variable de resultado nombrada por referencia (dirección), por lo que las asignaciones en defer afectan el valor devuelto a los llamadores.

Sombra err con := en un bloque interno rompe este patrón; usa = en el resultado nombrado en su lugar.

Notas de Go

// Anti-patrón: retorno desnudo lejos de la declaración.
func parseAll(input string) (tokens []string, err error) {
    for _, part := range strings.Split(input, ",") {
        if part == "" {
            return // ¿qué valores? el lector debe desplazarse hacia arriba
        }
        tokens = append(tokens, part)
    }
    return
}

Prefiere return tokens, nil al final y después de los errores para facilitar la lectura.

Trampas

• Sombra de err nombrado con :=: El foo, err := interno crea un nuevo err que defer no actualizará. Solución: usa = en el resultado nombrado existente o evita := en err.
• Retorno desnudo en funciones largas: Los lectores no pueden ver los valores devueltos en el punto de salida. Solución: usa return x, y explícito excepto en ayudantes cortos de defer.
• Devolver valor cero en caso de error: Los llamadores pueden ignorar err y usar s de todos modos. Solución: documenta "indefinido en caso de error" o devuelve punteros (*Settings, error).
• Mezclar retornos desnudos y explícitos: Estilo inconsistente en una función confunde la revisión. Solución: elige un estilo por función.
• Resultados nombrados en API pública sin beneficio: Añade carga cognitiva para ganancias marginales en godoc. Solución: nombra solo cuando el patrón defer/error lo requiera.
• Múltiples errores: Go no tiene agregación de errores incorporada en los retornos. Solución: devuelve el primer error o define un tipo error personalizado que recopile fallos.
• Cambiar nombres de resultados es un cambio que rompe la compatibilidad: Los nombres de resultados aparecen en godoc y pueden afectar a los envoltorios generados. Solución: trata las firmas exportadas como API estable.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de Funciones y Métodos - ejemplos introductorios para retornos y métodos
• Funciones e Interfaces: El Modelo de Composición de Go - cómo los errores se componen a través de capas
• Funciones Variádicas y Tipos de Función - funciones como valores que devuelven tuplas
• Interfaz Nil vs Puntero Nil - devolver nil, nil a través de interfaces
• Mejores Prácticas para Funciones, Métodos e Interfaces - convenciones de error y API

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).

WTI5a1pXZDFhV1JsY3k1cGIzeGpaMmx2TkRjM2ZESXdNall3Tnc9PQ==