struct型別

struct

Go語言中，也和C或者其他語言一樣，我們可以宣告新的型別，作為其它型別的屬性或欄位的容器。例如，我們可以建立一個自定義型別person代表一個人的實體。這個實體擁有屬性：姓名和年齡。這樣的型別我們稱之struct。如下程式碼所示:

type person struct {
    name string
    age int
}

看到了嗎？宣告一個struct如此簡單，上面的型別包含有兩個欄位
- 一個string型別的欄位name，用來儲存使用者名稱稱這個屬性
- 一個int型別的欄位age,用來儲存使用者年齡這個屬性

如何使用struct呢？請看下面的程式碼

type person struct {
    name string
    age int
}

var P person  // P現在就是person型別的變量了

P.name = "Astaxie"  // 賦值"Astaxie"給P的name屬性.
P.age = 25  // 賦值"25"給變數P的age屬性
fmt.Printf("The person's name is %s", P.name)  // 訪問P的name屬性.

除了上面這種P的宣告使用之外，還有另外幾種宣告使用方式：

• 1.按照順序提供初始化值

  P := person{“Tom”, 25}

• 2.通過field:value

  的方式初始化，這樣可以任意順序

  P := person{age:24, name:”Tom”}

• 3.當然也可以通過new函式分配一個指標，此處P的型別為*person

  P := new(person)

下面我們看一個完整的使用struct的例子

package main

import "fmt"

// 宣告一個新的型別
type person struct {
    name string
    age int
}

// 比較兩個人的年齡，返回年齡大的那個人，並且返回年齡差
// struct也是傳值的
func Older(p1, p2 person) (person, int) {
    if p1.age
 
>p2.age {  // 比較p1和p2這兩個人的年齡
        return p1, p1.age-p2.age
    }
    return p2, p2.age-p1.age
}

func main() {
    var tom person

    // 賦值初始化
    tom.name, tom.age = "Tom", 18

    // 兩個欄位都寫清楚的初始化
    bob := person{age:25, name:"Bob"}

    // 按照struct定義順序初始化值
    paul := person{"Paul", 43}

    tb_Older, tb_diff := Older(tom, bob)
    tp_Older, tp_diff := Older(tom, paul)
    bp_Older, bp_diff := Older(bob, paul)

    fmt.Printf("Of %s and %s, %s is older by %d years\n",
        tom.name, bob.name, tb_Older.name, tb_diff)

    fmt.Printf("Of %s and %s, %s is older by %d years\n",
        tom.name, paul.name, tp_Older.name, tp_diff)

    fmt.Printf("Of %s and %s, %s is older by %d years\n",
        bob.name, paul.name, bp_Older.name, bp_diff)
}

struct的匿名欄位

我們上面介紹瞭如何定義一個struct，定義的時候是欄位名與其型別一一對應，實際上Go支援只提供型別，而不寫欄位名的方式，也就是匿名欄位，也稱為嵌入欄位。

當匿名欄位是一個struct的時候，那麼這個struct所擁有的全部欄位都被隱式地引入了當前定義的這個struct。

讓我們來看一個例子，讓上面說的這些更具體化

package main

import "fmt"

type Human struct {
    name string
    age int
    weight int
}

type Student struct {
    Human  // 匿名欄位，那麼預設Student就包含了Human的所有欄位
    speciality string
}

func main() {
    // 我們初始化一個學生
    mark := Student{Human{"Mark", 25, 120}, "Computer Science"}

    // 我們訪問相應的欄位
    fmt.Println("His name is ", mark.name)
    fmt.Println("His age is ", mark.age)
    fmt.Println("His weight is ", mark.weight)
    fmt.Println("His speciality is ", mark.speciality)
    // 修改對應的備註資訊
    mark.speciality = "AI"
    fmt.Println("Mark changed his speciality")
    fmt.Println("His speciality is ", mark.speciality)
    // 修改他的年齡資訊
    fmt.Println("Mark become old")
    mark.age = 46
    fmt.Println("His age is", mark.age)
    // 修改他的體重資訊
    fmt.Println("Mark is not an athlet anymore")
    mark.weight += 60
    fmt.Println("His weight is", mark.weight)
}

我們看到Student訪問屬性age和name的時候，就像訪問自己所有用的欄位一樣，對，匿名欄位就是這樣，能夠實現欄位的繼承。是不是很酷啊？還有比這個更酷的呢，那就是student還能訪問Human這個欄位作為欄位名。請看下面的程式碼，是不是更酷了。

mark.Human = Human{"Marcus", 55, 220}
mark.Human.age -= 1

通過匿名訪問和修改欄位相當的有用，但是不僅僅是struct欄位哦，所有的內建型別和自定義型別都是可以作為匿名欄位的。請看下面的例子

package main

import "fmt"

type Skills []string

type Human struct {
    name string
    age int
    weight int
}

type Student struct {
    Human  // 匿名欄位，struct
    Skills // 匿名欄位，自定義的型別string slice
    int    // 內建型別作為匿名欄位
    speciality string
}

func main() {
    // 初始化學生Jane
    jane := Student{Human:Human{"Jane", 35, 100}, speciality:"Biology"}
    // 現在我們來訪問相應的欄位
    fmt.Println("Her name is ", jane.name)
    fmt.Println("Her age is ", jane.age)
    fmt.Println("Her weight is ", jane.weight)
    fmt.Println("Her speciality is ", jane.speciality)
    // 我們來修改他的skill技能欄位
    jane.Skills = []string{"anatomy"}
    fmt.Println("Her skills are ", jane.Skills)
    fmt.Println("She acquired two new ones ")
    jane.Skills = append(jane.Skills, "physics", "golang")
    fmt.Println("Her skills now are ", jane.Skills)
    // 修改匿名內建型別欄位
    jane.int = 3
    fmt.Println("Her preferred number is", jane.int)
}

圖例如下:

從上面例子我們看出來struct不僅僅能夠將struct作為匿名欄位、自定義型別、內建型別都可以作為匿名欄位，而且可以在相應的欄位上面進行函式操作（如例子中的append）。

這裡有一個問題：如果human裡面有一個欄位叫做phone，而student也有一個欄位叫做phone，那麼該怎麼辦呢？

Go裡面很簡單的解決了這個問題，最外層的優先訪問，也就是當你通過student.phone訪問的時候，是訪問student裡面的欄位，而不是human裡面的欄位。

這樣就允許我們去過載通過匿名欄位繼承的一些欄位，當然如果我們想訪問過載後對應匿名型別裡面的欄位，可以通過匿名欄位名來訪問。請看下面的例子

package main

import "fmt"

type Human struct {
    name string
    age int
    phone string  // Human型別擁有的欄位
}

type Employee struct {
    Human  // 匿名欄位Human
    speciality string
    phone string  // 僱員的phone欄位
}

func main() {
    Bob := Employee{Human{"Bob", 34, "777-444-XXXX"}, "Designer", "333-222"}
    fmt.Println("Bob's work phone is:", Bob.phone)
    // 如果我們要訪問Human的phone欄位
    fmt.Println("Bob's personal phone is:", Bob.Human.phone)
}