Zwracanie wielu wartości w Go: (value, error), nazwane wyniki

Zwracanie więcej niż jednej wartości

Wymień typy wyników w nawiasach. Zwracaj wartości oddzielone przecinkami i odbieraj je w ten sam sposób.

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

Wbudowane min i max istnieją od Go 1.21. Kod wywołujący musi odebrać każdy wynik: x := minMax(nums) się nie kompiluje i zgłasza assignment mismatch: 1 variable but minMax returns 2 values.

Konwencja (value, error)

Najczęstszy powód zwracania dwóch wartości to zgłaszanie niepowodzenia. Zgodnie z konwencją błąd jest ostatni, a gdy nie jest nil, pozostałe wyniki należy traktować jako pozbawione znaczenia.

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

Wynik:

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

Przy niepowodzeniu zwracaj wartość zerową dla każdego innego wyniku (0, "", nil). Pełny wzorzec, łącznie z opakowywaniem i sprawdzaniem, jest na stronie o obsłudze błędów.

Idiom comma-ok

Kilka wbudowanych operacji zwraca opcjonalny drugi bool, który mówi, czy pierwsza wartość jest prawdziwa. Zmienną zwyczajowo nazywa się 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
}

Te trzy formy (odczyt z mapy, asercja typu, odbiór z kanału) są wyjątkowe: zwracają jedną lub dwie wartości w zależności od tego, do ilu zmiennych je przypisujesz. Twoje własne funkcje tak nie potrafią. Funkcja zadeklarowana z dwoma wynikami zawsze zwraca dwa.

Pusty identyfikator

_ odbiera wartość i ją wyrzuca. Używaj go dla wyników, których nie potrzebujesz:

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

Zignorowanie błędu przez _ się kompiluje, więc rób to tylko wtedy, gdy wiesz, że wywołanie nie może zawieść albo niepowodzenie nie ma znaczenia. Na przykład strings.Builder.WriteString zawsze zwraca błąd nil; zamknięcie pliku po zapisie już nie.

Nazwane wyniki

Parametry wynikowe mogą mieć nazwy. Są deklarowane na początku funkcji, inicjalizowane wartościami zerowymi, a return bez wartości zwraca to, co akurat w nich jest.

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")
}

Nazwy pojawiają się w wyniku go doc, co pomaga, gdy dwa wyniki mają ten sam typ: (quotient, remainder int) mówi więcej niż (int, int).

Samo return w długiej funkcji trudno się czyta, bo trzeba cofać się wzrokiem, żeby zobaczyć, co zawierają wyniki. Typowa rada: nazywaj wyniki, gdy nazwy coś dokumentują, a mimo to pisz jawnie return quotient, remainder, chyba że funkcja ma kilka linii.

Nazwane wyniki i defer

Funkcja odroczona wykonuje się po tym, jak instrukcja return ustawi wyniki, a zanim otrzyma je kod wywołujący. Przy nazwanych wynikach funkcja odroczona może je odczytać i zmienić. W ten sposób dodaje się kontekst do każdego błędu zwracanego przez funkcję albo zamienia panikę w błąd.

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"))
}

To wypisuje load : empty name, a potem <nil>. return errors.New(...) najpierw przypisuje wartość do err, a potem funkcja odroczona ją opakowuje. Więcej w artykule o defer.

Przesłanianie nazwanego wyniku

Nazwane wyniki żyją w najbardziej zewnętrznym zasięgu funkcji. := wewnątrz zagnieżdżonego bloku tworzy nową zmienną o tej samej nazwie, a samo return zwraca wtedy tę zewnętrzną.

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

Kompilator wyłapuje najgorszy przypadek: samo return wewnątrz bloku, w którym wynik jest przesłonięty, kończy się błędem result parameter err not in scope at return. Nie wyłapuje wersji powyżej, gdzie return stoi poza blokiem. Używaj = zamiast :=, gdy chodzi ci o zmienne wynikowe.

Częste błędy

• Używanie wartości, gdy err nie jest nil. Najpierw sprawdź err. Funkcja może razem z błędem zwrócić cokolwiek.
• Zwracanie typowanego wskaźnika nil jako błędu. var e *MyErr; return e zwraca error, który nie jest nil. Przy sukcesie zwracaj dosłowne nil.
• Zbyt wiele wyników. Trzy lub więcej wyników o różnym znaczeniu trudno używać. Zwróć zamiast tego strukturę.