1. 结构体定义 基础数据类型可以表示事务的基本属性,通过定义结构体可以封装多个基本数据类型,可以表达该事物的部分或者全部属性了。
使用type
和struct
关键字来定义结构体,具体代码格式如下:
1 2 3 4 5 6 7 8 9 10 11 12 type 类型名 struct { 字段名 字段类型 字段名 字段类型 字段名,字段名2 字段类型 … }
2. 结构体实例化 只有当结构体实例化时,才会真正地分配内存。也就是必须实例化后才能使用结构体的字段,结构体本身也是一种类型,我们可以像声明内置类型一样使用var
关键字声明结构体类型。
2.1 基本实例化 1 2 3 4 5 6 7 8 9 10 11 12 13 14 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" , p1) fmt.Printf("p1=%#v" , p1) }
通过.
来访问结构体的字段(成员变量),例如p1.name
和p1.age
等
2.2 匿名结构体 在定义一些临时数据结构等场景下还可以使用匿名结构体。
1 2 3 4 5 6 7 8 9 10 11 12 package main import ( "fmt" ) func main () { var user struct {Name string ; Age int } user.Name = "小王子" user.Age = 18 fmt.Printf("%#v" , user) }
2.3 指针类型结构体 通过使用new
关键字对结构体进行实例化,得到的是结构体的地址。 格式如下:
1 2 3 4 5 6 7 type person struct { name string city string }var p2 = new (person) fmt.Printf("%T\n" , p2) fmt.Printf("p2=%#v\n" , p2)
2.4 取结构体地址实例化 使用&
对结构体进行取地址操作相当于对该结构体类型进行了一次new
实例化操作。
1 2 3 4 5 6 7 p3 := &person{} fmt.Printf("%T" , p3) fmt.Printf("p3=%#v" , p3) p3.name = "猪猪1号" p3.age = 30 p3.city = "成都" fmt.Printf("p3=%#v" , p3)
p3.name = "猪猪一号"
其实在底层是(*p3).name = "猪猪一号"
,这是Go语言帮我们实现的语法糖。
3. 结构体初始化 没有初始化的结构体,其成员变量都是对应其类型的零值。
1 2 3 4 5 6 7 8 9 type person struct { name string age int8 }func main () { var p person fmt.Printf("p=%#v" , p) }
3.1 键值初始化 使用键值对对结构体进行初始化时,键对应结构体的字段,值对应该字段的初始值。
1 2 3 4 5 6 p := person{ name: "小王子" , city: "北京" , age: 18 , } fmt.Printf("p=%#v" , p)
也可以对结构体指针进行键值对初始化,例如:
1 2 3 4 5 6 p := &person{ name: "小王子" , city: "北京" , age: 18 , } fmt.Printf("p=%#v" , p)
当某些字段没有初始值的时候,该字段可以不写。此时,没有指定初始值的字段的值就是该字段类型的零值。
1 2 3 4 p := &person{ city: "北京" , } fmt.Printf("p=%#v" , p)
3.2 使用值初始化 初始化结构体的时候可以简写,也就是初始化的时候不写键,直接写值:
1 2 3 4 5 6 p := &person{ "沙河娜扎" , "北京" , 28 , } fmt.Printf("p=%#v" , p)
使用这种格式初始化时,需要注意:
必须初始化结构体的所有字段。
初始值的填充顺序必须与字段在结构体中的声明顺序一致。
该方式不能和键值初始化方式混用
4. 结构体内存布局 结构体占用一块连续的内存。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 type test struct { a int8 b int8 c int8 d int8 } n := test{ 1 , 2 , 3 , 4 , } fmt.Printf("n.a %p" , &n.a) fmt.Printf("n.b %p" , &n.b) fmt.Printf("n.c %p" , &n.c) fmt.Printf("n.d %p" , &n.d)
空结构体是不占用空间的
1 2 var v struct {} fmt.Println(unsafe.Sizeof(v))
5. 构造函数 Go语言的结构体没有构造函数,我们可以自己实现。 例如,下方的代码就实现了一个person
的构造函数。 因为struct
是值类型,如果结构体比较复杂的话,值拷贝性能开销会比较大,所以该构造函数返回的是结构体指针类型。
1 2 3 4 5 6 7 func newPerson (name, city string , age int8 ) *person { return &person{ name: name, city: city, age: age, } }
调用构造函数
1 2 p9 := newPerson("张三" , "沙河" , 90 ) fmt.Printf("%#v" , p9)
6. 方法和接收者 Go语言中的方法(Method)
是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者(Receiver)
。接收者的概念就类似于其他语言中的this
或者 self。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 type Person struct { name string age int8 }func NewPerson (name string , age int8 ) *Person { return &Person{ name: name, age: age, } }func (p Person) Dream() { fmt.Printf("%s的梦想是学好Go语言!" , p.name) }func main () { p1 := NewPerson("小王子" , 25 ) p1.Dream() }
方法与函数的区别是,函数不属于任何类型,方法属于特定的类型。
6.1 指针类型的接收者 指针类型的接收者由一个结构体的指针组成,由于指针的特性,调用方法时修改接收者指针的任意成员变量,在方法结束后,修改都是有效的。例如我们为Person
添加一个SetAge
方法,来修改实例变量的年龄。
1 2 3 4 5 func (p *Person) SetAge(newAge int8 ) { p.age = newAge }
调用该方法:
1 2 3 4 5 6 func main () { p1 := NewPerson("小王子" , 25 ) fmt.Println(p1.age) p1.SetAge(30 ) fmt.Println(p1.age) }
6.2 值类型的接收者 当方法作用于值类型接收者时,Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值,但修改操作只是针对副本,无法修改接收者变量本身。
1 2 3 4 5 6 7 8 9 10 11 12 13 func (p Person) SetAge2(newAge int8 ) { p.age = newAge }func main () { p1 := NewPerson("小王子" , 25 ) p1.Dream() fmt.Println(p1.age) p1.SetAge2(30 ) fmt.Println(p1.age) }
什么时候应该使用指针类型接收者
需要修改接收者中的值
接收者是拷贝代价比较大的大对象
保证一致性,如果有某个方法使用了指针接收者,那么其他的方法也应该使用指针接收者。
7. 任意类型方法添加 在Go语言中,接收者的类型可以是任何类型,不仅仅是结构体,任何类型都可以拥有方法。 举个例子,我们基于内置的int
类型使用type关键字可以定义新的自定义类型,然后为我们的自定义类型添加方法。
1 2 3 4 5 6 7 8 9 10 11 12 13 type MyInt int func (m MyInt) SayHello() { fmt.Println("Hello, 我是一个int。" ) }func main () { var m1 MyInt m1.SayHello() m1 = 100 fmt.Printf("%#v %T" , m1, m1) }
注意事项: 非本地类型不能定义方法,也就是说我们不能给别的包的类型定义方法。
8. 结构体匿名字段 结构体允许其成员字段在声明时没有字段名而只有类型,这种没有名字的字段就称为匿名字段。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 type Person struct { string int }func main () { p1 := Person{ "小王子" , 18 , } fmt.Printf("%#v" , p1) fmt.Println(p1.string , p1.int ) }
注意:这里匿名字段的说法并不代表没有字段名,而是默认会采用类型名作为字段名,结构体要求字段名称必须唯一,因此一个结构体中同种类型的匿名字段只能有一个。
9. 嵌套结构体 一个结构体中可以嵌套包含另一个结构体或结构体指针,如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 type Address struct { Province string City string }type User struct { Name string Gender string Address Address }func main () { user1 := User{ Name: "小王子" , Gender: "男" , Address: Address{ Province: "山东" , City: "威海" , }, } fmt.Printf("user1=%#v" , user1) }
9.1 嵌套匿名字段 上面user结构体中嵌套的Address
结构体也可以采用匿名字段的方式,例如:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 type Address struct { Province string City string }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" , user2) }
当访问结构体成员时会先在结构体中查找该字段,找不到再去嵌套的匿名字段中查找。
9.2 嵌套结构体字段冲突 嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 type Address struct { Province string City string CreateTime string }type Email struct { Account string CreateTime string }type User struct { Name string Gender string Address Email }func main () { var user3 User user3.Name = "沙河娜扎" user3.Gender = "男" user3.Address.CreateTime = "2000" user3.Email.CreateTime = "2000" }
10. 结构体的继承 Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 type Animal struct { name string }func (a *Animal) move() { fmt.Printf("%s会动!" , a.name) }type Dog struct { Feet int8 *Animal }func (d *Dog) wang() { fmt.Printf("%s会汪汪汪~" , d.name) }func main () { d1 := &Dog{ Feet: 4 , Animal: &Animal{ name: "乐乐" , }, } d1.wang() d1.move() }
11. 结构体与json序列化 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式,键/值对组合中的键名写在前面并用双引号""
包裹,使用冒号:
分隔,然后紧接着值;多个键值之间使用英文,
分隔。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 type Student struct { ID int Gender string Name string }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) } data, err := json.Marshal(c) if err != nil { fmt.Println("json marshal failed" ) return } fmt.Printf("json:%s" , data) 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" , c1) }
11.1 结构体标签 Tag
是结构体的元信息,可以在运行的时候通过反射的机制读取出来。 Tag
在结构体字段的后方定义,由一对反引号 包裹起来,具体的格式如下:
1 `key1:"value1" key2:"value2"`
结构体tag由一个或多个键值对组成。键与值使用冒号分隔,值用双引号括起来。同一个结构体字段可以设置多个键值对tag,不同的键值对之间使用空格分隔。
注意事项: 为结构体编写Tag
时,必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差,一旦格式写错,编译和运行时都不会提示任何错误,通过反射也无法正确取值。例如不要在key和value之间添加空格。
例如我们为Student
结构体的每个字段定义json序列化时使用的Tag:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 type Student struct { ID int `json:"id"` Gender string name string }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 " , data) }
12. 结构体中的slice与map 因为slice和map这两种数据类型都包含了指向底层数据的指针,因此我们在需要复制它们时要特别注意。我们来看下面的例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 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) data[1 ] = "不睡觉" fmt.Println(p1.dreams) }
正确的做法是在方法中使用传入的slice的拷贝进行结构体赋值,这样在修改原有数据的时候,不影响结构里面的内容。
1 2 3 4 func (p *Person) SetDreams(dreams []string ) { p.dreams = make ([]string , len (dreams)) copy (p.dreams, dreams) }
深拷贝与浅拷贝的区别:
深拷贝,拷贝的是值
浅拷贝,拷贝的是指针
深拷贝开辟了新的内存空间,修改操作不影响原先的内存
浅拷贝指向的还是原来的内存空间,修改操作直接作用在原内存空间上