一文教你如何快速學會Go的struct數(shù)據(jù)類型
什么是結構體
結構是表示字段集合的用戶定義類型。它可以用于將數(shù)據(jù)分組為單個單元而不是將每個數(shù)據(jù)作為單獨的值的地方。
例如，員工有firstName、lastName和age。將這三個屬性分組到一個名為Employee。
type Employee struct {
firstName string
lastName string
age int
}上面的代碼段聲明了一個結構類型Employee，其中包含字段firstName、lastName和age。上面的Employee結構稱為命名結構，因為它創(chuàng)建了一個名為Employme的新數(shù)據(jù)類型，可以使用該數(shù)據(jù)類型創(chuàng)建Employ結構。
通過在一行中聲明屬于同一類型的字段，然后在類型名稱后面加上該字段，也可以使該結構更加緊湊。在上面的struct中，firstName和lastName屬于同一類型字符串，因此該struct可以重寫為:
type Employee struct {
firstName, lastName string
age int
}盡管上面的語法節(jié)省了幾行代碼，但它并沒有使字段聲明顯式。請避免使用上述語法。
創(chuàng)建結構體
讓我們使用以下簡單程序聲明一個命名的structEmployee。
package main
import (
"fmt"
)
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() {
//creating struct specifying field names
emp1 := Employee{
firstName: "Sam",
age: 25,
salary: 500,
lastName: "Anderson",
}
//creating struct without specifying field names
emp2 := Employee{"Thomas", "Paul", 29, 800}
fmt.Println("Employee 1", emp1)
fmt.Println("Employee 2", emp2)
}在上述程序的第7行中，我們創(chuàng)建了一個命名的結構類型Employee。在上述程序的第17行中，emp1結構是通過為每個字段名指定值來定義的。聲明結構類型時，字段的順序不必與字段名的順序相同。在這種情況下。我們已更改lastName的位置并將其移到末尾。這將不會有任何問題。
在上述程序的第25行中，通過省略字段名來定義emp2。在這種情況下，必須保持字段的順序與結構聲明中指定的順序相同。請避免使用此語法，因為它會使您難以確定哪個字段的值。我們在此處指定此格式只是為了理解這也是一個有效語法：）
以上程序打印為：
Employee 1 {Sam Anderson 25 500}
Employee 2 {Thomas Paul 29 800}
創(chuàng)建匿名結構體
可以在不創(chuàng)建新數(shù)據(jù)類型的情況下聲明結構。這些類型的結構稱為匿名結構。
package main
import (
"fmt"
)
func main() {
emp3 := struct {
firstName string
lastName string
age int
salary int
}{
firstName: "Andreah",
lastName: "Nikola",
age: 31,
salary: 5000,
}
fmt.Println("Employee 3", emp3)
}在上述程序的第8行中，定義了一個匿名結構變量emp3。正如我們已經(jīng)提到的，這個結構稱為anonymous，因為它只創(chuàng)建一個新的結構變量emp3，而沒有定義任何新的結構類型，如命名結構。
上述代碼打印的結果為：
Employee 3 {Andreah Nikola 31 5000}
訪問結構體字段
運算符.用于訪問結構的各個字段。
package main
import (
"fmt"
)
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() {
emp6 := Employee{
firstName: "Sam",
lastName: "Anderson",
age: 55,
salary: 6000,
}
fmt.Println("First Name:", emp6.firstName)
fmt.Println("Last Name:", emp6.lastName)
fmt.Println("Age:", emp6.age)
fmt.Printf("Salary: $%d\n", emp6.salary)
emp6.salary = 6500
fmt.Printf("New Salary: $%d", emp6.salary)
}上面程序中的emp6.firstName訪問emp6結構的firstName字段。在第25行中，我們修改了員工的工資。此程序打印。
First Name: Sam
Last Name: Anderson
Age: 55
Salary: $6000
New Salary: $6500
結構體零值
當定義了一個結構并且沒有用任何值顯式初始化它時，默認情況下會為該結構的字段分配零值。
package main
import (
"fmt"
)
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() {
var emp4 Employee //zero valued struct
fmt.Println("First Name:", emp4.firstName)
fmt.Println("Last Name:", emp4.lastName)
fmt.Println("Age:", emp4.age)
fmt.Println("Salary:", emp4.salary)
}上面的程序定義了emp4，但沒有用任何值初始化。因此，firstName和lastName被指定為字符串的零值，字符串為空字符串“”，age和salary被指定為零值int，即0。此程序打印
First Name:
Last Name:
Age: 0
Salary: 0
也可以為某些字段指定值，而忽略其余字段。在這種情況下，被忽略的字段被賦值為零。
package main
import (
"fmt"
)
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() {
emp5 := Employee{
firstName: "John",
lastName: "Paul",
}
fmt.Println("First Name:", emp5.firstName)
fmt.Println("Last Name:", emp5.lastName)
fmt.Println("Age:", emp5.age)
fmt.Println("Salary:", emp5.salary)
}在上面的程序中。第16號和第17號，firstName和lastName被初始化，而年齡和薪水沒有初始化。因此，年齡和工資被指定為零值。此程序輸出:
First Name: John
Last Name: Paul
Age: 0
Salary: 0
結構體指針
也可以創(chuàng)建指向結構的指針。
package main
import (
"fmt"
)
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() {
emp8 := &Employee{
firstName: "Sam",
lastName: "Anderson",
age: 55,
salary: 6000,
}
fmt.Println("First Name:", (*emp8).firstName)
fmt.Println("Age:", (*emp8).age)
}上面程序中的emp8是指向Employee結構的指針。（*emp8）。firstName是訪問emp8結構的firstName字段的語法。此程序打印:
First Name: Sam
Age: 55
Go語言為我們提供了使用emp8.firstName而不是顯式取消引用（*emp8）的選項。firstName以訪問firstName字段。
package main
import (
"fmt"
)
type Employee struct {
firstName string
lastName string
age int
salary int
}
func main() {
emp8 := &Employee{
firstName: "Sam",
lastName: "Anderson",
age: 55,
salary: 6000,
}
fmt.Println("First Name:", emp8.firstName)
fmt.Println("Age:", emp8.age)
}我們已經(jīng)使用emp8.firstName訪問上述程序中的firstName字段，該程序還輸出:
First Name: Sam
Age: 55
匿名字段
可以使用只包含類型而不包含字段名的字段創(chuàng)建結構。這類字段稱為匿名字段。下面的代碼段創(chuàng)建了一個struct Person，它有兩個匿名字段string和int:
type Person struct {
string
int
}即使匿名字段沒有顯式名稱，默認情況下，匿名字段的名稱是其類型的名稱。例如，在上面的Person結構中，雖然字段是匿名的，但默認情況下它們采用字段類型的名稱。所以Person結構有兩個字段，分別是名稱字符串和int。
package main
import (
"fmt"
)
type Person struct {
string
int
}
func main() {
p1 := Person{
string: "naveen",
int: 50,
}
fmt.Println(p1.string)
fmt.Println(p1.int)
}在上述程序的第17行和第18行中，我們訪問Person結構的匿名字段，使用它們的類型作為字段名，分別是string和int。上述程序的輸出為:
naveen
50
結構體嵌套
結構可能包含字段，而字段又是結構。這些類型的結構稱為嵌套結構。
package main
import (
"fmt"
)
type Address struct {
city string
state string
}
type Person struct {
name string
age int
address Address
}
func main() {
p := Person{
name: "Naveen",
age: 50,
address: Address{
city: "Chicago",
state: "Illinois",
},
}
fmt.Println("Name:", p.name)
fmt.Println("Age:", p.age)
fmt.Println("City:", p.address.city)
fmt.Println("State:", p.address.state)
}上述程序中的Person結構具有字段地址，而字段地址又是一個結構。此程序打印:
Name: Naveen
Age: 50
City: Chicago
State: Illinois
字段升級
屬于結構中匿名結構字段的字段稱為提升字段，因為可以像訪問包含匿名結構字段結構一樣訪問它們。我可以理解這個定義相當復雜，所以讓我們深入研究一些代碼來理解它。
type Address struct {
city string
state string
}
type Person struct {
name string
age int
Address
}在上面的代碼段中，Person結構有一個匿名字段Address，它是一個結構?，F(xiàn)在，Address的字段，即city和state，被稱為promoted字段，因為可以像直接在Person結構本身中聲明一樣訪問它們。
package main
import (
"fmt"
)
type Address struct {
city string
state string
}
type Person struct {
name string
age int
Address
}
func main() {
p := Person{
name: "Naveen",
age: 50,
Address: Address{
city: "Chicago",
state: "Illinois",
},
}
fmt.Println("Name:", p.name)
fmt.Println("Age:", p.age)
fmt.Println("City:", p.city) //city is promoted field
fmt.Println("State:", p.state) //state is promoted field
}在上面程序的第29行和第30行中，可以訪問提升字段city和state，就好像它們是使用語法p.city和p.state在結構p中聲明的一樣。此程序打印:
Name: Naveen
Age: 50
City: Chicago
State: Illinois
結構體導出
如果結構類型以大寫字母開頭，則它是導出類型，可以從其他包訪問。類似地，如果結構的字段以caps開頭，則可以從其他包訪問它們。讓我們編寫一個具有自定義包的程序來更好地理解這一點。在Documents目錄中創(chuàng)建名為structs的文件夾。請隨意在任何您喜歡的地方創(chuàng)建它。我更喜歡我的文檔目錄。
mkdir ~/Documents/structs
創(chuàng)建一個gomod，并命名為structs。
cd ~/Documents/structs/
go mod init structs
創(chuàng)建另外一個目錄computer申明一個結構體。
mkdir computer
創(chuàng)建一個spec.go文件，并寫入如下內容：
package computer
type Spec struct { //exported struct
Maker string //exported field
Price int //exported field
model string //unexported field
}上面的代碼片段創(chuàng)建了一個程序包計算機，其中包含一個導出的結構類型Spec，其中有兩個導出的字段Maker和Price，以及一個未導出的字段模型。讓我們從主包導入這個包并使用Spec結構。
創(chuàng)建名為main的文件。進入structs目錄并在main.go中編寫以下程序:
package main
import (
"structs/computer"
"fmt"
)
func main() {
spec := computer.Spec {
Maker: "apple",
Price: 50000,
}
fmt.Println("Maker:", spec.Maker)
fmt.Println("Price:", spec.Price)
}這個結構體如下結構體：
├── structs
│ ├── computer
│ │ └── spec.go
│ ├── go.mod
│ └── main.go
在上面程序的第4行，我們導入計算機包。在第13行和第14行，我們訪問struct Spec的兩個導出字段Maker和Price。這個程序可以通過執(zhí)行命令go-install，然后執(zhí)行structs命令來運行。
go install
structs
運行之后如下結果：
Maker: apple
Price: 50000
如果我們試圖訪問未報告的字段模型，編譯器會抱怨。更換main的內容。使用以下代碼。
package main
import (
"structs/computer"
"fmt"
)
func main() {
spec := computer.Spec {
Maker: "apple",
Price: 50000,
model: "Mac Mini",
}
fmt.Println("Maker:", spec.Maker)
fmt.Println("Price:", spec.Price)
}在上述程序的第12行中，我們嘗試訪問未報告的字段模型。運行此程序將導致編譯錯誤。
# structs
./main.go:12:13: unknown field 'model' in struct literal of type computer.Spec
由于模型字段未報告，因此無法從其他包訪問它。
結構體比較
結構是值類型，如果它們的每個字段都是可比較的，則可以進行比較。如果兩個結構變量的對應字段相等，則認為它們相等。
package main
import (
"fmt"
)
type name struct {
firstName string
lastName string
}
func main() {
name1 := name{
firstName: "Steve",
lastName: "Jobs",
}
name2 := name{
firstName: "Steve",
lastName: "Jobs",
}
if name1 == name2 {
fmt.Println("name1 and name2 are equal")
} else {
fmt.Println("name1 and name2 are not equal")
}
name3 := name{
firstName: "Steve",
lastName: "Jobs",
}
name4 := name{
firstName: "Steve",
}
if name3 == name4 {
fmt.Println("name3 and name4 are equal")
} else {
fmt.Println("name3 and name4 are not equal")
}
}在上面的程序中，名稱結構類型包含兩個字符串字段。由于字符串是可比較的，因此可以比較類型名的兩個結構變量。在上面的程序中，name1和name2相等，而name3和name4不相等。此程序將輸出:
name1 and name2 are equal
name3 and name4 are not equal
如果結構變量包含不可比較的字段，那么它們就不可比較（感謝reddit的alasija指出這一點）。
package main
import (
"fmt"
)
type image struct {
data map[int]int
}
func main() {
image1 := image{
data: map[int]int{
0: 155,
}}
image2 := image{
data: map[int]int{
0: 155,
}}
if image1 == image2 {
fmt.Println("image1 and image2 are equal")
}
}在上面的程序中，圖像結構類型包含類型映射的字段數(shù)據(jù)。地圖是不可比較的，因此無法比較image1和image2。如果運行此程序，編譯將失敗并返回錯誤。
./prog.go:20:12: invalid operation: image1 == image2 (struct containing map[int]int cannot be compared)
到此這篇關于一文教你如何快速學會Go的struct數(shù)據(jù)類型的文章就介紹到這了,更多相關Go struct數(shù)據(jù)類型內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
本文主要介紹了go中sync.RWMutex的源碼解讀,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2024-04-04
這篇文章主要為大家介紹了golang多維度排序及題解最長連續(xù)序列示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-10-10
Go語言中并沒有直接類似 Java 線程池的內建概念,主要通過goroutine和channel來實現(xiàn)并發(fā)處理,本文主要介紹了go語言中線程池的實現(xiàn),具有一定的參考價值,感興趣的可以了解一下2025-04-04
這篇文章主要為大家介紹了Go快速開發(fā)一個RESTful API服務，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06
這篇文章主要介紹了在goland中讀取tpl文件的圖文操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-12-12
本文詳細講解了Go語言的反射機制，文中通過示例代碼介紹的非常詳細。對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-07-07
cast庫是一個簡潔而強大的第三方庫,它的主要功能是實現(xiàn)類型之間的安全轉換,而在Golang開發(fā)中,類型轉換是一個常見且不可避免的過程,下面我們就來看看cast庫在Golang中的具體應用吧2024-11-11
golang數(shù)據(jù)結構之golang稀疏數(shù)組sparsearray詳解
這篇文章主要介紹了golang數(shù)據(jù)結構之golang稀疏數(shù)組sparsearray的相關知識，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-09-09
這篇文章主要介紹了Go語言中的逃逸，套喲究竟是什么呢？通俗來講，當一個對象的指針被多個方法或線程引用時，我們稱這個指針發(fā)生了“逃逸”。下面文章將詳細介紹Go語言中的逃逸,需要的朋友可以參考一下2021-09-09
這篇文章主要介紹了Go?內聯(lián)優(yōu)化讓程序員愛不釋手，內聯(lián)是在編譯過程中自動進行的一類基本優(yōu)化之一，文章圍繞主題展開更多詳細介紹，具有一定的參考價值，需要的小伙伴可以參考一下2022-06-06