1 結構體型別

有時我們需要將不同型別的資料組合成一個有機的整體，如：一個學生有學號/姓名/性別/年齡/地址等屬性。顯然單獨定義以上變數比較繁瑣，資料不便於管理。

結構體是一種聚合的資料型別，它是由一系列具有相同型別或不同型別的資料構成的資料集合。每個資料稱為結構體的成員。

2 結構體初始化

2.1 普通變數

type Student struct {
    id   int
    name string
    sex  byte
    age  int
    addr string
}

func main() {
    //1、順序初始化，必須每個成員都初始化
    var s1 Student = Student{1, "mike", 'm', 18, "sz"}
    s2 := Student{2, "yoyo", 'f', 20, "sz"}
    //s3 := Student{2, "tom", 'm', 20} //err, too few values in struct initializer

    //2、指定初始化某個成員，沒有初始化的成員為零值
    s4 := Student{id: 2, name: "lily"}
}
 

2.2 指標變數

type Student struct {
    id   int
    name string
    sex  byte
    age  int
    addr string
}

func main() {
    var s5 *Student = &Student{3, "xiaoming", 'm', 16, "bj"}
    s6 := &Student{4, "rocco", 'm', 3, "sh"}
}

3 結構體成員的使用

3.1 普通變數

 //===============結構體變數為普通變數
    //1、列印成員
    var s1 Student = Student{1, "mike", 'm', 18, "sz"}
    //結果：id = 1, name = mike, sex = m, age = 18, addr = sz
    fmt.Printf("id = %d, name = %s, sex = %c, age = %d, addr = %s\n", s1.id, s1.name, s1.sex, s1.age, s1.addr)

    //2、成員變數賦值
    var s2 Student
    s2.id = 2
    s2.name = "yoyo"
    s2.sex = 'f'
    s2.age = 16
    s2.addr = "guangzhou"
    fmt.Println(s2) //{2 yoyo 102 16 guangzhou}
 

 3.2 指標變數

//===============結構體變數為指標變數
    //3、先分配空間，再賦值
    s3 := new(Student)
    s3.id = 3
    s3.name = "xxx"
    fmt.Println(s3) //&{3 xxx 0 0 }

    //4、普通變數和指標變數型別列印
    var s4 Student = Student{4, "yyy", 'm', 18, "sz"}
    fmt.Printf("s4 = %v, &s4 = %v\n", s4, &s4) //s4 = {4 yyy 109 18 sz}, &s4 = &{4 yyy 109 18 sz}

    var p *Student = &s4
    //p.成員 和(*p).成員 操作是等價的
    p.id = 5
    (*p).name = "zzz"
    fmt.Println(p, *p, s4) //&{5 zzz 109 18 sz} {5 zzz 109 18 sz} {5 zzz 109 18 sz}
 

4 結構體比較

如果結構體的全部成員都是可以比較的，那麼結構體也是可以比較的，那樣的話兩個結構體將可以使用 == 或 != 運算子進行比較，但不支援 > 或 < 。

func main() {
    s1 := Student{1, "mike", 'm', 18, "sz"}
    s2 := Student{1, "mike", 'm', 18, "sz"}

    fmt.Println("s1 == s2", s1 == s2) //s1 == s2 true
    fmt.Println("s1 != s2", s1 != s2) //s1 != s2 false
}

5 結構體作為函式引數

5.1 值傳遞

func printStudentValue(tmp Student) {
    tmp.id = 250
    //printStudentValue tmp =  {250 mike 109 18 sz}
    fmt.Println("printStudentValue tmp = ", tmp)
}

func main() {
var s Student = Student{1, "mike", 'm', 18, "sz"}

    printStudentValue(s)        //值傳遞，形參的修改不會影響到實參
    fmt.Println("main s = ", s) //main s =  {1 mike 109 18 sz}
}

5.2 引用傳遞 

func printStudentPointer(p *Student) {
    p.id = 250
    //printStudentPointer p =  &{250 mike 109 18 sz}
    fmt.Println("printStudentPointer p = ", p)
}

func main() {
    var s Student = Student{1, "mike", 'm', 18, "sz"}

    printStudentPointer(&s)     //引用(地址)傳遞，形參的修改會影響到實參
    fmt.Println("main s = ", s) //main s =  {250 mike 109 18 sz}
}

6 可見性

Go語言對關鍵字的增加非常吝嗇，其中沒有private、 protected、 public這樣的關鍵字。

要使某個符號對其他包（package）可見（即可以訪問），需要將該符號定義為以大寫字母 開頭。

目錄結構：

 test.go示例程式碼如下：

//test.go
package test

//student01只能在本檔案件引用，因為首字母小寫
type student01 struct {
    Id   int
    Name string
}

//Student02可以在任意檔案引用，因為首字母大寫
type Student02 struct {
    Id   int
    name string
}

main.go示例程式碼如下：

// main.go
package main

import (
    "fmt"
    "test" //匯入test包
)

func main() {
    //s1 := test.student01{1, "mike"} //err, cannot refer to unexported name test.student01

    //err, implicit assignment of unexported field 'name' in test.Student02 literal
    //s2 := test.Student02{2, "yoyo"}
    //fmt.Println(s2)

    var s3 test.Student02 //宣告變數
    s3.Id = 1             //ok
    //s3.name = "mike"  //err, s3.name undefined (cannot refer to unexported field or method name)
    fmt.Println(s3)
}