Go：为什么你应当避免使用指针

点击上方蓝色“Golang来啦”关注我哟

加个“星标”，天天 15 分钟，掌握 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 的错误！

推荐阅读：

Go 语言机制之栈与指针

彻底学会Go指针

如果我的文章对你有所帮助，点赞、转发都是一种支持！

给个[在看]，是对四哥最大的支持