3.2 对参数值的影响

如果你之前写过 Java 代码的话经常会看到这样的代码：

public class Bar {
    
    String name;

    public void setName(String name){
    
        this.name = name;

    }

}
    

可以看到这里有 this 关键字，在 Go 中是没有的，这里的 this 可以调用当前对象的成员变量和实例方法，当使用 this 修改了成员变量就相当于在 Go 中使用了指针，看看下面的 Go 代码：

func (user *User) setNameByPoint(name string) {

    user.Name = name
}


func (user User) setName(name string) {

    user.Name = name
}
    

Go 中没有类这种语法，想要为结构体定义属于自己的方法就使用如上的两种方式，这两个方法在 Go 中称为 Receiver Type（接收者类型），可以使用结构体变量调用，我们今天只讨论结构体这种情况，来看看这两个方法有什么不同：

package main

import (
    "fmt"
)

type User struct {

    Name string
}


func (user *User) setNameByPoint(name string) {

    user.Name = name
}


func (user User) setName(name string) {

    user.Name = name
}


func main() {

    user := User{
Name: "iankevin"}

    user.setName("hello")
    fmt.Println("user.Name:", user.Name) // user.Name: iankevin

    user.setNameByPoint("world")
    fmt.Println("user.Name:", user.Name) // user.Name: world
}
    

根据输出发现一个结构体，如果不使用指针类型的时候值是不会被修改的。这点也很容易理解，在 setName方法中 user 变量被作为值传递，所以如果这时候输出 user 的内存地址会发现和外面调用的是不一样的，来看看：

package main

import (
    "fmt"
)

type User struct {

    Name string
}


func (user *User) setNameByPoint(name string) {
    
    fmt.Printf("setNameByPoint: %v address: %p \n", user, &
user) // 4
    user.Name = name
}


func (user User) setName(name string) {
    
    fmt.Printf("setName: %v address: %p \n", user, &
user) // 2
    user.Name = name
}


func main() {

    user := User{
Name: "iankevin"}
    
    fmt.Printf("src user: %v address: %p \n", user, &
    user) // 1

    user.setName("hello")
    fmt.Printf("by value user: %v address: %p \n", user, &
    user) // 3

    user.setNameByPoint("world")
    fmt.Printf("by point user: %v address: %p \n", user, &
user) // 5
}


/**
1. src user: {
iankevin}
        address: 0xc000014270
2. setName: {
iankevin}
         address: 0xc000014290
3. by value user: {
iankevin}
       address: 0xc000014270
4. setNameByPoint: &
{
iankevin}
 address: 0xc000012030
5. by point user: {
world}
          address: 0xc000014270
**/

而 setNameByPoint 方法和前面的指针类型传递是一样的，方法内部内存地址是一份指针的拷贝，修改数据会影响到外部指针变量的数据。

一般而言，工程化的项目中会出现非常多结构体定义方法的代码，这些方法的调用也会很频繁，使用结构体将其封装起来，和 Java 中类封装是一样的，大多数情况下建议都使用指针传递，避免值拷贝的情况。

4、内存变化分析

我们使用值类型和指针类型在内存的视角上会有什么不同之处吗？这将使得我们对这两个概念理解更加深入。

4.1 函数/方法返回值的情况

package main

import (
    "fmt"
)

var a = "hello world"

func returnValue() string {

    return a
}


func returnPoint() *string {
    
    return &
a
}


func main() {
    
    a1 := returnValue()
    a2 := returnPoint()

    fmt.Printf("a: %v address: %p \n", a, &
    a)     
    fmt.Printf("a1 : %v address: %p \n", a1, &
    a1)  
    fmt.Printf("a2 : %v address: %p \n", *a2, &
a2) 
}
    

//  a : hello world address: 0xc000014270 
// a1 : hello world  address: 0xc000014280 
// a2 : hello world  address: 0xc000012028 

从这个输出中可以看到数据都是一样的，这里使用 %p 输出一个指针的值（内存地址）都不同。第一个毋庸置疑是初始的内存地址，a1 是调用返回值类型的结果，a2 是返回指针类型的结果。照这样看的话好像返回指针还是值类型没有区别，地址都是新的。

来分析一下，首先 a1 的内存地址发生变化是因为方法参数被拷贝后产生了一份新的值给 a1，此时 a1 分配了新地址。对于 a2 也拷贝了一份新值，只不过这个值是 指针类型，所以在取数据的时候用了 * 进行解引用。

既然都分配了地址，到底使用值类型还是指针类型作为返回值，推荐这么做：

• 当返回类型不涉及状态变更并且是较简单的数据结构，一律返回值类型
• 当返回类型可能遇到状态变更或者你关心它的生命周期则使用指针类型
• 当返回的结构比较大的时候使用指针类型

4.2 函数/方法参数情况

来看下面的例子：

package main

import (
    "fmt"
    "strings"
)

type User struct {

    Name string
}


func nameToUpper(user User) string {
    
    user.Name = strings.ToUpper(user.Name)
    fmt.Printf("nameToUpper user: %v address: %p \n", user, &
user) // 2
    return user.Name
}


func main() {

    user := User{
Name: "iankevin"}
    
    fmt.Printf("user: %v address: %p \n", user, &
    user) // 1

    nameToUpper(user)
    fmt.Printf("user: %v address: %p \n", user, &
user) // 3
}


// user: {
iankevin}
 address: 0xc000014270
// nameToUpper user: {
IANKEVIN}
 address: 0xc000014290
// user: {
iankevin}
     address: 0xc000014270

nameToUpper 接收值类型的参数，观察输出你会发现在外部的 foo 变量内存地址是没有发生变化的。

在方法内部接收这个 值类型变量 的时候，内存地址和外面不同，这意味着 Go 会将这个值类型参数作为一个拷贝传递过去，在方法内部的改变都不会影响到外面的变量。

如果将函数/方法的参数修改为指针类型呢？

package main

import (
    "fmt"
    "strings"
)

type User struct {

    Name string
}


func modifyName(user *User) {
    
    fmt.Printf("modifyName user: %v address: %p \n", user, &
user) // 2
    user.Name = "hello " + user.Name
}


func main() {
    
    user := &
User{
Name: "iankevin"}
    
    fmt.Printf("user: %v address: %p \n", user, &
    user) // 1

    modifyName(user)
    fmt.Printf("user: %v address: %p \n", user, &
user) // 3
}
    

// user: &
{
iankevin}
     address: 0xc000012028 
// modifyName user: &
{
iankevin}
     address: 0xc000012038 
// user: &
{
hello iankevin}
     address: 0xc000012028 

可以看到，数据被修改了，因为传递的是指针；内存地址没有发生变化，作为入参的 foo 在方法内部的地址也是一份新的拷贝，这一点和前面返回值是相同的（0xc00000c028 和 0xc00000c038 指向同一份数据）。

4.3 其他类型数据

在前面我们有一张图中分了值类型和引用类型，除了那些常用的基本类型，还有像 map 和 slice 这种引用类型，它们在使用上有点像指针（但不用任何操作符如 & 、*），来看个例子：

package main

import (
    "fmt"
)

func updateMap(mmp map[string]int) {

    mmp["iankevin"] = 2333
}


func main() {
    
    mmp := make(map[string]int)
    mmp["iankevin"] = 1024
    fmt.Printf("src mmp: %v address: %p \n", mmp, &
    mmp) // 1

    updateMap(mmp)
    fmt.Printf("new mmp: %v address: %p \n", mmp, &
mmp) // 2
}
    

/**
src mmp: map[iankevin:1024] address: 0xc000012028 
new mmp: map[iankevin:2333] address: 0xc000012028 
**/

如果你尝试 slice 的话是同样的效果，可以看到给方法传递的并非是一个指针类型，但是 map 的值确实被修改了，这是为什么呢？

其实拷贝一个 map 或者 slice 的时候并没有拷贝这个类型（引用类型）里面指向的数据，而是拷贝了引用类型（可简单理解为指针），如何验证这一说法呢？我们在 updateMap 中添加一行输出代码，再次运行代码：

package main

import (
    "fmt"
)

func updateMap(mmp map[string]int) {
    
    fmt.Printf("param mmp: %v address: %p \n", mmp, &
mmp) // 2
    mmp["iankevin"] = 2333
}


func main() {
    
    mmp := make(map[string]int)
    mmp["iankevin"] = 1024
    fmt.Printf("src mmp: %v address: %p \n", mmp, &
    mmp) // 1

    updateMap(mmp)
    fmt.Printf("new mmp: %v address: %p \n", mmp, &
mmp) // 3
}
    

/**
src mmp: map[iankevin:1024] address: 0xc000012028 
param mmp: map[iankevin:1024] address: 0xc000012038 
new mmp: map[iankevin:2333] address: 0xc000012028 
**/

你会发现 input mmp 这行的地址发生了变化，正因为拷贝的是这个特殊的 “引用类型”，会产生一个新的地址，而这个地址 0xc000012038 和 0xc000012028 指向的是同一份数据，所以修改后外部的变量也会得到新的数据。

5、总结

前面我们通过一些代码示例来演示了在 Go 中值类型和指针类型的一些具体表现，最后我们要回答这么几个问题，希望你能够在使用 Go 编程的过程中更加清晰的掌握这些技巧。

Receiver Type 为什么推荐使用指针？

• 推荐在实例方法上使用指针（前提是这个类型不是一个自定义的 map、slice 等引用类型）
• 当结构体较大的时候使用指针会更高效
• 如果要修改结构内部的数据或状态必须使用指针
• 当结构类型包含 sync.Mutex 或者同步这种字段时，必须使用指针以避免成员拷贝
• 如果你不知道该不该使用指针，使用指针！

“结构较大” 到底多大才算大可能需要自己或团队衡量，如超过 5 个字段或者根据结构体内占用来计算。

函数/方法参数该使用什么类型？

• map、slice 等类型不需要使用指针（自带 buf）
• 指针可以避免内存拷贝，结构大的时候不要使用值类型
• 值类型和指针类型在方法内部都会产生一份拷贝，指向不同
• 小数据类型如 bool、int 等没必要使用指针传递
• 初始化一个新类型时（像 NewEngine() *Engine）使用指针
• 变量的生命周期越长则使用指针，否则使用值类型

参考

• Should I define methods on values or pointers?
• Receiver Type
• Pointers vs. values in parameters and return values

end ~

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！