说变长参数函数被使用得最多是因为最常用的 fmt 包、log 包中的几个导出函数都是变长参数函数：

  1. // $GOROOT/src/fmt/print.go
  2. func Println(a ...interface{}) (n int, err error)
  3. func Printf(format string, a ...interface{}) (n int, err error)
  4. func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)
  5. func Fprint(w io.Writer, a ...interface{}) (n int, err error)
  6. func Sprintf(format string, a ...interface{}) string
  7. func Sprintln(a ...interface{}) string
  9. // $GOROOT/src/log/log.go
  10. func Printf(format string, v ...interface{})
  11. func Println(v ...interface{}) 
  12. func Fatal(v ...interface{})
  13. func Fatalf(format string, v ...interface{})
  14. func Fatalln(v ...interface{}) 
  15. func Panic(v ...interface{})
  16. func Panicf(format string, v ...interface{})
  17. func Panicln(v ...interface{})

1. 什么是变长参数函数

顾名思义，变长参数函数就是指函数调用时可以接受零个、一个或多个实际参数，就像下面对 fmt.Println 的调用那样：

  1. fmt.Println() // ok
  2. fmt.Println("Tony", "Bai") // ok
  3. fmt.Println("Tony", "Bai", "is", "a", "gopher") // ok

对照下面 fmt.Println 函数的原型：

  1. func Println(a ...interface{}) (n int, err error)

一个变长参数函数只能有一个 ...T 类型形式参数，并且该形式参数应该为函数参数列表中的最后一个形式参数，否则 Go 编译器就会给出如下错误提示：

  1. func foo(args ...int, s string) int // syntax error: cannot use ... with non-final parameter args
  2. func bar(args1 ...int, args2 ...string) int // syntax error: cannot use ... with non-final parameter args1

变长参数函数的”…T“类型形式参数在函数体内呈现为[]T 类型的变量，我们可以将其理解为一个 Go 语法甜头：

  1. // variadic_function_1.go
  2. func sum(args ...int) int {
  3.         var total int
  5.         // 下面的args的类型为[]int
  6.         for _, v := range args { 
  7.                 total += v
  8.         }
  10.         return total
  11. }

但在函数外部，”…T“ 类型形式参数可匹配和接受的实参类型有两种：

  • 多个 T 类型变量；
  • t…（t 为 []T 类型变量）；
  1. // variadic_function_1.go
  3. func main() {
  4.         a, b, c := 1, 2, 3
  5.         println(sum(a, b, c)) // 传入多个int类型的变量
  6.         nums := []int{4, 5, 6}
  7.         println(sum(nums...)) // 传入"nums..."，num为[]int型变量
  8. }

使用变长参数函数时最容易出现的一个问题就是实参与形参的不匹配，比如下面这个例子：

  1. // variadic_function_2.go
  2. package main
  4. import "fmt"
  6. func dump(args ...interface{}) {
  7.     for _, v := range args {
  8.         fmt.Println(v)
  9.     }
  10. }
  12. func main() {
  13.     s := []string{"Tony", "John", "Jim"}
  14.     dump(s...)
  15. }

运行这段代码：

  1. $ go run variadic_function_2.go
  2. # command-line-arguments
  3. ./variadic_function_2.go:14:6: cannot use s (type []string) as type []interface {} in argument to dump

要消除编译错误，我们仅需将变量 s 的类型换为 []interface{}：

  1. // variadic_function_2.go
  3. ... ...
  5. func main() {
  6.     s := []interface{}{"Tony", "John", "Jim"}
  7.     dump(s...)
  8. }
  10. $ go run variadic_function_2.go 
  11. Tony
  12. John
  13. Jim

不过有个例外，那就是 Go 内置的 append 函数，它支持通过下面的方式将字符串附加到一个字节切片后面：

  1. // variadic_function_3.go
  2. package main
  4. import "fmt"
  6. func main() {
  7.     b := []byte{}
  8.     b = append(b, "hello"...)
  9.     fmt.Println(string(b))
  10. }
  12. $ go run variadic_function_3.go
  13. hello

2. 模拟函数重载

Go 语言不允许在同一个作用域下定义名字相同但函数原型不同的函数，如果定义这样的函数，Go 编译器会提示下面错误信息：

  1. // variadic_function_4.go
  2. package main
  4. import (
  5.     "fmt"
  6.     "strings"
  7. )
  9. func concat(a, b int) string {
  10.     return fmt.Printf("%d %d", a, b)
  11. }
  13. func concat(x, y string) string {
  14.     return x + " " + y
  15. }
  17. func concat(s []string) string {
  18.     return strings.Join(s, " ")
  19. }
  21. func main() {
  22.     println(concat(1, 2))
  23.     println(concat("hello", "gopher"))
  24.     println(concat([]string{"hello", "gopher", "!"}))
  25. }
  27. $ go run variadic_function_4.go
  28. # command-line-arguments
  29. ./variadic_function_4.go:9:2: too many arguments to return
  30.     have (int, error)
  31.     want (string)
  32. ./variadic_function_4.go:12:6: concat redeclared in this block
  33.     previous declaration at ./variadic_function_4.go:8:23
  34. ./variadic_function_4.go:16:6: concat redeclared in this block
  35.     previous declaration at ./variadic_function_4.go:12:26
  36. ./variadic_function_4.go:21:16: too many arguments in call to concat
  37.     have (number, number)
  38.     want ([]string)
  39. ./variadic_function_4.go:22:16: too many arguments in call to concat
  40.     have (string, string)
  41.     want ([]string)

如果要修复上面的例子程序，我们需要将三个”concat“函数作分别命名，比如：

  1. concatTwoInt
  2. concatTwoString
  3. concatStrings

但 Go 语言并不支持函数重载，Go 语言官方常见问答(即：FAQ)中给出的不支持的理由如下:

其他语言的经验告诉我们，使用具有相同名称但函数签名不同的多种方法有时会很有用，但在实践中也可能会造成混淆和脆弱性。 在 Go 的类型系统中，仅按名称进行匹配并要求类型一致是一个主要的简化决策。

如果要重载的函数的参数都是相同类型的，仅参数的个数是变化的，那么变长参数函数可以轻松对应；如果参数类型不同且个数可变，那么我们还要结合 interface{}类型的特性。我们来看一个例子：

  1. // variadic_function_5.go
  2. package main
  4. import (
  5.     "fmt"
  6.     "strings"
  7. )
  9. func concat(sep string, args ...interface{}) string {
  10.     var result string
  11.     for i, v := range args {
  12.         if i != 0 {
  13.             result += sep
  14.         }
  15.         switch v.(type) {
  16.         case int, int8, int16, int32, int64,
  17.             uint, uint8, uint16, uint32, uint64:
  18.             result += fmt.Sprintf("%d", v)
  19.         case string:
  20.             result += fmt.Sprintf("%s", v)
  21.         case []int:
  22.             ints := v.([]int)
  23.             for i, v := range ints {
  24.                 if i != 0 {
  25.                     result += sep
  26.                 }
  27.                 result += fmt.Sprintf("%d", v)
  28.             }
  29.         case []string:
  30.             strs := v.([]string)
  31.             result += strings.Join(strs, sep)
  32.         default:
  33.             fmt.Printf("the argument type [%T] is not supported", v)
  34.             return ""
  35.         }
  36.     }
  37.     return result
  38. }
  40. func main() {
  41.     println(concat("-", 1, 2))
  42.     println(concat("-", "hello", "gopher"))
  43.     println(concat("-", "hello", 1, uint32(2),
  44.         []int{11, 12, 13}, 17,
  45.         []string{"robot", "ai", "ml"},
  46.         "hacker", 33))
  47. }

我们运行一下该例子：

  1. $ go run variadic_function_5.go 
  2. 1-2
  3. hello-gopher
  4. hello-1-2-11-12-13-17-robot-ai-ml-hacker-33

3. 模拟实现函数的可选参数与默认参数

如果参数在传入时有隐式要求的固定顺序(这点由调用者保证)，我们还可以利用变长参数函数模拟实现函数的可选参数和默认参数。

  1. // variadic_function_6.go 
  2. package main
  4. import "fmt"
  6. type record struct {
  7.     name    string
  8.     gender  string
  9.     age     uint16
  10.     city    string
  11.     country string
  12. }
  14. func enroll(args ...interface{} /* name, gender, age, city = "Beijing", country = "China" */) (*record, error) {
  15.     if len(args) > 5 || len(args) < 3 {
  16.         return nil, fmt.Errorf("the number of arguments passed is wrong")
  17.     }
  19.     r := &record{
  20.         city:    "Beijing", // 默认值：Beijing
  21.         country: "China",   // 默认值：China
  22.     }
  24.     for i, v := range args {
  25.         switch i {
  26.         case 0: // name
  27.             name, ok := v.(string)
  28.             if !ok {
  29.                 return nil, fmt.Errorf("name is not passed as string")
  30.             }
  31.             r.name = name
  32.         case 1: // gender
  33.             gender, ok := v.(string)
  34.             if !ok {
  35.                 return nil, fmt.Errorf("gender is not passed as string")
  36.             }
  37.             r.gender = gender
  38.         case 2: // age
  39.             age, ok := v.(int)
  40.             if !ok {
  41.                 return nil, fmt.Errorf("age is not passed as int")
  42.             }
  43.             r.age = uint16(age)
  44.         case 3: // city
  45.             city, ok := v.(string)
  46.             if !ok {
  47.                 return nil, fmt.Errorf("city is not passed as string")
  48.             }
  49.             r.city = city
  50.         case 4: // country
  51.             country, ok := v.(string)
  52.             if !ok {
  53.                 return nil, fmt.Errorf("country is not passed as string")
  54.             }
  55.             r.country = country
  56.         default:
  57.             return nil, fmt.Errorf("unknown argument passed")
  58.         }
  59.     }
  61.     return r, nil
  62. }
  64. func main() {
  65.     r, _ := enroll("小明", "male", 23)
  66.     fmt.Printf("%+v\n", *r)
  68.     r, _ = enroll("小红", "female", 13, "Hangzhou")
  69.     fmt.Printf("%+v\n", *r)
  71.     r, _ = enroll("Leo Messi", "male", 33, "Barcelona", "Spain")
  72.     fmt.Printf("%+v\n", *r)
  74.     r, err := enroll("小吴", 21, "Suzhou")
  75.     if err != nil {
  76.         fmt.Println(err)
  77.         return
  78.     }
  79. }

我们运行一下上面的例子：

  1. $ go run variadic_function_6.go 
  2. {name:小明 gender:male age:23 city:Beijing country:China}
  3. {name:小红 gender:female age:13 city:Hangzhou country:China}
  4. {name:Leo Messi gender:male age:33 city:Barcelona country:Spain}
  5. gender is not passed as string

如果参数特多, 并且还要让调用者记住参数顺序, 这不太可取.

我们看到基于上述前提而用 Go 实现的可选参数和默认参数是有局限的：调用者只能从右侧的参数开始逐一做省略传递的处理，比如：可以省略 country，可以省略 country、city，但不能省略 city 而不省略 country 的传递。

4. 实现”功能选项“模式

日常 Go 编程时，我们经常会去实现一些带有设置选项的创建型函数，比如：我们要创建一个网络通信的客户端，创建客户端实例的函数需要提供某种方式可以让调用者设置客户端的一些行为属性，比如：超时时间、重试次数等。对于一些复杂的 Go 包中的创建型函数，它要提供的可设置选项有时多达数十种，甚至后续还会增加。因此，设计和实现这样的创建型函数时要尤为考虑使用者的体验：不能因选项较多而提供过多的 API，并且要保证选项持续增加后，函数的对外接口依旧保持稳定。

我们来设计和实现一个 NewFinishedHouse 函数，该函数返回一个”FinishedHouse(精装房)“实例。

1) 版本 1：通过参数暴露配置选项

  1. // variadic_function_7.go 
  2. package main
  4. import "fmt"
  6. type FinishedHouse struct {
  7.     style                  int    // 0: Chinese, 1: American, 2: European
  8.     centralAirConditioning bool   // true or false
  9.     floorMaterial          string // "ground-tile" or ”wood"
  10.     wallMaterial           string // "latex" or "paper" or "diatom-mud"
  11. }
  13. func NewFinishedHouse(style int, centralAirConditioning bool,
  14.     floorMaterial, wallMaterial string) *FinishedHouse {
  16.     // here: you should do some check to the arguments passed
  18.     h := &FinishedHouse{
  19.         style:                  style,
  20.         centralAirConditioning: centralAirConditioning,
  21.         floorMaterial:          floorMaterial,
  22.         wallMaterial:           wallMaterial,
  23.     }
  25.     return h
  26. }
  28. func main() {
  29.     fmt.Printf("%+v\n", NewFinishedHouse(0, true, "wood", "paper"))
  30. }

运行该例子：

  1. $ go run variadic_function_7.go 
  2. &{style:0 centralAirConditioning:true floorMaterial:wood wallMaterial:paper}

上述这个设计的唯一优点就是能够快速实现，但不足之处却有很多，最致命的是该接口没法扩展。如果我们此时应用户要求增加一个室内门型设置的选项（可选实木门/板材套装门），那么该接口无法满足。考虑兼容性原则，该接口一但发布就成为了 API 的一部分，我们不能随意变更。于是我们唯一能做的就是新增一个创建函数，比如：NewFinishedHouseWithDoorOption。如果后续要增加其他设置选项，API 中很大可能会充斥着 NewFinishedHouseWithXxxOption1、NewFinishedHouseWithYyyOpiton、… NewFinishedHouseWithZzzOption 等新接口。

2) 版本 2：使用结构体封装配置选项

  1. // variadic_function_8.go 
  2. package main
  4. import "fmt"
  6. type FinishedHouse struct {
  7.     style                  int    // 0: Chinese, 1: American, 2: European
  8.     centralAirConditioning bool   // true or false
  9.     floorMaterial          string // "ground-tile" or ”wood"
  10.     wallMaterial           string // "latex" or "paper" or "diatom-mud"
  11. }
  13. type Options struct {
  14.     Style                  int    // 0: Chinese, 1: American, 2: European
  15.     CentralAirConditioning bool   // true or false
  16.     FloorMaterial          string // "ground-tile" or ”wood"
  17.     WallMaterial           string // "latex" or "paper" or "diatom-mud"
  18. }
  20. func NewFinishedHouse(options *Options) *FinishedHouse {
  21.     // use default style and materials if option is nil
  22.     var style int = 0
  23.     var centralAirConditioning = true
  24.     var floorMaterial = "wood"
  25.     var wallMaterial = "paper"
  27.     if options != nil {
  28.         // here: you should do some check to the options passed
  30.         style = options.Style
  31.         centralAirConditioning = options.CentralAirConditioning
  32.         floorMaterial = options.FloorMaterial
  33.         wallMaterial = options.WallMaterial
  34.     }
  36.     h := &FinishedHouse{
  37.         style:                  style,
  38.         centralAirConditioning: centralAirConditioning,
  39.         floorMaterial:          floorMaterial,
  40.         wallMaterial:           wallMaterial,
  41.     }
  43.     return h
  44. }
  46. func main() {
  47.     fmt.Printf("%+v\n", NewFinishedHouse(nil)) // use default options
  48.     fmt.Printf("%+v\n", NewFinishedHouse(&Options{
  49.         Style:                  1,
  50.         CentralAirConditioning: false,
  51.         FloorMaterial:          "ground-tile",
  52.         WallMaterial:           "paper",
  53.     }))
  54. }

我们运行一下这个例子：

  1. $ go run variadic_function_8.go 
  2. &{style:0 centralAirConditioning:true floorMaterial:wood wallMaterial:paper}
  3. &{style:1 centralAirConditioning:false floorMaterial:ground-tile wallMaterial:paper}

我们看到：

  • 使用这种方法，即便后续添加新配置选项，Options 结构体可以随着时间变迁而增长，但 FinishedHouse 创建函数本身的 API 签名是保持不变的；
  • 这种方法还使得调用者可以使用 nil 来表示他们希望使用默认配置选项来创建 FinishedHouse；
  • 这种方法还带来了额外收获：更好的文档记录（文档重点从对 NewFinishedHouse 函数的大段注释描述转移到了对 Options 结构体各字段的说明）。

当然这种方法也有其不足的地方：

  • 调用者可能会有如此疑问：传递 nil 和传递&Options{}之间有区别吗？
  • 每次传递 Options 都要将 Options 中的所有字段做正确显式的赋值，即便调用者想使用某个配置项的默认值，赋值动作 1 依然不可少；
  • 调用者还可能有如此疑问：如果传递给 NewFinishedHourse 的 options 中的字段值在函数调用后发生了变化会发生什么情况？

**

3) 版本 3：使用“功能选项”模式

  1. // variadic_function_9.go 
  2. package main
  4. import "fmt"
  6. type FinishedHouse struct {
  7.     style                  int    // 0: Chinese, 1: American, 2: European
  8.     centralAirConditioning bool   // true or false
  9.     floorMaterial          string // "ground-tile" or ”wood"
  10.     wallMaterial           string // "latex" or "paper" or "diatom-mud"
  11. }
  13. type Option func(*FinishedHouse)
  15. func NewFinishedHouse(options ...Option) *FinishedHouse {
  16.     h := &FinishedHouse{
  17.         // default options
  18.         style:                  0,
  19.         centralAirConditioning: true,
  20.         floorMaterial:          "wood",
  21.         wallMaterial:           "paper",
  22.     }
  24.     for _, option := range options {
  25.         option(h)
  26.     }
  28.     return h
  29. }
  31. func WithStyle(style int) Option {
  32.     return func(h *FinishedHouse) {
  33.         h.style = style
  34.     }
  35. }
  37. func WithFloorMaterial(material string) Option {
  38.     return func(h *FinishedHouse) {
  39.         h.floorMaterial = material
  40.     }
  41. }
  43. func WithWallMaterial(material string) Option {
  44.     return func(h *FinishedHouse) {
  45.         h.wallMaterial = material
  46.     }
  47. }
  49. func WithCentralAirConditioning(centralAirConditioning bool) Option {
  50.     return func(h *FinishedHouse) {
  51.         h.centralAirConditioning = centralAirConditioning
  52.     }
  53. }
  55. func main() {
  56.     fmt.Printf("%+v\n", NewFinishedHouse()) // use default options
  57.     fmt.Printf("%+v\n", NewFinishedHouse(WithStyle(1),
  58.         WithFloorMaterial("ground-tile"),
  59.         WithCentralAirConditioning(false)))
  60. }

运行一下该新版例子：

  1. $ go run variadic_function_9.go 
  2. &{style:0 centralAirConditioning:true floorMaterial:wood wallMaterial:paper}
  3. &{style:1 centralAirConditioning:false floorMaterial:ground-tile wallMaterial:paper}

功能选项模式使得我们在设计和实现类似 NewFinishedHouse 这样带有配置选项的函数或方法时可以收获如下好处：

  • 更漂亮的、不随时间变化的公共 API
  • 参数可读性更好
  • 配置选项高度可扩展 (不依赖顺序)
  • 提供使用默认选项的最简单方式
  • 使用更安全（不会像版本 2 那样在创建函数被调用后，调用者仍然可以修改 options）