在Go中.变长参数函数使用的最多的就是fmt包 log包中的几个导出函数.
源码位置:src/fmt/print.go
// Println formats using the default formats for its operands and writes to standard output. // Spaces are always added between operands and a newline is appended. // It returns the number of bytes written and any write error encountered. func Println(a ...any) (n int, err error) { return Fprintln(os.Stdout, a...) } // Printf formats according to a format specifier and writes to standard output. // It returns the number of bytes written and any write error encountered. func Printf(format string, a ...any) (n int, err error) { return Fprintf(os.Stdout, format, a...) }源码位置:src/log/log.go
// Printf calls l.Output to print to the logger. // Arguments are handled in the manner of [fmt.Printf]. func (l *Logger) Printf(format string, v ...any) { l.output(0, 2, func(b []byte) []byte { return fmt.Appendf(b, format, v...) }) } // Println calls l.Output to print to the logger. // Arguments are handled in the manner of [fmt.Println]. func (l *Logger) Println(v ...any) { l.output(0, 2, func(b []byte) []byte { return fmt.Appendln(b, v...) }) }1.变长参数函数:
变长参数就是指调用时可以接受零个 一个或多个实际参数的函数.示例如
下:
可以看到无论传入零个 两个还是多个实际参数.都传给了Print()方法的形
式参数a(参考上面源码).形参a的类型是...any.这种接受"...T"类型形式参
数的函数就被称为变长参数函数.
一个变长参数函数只能有一个"...T"类型形式参数.并且该形式参数应该为
函数参数列表中的最后一个形式参数.否则Go编译器会有错误提示.
变长参数函数的"...T"类型形式参数在函数体内呈现为[]T类型的变量.可以
将其理解为一个Go的语法糖.示例如下:
func sum(arg ...int) int { var total int //arg的类型为[]int for _, v := range arg { total += v } return total }在函数外部."...T"类型形式参数可以匹配和接受的实参类型有两种.
1).多个T类型变量.
2).t...(t为[]T类型变量).示例如下:
func main() { a, b, c := 1, 2, 3 fmt.Println(sum(a, b, c)) nums := []int{1, 2, 3} fmt.Println(sum(nums...)) } func sum(arg ...int) int { var total int //arg的类型为[]int for _, v := range arg { total += v } return total }我们只能选择上述两种实参类型的一种.要么是多个T类型变量.要么是t...(t
为[]T类型变量).如果两种混用.会得到类似下面的编译错误.
使用变长参数函数最容易出现的问题是实参与形参不匹配.示例如下:
func main() { s := []string{"a", "b", "c"} dump(s...) } func dump(args ...interface{}) { for _, v := range args { fmt.Println(v) } }编译器给出了类型不匹配的错误.虽然string类型可以直接赋值给interf
ace{}类型变量.但是[]string类型变量并不能直接赋值给[]interface{}类
型变量.修改示例如下:
func main() { s := []interface{}{"a", "b", "c"} dump(s...) } func dump(args ...interface{}) { for _, v := range args { fmt.Println(v) } }不过有个例外.就是Go的内置函数append函数.它支持通过下面的方式将
字符串附加到一个字节后面.示例如下:
func main() { b := []byte{} b = append(b, "hello"...) fmt.Println(b) }string类型本身不满足类型要求(append本需要[]byte...).这算是Go的一
个编译优化.编译器自动将string隐式转换为了[]byte.
func main() { b := []byte{} b = append(b, "hello"...) fmt.Println(b) fooTest(b) } func fooTest(b ...byte) { fmt.Println(b) }2.模拟函数重载:
Go语言不允许在同一个作用域下定义名字相同但函数原型不同的函数.如果
定义这样的函数.Go编译器会提示下面代码的错误信息.
func concat(a, b int) string { return fmt.Sprintf("%d %d", a, b) } func concat(x, y string) string { return fmt.Sprintf("%s %s", x, y) } func concat(s []string)string { return strings.Join(s, " ") }要修复上面的错误.只能修改函数命名.但是在其他语言中.比如java.就支持
这种名字相同.参数类型不同的重载函数.但Go语言并不支持函数重载.Go语
言官方给出不支持的理由是:
其他语言的经验告诉我们.使用具有相同名称但是函数签名不同的多种方法
有时会很有用.但在实践中也可能会造成混淆和脆弱性.在Go的类型系统中.
仅按名称进行匹配要求类型一致是一个主要的简化决策.
变长参数解决.示例如下:
func main() { fmt.Println(concat("-", 1, 2)) fmt.Println(concat("-", "hello", "gopher")) } func concat(sep string, args ...interface{}) string { var result string for i, v := range args { if i != 0 { result += sep } switch v.(type) { case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64: result += fmt.Sprintf("%v", v) case string: result += fmt.Sprintf("%s", v) case []int: ints := v.([]int) for i, v := range ints { if i != 0 { result += sep } result += fmt.Sprintf("%v", v) } case []string: strings := v.([]string) result += fmt.Sprintf("%v", strings) default: fmt.Println("不支持此类型") return "" } } return result }3.模拟实现函数的可选参数和默认参数:
如果参数在传入时有隐式要求的固定顺序(调用者保证).还可以利用变长参
数函数模拟实现可选参数和默认参数.示例如下:
type record struct { name string gender string age int city string country string } func enroll(args ...interface{}) (*record, error) { if len(args) > 5 || len(args) < 3 { return nil, fmt.Errorf("the number of arguments passed to wrong") } r := &record{ city: "ShanXi", country: "TaiYuan", } for i, v := range args { switch i { case 0: name, ok := v.(string) if !ok { return nil, fmt.Errorf("the first argument to enroll must be a string") } r.name = name case 1: gender, ok := v.(string) if !ok { return nil, fmt.Errorf("the second argument to enroll must be a string") } r.gender = gender case 2: age, ok := v.(int) if !ok { return nil, fmt.Errorf("the third argument to enroll must be an uint16") } r.age = age case 3: city, ok := v.(string) if !ok { return nil, fmt.Errorf("the third argument to enroll must be a string") } r.city = city case 4: country, ok := v.(string) if !ok { return nil, fmt.Errorf("the fourth argument to enroll must be a string") } r.country = country default: return nil, fmt.Errorf("unknown argument %d", i) } } return r, nil } func main() { r, _ := enroll("小明", "male", 26) fmt.Printf("%+v\n", *r) r1, _ := enroll("小明", "male", 26, "linfen") fmt.Printf("%+v\n", *r1) }4.实现功能选项:
1).通过参数暴露配置选项:
type FinishedHouse struct { style int centralAirConditioning bool floorMaterial string wallMaterial string } func NewFinishedHouse(style int, centralAirConditioning bool, floorMaterial, wallMaterial string) *FinishedHouse { h := &FinishedHouse{ style: style, centralAirConditioning: centralAirConditioning, floorMaterial: floorMaterial, wallMaterial: wallMaterial, } return h } func main() { fmt.Printf("%+v\n", NewFinishedHouse(0, true, "wood", "paper")) }上面设计的唯一优点就是快速实现.不足之处很多.最致命的是接口无法扩
展.
2)结构体封装配置项:
type FinishedHouse struct { style int centralAirConditioning bool floorMaterial string wallMaterial string } type Options struct { style int centralAirConditioning bool floorMaterial string wallMaterial string } func NewFinishedHouse(options *Options) *FinishedHouse { var style = 0 var centralAirConditioning = true var floorMaterial = "wood" var wallMaterial = "paper" if options != nil { style = options.style centralAirConditioning = options.centralAirConditioning floorMaterial = options.floorMaterial wallMaterial = options.wallMaterial } h := &FinishedHouse{ style: style, centralAirConditioning: centralAirConditioning, floorMaterial: floorMaterial, wallMaterial: wallMaterial, } return h } func main() { fmt.Printf("%+v\n", NewFinishedHouse(0, true, "wood", "paper")) }优点:
1).后续添加配置项选项.Options结构体可以随着时间变迁而增长.但
FinishedHouse创建函数本身的Api签名不变.
2).允许调用者使用nil来表示他们希望使用默认值来创建.
3).可以更好地记录文档.
缺点:
1).每次都要为Options中所有字段赋值.
2).如果Options中的值在调用后变化了怎么办.
3).使用功能选项:
type FinishedHouse struct { style int centralAirConditioning bool floorMaterial string wallMaterial string } type Option func(h *FinishedHouse) func NewFinishedHouse(options ...Option) *FinishedHouse { h := &FinishedHouse{ style: 0, centralAirConditioning: true, floorMaterial: "wood", wallMaterial: "paper", } for _, option := range options { option(h) } return h } func WithStyle(style int) Option { return func(h *FinishedHouse) { h.style = style } } func WithCentralAirConditioning(centralAirConditioning bool) Option { return func(h *FinishedHouse) { h.centralAirConditioning = centralAirConditioning } } func WithFloorMaterial(floorMaterial string) Option { return func(h *FinishedHouse) { h.floorMaterial = floorMaterial } } func WithWallMaterial(wallMaterial string) Option { return func(h *FinishedHouse) { h.floorMaterial = wallMaterial } } func main() { //默认. fmt.Printf("%+v\n", NewFinishedHouse()) fmt.Printf("%+v\n", NewFinishedHouse(WithStyle(1), WithFloorMaterial("title"))) }我也曾像个疯子一样.
如果大家喜欢我的分享的话.可以关注我的微信公众号
念何架构之路
