1. 型別簡介

1.1 命名型別和非命名型別

命名型別（Named Type）
型別可以通過識別符號來表示，這種型別稱為命名型別，Go語言的基本型別中有20個預宣告簡單型別都是命名型別，Go語言還有一種命名型別——用戶自定義型別，
未命名型別（Unamed Type）
一個型別由預宣告型別、關鍵字和運算子組合而成，這個型別稱為未命名型別，又稱為型別字面量（Type Literal），

Go語言的基本型別中的復合型別：陣列（array）、切片（slice）、字典（map）、通道（channel）、指標（pointer）、函式字面量（function）、結構（struct）和介面（interface）都屬于型別字面量，都是未命名型別，
所以*int，[]int，[2]int，map[k]v都是未命名變數，

1.2 底層型別

• 所有“型別”都有一個underlying type（底層型別），底層型別的規則如下：
  • （1）預宣告型別（Pre-declared types）和型別字面量（type literals）的底層型別是她們自身，
  • （2）自定義型別type newtype oldtype中的newtype的底層型別是逐層遞回向下查找的，

1.3 型別相同和型別賦值

型別相同
Go是強型別的語言，編譯器在編譯時會進行嚴格的型別檢驗，兩個命名型別是否相同，參考如下：
（1）兩個命名型別相同的條件是兩個型別宣告的語言完全相同，
（2）命名型別和未命名型別永遠不相同
（3）兩個未命名型別相同的條件是它們的型別宣告字面量的結構相同，并且內部元素的型別相同，
（4）通過型別別名陳述句宣告的兩個型別相同，

型別可直接賦值

• 不同型別的變數之間一般是不能直接相互賦值的，除非滿足一定的條件，
• 型別為T1的變數a可以賦值給型別為T2的變數b，稱為型別T1可以賦值給型別T2，偽代碼如下：

//a是型別T1的變數，或者a本身就是一個字面常量或nil
var b T2 = a

a可以賦值給變數b必須滿足如下條件中的一個：
（1）T1和T2的型別相同
（2）T1和T2具有相同的底層型別，并且T1和T2里面至少有一個未命名型別，
（3）T2是介面型別，T1是具體型別，T1的方法集是T2方法集的超集
（4）T1和T2都是通道型別，它們擁有相同的元素型別，并且T1和T2中至少有一個是未命名型別，
（5）a是預宣告識別符號nil，T2是pointer、function、slice、map、channel、interfacce型別中的一個，
（6）a是一個字面量常量，可以用來表示型別T的值，

package main

import "fmt"

type Map map[string]string

func (m Map) Print() {
	for _, key := range m {
		fmt.Println(key)
	}
}

type iMap Map

//只要底層型別是slice、map等支持range的型別字面量，新型別仍然可以使用range迭代
func (m iMap) Print() {
	for _, key := range m {
		fmt.Println(key)
	}
}

type slice []int

func (s slice) Print() {
	for _, v := range s {
		fmt.Println(v)
	}
}

func main() {
	mp := make(map[string]string, 10)
	mp["hi"] = "tata"

	//mp與ma有相同的底層型別map[string][string]，并且mp是未命名型別
	//所以mp可以直接賦值給ma
	var ma Map = mp

	// im與ma雖然有相同的底層型別map[string][string]，但是它們中沒有一個是未命名型別，所以不能賦值，
	//var im iMap = ma

	ma.Print()
	//im.Print()
	// Map實作了Print()，所以其可以賦值給介面型別變數
	var i interface {
		Print()
	} = ma

	i.Print()

	s1 := []int{1, 2, 3}
	var s2 slice
	s2 = s1
	s2.Print()
}

1.4 型別強制轉換

• Go語言是強型別的語言，如果不滿足自動轉換的條件，則必須進行強制型別轉換，
• 任何兩個不相干的型別如果進行強制轉換，必須符合一定的規則，
• 強制型別的語法格式：var a T= (T) (b)，使用括號將型別和要轉換的變數或運算式的值括起來
• 非常量型別的變數x可以強制轉化并傳遞給型別T，需要滿足如下任一條件：
  • （1）x可以直接賦值給T型別變數
  • （2）x的型別和T具體相同的底層型別，
  • （3）x的型別和T都是未命名的指標型別，并且指標指向的型別具有相同的底層型別
  • （4）x的型別和T都是整型，或者都是浮點型
  • （5）x的型別和T都是復數型別
  • （6）x是整數值或[]byte型別的值，T是string型別
  • （7）x是一個字串，T是[]byte或[]rune，

注意：
（1）數值型別和string型別之間的相互轉換可能造成值部分丟失；其他的轉換僅是型別的轉換，不會造成值的改變，string和數字之間的轉換可使用標準庫strconv，
（2）Go語言沒有語言機制支持指標和integer之間的直接轉換，可以使用標準庫中的unsafe包進行處理，

2. 型別方法

2.1 自定義型別

• 用戶自定義型別使用關鍵字type，其語法格式是type newtype oldtype，oldtype可以是自定義型別、預宣告型別、未命名型別中的任意一種，newtype是新型別的識別符號，與oldtype具有相同的底層型別，并且都繼承了底層型別的操作集合，
• newtype和oldtype是兩個完全不同的型別，newtype不會集成oldtype的方法，無論oldtype是什么型別，使用type宣告的新型別都是一種命名型別，也就是說，自定義型別都是命名型別，

自定義struct型別

• struct型別是Go語言自定義型別的普遍的形式，是Go語言型別擴展的基石，
• 當用戶宣告一個新型別時，這個宣告就給編譯器提供了一個框架，告知必要的記憶體大小和表示資訊，
• 結構里每個欄位都會用一個已知型別宣告，這個已知型別可以是內置型別，也可以是其他用戶定義的型別，

type Person struct{
	name string
	email string
	age	int
}

• （1）按照欄位順序進行初始化
• （2）指定欄位名進行初始化

package main

import "fmt"

type Person struct {
	name string
	age  int
}

func main() {
	a := Person{"john", 18}
	b := Person{
		"Tom",
		20,
	}
	c := Person{
		"Jim",
		21,
	}
	// 下面是推薦的三種方法
	d := Person{name: "Kim", age: 20}
	e := Person{
		name: "Band",
		age:  22,
	}
	f := Person{
		name: "Pony",
		age:  22,
	}
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)
	fmt.Println(e)
	fmt.Println(f)
}

• （3）使用new創建內置函式，欄位默認初始化為其型別的零值，回傳值是指向結構的指標，這種方法一般不常用，一般使用struct都不會將所有欄位初始化為零值，
• （4）一次初始化一個欄位

p ：= Person{}
p.name = "Tom"
p.age = 20

• （5）使用建構式進行初始化，這是推薦的方法，當結構發生變化時，建構式可以屏蔽細節，

結構欄位的特點

• 結構的欄位可以是任意的型別，基本型別、介面型別、指標型別、函式型別都可以作為struct的欄位，
• 結構欄位的型別名必須唯一，struct欄位型別可以是普通型別，也可以是指標，
• 結構支持內嵌自身的指標，這也是實作樹形和鏈表等復雜資料結構的基礎，

import "container/list"

type Element struct {
	// 指向自身型別的指標
	next, prev *Element
	list       *list.List
	Value      interface{}
}

匿名方法

• 在定義struct的程序中，如果欄位只給出欄位型別，沒有給出欄位名，則稱這樣的欄位為“匿名欄位”，
• 被匿名嵌入的欄位必須是命名型別或命名型別的指標，型別字面量不能作為匿名欄位使用，
• 匿名欄位的欄位名默認就是型別名，如果匿名欄位是指標型別，則默認的欄位名就是指標指向的型別名，
• 但是一個結構體里面不能同時存在某一型別及其指標型別的匿名欄位，原因是二者的欄位名相等，如果嵌入的欄位來自其他包，則需要加上包名，并且必須是其他包可以匯出的型別，

自定義介面型別

• 自定義介面型別同樣使用type關鍵字宣告，

// interface{}是介面字面量型別標識，所以i是非命名型別變數
var i interface{}

//Reader是自定義介面型別，屬于命名型別
type Reader interfacce{
	Read(p []byte) (n int, err error)
}

2.2 方法

• Go語言的型別方法是一種對型別行為的封裝，可以看作特殊型別的函式，其顯式地將物件實體或指標作為函式的第一個引數，并且引數名可以自己指定，這個物件實體或指標稱為方法的接收者（reciver），
• 關鍵字 func 和函式名之間的引數被稱作接收者，將函式與接收者的型別綁在一起，如果一個函式有接收者，這個函式就被稱為方法，
• Go 語言里有兩種型別的接收者：值接收者和指標接收者，

//型別方法接收者是值型別
func (t TypeName)MethodName(ParamList) (Returnlist)  {
	// method body
}

//型別方法接收者是指標
func (t *TypeName)MethodName(ParamList) (Returnlist)  {
	//method body
}

- t是接收者，可以自由指定名稱，
- TypeName為命名型別的型別名
- MethodName為方法名，是一個自定義識別符號
- ParamList是形參串列
- ReturnList是回傳值串列，

• 當呼叫使用指標接收者宣告的方法時，這個方法會共享呼叫方法時接收者所指向的值
• 值接收者使用值的副本來呼叫方法，而指標接受者使用實際值來呼叫方法，
• 也可以使用一個值來呼叫使用指標接收者宣告的方法
• 如果給這個型別增加或者洗掉某個值，是要創建一個新的值，還是要更改當前的值？如果是要創建一個新值，該型別的方法就使用值接收者，如果是要修改當前值，就使用指標接收者，
• 內置型別是由語言提供的一組型別，我們已經見過這些型別，分別是數值型別、字串型別和布爾型別，
• Go 語言里的參考型別有如下幾個：切片、映射、通道、介面和函式型別，
• 是使用值接收者還是指標接收者，不應該由該方法是否修改了接收到的值來決定，這個決策應該基于該型別的本質，
• 這條規則的一個例外是，需要讓型別值符合某個介面的時候，即便型別的本質是非原始本質的，也可以選擇使用值接收者宣告方法，這樣做完全符合介面值呼叫方法的機制，
• Go語言的型別方法本質上就是一個函式，沒有使用隱式的指標，

//將型別的方法改寫成常規的函式
func TypName_MethodName(t TypeName, otherParamList) (Returnlist)  {
	//method body
}
func TypName_MethodName(t *TypeName, otherParamList) (Returnlist) {
	//method body
}

• 型別方法的特點：
  • （1）可以為命名型別增加方法（除了介面），非命名不能自定義方法，
  • （2）為型別增加方法有一個限制，就是方法的定義必須和型別的定義在同一個包中，
  • （3）方法的命名空間的可見性和變數一樣，大寫開頭的方法可以在包外被訪問，否則只能在包內可見，
  • （4）使用type定義的自定義型別是一個新型別，新型別不能呼叫原有型別的方法，但是底層型別支持的運算可以被新型別繼承，

package main

import "fmt"

type Map map[string]string

func (m Map) Print() {
	//底層型別支持range運算，新型別可用
	for _, key := range m {
		fmt.Println(key)
	}
}

type MyInt int

func main() {
	var a MyInt = 10
	var b MyInt = 10

	// int型別支持的加減乘除運算，新型別同樣可用
	c := a + b
	d := a * b
	fmt.Printf("%d\n", c)
	fmt.Printf("%d\n", d)
}

3. 方法呼叫

3.1 一般呼叫

型別方法的一般呼叫方式：

TypeInstancceName.MethodName(ParamList)

• TypeInstanceName: 型別實體名或指向實體的指標變數名;
• MethodName：型別方法名
• ParamList：方法實參

package main

type T struct {
	a int
}

func (t T) Get() int {
	return t.a
}
func (t *T) Set(i int) {
	t.a = i
}

func main() {
	var t = &T{}

	//普通方法呼叫
	t.Set(2)
	//普通方法呼叫
	t.Get()
}

3.2 方法值（method value）

• 變數x的靜態型別是T，M是型別T的一個方法，x.M被稱為方法值（method value），x.M是一個函式型別變數，可以賦值給其他變數，并像普通的函式名一樣使用，

f := x.M
f(args...)

等價于

x.M(args ...)

方法值（method value）其實是一個帶有閉包的函式變數，其底層實作原理和帶有閉包的匿名函式類似，接收值被隱式地系結到方法值（method value）的閉包環境中，后續呼叫不需要再顯顯式地傳遞接收者，

package main

import "fmt"

type T struct {
	a int
}

func (t T) Get() int {
	return t.a
}
func (t *T) Set(i int) {
	t.a = i
}

func (t *T) Print() {
	fmt.Printf("%p,%v,%d \n", t, t, t.a)
}

func main() {
	var t = &T{}

	// method value
	f := t.Set

	//方法值呼叫
	f(2)
	t.Print()

	//方法值呼叫
	f(3)
	t.Print()
}

3.3 方法運算式（method expression）

• 方法運算式相當于提供一種語法將型別方法呼叫顯式地轉換為函式呼叫，接收者（receiver）必須顯式地傳遞進去，

func (t T) Get() int {
	return t.a
}
func (t *T) Set(i int) {
	t.a = i
}

func (t *T) Print() {
	fmt.Printf("%p,%v,%d \n", t, t, t.a)
}

運算式T.Get和（*T）.Set被稱為方法運算式（method expression），方法運算式可以看作函式名，只不過這個函式的首個引數是接收者的實體或指標，
Go的方法底層是基于函式實作的，

3.4 方法集（method set）

命名型別方法接收者有兩種型別：一個是值型別，另一個是指標型別，前者的形參是值型別，后者的形參是指標型別，無論接收者是什么型別，方法和函式的實參傳遞都是值拷貝，

package main

import "fmt"

type Int int

func (a Int) Max(b Int) Int {
	if a >= b {
		return a
	} else {
		return b
	}
}
func (i *Int) Set(a Int) {
	*i = a
}
func (i Int) Print() {
	fmt.Printf("value=%d\n", i)
}
func main() {
	var a Int = 10
	var b Int = 20

	c := a.Max(b)
	c.Print()
	(&c).Print()

	a.Set(20)
	a.Print()

	(&a).Set(30)
	a.Print()
}

為了簡化描述，將接收者（receiver）為值型別T的方法的集合記為S，將接收者（receiver）為指標型別T的方法的集合統稱為S，型別的方法集總結如下：
（1）T型別的方法集為S
（2）T型別的方法集是S和S

3.5 值呼叫和運算式呼叫的方法集

• （1）通過型別字面量顯式地進行值呼叫和運算式呼叫，可以看到在這種情況下編譯器不會做自動轉換，會進行嚴格的方法集檢查，
• （2）通過型別變數進行值呼叫和運算式呼叫，在這種情況下，使用值呼叫（method value）方式呼叫時編譯器會進行自動轉換，使用運算式呼叫（method expression）方式呼叫時編譯器不會進行轉換，會進行嚴格的方法集檢查，

4. 組合和方法集

結構型別（struct）為Go提供了強大的型別擴展，主要是兩方面：第一，struct可以嵌入任意其他型別的欄位；第二，struct可以嵌套自身的指標型別的欄位，

4.1 組合

• 使用type定義的新型別不會繼承原有型別的方法，有個特例就是命名結構型別，命名結構型別可以嵌套其他的命名型別的欄位，外層的結構型別是可以呼叫嵌入欄位型別的方法，這種呼叫既可以是顯式的，也可以是隱式的，這就是Go的“繼承”，也就是“組合”.
• struct型別中的欄位稱為“內嵌欄位”，
  內嵌欄位的初始化和訪問
• struct的欄位訪問使用點運算子“.”，struct的欄位可以嵌套很多層，只要內嵌的欄位是唯一的即可，不需要使用全路徑進行訪問，
• 在struct的多層嵌套中，不同嵌套層次可以有相同的欄位，此時最好使用完全路徑進行訪問和初始化，

內嵌欄位的方法呼叫

• 如果外層欄位和內層欄位有相同的方法，則使用簡化模式訪問外層的方法會覆寫記憶體的方法，即在簡寫模式下，Go編譯器優先從外向內逐層查找方法，同名方法中外層的方法能夠覆寫內層的方法，
• 不推薦在多層的struct型別中內嵌多個同名的欄位；但是并不反對struct定義和內嵌欄位同名方法的用法，

4.2 組合的方法集

組合結構的方法集有如下規則：
（1）若型別S包含匿名欄位T，則S的方法集包含T的方法集
（2）若型別S包含匿名欄位T，則S的方法集包含T和T方法集
（3）不管型別S中嵌入的匿名欄位是T還是*T，S方法集總是包含T和T方法集，

• 編譯器的自動轉換僅適用于直接通過型別實體呼叫方法時才有效，型別實體傳遞給介面時，編譯器不會進行自動轉換，而是會進行嚴格的方法集檢驗，

5. 函式型別

• 使用func FunctionName()語法格式定義的函式稱為“有名函式”.
• 所謂的匿名函式就是在定義時使用func()語法格式，沒有指定函式名，
• 函式型別也分為兩種，一種是函式字面量型別（未命名型別），另一種是函式命名型別，

函式字面量型別
函式字面量型別的語法運算式是func (InputTypeList)OutputTypeList，“有名函式”和“匿名函式”都屬于函式字面量型別，

函式命名型別
使用type NewType OldType語法定義一種新型別，這種型別都是命名型別，同理可以使用該方法定義一種新型別：函式命名型別，簡稱函式型別，
type NewFuncType FuncLiteral
NewFuncType為新定義的函式命名型別，FuncLiteral為函式字面量型別，FuncLiteral為函式型別NewFuncType的底層型別，當然也可以使用type在一個函式型別中再定義一個新的函式型別，

函式簽名
所謂的“函式簽名”,就是“有名函式”和“匿名函式”的字面量型別，不包括函式名，
函式宣告
Go代碼呼叫Go撰寫的函式不需要宣告，可以直接呼叫，但是Go呼叫匯編語言撰寫的函式還是要使用函式宣告陳述句，

//函式宣告=函式名+函式簽名

//函式簽名
func (InputTypeList)OutputTypeList
//函式宣告
func FuncName (InputTypeList)OutputTypeList

上述概念的示例：

package main

import "fmt"

//有名函式定義，函式名為add
func add(a, b int) int {
	return a + b
}

//函式宣告陳述句，用于Go代碼呼叫匯編代碼
func add(int, int) int

// add函式的簽名，實際上就是add的字面量型別
func (int, int) int

//匿名函式不能獨立存在，常作為函式引數、回傳值、或者賦值給某個變數
//匿名函式可以直接顯式初始化
//匿名函式的型別也是函式字面量型別func (int,int) int
func (a,b int) int {
	return a + b
}

//新定義函式型別ADD
//ADD底層型別是函式字面量型別func (int, int) int
type ADD func(int, int) int

//add和ADD的底層型別相同，并且add是字面量型別
//所以add可直接賦值給ADD型別的變數g
var g ADD = add

func main() {
	f := func(a, b int) int {
		return a + b
	}
	g(1, 2)
	f(1, 2)

	//f和add的函式簽名相同
	fmt.Printf("%T\n", f)
	fmt.Printf("%T\n", add)
}

函式型別有如下意義：
（1）函式也是一種型別，可以在函式字面量型別的基礎上定義一種命名函式型別
（2）有名函式和匿名函式的函式簽名與命名函式型別的底層型別相同，它們之間可以進行型別轉換
（3）可以為有名函式型別添加方法，可以方便地為一個函式增加“攔截”或“過濾”等額外功能，這提供了一種裝飾設計模式
（4）為有名函式型別添加方法，使其與介面打通關系，使用介面的地方可以傳遞函式型別的變數，

至此，我們基本了解了Go原因的型別系統，下一部分我們將學習Go語言的介面，