Golang variadische Funktionen: ...T-Parameter und s...

Der ...T-Parameter

Setz ... vor den Typ des letzten Parameters. Aufrufer können dann beliebig viele Argumente dieses Typs übergeben, auch keins. Innerhalb der Funktion ist der Parameter ein 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))
}

Das gibt 0, 5 und 10 aus. Ohne Argumente ist nums ein nil-Slice mit Länge 0, also läuft die Schleife einfach nicht.

Normale Parameter können davor stehen. Nur der letzte darf variadisch sein:

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

Einen Slice mit s... übergeben

Wenn du schon einen Slice hast, kannst du ihn nicht direkt übergeben: sum(nums) scheitert mit cannot use nums (variable of type []int) as int value in argument to sum. Spreize ihn mit ... hinter dem 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 ist ebenfalls variadisch. Deshalb verbindest du zwei Slices mit append(a, b...).

Der Spread muss allein an der variadischen Position stehen. sum(1, nums...) scheitert mit too many arguments in call to sum. Bau den kombinierten Slice vorher mit append.

Der Slice wird geteilt, nicht kopiert

Rufst du mit einzelnen Argumenten auf, erzeugt Go für sie einen neuen Slice. Spreizt du einen vorhandenen Slice mit s..., bekommt die Funktion genau diesen Slice. Schreibzugriffe auf seine Elemente ändern die Daten des Aufrufers.

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
}

Ausgabe:

[7 8 9]
[0 8 9]

Eine variadische Funktion, die ihren Parameter verändert, sollte das dokumentieren oder vorher mit slices.Clone kopieren. Die meisten variadischen Funktionen lesen ihre Argumente nur, daher beißt das selten, aber es ist ein echter Unterschied zu Sprachen, in denen Rest-Parameter immer ein neues Array sind.

...any und wie fmt.Println funktioniert

fmt.Println ist als func Println(a ...any) (n int, err error) deklariert. any (seit Go 1.18 ein Alias für interface{}) akzeptiert jeden Typ, also kannst du Strings, Zahlen und Structs in einem Aufruf übergeben.

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

Entscheidend ist das Weiterreichen: logf übergibt args... an Printf. Ohne die Punkte bekommt Printf ein einziges Argument, ein []any, und die Warnzeile lautet [WARN] [3 8] of %!d(MISSING) workers idle. go vet meldet missing ... in args forwarded to printf-like function nur, wenn der Format-Parameter unverändert durchgereicht wird, wie in fmt.Printf(format, args). Hier wird das Format mit + gebaut, also schweigt vet, und die Punkte sind deine Verantwortung.

Ein []string lässt sich nicht in ...any spreizen. Die Elementtypen müssen exakt passen, also konvertierst du vorher:

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

Mindestens ein Argument verlangen

Ein variadischer Parameter akzeptiert null Argumente. Braucht die Funktion mindestens eins, mach das erste zu einem normalen Parameter:

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

Jetzt ist maxOf() ein Compilerfehler statt einer Prüfung zur Laufzeit. Das eingebaute max funktioniert genauso: Es verlangt mindestens ein Argument.

Variadische Parameter als optionale Argumente

Go hat keine Standardwerte für Parameter. Manchmal wird ein variadischer Parameter benutzt, um ein optionales Argument nachzubilden:

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

Das funktioniert, liest sich aber schlecht, weil Aufrufer drei Timeouts übergeben können und die Signatur nicht sagt, welcher gewinnt. Für mehr als eine Option nimm lieber ein Config-Struct oder das Functional-Options-Pattern (...Option, wobei jede Option eine Funktion ist, die ein Feld setzt). Dieses Pattern ist variadisch, aber jedes Argument hat eine klare Bedeutung.

Regeln im Überblick