Go 可变参数函数

平时调用 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...)),表示把一个现成的切片 “拆包” 成零散元素传给函数。
给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号