大家对golang中结构体的了解可能停留在概念的层面上，而对于golang中结构体的使用方法了解相对较少。今天就跟大家聊聊golang中结构体的使用。

在Go语言中有一些基本的数据类型，如string,整型，浮点型，布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型。自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。//将MyInt定义为int类型type MyInt int通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性。1.2类型别名

类型别名是Go1.9版本添加的新功能。类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像我们的英文名，乳名，但这些名字都指的是一个人。type TypeAlias = type我们之前见过的rune和byte都是类型别名，他们的定义如下：type byte = uint8type rune = int321.3类型定义和类型别名的区别

类型别名与类型定义，表面上看只有一个等号的差异，我们可以通过下面的代码来查看他们的区别。package mainimport "fmt"type NewInt inttype MyInt = intfunc main() { var a NewInt var b MyInt fmt.Printf("type of a:%T\n",a) fmt.Printf("type of b:%T\n",b)}结果：type of a:main.NewInttype of b:intProcess finished with exit code 0结果显示a的类型是main.NewInt,表示main包下定义的NewInt类型。b类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。2.结构体

Go语言中的基本数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候基本数据类型就无法满足需求了。Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体（struct）。我们可以通过struct来定义自己的类型了。Go语言中通过struct来实现面向对象。2.1结构体的定义

使用type和struct关键字来定义结构体，具体代码格式如下：type 类型名 struct { 字段名 字段类型 字段名 字段类型 …}其中：类型名：标识自定义结构体的名称，在同一个包内不能重复。字段名：表示结构体字段名。结构体中的字段名必须唯一。字段类型：表示结构体字段的具体类型。

举个例子，我们定义一个Person结构体，代码如下：type Person struct { name string city string age int8} 同样类型的字段可以卸载一行type Person struct { name,city string age int8}这样我们就拥有了一个Person的自定义类型，它有name,city,age三个字段，分别表示姓名，城市和年龄。这样我们就能使用Person结构体存储人的信息了。语言内置的数据类型是用来描述一个值得，结构体是用来描述一组值的。比如一个人有名字，年龄和居住城市等，本质上是一种聚合型的数据类型。2.2结构体实例化

只有当结构体实例化时，才会真正的分配内存。即必须实例化后才能使用结构体的字段。结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型。var 结构体实例 结构体类型2.2.1结构体基本实例化

通过"."来访问结构体的字段，例如person1.name和person1.agepackage mainimport "fmt"type Person struct { name,city string age int8}func main() { var person1 Person person1.name="vita" person1.city="ShangHai" person1.age=27 fmt.Printf("p1=%v\n",person1) fmt.Printf("p1=%#v\n",person1)}结果：p1={vita ShangHai 27}p1=main.Person{name:"vita", city:"ShangHai", age:27}Process finished with exit code 02.2.2匿名结构体

在定义一些临时数据结构时，可以使用匿名结构体。package mainimport "fmt"func main() { var person2 struct{name string;age int} person2.name="vita" person2.age=27 fmt.Printf("p1=%v\n",person2) fmt.Printf("p1=%#v\n",person2)}结果：p1={vita 27}p1=struct { name string; age int }{name:"vita", age:27}Process finished with exit code 02.2.3创建指针类型结构体

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

package mainimport "fmt"type Person struct { name string city string age int}func main() { var person3 = new(Person) fmt.Printf("%T\n",person3) fmt.Printf("p3=%#v\n",person3) person3.name="vita" person3.age=27 fmt.Printf("p3=%v\n",person3) fmt.Printf("p3=%#v\n",person3)}结果：*main.Personp3=&main.Person{name:"", city:"", age:0}p3=&{vita 27}p3=&main.Person{name:"vita", city:"", age:27}Process finished with exit code 0从打印结果可以看到，p3是一个结构体指针。Go语言中支持对结构体指针直接使用"."访问结构体成员。2.2.4取结构体的地址实例化

使用&对结构体进行取地址操作相当于对该结构体进行了一次new实例化操作。package mainimport "fmt"type Person struct { name string city string age int}func main() { var person4 = &Person{} fmt.Printf("%T\n",person4) fmt.Printf("p4=%#v\n",person4) person4.name="vita" person4.age=27 fmt.Printf("p4=%v\n",person4) fmt.Printf("p4=%#v\n",person4)}结果：*main.Personp4=&main.Person{name:"", city:"", age:0}p4=&{vita 27}p4=&main.Person{name:"vita", city:"", age:27}Process finished with exit code 0 person4.name="vita"其实在底层是(* person4).name="vita",这是Go语言帮我们实现的语法糖。2.3结构体初始化

没有初始化的结构体，其成员变量都是对应类型的零值。package mainimport "fmt"type Person struct { name string city string age int}func main() { var p1 Person fmt.Printf("%T\n",p1) fmt.Printf("p1=%v\n",p1) fmt.Printf("p1=%#v\n",p1)}结果：main.Personp1={ 0}p1=main.Person{name:"", city:"", age:0}Process finished with exit code 02.3.1使用键值对初始化

使用键值对对结构体初始化时，键对应结构体的字段，值对应该字段的初始值。package mainimport "fmt"type Person struct { name string city string age int}func main() { var p1 = Person{ name:"vita", city:"ShangHai", age:27, } fmt.Printf("%T\n",p1) fmt.Printf("p1=%v\n",p1) fmt.Printf("p1=%#v\n",p1)}结果：main.Personp1={vita ShangHai 27}p1=main.Person{name:"vita", city:"ShangHai", age:27}Process finished with exit code 0

也可以对结构体指针进行键值对初始化package mainimport "fmt"type Person struct { name string city string age int}func main() { var p1 = &Person{ name:"vita", city:"ShangHai", age:27, } fmt.Printf("%T\n",p1) fmt.Printf("p1=%v\n",p1) fmt.Printf("p1=%#v\n",p1)}结果：*main.Personp1=&{vita ShangHai 27}p1=&main.Person{name:"vita", city:"ShangHai", age:27}Process finished with exit code 0

某些字段没有初始值的时候，该字段可以不写。没有指定初始值的字段值就是该字段类型的零值。package mainimport "fmt"type Person struct { name string city string age int}func main() { var p1 = &Person{ name:"vita", } fmt.Printf("%T\n",p1) fmt.Printf("p1=%v\n",p1) fmt.Printf("p1=%#v\n",p1)}结果：*main.Personp1=&{vita 0}p1=&main.Person{name:"vita", city:"", age:0}Process finished with exit code 02.3.3使用值的列表初始化

初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值package mainimport "fmt"type Person struct { name string city string age int}func main() { var p1 = &Person{ "vita", "ShangHai", 27, } fmt.Printf("%T\n",p1) fmt.Printf("p1=%v\n",p1) fmt.Printf("p1=%#v\n",p1)}结果：*main.Personp1=&{vita ShangHai 27}p1=&main.Person{name:"vita", city:"ShangHai", age:27}Process finished with exit code 0使用这种格式初始化时，需要注意：1.必须初始化结构体的所有字段。2.初始值的填充顺序必须与字段在结构体中的声明顺序一致。3.该方式不能和键值初始化方式混用。2.4结构体布局

结构体占用一块连续的内存。package mainimport "fmt"type Person struct { name string city string age int}func main() { var p1 = &Person{ "vita", "ShangHai", 27, } fmt.Printf("p1.name %p\n",&p1.name) fmt.Printf("p1.city %p\n",&p1.city) fmt.Printf("p1.age %p\n",&p1.age)}结果：p1.name 0xc00005c360p1.city 0xc00005c370p1.age 0xc00005c380Process finished with exit code 0

// 内存是以字节为单位的十六进制数// 1字节 = 8位 = 8bitpackage mainimport "fmt"type test struct { a int8 b int8 c int8}func main() { var p1 = &test{ 1,2,3, } fmt.Printf("p1.a %p\n",&p1.a) fmt.Printf("p1.b %p\n",&p1.b) fmt.Printf("p1.c %p\n",&p1.c)}结果：p1.a 0xc000054080p1.b 0xc000054081p1.c 0xc000054082Process finished with exit code 02.5构造函数

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

package mainimport "fmt"type Person struct { name string city string age int}//构造函数func newPerson(name,city string,age int) *Person { return &Person{ name: name, city: city, age: age, }}func main() { //调用构造函数 p := newPerson("vita","ShangHai",27) fmt.Printf("%#v",p)}结果：&main.Person{name:"vita", city:"ShangHai", age:27}Process finished with exit code 02.6方法和接收者2.6.1方法和接收者

Go语言中的方法(method)是一种作用于特定类型变量的函数。这种特定类型变量叫做"接收者(Receiver)"。接收者的概念就类似于其他语言中的this或者self。方法的定义格式如下：func (接收者变量 接收者类型) 方法名(参数列表) (返回参数){ 函数体}其中，接收者变量：接收者中的参数变量名在命名的时候，官方建议使用接收者类型名的第一个小写字母，而不是self,this之类的命名。 例如：Person类型的接收者变量应该命名为p,Connector类型的接收者变量应该命名为c等。接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。方法名，参数列表，返回参数：具体格式与函数定义相同。

package mainimport "fmt"type Person struct { name string city string age int}func newPerson(name,city string,age int) *Person { return &Person{ name: name, city: city, age: age, }}func (p Person) Dream() { fmt.Printf("%s的梦想是实现自己的价值。",p.name)}func main() { p := newPerson("vita","ShangHai",27) p.Dream()}结果：vita的梦想是实现自己的价值。Process finished with exit code 0

方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。2.6.2指针类型的接收者

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

package mainimport "fmt"type Person struct { name string city string age int}func newPerson(name,city string,age int) *Person { return &Person{ name: name, city: city, age: age, }}func (p Person) Dream() { fmt.Printf("%s的梦想是实现自己的价值。",p.name)}//指针类型的接收者func (p *Person) SetAge(newAge int) { p.age=newAge}func main() { p := newPerson("vita","ShangHai",27) fmt.Println(p.age)//修改年龄 p.SetAge(29) fmt.Println(p.age)}结果：2729Process finished with exit code 02.6.3值类型的接收者

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

package mainimport "fmt"type Person struct { name string city string age int}func newPerson(name,city string,age int) *Person { return &Person{ name: name, city: city, age: age, }}func (p Person) Dream() { fmt.Printf("%s的梦想是实现自己的价值。",p.name)}//值类型的接收者func (p Person) SetAge(newAge int) { p.age=newAge}func main() { p := newPerson("vita","ShangHai",27) fmt.Println(p.age)//修改年龄 p.SetAge(29) fmt.Println(p.age)}结果：2727Process finished with exit code 02.6.4什么时候应该使用指针类型接收者

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

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

package mainimport "fmt"type MyInt intfunc (m MyInt) SayHello() { fmt.Println("hello,我是一个Int")}func main() { var m MyInt m.SayHello() m=100 fmt.Printf("%#v %T\n",m,m)}结果：hello,我是一个Int100 main.MyIntProcess finished with exit code 0

注意：非本地类型不能定义方法，即不能给别的包的类型定义方法。2.8结构体的匿名字段

结构体允许其成员字段在声明时没有字段名，只有字段类型，这种没有名字的字段称为匿名字段。匿名字段默认采用类型名作为字段名，结构体要求字段名必须唯一，因此结构体中同种类型的匿名字段只能有一个。

package mainimport "fmt"type Person struct { string int}func main() { p1:=Person{ "vita", 27, } fmt.Printf("%#v\n",p1) fmt.Println(p1.string,p1.int)}结果：main.Person{string:"vita", int:27}vita 27Process finished with exit code 02.9嵌套结构体

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

package mainimport "fmt"//地址结构体type Address struct { Province string City string}//User结构体type User struct { Name string Gender string Address Address}func main() { user1 := User{ Name:"vita", Gender:"女", Address:Address{ Province:"ShangHai", City:"ShangHai", }, } fmt.Printf("user1=%#v\n",user1)}结果：user1=main.User{Name:"vita", Gender:"女", Address:main.Address{Province:"ShangHai", City:"ShangHai"}}Process finished with exit code 02.10嵌套匿名结构体

当访问结构体成员时，会现在结构体中查找该字段，找不到就去匿名结构体中查找。package mainimport "fmt"//地址结构体type Address struct { Province string City string}//User结构体type User struct { Name string Gender string Address}func main() { var user2 User user2.Name = "vita" user2.Gender = "女" user2.Address.Province = "江苏" //通过匿名结构体.字段名访问 user2.City = "南京" //直接访问匿名结构体的字段名 fmt.Printf("user1=%#v\n",user2)}结果：user1=main.User{Name:"vita", Gender:"女", Address:main.Address{Province:"江苏", City:"南京"}}Process finished with exit code 02.11嵌套结构体的字段名冲突

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

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

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.13结构体字段的可见性

结构体中字段大写开头表示可公开访问，小写表示私有(仅在定义当前结构体的包中可访问)。1.14结构体与JSON序列化

JSON数据是一些键值对数据，便于阅读和编写。

package mainimport ( "encoding/json" "fmt")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{ ID: i, Gender: "男", Name: "张三", } 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:{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"张三"},{"ID":1,"Gender":"男","Name":"张三"},{"ID":2,"Gender":"男","Name":"张三"},{"ID":3,"Gender":"男","Name":"张三"},{"ID":4,"Gender":"男","Name":"张三"},{"ID":5,"Gender":"男","Name":"张三"},{"ID":6,"Gender":"男","Name":"张三"},{"ID":7,"Gender":"男","Name":"张三"},{"ID":8,"Gender":"男","Name":"张三"},{"ID":9,"Gender":"男","Name":"张三"}]}&main.Class{Title:"101", Students:[]*main.Student{(*main.Student)(0xc0000526f0), (*main.Student)(0xc000052720), (*main.Student)(0xc000052750), (*main.Student)(0xc000052780), (*main.Student)(0xc0000527e0), (*main.Student)(0xc000052810), (*main.Student)(0xc000052840), (*main.Student)(0xc000052870), (*main.Student)(0xc0000528a0), (*main.Student)(0xc0000528d0)}}Process finished with exit code 02.15结构体标签(Tag)

Tag是结构体的元信息，可以在运行的时候通过反射的 机制读取出来。Tag在结构体字段的后方定义，由一对反引号包裹起来，具体格式如下：`key1:"value1" key2:"value2"`结构体标签由一个或多个键值对组成。键和值使用冒号分隔，值用引号括起来。键值对质检使用一个空格分隔，注意事项：1.为结构体编写Tag时，必须严格遵守键值对的规则。2.结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。3.key和value之间是不可以有空格的。

package mainimport ( "encoding/json" "fmt")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: "沙河娜扎", } 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":"男"}Process finished with exit code 03.书籍的增删改查

package mainimport ( "fmt" "os")// 1. 打印菜单// 2. 等待用户输入菜单选项// 3. 添加书籍的函数// 4. 修改书籍的函数// 5. 展示书籍的函数// 6. 退出 os.Exit(0)type Book struct { title string author string price float32 publish bool}var( AllBooks []*Book)func showMenu() { fmt.Println("1.展示所有书籍") fmt.Println("2.添加书籍") fmt.Println("3.修改书籍") fmt.Println("4.删除书籍") fmt.Println("5.退出") fmt.Println()}func showAllBook() { fmt.Println("书籍信息如下：") for _,value := range AllBooks{ fmt.Printf("title:%s author:%s price:%.2f publish:%v",value.title,value.author,value.price,value.publish) } fmt.Println()}func newBook(title,author string,price float32,publish bool) *Book { return &Book{ title:title, author:author, price:price, publish:publish, }}func addBook() { var ( title string author string price float32 publish bool ) fmt.Println("输入书籍的title(string),author(string),price(float32),publish(bool)信息") fmt.Scanln(&title,&author,&price,&publish) for _,value := range AllBooks{ if value.title == title{ fmt.Println("该书已经存在了！") return } } book := newBook(title,author,price,publish) AllBooks = append(AllBooks,book)}func modifyBook() { fmt.Println("输入要修改的书籍信息") var ( title string author string price float32 publish bool ) fmt.Println("输入书籍的title(string),author(string),price(float32),publish(bool)信息") fmt.Scanln(&title,&author,&price,&publish) for index,value := range AllBooks{ if value.title == title{ modifyBook := newBook(title,author,price,publish) AllBooks[index] = modifyBook fmt.Println("书籍信息修改成功！") return } } fmt.Println("该书不存在，就不进行修改了！")}func delBook() { var ( title string ) fmt.Println("输入要删除的书籍名称") fmt.Scanln(&title) for index,value := range AllBooks{ if value.title == title{ // 要删除索引为2的元素 AllBooks = append(AllBooks[:index], AllBooks[index+1:]...) fmt.Println("书籍删除成功！") return } } fmt.Println("该书不存在！")}func main() { for{ showMenu() var input int fmt.Scanln(&input) switch input { case 1: showAllBook() case 2: addBook() case 3: modifyBook() case 4: delBook() case 5: os.Exit(0) } }}结果：1.展示所有书籍2.添加书籍3.修改书籍4.删除书籍5.退出1书籍信息如下：1.展示所有书籍2.添加书籍3.修改书籍4.删除书籍5.退出2输入书籍的title(string),author(string),price(float32),publish(bool)信息zhangsan zhangsan 12.23 true1.展示所有书籍2.添加书籍3.修改书籍4.删除书籍5.退出3输入要修改的书籍信息输入书籍的title(string),author(string),price(float32),publish(bool)信息zhangsan Zhansan 231.1 false书籍信息修改成功！1.展示所有书籍2.添加书籍3.修改书籍4.删除书籍5.退出1书籍信息如下：title:zhangsan author:Zhansan price:231.10 publish:false1.展示所有书籍2.添加书籍3.修改书籍4.删除书籍5.退出4输入要删除的书籍名称zhangsan书籍删除成功！1.展示所有书籍2.添加书籍3.修改书籍4.删除书籍5.退出1书籍信息如下：1.展示所有书籍2.添加书籍3.修改书籍4.删除书籍5.退出5Process finished with exit code 0

上文描述的就是golang中结构体的详细内容，具体使用情况还需要大家自己动手实验使用过才能领会。如果想了解更多相关内容，欢迎关注亿速云行业资讯频道！