打开Go语言之门 入门、实战与进阶

前言　学习Go语言，抓住未来的机遇

**部分　快速入门Go语言

第1章　基础入门：Hello, Go语言 2

1.1　Hello，World 2

1.2　程序结构分析 3

1.3　搭建Go语言开发环境 4

1.3.1　在Windows下安装 4

1.3.2　在Linux下安装 4

1.3.3　在macOS下安装 4

1.3.4　安装测试 4

1.3.5　环境变量设置 5

1.4　项目结构 5

1.5　编译发布 6

1.6　跨平台编译 6

1.7　Go编辑器推荐 7

1.8　小结 8

第2章　数据类型：Go语言的基石 9

2.1　一个简单示例 9

2.2　基础类型 11

2.2.1　整型 11

2.2.2　浮点型 11

2.2.3　布尔型 12

2.2.4　字符串 12

2.2.5　零值 12

2.3　变量 13

2.3.1　变量简短声明 13

2.3.2　指针 13

2.3.3　赋值 13

2.4　常量 14

2.4.1　常量的定义 14

2.4.2　iota 14

2.5　字符串的使用 15

2.5.1　字符串和数字互转 15

2.5.2　strings包 16

2.6　小结 16

第3章　

控制结构：if、for、switch

　那些事儿 17

3.1　if条件语句 17

3.2　switch选择语句 19

3.3　for循环语句 20

3.4　小结 22

第4章　

集合类型：如何正确使用

　array、slice和map 23

4.1　数组 24

4.1.1　数组声明 24

4.1.2　数组循环 25

4.2　切片 25

4.2.1　基于数组生成切片 26

4.2.2　切片的修改 26

4.2.3　切片的声明 27

4.2.4　append函数 27

4.2.5　切片元素循环 28

4.3　映射 28

4.3.1　创建和初始化map 28

4.3.2　获取和删除map 29

4.3.3　遍历map 29

4.3.4　获取map的大小 30

4.4　string和[]byte 30

4.5　小结 31

第5章　

函数和方法：如何区分函数

　和方法 32

5.1　函数 33

5.1.1　函数初探 33

5.1.2　函数声明 33

5.1.3　多值返回 34

5.1.4　返回值命名 35

5.1.5　可变参数 36

5.1.6　包级函数 37

5.1.7　匿名函数和闭包 37

5.2　方法 39

5.2.1　不同于函数的方法 39

5.2.2　值和指针类型接收者 39

5.3　小结 40

第6章　

struct和interface：隐式的

　接口实现 42

6.1　结构体 43

6.1.1　结构体的定义 43

6.1.2　声明和使用 44

6.1.3　结构体的字段 44

6.2　接口 45

6.2.1　接口的定义 45

6.2.2　接口的实现 46

6.2.3　值和指针类型接收者 47

6.3　工厂函数 48

6.4　继承和组合 49

6.5　类型断言 50

6.6　小结 52

第7章　

错误处理：如何更优雅地

　处理程序异常和错误 53

7.1　错误 54

7.1.1　error接口 54

7.1.2　error工厂函数 55

7.1.3　自定义error 55

7.1.4　error断言 56

7.2　错误嵌套 56

7.2.1　Error Wrapping功能 56

7.2.2　errors.Unwrap函数 57

7.2.3　errors.Is函数 57

7.2.4　errors.As函数 58

7.3　defer函数 58

7.4　panic函数 59

7.5　recover函数 60

7.6　小结 60

第二部分　Go语言的高效并发

第8章　

goroutine和channel：

　并发的基础 62

8.1　什么是并发 63

8.2　进程和线程 63

8.2.1　进程 63

8.2.2　线程 64

8.3　协程 64

8.4　管道 65

8.4.1　声明一个管道 65

8.4.2　无缓冲管道 66

8.4.3　有缓冲管道 66

8.4.4　关闭管道 67

8.4.5　单向管道 67

8.5　select+channel示例 68

8.6　小结 69

第9章　

同步原语：让你对并发控制

　得心应手 70

9.1　资源竞争 70

9.2　同步原语 71

9.2.1　sync.Mutex 71

9.2.2　sync.RWMutex 72

9.2.3　sync.WaitGroup 73

9.2.4　sync.Once 75

9.2.5　sync.Cond 76

9.3　小结 77

第10章　

Context：多协程并发控制

　神器 79

10.1　协程如何退出 79

10.2　Context的使用示例 81

10.3　Context详解 82

10.4　Context树 83

10.5　使用Context取消多个协程 84

10.6　Context传值 85

10.7　Context使用原则 85

10.8　小结 86

第11章　

并发模式：拿来即用的

　经验总结 87

11.1　for select循环模式 87

11.2　select timeout模式 88

11.3　流水线模式 89

11.4　扇出和扇入模式 92

11.5　Future模式 94

11.6　小结 96

第12章　

并发技巧：高效并发

　安全的字节池 97

12.1　字节切片 97

12.2　高效字节池 98

12.3　使用BytePoolCap 99

12.4　

BytePoolCap与sync.Pool的

　对比 99

12.5　小结 101

第三部分　深入理解Go语言

第13章　

指针详解：什么情况下

　应该使用指针 104

13.1　什么是指针 104

13.2　指针的声明和定义 105

13.3　指针的操作 107

13.4　指针参数 107

13.5　指针接收者 108

13.6　什么情况下使用指针 108

13.7　小结 109

第14章　

参数传递：值、引用以及

　指针的区别 110

14.1　修改参数 111

14.2　值类型 112

14.3　指针类型 113

14.4　引用类型 114

14.4.1　map 114

14.4.2　chan 116

14.5　类型的零值 116

14.6　小结 117

第15章　

内存分配：new和make

　该如何选择 118

15.1　变量 118

15.1.1　变量的声明 119

15.1.2　变量的赋值 119

15.2　new函数 120

15.3　变量初始化 121

15.3.1　指针变量初始化 122

15.3.2　make 函数 123

15.4　小结 124

第16章　

运行时反射：字符串和

　结构体之间如何转换 125

16.1　什么是反射 125

16.2　获取对象的值和类型 126

16.3　reflect.Value 126

16.3.1　结构体定义 126

16.3.2　获取原始类型 128

16.3.3　修改对应的值 128

16.3.4　获取对应的底层类型 129

16.4　reflect.Type 130

16.4.1　接口定义 130

16.4.2　遍历结构体的字段和方法 131

16.4.3　是否实现某接口 132

16.5　字符串和结构体的互转 133

16.5.1　JSON和struct互转 133

16.5.2　struct tag功能 134

16.5.3　struct转JSON的示例 135

16.6　反射定律 136

16.7　小结 137

第17章　

非类型安全：不安全但

　高效的unsafe 138

17.1　指针类型转换 139

17.2　unsafe.Pointer 139

17.3　uintptr 指针类型 140

17.4　指针转换规则 142

17.5　unsafe.Sizeof 142

17.6　小结 143

第18章　

零拷贝：slice为何如此

　高效 144

18.1　数组 144

18.2　slice 145

18.2.1　动态扩容 145

18.2.2　数据结构 146

18.2.3　高效的原因 148

18.2.4　string 和 []byte 互转 149

18.3　小结 151

第19章　

实战：字符串如何高效

　拼接 152

19.1　一个例子 152

19.2　几种拼接方式 153

19.2.1　“+”拼接 153

19.2.2　fmt 拼接 153

19.2.3　join 拼接 154

19.2.4　buffer 拼接 154

19.2.5　builder拼接 155

19.3　性能对比 155

19.4　拼接函数改造 156

19.5　再次进行性能测试 157

19.5.1　10个字符串 157

19.5.2　100个字符串 160

19.5.3　1000个字符串 161

19.6　builder拼接慢在哪里 161

19.7　内存分配优化 162

19.8　小结 163

第四部分　Go语言工程管理

第20章　测试：质量保证的基石 166

20.1　单元测试 166

20.1.1　什么是单元测试 166

20.1.2　Go 语言的单元测试 167

20.1.3　单元测试覆盖率 169

20.2　基准测试 170

20.2.1　什么是基准测试 170

20.2.2　Go 语言的基准测试 170

20.2.3　计时方法 171

20.2.4　内存统计 172

20.2.5　并发基准测试 172

20.2.6　基准测试实战 173

20.3　小结 174

第21章　

性能优化：如何写出

　高质量的代码 175

21.1　代码规范检查 175

21.1.1　什么是代码规范检查 175

21.1.2　golangci-lint的安装和使用 176

21.1.3　golangci-lint的配置 177

21.1.4　集成 golangci-lint 到 CI 179

21.2　性能优化 179

21.2.1　堆或栈分配 179

21.2.2　逃逸分析 180

21.2.3　优化技巧 182

21.3　小结 183

第22章　协作开发：模块化管理 184

22.1　Go语言中的包 184

22.1.1　什么是包 184

22.1.2　使用包 185

22.1.3　作用域 185

22.1.4　自定义包 185

22.1.5　init 函数 186

22.2　Go 语言中的模块 186

22.2.1　go mod 186

22.2.2　使用第三方模块 187

22.3　小结 188

第五部分　Go语言泛型

第23章　

初识泛型：使用泛型简化

　编程 192

23.1　一个非泛型示例 192

23.2　使用泛型重构示例 193

23.3　类型推导 194

23.4　自定义类型约束 194

23.5　内置的类型约束 195

23.5.1　Signed 196

23.5.2　Unsigned 196

23.5.3　Integer 196

23.5.4　Float 196

23.5.5　Ordered 196

23.6　函数式编程 197

23.6.1　map 197

23.6.2　reduce 199

23.6.3　filter 200

23.7　小结 201

第24章　

深入泛型：漫谈泛型

　设计 202

24.1　为什么需要泛型 202

24.2　类型参数 203

24.3　泛型类型 204

24.4　类型约束 205

24.4.1　any约束 206

24.4.2　类型集 206

24.5　再论类型推导 209

24.5.1　参数类型推导 209

24.5.2　约束类型推导 210

24.6　小结 211

结束语　你的Go语言成长之路 212