溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
大家對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進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
