via:
作者：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 的错误！
