Замыкания и анонимные функции в Golang с примерами

Анонимные функции

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

package main

import (
	"fmt"
	"slices"
	"strings"
)

func main() {
	double := func(n int) int { return n * 2 }
	fmt.Println(double(21))

	// Call immediately.
	func(msg string) {
		fmt.Println("now:", msg)
	}("hello")

	// Pass inline as an argument.
	words := []string{"banana", "Apple", "cherry"}
	slices.SortFunc(words, func(a, b string) int {
		return strings.Compare(strings.ToLower(a), strings.ToLower(b))
	})
	fmt.Println(words)
}

Стрелочного синтаксиса или сокращённых лямбд в Go нет. Полная форма func(params) results { body } единственный способ её записать.

Захват переменных

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

package main

import "fmt"

func main() {
	count := 0
	inc := func() {
		count++
	}

	inc()
	inc()
	fmt.Println(count) // 2: the closure changed the outer variable

	count = 10
	inc()
	fmt.Println(count) // 11: and it sees outside changes too
}

Захваченная переменная живёт, пока на неё ссылается хотя бы одно замыкание, даже после того, как функция, которая её объявила, вернула управление. При необходимости компилятор переносит её в кучу; управлять этим самому не нужно.

Генераторы и счётчики

Если функция возвращает замыкание, каждая возвращённая функция получает своё приватное состояние.

package main

import "fmt"

func counter() func() int {
	n := 0
	return func() int {
		n++
		return n
	}
}

func fibonacci() func() int {
	a, b := 0, 1
	return func() int {
		r := a
		a, b = b, a+b
		return r
	}
}

func main() {
	c1 := counter()
	c2 := counter()
	fmt.Println(c1(), c1(), c1()) // 1 2 3
	fmt.Println(c2())             // 1: separate n

	fib := fibonacci()
	for range 10 {
		fmt.Print(fib(), " ")
	}
	fmt.Println()
}

Каждый вызов counter() создаёт новую n, поэтому c1 и c2 считают независимо. Никто снаружи не может прочитать или сбросить n, так что это маленькая форма инкапсуляции.

Замыкания в циклах (Go 1.22 и новее)

До Go 1.22 у цикла for была одна переменная цикла на весь цикл. Все созданные внутри замыкания захватывали эту единственную переменную и видели её последнее значение. Это был самый частый баг с замыканиями в Go.

Начиная с Go 1.22 каждая итерация получает свою копию, поэтому код ниже печатает 0 1 2:

package main

import "fmt"

func main() {
	var funcs []func()
	for i := range 3 {
		funcs = append(funcs, func() { fmt.Print(i, " ") })
	}
	for _, f := range funcs {
		f()
	}
	fmt.Println()
}

В Go 1.21 и раньше тот же цикл, записанный как for i := 0; i < 3; i++ (range по целому числу тоже появился в 1.22), печатал 3 3 3. Новое правило действует для каждого модуля по строке go в go.mod, поэтому старый модуль сохраняет старое поведение, пока строку go не поднимут до 1.22 или выше. В старом коде внутри циклов до сих пор встречается i := i или v := v: это было ручное исправление, и теперь оно избыточно.

Правило «своя переменная на итерацию» касается только переменных, объявленных самой инструкцией for. Переменная, объявленная до цикла и обновляемая в теле, по-прежнему одна на всех:

var last string
for _, s := range items {
	last = s
	handlers = append(handlers, func() { use(last) }) // every closure sees the final value
}

Замыкания и горутины

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

package main

import (
	"fmt"
	"sync"
)

func main() {
	var (
		mu    sync.Mutex
		wg    sync.WaitGroup
		total int
	)
	for i := 1; i <= 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			mu.Lock()
			total += i
			mu.Unlock()
		}()
	}
	wg.Wait()
	fmt.Println(total)
}

Программа всегда печатает 5050. Каждая горутина читает свою i (семантика циклов Go 1.22) и пишет в общий total под блокировкой. Уберите мьютекс, и результат станет непредсказуемым; go run -race сообщит о гонке данных. WaitGroup и детектор гонок описаны на странице о горутинах.

Где замыкания встречаются в реальном коде

• Сортировка и поиск: slices.SortFunc, slices.IndexFunc, sort.Slice принимают функциональный литерал.
• Отложенная очистка: defer func() { ... }() выполняет блок при выходе из функции и может читать её переменные. См. defer.
• HTTP middleware: функция, которая принимает обработчик и возвращает новый литерал http.HandlerFunc, оборачивающий его.
• Конфигурация: функциональные опции (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) это замыкания над аргументом.

Пример middleware, который захватывает и параметр, и счётчик:

package main

import (
	"fmt"
	"strings"
)

type Handler func(string) string

func withLogging(name string, next Handler) Handler {
	calls := 0
	return func(in string) string {
		calls++
		out := next(in)
		fmt.Printf("%s call #%d: %q -> %q\n", name, calls, in, out)
		return out
	}
}

func main() {
	upper := withLogging("upper", strings.ToUpper)
	upper("go")
	upper("closures")
}

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

• Ожидание снимка значения. Замыкание читает текущее значение переменной в момент выполнения, а не то, что было при создании замыкания. Если нужен снимок, передайте значение параметром: go func(v int) { ... }(x).
• Рекурсивные литералы. Функциональный литерал не может сослаться на себя через переменную, которой он присваивается в том же :=. Сначала объявите переменную: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• Несинхронизированная запись из горутин. Захват не является синхронизацией. Защищайте общие записи.