Go语言基础（七）：结构体

文章目录

一、类型别名和自定义类型1、自定义类型2、类型别名3、类型定义和类型别名的区别 二、结构体1、结构体定义2、结构体实例化（1）基本实例化（2）匿名结构体（3）创建指针类型结构体（4）取结构体的地址实例化 3、结构体初始化（1）使用键值对初始化（2）使用值的列表初始化 4、结构体内存布局（1）空结构体 5、面试题6、构造函数7、方法和接收者（1）指针类型的接收者（2）值类型的接收者（3）什么时候应该使用指针类型接收者 8、任意类型添加方法9、结构体的匿名字段10、嵌套结构体（1）嵌套匿名字段（2）嵌套结构体的字段名冲突 11、结构体的组合12、结构体字段的可见性13、结构体与JSON序列化14、结构体标签15、结构体和方法补充知识点 Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过 结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

一、类型别名和自定义类型

1、自定义类型

自定义类型是定义了一个全新的类型。

//将MyInt定义为int类型 type MyInt int

通过type关键字的定义，MyInt就是一种新的类型，它具有int的特性。

2、类型别名

下面的TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。

type TypeAlias = Type

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

type byte = uint8 type rune = int32

3、类型定义和类型别名的区别

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

//类型定义 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。类型的别名只会在代码中存在，编译完成时并不会有此别名。

二、结构体

相信大家应该对java、python等支持面向对象编程的语言有过了解吧，一个类中有数据属性与方法属性，虽然Go语言不支持面向对象，但是个人认为有面向对象的影子在里面，比如结构体主要就是数据属性的集合，接口就是实现方法属性的！

Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。 也就是我们可以通过struct来定义自己的类型了。

1、结构体定义

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

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

其中：

类型名：标识自定义结构体的名称，在同一个包内不能重复。字段名：表示结构体字段名。结构体中的字段名必须唯一。字段类型：表示结构体字段的具体类型。 type person1 struct { name, city string // 同样类型的字段也可以写在一行 age int8 }

看到这里是不是有我说的面向对象的感觉了，哈哈哈，别急，骚操作下面还有很多！

2、结构体实例化

只有当结构体实例化时，才会真正地分配内存。也就是必须实例化后才能使用结构体的字段。

结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型并实例化。

var 结构体实例名称 结构体类型

（1）基本实例化

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} }

（2）匿名结构体

在定义一些临时数据结构等场景下还可以使用匿名结构体。

package main import ( "fmt" ) func main() { var user struct{Name string; Age int} user.Name = "小王子" user.Age = 18 fmt.Printf("%#v\n", user) }

（3）创建指针类型结构体

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

var p2 = new(person) fmt.Printf("%T\n", p2) //*main.person fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

从打印的结果中我们可以看出p2是一个结构体指针。 注意：Go语言中支持对结构体指针直接使用.来访问结构体的成员,如下面注释部分。

var p2 = new(person) (*p2).name="吴晋丞" // 可以简写为p2.name="吴晋丞",Go语言遇到指针会自动解引用! (*p2).city="成都" (*p2).age=18 fmt.Printf("%T\n",p2) fmt.Printf("%#v\n",p2) 运行结果： *main.person &main.person{name:"吴晋丞", city:"成都", age:18}

（4）取结构体的地址实例化

使用&对结构体进行取地址操作相当于对该结构体类型进行了一次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}

p3.name = "七米"其实在底层是(*p3).name = "七米"，这是Go语言帮我们实现的语法糖。和上面（3）一样的语法糖

3、结构体初始化

没有初始化的结构体，其成员变量都是对应其类型的零值。

type person struct { name string city string age int8 } func main() { var p4 person fmt.Printf("p4=%#v\n", p4) // p4=main.person{name:"", city:"", age:0} }

（1）使用键值对初始化

p5 := person{ name: "小王子", city: "北京", age: 18, } fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"小王子", city:"北京", age:18}

也可以对结构体指针进行键值对初始化，例如：

p6 := &person{ name: "小王子", city: "北京", age: 18, } fmt.Printf("p6=%#v\n", p6) //p6=&main.person{name:"小王子", city:"北京", age:18}

（2）使用值的列表初始化

初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：

p8 := &person{ "沙河娜扎", "北京", 28, } fmt.Printf("p8=%#v\n", p8) //p8=&main.person{name:"沙河娜扎", city:"北京", age:28}

使用这个格式初始化时，需要注意以下几点：

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

4、结构体内存布局

结构体占用一块连续的内存。

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) 运行结果： n.a 0xc0000a0060 n.b 0xc0000a0061 n.c 0xc0000a0062 n.d 0xc0000a0063

（1）空结构体

空结构体是不占用空间的。

var v struct{} fmt.Println(unsafe.Sizeof(v)) // 0

5、面试题

请问下面代码的执行结果是什么？

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) } }

6、构造函数

Go语言的结构体没有构造函数，我们可以自己实现。 例如，下方的代码就实现了一个person的构造函数。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

func newPerson(name, city string, age int8) *person { return &person{ name: name, city: city, age: age, } }

调用构造函数

p9 := newPerson("张三", "沙河", 90) fmt.Printf("%#v\n", p9) //&main.person{name:"张三", city:"沙河", age:90}

7、方法和接收者

Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。

方法的定义格式如下：

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) { 函数体 } 接收者变量：接收者中的参数变量名在命名时，官方建议直接使用接收者类型名称首字母的小写接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。方法名、参数列表、返回参数：具体格式与函数定义相同。 //Person 结构体 type Person struct { name string age int8 } //NewPerson 构造函数 func NewPerson(name string, age int8) *Person { return &Person{ name: name, age: age, } } //Dream Person做梦的方法 func (p Person) Dream() { fmt.Printf("%s的梦想是学好Go语言！\n", p.name) } func main() { p1 := NewPerson("小王子", 25) p1.Dream() }

方法与函数的区别是，函数不属于任何类型，方法是属于特定的类型。 如果你把struct看作是一个对象的话，那么你可以把方法理解为属于特定对象的函数！

（1）指针类型的接收者

指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。例如我们为Person添加一个SetAge方法，来修改实例变量的年龄。

// SetAge 设置p的年龄 // 使用指针接收者 func (p *Person) SetAge(newAge int8) { p.age = newAge }

（2）值类型的接收者

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

// SetAge2 设置p的年龄 // 使用值接收者 func (p Person) SetAge2(newAge int8) { p.age = newAge } func main() { p1 := NewPerson("小王子", 25) p1.Dream() fmt.Println(p1.age) // 25 p1.SetAge2(30) // (*p1).SetAge2(30) 自动解引用 fmt.Println(p1.age) // 25 }

（3）什么时候应该使用指针类型接收者

需要修改接收者中的值接收者是拷贝代价比较大的大对象保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。

8、任意类型添加方法

在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 }

注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。

9、结构体的匿名字段

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

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

注意： 这里匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

10、嵌套结构体

//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:"威海"}} }

（1）嵌套匿名字段

上面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:"威海"}} }

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

（2）嵌套结构体的字段名冲突

嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。

//Address 地址结构体 type Address struct { Province string City string CreateTime string // 和Email冲突 } //Email 邮箱结构体 type Email struct { Account string CreateTime string // 和Address冲突 } //User 用户结构体 type User struct { Name string Gender string Address Email } func main() { var user3 User user3.Name = "沙河娜扎" user3.Gender = "男" // user3.CreateTime = "2019" //ambiguous selector user3.CreateTime user3.Address.CreateTime = "2000" //指定Address结构体中的CreateTime user3.Email.CreateTime = "2000" //指定Email结构体中的CreateTime }

11、结构体的组合

我们可以通过下面这种方法实现，面向对象中的组合！

//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() //乐乐会动！ }

什么是组合？我们看看python中的组合： https://blog.csdn.net/weixin_44571270/article/details/106318934

注意： 很多人都说上面相当于是面向对象中的继承，这句话是错的，实际上是组合！

12、结构体字段的可见性

结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。 我们的函数名、变量名也是这样的哦！

13、结构体与JSON序列化

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。

json.Marshal(c) // 序列化 json.Unmarshal() // 反序列化 //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) }

14、结构体标签

15、结构体和方法补充知识点

因为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) }

正确的做法是在方法中使用传入的slice的拷贝进行结构体赋值。

func (p *Person) SetDreams(dreams []string) { p.dreams = make([]string, len(dreams)) copy(p.dreams, dreams) }

同样的问题也存在于返回值slice和map的情况，在实际编码过程中一定要注意这个问题。