Closures et fonctions anonymes en Golang, avec exemples

Fonctions anonymes

Un littéral de fonction est une fonction sans nom. C'est une expression, il peut donc aller partout où va une valeur : une variable, un argument, une valeur de retour, un champ de struct.

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 n'a pas de raccourci flèche ou lambda. La forme complète func(params) results { body } est la seule façon d'en écrire un.

Capturer des variables

Un littéral de fonction peut utiliser les variables de la fonction englobante. Il ne les copie pas : la closure et le code environnant partagent une seule 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
}

La variable capturée vit tant qu'une closure y fait encore référence, même après le retour de la fonction qui l'a déclarée. Le compilateur la déplace sur le tas si nécessaire ; vous ne gérez jamais cela vous-même.

Générateurs et compteurs

Renvoyer une closure depuis une fonction donne à chaque fonction renvoyée son propre état privé.

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

Chaque appel à counter() crée un nouveau n, donc c1 et c2 comptent indépendamment. Rien à l'extérieur ne peut lire ou réinitialiser n, ce qui en fait une petite forme d'encapsulation.

Closures dans les boucles (Go 1.22 et plus)

Avant Go 1.22, une boucle for avait une seule variable de boucle pour toute la boucle. Les closures créées à l'intérieur capturaient toutes cette variable unique et voyaient sa valeur finale. C'était le bug de closure le plus fréquent en Go.

Depuis Go 1.22, chaque itération reçoit sa propre copie, donc le code ci-dessous affiche 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()
}

Avec Go 1.21 et avant, la même boucle écrite for i := 0; i < 3; i++ (le range sur un entier est aussi une nouveauté de 1.22) affichait 3 3 3. La nouvelle règle s'applique par module, selon la ligne go du go.mod, donc un ancien module garde l'ancien comportement tant que sa ligne go n'est pas passée à 1.22 ou plus. Vous verrez encore i := i ou v := v dans des boucles de code ancien : c'était la correction manuelle, elle est désormais redondante.

La règle par itération ne couvre que les variables déclarées par l'instruction for elle-même. Une variable déclarée avant la boucle et modifiée dans le corps reste une seule variable partagée :

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

Closures et goroutines

Une goroutine lancée avec un littéral de fonction est aussi une closure. Les mêmes règles de partage s'appliquent, plus la règle habituelle de la concurrence : si plusieurs goroutines écrivent une variable capturée, il vous faut un mutex ou un 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)
}

Ce code affiche toujours 5050. Chaque goroutine lit son propre i (sémantique de boucle de Go 1.22) et écrit le total partagé sous verrou. Retirez le mutex et le résultat devient imprévisible ; go run -race le signale comme data race. Voir les goroutines pour WaitGroup et le détecteur de races.

Où l'on trouve des closures dans le vrai code

• Tri et recherche : slices.SortFunc, slices.IndexFunc, sort.Slice prennent tous un littéral de fonction.
• Nettoyage différé : defer func() { ... }() exécute un bloc à la sortie de la fonction et peut lire les variables de la fonction. Voir defer.
• Middleware HTTP : une fonction qui prend un handler et renvoie un nouveau littéral http.HandlerFunc qui l'enveloppe.
• Configuration : les options fonctionnelles (func WithTimeout(d time.Duration) Option { return func(c *Config) { c.Timeout = d } }) sont des closures sur l'argument.

Un exemple de middleware qui capture à la fois un paramètre et un compteur :

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

Erreurs courantes

• S'attendre à un instantané. Une closure lit la valeur actuelle de la variable au moment où elle s'exécute, pas celle du moment où elle a été créée. Passez la valeur en paramètre si vous voulez un instantané : go func(v int) { ... }(x).
• Littéraux récursifs. Un littéral de fonction ne peut pas se référer à lui-même via la variable à laquelle il est affecté dans le même :=. Déclarez d'abord la variable : var walk func(n int); walk = func(n int) { ... walk(n-1) }.
• Écritures non synchronisées depuis des goroutines. Capturer n'est pas synchroniser. Protégez les écritures partagées.