Fonctions variadiques en Golang : paramètres ...T et expansion s...

Le paramètre ...T

Placez ... devant le type du dernier paramètre. Les appelants peuvent alors passer un nombre quelconque d'arguments de ce type, y compris aucun. Dans la fonction, le paramètre est une slice.

package main

import "fmt"

func sum(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	fmt.Println(sum())
	fmt.Println(sum(5))
	fmt.Println(sum(1, 2, 3, 4))
}

Ce code affiche 0, 5 et 10. Sans argument, nums est une slice nil de longueur 0, donc la boucle ne s'exécute tout simplement pas.

Des paramètres ordinaires peuvent venir avant. Seul le dernier peut être variadique :

func logf(level string, format string, args ...any)

Passer une slice avec s...

Si vous avez déjà une slice, vous ne pouvez pas la passer directement : sum(nums) échoue avec cannot use nums (variable of type []int) as int value in argument to sum. Développez-la avec ... après l'argument :

package main

import "fmt"

func sum(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	nums := []int{10, 20, 30}
	fmt.Println(sum(nums...))

	more := append([]int{1, 2}, nums...)
	fmt.Println(more)
}

append est aussi variadique, c'est pourquoi joindre deux slices s'écrit append(a, b...).

L'expansion doit être la seule chose à la position variadique. sum(1, nums...) échoue avec too many arguments in call to sum. Construisez d'abord la slice combinée avec append.

La slice est partagée, pas copiée

Quand vous appelez avec des arguments individuels, Go crée une nouvelle slice pour eux. Quand vous développez une slice existante avec s..., la fonction reçoit cette même slice. Écrire dans ses éléments modifie les données de l'appelant.

package main

import "fmt"

func zeroFirst(xs ...int) {
	if len(xs) > 0 {
		xs[0] = 0
	}
}

func main() {
	nums := []int{7, 8, 9}

	zeroFirst(nums[0], nums[1], nums[2])
	fmt.Println(nums) // untouched: a new slice was built

	zeroFirst(nums...)
	fmt.Println(nums) // changed: the same backing array
}

Sortie :

[7 8 9]
[0 8 9]

Une fonction variadique qui modifie son paramètre devrait le documenter, ou copier d'abord avec slices.Clone. La plupart des fonctions variadiques ne font que lire leurs arguments, donc cela piège rarement, mais c'est une vraie différence avec les langages où les paramètres rest sont toujours un nouveau tableau.

...any et le fonctionnement de fmt.Println

fmt.Println est déclarée func Println(a ...any) (n int, err error). any (un alias de interface{} depuis Go 1.18) accepte tous les types, donc vous pouvez passer des chaînes, des nombres et des structs dans un même appel.

package main

import (
	"fmt"
	"strings"
)

func logf(level, format string, args ...any) {
	prefix := "[" + strings.ToUpper(level) + "] "
	fmt.Printf(prefix+format+"\n", args...)
}

func main() {
	logf("info", "server started on port %d", 8080)
	logf("warn", "%d of %d workers idle", 3, 8)
	logf("error", "no arguments here")
}

La transmission est le détail important : logf passe args... à Printf. Sans les points, Printf reçoit un seul argument, un []any, et la ligne d'avertissement affiche [WARN] [3 8] of %!d(MISSING) workers idle. go vet ne signale missing ... in args forwarded to printf-like function que lorsque le paramètre de format est transmis tel quel, comme dans fmt.Printf(format, args). Ici le format est construit avec +, donc vet reste silencieux et les points sont à votre charge.

Une []string ne peut pas être développée dans un ...any. Les types des éléments doivent correspondre exactement, donc convertissez d'abord :

names := []string{"a", "b"}
args := make([]any, len(names))
for i, n := range names {
	args[i] = n
}
fmt.Println(args...)

Exiger au moins un argument

Un paramètre variadique accepte zéro argument. Quand la fonction en a besoin d'au moins un, faites du premier un paramètre ordinaire :

package main

import "fmt"

func maxOf(first int, rest ...int) int {
	m := first
	for _, n := range rest {
		m = max(m, n)
	}
	return m
}

func main() {
	fmt.Println(maxOf(3))
	fmt.Println(maxOf(3, 9, 4))
}

maxOf() devient alors une erreur de compilation au lieu d'une vérification à l'exécution. La fonction intégrée max fonctionne de la même façon : elle exige au moins un argument.

Les paramètres variadiques comme arguments facultatifs

Go n'a pas de valeurs de paramètre par défaut. Un paramètre variadique sert parfois à simuler un argument facultatif :

func connect(addr string, timeout ...time.Duration)

Cela fonctionne mais se lit mal, puisque les appelants peuvent passer trois timeouts et que la signature ne dit pas lequel l'emporte. Pour plus d'une option, préférez une struct de configuration, ou le motif des options fonctionnelles (...Option, où chaque Option est une fonction qui définit un champ). Ce motif est variadique, mais chaque argument a un sens clair.

Référence des règles