golang中结构体的使用

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

1.类型别名和自定义类型

1.1自定义类型

在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 = uint8
type rune = int32

1.3类型定义和类型别名的区别

类型别名与类型定义，表面上看只有一个等号的差异，我们可以通过下面的代码来查看他们的区别。

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类型。

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

2.2.2匿名结构体

在定义一些临时数据结构时，可以使用匿名结构体。

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

2.2.3创建指针类型结构体

我们还可以通过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语言中支持对结构体指针直接使用"."访问结构体成员。

2.2.4取结构体的地址实例化

使用&对结构体进行取地址操作相当于对该结构体进行了一次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语言帮我们实现的语法糖。

2.3结构体初始化

没有初始化的结构体，其成员变量都是对应类型的零值。
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

2.3.1使用键值对初始化

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

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

2.3.3使用值的列表初始化

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

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.该方式不能和键值初始化方式混用。

2.4结构体布局

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

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 0

2.5构造函数

Go语言的结构体没有构造函数，可以自己实现。
下面的代码就实现了一个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 0

2.6方法和接收者

2.6.1方法和接收者

Go语言中的方法(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

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

2.6.2指针类型的接收者

指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
这种方式接近于其他语言中的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

2.6.3值类型的接收者

当方法作用于值类型的接收者时，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 0

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

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

2.7任意类型添加方法

在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

注意：
非本地类型不能定义方法，即不能给别的包的类型定义方法。

2.8结构体的匿名字段

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

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

2.9嵌套结构体

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

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

2.10嵌套匿名结构体

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

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

2.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 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 0

2.15结构体标签(Tag)

Tag是结构体的元信息，可以在运行的时候通过反射的 机制读取出来。
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 0

3.书籍的增删改查

package 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中结构体的详细内容，具体使用情况还需要大家自己动手实验使用过才能领会。如果想了解更多相关内容，欢迎关注亿速云行业资讯频道！