Domknięcia i funkcje anonimowe w Go (Golang) z przykładami

Funkcje anonimowe

Literał funkcji to funkcja bez nazwy. Jest wyrażeniem, więc może trafić wszędzie tam, gdzie wartość: do zmiennej, argumentu, wartości zwracanej, pola struktury.

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 nie ma skróconej składni ze strzałką ani lambd. Pełna forma func(params) results { body } to jedyny sposób zapisu.

Przechwytywanie zmiennych

Literał funkcji może używać zmiennych z otaczającej funkcji. Nie kopiuje ich: domknięcie i otaczający kod dzielą jedną zmienną.

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
}

Przechwycona zmienna żyje tak długo, jak długo odwołuje się do niej jakieś domknięcie, nawet gdy funkcja, która ją zadeklarowała, już zwróciła wynik. Kompilator w razie potrzeby przenosi ją na stertę; nie musisz tym w ogóle zarządzać.

Generatory i liczniki

Zwrócenie domknięcia z funkcji daje każdej zwróconej funkcji jej własny, prywatny stan.

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

Każde wywołanie counter() tworzy nowe n, więc c1 i c2 liczą niezależnie. Nic z zewnątrz nie może odczytać ani wyzerować n, co jest małą formą enkapsulacji.

Domknięcia w pętlach (Go 1.22 i nowsze)

Przed Go 1.22 pętla for miała jedną zmienną pętli na całą pętlę. Domknięcia utworzone w jej wnętrzu przechwytywały tę jedną zmienną i widziały jej końcową wartość. To był najczęstszy błąd z domknięciami w Go.

Od Go 1.22 każda iteracja dostaje własną kopię, więc poniższy kod wypisuje 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()
}

W Go 1.21 i starszych ta sama pętla zapisana jako for i := 0; i < 3; i++ (range po liczbie całkowitej też jest nowością w 1.22) wypisywała 3 3 3. Nowa reguła działa na poziomie modułu, na podstawie linii go w go.mod, więc stary moduł zachowuje stare zachowanie, dopóki jego linia go nie zostanie podniesiona do 1.22 lub wyżej. W starszym kodzie nadal zobaczysz i := i albo v := v w pętlach: była to ręczna poprawka, dziś zbędna.

Reguła dotycząca iteracji obejmuje tylko zmienne zadeklarowane przez samą instrukcję for. Zmienna zadeklarowana przed pętlą i zmieniana w jej ciele to nadal jedna wspólna zmienna:

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

Domknięcia i gorutyny

Gorutyna uruchomiona z literałem funkcji to też domknięcie. Obowiązują te same zasady współdzielenia, plus zwykła reguła współbieżności: jeśli kilka gorutyn zapisuje przechwyconą zmienną, potrzebujesz mutexa albo kanału.

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

To zawsze wypisuje 5050. Każda gorutyna czyta własne i (semantyka pętli z Go 1.22) i zapisuje wspólne total pod blokadą. Usuń mutex, a wynik stanie się nieprzewidywalny; go run -race zgłosi to jako wyścig danych. Na stronie o gorutynach znajdziesz WaitGroup i detektor wyścigów.

Gdzie domknięcia pojawiają się w prawdziwym kodzie

• Sortowanie i wyszukiwanie: slices.SortFunc, slices.IndexFunc, sort.Slice przyjmują literał funkcji.
• Odroczone sprzątanie: defer func() { ... }() uruchamia blok przy wyjściu z funkcji i może czytać jej zmienne. Zobacz defer.
• Middleware HTTP: funkcja, która przyjmuje handler i zwraca nowy literał http.HandlerFunc, który go opakowuje.
• Konfiguracja: opcje funkcyjne (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) to domknięcia nad argumentem.

Przykład middleware, który przechwytuje zarówno parametr, jak i licznik:

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

Typowe błędy

• Oczekiwanie migawki. Domknięcie czyta bieżącą wartość zmiennej w chwili uruchomienia, a nie wartość z chwili utworzenia domknięcia. Jeśli potrzebujesz migawki, przekaż wartość jako parametr: go func(v int) { ... }(x).
• Rekurencyjne literały. Literał funkcji nie może odwołać się do siebie przez zmienną, do której jest przypisywany w tym samym :=. Najpierw zadeklaruj zmienną: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• Niesynchronizowane zapisy z gorutyn. Przechwytywanie to nie synchronizacja. Chroń wspólne zapisy.