Golang mehrere Rückgabewerte: (value, error), benannte Ergebnisse

Mehr als einen Wert zurückgeben

Schreib die Ergebnistypen in Klammern. Gib die Werte durch Kommas getrennt zurück und empfange sie auf dieselbe Weise.

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

Die eingebauten Funktionen min und max gibt es seit Go 1.21. Der Aufrufer muss jedes Ergebnis empfangen: x := minMax(nums) kompiliert nicht und meldet assignment mismatch: 1 variable but minMax returns 2 values.

Die Konvention (value, error)

Der häufigste Grund, zwei Werte zurückzugeben, ist das Melden eines Fehlschlags. Per Konvention kommt der Fehler zuletzt, und wenn er nicht nil ist, gelten die anderen Ergebnisse als bedeutungslos.

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

Ausgabe:

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

Bei einem Fehler gibst du für jedes andere Ergebnis den Nullwert zurück (0, "", nil). Das vollständige Muster mit Wrapping und Prüfung steht auf der Seite zur Fehlerbehandlung.

Das Comma-ok-Idiom

Mehrere eingebaute Operationen geben optional ein zweites bool zurück, das sagt, ob der erste Wert echt ist. Die Variable heißt per Konvention 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
}

Diese drei Formen (Map-Lookup, Type Assertion, Empfang aus einem Channel) sind besonders: Sie liefern einen oder zwei Werte, je nachdem, wie vielen Variablen du zuweist. Deine eigenen Funktionen können das nicht. Eine Funktion, die mit zwei Ergebnissen deklariert ist, gibt immer zwei zurück.

Der Blank Identifier

_ nimmt einen Wert entgegen und wirft ihn weg. Nutz ihn für Ergebnisse, die du nicht brauchst:

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

Einen Fehler mit _ zu ignorieren kompiliert, also tu es nur, wenn du weißt, dass der Aufruf nicht fehlschlagen kann oder ein Fehlschlag egal ist. strings.Builder.WriteString zum Beispiel gibt immer einen nil-Fehler zurück; beim Schließen einer Datei nach dem Schreiben ist das nicht so.

Benannte Ergebnisse

Ergebnisparameter können Namen haben. Sie werden am Anfang der Funktion deklariert, mit ihren Nullwerten initialisiert, und ein return ohne Werte gibt zurück, was sie gerade enthalten.

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

Die Namen erscheinen in der Ausgabe von go doc. Das hilft, wenn zwei Ergebnisse denselben Typ haben: (quotient, remainder int) sagt mehr als (int, int).

Ein nacktes return in einer langen Funktion ist schwer zu lesen, weil der Leser zurückscrollen muss, um zu sehen, was die Ergebnisse enthalten. Der übliche Rat: Benenne Ergebnisse, wenn die Namen etwas dokumentieren, und schreib trotzdem explizit return quotient, remainder, außer die Funktion ist nur ein paar Zeilen lang.

Benannte Ergebnisse und defer

Eine per defer aufgerufene Funktion läuft, nachdem die return-Anweisung die Ergebnisse gesetzt hat, und bevor der Aufrufer sie erhält. Mit benannten Ergebnissen kann sie diese lesen und ändern. So ergänzt du jeden Fehler, den eine Funktion zurückgibt, um Kontext, oder machst aus einer Panic einen Fehler.

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

Das gibt load : empty name und dann <nil> aus. return errors.New(...) weist zuerst err zu, dann wrappt die defer-Funktion den Fehler. Mehr dazu unter defer.

Ein benanntes Ergebnis verschatten

Benannte Ergebnisse leben im äußersten Scope der Funktion. Ein := in einem verschachtelten Block erzeugt eine neue Variable mit demselben Namen, und ein nacktes return gibt dann die äußere zurück.

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

Den schlimmsten Fall fängt der Compiler ab: Ein nacktes return innerhalb des Blocks, in dem ein Ergebnis verschattet ist, scheitert mit result parameter err not in scope at return. Die Version oben, bei der das Return außerhalb des Blocks steht, fängt er nicht ab. Nimm = statt :=, wenn du die Ergebnisvariablen meinst.

Häufige Fehler

• Den Wert benutzen, obwohl err nicht nil ist. Prüf zuerst err. Eine Funktion darf neben einem Fehler beliebigen Müll zurückgeben.
• Einen typisierten nil-Pointer als Fehler zurückgeben. var e *MyErr; return e gibt einen error zurück, der nicht nil ist. Gib bei Erfolg ein wörtliches nil zurück.
• Zu viele Ergebnisse. Drei oder mehr Ergebnisse mit gemischter Bedeutung sind unhandlich. Gib stattdessen ein Struct zurück.