在 Go 语言中,当我们调用函数并传入参数时,默认采用的是 “值传递”。也就是说,把普通变量作为函数参数传进去后,即使在函数内部修改了形参的值,外部的原变量依然不会改变。
如果我们在实际开发中,确实需要让一个函数直接修改外部变量的值,应该怎么实现呢?答案就是使用指针作为参数,把变量的 “内存地址” 传给函数,这种方式通常称为 “指针传递”。
“值传递” 与 “指针传递” 的区别
根据函数形参类型的不同,传参效果可以分为以下 2 种情况:
- 值传递:函数形参是普通类型(如
int、string)。调用函数时,程序会把实参的值复制一份交给形参,就像把本地文档复制了一份发给别人,对方怎么修改副本都不会影响原文档。 - 指针传递:函数形参是指针类型(如
*int、*string)。调用函数时,我们传入的是实参的内存地址(如&x),就像把同一个在线文档的编辑链接发给别人,对方修改后原文档也会同步改变。
这两种传参方式在内存中的差异如下图所示。

语法:
func 函数名(形参名 *数据类型) {
*形参名 = 新值
}说明:
想要通过指针传递在函数内部修改外部变量的值,我们需要完成以下 3 步配合:① 定义函数时将形参声明为指针类型(如 p *int);② 在函数体内通过 *p 修改目标变量的值;③ 调用函数时在实参前面加上 & 传入内存地址。
示例 1:对比值传递与指针传递
package main
import "fmt"
// 值传递
func changeVal(n int) {
n = 99
}
// 指针传递
func changePtr(p *int) {
*p = 99
}
func main() {
x := 10
changeVal(x)
fmt.Println(x)
changePtr(&x)
fmt.Println(x)
}运行结果如下。
10
99分析:
在这个例子中,我们先调用了值传递函数 changeVal(x)。此时程序只是把 x 的值 10 复制了一份赋给形参 n。函数内部执行 n = 99 修改的仅仅是副本 n,因此 main() 函数里的原变量 x 依然输出 10。
随后我们调用了指针传递函数 changePtr(&x),这一次传入的是变量 x 的内存地址 &x。形参 p 拿到地址后,执行 *p = 99 会直接修改外部变量 x 所在内存的数据,因此 x 的值也就同步变成了 99。
交换两个变量的值
指针传递很经典的一个应用场景,就是编写一个 swap() 函数来交换两个外部变量的值。如果使用普通的值传递,函数内部交换的只是两个形参副本,外部变量不会发生任何改变。改用指针传递后,就能轻松实现交换。
示例 2:通过指针交换变量
package main
import "fmt"
// 交换两个指针指向的值
func swap(a, b *int) {
*a, *b = *b, *a
}
func main() {
x, y := 10, 20
swap(&x, &y)
fmt.Println(x, y)
}运行结果如下。
20 10分析:
*a, *b = *b, *a 利用了 Go 语言的多重赋值特性,直接将指针 a 和指针 b 所指向的两个目标变量的值进行了对调。
在编写 swap() 函数时,很多初学的小伙伴容易漏掉函数体内的星号 *,下面这 2 种写法的效果完全不同。
// 正确方式
func swap(a, b *int) {
*a, *b = *b, *a
}
// 错误方式
func swap(a, b *int) {
a, b = b, a
}为什么下面的错误方式不起作用呢?其实,指针传递本质上也是把实参的 “内存地址” 复制了一份交给形参 a 和 b。
如果不加星号写成 a, b = b, a,交换的只是函数内部两个局部指针变量各自保存的地址,外部变量 x 和 y 本身的数值并没有改变。只有加上星号写成 *a, *b = *b, *a,才是通过地址找到外部的目标变量并把它们的值对调。
注意: 调用形参为指针的函数时,如果实参是一个普通变量,前面必须加上取地址符 &(如 swap(&x, &y))。如果漏写 & 直接写成 swap(x, y),编译器就会报类型不匹配错误。
数组、切片与 Map 的传参特点
除了 int、float64、string 等基本数据类型之外,当我们把数组、切片或 Map 传给函数时,它们的传参表现也有着明显的差别:
- 定长数组(值类型):我们直接把数组(如
[3]int)传给函数时,程序会把所有元素完整复制一份,函数内修改元素不影响原数组。虽然传递数组指针(如*[3]int)能修改原数组,但实际开发中一般直接改用切片传参。 - 切片与 Map:切片(
[]T)和 Map(map[K]V)在底层内部已经自带了指向数据存储区的指针。因此我们直接传参时不需要加&和*,在函数内部通过下标或键修改已有元素就会直接反映到外部。
下面我们通过一个例子来验证定长数组与切片、Map 在函数传参时的差异。
示例 3:数组与切片、Map 的传参对比
package main
import "fmt"
// 定长数组传参
func modifyArr(a [3]int) {
a[0] = 99
}
// 切片与 Map 传参
func modifySliceAndMap(s []int, m map[string]int) {
s[0] = 99
m["Jack"] = 100
}
func main() {
arr := [3]int{1, 2, 3}
modifyArr(arr)
fmt.Println(arr)
nums := []int{1, 2, 3}
scores := map[string]int{"Jack": 85}
modifySliceAndMap(nums, scores)
fmt.Println(nums)
fmt.Println(scores)
}运行结果如下。
[1 2 3]
[99 2 3]
map[Jack:100]分析:
调用 modifyArr(arr) 时,形参接收的是定长数组 [3]int,传参过程会复制一份独立的数组副本。函数内部执行 a[0] = 99 改的只是副本,因此外部的原数组 arr 依然输出 [1 2 3]。
而 modifySliceAndMap() 接收的是切片和 Map,传参时会把内部的底层数据地址复制给形参。由于函数内外指向同一份底层数据,执行 s[0] = 99 和 m["Jack"] = 100 就会直接修改外部的 nums 和 scores。
不过小伙伴们要特别注意一个高频易错点:如果在函数内部调用 append() 为切片追加新元素,情况就不同了。我们来看下面的例子。
示例 4:切片在函数中追加元素
package main
import "fmt"
// 只在函数内追加,外部切片不变
func appendWrong(s []int) {
s = append(s, 4)
}
// 将追加后的新切片返回(推荐)
func appendRight(s []int) []int {
return append(s, 4)
}
func main() {
nums := []int{1, 2, 3}
appendWrong(nums)
fmt.Println(nums)
nums = appendRight(nums)
fmt.Println(nums)
}运行结果如下。
[1 2 3]
[1 2 3 4]分析:
从运行结果可以看出,调用 appendWrong(nums) 之后,外面的 nums 依然是 [1 2 3],新追加的 4 并没有生效。为什么在函数内修改已有元素能生效,追加新元素却不行呢?
我们可以把切片变量想象成一张 “小纸条”,上面写着底层数组的地址、当前长度 len(这里是 3)和容量 cap(这里是 3)。把切片传给函数时,程序会把这张小纸条抄一份交给形参 s。
由于两张纸条指向同一个底层数组,直接修改 s[0] 时外部就能看到变化。但在函数内部执行 s = append(s, 4) 时,只更新了形参 s 那张纸条上的长度;一旦容量不足,还会换掉底层数组。
反观外部的 nums,它手里那张纸条上记录的长度始终保持为 3,所以打印出来还是原来的前 3 个元素。
因此,当我们需要在函数内为切片追加或删除元素时,标准做法是像 appendRight() 那样把更新后的新切片通过 return 返回,并在外部重新接收。
如何选择传参方式?
在实际开发中,什么时候应该使用值传递,什么时候应该使用指针传递呢?小伙伴们可以参考以下 3 条实用经验:
- 基本数据类型:对于
int、float64、bool、string等类型,如果不需要修改外部变量,我们优先使用值传递并通过return返回结果。这样代码更直观好读。 - 需要修改外部变量或传递大对象:当函数需要直接修改外部变量的值,或者传递大型数组以及下一章要学习的结构体等复合数据时,我们就应该使用指针传递。
- 切片与 Map:如果只是读写内部已有元素,我们直接按原样传参即可。需要在函数内追加或删除切片元素时,推荐把新切片作为返回值返回,平时一般不需要写成
*[]int或*map[string]int这样的指针参数。
