go结构体详解

结构体简介

Golang 中没有“类”的概念，Golang 中的结构体和其他语言中的类有点相似。和其他面向对象语言中的类相比，Golang 中的结构体具有更高的扩展性和灵活性。

Golang 中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型就无法满足需求了，Golang 提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称 struct。也就是我们可以通过 struct 来定义自己的类型了。

type 关键词自定义类型和类型别名

Golang 中通过 type 关键词定义一个结构体，在讲解结构体之前，我们首先给大家看看通过type 自定义类型以及定义类型别名。

1. 自定义类型

在 Go 语言中有一些基本的数据类型，如 string、整型、浮点型、布尔等数据类型， Go 语言中可以使用 type 关键字来定义自定义类型。

type myInt int

上面代码表示：将 myInt 定义为 int 类型，通过 type 关键字的定义，myInt 就是一种新的类型，它具有 int 的特性。

2. 类型别名

Golang1.9 版本以后添加的新功能。

类型别名规定：TypeAlias 只是 Type 的别名，本质上 TypeAlias 与 Type 是同一个类型。就像一个孩子小时候有大名、小名、英文名，但这些名字都指的是他本人。

type TypeAlias = Type

我们之前见过的 rune 和 byte 就是类型别名，他们的底层定义如下：

type byte = uint8
type rune = int32

自定义类型和类型别名的区别

类型别名与自定义类型表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。

package mainimport ("fmt"
)// 类型定义
type newInt int// 类型别名
type myInt = intfunc main() {var a newIntvar b myIntfmt.Printf("type of a:%T\n", a) //type of a:main.newIntfmt.Printf("type of b:%T\n", b) //type of b:int
}

结果显示 a 的类型是 main.newInt，表示 main 包下定义的 newInt 类型。b 的类型是 int 类型。

下面让我们通过一些具体的例子来帮助你更好地理解Go语言中自定义类型和类型别名的区别。

1. 自定义类型案例

假设我们正在开发一个应用程序，需要记录用户的年龄。我们可以创建一个名为Age的新类型，基于整数类型：

type Age intfunc (a Age) isAdult() bool {return a >= 18
}func main() {var userAge Age = 20fmt.Println(userAge.isAdult()) // 输出: true
}

在这个例子中，Age是一个自定义类型。它不仅限于只是一个整数，还拥有自己的方法isAdult()，用于判断该年龄是否达到成年标准。即使int类型的值为20，也不能直接赋值给Age变量（除非显式转换），因为它们被视为不同的类型。

2. 类型别名案例

现在考虑我们需要在项目中处理大量的用户ID，这些ID实际上是字符串形式的。为了简化代码，我们可以为string类型创建一个别名UserID：

type UserID = stringfunc main() {var id UserID = "user123"var str string = id // 这里可以直接赋值，因为UserID是string的别名fmt.Println(str) // 输出: user123
}

在这个例子中，UserID是string类型的别名。这意味着UserID和string实际上是同一个类型，你可以自由地将一个UserID类型的值赋给一个string类型的变量，反之亦然，而不需要进行任何类型转换。此外，你不能给UserID添加新的方法，因为它不是新类型，而是现有类型的一个别名。

总结

• 自定义类型：当你想要基于某个已有类型创建一个新的、独立的类型，并且可能想为这个新类型添加特定的方法或行为时使用。例如，我们的Age类型。
• 类型别名：当你想要简化复杂类型的引用或者是在重构过程中希望保持类型兼容性时使用。比如，我们的UserID别名。

结构体定义初始化的几种方法

1. 结构体的定义

使用 type 和 struct 关键字来定义结构体，具体代码格式如下：

type 类型名 struct {
字段名 字段类型
字段名 字段类型
…
}

其中：

• 类型名：表示自定义结构体的名称，在同一个包内不能重复。
• 字段名：表示结构体字段名。结构体中的字段名必须唯一。
• 字段类型：表示结构体字段的具体类型。

举个例子，我们定义一个 person（人）结构体，代码如下：

type person struct {name stringcity stringage  int8
}

同样类型的字段也可以写在一行，

type person struct {
name, city string
age int8
}

注意：结构体首字母可以大写也可以小写，大写表示这个结构体是公有的，在其他的包里面可以使用。小写表示这个结构体是私有的，只有这个包里面才能使用。

2. 结构体实例化（第一种方法）

只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。结构体本身也是一种类型，我们可以像声明内置类型一样使用 var 关键字声明结构体类型。

var 结构体实例 结构体类型

示例代码：

package mainimport ("fmt"
)type person struct {name stringcity stringage  int8
}func main() {var p1 personp1.name = "张三"p1.city = "北京"p1.age = 18fmt.Printf("p1=%v\n", p1)  //p1={张三 北京 18}fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"张三", city:"北京", age:18}
}

3. 结构体实例化（第二种方法）

我们还可以通过使用 new 关键字对结构体进行实例化，得到的是结构体的地址。 格式如下：

package mainimport ("fmt"
)type person struct {name stringcity stringage  int8
}func main() {var p2 = new(person)p2.name = "张三"p2.age = 20p2.city = "北京"fmt.Printf("%T\n", p2)     //*main.personfmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"张三", city:"北京", age
}

从打印的结果中我们可以看出 p2 是一个结构体指针。

注意：在 Golang 中支持对结构体指针直接使用.来访问结构体的成员。p2.name = “张三” 其实在底层是(*p2).name = “张三”。

4. 结构体实例化（第三种方法）

使用&对结构体进行取地址操作相当于对该结构体类型进行了一次 new 实例化操作。

package mainimport ("fmt"
)type person struct {name stringcity stringage  int8
}func main() {p3 := &person{}fmt.Printf("%T\n", p3)     //*main.personfmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}p3.name = "zhangsan"p3.age = 30p3.city = "深圳"(*p3).age = 40             //这样也是可以的fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"zhangsan", city:"深圳", age:3
}

5. 结构体实例化（第四种方法） 键值对初始化

package mainimport ("fmt"
)type person struct {name stringcity stringage  int8
}func main() {p4 := person{name: "zhangsan", city: "北京", age: 18}fmt.Printf("p4=%#v\n", p4) //p4=main.person{name:"zhangsan", city:"北京", age:18}
}

6. 结构体实例化（第五种方法） 结构体指针进行键值对初始化

package mainimport ("fmt"
)type person struct {name stringcity stringage  int8
}func main() {p5 := &person{name: "zhangsan", city: "上海", age: 28}fmt.Printf("p5=%#v\n", p5) //p5=&main.person{name:"zhangsan", city:"上海", age:28}
}

当某些字段没有初始值的时候，这个字段可以不写。此时，没有指定初始值的字段的

package mainimport ("fmt"
)type person struct {name stringcity stringage  int8
}func main() {p6 := &person{city: "北京"}fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"", city:"北京", age:0}
}

7. 结构体实例化（第六种方法） 使用值的列表初始化

package mainimport ("fmt"
)type person struct {name stringcity stringage  int8
}func main() {// 初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：p7 := &person{"zhangsan", "北京", 28}fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"zhangsan", city:"北京", age:28}
}

使用这种格式初始化时，需要注意：

• 必须初始化结构体的所有字段。
• 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
• 该方式不能和键值初始化方式混用。

结构体方法和接收者

在 go 语言中，没有类的概念但是可以给类型（结构体，自定义类型）定义方法。所谓方法就是定义了接收者的函数。接收者的概念就类似于其他语言中的 this 或者 self。

方法的定义格式如下：

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}

其中

• 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是 self、this 之类的命名。例如，Person 类型的接收者变量应该命名为 p，Connector 类型的接收者变量应该命名为 c 等。
• 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
• 方法名、参数列表、返回参数：具体格式与函数定义相同。

示例代码：

package mainimport ("fmt"
)type Person struct {name stringage  int8
}func (p Person) printInfo() {fmt.Printf("姓名:%v 年龄:%v", p.name, p.age)
}
func main() {p1 := Person{name: "小王子", age: 25}p1.printInfo()
}

运行结果：

姓名:小王子 年龄:25

1. 值类型的接收者

当方法作用于值类型接收者时，Go 语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。

2. 指针类型的接收者

指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的 this 或者 self。

代码示例：

package mainimport ("fmt"
)type Person struct {name stringage  int
}// 值类型接收者
func (p Person) printInfo() {fmt.Printf("姓名:%v 年龄:%v\n", p.name, p.age)
}// 指针类型接收者
func (p *Person) setInfo(name string, age int) {p.name = namep.age = age
}
func main() {p1 := Person{name: "小王子", age: 25}p1.printInfo()p1.setInfo("张三", 20)p1.printInfo()p1.setInfo("李四", 24)p1.printInfo()
}

运行结果：

姓名:小王子 年龄:25
姓名:张三 年龄:20
姓名:李四 年龄:24

在Go语言中，给结构体增加方法时选择值接收者还是指针接收者，主要取决于你是否需要在方法内部修改结构体的字段，以及关于性能和语义方面的考量。以下是选择哪种方式的一些指导原则：

• 如果需要修改结构体的字段：

  • 应该使用指针接收者。因为只有通过指针接收者，方法内部对结构体字段的修改才会反映到调用该方法的实例上。例如，在你的代码示例中，setInfo方法使用了指针接收者，这样它才能改变Person实例的name和age属性。

• 如果方法不修改结构体的字段：

  • 通常使用值接收者就足够了。这可以避免不必要的内存分配和复制操作。比如printInfo方法，因为它不需要修改结构体的状态，所以可以安全地使用值接收者。

• 关于性能：

  • 对于大型结构体来说，使用指针接收者可以避免复制整个结构体带来的开销，从而提高性能。
  • 对于小型结构体（如只包含几个基本类型的字段），使用值接收者可能更简洁且不会显著影响性能。

• 一致性：

  • 在一个程序中，对于同一个类型的方法，最好保持一致，要么全部使用指针接收者，要么全部使用值接收者，以避免混淆。特别是当某些方法使用指针接收者而其他方法使用值接收者时，可能会导致意外的行为或增加理解难度。

• 接口实现：

  • 如果一个类型实现了某个接口，那么无论是使用值接收者还是指针接收者的具体方法都会被认作实现了该接口，只要调用时的接收者类型匹配即可。但是，为了保持清晰和一致性，通常建议所有方法都使用同一种接收者类型（值或指针）。

我们上面的代码中也能看出，printInfo中并没有修改结构体字段，因此用的是值类型接收者，而setInfo方法中更改了结构体字段，用的就是指针类型接收者。

比如我们把上面setInfo方法传入了值类型接收者：

package mainimport ("fmt"
)type Person struct {name stringage  int
}// 值类型接收者
func (p Person) printInfo() {fmt.Printf("姓名:%v 年龄:%v\n", p.name, p.age)
}// 指针类型接收者
func (p Person) setInfo(name string, age int) {p.name = namep.age = age
}
func main() {p1 := Person{name: "小王子", age: 25}p1.printInfo()p1.setInfo("张三", 20)p1.printInfo()p1.setInfo("李四", 24)p1.printInfo()
}

运行结果：

姓名:小王子 年龄:25
姓名:小王子 年龄:25
姓名:小王子 年龄:25

综上所述，选择值接收者还是指针接收者，主要基于你是否需要在方法内修改结构体的字段、性能考虑以及代码的一致性和可读性。根据具体情况做出合适的选择是很重要的。

给任意类型添加方法

在 Go 语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。举个例子，我们基于内置的 int 类型使用 type 关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。

package mainimport ("fmt"
)type myInt intfunc (m myInt) SayHello() {fmt.Println("Hello, 我是一个 int。")
}
func main() {var m1 myIntm1.SayHello() //Hello, 我是一个 int。m1 = 100fmt.Printf("%#v %T\n", m1, m1) //100 main.
}

结构体的匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

代码示例：

package mainimport ("fmt"
)// Person 结构体 Person 类型
type Person struct {stringint
}func main() {p1 := Person{"小王子", 18}fmt.Printf("%#v\n", p1)        //main.Person{string:"北京", int:18}fmt.Println(p1.string, p1.int) //北京 18
}

运行结果：

main.Person{string:"小王子", int:18}
小王子 18

匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

嵌套结构体

一个结构体中可以嵌套包含另一个结构体或结构体指针。

package mainimport ("fmt"
)// Address 地址结构体
type Address struct {Province stringCity     string
}// User 用户结构体
type User struct {Name    stringGender  stringAddress Address
}func main() {user1 := User{Name: "张三", Gender: "男", Address: Address{Province: "广东", City: "深圳"}}fmt.Printf("user1=%#v\n", user1) //user1=main.User{Name:" 张 三 ", Gender:" 男 ", Address:main.Address{Province:"广东", City:"深圳"}}
}

嵌套匿名结构体

package mainimport "fmt"// Address 地址结构体
type Address struct {Province stringCity     string
}// User 用户结构体
type User struct {Name    stringGender  stringAddress // 匿名结构体
}func main() {var user2 Useruser2.Name = "张三"user2.Gender = "男"user2.Address.Province = "广东"    //通过匿名结构体.字段名访问user2.City = "深圳"                //直接访问匿名结构体的字段名fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:" 张 三 ", Gender:" 男 ", Address:main.Address{Province:"广东", City:"深圳"
}

注意：当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。

关于嵌套结构体的字段名冲突

嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体的字段。

package main// Address 地址结构体
type Address struct {Province   stringCity       stringCreateTime string
}// Email 邮箱结构体
type Email struct {Account    stringCreateTime string
}// User 用户结构体
type User struct {Name   stringGender stringAddressEmail
}func main() {var user3 Useruser3.Name = "张三"user3.Gender = "男"// user3.CreateTime = "2020" // ambiguous selector user3.CreateTimeuser3.Address.CreateTime = "2020" //指定 Address 结构体中的 CreateTimeuser3.Email.CreateTime = "2021"   //指定 Email 结构体中的 C
}

结构体的继承

Go 语言中使用结构体也可以实现其他编程语言中的继承。

package mainimport "fmt"// Animal 动物
type Animal struct {name string
}func (a *Animal) run() {fmt.Printf("%s 会运动！\n", a.name)
}// Dog 狗
type Dog struct {Age     int8*Animal //通过嵌套匿名结构体实现继承
}func (d *Dog) wang() {fmt.Printf("%s 会汪汪汪~\n", d.name)
}func main() {d1 := &Dog{Age: 4, Animal: &Animal{name: "乐乐"}} //注意嵌套的是结构体指针d1.wang()                                       //乐乐会汪汪汪~d1.run()                                        //乐乐会动！
}

在Go语言中，实际上并没有传统面向对象编程中的“继承”概念。Go采用了一种称为组合的方式，来实现类似的功能。通过将一个结构体嵌入到另一个结构体中，可以达到代码复用的目的，这种方式有时被称作“嵌入”或“委派”，它提供了一种灵活的方式来模拟继承的行为。

参考文献

https://gobyexample.com/

https://www.w3schools.com/go/

https://go.dev/doc/tutorial/

https://www.geeksforgeeks.org/golang-tutorial-learn-go-programming-language/