Функции в Golang: объявление, вызов и передача функций

Объявление функции

Объявление функции это func, имя, параметры, тип результата и тело. Тип пишется после имени параметра, а не перед ним.

package main

import "fmt"

func add(a int, b int) int {
	return a + b
}

func greet(name string) {
	fmt.Println("Hello,", name)
}

func main() {
	sum := add(3, 4)
	fmt.Println(sum)
	greet("Gopher")
}

add принимает два значения int и возвращает int. greet ничего не возвращает, поэтому в её сигнатуре нет типа результата, а в теле не нужен return.

Функция, объявившая результат, должна заканчиваться завершающей инструкцией. Если какой-то путь может дойти до закрывающей скобки без возврата, компилятор остановится с ошибкой missing return.

Параметры с общим типом

У идущих подряд параметров одного типа может быть одно общее имя типа. func add(a, b int) int означает ровно то же, что func add(a int, b int) int. Смешивать тоже можно:

func scale(x, y float64, factor int) (float64, float64)

Здесь x и y имеют тип float64, а factor имеет тип int.

Возвращаемые значения

Функция может возвращать ноль, одно или несколько значений. Несколько результатов пишутся в скобках, и вызывающий код получает их множественным присваиванием:

package main

import "fmt"

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func main() {
	q, r := divmod(17, 5)
	fmt.Println(q, r)
}

Программа печатает 3 2. Пара (value, error) это самое частое применение этой возможности в Go, и ей посвящена отдельная страница о нескольких возвращаемых значениях.

Аргументы копируются

Go передаёт каждый аргумент по значению. Функция работает с копией, поэтому присваивание параметру никогда не меняет переменную вызывающего кода.

package main

import "fmt"

type Point struct{ X, Y int }

func moveCopy(p Point) {
	p.X = 100
}

func movePtr(p *Point) {
	p.X = 100
}

func fillFirst(s []int) {
	s[0] = 99
}

func main() {
	p := Point{1, 2}
	moveCopy(p)
	fmt.Println(p) // unchanged

	movePtr(&p)
	fmt.Println(p) // changed through the pointer

	nums := []int{1, 2, 3}
	fillFirst(nums)
	fmt.Println(nums) // the slice header was copied, the elements were not
}

Вывод:

{1 2}
{100 2}
[99 2 3]

Третья строка удивляет. Значение слайса это небольшой заголовок (указатель, длина, ёмкость). Копия указывает на тот же базовый массив, поэтому запись в s[0] меняет элемент вызывающего кода. Но append внутри функции может выделить новый массив, и вызывающий код этот новый заголовок никогда не увидит. Если функция увеличивает слайс, возвращайте новый слайс. С мапами логика та же: функция может добавить ключи, и вызывающий код их увидит, потому что значение мапы ссылается на общие данные.

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

Функции это значения

У функции есть тип, который записывается без имени: func(int, int) int. Функцию можно сохранить в переменную, положить в мапу или слайс и передать в другую функцию.

package main

import (
	"fmt"
	"strings"
)

func apply(xs []int, f func(int) int) []int {
	out := make([]int, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

func double(n int) int { return n * 2 }

func main() {
	fmt.Println(apply([]int{1, 2, 3}, double))

	square := func(n int) int { return n * n }
	fmt.Println(apply([]int{1, 2, 3}, square))

	ops := map[string]func(string) string{
		"upper": strings.ToUpper,
		"lower": strings.ToLower,
	}
	fmt.Println(ops["upper"]("go"), ops["lower"]("GO"))
}

square это анонимная функция, присвоенная переменной. Анонимные функции могут также читать и менять переменные из окружающей области видимости, что делает их замыканиями.

Именованный функциональный тип делает сигнатуры читабельнее, когда одна и та же форма встречается во многих местах:

type Transform func(int) int

func apply(xs []int, f Transform) []int

Нулевое значение функционального типа это nil. Вызов nil-функции вызывает панику с invalid memory address or nil pointer dereference, поэтому проверяйте необязательные колбэки перед вызовом. Функциональные значения можно сравнивать только с nil, но не друг с другом.

Рекурсия

Функция может вызывать саму себя. Оптимизации хвостовых вызовов в Go нет, но стеки горутин растут по мере надобности, так что обычная глубина рекурсии не проблема.

package main

import "fmt"

func factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	for i := range 6 {
		fmt.Println(i, factorial(i))
	}
}

for i := range 6 считает от 0 до 5 и требует Go 1.22 или новее.

Чего нет у функций в Go

• Нет перегрузки. Две функции в одном пакете не могут иметь одно имя, даже с разными параметрами.
• Нет аргументов по умолчанию и именованных аргументов. Каждый параметр передаётся при каждом вызове, по порядку. Структура с конфигурацией даёт именованные необязательные поля: NewServer(Config{Port: 8080}).
• Нет вложенных именованных функций. Внутри тела функции можно объявлять только анонимные функции, обычно присваивая их переменной.

Списки аргументов переменной длины поддерживаются через вариативные функции.

Экспортируемые и неэкспортируемые функции

Функция, имя которой начинается с заглавной буквы (Parse), экспортируется, и её можно вызывать из других пакетов. Имя со строчной буквы (parse) видно только внутри своего пакета. Ключевых слов public и private нет; регистр первой буквы и есть всё правило.

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

• Ожидание, что изменение параметра дойдёт до вызывающего кода. Присваивание параметру меняет только копию. Верните новое значение или примите указатель.
• append внутри функции без использования результата. func add(s []int) { s = append(s, 1) } никак не влияет на длину слайса вызывающего кода. Напишите func add(s []int) []int и используйте s = add(s).
• Неиспользуемые результаты. Go позволяет игнорировать возвращаемое значение. go vet не отмечает выброшенную ошибку, а линтеры вроде errcheck (входит в golangci-lint) отмечают. Используйте _ = только тогда, когда игнорирование это осознанное решение.