在Go语言里，可变参数函数是指接收不定数量参数的函数，这种写法能让API更简洁，也方便做参数扩展。它的核心是在函数最后一个参数类型前加省略号，Go会把传入的多个值自动组装成该类型的切片。理解它的工作机制，有助于我们写出更通用且性能可控的代码。
一、可变参数函数的基本语法
声明可变参数函数时，末尾参数形如 vals ...int 或 items ...interface{}。在函数体内，这个参数就是一个普通的切片，可以遍历也可以取长度。调用时，你可以直接罗列多个值，也可以把一个切片用 slice... 的形式展开传入。
下面是最简单的求和函数示例，它接收任意个 int 并返回总和：
package main
import "fmt"
// sum 接收不定数量的int参数
func sum(nums ...int) int {
total := 0
for _, n := range nums {
total += n
}
return total
}
func main() {
// 直接传多个值
fmt.Println(sum(1, 2, 3))
// 传切片并展开
s := []int{4, 5, 6}
fmt.Println(sum(s...))
}
从上面的代码可以看出，nums 在函数内就是 []int 类型。如果调用时一个参数都不传，nums 会是长度为0的空切片，而不是 nil，这一点在判空逻辑里要注意。
另外，可变参数必须是参数列表的最后一项。如果你尝试写成 func f(a ...int, b string)，编译器会直接报错。这是语法层面的强制约束，目的是避免调用时产生歧义。
二、使用 interface{} 实现泛型式参数扩展
在 Go 1.18 之前没有正式泛型时，很多库用 ...interface{} 来接收任意类型。这样函数可以接收混合类型的参数，但在函数内需要做类型断言或反射来处理。
下面是一个简单的日志打印函数，它可以接收任意数量和类型的参数：
package main
import "fmt"
import "time"
// logInfo 接收任意类型的可变参数
func logInfo(args ...interface{}) {
prefix := time.Now().Format("15:04:05")
fmt.Print(prefix, " ")
for _, a := range args {
fmt.Print(a, " ")
}
fmt.Println()
}
func main() {
logInfo("user", 123, "login", true)
logInfo("system", "started")
}
这种写法在工具函数中非常普遍，例如 fmt.Println 本身就是 ...interface{}。它的好处是调用方不用自己组装切片，写起来自然。缺点是编译期无法检查类型，错误使用可能要到运行时才暴露。
如果现在用 Go 1.18 以上的版本，也可以结合泛型约束来写更安全的可变参数函数，例如 func printAll[T any](items ...T)，这样既保留扩展能力，又能在编译期确定类型。
三、切片展开与性能注意点
当已经有一个切片，需要传给可变参数函数时，要用 slice... 语法展开。这个操作在底层会复用原切片头，不会额外拷贝元素，因此是比较廉价的。
但要小心在循环里反复展开大切片，或者把切片展开后再 append 进另一个可变参数调用，可能会触发多次分配。看下面这段有问题的代码：
package main
import "fmt"
func join(parts ...string) string {
result := ""
for _, p := range parts {
result += p
}
return result
}
func main() {
base := []string{"a", "b", "c"}
more := []string{"d", "e"}
// 不好的做法：先展开再append产生新切片
combined := append(base, more...)
fmt.Println(join(combined...))
}
在上面的例子中，append(base, more...) 会生成新切片，再展开传给 join。如果 base 很大且调用频繁，会带来不必要的内存分配。更合理的做法是直接让 join 接收切片参数，或者预先分配好容量。
另一个常见误区是以为可变参数函数一定能接收 nil 切片。实际上传 nil... 是非法语法，你必须传一个具体切片变量再加省略号，或者什么都不传。如果需要兼容 nil，可以在函数内部判断长度而非是否 nil。
四、实战：封装带上下文的错误函数
在业务代码里，我们常需要把错误和附加信息一起返回。用可变参数可以写出清晰的包装函数：
package main
import (
"errors"
"fmt"
)
// wrapError 把基础错误和上下文信息组合
func wrapError(err error, msgs ...string) error {
if err == nil {
return nil
}
extra := ""
for _, m := range msgs {
extra += " | " + m
}
return fmt.Errorf("%w%s", err, extra)
}
func main() {
base := errors.New("db failed")
err := wrapError(base, "user_id=10", "retry=0")
fmt.Println(err)
}
这个函数让调用方按需补充任意条上下文，而不用拼字符串。它比固定两个参数更灵活，也避免了为了扩展参数而频繁改签名。
总结来看，Golang 的可变参数函数是参数扩展的轻量方案。掌握省略号语法、切片展开规则以及类型选择，就能在API设计和工具封装中用好它，同时避开隐藏的分配陷阱。