Go 可变参数函数：...T 参数与 s... 展开

...T 参数

在最后一个参数的类型前加上 ...。这样调用方就可以传入任意数量的该类型参数，一个都不传也可以。在函数内部，这个参数是一个切片。

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

程序输出 0、5 和 10。没有参数时，nums 是一个长度为 0 的 nil 切片，所以循环根本不会执行。

普通参数可以放在前面，只有最后一个参数可以是可变参数：

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

用 s... 传入切片

如果你手上已经有一个切片，不能直接把它传进去：sum(nums) 会报错 cannot use nums (variable of type []int) as int value in argument to sum。在参数后面加上 ... 把它展开：

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 也是可变参数函数，所以拼接两个切片的写法是 append(a, b...)。

可变参数的位置上只能放这一个展开的切片。sum(1, nums...) 会报错 too many arguments in call to sum。先用 append 构造出合并后的切片。

切片是共享的，不是复制的

用单个参数调用时，Go 会为这些参数新建一个切片。用 s... 展开一个已有的切片时，函数收到的就是同一个切片。修改它的元素会改变调用方的数据。

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
}

输出：

[7 8 9]
[0 8 9]

会修改参数的可变参数函数应该在文档里写明这一点，或者先用 slices.Clone 复制一份。大多数可变参数函数只读取参数，所以这个问题很少出现，但在有些语言里剩余参数总是一个新数组，这一点和它们确实不同。

...any 与 fmt.Println 的原理

fmt.Println 的声明是 func Println(a ...any) (n int, err error)。any（从 Go 1.18 起是 interface{} 的别名）可以接收任何类型，所以你可以在一次调用里传入字符串、数字和结构体。

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

关键在于转发：logf 把 args... 传给 Printf。如果漏掉这三个点，Printf 只会收到一个参数，也就是一个 []any，警告那一行会打印成 [WARN] [3 8] of %!d(MISSING) workers idle。只有当格式参数被原样传递时，比如 fmt.Printf(format, args)，go vet 才会报告 missing ... in args forwarded to printf-like function。这里的格式字符串是用 + 拼出来的，所以 vet 不会提示，这三个点得靠你自己记住。

[]string 不能展开传给 ...any。元素类型必须完全一致，所以要先转换：

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

要求至少传一个参数

可变参数可以接收零个参数。如果函数至少需要一个参数，就把第一个参数写成普通参数：

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

这样 maxOf() 就会变成编译错误，而不需要在运行时检查。内置的 max 也是这样设计的：它至少需要一个参数。

用可变参数模拟可选参数

Go 没有参数默认值。有时人们会用可变参数来模拟一个可选参数：

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

这种写法能用，但可读性差：调用方可以传入三个超时时间，而函数签名并没有说明哪个生效。如果有不止一个选项，更好的做法是用一个配置结构体，或者使用函数式选项模式（...Option，每个 Option 都是一个设置某个字段的函数）。这种模式也是可变参数，但每个参数的含义都很清楚。

规则速查