Golang Closures und anonyme Funktionen, mit Beispielen

Anonyme Funktionen

Ein Funktionsliteral ist eine Funktion ohne Namen. Es ist ein Ausdruck und kann überall stehen, wo ein Wert stehen kann: in einer Variablen, als Argument, als Rückgabewert, in einem Struct-Feld.

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 hat keine Pfeil- oder Lambda-Kurzschreibweise. Die vollständige Form func(params) results { body } ist der einzige Weg.

Variablen einfangen

Ein Funktionsliteral kann Variablen der umgebenden Funktion benutzen. Es kopiert sie nicht: Closure und umgebender Code teilen sich eine Variable.

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
}

Die eingefangene Variable lebt, solange noch eine Closure auf sie verweist, auch nachdem die Funktion, die sie deklariert hat, zurückgekehrt ist. Der Compiler verschiebt sie bei Bedarf auf den Heap; darum musst du dich nie kümmern.

Generatoren und Zähler

Gibt eine Funktion eine Closure zurück, bekommt jede zurückgegebene Funktion ihren eigenen privaten Zustand.

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

Jeder Aufruf von counter() erzeugt ein neues n, also zählen c1 und c2 unabhängig voneinander. Von außen kann niemand n lesen oder zurücksetzen. Das ist eine kleine Form der Kapselung.

Closures in Schleifen (ab Go 1.22)

Vor Go 1.22 hatte eine for-Schleife eine einzige Schleifenvariable für die ganze Schleife. Alle Closures, die darin entstanden, fingen diese eine Variable ein und sahen ihren Endwert. Das war der häufigste Closure-Bug in Go.

Seit Go 1.22 bekommt jeder Durchlauf seine eigene Kopie, also gibt der Code unten 0 1 2 aus:

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

Unter Go 1.21 und älter gab dieselbe Schleife, geschrieben als for i := 0; i < 3; i++ (range über eine Ganzzahl ist ebenfalls neu in 1.22), 3 3 3 aus. Die neue Regel gilt pro Modul, abhängig von der go-Zeile in go.mod, also behält ein altes Modul das alte Verhalten, bis seine go-Zeile auf 1.22 oder höher angehoben wird. In älterem Code siehst du noch i := i oder v := v in Schleifen: Das war der manuelle Fix und ist jetzt überflüssig.

Die Regel pro Durchlauf gilt nur für Variablen, die die for-Anweisung selbst deklariert. Eine Variable, die vor der Schleife deklariert und im Rumpf aktualisiert wird, bleibt eine einzige geteilte Variable:

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

Closures und Goroutinen

Eine Goroutine, die mit einem Funktionsliteral gestartet wird, ist ebenfalls eine Closure. Es gelten dieselben Regeln fürs Teilen, dazu die übliche Regel für Nebenläufigkeit: Wenn mehrere Goroutinen eine eingefangene Variable schreiben, brauchst du einen Mutex oder einen Channel.

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

Das gibt immer 5050 aus. Jede Goroutine liest ihr eigenes i (Schleifensemantik ab Go 1.22) und schreibt das geteilte total unter einem Lock. Entfernst du den Mutex, wird das Ergebnis unvorhersehbar; go run -race meldet ein Data Race. Zu WaitGroup und dem Race Detector siehe Goroutinen.

Wo Closures in echtem Code auftauchen

• Sortieren und Suchen: slices.SortFunc, slices.IndexFunc und sort.Slice nehmen alle ein Funktionsliteral.
• Aufräumen mit defer: defer func() { ... }() führt beim Verlassen der Funktion einen Block aus und kann die Variablen der Funktion lesen. Siehe defer.
• HTTP-Middleware: eine Funktion, die einen Handler nimmt und ein neues http.HandlerFunc-Literal zurückgibt, das ihn umhüllt.
• Konfiguration: Functional Options (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) sind Closures über das Argument.

Ein Middleware-Beispiel, das sowohl einen Parameter als auch einen Zähler einfängt:

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

Häufige Fehler

• Einen Schnappschuss erwarten. Eine Closure liest den aktuellen Wert der Variable, wenn sie läuft, nicht den Wert beim Erzeugen. Brauchst du einen Schnappschuss, übergib den Wert als Parameter: go func(v int) { ... }(x).
• Rekursive Literale. Ein Funktionsliteral kann sich nicht über die Variable selbst aufrufen, der es im selben := zugewiesen wird. Deklarier die Variable zuerst: var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• Unsynchronisierte Schreibzugriffe aus Goroutinen. Einfangen ist keine Synchronisation. Schütze geteilte Schreibzugriffe.