Несколько возвращаемых значений в Golang: (value, error)

Возврат нескольких значений

Перечислите типы результатов в скобках. Возвращайте значения через запятую и принимайте так же.

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

Встроенные min и max появились в Go 1.21. Вызывающий код обязан принять все результаты: x := minMax(nums) не компилируется с ошибкой assignment mismatch: 1 variable but minMax returns 2 values.

Соглашение (value, error)

Чаще всего два значения возвращают, чтобы сообщить об ошибке. По соглашению ошибка идёт последней, и если она не nil, остальные результаты считаются бессмысленными.

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

Вывод:

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

При ошибке возвращайте нулевое значение для всех остальных результатов (0, "", nil). Полный шаблон, включая оборачивание и проверку, описан на странице обработка ошибок.

Идиома comma-ok

Несколько встроенных операций возвращают необязательное второе значение bool, которое говорит, настоящее ли первое значение. Переменную по соглашению называют 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
}

Эти три формы (поиск в мапе, утверждение типа, получение из канала) особые: они возвращают одно или два значения в зависимости от того, скольким переменным вы присваиваете. Ваши собственные функции так не умеют. Функция, объявленная с двумя результатами, всегда возвращает два.

Пустой идентификатор

_ принимает значение и выбрасывает его. Используйте его для ненужных результатов:

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

Игнорирование ошибки через _ компилируется, поэтому делайте так, только если точно знаете, что вызов не может завершиться неудачей или неудача не важна. Например, strings.Builder.WriteString всегда возвращает nil-ошибку, а закрытие файла после записи нет.

Именованные результаты

У параметров результата могут быть имена. Они объявляются в начале функции, инициализируются нулевыми значениями, а return без значений возвращает то, что в них лежит.

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

Имена попадают в вывод go doc, что помогает, когда у двух результатов один тип: (quotient, remainder int) говорит больше, чем (int, int).

Голый return в длинной функции трудно читать: читателю приходится листать назад, чтобы понять, что лежит в результатах. Обычный совет: называйте результаты, когда имена что-то документируют, и всё равно пишите return quotient, remainder явно, если функция длиннее нескольких строк.

Именованные результаты и defer

Отложенная функция выполняется после того, как инструкция return записала результаты, и до того, как их получит вызывающий код. С именованными результатами отложенная функция может читать и менять их. Так добавляют контекст к любой ошибке, которую возвращает функция, или превращают панику в ошибку.

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

Программа печатает load : empty name, а затем <nil>. return errors.New(...) сначала присваивает значение err, а затем отложенная функция его оборачивает. Подробнее на странице о defer.

Затенение именованного результата

Именованные результаты живут во внешней области видимости функции. := во вложенном блоке создаёт новую переменную с тем же именем, и голый return вернёт внешнюю.

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

Худший случай компилятор ловит: голый return внутри блока, где результат затенён, даёт ошибку result parameter err not in scope at return. Вариант выше, где return стоит вне блока, он не ловит. Используйте = вместо :=, когда имеете в виду переменные результата.

Частые ошибки

• Использование значения, когда err не nil. Сначала проверьте err. Функция вправе вернуть мусор вместе с ошибкой.
• Возврат типизированного nil-указателя в качестве ошибки. var e *MyErr; return e возвращает не-nil error. При успехе возвращайте литерал nil.
• Слишком много результатов. Три и больше результатов разного смысла неудобны в использовании. Верните структуру.