可変個引数関数

Variadic functions accept an arbitrary number of arguments of the same type. You declare them by putting ... before the type of the last parameter. Inside the function the parameter is a slice.

Declaration

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

sum()              // 0   (nums = []int{})
sum(1)             // 1
sum(1, 2, 3, 4)    // 10

Only the last parameter can be variadic:

func log(prefix string, values ...any) { ... }   // ok
// func wrong(...int, suffix string) {}            // ERRORE

Spreading a slice

If you already have a slice, you can pass it to a variadic function with ...:

nums := []int{1, 2, 3}
sum(nums...)         // 6 — espande lo slice nei singoli argomenti

The "..." goes after the slice. Without spread you'd get a type error: you'd be passing a []int where the function expects a sequence of int.

nums is a slice, not a new container

Inside the function nums has type []int. All standard slice operations work: len(nums), nums[0], range, etc.

Classic use case: fmt.Println

All of fmt's Print* functions are variadic:

// signature (semplificata):
// func Println(a ...any) (n int, err error)

fmt.Println("ciao", 42, true)
args := []any{"a", "b", "c"}
fmt.Println(args...)

Try it

func f(args ...string) {
    _ = args
}

Recap

• ...T as the LAST parameter = variadic function; inside it's []T.
• Called with single values: the compiler collects them into a slice.
• Called with an existing slice: slice... (spread, reuses the slice).
• All fmt.Print* functions are variadic.
• Only the last parameter can be variadic.