Funções variádicas em Golang: parâmetros ...T e o espalhamento s...

O parâmetro ...T

Coloque ... antes do tipo do último parâmetro. Quem chama pode então passar qualquer quantidade de argumentos daquele tipo, inclusive nenhum. Dentro da função, o parâmetro é um 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))
}

Isto imprime 0, 5 e 10. Sem argumentos, nums é um slice nil de tamanho 0, então o laço simplesmente não executa.

Parâmetros comuns podem vir antes. Só o último pode ser variádico:

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

Passando um slice com s...

Se você já tem um slice, não pode passá-lo diretamente: sum(nums) falha com cannot use nums (variable of type []int) as int value in argument to sum. Espalhe-o com ... depois do argumento:

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

O append também é variádico, e por isso juntar dois slices é append(a, b...).

O espalhamento precisa ser a única coisa na posição variádica. sum(1, nums...) falha com too many arguments in call to sum. Monte antes o slice combinado com append.

O slice é compartilhado, não copiado

Quando você chama com argumentos avulsos, o Go cria um slice novo para eles. Quando você espalha um slice existente com s..., a função recebe aquele mesmo slice. Escritas nos elementos dele alteram os dados de quem chama.

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
}

Saída:

[7 8 9]
[0 8 9]

Uma função variádica que modifica o seu parâmetro deveria documentar isso, ou copiar antes com slices.Clone. A maioria das funções variádicas só lê os argumentos, então isso raramente dá problema, mas é uma diferença real em relação a linguagens em que os parâmetros rest são sempre um array novo.

...any e como o fmt.Println funciona

fmt.Println é declarada como func Println(a ...any) (n int, err error). any (um alias de interface{} desde o Go 1.18) aceita qualquer tipo, então você pode passar strings, números e structs na mesma chamada.

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

O detalhe importante é o repasse: logf passa args... para o Printf. Sem os pontos, o Printf recebe um único argumento, um []any, e a linha de aviso imprime [WARN] [3 8] of %!d(MISSING) workers idle. O go vet só reporta missing ... in args forwarded to printf-like function quando o parâmetro de formato é repassado sem alteração, como em fmt.Printf(format, args). Aqui o formato é montado com +, então o vet fica quieto e os pontos são responsabilidade sua.

Um []string não pode ser espalhado em ...any. Os tipos dos elementos precisam bater exatamente, então converta antes:

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

Exigindo pelo menos um argumento

Um parâmetro variádico aceita zero argumentos. Quando a função precisa de pelo menos um, transforme o primeiro em parâmetro comum:

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

Agora maxOf() é erro de compilação em vez de uma verificação em tempo de execução. A própria função embutida max funciona assim: ela exige pelo menos um argumento.

Parâmetros variádicos como argumentos opcionais

Go não tem valores padrão para parâmetros. Às vezes um parâmetro variádico é usado para simular um argumento opcional:

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

Funciona, mas fica pouco legível, já que quem chama pode passar três timeouts e a assinatura não diz qual deles vale. Para mais de uma opção, prefira uma struct de configuração ou o padrão functional options (...Option, em que cada Option é uma função que define um campo). Esse padrão é variádico, mas cada argumento tem um significado claro.

Referência das regras