自定义类型#
Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型， 使用type关键字来定义自定义类型。
自定义类型是定义了一个全新的类型。可以基于内置的基本类型定义，也可以通过 struct 定义。例如：
// 将MyInt定义为int类型
type MyInt int通过 type 关键字的定义，MyInt 就是一种新的类型，具有 int 的特性。
类型别名#
类型别名是Go1.9版本添加的新功能。类型别名规定：TypeAlias 只是Type的别名，本质上TypeAlias与Type是同一个类型。
type TypeAlias = Type之前见过的rune和byte就是类型别名，定义如下：
type byte = uint8
type rune = int32自定义类型/类型别名区别#
类型别名与类型定义表面上看只有一个等号的差异，通过下面的这段代码来理解它们之间的区别：
// 类型定义
type NewInt int
// 类型别名
type MyInt = int
func main() {
var a NewInt
var b MyInt
fmt.Printf("type of a:%T\n", a) // type of a:main.NewInt
fmt.Printf("type of b:%T\n", b) // type of b:int
}结果显示a的类型是 main.NewInt，表示main包下定义的NewInt类型。b的类型是int。MyInt类型只会在代码中存在，编译完成时并不会有MyInt类型。
结构定义#
Go语言的结构体（struct）和其他语言的类（class）有同等的地位，但Go语言放弃了大量面向对象特性，只保留了组合（composition）这个最基础的特性。Go语言中可以通过 struct 来实现面向对象。
使用 type 和 struct 关键字来定义结构体，具体代码格式如下：
type 类型名 struct {
字段名 字段类型
字段名 字段类型
…
}其中：
- 类型名：标识自定义结构体的名称。在同一个包内不能重复
- 字段名：表示结构体字段名。结构体中的字段名必须唯一
- 字段类型：表示结构体字段的具体类型
比如：定义一个表示矩形的结构
type Rect struct {
width float64
height float64
}同样类型的字段也可以写在一行，看起来更简洁
type Rect struct {
width, height float64
}语言内置的基础数据类型是用来描述一个值的，而结构体是用来描述一组值的。本质上是一种聚合型的数据类型。
结构实例化#
最简单的实例化方式：
var rect Rect
fmt.Printf("%p %T \n", &rect, rect)
rect.height = 13.4
rect.width = 21.
fmt.Printf("%p %T \n", &rect, rect)
fmt.Println(rect.height, rect.width)0xc0000120a0 main.Rect
0xc0000120a0 main.Rect
13.4 21因为结构是值类型，所以定义结构体类型变量就会分配内存，如果不给结构体中的字段赋值，默认就会是该类型的零值。而后可以通过.来访问结构体的字段
创建指针类型结构：
通过使用 new 关键字对结构体进行实例化，得到的是结构体的内存地址。
var rect = new(Rect)
// Go语言中支持对结构体指针直接使用.来访问结构体的成员
rect.height = 13.4
rect.width = 21.4
// 这里因为使用new()返回的已经是指针类型,所以打印输出时不需要加&取址
fmt.Printf("%T %p\n", rect, rect)*main.Rect 0xc0000aa070使用结构体的地址实例化：
使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。
var rect = &Rect{}
rect.height = 13.4
rect.width = 21.4
fmt.Printf("%T %p\n", rect, rect)结构初始化#
默认：没有初始化的结构体，其成员变量都是对应其类型的零值。
var rect Rect
fmt.Printf("%#v \n", rect)main.Rect{width:0, height:0}使用键值对初始化：
使用键值对初始化时，键对应结构体的字段，值对应该字段的初始值。
rect := Rect{width: 10.5, height: 3.5}
fmt.Printf("%#v \n", rect)也可以对结构体指针进行键值对初始化，比如：
// 对结构体指针进行键值初始化
rect2 := &Rect{width: 10.5, height: 3.5}
fmt.Printf("%#v \n", rect2)如果字段没有初始值,可以省略，那么被省略的值就是该字段的零值。
// 如果字段没有初始值,可以省略,那么被省略的值就是该字段的零值
rect3 := Rect{width: 100.0}
fmt.Printf("%#v \n", rect3) 使用值的列表初始化：
初始化结构体的时候可以简写，也就是初始化的时候不写键，直接写值：
rect := Rect{10.5, 3.5}
fmt.Printf("%#v \n", rect)
rect2 := &Rect{10.5, 3.5}
fmt.Printf("%#v \n", rect2)使用这种格式初始化时，需要注意：
- 必须初始化结构体的所有字段
- 初始值的填充顺序必须与字段在结构体中的声明顺序一致
- 该方式不能和键值初始化方式混用
匿名结构体#
在定义一些临时数据结构等场景下可以使用匿名结构体。
// 匿名结构体
var user struct {
name string
age int
}
user.name = "wangpengliang"
user.age = 18
fmt.Printf("%v \n", user)空结构体#
空结构体不占用内存空间。
var a struct{}
fmt.Println(unsafe.Sizeof(a)) // 0结构体内存布局#
结构体占用一块连续的内存。
TODO：在 Go 中恰到好处的内存对齐
构造函数#
Go语言的结构体没有构造函数，可以自己实现。 因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以构造函数返回的是结构体指针类型。
// 如果不初始化,字段值为类型零值
type Person struct {
name string
age int
address string
hobby []string
}// 第一种方式,使用指定值初始化结构体,返回指针类型
func NewPerson(name, address string, age int, hobby []string) *Person {
instance := new(Person)
instance.name = name
instance.address = address
instance.age = age
instance.hobby = hobby
return instance
}
// 第二种方式,使用&初始化结构体,返回指针类型
func NewPerson2(name, address string, age int) *Person {
return &Person{
name: name,
address: address,
age: age,
}
}Go中不支持函数重载，但是可以通过两个名称不同的构造函数来模拟实现构造函数重载。
a := NewPerson("wangpengliang", "beijing", 18, []string{"java", "go"})
fmt.Println(a)
b := NewPerson2("wangpengliang", "beijing", 18)
fmt.Println(b) 方法和接收者#
Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}其中：
- 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是
self、this之类的命名。例如，Person类型的接收者变量应该命名为p，Connector类型的接收者变量应该命名为c等 - 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型
- 方法名、参数列表、返回参数：具体格式与函数定义相同
简单理解：因为Go语言中没有Class的概念，所以不存在实例化一个类调用其中某个方法这种做法，Go语言中的方法其实就是给指定结构添加方法。比如：
// 给结构体Person定义方法,所谓方法在go中就是定义了接受者的函数
func (p Person) say1() {
fmt.Printf("name: %s,age：%d \n", p.name, p.age)
}
func (p Person) addAge1() {
p.age = p.age + 1
}方法与函数的区别在于：函数不属于任何类型，方法属于特定的类型。
值类型的接收者#
当方法作用于值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，但修改操作只是针对副本，无法修改接收者变量本身。比如：
// 给结构体Person定义方法,所谓方法在go中就是定义了接受者的函数
func (p Person) say1() {
fmt.Printf("name: %s,age：%d \n", p.name, p.age)
}
func (p Person) addAge1() {
p.age = p.age + 1
} var p1 Person = Person{"zhansan", 16, "beijing", []string{}}
p1.addAge1()
p1.say1()
var p2 *Person = &Person{"lisi", 16, "shanghai", []string{}}
p2.addAge1()
p2.say1()name: zhansan,age：16
name: lisi,age：16 指针类型的接收者#
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
func (p *Person) say2() {
fmt.Printf("name: %s,age：%d \n", p.name, p.age)
}
func (p *Person) addAge2() {
p.age = p.age + 1
} var p3 Person = Person{"zhansan", 16, "beijing", []string{}}
p3.addAge2()
p3.say2()
var p4 *Person = &Person{"lisi", 16, "beijing", []string{}}
p4.addAge2()
p4.say2()name: zhansan,age：17
name: lisi,age：17 什么时候使用指针类型接收?
- 需要修改接收者中的值
- 接收者是拷贝代价比较大的大对象
- 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。
任意类型添加方法#
Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。比如：基于内置的int类型使用 type 关键字可以定义新的自定义类型，然后为自定义类型添加方法。
// MyInt 将int定义为自定义MyInt类型
type MyInt int
// SayHello 为MyInt添加一个SayHello的方法
func (m MyInt) SayHello() {
fmt.Println("Hello, 我是一个int。")
}
func main() {
var m1 MyInt
m1.SayHello() //Hello, 我是一个int。
m1 = 100
fmt.Printf("%#v %T\n", m1, m1) //100 main.MyInt
}注意事项： 非本地类型不能定义方法，不能给别的包的类型定义方法。
结构体的匿名字段#
结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。
// 匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个
type Book struct {
string
float64
}
func main() {
book := Book{
"go语言编程",
100.00,
}
fmt.Printf("%#v\n", book) // main.Book{string:"go语言编程", float64:100}
fmt.Println(book.string, book.float64) //北京 go语言编程 100
}注意：这里匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。
嵌套结构体#
一个结构体中可以嵌套包含另一个结构体或结构体指针，比如：
// 地址结构体
type Address struct {
Province string
City string
}
// 用户结构体
type User struct {
Name string
Gender string
Address Address
}
func main() {
user := User{
Name: "wangpengliang",
Gender: "男",
Address: Address{
Province: "山西",
City: "长治",
},
}
fmt.Printf("user=%#v\n", user)
}user=main.User{Name:"wangpengliang", Gender:"男", Address:main.Address{Province:"山西", City:"长治"}}嵌套匿名字段#
上面user结构体中嵌套的Address结构体也可以采用匿名字段的方式，匿名字段默认使用类型名作为字段名。比如：
// 地址结构体
type Address struct {
province string
city string
}
// 用户结构体
type User struct {
name string
gender string
address Address // 该字段为具名字段
Address // 嵌套的Address结构体也可以采用匿名字段的方式
}
func main() {
user := User{
name: "wangpengliang",
gender: "男",
address: Address{
province: "山西",
city: "长治",
},
Address: Address{
province: "北京",
city: "北京",
},
}
fmt.Printf("user=%#v\n", user)
}user=main.User{name:"wangpengliang", gender:"男", address:main.Address{province:"山西", city:"长治"}, Address:main.Address{province:"北京", city:"北京"}}当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找。
嵌套结构体字段名冲突#
嵌套结构体内部可能存在相同的字段名。这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。
// 地址结构体
type Address struct {
province string
city string
createTime string
}
// 邮箱结构体
type Email struct {
account string
createTime string
}
// 用户结构体
type User struct {
name string
gender string
address Address // 该字段为具名字段
Address // 嵌套的Address结构体也可以采用匿名字段的方式
Email
}
func main() {
// 具名字段赋值
user := User{
name: "wangpengliang",
gender: "男",
address: Address{
province: "山西",
city: "长治",
},
}
fmt.Printf("user=%#v\n", user)
// 匿名字段
user1 := User{
name: "wangpengliang",
gender: "男",
Address: Address{
province: "山西",
city: "长治",
},
}
fmt.Printf("user1=%#v\n", user1)
var user2 User
user2.name = "wangpengliang"
user2.gender = "男"
// user2.createTime = "2019" //ambiguous selector user2.createTime
user2.Address.createTime = "2000" //指定Address结构体中的createTime
user2.Email.createTime = "2000" //指定Email结构体中的createTime
}user=main.User{name:"wangpengliang", gender:"男", address:main.Address{province:"山西", city:"长治", createTime:""}, Address:main.Address{province:"", city:"", createTime:""}, Email:main.Email{account:"", createTime:""}}
user=main.User{name:"wangpengliang", gender:"男", address:main.Address{province:"", city:"", createTime:""}, Address:main.Address{province:"山西", city:"长治", createTime:""}, Email:main.Email{account:"", createTime:""}}结构体字段可见性#
结构体中字段大写开头表示可公开访问，小写表示私有（仅在定义当前结构体的包中可访问）。
结构体与JSON序列化#
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。
// Student
type Student struct {
ID int
Gender string
Name string
}
// Class
type Class struct {
Title string
Students []*Student
}
func jsonSerializeTest() {
c := &Class{
Title: "101",
Students: make([]*Student, 0, 200),
}
for i := 0; i < 10; i++ {
stu := &Student{
Name: fmt.Sprintf("stu%02d", i),
Gender: "男",
ID: i,
}
c.Students = append(c.Students, stu)
}
// JSON序列化：结构体-->JSON格式的字符串
data, err := json.Marshal(c)
if err != nil {
fmt.Println("json marshal failed")
return
}
fmt.Printf("json:%s\n", data)
//JSON反序列化：JSON格式的字符串-->结构体
str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
c1 := &Class{}
err = json.Unmarshal([]byte(str), c1)
if err != nil {
fmt.Println("json unmarshal failed!")
return
}
fmt.Printf("%#v\n", c1)
}结构体标签（Tag）#
Tag是结构体的元信息，可以在运行时通过反射读取出来。 Tag在结构体字段的后方定义，由一对反引号包裹起来，格式如下：
`key1:"value1" key2:"value2"`结构体tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。
注意事项： 为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差，一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。
Go 中标签最常见的用途比如 marshalling。看一下来自 JSON 包的函数 Marshal 如何使用它（源代码）：
import (
"encoding/json"
"fmt"
)
func main() {
type T struct {
F1 int `json:"f_1"`
F2 int `json:"f_2,omitempty"`
F3 int `json:"f_3,omitempty"`
F4 int `json:"-"`
}
t := T{1, 0, 2, 3}
b, err := JSON.Marshal(t)
if err != nil {
panic(err)
}
fmt.Printf("%s\n", b) // {"f_1":1,"f_3":2}
}xml 包也利用了标签 - https://golang.org/pkg/encoding/xml/#MarshalIndent.
ORM
像 GORM 这样的对象关系映射工具，也广泛使用标签 - 例子.
摘要数据（Digesting forms data）
https://godoc.org/github.com/gorilla/schema
其他（Other）
标签的更多潜在用例，如配置管理，结构的默认值，验证，命令行参数描述等（众所周知的结构标记列表）。
练习题一#
func exercises01Test() {
make := make(map[int]*int)
slice := []int{0, 1, 2, 3}
for index, value := range slice {
make[index] = &value
}
for k, v := range make {
fmt.Println(k, "=>", *v)
}
}输出：
0 => 3
1 => 3
2 => 3
3 => 3思考：这里输出map的value为什么都是3?
调整代码：输出指针地址
for index, value := range slice {
fmt.Printf("%p \n", &value)
make[index] = &value
}0xc000012088
0xc000012088
0xc000012088
0xc000012088 这里其实就可以看出来了，&stu 指向了同一个内存地址，当遍历到最后一个元素时，将3写入了该地址。导致映射所有值都相同。for range 创建了每个元素的副本，而不是直接返回每个元素的引用，如果使用该值变量的地址作为指向每个元素的指针，就会导致错误，迭代时返回的变量是一个迭代过程中根据切片依次赋值的新变量，所以值的地址总是相同的，导致结果不如预期。
修改代码：
func exercises02Test() {
make := make(map[int]*int)
slice := []int{0, 1, 2, 3}
for index, value := range slice {
// 循环中使用新的变量接收
item := value
fmt.Printf("%p \n", &item)
make[index] = &item
}
for k, v := range make {
fmt.Println(k, "=>", *v)
}
}0xc000012088
0xc0000120c0
0xc0000120c8
0xc0000120d0
3 => 3
0 => 0
1 => 1
2 => 2这个问题很像C#学习委托时遇到的闭包问题。上面问题还可以使用传统的 for 循环处理：
func exercises03Test() {
make := make(map[int]*int)
slice := []int{0, 1, 2, 3}
for i := 0; i < len(slice); i++ {
make[i] = &slice[i]
}
for k, v := range make {
fmt.Println(k, "=>", *v)
}
}0xc0000101e0
0xc0000101e8
0xc0000101f0
0xc0000101f8
0 => 0
1 => 1
2 => 2
3 => 3 练习题二#
因为 slice 和 map 这两种数据类型都包含了指向底层数据的指针，因此在需要复制它们时要特别注意。来看下面的例子：
type Test struct {
name string
age int8
dreams []string
}
func (t *Test) setDreams(dreams []string) {
t.dreams = dreams
}
func exercises02Test() {
t := Test{name: "wangpengliang", age: 18}
data := []string{"吃饭", "睡觉", "搞钱"}
t.setDreams(data)
// 真的想修改t.dreams吗？
data[1] = "不睡觉"
fmt.Println(t.dreams) //
}[吃饭 不睡觉 搞钱]这里因为 slice 和 map 这两种数据类型都包含了指向底层数据的指针所以修改了 slice 导致结构体内容也被修改，正确做法应该是：方法中使用传入的slice的拷贝进行结构体赋值。
func (t *Test) setDreams(dreams []string) {
t.dreams = make([]string, len(dreams))
copy(t.dreams, dreams)
} t := Test{name: "wangpengliang", age: 18}
data := []string{"吃饭", "睡觉", "搞钱"}
t.setDreams(data)
data[1] = "不睡觉"
fmt.Println(t.dreams) [吃饭 睡觉 搞钱]