Valores de retorno múltiples en Golang: (valor, error)

Devolver más de un valor

Enumera los tipos de los resultados entre paréntesis. Devuelve los valores separados por comas y recíbelos de la misma forma.

package main

import "fmt"

func minMax(xs []int) (int, int) {
	lo, hi := xs[0], xs[0]
	for _, x := range xs[1:] {
		lo = min(lo, x)
		hi = max(hi, x)
	}
	return lo, hi
}

func main() {
	lo, hi := minMax([]int{4, 9, 1, 7})
	fmt.Println("min:", lo, "max:", hi)
}

Las funciones integradas min y max existen desde Go 1.21. Quien llama tiene que recibir todos los resultados: x := minMax(nums) no compila y da assignment mismatch: 1 variable but minMax returns 2 values.

La convención (valor, error)

La razón más común para devolver dos valores es informar de un fallo. Por convención el error va el último, y cuando no es nil los demás resultados se deben tratar como sin sentido.

package main

import (
	"errors"
	"fmt"
	"strconv"
)

func parsePort(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("port %q: %w", s, err)
	}
	if n < 1 || n > 65535 {
		return 0, errors.New("port out of range")
	}
	return n, nil
}

func main() {
	for _, in := range []string{"8080", "http", "70000"} {
		port, err := parsePort(in)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("port:", port)
	}
}

Salida:

port: 8080
error: port "http": strconv.Atoi: parsing "http": invalid syntax
error: port out of range

Si algo falla, devuelve el valor cero en todos los demás resultados (0, "", nil). El patrón completo, con cómo envolver y comprobar errores, está en la página de manejo de errores.

El idioma comma-ok

Varias operaciones integradas devuelven un segundo bool opcional que dice si el primer valor es real. Por convención la variable se llama ok.

package main

import "fmt"

func main() {
	ages := map[string]int{"ana": 31}

	age, ok := ages["bob"]
	fmt.Println(age, ok) // 0 false: missing key, not a zero age

	var v any = "hello"
	s, ok := v.(string)
	fmt.Println(s, ok)

	ch := make(chan int, 1)
	ch <- 5
	close(ch)
	x, ok := <-ch
	fmt.Println(x, ok) // 5 true: a buffered value is still delivered
	x, ok = <-ch
	fmt.Println(x, ok) // 0 false: closed and drained
}

Estas tres formas (búsqueda en un map, aserción de tipo, recepción de un channel) son especiales: devuelven uno o dos valores según a cuántas variables asignes. Tus propias funciones no pueden hacer eso. Una función declarada con dos resultados siempre devuelve dos.

El identificador vacío

_ recibe un valor y lo descarta. Úsalo para los resultados que no necesitas:

_, err := fmt.Sscan(input, &n)
key, _ := parseLine(line)

Ignorar un error con _ compila, así que hazlo solo cuando sepas que la llamada no puede fallar o que el fallo no importa. strings.Builder.WriteString siempre devuelve un error nil, por ejemplo; cerrar un archivo después de escribir en él, no.

Resultados con nombre

Los parámetros de resultado pueden tener nombre. Se declaran al principio de la función, se inicializan con su valor cero, y un return sin valores devuelve lo que contengan.

package main

import "fmt"

func split(total int) (quotient, remainder int) {
	quotient = total / 7
	remainder = total % 7
	return
}

func main() {
	weeks, days := split(45)
	fmt.Println(weeks, "weeks and", days, "days")
}

Los nombres aparecen en la salida de go doc, lo que ayuda cuando dos resultados comparten tipo: (quotient, remainder int) dice más que (int, int).

Un return vacío en una función larga es difícil de leer, porque quien lee tiene que volver atrás para ver qué contienen los resultados. El consejo habitual: pon nombre a los resultados cuando los nombres documenten algo, y aun así escribe return quotient, remainder de forma explícita salvo que la función tenga pocas líneas.

Resultados con nombre y defer

Una función diferida se ejecuta después de que la sentencia return haya asignado los resultados y antes de que quien llama los reciba. Con resultados con nombre, la función diferida puede leerlos y cambiarlos. Así se añade contexto a cualquier error que devuelva una función, o se convierte un panic en un error.

package main

import (
	"errors"
	"fmt"
)

func load(name string) (err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("load %s: %w", name, err)
		}
	}()
	if name == "" {
		return errors.New("empty name")
	}
	return nil
}

func main() {
	fmt.Println(load(""))
	fmt.Println(load("config.json"))
}

Esto imprime load : empty name y luego <nil>. return errors.New(...) primero asigna a err, y después la función diferida lo envuelve. Más sobre esto en defer.

Sombrear un resultado con nombre

Los resultados con nombre viven en el ámbito más externo de la función. Un := dentro de un bloque anidado crea una variable nueva con el mismo nombre, y un return vacío devuelve entonces la exterior.

func find() (n int, err error) {
	if true {
		n, err := compute() // new n and err, shadowing the results
		_ = n
		_ = err
	}
	return // returns 0, nil
}

El compilador detecta el peor caso: un return vacío dentro del bloque donde un resultado está sombreado falla con result parameter err not in scope at return. No detecta la versión de arriba, donde el return está fuera del bloque. Usa = en lugar de := cuando te refieras a las variables de resultado.

Errores comunes

• Usar el valor cuando err no es nil. Comprueba primero err. Una función puede devolver basura junto a un error.
• Devolver un puntero nil con tipo como error. var e *MyErr; return e devuelve un error que no es nil. Devuelve un nil literal si todo va bien.
• Demasiados resultados. Tres o más resultados de significado dispar son difíciles de usar. Devuelve un struct.