9.Go語言基礎之結構體

Go語言中沒有類的概念，也不支持“類”的繼承等面向對象的概念。
Go語言中通過結構體的內嵌再配合接口，比面向對象具有更高的擴展性和靈活性。

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