平时调用 fmt.Println(10, 20, 30) 打印数据时,不管往小括号里传 1 个参数、3 个参数还是 10 个参数,它都能正常执行。为什么这类函数可以接收不确定个数的参数呢?
其实,这是因为它们用到了 Go 语言中的 “可变参数函数(variadic function)”。只要把参数声明成可变参数,函数就能一次性接收任意多个同类型的实参。
定义与调用可变参数函数
在 Go 语言中,定义一个可变参数函数非常简单,我们只需要在参数类型的前面加上 3 个英文句点(...)就可以了。
语法:
func 函数名(参数名 ...类型) 返回值类型 {
// 函数体
}说明:
在参数类型前加上 ...,表示该参数可以接收 0 个、1 个或多个同类型的实参。当我们调用这个函数时,Go 语言会自动把传进来的零散数据打包放进一个切片中。
也就是说,在函数体内部,这个可变参数本质上就是一个切片。我们可以直接使用 len() 获取传入的参数个数,也可以使用 for range 循环把每个参数遍历出来。
示例 1:求任意多个整数之和
package main
import "fmt"
func sum(nums ...int) int {
total := 0
for _, v := range nums {
total += v
}
return total
}
func main() {
fmt.Println(sum()) // 传入 0 个参数
fmt.Println(sum(5, 15)) // 传入 2 个参数
fmt.Println(sum(3, 6, 9, 12)) // 传入 4 个参数
}运行结果如下。
0
20
30分析:
func sum(nums ...int) int 定义了一个可变参数 nums。在 sum() 函数内部,nums 就相当于一个 []int 切片,我们通过 for _, v := range nums 把传进来的每个整数依次累加到 total 中。
从运行结果可以看出,当我们不传任何参数调用 sum() 时,nums 是一个长度为 0 的空切片,返回结果为 0。当我们传入 2 个或 4 个整数时,函数都能正常算出它们的总和。
为了验证可变参数在函数内部是不是真正的切片,我们可以借助 fmt.Printf() 的 %T 占位符,把它的具体类型和长度打印出来看一看。
示例 2:查看可变参数的类型
package main
import "fmt"
func check(items ...string) {
fmt.Printf("类型:%T,长度:%d\n", items, len(items))
}
func main() {
check("Go", "Python", "Java")
}运行结果如下。
类型:[]string,长度:3分析:
从运行结果可以看到,声明为 ...string 的可变参数 items,在函数内部的数据类型就是标准的 []string 切片,长度为 3。
提示: 小伙伴们只需要记住一句话:可变参数在函数内部就是一个普通切片。前面学过的按下标访问 items[0]、使用 len() 求长度等切片操作,在函数内部都可以直接使用。
“固定参数” 与 “可变参数” 混用
在实际开发中,一个函数经常既需要接收几个固定的普通参数,又需要接收一组数量不定的可变参数。在 Go 语言中,这两类参数是可以搭配使用的。
语法:
func 函数名(固定参数1 类型1, 可变参数 ...类型2) 返回值类型 {
// 函数体
}说明:
当固定参数与可变参数同时出现时,可变参数必须放在参数列表的最后一项,并且一个函数中最多只能定义一个可变参数。调用函数时,前面的实参会先按顺序赋给固定参数,剩下的所有实参则统一交给最后的可变参数。
示例 3:搭配固定参数使用
package main
import "fmt"
func printScore(name string, scores ...int) {
total := 0
for _, s := range scores {
total += s
}
fmt.Printf("%s的总分为:%d\n", name, total)
}
func main() {
printScore("小明", 90, 95, 85)
printScore("小红", 88, 92)
}运行结果如下。
小明的总分为:270
小红的总分为:180分析:
当我们调用 printScore("小明", 90, 95, 85) 时,第 1 个实参 "小明" 会传给固定参数 name,后面剩下的 3 个整数则会自动打包进可变参数 scores 切片中。
调用时前面的固定参数 name 必须按要求传入,而后面的可变参数 scores 可以传 0 个值。比如直接调用 printScore("小华") 也是合法的,此时算出的总分为 0。
需要注意的是,如果把可变参数写在了固定参数的前面,编译器就无法判断可变参数到哪里结束,编译时会直接报错。
// 正确方式
func printScore(name string, scores ...int) {}
// 错误方式
func printScore(scores ...int, name string) {}将切片展开传入可变参数函数
前面我们调用 sum(5, 15) 时,传进去的都是一个个零散的数字。如果我们手头已经有一个现成的 []int 切片,能不能直接把这个切片传给 sum() 函数呢?
直接写成 sum(s) 会报错,因为 sum() 需要接收零散的 int 整数,而不是整个 []int 切片。此时只要在切片名后面加上 3 个英文句点写成 sum(s...),就能把元素拆开传进去,这和前面 “合并切片” 一节中的 append(s1, s2...) 是一样的道理。
语法:
函数名(切片名...)说明:
在调用可变参数函数时,我们在切片变量名后面加上 ...,即可把切片中的所有元素打散成独立的参数传给函数。
示例 4:将切片展开传入函数
package main
import "fmt"
func sum(nums ...int) int {
total := 0
for _, v := range nums {
total += v
}
return total
}
func main() {
s := []int{5, 15, 25}
res := sum(s...) // 将切片 s 展开传入
fmt.Println(res)
}运行结果如下。
45分析:
在这个例子中,s 是一个包含 5、15、25 的整型切片。当我们执行 sum(s...) 时,Go 语言会把切片 s 展开传入,效果就相当于调用了 sum(5, 15, 25),最终算出总和 45。
使用 s... 展开切片时有两个细节,小伙伴们一定要留意。第 1 点是 s... 会单独占用整个可变参数的位置,不能再和同属于可变参数的零散数字混在一起传。
比如对于只接收可变参数的 sum(nums ...int) 来说,写成 sum(1, 2, s...) 会直接报错。但如果函数前面有独立的固定参数(如 printScore),先传入固定参数再传入 s... 则是完全合法的。
s := []int{5, 15, 25}
// 正确方式
printScore("小明", s...)
// 错误方式
sum(1, 2, s...)第 2 点则更隐蔽,很多初学者都踩过坑:用 s... 把切片展开传入可变参数函数时,Go 语言并不会重新复制一份底层数组。如果在函数内部修改了可变参数里的元素,外面的原切片也会跟着改变。下面我们通过一个例子来验证一下。
示例 5:展开切片传参共享底层数组
package main
import "fmt"
func changeFirst(nums ...int) {
if len(nums) > 0 {
nums[0] = 99
}
}
func main() {
s := []int{5, 15, 25}
changeFirst(s...)
fmt.Println(s)
}运行结果如下。
[99 15 25]分析:
从运行结果可以看出,当我们在 changeFirst() 内部把 nums[0] 改成 99 后,外部的原切片 s 也变成了 [99 15 25]。
这是因为使用 s... 展开传参时,函数接收到的可变参数切片 nums 与外面的 s 依然指向同一块底层数组。因此在实际开发中,如果函数内部需要修改可变参数的元素,又不希望影响外部原切片,记得先通过复制切片备出一份副本再操作。
“...类型” 与 “切片...” 的区别
在可变参数函数中,3 个英文句点 ... 可以出现在两个不同的位置,大家可以通过 “一打一拆” 来对比记忆:
- 参数名 ...类型(定义函数时):写在参数类型的前面(如
nums ...int),表示把调用时传入的多个零散参数 “打包” 成一个切片。 - 切片名...(调用函数时):写在切片变量的后面(如
sum(s...)),表示把一个现成的切片 “拆包” 成零散元素传给函数。
