例子

函数变参的定义：
func Printf(format string, a ...interface{}) (n int, err error) { ... }

调用方式
Printf("%s-%d-%s", "AAA", 123, "BBB")

传递方式

在函数调用的时候，caller会把所有的变参转换成一个slice对象，然后传递给callee，

package main

import "fmt"
import "reflect"

func foo1(args ...string) {
    fmt.Println("=====foo1()====")
    fmt.Println("Type=", reflect.TypeOf(args))
    fmt.Println("Value=", reflect.ValueOf(args))
    fmt.Println(args)
}

func main() {
    foo1("aaa", "bbb", "ccc")
}

运行结果为：

$ go build && ./main     
=====foo1()====
Type= []string
Value= [aaa bbb ccc]
[aaa bbb ccc]

可以很清楚的看到在foo1函数内，args的类型是[]string是一个slice.

main函数内容可以这么写，能产生同样的结果：

func main() {
    //foo1("aaa", "bbb", "ccc")
    params := []string{"aaa", "bbb", "ccc"}
    foo1(params...) // notice: not foo1(params)
}

如何变参传递给其他变参函数

这里我们讨论的是如何传递变参给另一个变参函数，如果对象不是一个变参函数，那么调用者可以分析slice得到每一个元素，这样就随便处理了。

把变参作为整体传给另一个变参函数也很容易，使用"args..."就行，例如上述代码再调用fmt.Printf

package main

import "fmt"
import _ "reflect"

func foo1(args ...interface{}) {
    fmt.Printf("%s-%s-%s", args...)
}

func main() {
    foo1("aaa", "bbb", "ccc")
}

运行结果

$ go build && ./main 
aaa-bbb-ccc

如果没有使用args...，而是直接使用了args会出什么结果呢？

package main

import "fmt"
import _ "reflect"

func foo1(args ...interface{}) {
    fmt.Printf("%s-%s-%s", args)
}

func main() {
    foo1("aaa", "bbb", "ccc")
}

运行结果：

$ go build && ./main 
[aaa bbb ccc]-%!s(MISSING)-%!s(MISSING)

这里因为"%s-%s-%s"，需要三个string类型来匹配，而args作为整体只能算是提供了第一个参数。所以导致
第一个%s <- args, 即[]string {"aaa", "bbb", "ccc"}
第二个%s <- 没有值
第三个%s <- 没有值

常用场景

这个需求经常被用在自定义log输出的场合。比如

func myInfo(formating string, args ...interface{}) {
  // fmt.Printf(fInfoormating+"\n", args...)
  fmt.Printf("INFO: %s", fmt.Sprintf(formatting, args...))
}

func myDebug(formating string, args ...interface{}) {
  // fmt.Printf(fInfoormating+"\n", args...)
  fmt.Printf("DEBUG: %s", fmt.Sprintf(formatting, args...))
}

调用者

myInfo("Hello World");
myDebug("This is the %d bug", 12)
myDebug("This %s are %d", "AAA", 20)