在Golang的开发实践中，结构体是组织复杂数据最常用的自定义类型，当结构体作为函数参数传递时，开发者需要在传值和传指针两种方案中做选择，不同的选择会直接影响代码的性能和正确性。
传值与传指针的核心差异
首先需要明确两种传递方式的本质区别：
- 传值：函数接收的是结构体的一份完整副本，对副本的修改不会影响原始结构体实例，传递过程中会触发结构体的全量复制。
- 传指针：函数接收的是结构体实例的内存地址，通过该地址可以直接操作原始结构体，不会触发结构体的复制。
性能层面的差异
结构体的大小直接决定了传值的复制成本，我们可以通过下面的示例验证：
package main
import (
"fmt"
"time"
)
// 小结构体，仅包含两个int字段
type SmallStruct struct {
ID int
Age int
}
// 大结构体，包含大量字段
type LargeStruct struct {
Data [1024]byte // 1KB的字节数组
ID int
Name string
}
// 传值处理小结构体
func handleSmallByValue(s SmallStruct) {
s.Age += 1
}
// 传指针处理小结构体
func handleSmallByPointer(s *SmallStruct) {
s.Age += 1
}
// 传值处理大结构体
func handleLargeByValue(s LargeStruct) {
s.ID += 1
}
// 传指针处理大结构体
func handleLargeByPointer(s *LargeStruct) {
s.ID += 1
}
func main() {
small := SmallStruct{ID: 1, Age: 20}
large := LargeStruct{ID: 1}
// 测试小结构体传值性能
start := time.Now()
for i := 0; i < 1000000; i++ {
handleSmallByValue(small)
}
fmt.Println("小结构体传值耗时:", time.Since(start))
// 测试小结构体传指针性能
start = time.Now()
for i := 0; i < 1000000; i++ {
handleSmallByPointer(&small)
}
fmt.Println("小结构体传指针耗时:", time.Since(start))
// 测试大结构体传值性能
start = time.Now()
for i := 0; i < 1000000; i++ {
handleLargeByValue(large)
}
fmt.Println("大结构体传值耗时:", time.Since(start))
// 测试大结构体传指针性能
start = time.Now()
for i := 0; i < 1000000; i++ {
handleLargeByPointer(&large)
}
fmt.Println("大结构体传指针耗时:", time.Since(start))
}
运行上述代码可以发现，小结构体两种传递方式的耗时差异极小，而大结构体传值的耗时远高于传指针，这是因为大结构体的复制需要占用更多的内存和CPU资源。
功能层面的差异
传值无法修改原始结构体，传指针可以直接修改原始结构体，示例代码如下：
package main
import "fmt"
type User struct {
Name string
Age int
}
// 传值修改，不影响原始实例
func updateUserByValue(u User) {
u.Age = 30
u.Name = "张三"
}
// 传指针修改，会影响原始实例
func updateUserByPointer(u *User) {
u.Age = 30
u.Name = "张三"
}
func main() {
user := User{Name: "李四", Age: 20}
updateUserByValue(user)
fmt.Println("传值修改后:", user) // 输出 {李四 20}
updateUserByPointer(&user)
fmt.Println("传指针修改后:", user) // 输出 {张三 30}
}
结构体传值和传指针的选择标准
可以结合以下场景判断使用哪种传递方式：
优先选择传值的场景
- 结构体体积很小，比如仅包含几个基础类型的字段，复制成本可以忽略。
- 函数不需要修改原始结构体，只需要读取结构体字段的值。
- 需要保证原始结构体的不可变性，避免函数内部意外修改外部数据。
- 结构体是并发场景下使用的，传值可以避免共享内存带来的并发安全问题。
优先选择传指针的场景
- 结构体体积较大，比如包含大数组、切片、映射等字段，传值复制成本过高。
- 函数需要修改原始结构体的字段值，并且希望修改生效到外部实例。
- 结构体需要作为引用类型使用，多个地方操作的是同一个实例。
- 结构体实现了
sync.Locker等接口，需要传递指针才能保持锁的状态一致性。
结构体参数设计的实用建议
除了传递方式的选择，参数设计本身也有一些需要遵循的原则：
保持接口一致性
同一个结构体的相关方法，传递方式尽量统一，比如如果结构体的大部分方法都使用传指针，那么新增方法也优先使用传指针，避免调用方混淆。
避免混合使用导致的问题
如果一个结构体同时有传值和传指针的方法，需要注意方法接收者的类型，下面的示例展示了混合使用可能带来的问题：
package main
import "fmt"
type Config struct {
Timeout int
}
// 传值 receiver 的方法
func (c Config) SetTimeoutByValue(t int) {
c.Timeout = t
}
// 传指针 receiver 的方法
func (c *Config) SetTimeoutByPointer(t int) {
c.Timeout = t
}
func main() {
c := Config{Timeout: 10}
c.SetTimeoutByValue(20)
fmt.Println("传值 receiver 修改后:", c.Timeout) // 输出 10
c.SetTimeoutByPointer(20)
fmt.Println("传指针 receiver 修改后:", c.Timeout) // 输出 20
}
合理处理零值场景
当结构体参数可能为nil时，传指针需要处理空指针问题，传值则不存在这个问题，设计参数时可以结合是否需要区分零值和空值来判断：
package main
import "fmt"
type Option struct {
MaxConn int
}
// 传指针，需要判断是否为nil
func applyOptionByPointer(opt *Option) {
if opt == nil {
fmt.Println("使用默认配置")
return
}
fmt.Println("最大连接数:", opt.MaxConn)
}
// 传值，不需要处理nil，零值就是默认配置
func applyOptionByValue(opt Option) {
if opt.MaxConn == 0 {
fmt.Println("使用默认配置，最大连接数100")
return
}
fmt.Println("最大连接数:", opt.MaxConn)
}
func main() {
applyOptionByPointer(nil) // 输出 使用默认配置
applyOptionByPointer(&Option{MaxConn: 200}) // 输出 最大连接数: 200
applyOptionByValue(Option{}) // 输出 使用默认配置，最大连接数100
applyOptionByValue(Option{MaxConn: 200}) // 输出 最大连接数: 200
}
切片和映射字段的特殊处理
结构体如果包含切片、映射这类引用类型的字段，即使是传值，字段本身引用的是底层数据，修改这些字段的内容还是会影响原始结构体，这一点需要特别注意：
package main
import "fmt"
type Data struct {
Tags []string
}
// 传值修改结构体的切片字段
func updateDataByValue(d Data) {
d.Tags = append(d.Tags, "new")
}
func main() {
d := Data{Tags: []string{"old"}}
updateDataByValue(d)
// 切片本身是引用类型，append 如果触发扩容会生成新切片，这里没有触发扩容的话会修改原始数据
fmt.Println(d.Tags) // 输出 [old new]
}
如果希望完全隔离原始结构体，传值时还需要对引用类型的字段做深拷贝。