Funciones variádicas en Golang: parámetros ...T y expandir con s...

El parámetro ...T

Pon ... delante del tipo del último parámetro. Quien llama puede pasar entonces cualquier número de argumentos de ese tipo, incluido ninguno. Dentro de la función el parámetro es un 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))
}

Esto imprime 0, 5 y 10. Sin argumentos, nums es un slice nil de longitud 0, así que el bucle simplemente no se ejecuta.

Los parámetros normales pueden ir primero. Solo el último puede ser variádico:

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

Pasar un slice con s...

Si ya tienes un slice, no puedes pasarlo directamente: sum(nums) falla con cannot use nums (variable of type []int) as int value in argument to sum. Expándelo con ... detrás del 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)
}

append también es variádica, y por eso unir dos slices es append(a, b...).

La expansión tiene que ser lo único que haya en la posición variádica. sum(1, nums...) falla con too many arguments in call to sum. Construye antes el slice combinado con append.

El slice se comparte, no se copia

Cuando llamas con argumentos sueltos, Go crea un slice nuevo para ellos. Cuando expandes un slice existente con s..., la función recibe ese mismo slice. Las escrituras en sus elementos cambian los datos de quien llama.

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
}

Salida:

[7 8 9]
[0 8 9]

Una función variádica que modifica su parámetro debería documentarlo, o copiarlo antes con slices.Clone. La mayoría de funciones variádicas solo leen sus argumentos, así que rara vez muerde, pero es una diferencia real con los lenguajes donde los parámetros rest son siempre un array nuevo.

...any y cómo funciona fmt.Println

fmt.Println está declarada como func Println(a ...any) (n int, err error). any (un alias de interface{} desde Go 1.18) acepta cualquier tipo, así que puedes pasar strings, números y structs en una sola llamada.

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

Reenviar es el detalle importante: logf pasa args... a Printf. Sin los puntos, Printf recibe un solo argumento, un []any, y la línea de aviso imprime [WARN] [3 8] of %!d(MISSING) workers idle. go vet informa de missing ... in args forwarded to printf-like function solo cuando el parámetro de formato se pasa sin cambios, como en fmt.Printf(format, args). Aquí el formato se construye con +, así que vet no dice nada y los puntos son cosa tuya.

Un []string no se puede expandir en un ...any. Los tipos de los elementos tienen que coincidir exactamente, así que convierte antes:

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

Exigir al menos un argumento

Un parámetro variádico acepta cero argumentos. Cuando la función necesita al menos uno, haz que el primero sea un parámetro normal:

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

Ahora maxOf() es un error de compilación en lugar de una comprobación en tiempo de ejecución. La propia función integrada max funciona igual: exige al menos un argumento.

Parámetros variádicos como argumentos opcionales

Go no tiene valores por defecto en los parámetros. A veces se usa un parámetro variádico para simular un argumento opcional:

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

Funciona, pero se lee mal, porque quien llama puede pasar tres timeouts y la firma no dice cuál gana. Para más de una opción, prefiere un struct de configuración o el patrón de opciones funcionales (...Option, donde cada Option es una función que asigna un campo). Ese patrón es variádico, pero cada argumento tiene un significado claro.

Referencia de reglas