Go:为什么你应当避免使用指针
via:
https://medium.com/better-programming/why-you-should-avoid-pointers-in-go-36724365a2a7
作者:Dirk Hoekstra
四哥水平有限,如有翻译或理解错误,烦请帮忙指出,感谢!
别被作者的这个标题误导了,其实阅读完全文,发现作者并不是排斥使用指针,而是应选择适当的场景去使用指针。关于指针的基础知识,可以阅读公号之前发的文章 指针。
原文如下:
什么是指针
为了覆盖基础知识,我们先讲解什么是指针。
看下面 CoffeeMachine 的例子,CoffeeMachine 结构体中保存咖啡豆的数量。
为了创建一台“咖啡机”,我需要使用 NewCoffeeMachine() 函数。
这里我创建了一个新的结构体,使用 & 操作符返回结构体的引用。
type CoffeeMachine struct {
NumberOfCoffeeBeans int
}
func NewCoffeeMachine() *CoffeeMachine {
return &CoffeeMachine{}
}
当我将 CoffeeMachine 结构体的引用传递给其他函数时,在这些函数里可以改变结构体的底层数据。
例如,我可以创建 SetNumberOfCoffeeBeans() 函数,可以像下面这样在函数内部改变 CoffeeMachine 结构体的值:
package main
import "fmt"
type CoffeeMachine struct {
NumberOfCoffeeBeans int
}
func NewCoffeeMachine() *CoffeeMachine {
return &CoffeeMachine{}
}
func (cm *CoffeeMachine) SetNumberOfCoffeeBeans(n int) {
cm.NumberOfCoffeeBeans = n
}
func main() {
cm := NewCoffeeMachine()
cm.SetNumberOfCoffeeBeans(100)
fmt.Printf("The coffee machine has %d beans\n", cm.NumberOfCoffeeBeans)
}
因为 SetNumberOfCoffeeBeans() 函数的指针接收者指向 CoffeeMachine() 结构体的底层结构,所以在函数内部可以直接改变结构体字段的值。
因此,当我运行此程序时,显示机器中确实有 100 个咖啡豆!
go run main.go
The coffee machine has 100 beans
不使用指针解决这个问题
我们可以使用非指针方式实现同样的“咖啡机”
func NewCoffeeMachine() CoffeeMachine {
return CoffeeMachine{}
}
func (cm CoffeeMachine) SetNumberOfCoffeeBeans(n int) CoffeeMachine {
cm.NumberOfCoffeeBeans = n
return cm
}
func main() {
cm := NewCoffeeMachine()
cm = cm.SetNumberOfCoffeeBeans(100)
fmt.Printf("The coffee machine has %d beans\n", cm.NumberOfCoffeeBeans)
}
现在主要不同的是 SetNumberOfCoffeeBeans() 函数接收的是 CoffeeMachine 结构体的副本,正因为这样,需要返回更新之后的 CoffeeMachine 结构体。
输出结构如下:
go run main.go
The coffee machine has 100 beans
性能
好的,到这里你可能会在想:“是不是传值始终都会比传指针效率低”。
现在我们来做个实用性的测试,比较下传指针和传值的效率。
我修改了 CoffeeMachine 结构体,加入了两个字段 UID 和 Description。
type CoffeeMachine struct {
UID string
Description string
NumberOfCoffeeBeans int
}
下一步,我使用指针方式给结构体赋值,循环 100000 次,测量需要消耗多长时间。
func main() {
cm := NewCoffeeMachine()
start := time.Now()
for i := 0; i<100000; i++ {
cm.SetUID(fmt.Sprintf("random-generated-uid-%d", i))
cm.SetNumberOfCoffeeBeans(i)
cm.SetDescription(fmt.Sprintf("This is the best coffee machine that is around! This is version %d", i))
}
elapsed := time.Since(start)
fmt.Printf("It took %s\n", elapsed)
}
同样的,我们再次使用传值的方式实现上面的赋值操作。
func main() {
cm := NewCoffeeMachine()
start := time.Now()
for i := 0; i<100000; i++ {
cm = cm.SetUID(fmt.Sprintf("random-generated-uid-%d", i))
cm = cm.SetNumberOfCoffeeBeans(i)
cm = cm.SetDescription(fmt.Sprintf("This is the best coffee machine that is around! This is version %d", i))
}
elapsed := time.Since(start)
fmt.Printf("It took %s\n", elapsed)
}
分别执行这两段程序,发现消耗的时间差不多:
With pointers result: 32ms
Without pointers result: 31ms
我上面举例子使用的结构体比较小,如果需要拷贝的结构体很大,则性能差距会更大。
“意外之喜”
所以,使用指针的缺点是什么?
当你在函数之间传指针时,你不知道是否会改变指针指向的值。
这增加了代码库的复杂性,并且随着代码的增长,很容易就会出现错误,因为调用堆栈深处的某个地方改变了指针指向的值。
最近,在我的项目里遇到了一个“搜索商品”的函数:
func SearchProducts(criteria *SearchCriteria) []Product {
// Searches for products here
}
在这个函数里,我不希望 SearchCriteria 被改变。但是,事实证明,在函数某个地方已经将 SearchCriteria 的值改变了。
在我看来,尽可能使用不可变的参数(即值而不是指针)是一种更好的做法,并且可以避免此类bug。
指针的 Nil 值
使用指针的时候,我们都需要考虑指针可能为 nil 的情况。程序员在使用指针之前不会被明确地强制检查指针是否为 nil 的情况,因此在代码里很容易出现这种人为错误。
一起来思考下面这个例子:
package main
import "fmt"
type Product struct {
Price string
}
func GetProduct(productUid string) *Product {
// Code that retrieves a product or nil if not found.
// Let's simulate a "not found" scenario.
return nil
}
func main() {
product := GetProduct("corona-face-mask")
fmt.Println("The Corona Face mask is currently %d euro's", product.Price)
}
在这个例子中,函数 GetProduct() 返回一个 nil 值,但是我们没有强制检查返回值是否为 nil,所以运行这代代码会报错 nil pointer:
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x8 pc=0x10994f3]
goroutine 1 [running]:
main.main()
main.go:17 +0x23
exit status 2
解决这个问题更优雅的做法是,如果商品没有找到就返回空结构体和错误信息,想下面这样:
package main
import (
"fmt"
"errors"
)
type Product struct {
Price string
}
func GetProduct(productUid string) (Product, error) {
// Code that retrieves a product or nil if not found.
// Let's simulate a "not found" scenario.
return Product{}, errors.New("Product not found")
}
func main() {
product, err := GetProduct("corona-face-mask")
if err != nil {
fmt.Println("Error, product not found")
} else {
fmt.Println("The Corona Face mask is currently %d euro's", product.Price)
}
}
像上面那样,判断返回值是否为 nil,绝对可以确保不会发生 nil pointer 错误。
什么时候使用指针
好吧,使用指针并不总是坏事,下面这两种情况你应当使用指针
当你确实需要修改参数的时候
举个例子,下面的代码片段,通过指针的方式可以直接在函数 setName() 里面修改 User 结构体的 Name 字段。
type User struct {
Name string
}
func (user *User) setName(name string) {
user.Name = name
}
func main() {
user := &User{}
user.setName("John")
}
当使用单例的时候
有时候,当需要在全局保存唯一一个实例时,使用指针就很重要,这样就能确保内存中的数据不会发生多次拷贝(拷贝是需要消耗性能的)。
总结
不要在项目里面疯狂地使用指针,而是要考虑何时以及如何更好地使用指针。
如果你遵循上面的建议,大概率你就不会再次遇到 nil pointer dereference 的错误!
推荐阅读
站长 polarisxu
自己的原创文章
不限于 Go 技术
职场和创业经验
Go语言中文网
每天为你
分享 Go 知识
Go爱好者值得关注