《打开Go语言之门：入门、实战与进阶》资深Go专家从基础知识、底层原理、工程实践3个维度带你快速掌握Go语言编程方法与技

通过不断思考和整理，作者编写了这本更具系统性也更通俗易懂的Go语言入门和进阶书籍，以帮助学习者少走弯路，比其他人更快一步提升职业竞争力。<br /><br />本书共包含5个部分。<br /><br />第1部分：快速入门Go语言。作者挑选了变量、常量、基础数据类型、函数和方法、结构体和接口等知识点进行介绍。这部分内容相对简洁，但已经足够让你掌握Go的基本程序结构了。<br /><br />第2部分：Go语言的高效并发。这部分主要介绍goroutine、channel、同步原语等知识，让你对Go语言层面的并发支持有更深入的理解，并且可以编写自己的Go语言并发程序。这个部分*后一章专门介绍常用的并发模式，可以拿来即用，以更好地控制并发。<br /><br />第3部分：深入理解Go语言。这部分讲解Go 语言底层原理和高级功能，比如slice的底层是怎样的、为什么这么高效等。这部分内容也是作者特意设计的，跟着作者一起研究底层原理，可避免初学者不求甚解的通病。总之，只有理解了底层原理，你才能更灵活地编写程序并高效地应对问题。<br /><br />第4部分：Go语言工程管理。学习一门语言，不仅要掌握它本身的知识，还要掌握模块管理、性能优化等周边技能，因为这些技能可以帮助你更好地进行多人协作，提高开发效率，写出更高质量的代码。你可以在这部分学到如何测试Go语言代码以提高代码质量、如何做好性能优化、如何使用第三方库来提高自己项目的开发效率等。<br /><br />第5部分：Go语言泛型。这是Go语言在1.18版本中新增的特性，也是大家期待已久的特性。在这一部分作者会带你学习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  ref lect.Value 126
16.3.1  结构体定义 126
16.3.2  获取原始类型 128
16.3.3  修改对应的值 128
16.3.4  获取对应的底层类型 129
16.4  ref lect.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  f ilter 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