Go--struct

Go語言中，也和C或者其它語言一樣，也可以聲明新的類型，作爲其它類型的屬性或者是字段的容器。例如我們可以創建一個自定義類型person代表一個人的實體。這個實體擁有屬性：姓名和年齡。這樣的類型我們稱之爲struct

type person struct {
	name string
	age int
}

　　上面的person中包含了兩個字段：

　　　　一個string類型的字段name，用來保存用戶名稱這個屬性

　　　　一個int類型的字段age，用來保存用戶年齡這個屬性

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 := new(person)

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的時候就像訪問自己的字段一樣，其實匿名字段就是這樣的，能夠實現字段的繼承

　　通過匿名訪問和修改字段相當有用，但是不僅僅是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作爲匿名字段，自定義類型、內置類型都可以作爲匿名字段，而且可以在相應的字段上面進行函數操作

　　如果要是碰到兩個struct重名的時候，Go中最外層的優先訪問，這樣就允許我們去重載通過匿名字段繼承的一些字段，當然如果我們像訪問重載後對應匿名類型裏面的字段，可以通過匿名字段名來進行訪問，

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