Golang struct結構

結構struct

• Go中的struct與C中的struct很是類似，而且Go沒有class，代替了class的位置，但並無代替class的功能
• 使用type struct{} 定義結構，名稱遵循可見性規則
• 支持指向自身的指針類型成員
• 支持匿名結構，可用做成員或定義成員變量
• 匿名結構也能夠用於map的值
• 能夠使用字面值對結構進行初始化
• 容許直接經過指針來讀寫結構成員
• 相同類型的成員可進行直接拷貝賦值
• 支持==與!=比較運算符，但不支持>或<
• 支持匿名字段，本質上是定義了以某個類型名爲名稱的字段
• 嵌入結構做爲匿名字段看起來像繼承，但不是繼承
• 能夠使用匿名字段指針

結構的定義

package main

import (
    "fmt"
)

type Person struct { //結構也是一中類型
    Name string //定義struct的屬性
    Age  int
}

func main() {
    a := Person{}
    a.Name = "joe" //對struct的屬性進行操做，類型與class的使用方法
    a.Age = 19
    fmt.Println(a)
}

字面值初始化

package main

import (
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    a := Person{
        Name: "jack",
        Age:  19, //對結構的屬性進行字面值的初始化
    }
    fmt.Println(a)
}

結構的傳遞

package main

import (
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    a := Person{
        Name: "jack",
        Age:  19, //對結構的屬性進行字面值的初始化
    }
    fmt.Println(a)
    A(a)
    fmt.Println(a) //結構也是一種值類型，對它進行傳遞的時候，也是進行了值得拷貝
}
func A(per Person) {
    per.Age = 13
    fmt.Println("A", per)
}
PS G:\mygo\src\mytest> go run .\temp.go
{jack 19}
A {jack 13}
{jack 19}

package main

import (
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    a := Person{
        Name: "jack",
        Age:  19, //對結構的屬性進行字面值的初始化
    }
    fmt.Println(a)
    A(&a)
    fmt.Println(a) //結構也是一種值類型，對它進行傳遞的時候，也是進行了值得拷貝
}
func A(per *Person) { //經過一個指針進行傳遞，此時就不是值得拷貝了
    per.Age = 13
    fmt.Println("A", per)
}
PS G:\mygo\src\mytest> go run .\temp.go
{jack 19}
A &{jack 13}
{jack 13}

package main

import (
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    a := &Person{
        Name: "jack",
        Age:  19, //此時初始化的時候就將這個struct的指針取出來
    }
    //在進行struct的初始化的時候，就加上&取地址符號
    fmt.Println(a)
    A(a)
    B(a)
    fmt.Println(a) //結構也是一種值類型，對它進行傳遞的時候，也是進行了值得拷貝
}
func A(per *Person) { //經過一個指針進行傳遞，此時就不是值得拷貝了
    per.Age = 13
    fmt.Println("A", per)
}
func B(per *Person) { //經過一個指針進行傳遞，此時就不是值得拷貝了
    per.Age = 15
    fmt.Println("B", per)
}
PS G:\mygo\src\mytest> go run .\temp.go
&{jack 19}
A &{jack 13}
B &{jack 15}
&{jack 15}

匿名結構

package main

import (
    "fmt"
)

func main() {
    a := &struct { //匿名結構，須要先對結構自己進行一個定義
        Name string
        Age  int
    }{
        Name: "jack",
        Age:  20,
    }
    fmt.Println(a)
}

匿名結構的嵌套

package main

import (
    "fmt"
)

type Person struct {
    Name    string
    Age     int
    Contact struct {
        Phone, City string //匿名結構嵌套在Person中
    }
}

func main() {
    a := Person{Name: "Jack", Age: 20}
    a.Contact.Phone = "123321" //經過這種方法對嵌套在Person中的匿名結構進行字面值的初始化
    a.Contact.City = "BeiJing"
    fmt.Println(a)
}
PS G:\mygo\src\mytest> go run .\temp2.go
{Jack 20 {123321 BeiJing}}

匿名字段

package main

import (
    "fmt"
)

type Person struct {
    string //匿名字段 在進行字面值初始化的時候 必須嚴格按照字段聲明的順序
    int
}

func main() {
    a := Person{"Jack", 20} //此時將string 和 int類型對調的時候就會報錯
    fmt.Println(a)
}

結構相同類型的比較

package main

import (
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    a := Person{Name: "Jack", Age: 20}
    b := Person{Name: "Jack", Age: 20}

    fmt.Println(a == b)
}
PS G:\mygo\src\mytest> go run .\temp3.go
true

嵌入結構

package main

import (
    "fmt"
)

type human struct {
    Sex int
}
type teacher struct {
    human
    Name string
    Age  int
}
type student struct {
    human //這裏的human也是一種類型，此時它至關於一種匿名字段，嵌入結構做爲匿名字段的話
    //它本質上是將結構名稱做爲咱們的字段名稱
    Name string
    Age  int
}

func main() {
    a := teacher{Name: "Jack", Age: 20, human: human{Sex: 0}} //所以咱們須要在這裏進行這種初始化
    b := student{Name: "Tom", Age: 19, human: human{Sex: 1}}
    a.Name = "Fack"
    a.Age = 13
    a.human.Sex = 100 //保留這種調用的方法，是由於會涉及到名稱的衝突
    //a.Sex = 101 這種寫法也是能夠的
    fmt.Println(a, b)
}
PS G:\mygo\src\mytest> go run .\temp3.go
{{100} Fack 13} {{1} Tom 19}