在Go语言里，指针是一种保存了另一个变量内存地址的值。理解指针并不复杂，核心就是两个操作符：&用于获取变量的地址，*用于根据地址读取或修改对应的数据。和C语言不同，Go的指针不能进行加减运算，也不能任意转换类型，因此它避开了很多底层内存操作带来的风险，同时保留了间接访问和共享数据的能力。Go函数默认采用值传递，也就是说调用函数时实参会被复制一份。如果参数是大型结构体或数组，复制成本会很高，而指针只复制一个地址值，这也是它在Go项目中最常见的价值之一。
一、指针的声明、赋值与零值
声明指针类型时，通常把 * 放在类型前面，例如 var p *int 表示 p 是一个指向 int 类型数据的指针。指针的零值是 nil，它不指向任何内存地址。对 nil 指针进行解引用会触发运行时 panic，所以使用指针前需要判断它是否为空。要获得一个变量的地址，使用取地址操作符 &，例如 x := 10; p := &x。也可以使用内置函数 new，new(int) 会分配一块 int 类型的零值内存并返回指向它的指针。
需要理解的是，&x 产生的是一个地址值，而 *p 则是根据这个地址找到那块内存。可以把地址想象成门牌号，*p 就是走进对应房间查看或修改里面的东西。Go 指针的类型信息会告诉编译器该地址上存放的是什么类型，这样解引用时才能正确解释内存数据。指针本身也占用内存，在 64 位平台上通常为 8 字节，保存的内容就是目标变量的地址。
下面的代码展示了声明、赋值、解引用和零值判断：
package main
import "fmt"
func main() {
var p *int
fmt.Println(p == nil) // true
x := 10
p = &x
fmt.Println(p) // 类似 0xc0000140a0
fmt.Println(*p) // 10
*p = 20
fmt.Println(x) // 20
}
另外，并不是所有值都可以取地址。变量、数组元素、结构体字段等通常可以取地址，而常量、临时表达式结果以及 map 的元素不能取地址。例如 m["key"] 不能在不需要重新赋值的情况下直接取地址，因为 map 扩容时元素位置可能变化。
二、函数参数中的指针：修改外部变量与减少复制
Go 语言只有值传递，没有引用传递。调用函数时，实参的值会被复制一份交给函数。如果一个函数接收普通结构体参数，内部对它字段的修改不会影响调用方，因为修改的是副本。要让函数真正改变外部变量，需要把变量的指针传进去。指针作为参数时，复制的是地址值，函数内部的指针和调用方的指针指向同一块内存，因此通过解引用可以修改原数据。
下面这个例子分别使用值传递和指针传递修改 User 的年龄：
package main
import "fmt"
type User struct {
Name string
Age int
}
func updateByValue(u User) {
u.Age = 30
}
func updateByPointer(u *User) {
u.Age = 30
}
func main() {
user := User{Name: "Alice", Age: 25}
updateByValue(user)
fmt.Println(user.Age) // 25
updateByPointer(&user)
fmt.Println(user.Age) // 30
}
除了修改外部变量，指针参数还能避免大对象复制。如果结构体包含大数组、长字符串或很多字段，按值传递会复制整块内存，可能造成较大的栈或堆开销。指针只需要复制 8 字节地址，调用开销明显更低。不过也不能因此认为指针一定更好：指针会增加间接寻址成本，而且如果局部变量被取地址后逃逸到堆上，会带来垃圾回收压力。具体是否使用指针，要结合对象大小、调用频率和是否修改原值来权衡。
还有一种常见用法是用 nil 表示可选参数或未赋值状态。例如函数使用 *Config 而不是 Config，当调用方传 nil 时可以走默认配置逻辑。值类型无法表达“没有”这个概念，因为它总有一个零值。
三、方法接收者：值接收者与指针接收者的区别
Go 的方法接收者可以是值类型，也可以是指针类型。值接收者方法在调用时复制接收者本身，方法内修改字段不会影响原对象；指针接收者方法则通过指针操作原对象，修改会直接反映到调用方。下面的 Counter 示例能清楚看到区别：
package main
import "fmt"
type Counter struct {
total int
}
func (c Counter) addByValue(n int) {
c.total += n
}
func (c *Counter) addByPointer(n int) {
c.total += n
}
func main() {
c := Counter{}
c.addByValue(5)
fmt.Println(c.total) // 0
c.addByPointer(5)
fmt.Println(c.total) // 5
}
选择值接收者还是指针接收者，通常看三个因素：是否需要修改接收者状态、接收者是否较大需要避免复制、以及类型是否希望保持一致性。如果某个类型的一个方法使用了指针接收者，其他方法也建议使用指针接收者，避免混用导致调用方疑惑。
接口实现也和方法接收者有关。假设定义一个接口 type Adder interface { Add(n int) }，如果 Add 是值接收者方法，那么 Counter 和 *Counter 都可以赋值给该接口；如果 Add 是指针接收者方法，只有 *Counter 能实现接口。这个规则源于方法集：类型 T 的方法集只包含值接收者方法，而 *T 的方法集同时包含值接收者和指针接收者方法。很多接口使用场景下，指针接收者会让类型更灵活，但也要注意不能把普通值直接传给需要指针接口的地方。
四、典型使用场景与性能取舍
指针在 Go 项目中的典型场景可以归纳为几类。第一，函数需要修改外部变量，例如初始化、更新状态、参数回传。第二，避免大对象复制，例如一个包含 [1024]int 数组的结构体，按值传递会复制 8KB 甚至更多内容，而指针只复制地址。第三，方法需要修改接收者本身，例如链表节点的 Next 字段、缓存对象的命中次数。第四，需要区分零值与未赋值，例如数据库查询是否查到了记录，可以用 *Record 是否为 nil 来判断。
性能上，指针不是无条件更快的。对于小对象，复制一个几十字节的结构体可能比通过指针间接访问更快，因为值对象常常可以分配在栈上，访问时缓存命中率更好。一旦对变量取地址并让它逃逸，Go 编译器会把它分配到堆上，后续的垃圾回收需要扫描这些对象。频繁创建和丢弃指针对象会增加 GC 的负担。判断是否发生逃逸可以使用 go build -gcflags="-m" 查看编译器的逃逸分析结果。总体原则是：小型、不改原值、生命周期短的数据用值类型；大型、需要共享或修改的数据用指针。
并发场景下，指针共享同一块内存也意味着如果多个 goroutine 同时读写这个内存，就会出现数据竞争。必须通过 sync.Mutex、channel 或其他同步机制来保护。单纯换用指针并不能解决并发问题，反而容易隐藏共享状态。开发时建议配合 go test -race 检查竞态。
五、哪些东西不需要指针：切片、map、channel
切片、map 和 channel 在 Go 中经常被误认为需要传指针才能修改，其实它们内部已经包含指向底层数据结构的指针。函数传参时复制的是描述符，但描述符和原变量共享底层数组、哈希表或队列。所以下面这种修改切片元素的做法是有效的：
package main
import "fmt"
func updateSlice(s []int) {
s[0] = 99
}
func main() {
nums := []int{1, 2, 3}
updateSlice(nums)
fmt.Println(nums[0]) // 99
}
但如果函数内对切片执行了 append 可能改变长度或容量，或者执行重新赋值，调用方是否能看到变化取决于底层数组是否发生了扩容。想让函数内对切片本身的修改（例如重新分配）影响调用方，可以传 *[]int，但更常见的做法是让函数返回新的切片。对于 map，如果传入的是 nil map，在函数内直接赋值会 panic，此时可以传 *map，但推荐在外部先用 make 初始化。
还需要注意 map 元素不能取地址。m := map[string]int{"a": 1}; p := &m["a"] 无法编译，原因是 map 扩容会重新分布元素，旧地址会失效。如果需要修改 map 中的结构体字段，通常做法是取出该值、修改字段后再写回 map，或者让 map 的值类型为指向结构体的指针，例如 map[string]*User。
最后，指针使用前必须考虑 nil。调用指针接收者方法时，如果接收者是 nil，方法仍然可以执行，但方法内部访问字段或解引用就会 panic。如果方法允许处理 nil 接收者，应该在方法开头显式判断，例如 if c == nil { return }。这种防御式写法能避免一些运行时崩溃。