本文内容基于《Go语言核心编程》，李文塔著。

1 类型系统

1.1 类型简介

1.1.1 命名类型和未命名类型

1.1.2 底层类型

1.1.3 类型相同

1.1.4 类型强制转换

1.2 类型方法

1.2.1 自定义类型

1.2.2 方法

1.3 方法调用

1.3.1 一般调用

1.3.2 方法值

1.3.3 方法表达式

1.3.4 方法集

1.3.5 值调用和表达式调用的方法集

1.4 组合

1.5 函数类型

1.5.1 函数类型

1.5.2 函数签名

1.5.3 函数声明

1.5.4 函数类型的意义

1 类型系统

Go语言的类型系统可以分为命名类型、非命名类型、底层类型、动态类型和静态类型等。

1.1 类型简介

1.1.1 命名类型和未命名类型

命名类型：类型可以通过标识符来表示，这种类型称为命名类型，Go语言的基本类型中有20个预声明简单类型和用户自定义类型都是命名类型。

未命名类型：一个类型由预声明类型、关键字和操作符组合而成，这个类型成为未命名类型，又称为类型字面量，Go语言的基本类型中的复合类型都是未命名类型（数组、切片、字典、通道、指针、函数字面量、结构、接口），注意这里指的是没有使用type格式来定义的。

type Person struct {name stringage int
}func main() {// 未命名类型a := struct {name stringage int}{"张三", 18}// 命名类型b := Person{name: "李四",age: 20,}fmt.Printf("a = %T\n", a)		// a = struct { name string; age int }fmt.Printf("b = %T\n", b)		// b = main.Person
}

• 基本类型=简单类型+复合类型；
• 命名类型=预声明类型+自定义类型；
• 预声明类型=简单类型；
• 自定义类型的old_type可以是预声明类型、自定义类型和未命名类型中的一种；
• 未命名类型=类型字面量=复合类型。

1.1.2 底层类型

所有类型都有一个底层类型：

• 预声明类型和未命名类型的底层类型是它们自身；
• 自定义类型中的new_type的底层类型是逐层递归向下查找的，知道查到的old_type是预声明类型或未命名类型为止。

// T1和T2的底层类型是string
type T1 string
type T2 T1// T3和T4的底层类型是[]string
type T3 []string
type T4 T3// T5和T6的底层类型是[]T1
type T5 []T1
type T6 T5

1.1.3 类型相同

两个类型是否相同，参考如下：

• 两个命名类型相同的条件是两个类型声明的语句完全相同；
• 命名类型和未命名类型永远不相同；
• 两个未命名类型相同的条件是它们的类型声明字面量的结构相同，并且内部元素的类型相同；
• 通过类型别名语句声明的两个类型相同（type T1 = T2）。

引入别名主要有如下原因：

• 为了解决新旧包的迁移兼容问题，比如context包先前并不在标准库里面，后面迁移到了标准库；
• Go的按包进行隔离的机制不太精细，有时我们需要将大包划分为几个小包进行开发，但需要在大包里面暴露全部的类型给使用者；
• 解决新旧类型的迁移问题，新类型先是旧类型的别名，后续的软件都基于新类型编程，在合适的时间将新类型升级为和旧类型不兼容，常用于软件的柔性升级。

1.1.4 类型强制转换

字符串和字节切片之间的转换最为常见：

• 数值类型和string类型之间的相互转换可能造成值部分丢失，其他的转换仅是类型的转换，不会造成值的改变；
• string和数字之间的转换可以使用标准库strconv；
• Go语言没有语言机制支持指针和interger之间的直接转换，可以使用标准库中的unsafe包进行处理。

// 顺便体会[]byte和[]rune的区别（中文占几个字节？）
func main() {s := "hello 世界"var a []bytea = []byte(s)fmt.Printf("string -> []byte = %v -> %v\n", s, a)		// string -> []byte = hello 世界 -> [104 101 108 108 111 32 228 184 150 231 149 140]var b stringb = string(a)fmt.Printf("[]byte -> string = %v -> %v\n", a, b)		// []byte -> string = [104 101 108 108 111 32 228 184 150 231 149 140] -> hello 世界var c []runec = []rune(s)fmt.Printf("string -> []rune = %v -> %v\n", s, c)		// string -> []rune = hello 世界 -> [104 101 108 108 111 32 19990 30028]
}

1.2 类型方法

1.2.1 自定义类型

自定义struct类型：

type xxx struct {Field1 type1Field2 type2
}

struct初始化：

• 按照字段顺序进行初始化；

type Person struct {name stringage int
}func main() {a := Person{"张三", 18}b := Person{"张三",18}c := Person{"张三",18,}
}

• 指定字段名进行初始化；

type Person struct {name stringage int
}func main() {a := Person{name: "张三", age: 18}b := Person{name: "张三",age: 18}c := Person{name: "张三",age: 18,}
}

• 使用new创建内置函数，字段默认初始化为其类型的零值，返回值是指向结构的指针；

type Person struct {name stringage int
}func main() {a := new(Person)
}

• 一次初始化一个字段；

type Person struct {name stringage int
}func main() {a := Person{}a.name = "张三"a.age = 18
}

• 使用构造函数进行初始化。

type Person struct {Name stringAge int
}func NewPerson(name string, age int) Person {return Person{Name: name,Age:  age,}
}func main() {a := NewPerson("张三", 18)fmt.Println(a)
}

结构字段的特点：

• 结构的字段可以是任意的类型；
• 结构字段的类型名必须唯一；
• 结构支持内嵌自身的指针，这也是实现树形和链表等复杂数据结构的基础。

1.2.2 方法

为命名类型定义方法的语法格式如下：

package maintype Person struct {name stringage int
}func NewPerson(name string, age int) Person {return Person{name: name,age:  age,}
}// 第一种写法
func (p *Person) SetName(name string) {p.name = name
}// 第二种写法
func GetAge(p Person) int {return p.age
}func main() {p := NewPerson("张三", 18)fmt.Println(p)				// {张三 18}p.SetName("张三1")fmt.Println(p)				// {张三1 18}fmt.Println(GetAge(p))		// 18
}

类型方法的特点：

• 可以为除了接口的命名类型增加方法，非命名类型不能自定义方法；
• 方法的定义必须和类型的定义在同一个包中；
• 前两条加起来相当于只能为自定义类型增加方法；
• 方法的命名空间的可见性和变量一样，大写开头的方法可以在包外被访问，否则只能在包内可见；
• 使用type定义的自定义类型是一个新类型，新类型不能调用原有类型的方法，但是底层类型支持的运算可以被新类型继承。

1.3 方法调用

1.3.1 一般调用

type T struct {a int
}func(t T) Get() int {return t.a
}func(t *T) Set(i int) {t.a = i
}func main() {t := &T{}t.Set(2)fmt.Println(t.Get())
}

1.3.2 方法值

如1.3.1中的代码，变量t的静态类型是T，Get和Set是T的方法，t.Get和t.Set就被称为方法值，是一个函数类型变量，可以赋值给其他变量，并向普通函数名一样使用。

f := t.Get
f()
// 等价于
t.Get()

1.3.3 方法表达式

如1.3.1中的代码，表达式T.Get和(*T).Set被称为方法表达式，可以看作是函数名，只不过这个函数的首个参数是接受者的实例或指针：

• T.Get的函数签名是func(t T) int；
• (*T).Set的函数签名是func(t *T, i int)。

t.Set(2)
// 等价
(*T).Set(t, 2)
// 等价
f1 := (*T).Set
f1(t, 2)fmt.Println(t.Get())
// 等价
fmt.Println(T.Get(*t))
// 等价
f2 := T.Get
fmt.Println(f2(*t))

1.3.4 方法集

如1.3.1中的代码，T类型的方法集是func (t T) Get()，*T类型的方法集是：func (t T) Get()和func (t *T) Set(i int)，直接使用类型实例调用类型的方法时，无论值类型变量还是指针类型变量，都可以调用类型的所有方法，原因是编译器在编译期间能够识别出这种调用关系，做了自动转换。

// 类型实例指针
//t := &T{}
// 类型实例
t := T{}t.Set(2)
// 等价
(&t).Set(2)fmt.Println(t.Get())
// 等价
fmt.Println((&t).Get())

1.3.5 值调用和表达式调用的方法集

• 通过类型字面量显式地进行值调用和表达式调用，编译器不会做自动转换，会进行严格的方法集检查；
• 通过类型变量使用值调用时编译器会进行自动转换，使用表达式调用时编译器不会进行转换，会进行严格的方法集检查。

1.4 组合

命名结构类型可以嵌套其他的命名类型的字段，这就是Go的组合（其实也可以叫继承，只是Go里面没有继承这个概念），struct类型中的字段成为内嵌字段：

• struct的字段访问使用点操作符，struct的字段可以嵌套很多层，只要内嵌的字段是唯一的即可，不需要使用全路径进行访问；

type A struct {a int
}type B struct {Ab int
}type C struct {Bc int
}func main() {a := A{a: 1}b := B{A: a, b: 2}c := C{B: b, c: 3}fmt.Println(c.c, c.b, c.B.b, c.a, c.A.a)
}

• struct的多层嵌套中，不同嵌套层次可以有相同的字段，此时最好使用完全路径进行访问和初始化；

type A struct {i int
}type B struct {Ai int
}type C struct {Bi int
}func main() {a := A{i: 1}b := B{A: a, i: 2}c := C{B: b, i: 3}fmt.Println(c.i, c.B.i, c.A.i)
}

• struct类型方法的调用也是用点操作符，不同嵌套层次的字段可以有相同的方法，外层变量调用内嵌字段的方法时也可以像嵌套字段的访问一样使用简化模式，如果外层字段和内层字段有相同的方法，则使用简化模式访问外层的方法会覆盖内层的方法，类似子类覆盖父类的同名方法。

type A struct {a int
}func (a A) print() {fmt.Println(a.a)
}type B struct {Ab int
}func (b B) print() {fmt.Println(b.b)
}type C struct {Bc int
}func (c C) print() {fmt.Println(c.c)
}func main() {a := A{a: 1}b := B{A: a, b: 2}c := C{B: b, c: 3}c.print()		// 3c.B.print()		// 2c.A.print()		// 1
}

1.5 函数类型

1.5.1 函数类型

函数类型分为两种：

• 函数字面量类型（未命名类型）：func(InputTypeList) OutputTypeList，无论是有名函数还是匿名函数的类型都属于函数字面量类型；
  • 有名函数：func FunctionName(input InputType)；
  • 匿名函数：func(input InputType)；
• 函数命名类型（简称函数类型）：type NewFuncType FuncLiteral。

1.5.2 函数签名

函数签名就是有名函数或匿名函数的字面量类型。

1.5.3 函数声明

// 函数签名
func(InputTypeList) OutputTypeList// 函数声明 = 函数名 + 函数签名
func FuncName(InputTypeList) OutputTypeList

1.5.4 函数类型的意义

// 定义一个有名函数类型HandlerFunc
type HandlerFunc func(ResponseWriter, *Request)// 为有名函数类型添加方法
// 这是一种包装器的编程技法
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {f(w, r)
}// 函数类型HandlerFunc实现了接口Handler的方法
type Handler interface {ServeHTTP(ResponseWriter, *Request)
}func (mux *ServeMux) Handle(pattern string, handler Handler) // 所以HandlerFunc类型的变量可以传递给Handler接口变量
func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {mux.Handle(pattern, HandlerFunc(handler))
}

• 函数也是一种类型，可以在函数字面量类型的基础上定义一种命名函数类型；
• 有名函数和匿名函数的函数签名与命名函数类型的底层类型相同，他们之间可以进行类型转换；
• 可以为有名函数类型添加方法，这种为一个函数类型添加方法的技法非常有价值，可以方便地为一个函数增加拦截或过滤等额外功能，这提供了一种装饰设计模式；
• 为有名函数类型添加方法，使其与接口打通关系，使用接口的地方可以传递函数类型的变量，这为函数到接口的转换开启了大门。

type Func func(a, b int) intfunc main() {// 函数作为值funcMap := map[string]Func{}f1 := func(a, b int) int {return a + b}funcMap["f1"] = f1fmt.Println(funcMap["f1"](1, 2))		// 3
}

type StudyFunc func(name string) stringfunc study(studyFunc StudyFunc, name string) {fmt.Println(studyFunc(name))
}func main() {// 函数作为参数study(func(name string) string {return "study " + name}, "math")		// study math
}

type StudyFunc func(name string) stringfunc (studyFunc StudyFunc) study(name string) {fmt.Println(studyFunc(name))
}func main() {// 为函数类型添加方法studyMath := StudyFunc(func(name string) string {return "study " + name})studyMath.study("math")		// study math
}