GoLong的学习之路（九）语法之结构体(非常重要，不看就等于不会Go语言)
书接上回，上回书说到，map等数据结构，接下来说结构体
文章目录
- 类型别名和自定义类型
-
- 自定义
- 类型别名
- 类型定义和类型别名的区别
- 结构体
-
- 结构体的定义
- 结构体实例化
-
- 基本实例化
- 匿名结构体
- 创建指针类型结构体并取用
-
- 获取结构体指针
- 取用结构体
- 结构体初始化
-
- 使用键值对初始化
- 使用值的列表初始化
- 结构体内存布局
-
- 空结构体
- 构造函数
- 方法和接收者
-
- 指针类型的接收者
- 值类型的接收者
- 任意类型添加方法
- 结构体的匿名字段
- 嵌套结构体
-
- 嵌套匿名字段
- 嵌套结构体的字段名冲突
- 结构体与JSON序列化（`重要`）
-
- 结构体标签
- `注意`
类型别名和自定义类型
自定义
在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型， Go语言中可以使用type关键字来定义自定义类型。
自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。
将MyInt定义为int类型: type MyInt int
通过type关键字的定义，MyInt就是一种新的类型，它具有int的特性。
类型别名
TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。
type TypeAlias = Type
我们之前见过的rune和byte就是类型别名:
type byte = uint8
type rune = int32
类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别。
类型定义和类型别名的区别
//类型定义
type NewInt int
//类型别名
type MyInt = int
func main() {
var a NewInt
var b MyInt
fmt.Printf("type of a:%T\n", a) //type of a:main.NewInt
fmt.Printf("type of b:%T\n", b) //type of b:int
}
- a的类型是main.NewInt，表示main包下定义的NewInt类型。
- b的类型是int
结构体
Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。
注意：
结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。
结构体的定义
Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了。
此时就需要一个类似于class类的数据类型，可以封装多个数据类型。Go就提供了一个自定义数据类型，可以封装多个数据基本类型。也就是所说的结构体（struct）。
Go语言中通过struct来实现面向对象。
使用type和struct关键字来定义结构体，具体代码格式如下：
type 类型名 struct {
字段名 字段类型
字段名 字段类型
…
}
注意：
- 类型名：标识自定义结构体的名称，在
同一个包内不能重复。 - 字段名：表示结构体字段名。结构体中的
字段名必须唯一。 - 字段类型：表示结构体字段的
具体类型。
定义一个结构体：
type person struct {
name string
city string
age int8
}
type person1 struct {
name, city string
age int8
}
这样我们就拥有了一个person的自定义类型，它有name、city、age三个字段，分别表示姓名、城市和年龄。这样我们使用这个person结构体就能够很方便的在程序中表示和存储人信息了。
结构体实例化
只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。
如何实例化？
结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型：
var 结构体实例 结构体类型
基本实例化
type person struct {
name string
city string
age int8
}
func main() {
var p1 person
p1.name = "李四"
p1.city = "北京"
p1.age = 18
fmt.Printf("p1=%v\n", p1) //p1={李四 北京 18}
fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"李四", city:"北京", age:18}
}
我们通过.来访问结构体的字段（成员变量）,例如p1.name和p1.age等
其实这里与Java差不多
匿名结构体
在定义一些临时数据结构等场景下还可以使用匿名结构体。
func main() {
var user struct{Name string; Age int}
user.Name = "小王子"
user.Age = 18
fmt.Printf("%#v\n", user)
}
创建指针类型结构体并取用
获取结构体指针
我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。
var p = new(person)
fmt.Printf("%T\n", p) //*main.person
fmt.Printf("p2=%#v\n", p) //p2=&main.person{name:"", city:"", age:0}
可以看出，p本身就是一个指针，而这个指针指向结构体person这个结构体
取用结构体
使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。
p3 := &person{}
fmt.Printf("%T\n", p3) //*main.person
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"", city:"", age:0}
p3.name = "七米"
p3.age = 30
p3.city = "成都"
fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"七米", city:"成都", age:30}
所以啊，咱们用new就好了。第二种看起来就不舒服。
结构体初始化
没有初始化的结构体，其成员变量都是对应其类型的零值。
使用键值对初始化
使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值。
p := person{
name: "王",
city: "北京",
age: 18,
}
fmt.Printf("p5=%#v\n", p) //p=main.person{name:"王", city:"北京", age:18}
对结构体指针进行键值对初始化
p := &person{
name: "王",
city: "北京",
age: 18,
}
fmt.Printf("p6=%#v\n", p) //p=&main.person{name:"王", city:"北京", age:18}
使用值的列表初始化
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
p := &person{
"王",
"北京",
18,
}
fmt.Printf("p=%#v\n", p) //p=&main.person{name:"王", city:"北京", age:18}
注意:
- 必须初始化结构体的所有字段。
- 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
- 该方式不能和键值初始化方式混用。
结构体内存布局
结构体占用一块连续的内存
type test struct {
a int8
b int8
c int8
d int8
}
n := test{
1, 2, 3, 4,
}
fmt.Printf("n.a %p\n", &n.a)
fmt.Printf("n.b %p\n", &n.b)
fmt.Printf("n.c %p\n", &n.c)
fmt.Printf("n.d %p\n", &n.d)
例子：
type student struct {
name string
age int
}
func main() {
m := make(map[string]*student)
stus := []student{
{name: "小王子", age: 18},
{name: "娜扎", age: 23},
{name: "大王八", age: 9000},
}
for _, stu := range stus {
m[stu.name] = &stu
}
for k, v := range m {
fmt.Println(k, "=>", v.name)
}
}
空结构体
空结构体是不占用空间的。
var v struct{}
fmt.Println(unsafe.Sizeof(v)) // 0
这个比较难，需要更加深入才可以Go结构体的内存对齐
构造函数
Go语言的结构体没有构造函数，我们可以自己实现。
因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。
func newPerson(name, city string, age int8) *person {
return &person{
name: name,
city: city,
age: age,
}
}
p := newPerson("张三", "李四", 90)
fmt.Printf("%#v\n", p) //&main.person{name:"张三", city:"李四", age:90}
方法和接收者
Go语言中的方法（Method）是一种作用于特定类型变量的函数。
这种特定类型变量叫做接收者（Receiver），接收者的概念就类似于Java语言中的this。
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}
-
接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是self、this之类的命名。
-
接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
-
方法名、参数列表、返回参数：具体格式与函数定义相同。
import "fmt"
// 一个学生的结构体
type student struct {
name string
age int
}
// newStudent的构造函数
func newStudent(name string, age int) *student {
return &student{
name: name,
age: age,
}
}
// 一个学生打招呼的方式
func (s student) helle() {
fmt.Printf("%s给新同学一个拥抱", s.name)
}
func main() {
p := newStudent("李四", 25)
p.helle()
}
方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。
指针类型的接收者
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
这种方式就十分接近于java语言中面向对象中的this。
比如我们修改一个学生的年龄
import "fmt"
// 一个学生的结构体
type student struct {
name string
age int
}
// newStudent的构造函数
func newStudent(name string, age int) *student {
return &student{
name: name,
age: age,
}
}
// 一个学生打招呼的方式
func (s student) helle() {
fmt.Printf("%s给新同学一个拥抱", s.name)
}
/*
func main1() {
p := newStudent("李四", 25)
p.helle()
}
*/
func (s *student) SetAge(newAge int) {
s.age = newAge
}
func main() {
p := newStudent("李四", 25)
fmt.Println(p.age)
p.SetAge(18)
fmt.Println(p.age)
}
可以看见，值进行了修改。我试过，不加 * 号会并不会彻底修改
值类型的接收者
当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。
在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。
// 一个学生的结构体
type student struct {
name string
age int
}
// newStudent的构造函数
func newStudent(name string, age int) *student {
return &student{
name: name,
age: age,
}
}
// 一个学生打招呼的方式
func (s student) helle() {
fmt.Printf("%s给新同学一个拥抱", s.name)
}
/*
func main1() {
p := newStudent("李四", 25)
p.helle()
}
*/
func (s student) SetAge(newAge int) {
s.age = newAge
}
func main() {
p := newStudent("李四", 25)
fmt.Println(p.age) //25
p.SetAge(18)
fmt.Println(p.age) //25
}
使用时机
什么时候使用指针类型接收者
- 需要修改接收者中的值
- 接收者是拷贝代价比较大的大对象
- 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。
任意类型添加方法
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 （这个确实比java方便，java的接口只能定义抽象类方法）
我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。
//MyInt 将int定义为自定义MyInt类型
type MyInt int
//SayHello 为MyInt添加一个SayHello的方法
func (m MyInt) SayHello() {
fmt.Println("Hello, 我是一个int。")
}
func main() {
var m1 MyInt
m1.SayHello() //Hello, 我是一个int。
m1 = 100
fmt.Printf("%#v %T\n", m1, m1) //100 main.MyInt
}
非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。更进一步的说法就是，一个包的类型定义方法可以，超出这个包，去定义这个包下的类型定义方法，语法规定不行。
结构体的匿名字段
结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。
这里匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。
type student2 struct {
string
int
}
func main() {
p := student2{"李四", 18}
fmt.Printf("%#v\n", p) //main.student2{string:"李四", int:18}
fmt.Println(p.string, p.int) //李四 18
}
嵌套结构体
一个结构体中可以嵌套包含另一个结构体或结构体指针
//Address 地址结构体
type Address struct {
Province string
City string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address 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:"威海"}}
}
嵌套匿名字段
上面user结构体中嵌套的Address结构体也可以采用匿名字段的方式。
//Address 地址结构体
type Address struct {
Province string
City string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address //匿名字段
}
func main() {
var user2 User
user2.Name = "小王子"
user2.Gender = "男"
user2.Address.Province = "山东" // 匿名字段默认使用类型名作为字段名
user2.City = "威海" // 匿名字段可以省略
fmt.Printf("user2=%#v\n", user2) //user2=main.User{Name:"小王子", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}}
}
当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找。
嵌套结构体的字段名冲突
嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。
//Address 地址结构体
type Address struct {
Province string
City string
CreateTime string
}
//Email 邮箱结构体
type Email struct {
Account string
CreateTime string
}
//User 用户结构体
type User struct {
Name string
Gender string
Address
Email
}
func main() {
var user3 User
user3.Name = "娜扎"
user3.Gender = "男"
// user3.CreateTime = "2023" //ambiguous selector user3.CreateTime
user3.Address.CreateTime = "2023" //指定Address结构体中的CreateTime
user3.Email.CreateTime = "2023" //指定Email结构体中的CreateTime
}
像这种情况，就需要具体指向那个结构体属性
发现没有，像这种嵌套的结构体，有点类似java编程中的继承。以下例子就是在证明继承的例子
//Animal 动物
type Animal struct {
name string
}
func (a *Animal) move() {
fmt.Printf("%s会动！\n", a.name)
}
//Dog 狗
type Dog struct {
Feet int8
*Animal //通过嵌套匿名结构体实现继承
}
func (d *Dog) wang() {
fmt.Printf("%s会汪汪汪~\n", d.name)
}
func main() {
d1 := &Dog{
Feet: 4,
Animal: &Animal{ //注意嵌套的是结构体指针
name: "乐乐",
},
}
d1.wang() //乐乐会汪汪汪~
d1.move() //乐乐会动！
}
结构体与JSON序列化（重要）
我在学习java中最常用一种前后端交互的数据格式。作为编程语言或多，或少都要前后端交互。而如何实现这种数据格式就显得尤为重要。
而go如何实现Json序列化，且看下面
JSON(JavaScript Object Notation) 是一种
轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。
//Student 学生
type Student struct {
ID int
Gender string
Name string
}
//Class 班级
type Class struct {
Title string
Students []*Student
}
func main() {
c := &Class{
Title: "101",
Students: make([]*Student, 0, 200),
}
for i := 0; i < 10; i++ {
stu := &Student{
Name: fmt.Sprintf("stu%02d", i),
Gender: "男",
ID: i,
}
c.Students = append(c.Students, stu)
}
//JSON序列化：结构体-->JSON格式的字符串
data, err := json.Marshal(c)
if err != nil {
fmt.Println("json marshal failed")
return
}
fmt.Printf("json:%s\n", data)
//JSON反序列化：JSON格式的字符串-->结构体
str := `{"Title":"101","Students":[
{"ID":0,"Gender":"男","Name":"stu00"},
{"ID":1,"Gender":"男","Name":"stu01"},
{"ID":2,"Gender":"男","Name":"stu02"},
{"ID":3,"Gender":"男","Name":"stu03"},
{"ID":4,"Gender":"男","Name":"stu04"},
{"ID":5,"Gender":"男","Name":"stu05"},
{"ID":6,"Gender":"男","Name":"stu06"},
{"ID":7,"Gender":"男","Name":"stu07"},
{"ID":8,"Gender":"男","Name":"stu08"},
{"ID":9,"Gender":"男","Name":"stu09"}
]}`
c1 := &Class{}
err = json.Unmarshal([]byte(str), c1)
if err != nil {
fmt.Println("json unmarshal failed!")
return
}
fmt.Printf("%#v\n", c1)
}
可以看见，为了突出如何进行json转换的情况。我边用一个json格式的字符串进行转换。
结构体标签
Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。Tag在结构体字段的后方定义，由一对反引号包裹起来。
`key1:"value1" key2:"value2"`
结构体tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。
注意事项：
为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。
import (
"encoding/json"
"fmt"
)
// Student 学生
type Student struct {
ID int `json:"ll"` //通过指定tag实现json序列化该字段时的key
Gender string //json序列化是默认使用字段名作为key
name string //私有不能被json包访问
}
func main() {
s1 := Student{
ID: 1,
Gender: "男",
name: "沙河娜扎",
}
data, err := json.Marshal(s1)
if err != nil {
fmt.Println("json marshal failed!")
return
}
fmt.Printf("json str:%s\n", data) //json str:{"id":1,"Gender":"男"}
}
注意
- 通过指定tag实现json序列化该字段时的key
- json序列化是默认使用字段名作为key
- 私有不能被json包访问
这个标签的方式在我看来就有些像重命名。通过标签，配合json函数实现对字段的重命名。（本质应该不变）,这种方式似乎对链接数据库有好处
注意
因为slice和map这两种数据类型都包含了指向底层数据的指针，因此我们在需要复制它们时要特别注意。
type Person struct {
name string
age int8
dreams []string
}
func (p *Person) SetDreams(dreams []string) {
p.dreams = dreams
}
func main() {
p1 := Person{name: "小王子", age: 18}
data := []string{"吃饭", "睡觉", "打豆豆"}
p1.SetDreams(data)
// 你真的想要修改 p1.dreams 吗？
data[1] = "不睡觉"
fmt.Println(p1.dreams) // ?
}
发现问题没有？我刚开始的时候也挺懵逼，这不是成功修改了吗？为什么要注意呢？仔细看每个功能的点，很明显之前我们将一个结构体进行了初始化，但是，下面修改就成了永久修改。这明显不符合我们预期。所以要利用copy的性质。
正确的做法是在方法中使用传入的slice的拷贝进行结构体赋值。
type Person struct {
name string
age int8
dreams []string
}
func (p *Person) SetDreams(dreams []string) {
p.dreams = make([]string, len(dreams))
copy(p.dreams, dreams)
}
func main() {
p1 := Person{name: "小王子", age: 18}
data := []string{"吃饭", "睡觉", "打豆豆"}
p1.SetDreams(data)
// 你真的想要修改 p1.dreams 吗？
data[1] = "不睡觉"
fmt.Println(p1.dreams) // ?
}
同样的问题也存在于返回值slice和map的情况，在实际编码过程中一定要注意这个问题。