golang struct

ex1

/*
https://golangbot.com/structs/
struct 結構
結構就是一組字段。
*/

package main

import "fmt"

// 聲明一個結構
type Employee struct {
    firstName string
    lastName  string
    age       int
}
//// 同類型簡化聲明
//type Employee struct {
//  firstName, lastName string
//  age, salary         int
//}

func main() {

    // 匿名結構， 不給結構名字
    var employee struct {
        firstName, lastName string
        age int
    }
    employee.age = 33
    fmt.Println(employee)

    // 結構初始化爲零値
    fmt.Println("Employee:", Employee{})
}

ex2

// 建立命名結構
package main

import (
    "fmt"
)

type Employee struct {
    firstName, lastName string
    age, salary         int
}

func main() {

    //使用字段名字建立結構
    emp1 := Employee{
        firstName: "Sam",
        age:       25,
        salary:    500,
        lastName:  "Anderson",
    }

    //建立結構不使用字段名字
    emp2 := Employee{"Thomas", "Paul", 29, 800}

    fmt.Println("Employee 1", emp1)
    fmt.Println("Employee 2", emp2)
}

ex3

// 建立匿名結構
package main

import (
    "fmt"
)

func main() {
    emp3 := struct {               // 這裏定義
        firstName, lastName string
        age, salary         int
    }{                            // 這裏初始化
        firstName: "Andreah",
        lastName:  "Nikola",
        age:       31,
        salary:    5000,
    }

    fmt.Println("Employee 3", emp3)
}

ex4

// 結構字段訪問
package main

import (
    "fmt"
)

type Employee struct {
    firstName, lastName string
    age, salary         int
}

func main() {
    emp6 := Employee{"Sam", "Anderson", 55, 6000}
    fmt.Println("First Name:", emp6.firstName)
    fmt.Println("Last Name:", emp6.lastName)
    fmt.Println("Age:", emp6.age)
    fmt.Printf("Salary: $%d", emp6.salary)
    fmt.Println()
    var emp7 Employee
    emp7.firstName = "Jack"
    emp7.lastName = "Adams"
    fmt.Println("Employee 7:", emp7)
}

ex5

// 結構指針
package main

import (
    "fmt"
)

type Employee struct {
    firstName, lastName string
    age, salary         int
}

func main() {
    // 這裏emp8就是一個結構指針
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}
    fmt.Println("First Name:", (*emp8).firstName)  // 經過指針訪問結構字段
    fmt.Println("Age:", (*emp8).age)

    // golang提供另外一種可選方法來訪問結構字段
    fmt.Println("First Name:", emp8.firstName)
    fmt.Println("Age:", emp8.age)
}

ex6

// 結構匿名字段
package main

import (
    "fmt"
)

// 定義的結構， 包含有匿名字段
type Person struct {
    string
    int
}

func main() {
    // 帶匿名字段的結構的實例化
    p1 := Person{"Naveen", 50}
    fmt.Println(p1)
    // 儘管匿名字段沒有名字， 它的缺省名字是類型名字
    p1.string = "naveen_new"
    p1.int = 100
    fmt.Println(p1)
}

ex7

// 結構嵌套
package main

import (
    "fmt"
)

type Address struct {
    city, state string
}
type Person struct {
    name string
    age int
    address Address
}

func main() {
    var p Person
    p.name = "Naveen"
    p.age = 50
    p.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)
}

ex8

// 結構提高字段
package main

import (
    "fmt"
)

type Address struct {
    city, state string
}
type Person struct {
    name string
    age  int
    Address  // 當結構中， 存在一個匿名的結構型字段。  咱們把這個字段叫提高字段
}

func main() {
    var p Person
    p.name = "Naveen"
    p.age = 50
    p.Address = Address{
        city:  "Chicago",
        state: "Illinois",
    }
    fmt.Println("Name:", p.name)
    fmt.Println("Age:", p.age)
    fmt.Println("City:", p.city) //這個字段，直接提高到上一級，能夠直接訪問
    fmt.Println("State:", p.state) //這個字段，直接提高到上一級，能夠直接訪問
    fmt.Println("City:", p.Address.city)
    fmt.Println("State:", p.Address.state)
}

ex9

// 結構導出<即外部可訪問性>
package main

import (
    "fmt"
)

// 當前結構首字母大寫， 則外部包能夠訪問
type Address struct {
    // 字段同理
    City, state string
}
type Person struct {
    name string
    age  int
    Address  // 當結構中， 存在一個匿名的結構型字段。  咱們把這個字段叫提高字段
}

func main() {
    var p Person
    p.name = "Naveen"
    p.age = 50
    p.Address = Address{
        City:  "Chicago",
        state: "Illinois",
    }
    fmt.Println(p)

}

ex10

// 結構相等
// 結構是值類型，能夠直接比較（僅當他們字段能夠比較時)
package main

import (
    "fmt"
)

type name struct {
    firstName string
    lastName string
}

type image struct {
    data map[int]int  // 這個字段是不可比較的
}

func main() {
    name1 := name{"Steve", "Jobs"}
    name2 := name{"Steve", "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{}
    name4.firstName = "Steve"
    if name3 == name4 {
        fmt.Println("name3 and name4 are equal")
    } else {
        fmt.Println("name3 and name4 are not equal")
    }


    // 不可比較狀況
    //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")
    //}
}