【Golang】结构体详解
文章目录
- 1、类型别名 && 自定义类型
-
- 1.1、自定义类型
- 1.2、 类型别名
- 1.3、二者的区别
- 2、结构体
-
- 2.1、结构体定义
- 2.2、结构体实例化
- 2.3、结构体初始化
- 2.4、结构体内存布局
- 2.5、方法和接收者
- 2.6、任意类型添加方法
- 2.7、结构体匿名字段
- 2.8、嵌套结构体
- 2.9、结构体的“继承”
- 2.10、结构体与JSON序列化
- 2.11、结构体标签（Tag）
- 2.12、补充说明
1、类型别名 && 自定义类型
Go语言中没有 “类” 的概念，也不支持 “类” 的继承等面向对象的概念
Go语言中通过结构体的内嵌 再配合 接口，达到比面向对象更高的扩展性和灵活性
1.1、自定义类型
在Go语言中有一些基本的数据类型，可以使用type关键字来定义自定义类型
自定义类型是定义了一个全新的类型，我们可以基于内置的基本类型定义，也可以通过struct定义
type MyInt int
type MyStruct struct {
Name string
Age int
}
通过type关键字的定义，MyInt && MyStruct 就是一种新的类型
1.2、 类型别名
类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型
type TypeAlias = Type
//e.g
type byte = uint8
type rune = int32
1.3、二者的区别
类型别名与类型定义表面上看只有一个等号的差异，我们通过下面的这段代码来理解它们之间的区别
//类型定义
type NewInt int
//类型别名
type MyInt = int
func main() {
var a NewInt
var b MyInt
fmt.Printf("type of a:%T\n", a)
fmt.Printf("type of b:%T\n", b)
}
结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型
b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型
总结：类型定义有新类型产生，类型别名没有新类型产生，并且在编译阶段被替换为原始类型
2、结构体
Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了
Go语言提供了一种自定义数据类型，可以封装多个基本数据类型 or 自定义类型，这种数据类型叫结构体，英文名称struct
2.1、结构体定义
使用type和struct关键字来定义结构体，具体代码格式如下：
type 类型名 struct {
字段名 字段类型
字段名 字段类型
…
}
注意：
- 类型名：表示自定义结构体的名称，同一个包内不允许重复
- 字段名：表示结构体字段的名称，在整个结构体内这个名称是唯一的
- 字段类型：表示结构体字段的具体类型，可以是基本数据类型，也可以是自定义类型
e.g:
type Person struct {
Name string
City string
Age int
}
上面代码表示：定义了一个自定义类型Person,由Name, City，Age三个字段组成
语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的，本质上是一种聚合型的数据类型
2.2、结构体实例化
只有当结构体实例化的时候，才会真正的分配内存，也就是 必须实例化后才能使用结构体中的字段
结构体本身也是一种类型，我们可以像申明内置类型那样申明一个结构体
var 结构体实例 结构体类型
下面介绍结构体实例化的几种方式：
- 基本实例化
type Person struct {
Name string
City string
Age int
}
func main() {
var person Person
person.Name = "GGBond"
person.Age = 18
person.City = "深圳"
fmt.Println(person)
fmt.Printf("%+v\n", person)
fmt.Printf("%#v\n", person)
}
- 匿名结构体
在定义一些临时数据结构等场景下还可以使用匿名结构体
func main() {
var person struct {
Name string
Age int
City string
}
person.Name = "GGBond"
person.Age = 18
person.City = "深圳"
fmt.Printf("%+v\n", person)
}
- 创建指针类型结构体
我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址。 格式如下：
type Person struct {
Name string
Age int
City string
}
func main() {
var p2 = new(Person)
fmt.Printf("%T\n", p2)
fmt.Printf("p2=%+v\n", p2)
}
可以看到：结构体成员变量没有显示赋值的，均是对应类型的0值
同时这里的p2是一个结构体指针
我们可以使用指针的基本操作来对这个new出来的结构体变量的成员进行赋值操作：
func main() {
var p2 = new(Person)
fmt.Printf("%T\n", p2)
fmt.Printf("p2=%+v\n", p2)
//使用指针的操作方式对Person成员进行赋值
(*p2).Name = "GGBond"
p2.Age = 18
p2.City = "深圳"
fmt.Printf("p2=%+v\n", p2)
}
注意：
在Go语言中支持对结构体指针直接使用 .来访问结构体的成员
不支持像C/C++ 使用 ->的方式访问
- 取结构体的地址实例化
使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作
type Person struct {
Name string
Age int
City string
}
func main() {
var p2 = &Person{}
fmt.Printf("%T\n", p2)
fmt.Printf("p2=%+v\n", p2)
//使用指针的操作方式对Person成员进行赋值
(*p2).Name = "GGBond"
p2.Age = 18
p2.City = "深圳"
fmt.Printf("p2=%+v\n", p2)
}
2.3、结构体初始化
没有初始化的结构体，其成员变量都是对应其类型的零值
常见的结构体初始化方式有以下几种：
- 使用键值对初始化
使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值
type Person struct {
Name string
Age int
City string
}
func main() {
person := Person{
Name: "GGBond",
Age: 18,
City: "深圳",
}
fmt.Printf("person = %+v\n", person)
}
当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值
- 使用值得列表初始化
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
type Person struct {
Name string
Age int
City string
}
func main() {
person := &Person{
"GGBond",
18,
"深圳",
}
fmt.Printf("person = %#v\n", person)
}
使用这种格式初始化时，需要注意：
必须初始化结构体的所有字段
初始值的填充顺序必须与字段在结构体中的声明顺序一致
该方式不能和键值初始化方式混用
2.4、结构体内存布局
结构体占用一块连续的内存空间
type test struct {
a int8
b int8
c int8
d int8
}
func main() {
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 Bar struct {
x int32 // 4
y *int // 8
z bool // 1
}
func main() {
var b1 Bar
fmt.Println(unsafe.Sizeof(b1)) // 24
}
疑问1：既然结构体的内存是“连续”的，为什么结构体大小不是13（4 + 8 + 1）而是24呢？
接着再来看另一个场景：
type Bar struct {
y *int // 8
x int32 // 4
z bool // 1
}
func main() {
var b1 Bar
fmt.Println(unsafe.Sizeof(b1)) // 24
}
疑问2：为什么看似“一样”的代码，就是结构体成员变量的定义顺序不一样，得到的结构体大小却不一样了？
好，想要解决这两个问题，那就得说说结构体中最常见的知识：结构体内存对齐
Go 在编译的时候会按照一定的规则自动进行内存对齐。之所以这么设计是为了减少 CPU 访问内存的次数，加大 CPU 访问内存的吞吐量。如果不进行内存对齐的话，很可能就会增加CPU访问内存的次数
针对上面提到的两个问题，我们可以通过内存对齐的角度来分析
type Bar struct {
x int32 // 4
y *int // 8
z bool // 1
}
这个结构体对应的内存示意图如下所示：
对于另一个结构体，他的内存示意图又是另一种情况
type Bar struct {
y *int // 8
x int32 // 4
z bool // 1
}
我们可以看到，结构体成员变量的定义位置不一样，同一对其规则下就会产生不同大小的结构体。具体的对齐规则参考：
结构体详解
内存对齐-李文周
空结构体是不占用内存空间的
var v struct{}
fmt.Println(unsafe.Sizeof(v)) // 0
由于空结构体struct{}的大小为 0，所以当一个结构体中包含空结构体类型的字段时，通常不需要进行内存对齐。例如：
type Demo1 struct {
m struct{} // 0
n int8 // 1
}
var d1 Demo1
fmt.Println(unsafe.Sizeof(d1)) // 1
但是当空结构体类型作为结构体的最后一个字段时，如果有指向该字段的指针，那么就会返回该结构体之外的地址。为了避免内存泄露会额外进行一次内存对齐
type Demo2 struct {
n int8 // 1
m struct{} // 0
}
var d2 Demo2
fmt.Println(unsafe.Sizeof(d2)) // 2
2.5、方法和接收者
Go语言中的方法是一种作用于特定类型变量的函数，这种特定类型变量叫做 接收者。接收者的概念就类似于其他语言中的this/self
方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}
详细解释：
- 接收者变量：接收者中的参数变量在命名的时候，官方建议使用接收者类型名称首字母的小写，而不是使用self、this这类的命名。例如，Person类型的接收者变量应该命名为p
- 接收者类型：接收者类型和参数相似，可以是指针类型和非指针类型
- 方法名、参数列表、返回参数：具体格式与
函数定义相同
e.g
type Person struct {
Name string
Age int8
}
func newPerson(name string, age int8) *Person {
return &Person{
Name: name,
Age: age,
}
}
func (p Person) Freedom() {
fmt.Printf("%v 向往自由\n", p.Name)
}
func main() {
ggbond := newPerson("GGBond", 18)
ggbond.Freedom()
}
方法与函数的区别是，函数不属于任何类型，方法属于特定的类型
问：指针类型的 接收者和值类型的接收者有什么区别？应该如何选择？
- 值类型接收者
当方法作用于值类型的接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获得接收者的成员值，但修改的内容只是针对复制的副本，无法修改接收者变量本身。 - 指针类型接收者
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。这种方式就十分接近于其他语言中面向对象中的this或者self
什么时候该用指针接收者类型呢？
- 1.需要修改接收者中的值
- 2.接收者时拷贝代价比较大的对象
- 3.保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者
2.6、任意类型添加方法
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。
举个例子，我们基于内置的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
}
注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法
2.7、结构体匿名字段
结构体允许其成员字段在申明的时候没有字段名只有字段类型，这种没有名字的字段就称为匿名字段
type Person struct {
string
int
}
func main() {
person := Person{
"GGBond",
18,
}
fmt.Printf("%#v\n", person)
fmt.Printf("person.string is : %v, person.int is : %v\n", person.string, person.int)
}
注意：
- 这里的匿名字段说法并不是说没有字段名，而是默认会采用类型名作为字段名
- 结构体要求字段名唯一，因此一个结构体中同种类型的匿名字段只能有一个
2.8、嵌套结构体
一个结构体中可以嵌套包含另一个结构体或结构体指针。示例如下：
type Address struct {
Province string
City string
}
type Person struct {
Name string
Age int8
Address Address
}
func main() {
person := Person{
Name: "GGBond",
Age: 18,
Address: Address{
Province: "广东",
City: "深圳",
},
}
fmt.Printf("%#v\n", person)
}
当然，也支持 嵌套匿名字段，将上述的Person结构体中的Address字段设置为匿名字段
type Address struct {
Province string
City string
}
type Person struct {
Name string
Age int8
Address //匿名字段
}
func main() {
person := Person{
Name: "GGBond",
Age: 18,
Address: Address{
Province: "广东",
City: "深圳",
},
}
fmt.Printf("%#v\n", person)
person.Address.Province = "陕西" //匿名字段默认使用类型名作为字段名
person.City = "西安" //匿名字段可以直接省略
fmt.Printf("%#v\n", person)
}
当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找
- 嵌套结构体的字段名冲突
嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。
type Address struct {
Province string
City string
CreateTime string
}
type Email struct {
Account string
CreateTime string
}
type Person struct {
Name string
Age int8
Address //匿名字段
Email
}
func main() {
person := Person{
Name: "GGBond",
Age: 18,
Address: Address{
Province: "广东",
City: "深圳",
},
}
fmt.Printf("%#v\n", person)
person.Address.Province = "陕西" //匿名字段默认使用类型名作为字段名
person.City = "西安" //匿名字段可以直接省略
//person.CreateTime = "xxxx" //错误写法，会产生歧义
person.Address.CreateTime = "xxx"
person.Email.CreateTime = "111"
fmt.Printf("%#v\n", person)
}
2.9、结构体的“继承”
Go语言中使用结构体也可以实现其他编程语言中面向对象的继承
//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() //乐乐会动！
}
2.10、结构体与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 < 5; 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"
}
]
}`
c1 := &Class{}
err = json.Unmarshal([]byte(str), c1)
if err != nil {
fmt.Println("json unmarshal failed!")
return
}
fmt.Printf("%#v\n", c1)
}
2.11、结构体标签（Tag）
Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。
Tag在结构体字段的后方定义，由一对反引号包裹起来，具体的格式如下：
key1:"value1" key2:"value2"
结构体tag由一个或多个键值对组成。
键与值使用冒号分隔，值用双引号括起来。
同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。
注意事项：
为结构体编写Tag时，必须严格遵守键值对的规则。
结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。
例如我们为Student结构体的每个字段定义json序列化时使用的Tag：
//Student 学生
type Student struct {
ID int `json:"id"` //通过指定tag实现json序列化该字段时的key
Gender string //json序列化是默认使用字段名作为key
name string //私有不能被json包访问
}
func main() {
s1 := Student{
ID: 1,
Gender: "男",
name: "GGBond",
}
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":"男"}
}
2.12、补充说明
因为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: "GGbond", age: 18}
data := []string{"吃饭", "睡觉", "打豆豆"}
p1.SetDreams(data)
// 你真的想要修改 p1.dreams 吗？
data[1] = "不睡觉"
fmt.Println(p1.dreams) // ?
}
针对这种情况，我们需要避免结构体字段与切片共用底层数组
所以，SetDreams的实现方式需要加以修改：
func (p *Person) SetDreams(dreams []string) {
p.dreams = make([]string, len(dreams))
copy(p.dreams, dreams)
}
这样修改之后就不会存在上面的情况了