Golang Variadic Functions: ...T Params and s... Spreading

The ...T parameter

Put ... before the type of the last parameter. Callers can then pass any number of arguments of that type, including none. Inside the function the parameter is a 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))
}

This prints 0, 5 and 10. With no arguments, nums is a nil slice with length 0, so the loop simply does not run.

Regular parameters can come first. Only the last one may be variadic:

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

Passing a slice with s...

If you already have a slice, you cannot pass it directly: sum(nums) fails with cannot use nums (variable of type []int) as int value in argument to sum. Spread it with ... after the 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 is variadic too, which is why joining two slices is append(a, b...).

The spread must be the only thing in the variadic position. sum(1, nums...) fails with too many arguments in call to sum. Build the combined slice first with append.

The slice is shared, not copied

When you call with individual arguments, Go creates a fresh slice for them. When you spread an existing slice with s..., the function receives that same slice. Writes to its elements change the caller's data.

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
}

Output:

[7 8 9]
[0 8 9]

A variadic function that modifies its parameter should document that, or copy first with slices.Clone. Most variadic functions only read their arguments, so this rarely bites, but it is a real difference from languages where rest parameters are always a fresh array.

...any and how fmt.Println works

fmt.Println is declared as func Println(a ...any) (n int, err error). any (an alias for interface{} since Go 1.18) accepts every type, so you can pass strings, numbers and structs in one call.

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

Forwarding is the important detail: logf passes args... to Printf. Without the dots, Printf receives one argument, a []any, and the warning line prints [WARN] [3 8] of %!d(MISSING) workers idle. go vet reports missing ... in args forwarded to printf-like function only when the format parameter is passed through unchanged, as in fmt.Printf(format, args). Here the format is built with +, so vet stays silent and the dots are on you.

A []string cannot be spread into ...any. The element types must match exactly, so convert first:

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

Requiring at least one argument

A variadic parameter accepts zero arguments. When the function needs at least one, make the first a regular 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))
}

Now maxOf() is a compile error instead of a runtime check. The built-in max itself works the same way: it requires at least one argument.

Variadic parameters as optional arguments

Go has no default parameter values. A variadic parameter is sometimes used to fake one optional argument:

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

This works but reads poorly, since callers can pass three timeouts and the signature does not say which one wins. For more than one option, prefer a config struct, or the functional options pattern (...Option, where each Option is a function that sets a field). That pattern is variadic, but every argument has a clear meaning.

Rules Reference