首页分享 Go语言全栈开发：结构体

Go语言全栈开发：结构体

来源：花匠小妙招时间：2024-12-01 08:50

Go语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。Go语言中通过结构体的内嵌再配合接口比面向对象具有更高的扩展性和灵活性。

类型别名和自定义类型

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

自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。例如：

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

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

类型别名是Go1.9版本添加的新功能。

类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像一个孩子小时候有小名、乳名，上学后用学名，英语老师又会给他起英文名，但这些名字都指的是他本人。

type TypeAlias = Type 1

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

type byte = uint8 type rune = int32 12

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

//类型定义 type NewInt int //类型别名 type MyInt = int func main() {var a NewIntvar b MyIntfmt.Printf("type of a:%Tn", a) //type of a:main.NewIntfmt.Printf("type of b:%Tn", b) //type of b:int } 12345678910111213

结果显示a的类型是main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。

结构体

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

Go语言中通过struct来实现面向对象。

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

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

其中：

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

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

type person struct {name stringcity stringage int8 } 12345

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

type person1 struct {name, city stringage int8 } 1234

这样我们就拥有了一个person的自定义类型，它有name、city、age三个字段，分别表示姓名、城市和年龄。这样我们使用这个person结构体就能够很方便的在程序中表示和存储人信息了。

语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的。比如一个人有名字、年龄和居住城市等，本质上是一种聚合型的数据类型

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

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

var 结构体实例结构体类型 1

| 基本实例化

举个例子：

type person struct {name stringcity stringage int8 } func main() {var p1 personp1.name = "一枝花"p1.city = "武汉"p1.age = 18fmt.Printf("p1=%vn", p1) //p1={一枝花武汉 18}fmt.Printf("p1=%#vn", p1) //p1=main.person{name:"一枝花", city:"武汉", age:18} } 1234567891011121314

我们通过.来访问结构体的字段（成员变量）,例如p1.name和p1.age等。

| 匿名结构体

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

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

| 创建指针类型结构体

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

var p2 = new(person) fmt.Printf("%Tn", p2) //*main.person fmt.Printf("p2=%#vn", p2) //p2=&main.person{name:"", city:"", age:0} 123

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

需要注意的是在Go语言中支持对结构体指针直接使用.来访问结构体的成员。

var p2 = new(person) p2.name = "一枝花" p2.age = 28 p2.city = "武汉" fmt.Printf("p2=%#vn", p2) //p2=&main.person{name:"一枝花", city:"武汉", age:28} 12345

| 取结构体的地址实例化

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

p3 := &person{} fmt.Printf("%Tn", p3) //*main.person fmt.Printf("p3=%#vn", p3) //p3=&main.person{name:"", city:"", age:0} p3.name = "winstonfy" p3.age = 22 p3.city = "武汉" fmt.Printf("p3=%#vn", p3) //p3=&main.person{name:"winstonfy", city:"武汉", age:22} 1234567

p3.name = "winstonfy"其实在底层是(*p3).name = “winstonfy”，这是Go语言帮我们实现的语法糖。

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

type person struct {name stringcity stringage int8 } func main() {var p4 personfmt.Printf("p4=%#vn", p4) //p4=main.person{name:"", city:"", age:0} } 12345678910

| 使用键值对初始化

使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值。

p5 := person{name: "一枝花",city: "武汉",age: 18, } fmt.Printf("p5=%#vn", p5) //p5=main.person{name:"一枝花", city:"武汉", age:18} 123456

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

p6 := &person{name: "一枝花",city: "武汉",age: 18, } fmt.Printf("p6=%#vn", p6) //p6=&main.person{name:"一枝花", city:"武汉", age:18} 123456

当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值。

p7 := &person{city: "武汉", } fmt.Printf("p7=%#vn", p7) //p7=&main.person{name:"", city:"武汉", age:0} 1234

| 使用值的列表初始化

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

p8 := &person{"武汉一枝花","湖北",22, } fmt.Printf("p8=%#vn", p8) //p8=&main.person{name:"武汉一枝花", city:"湖北", age:22} 123456

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

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

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

type test struct {a int8b int8c int8d int8 } n := test{1, 2, 3, 4, } fmt.Printf("n.a %pn", &n.a) fmt.Printf("n.b %pn", &n.b) fmt.Printf("n.c %pn", &n.c) fmt.Printf("n.d %pn", &n.d) 12345678910111213

输出：

n.a 0xc0000a0060 n.b 0xc0000a0061 n.c 0xc0000a0062 n.d 0xc0000a0063 1234

【进阶知识点】关于Go语言中的内存对齐推荐阅读:在 Go 中恰到好处的内存对齐

| 空结构体

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

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

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

type student struct {name stringage 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)} }

1234567891011121314151617181920

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

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

调用构造函数

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

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

方法的定义格式如下：

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

其中，

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

举个例子：

//Person 结构体 type Person struct {name stringage 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("winstonfy", 18)p1.Dream() }

1234567891011121314151617181920212223

方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。

| 指针类型的接收者

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

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

调用该方法：

func main() {p1 := NewPerson("小王子", 25)fmt.Println(p1.age) // 25p1.SetAge(30)fmt.Println(p1.age) // 30 } 123456

| 值类型的接收者

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

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

| 什么时候应该使用指针类型接收者

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

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

//MyInt 将int定义为自定义MyInt类型 type MyInt int //SayHello 为MyInt添加一个SayHello的方法 func (m MyInt) SayHello() {fmt.Println("Hello, 我是一个int。") } func main() {var m1 MyIntm1.SayHello() //Hello, 我是一个int。m1 = 100fmt.Printf("%#v %Tn", m1, m1) //100 main.MyInt } 12345678910111213

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

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

//Person 结构体Person类型 type Person struct {stringint } func main() {p1 := Person{"winstonfy",18,}fmt.Printf("%#vn", p1) //main.Person{string:"winstonfy", int:18}fmt.Println(p1.string, p1.int) //winstonfy 18 } 1234567891011121314

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

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

//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=%#vn", user1)//user1=main.User{Name:"一枝花", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}} }

123456789101112131415161718192021222324

| 嵌套匿名结构体

//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=%#vn", user2) //user2=main.User{Name:"一枝花", Gender:"男", Address:main.Address{Province:"山东", City:"威海"}} }

123456789101112131415161718192021

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

| 嵌套结构体的字段名冲突

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

//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 = "2019" //ambiguous selector user3.CreateTimeuser3.Address.CreateTime = "2000" //指定Address结构体中的CreateTimeuser3.Email.CreateTime = "2000" //指定Email结构体中的CreateTime }

1234567891011121314151617181920212223242526272829

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

1234567891011121314151617181920212223242526272829

结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。

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

//Student 学生 type Student struct {ID intGender stringName string } //Class 班级 type Class struct {Title stringStudents []*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:%sn", 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("%#vn", c1)

123456789101112131415161718192021222324252627282930313233343536373839404142

Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。 Tag在结构体字段的后方定义，由一对 反引号 包裹起来，具体的格式如下：

`key1:"value1" key2:"value2"` 1

结构体tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。

注意事项： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。

例如我们为<code>Student</code>结构体的每个字段定义json序列化时使用的Tag： //Student 学生 type Student struct {ID int `json:"id"` //通过指定tag实现json序列化该字段时的keyGender string //json序列化是默认使用字段名作为keyname 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:%sn", data) //json str:{"id":1,"Gender":"男"} }

12345678910111213141516171819202122

因为slice和map这两种数据类型都包含了指向底层数据的指针，因此我们在需要复制它们时要特别注意。我们来看下面的例子：

type Person struct {name stringage int8dreams []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) // ? }

12345678910111213141516171819

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

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

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