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")
	//}
}