大家对golang中结构体的了解可能停留在概念的层面上，而对于golang中结构体的使用方法了解相对较少。今天就跟大家聊聊golang中结构体的使用。
在Go语言中有一些基本的数据类型，如string,整型，浮点型，布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型。
自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。
//将MyInt定义为int类型
type MyInt int
通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性。类型别名是Go1.9版本添加的新功能。
类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像我们的英文名，乳名，但这些名字都指的是一个人。
type TypeAlias = type
我们之前见过的rune和byte都是类型别名，他们的定义如下：
type byte = uint8
type rune = int32类型别名与类型定义，表面上看只有一个等号的差异，我们可以通过下面的代码来查看他们的区别。
package main
import "fmt"
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)
}
结果：
type of a:main.NewInt
type of b:int
Process finished with exit code 0
结果显示a的类型是main.NewInt,表示main包下定义的NewInt类型。
b类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。Go语言中的基本数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候基本数据类型就无法满足需求了。
Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体（struct）。
我们可以通过struct来定义自己的类型了。
Go语言中通过struct来实现面向对象。使用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结构体存储人的信息了。
语言内置的数据类型是用来描述一个值得，结构体是用来描述一组值的。
比如一个人有名字，年龄和居住城市等，本质上是一种聚合型的数据类型。只有当结构体实例化时，才会真正的分配内存。即必须实例化后才能使用结构体的字段。
结构体本身也是一种类型，我们可以像声明内置类型一样使用var关键字声明结构体类型。
var 结构体实例 结构体类型通过"."来访问结构体的字段，例如person1.name和person1.age
package main
import "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 0在定义一些临时数据结构时，可以使用匿名结构体。
package main
import "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 0我们还可以通过new关键字对结构体进行实例化，得到的是结构体的地址。package main
import "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.Person
p3=&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语言中支持对结构体指针直接使用"."访问结构体成员。使用&对结构体进行取地址操作相当于对该结构体进行了一次new实例化操作。
package main
import "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.Person
p4=&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语言帮我们实现的语法糖。没有初始化的结构体，其成员变量都是对应类型的零值。
package main
import "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.Person
p1={ 0}
p1=main.Person{name:"", city:"", age:0}
Process finished with exit code 0使用键值对对结构体初始化时，键对应结构体的字段，值对应该字段的初始值。
package main
import "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.Person
p1={vita ShangHai 27}
p1=main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0也可以对结构体指针进行键值对初始化
package main
import "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.Person
p1=&{vita ShangHai 27}
p1=&main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0某些字段没有初始值的时候，该字段可以不写。没有指定初始值的字段值就是该字段类型的零值。
package main
import "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.Person
p1=&{vita 0}
p1=&main.Person{name:"vita", city:"", age:0}
Process finished with exit code 0初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值
package main
import "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.Person
p1=&{vita ShangHai 27}
p1=&main.Person{name:"vita", city:"ShangHai", age:27}
Process finished with exit code 0
使用这种格式初始化时，需要注意：
1.必须初始化结构体的所有字段。
2.初始值的填充顺序必须与字段在结构体中的声明顺序一致。
3.该方式不能和键值初始化方式混用。结构体占用一块连续的内存。
package main
import "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 0xc00005c360
p1.city 0xc00005c370
p1.age 0xc00005c380
Process finished with exit code 0// 内存是以字节为单位的十六进制数
// 1字节 = 8位 = 8bit
package main
import "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 0xc000054080
p1.b 0xc000054081
p1.c 0xc000054082
Process finished with exit code 0Go语言的结构体没有构造函数，可以自己实现。
下面的代码就实现了一个Person的构造函数。因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。package main
import "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 0Go语言中的方法(method)是一种作用于特定类型变量的函数。这种特定类型变量叫做"接收者(Receiver)"。
接收者的概念就类似于其他语言中的this或者self。
方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数){
函数体
}
其中，
接收者变量：接收者中的参数变量名在命名的时候，官方建议使用接收者类型名的第一个小写字母，而不是self,this之类的命名。
例如：Person类型的接收者变量应该命名为p,Connector类型的接收者变量应该命名为c等。
接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
方法名，参数列表，返回参数：具体格式与函数定义相同。package main
import "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方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
这种方式接近于其他语言中的this或者self。下面我们为Person添加一个SetAge方法，修改实例变量的年龄。package main
import "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)
}
结果：
27
29
Process finished with exit code 0当方法作用于值类型的接收者时，GO语言会在代码运行时将接收者的值复制一份。
在值类型接收者的方法中，可以获取接收者的成员值，但是修改只是针对副本，无法修改接收者变量本身。package main
import "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)
}
结果：
27
27
Process finished with exit code 01.需要修改接收者中的值。
2.接收者是拷贝代价比较大的大对象。
3.保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。在GO语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。
举个例子，我们基于内置的int类型，使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。package main
import "fmt"
type MyInt int
func (m MyInt) SayHello() {
fmt.Println("hello,我是一个Int")
}
func main() {
var m MyInt
m.SayHello()
m=100
fmt.Printf("%#v %T\n",m,m)
}
结果：
hello,我是一个Int
100 main.MyInt
Process finished with exit code 0注意：
非本地类型不能定义方法，即不能给别的包的类型定义方法。结构体允许其成员字段在声明时没有字段名，只有字段类型，这种没有名字的字段称为匿名字段。
匿名字段默认采用类型名作为字段名，结构体要求字段名必须唯一，因此结构体中同种类型的匿名字段只能有一个。package main
import "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 27
Process finished with exit code 0一个结构体中可以嵌套另一个结构体或结构体指针。package main
import "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 0当访问结构体成员时，会现在结构体中查找该字段，找不到就去匿名结构体中查找。
package main
import "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 0嵌套结构体内部可能存在相同的字段名。这时候为了避免歧义，需要指定具体的内嵌结构体的字段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
}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() //乐乐会动！
}结构体中字段大写开头表示可公开访问，小写表示私有(仅在定义当前结构体的包中可访问)。JSON数据是一些键值对数据，便于阅读和编写。package main
import (
"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 0Tag是结构体的元信息，可以在运行的时候通过反射的 机制读取出来。
Tag在结构体字段的后方定义，由一对反引号包裹起来，具体格式如下：
`key1:"value1" key2:"value2"`
结构体标签由一个或多个键值对组成。键和值使用冒号分隔，值用引号括起来。
键值对质检使用一个空格分隔，
注意事项：
1.为结构体编写Tag时，必须严格遵守键值对的规则。
2.结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。
3.key和value之间是不可以有空格的。package main
import (
"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 0package main
import (
"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 true
1.展示所有书籍
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:false
1.展示所有书籍
2.添加书籍
3.修改书籍
4.删除书籍
5.退出
4
输入要删除的书籍名称
zhangsan
书籍删除成功！
1.展示所有书籍
2.添加书籍
3.修改书籍
4.删除书籍
5.退出
1
书籍信息如下：
1.展示所有书籍
2.添加书籍
3.修改书籍
4.删除书籍
5.退出
5
Process finished with exit code 0
上文描述的就是golang中结构体的详细内容，具体使用情况还需要大家自己动手实验使用过才能领会。如果想了解更多相关内容，欢迎关注亿速云行业资讯频道！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
