Go 函数参数

编写函数时,我们经常需要把外部的数据传进函数内部进行处理,用来传递数据的通道就是 “函数参数”。按照出现位置和作用的不同,函数参数分为 “形参” 和 “实参” 两类。

形参与实参

很多初学编程的小伙伴容易把 “形参” 和 “实参” 搞混,其实从名字上就很好区分:

  • 形参(parameter):全称是 “形式参数”,指的是定义函数时在小括号里声明的变量。它只是一个占位名称,用来规定函数需要接收什么类型的数据。
  • 实参(argument):全称是 “实际参数”,指的是调用函数时实际传进小括号里的具体数值或变量。

语法:

func 函数名(形参1 类型1, 形参2 类型2) 返回值类型 {
    // 函数体
}

说明:

声明形参时,我们要遵守 “参数名在前,类型在后” 的规则,多个形参之间用英文逗号(,)隔开。调用函数时,在小括号内传入对应的实参即可,传入的实参必须与形参的个数、排列顺序和数据类型一一对应。

示例 1:传入多个不同类型的参数

package main

import "fmt"

// name 和 age 是形参
func printUser(name string, age int) {
    fmt.Printf("姓名:%s,年龄:%d\n", name, age)
}

func main() {
    // "Tom" 和 21 是实参
    printUser("Tom", 21)
}

运行结果如下。

姓名:Tom,年龄:21

分析:

在这个例子中,我们定义 printUser() 函数时声明了两个形参:第 1 个是 string 类型的 name,第 2 个是 int 类型的 age。

当我们在 main() 函数中调用 printUser("Tom", 21) 时,第 1 个实参 "Tom" 会赋给形参 name,第 2 个实参 21 会赋给形参 age。如果调用时把实参顺序写反了,或者少传了参数,编译时都会直接报错。下面这两种调用方式都是错误的。

printUser(21, "Tom")    // 实参类型不匹配
printUser("Tom")        // 实参个数不足

同类型参数的合并简写(推荐)

在 Go 语言中,如果遇到连续多个相邻的形参属于同一种数据类型,我们不需要在每个参数名后面都重复写一遍类型。此时可以把前面的类型省略掉,只在最后一个参数名后面写一次类型即可。

语法:

func 函数名(形参1, 形参2 类型) 返回值类型 {
    // 函数体
}

说明:

这种合并简写只适用于位置相邻且类型相同的形参。如果两个 int 参数中间隔了一个 string 参数,就不能跨位置合并。另外,当函数需要接收数量不固定的同类型参数时,我们可以使用后面介绍的可变参数函数。

示例 2:合并简写同类型参数

package main

import "fmt"

// a、b、c 都是 int 类型
func sumThree(a, b, c int) int {
    return a + b + c
}

func main() {
    total := sumThree(15, 25, 30)
    fmt.Println(total)
}

运行结果如下。

70

分析:

sumThree(a, b, c int) 中的 a、b、c 都是 int 类型的形参。对于这个例子来说,下面 2 种方式是等价的。

// 方式 1(推荐)
func sumThree(a, b, c int) int {
    return a + b + c
}

// 方式 2
func sumThree(a int, b int, c int) int {
    return a + b + c
}

其中,方式 1 省去了前面重复的 int,代码看起来更加清爽。

如果一个函数同时包含多组不同类型的参数,每一组相邻的同类型参数也可以各自合并简写。下面我们来看这个例子。

示例 3:多组同类型参数简写

package main

import "fmt"

func showOrder(item1, item2 string, price1, price2 float64) {
    fmt.Printf("%s:%.1f 元\n", item1, price1)
    fmt.Printf("%s:%.1f 元\n", item2, price2)
}

func main() {
    showOrder("苹果", "牛奶", 8.5, 12.0)
}

运行结果如下。

苹果:8.5 元
牛奶:12.0 元

分析:

在 showOrder() 函数中,前两个形参 item1 和 item2 共用了 string 类型,后两个形参 price1 和 price2 共用了 float64 类型,参数分组清晰直观。

提示: 在实际开发中,只要遇到相邻的同类型参数,我们一般都会采用合并简写的方式(如 a, b int),这也是 Go 语言官方推荐的标准写法。

函数参数的值传递

当我们把一个变量作为实参传给函数后,如果在函数内部修改了形参的值,外面的原变量会跟着改变吗?

在 Go 语言中,函数传参统一采用 “值传递”。简单来说,在调用函数时,系统总是会把实参的值复制一份交给形参。对于整数、浮点数、布尔值、字符串以及数组这类数据,变量里直接保存着数据本身,因此修改函数内部的副本并不会影响外面的原变量。

示例 4:基本类型的 “值传递”

package main

import "fmt"

func modify(n int) {
    n = 99
    fmt.Println("函数内 n =", n)
}

func main() {
    x := 10
    modify(x)
    fmt.Println("函数外 x =", x)
}

运行结果如下。

函数内 n = 99
函数外 x = 10

分析:

从运行结果可以看出,虽然我们在 modify() 函数内部把形参 n 改成了 99,但回到 main() 函数后,外部变量 x 的值依然是 10。这是因为 n 和 x 占用的是两块各自独立的内存,modify(x) 只是把 x 的数值 10 复制了一份传给 n。

如果希望在函数内部直接修改外部变量 x 本身的值,我们需要借助指针把变量的内存地址传进去,下一章会详细介绍。

不过,如果把前面学过的切片或 Map 作为参数传给函数,并在函数内部修改其中的元素值,情况就会有所不同。请看下面例子。

示例 5:切片作为参数修改元素

package main

import "fmt"

func changeSlice(s []int) {
    s[0] = 99
}

func main() {
    nums := []int{10, 20, 30}
    changeSlice(nums)
    fmt.Println(nums)
}

运行结果如下。

[99 20 30]

分析:

在 changeSlice() 函数内部把 s[0] 改成 99 后,外部原切片 nums 的第 1 个元素也跟着变成了 99。为什么同样是值传递,基本类型和切片的表现却不一样呢?这是因为两类变量内部保存的内容不同:

  • 基本类型与数组:普通基本类型和数组的变量里,直接保存着数据值本身。传参时会复制出一份完全独立的数据,因此在函数内部修改形参不会影响外部实参。
  • 切片与 Map:变量本身保存的是指向底层数据的地址信息,就像房间的 “门牌号”。传参时虽然把门牌号复制了一份,但两份门牌号指向的仍是同一块底层空间,因此通过下标或键修改已有元素时,外部的原切片或 Map 也会跟着改变。

两类数据在传参时的内存差异如下图所示。

基本类型与切片传参的内存对比

看到这里,很多小伙伴容易产生一个误解,以为在函数里对切片做任何操作都会同步到外面。如果我们在函数内部用 append() 给切片追加新元素,外面的原切片会跟着变长吗?下面我们来验证一下。

示例 6:函数内使用 append() 追加元素

package main

import "fmt"

func addItem(s []int) {
    s = append(s, 40)
    fmt.Println("函数内 s =", s)
}

func main() {
    nums := []int{10, 20, 30}
    addItem(nums)
    fmt.Println("函数外 nums =", nums)
}

运行结果如下。

函数内 s = [10 20 30 40]
函数外 nums = [10 20 30]

分析:

结果和很多人的直觉恰恰相反:函数内部打印出的 s 已经变成了 [10 20 30 40],但回到 main() 后,外部的 nums 依然是 [10 20 30],新追加的 40 并没有出现在外面。

道理其实很简单,还是用刚才的 “门牌号纸条” 就能想明白:切片变量这张纸条上,除了记录底层数组的地址,还记着当前的长度和容量。修改 s[0] = 99 相当于拿着复制出来的纸条进房间换家具,外面自然能看到变化。

但调用 append() 追加元素会改变长度,容量不够时还会扩容换一间新房子。这些更新都只写在了函数内部那张复制纸条 s 上,外面的 nums 纸条记录的长度和地址根本没变。

在实际开发中,如果需要通过函数给切片追加元素,标准做法是把 append() 后的新切片作为返回值返回给调用者,下一节就会学到这种写法。至于更底层的传参细节,等下一章学习值传递与指针传递时,我们还会进一步展开。

默认参数与函数重载

如果小伙伴们之前接触过 Python、C++ 或 Java,可能会习惯使用 “默认参数值” 或 “函数重载”。但在 Go 语言中,这两项特性都是不支持的:

  • 不支持默认参数值:定义函数时不能给形参指定默认值,比如写成 func f(a int = 10) 会直接报错。每次调用函数时,我们都必须把规定的实参明确传进去。
  • 不支持同名函数重载:所谓函数重载,指的是定义多个名字相同但参数个数或类型不同的函数。在 Go 语言的同一个包内,函数名必须唯一,不允许定义两个同名的普通函数。

Go 语言之所以这样设计,是为了让函数调用关系保持直观明确。阅读代码时,我们既不需要去猜某个调用省略了哪些默认参数,也不需要去分辨它到底匹配了哪一个同名函数。

上一篇:

下一篇:

给站长反馈

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

邮箱:lvyenet@vip.qq.com

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