&和*

Go 语言中，一个变量可以正常赋值。

通过 & 获取内存地址（指针），指针也可以赋值。

这使得我这种从 Java 语言跳出的小伙伴看的一头雾水，先看概念。

• &：取址符（指针），用于返回一个变量的内存地址。
• *：指针值，用于返回一个指针的具体变量值。

实例感受

编写一个简单的实例来感受下变量和指针的特性。

func main() {
    A := 3
    fmt.Printf("A值：%v 
", A)
    fmt.Printf("A内存地址：%p 
", &A)
    // 变量取址（指针）
    P := &A
    fmt.Printf("P值(实际是A的地址)：%v 
", P)
    fmt.Printf("P内存地址：%p 
", &P)
    // 指针取值
    fmt.Printf("P实际值：%v 
", *P)
}

输出结果如下：

A值：3
A内存地址：0xc00000a0c8
P值(实际是A的地址)：0xc00000a0c8
P内存地址：0xc000006030
P实际值：3

变量和指针赋值

直接上代码。

func main() {
    A := 3
    fmt.Printf("A值：%v 
", A)
    P := &A
    fmt.Printf("P值(实际是A的地址)：%v 
", P)
    fmt.Printf("P实际值：%v 
", *P)
    // 变量赋值
    A = 4
    fmt.Printf("A值：%v 
", A)
    // 指针赋值
    *P = 5
    fmt.Printf("P值(实际是A的地址)：%v 
", P)
    fmt.Printf("P实际值：%v 
", *P)
    fmt.Printf("A值：%v 
", A)
}

输出结果如下：

A值：3
P值(实际是A的地址)：0xc000062090
P实际值：3
A值：4
P值(实际是A的地址)：0xc000062090
P实际值：5
A值：5

通过变量赋值和指针赋值，可得大致得到如下流程图：

函数入参

从上文中，我们可以看到变量的值修改可以使用变量赋值或者指针赋值。

表面上看起来，最终实现的效果都一致，那指针赋值的意义何在呢？感觉似乎绕了一圈实现了同一个结果？

这里就涉及到函数入参问题，在 Go 中函数的入参均是值传递，也就是说将入参对象（变量）的值 Copy 一份出来传到函数中。

既然是值传递就必然带来一个问题，无法修改入参变量原本的值，可以通过下方 DEMO 验证一下。

func main() {
    A := 3
    fmt.Printf("A值：%v 
", A)
    // A 值修改方法
    changeA(A)
    fmt.Printf("修改方法后的A值：%v 
", A)
}

func changeA(A int) {
    A = 4
    fmt.Printf("修改方法，A值：%v 
", A)
}

输出结果如下：

A值：3
修改方法，A值：4
修改方法后的A值：3

为了进一步验证为什么修改没有生效，我们输出各自的内存地址：

A值：3
A内存地址：0xc00000a0c8
修改方法，A内存地址：0xc00000a110
修改方法，A值：4
修改方法后的A内存地址：0xc00000a0c8
修改方法后的A值：3

我们发现，在 changeA() 函数中所修改的 A 变量的内存地址和 main() 函数的内存地址并不一样，因此可以确定函数中的 A 变量是一个全新的 Copy 出来的变量。

如何解决？

函数返回

常见的形式就是函数直接返回修改后的变量。

func main() {
    A := 3
    fmt.Printf("A值：%v 
", A)
    // A 值修改方法
    A = changeA(A)
    fmt.Printf("修改方法后的A值：%v 
", A)
}

func changeA(A int) int {
    A = 4
    fmt.Printf("修改方法，A值：%v 
", A)
    return A
}

输出结果如下：

A值：3
修改方法，A值：4
修改方法后的A值：4

函数传递指针

如果我们不想函数有返回值，又希望修改入参变量的值，指针和指针赋值就可以达成这个目录。

func main() {
    A := 3
    fmt.Printf("A值：%v 
", A)
    // A 值修改方法
    changeA(&A)
    fmt.Printf("修改方法后的A值：%v 
", A)
}

func changeA(A *int) {
    *A = 4
    fmt.Printf("修改方法，A值：%v 
", A)
    fmt.Printf("修改方法，A实际值：%v 
", *A)
}

输出结果如下：

A值：3
修改方法，A值：0xc00000a0c8
修改方法，A实际值：4
修改方法后的A值：4

入参形式选择

从上文我们大致感受到，函数在接受参数时均使用值传递，一定会执行一次 Copy 的过程。

如果直接 Copy 的是一个对象（变量），对 Copy 后的对象（变量）修改永远无法影响初始对象（变量），除非返回结果并对初始对象（变量）重新赋值。

如果 Copy 的是一个指针，本质上在对 Copy 后的指针赋值的时候，最终还是指向了初始对象（变量），因此能够实现初始对象（变量）的修改。

既然如此，在什么场景下选择什么入参形式就一目了然了。

1. 单纯的基于入参梳理后续数据，可以优先考虑直接对象（变量）传递。
2. 涉及到对初始对象（变量）进行修改，可以考虑使用指针传递。
3. 如果初始对象（变量）是基本数据类型或者简单类型的 struct，建议直接变量传递，通过返回值赋值，效率较高（非指针内存多数放在栈上）。
4. 如果初始对象（变量）比较复杂，体量大（Copy 内存消耗高）或者涉及多层的嵌套（深层赋值的消耗），建议使用指针传递。