[套装书]Go语言精进之路：从新手到高手的编程思想、方法和技巧 1+Go语言精进之路：从新手到高手的编程思想、方法和技巧 2（2册）

. （7）错误处理
（8）测试、性能剖析与调试
（9）标准库、反射与cgo
（10）工具链与工程实践
学完这本书，你将拥有和 Go专家一样的编程思维，写出符合Go惯例和风格的高质量代码，从众多 Go 初学者中脱颖而出，快速实现从Go新手到专家的转变！


---------------------------8085127 - Go语言精进之路：从新手到高手的编程思想、方法和技巧 2---------------------------


内容简介
Go入门容易，精进难，如何才能像Go开发团队那样写出符合Go思维和语言惯例的高质量代码呢？
本书将从编程思维和实践技巧2个维度给出答案，帮助你在Go进阶的路上事半功倍。
编程思维层面
只有真正领悟了一门语言的设计哲学和编程思维，并能将之用于实践，才算精通了这门语言。本书从Go语言设计者的视角对Go背后的设计哲学和编程思想进行了梳理和分析，指引读者体会那些看似随意实则经过深思熟虑的设计背后的秘密。
实践技巧层面
实践技巧源于对Go开发团队和Go社区开发的高质量代码的阅读、挖掘和归纳，从项目结构、代码风格、语法及其实现、接口、并发、同步、错误与异常处理、测试与调试、性能优化、标准库、第三方库、工具链、Z佳实践、工程实践等多个方面给出了改善Go代码质量、写出符合 Go 思维和惯例的代码的有效实践。
全书的内容覆盖如下10个大类，共66个主题，字字珠玑，句句箴言。
（1）Go语言的一切
（2）项目结构、代码风格与标识符命名
（3）声明、类型、语句与控制结构
（4）函数与方法
（5）接口
（6）并发编程
（7）错误处理
（8）测试、性能剖析与调试
（9）标准库、反射与cgo
（10）工具链与工程实践
学完这本书，你将拥有和 Go专家一样的编程思维，写出符合Go惯例和风格的高质量代码，从众多 Go 初学者中脱颖而出，快速实现从Go新手到专家的转变！

第3条　理解Go语言的设计哲学12
3.1　追求简单，少即是多12
3.2　偏好组合，正交解耦15
3.3　原生并发，轻量高效17
3.4　面向工程，“自带电池”21
第4条　使用Go语言原生编程思维来写Go代码26
4.1　语言与思维—来自大师的观点26
4.2　现实中的“投影”27
4.3　Go语言原生编程思维29
第二部分　项目结构、代码风格与标识符命名
第5条　使用得到公认且广泛使用的项目结构32
5.1　Go项目的项目结构32
5.2　Go语言典型项目结构35
第6条　提交前使用gofmt格式化源码40
6.1　gofmt：Go语言在解决规模化问题上的最佳实践40
6.2　使用gofmt41
6.3　使用goimports43
6.4　将gofmt/goimports与IDE或编辑器工具集成44
第7条　使用Go命名惯例对标识符进行命名47
7.1　简单且一致48
7.2　利用上下文环境，让最短的名字携带足够多的信息53
第三部分　声明、类型、语句与
控制结构
第8条　使用一致的变量声明形式56
8.1　包级变量的声明形式56
8.2　局部变量的声明形式59
第9条　使用无类型常量简化代码63
9.1　Go常量溯源63
9.2　有类型常量带来的烦恼64
9.3　无类型常量消除烦恼，简化代码65
第10条　使用iota实现枚举常量68
第11条　尽量定义零值可用的类型73
11.1　Go类型的零值73
11.2　零值可用75
第12条　使用复合字面值作为初值构造器78
12.1　结构体复合字面值79
12.2　数组/切片复合字面值80
12.3　map复合字面值81
第13条　了解切片实现原理并高效使用83
13.1　切片究竟是什么83
13.2　切片的高级特性：动态扩容87
13.3　尽量使用cap参数创建切片90
第14条　了解map实现原理并高效使用92
14.1　什么是map92
14.2　map的基本操作93
14.3　map的内部实现97
14.4　尽量使用cap参数创建map103
第15条　了解string实现原理并高效使用105
15.1　Go语言的字符串类型105
15.2　字符串的内部表示110
15.3　字符串的高效构造112
15.4　字符串相关的高效转换115
第16条　理解Go语言的包导入120
16.1　Go程序构建过程121
16.2　究竟是路径名还是包名127
16.3　包名冲突问题130
第17条　理解Go语言表达式的求值顺序132
17.1　包级别变量声明语句中的表达式求值顺序133
17.2　普通求值顺序136
17.3　赋值语句的求值139
17.4　switch/select语句中的表达式求值140
第18条　理解Go语言代码块与作用域143
18.1　Go代码块与作用域简介143
18.2　if条件控制语句的代码块145
18.3　其他控制语句的代码块规则简介148
第19条　了解Go语言控制语句惯用法及使用注意事项154
19.1　使用if控制语句时应遵循“快乐路径”原则154
19.2　for range的避“坑”指南156
19.3　break跳到哪里去了165
19.4　尽量用case表达式列表替代fallthrough167
第四部分　函数与方法
第20条　在init函数中检查包级变量的初始状态170
20.1　认识init函数170
20.2　程序初始化顺序171
20.3　使用init函数检查包级变量的初始状态174
第21条　让自己习惯于函数是“一等公民”179
21.1　什么是“一等公民”179
21.2　函数作为“一等公民”的特殊运用183
第22条　使用defer让函数更简洁、更健壮192
22.1　defer的运作机制193
22.2　defer的常见用法194
22.3　关于defer的几个关键问题199
第23条　理解方法的本质以选择
正确的receiver类型206
23.1　方法的本质207
23.2　选择正确的receiver类型208
23.3　基于对Go方法本质的理解巧解难题210
第24条　方法集合决定接口实现214
24.1　方法集合215
24.2　类型嵌入与方法集合216
24.3　defined类型的方法集合226
24.4　类型别名的方法集合227
第25条　了解变长参数函数的妙用230
25.1　什么是变长参数函数230
25.2　模拟函数重载233
25.3　模拟实现函数的可选参数与默认参数236
25.4　实现功能选项模式238
第五部分　接口
第26条　了解接口类型变量的内部表示246
26.1　nil error值 != nil247
26.2　接口类型变量的内部表示248
26.3　输出接口类型变量内部表示的详细信息254
26.4　接口类型的装箱原理258
第27条　尽量定义小接口263
27.1　Go推荐定义小接口263
27.2　小接口的优势265
27.3　定义小接口可以遵循的一些点267
第28条　尽量避免使用空接口作为函数参数类型270
第29条　使用接口作为程序水平组合的连接点274
29.1　一切皆组合274
29.2　垂直组合回顾275
29.3　以接口为连接点的水平组合276
第30条　使用接口提高代码的可测试性281
30.1　实现一个附加免责声明的电子邮件发送函数282
30.2　使用接口来降低耦合283
第六部分　并发编程
第31条　优先考虑并发设计288
31.1　并发与并行288
31.2　Go并发设计实例290
第32条　了解goroutine的调度原理299
32.1　goroutine调度器299
32.2　goroutine调度模型与演进过程300
32.3　对goroutine调度器原理的进一步理解302
32.4　调度器状态的查看方法305
32.5　goroutine调度实例简要分析307
第33条　掌握Go并发模型和常见并发模式315
33.1　Go并发模型315
33.2　Go常见的并发模式317
第34条　了解channel的妙用340
34.1　无缓冲channel341
34.2　带缓冲channel347
34.3　nil channel的妙用354
34.4　与select结合使用的一些惯用法357
第35条　了解sync包的正确用法359
35.1　sync包还是channel359
35.2　使用sync包的注意事项360
35.3　互斥锁还是读写锁362
35.4　条件变量365
35.5　使用sync.Once实现单例模式 368
35.6　使用sync.Pool减轻垃圾回收压力370
第36条　使用atomic包实现伸缩性更好的并发读取374
36.1　atomic包与原子操作374
36.2　对共享整型变量的无锁读写375
36.3　对共享自定义类型变量的无锁读写377
第七部分　错误处理
第37条　了解错误处理的4种策略382
37.1　构造错误值383
37.2　透明错误处理策略385
37.3　“哨兵”错误处理策略385
37.4　错误值类型检视策略388
37.5　错误行为特征检视策略390
第38条　尽量优化反复出现的if err != nil392
38.1　两种观点393
38.2　尽量优化395
38.3　优化思路395
第39条　不要使用panic进行正常的错误处理405
39.1　Go的panic不是Java的checked exception405
39.2　panic的典型应用408
39.3　理解panic的输出信息412
（以上为本书内容，以下为第2册内容。）
第八部分　测试、性能剖析与调试
第40条　理解包内测试与包外测试的差别
40.1　官方文档的“自相矛盾”
40.2　包内测试与包外测试
第41条　有层次地组织测试代码
41.1　经典模式—平铺
41.2　xUnit家族模式
41.3　测试固件
第42条　优先编写表驱动的测试
42.1　Go测试代码的一般逻辑
42.2　表驱动的测试实践
42.3　表驱动测试的优点
42.4　表驱动测试实践中的注意事项
第43条　使用testdata管理测试依赖的外部数据文件
43.1　testdata目录
43.2　golden文件惯用法
第44条　正确运用fake、stub和mock等辅助单元测试
44.1　fake：真实组件或服务的简化实现版替身
44.2　stub：对返回结果有一定预设控制能力的替身
44.3　mock：专用于行为观察和验证的替身
第45条　使用模糊测试让潜在bug无处遁形
45.1　模糊测试在挖掘Go代码的潜在bug中的作用
45.2　go-fuzz的初步工作原理
45.3　go-fuzz使用方法
45.4　使用go-fuzz建立模糊测试的示例
45.5　让模糊测试成为“一等公民”
第46条　为被测对象建立性能基准
46.1　性能基准测试在Go语言中是“一等公民”
46.2　顺序执行和并行执行的性能基准测试
46.3　使用性能基准比较工具
46.4　排除额外干扰，让基准测试更精确
第47条　使用pprof对程序进行性能剖析
47.1　pprof的工作原理
47.2　使用pprof进行性能剖析的实例
第48条　使用expvar输出度量数据，辅助定位性能瓶颈点
48.1　expvar包的工作原理
48.2　自定义应用通过expvar输出的度量数据
48.3　输出数据的展示
第49条　使用Delve调试Go代码
49.1　关于调试，你首先应该知道的几件事
49.2　Go调试工具的选择
49.3　Delve调试基础、原理与架构
49.4　并发、Coredump文件与挂接进程调试
第九部分　标准库、反射与cgo
第50条　理解Go TCP Socket网络编程模型
50.1　TCP Socket网络编程模型
50.2　TCP连接的建立
50.3　Socket读写
50.4　Socket属性
50.5　关闭连接
第51条　使用net/http包实现安全通信
51.1　HTTPS：在安全传输层上运行的HTTP协议
51.2　HTTPS安全传输层的工作机制
51.3　非对称加密和公钥证书
51.4　对服务端公钥证书的校验
51.5　对客户端公钥证书的校验
第52条　掌握字符集的原理和字符 编码方案间的转换
52.1　字符与字符集
52.2　Unicode字符集的诞生与UTF-8编码方案
52.3　字符编码方案间的转换
第53条　掌握使用time包的正确方式
53.1　时间的基础操作
53.2　时间的格式化输出
53.3　定时器的使用
第54条　不要忽略对系统信号的处理
54.1　为什么不能忽略对系统信号的处理
54.2　Go语言对系统信号处理的支持
54.3　使用系统信号实现程序的优雅退出
第55条　使用crypto下的密码学包构建安全应用
55.1　Go密码学包概览与设计原则
55.2　分组密码算法
55.3　公钥密码
55.4　单向散列函数
55.5　消息认证码
55.6　数字签名
55.7　随机数生成
第56条　掌握bytes包和strings包的基本操作
56.1　查找与替换
56.2　比较
56.3　分割
56.4　拼接
56.5　修剪与变换
56.6　快速对接I/O模型
第57条　理解标准库的读写模型
57.1　直接读写字节序列
57.2　直接读写抽象数据类型实例
57.3　通过包裹类型读写数据
第58条　掌握unsafe包的安全使用模式
58.1　简洁的unsafe包
58.2　unsafe包的典型应用
58.3　正确理解unsafe.Pointer与uintptr
58.4　unsafe.Pointer的安全使用模式
第59条　谨慎使用reflect包提供的反射能力
59.1　Go反射的三大法则
59.2　反射世界的入口
59.3　反射世界的出口
59.4　输出参数、interface{}类型变量及反射对象的可设置性
第60条　了解cgo的原理和使用开销
60.1　Go调用C代码的原理
60.2　在Go中使用C语言的类型
60.3　在Go中链接外部C库
60.4　在C中使用Go函数
60.5　使用cgo的开销
60.6　使用cgo代码的静态构建
第十部分　工具链与工程实践
第61条　使用module管理包依赖
61.1　Go语言包管理演进回顾
61.2　Go module：Go包依赖管理的生产标准
61.3　Go module代理
61.4　升级module的主版本号
第62条　构建最小Go程序容器镜像
62.1　镜像：继承中的创新
62.2　“镜像是个筐”：初学者的认知
62.3　理性回归：builder模式的崛起
62.4　“像赛车那样减重”：追求最小镜像
62.5　“要有光”：对多阶段构建的支持
第63条　自定义Go包的导入路径
63.1　govanityurls
63.2　使用govanityurls
第64条　熟练掌握Go常用工具
64.1　获取与安装
64.2　包或module检视
64.3　构建
64.4　运行与诊断
64.5　格式化与静态代码检查
64.6　重构
64.7　查看文档
64.8　代码导航与洞察
第65条　使用go generate驱动代码生成“驱动器”
65.2　go generate的工作原理
65.3　go generate的应用场景
第66条　牢记Go的常见“陷阱”
66.1　语法规范类
66.2　标准库类



---------------------------8085127 - Go语言精进之路：从新手到高手的编程思想、方法和技巧 2---------------------------


推荐序
前言
第一部分　熟知Go语言的一切
第1条　了解Go语言的诞生与演进
1.1　Go语言的诞生
1.2　Go语言的早期团队和演进历程
1.3　Go语言正式发布并开源
第2条　选择适当的Go语言版本
2.1　Go语言的先祖
2.2　Go语言的版本发布历史
2.3　Go语言的版本选择建议
第3条　理解Go语言的设计哲学
3.1　追求简单，少即是多
3.2　偏好组合，正交解耦
3.3　原生并发，轻量高效
3.4　面向工程，“自带电池”
第4条　使用Go语言原生编程思维来写Go代码
4.1　语言与思维—来自大师的观点
4.2　现实中的“投影”
4.3　Go语言原生编程思维
第二部分　项目结构、代码风格与标识符命名
第5条　使用得到公认且广泛使用的项目结构
5.1　Go项目的项目结构
5.2　Go语言典型项目结构
第6条　提交前使用gofmt格式化源码
6.1　gofmt：Go语言在解决规模化问题上的最佳实践
6.2　使用gofmt
6.3　使用goimports
6.4　将gofmt/goimports与IDE或编辑器工具集成
第7条　使用Go命名惯例对标识符进行命名
7.1　简单且一致
7.2　利用上下文环境，让最短的名字
携带足够多的信息
第三部分　声明、类型、语句与
控制结构
第8条　使用一致的变量声明形式
8.1　包级变量的声明形式
8.2　局部变量的声明形式
第9条　使用无类型常量简化代码
9.1　Go常量溯源
9.2　有类型常量带来的烦恼
9.3　无类型常量消除烦恼，简化代码
第10条　使用iota实现枚举常量
第11条　尽量定义零值可用的类型
11.1　Go类型的零值
11.2　零值可用
第12条　使用复合字面值作为初值构造器
12.1　结构体复合字面值
12.2　数组/切片复合字面值
12.3　map复合字面值
第13条　了解切片实现原理并高效使用
13.1　切片究竟是什么
13.2　切片的高级特性：动态扩容
13.3　尽量使用cap参数创建切片
第14条　了解map实现原理并高效使用
14.1　什么是map
14.2　map的基本操作
14.3　map的内部实现
14.4　尽量使用cap参数创建map
第15条　了解string实现原理并高效使用
15.1　Go语言的字符串类型
15.2　字符串的内部表示
15.3　字符串的高效构造
15.4　字符串相关的高效转换
第16条　理解Go语言的包导入
16.1　Go程序构建过程
16.2　究竟是路径名还是包名
16.3　包名冲突问题
第17条　理解Go语言表达式的求值顺序
17.1　包级别变量声明语句中的表达式求值顺序
17.2　普通求值顺序
17.3　赋值语句的求值
17.4　switch/select语句中的表达式求值
第18条　理解Go语言代码块与作用域
18.1　Go代码块与作用域简介
18.2　if条件控制语句的代码块
18.3　其他控制语句的代码块规则简介
第19条　了解Go语言控制语句惯用法及使用注意事项
19.1　使用if控制语句时应遵循“快乐路径”原则
19.2　for range的避“坑”指南
19.3　break跳到哪里去了
19.4　尽量用case表达式列表替代fallthrough
第四部分　函数与方法
第20条　在init函数中检查包级变量的初始状态
20.1　认识init函数
20.2　程序初始化顺序
20.3　使用init函数检查包级变量的初始状态
第21条　让自己习惯于函数是“一等公民”
21.1　什么是“一等公民”
21.2　函数作为“一等公民”的特殊运用
第22条　使用defer让函数更简洁、更健壮
22.1　defer的运作机制
22.2　defer的常见用法
22.3　关于defer的几个关键问题
第23条　理解方法的本质以选择正确的receiver类型
23.1　方法的本质
23.2　选择正确的receiver类型
23.3　基于对Go方法本质的理解巧解难题
第24条　方法集合决定接口实现
24.1　方法集合
24.2　类型嵌入与方法集合
24.3　defined类型的方法集合
24.4　类型别名的方法集合
第25条　了解变长参数函数的妙用
25.1　什么是变长参数函数
25.2　模拟函数重载
25.3　模拟实现函数的可选参数与默认参数
25.4　实现功能选项模式
第五部分　接口
第26条　了解接口类型变量的内部表示
26.1　nil error值 != nil
26.2　接口类型变量的内部表示
26.3　输出接口类型变量内部表示的详细信息
26.4　接口类型的装箱原理
第27条　尽量定义小接口
27.1　Go推荐定义小接口
27.2　小接口的优势
27.3　定义小接口可以遵循的一些点
第28条　尽量避免使用空接口作为函数参数类型
第29条　使用接口作为程序水平组合的连接点
29.1　一切皆组合
29.2　垂直组合回顾
29.3　以接口为连接点的水平组合
第30条　使用接口提高代码的可测试性
30.1　实现一个附加免责声明的电子邮件发送函数
30.2　使用接口来降低耦合
第六部分　并发编程
第31条　优先考虑并发设计
31.1　并发与并行
31.2　Go并发设计实例
第32条　了解goroutine的调度原理
32.1　goroutine调度器
32.2　goroutine调度模型与演进过程
32.3　对goroutine调度器原理的进一步理解
32.4　调度器状态的查看方法
32.5　goroutine调度实例简要分析
第33条　掌握Go并发模型和常见并发模式
33.1　Go并发模型
33.2　Go常见的并发模式
第34条　了解channel的妙用
34.1　无缓冲channel
34.2　带缓冲channel
34.3　nil channel的妙用
34.4　与select结合使用的一些惯用法
第35条　了解sync包的正确用法
35.1　sync包还是channel
35.2　使用sync包的注意事项
35.3　互斥锁还是读写锁
35.4　条件变量
35.5　使用sync.Once实现单例模式
35.6　使用sync.Pool减轻垃圾回收压力
第36条　使用atomic包实现伸缩性更好的并发读取
36.1　atomic包与原子操作
36.2　对共享整型变量的无锁读写
36.3　对共享自定义类型变量的无锁读写
第七部分　错误处理
第37条　了解错误处理的4种策略
37.1　构造错误值
37.2　透明错误处理策略
37.3　“哨兵”错误处理策略
37.4　错误值类型检视策略
37.5　错误行为特征检视策略
第38条　尽量优化反复出现的if err != nil
38.1　两种观点
38.2　尽量优化
38.3　优化思路
第39条　不要使用panic进行正常的错误处理
39.1　Go的panic不是Java的checked exception
39.2　panic的典型应用
39.3　理解panic的输出信息
（以上为第1册内容，以下为本书内容。）
第八部分　测试、性能剖析与调试
第40条　理解包内测试与包外测试的差别2
40.1　官方文档的“自相矛盾”2
40.2　包内测试与包外测试3
第41条　有层次地组织测试代码9
41.1　经典模式—平铺9
41.2　xUnit家族模式10
41.3　测试固件13
第42条　优先编写表驱动的测试20
42.1　Go测试代码的一般逻辑20
42.2　表驱动的测试实践21
42.3　表驱动测试的优点22
42.4　表驱动测试实践中的注意事项23
第43条　使用testdata管理测试依赖的外部数据文件28
43.1　testdata目录28
43.2　golden文件惯用法32
第44条　正确运用fake、stub和mock等辅助单元测试35
44.1　fake：真实组件或服务的简化实现版替身36
44.2　stub：对返回结果有一定预设控制能力的替身39
44.3　mock：专用于行为观察和验证的替身44
第45条　使用模糊测试让潜在bug无处遁形48
45.1　模糊测试在挖掘Go代码的潜在bug中的作用49
45.2　go-fuzz的初步工作原理49
45.3　go-fuzz使用方法51
45.4　使用go-fuzz建立模糊测试的示例54
45.5　让模糊测试成为“一等公民”58
第46条　为被测对象建立性能基准60
46.1　性能基准测试在Go语言中是“一等公民”60
46.2　顺序执行和并行执行的性能基准测试62
46.3　使用性能基准比较工具69
46.4　排除额外干扰，让基准测试更精确72
第47条　使用pprof对程序进行性能剖析76
47.1　pprof的工作原理76
47.2　使用pprof进行性能剖析的实例90
第48条　使用expvar输出度量数据，辅助定位性能瓶颈点101
48.1　expvar包的工作原理102
48.2　自定义应用通过expvar输出的度量数据105
48.3　输出数据的展示110
第49条　使用Delve调试Go代码112
49.1　关于调试，你首先应该知道的几件事112
49.2　Go调试工具的选择114
49.3　Delve调试基础、原理与架构116
49.4　并发、Coredump文件与挂接进程调试125
第九部分　标准库、反射与cgo
第50条　理解Go TCP Socket网络编程模型136
50.1　TCP Socket网络编程模型137
50.2　TCP连接的建立142
50.3　Socket读写145
50.4　Socket属性155
50.5　关闭连接156
第51条　使用net/http包实现安全通信158
51.1　HTTPS：在安全传输层上运行的HTTP协议158
51.2　HTTPS安全传输层的工作机制161
51.3　非对称加密和公钥证书164
51.4　对服务端公钥证书的校验169
51.5　对客户端公钥证书的校验172
第52条　掌握字符集的原理和字符编码方案间的转换175
52.1　字符与字符集175
52.2　Unicode字符集的诞生与UTF-8编码方案177
52.3　字符编码方案间的转换179
第53条　掌握使用time包的正确方式187
53.1　时间的基础操作187
53.2　时间的格式化输出196
53.3　定时器的使用199
第54条　不要忽略对系统信号的处理209
54.1　为什么不能忽略对系统信号的处理209
54.2　Go语言对系统信号处理的支持210
54.3　使用系统信号实现程序的优雅退出216
第55条　使用crypto下的密码学包构建安全应用219
55.1　Go密码学包概览与设计原则219
55.2　分组密码算法221
55.3　公钥密码228
55.4　单向散列函数231
55.5　消息认证码233
55.6　数字签名235
55.7　随机数生成238
第56条　掌握bytes包和strings包的基本操作240
56.1　查找与替换241
56.2　比较244
56.3　分割246
56.4　拼接248
56.5　修剪与变换249
56.6　快速对接I/O模型252
第57条　理解标准库的读写模型254
57.1　直接读写字节序列255
57.2　直接读写抽象数据类型实例257
57.3　通过包裹类型读写数据263
第58条　掌握unsafe包的安全使用模式269
58.1　简洁的unsafe包 270
58.2　unsafe包的典型应用273
58.3　正确理解unsafe.Pointer与uintptr277
58.4　unsafe.Pointer的安全使用模式280
第59条　谨慎使用reflect包提供的反射能力288
59.1　Go反射的三大法则288
59.2　反射世界的入口291
59.3　反射世界的出口295
59.4　输出参数、interface{}类型变量及反射对象的可设置性295
第60条　了解cgo的原理和使用开销300
60.1　Go调用C代码的原理300
60.2　在Go中使用C语言的类型302
60.3　在Go中链接外部C库307
60.4　在C中使用Go函数309
60.5　使用cgo的开销309
60.6　使用cgo代码的静态构建314
第十部分　工具链与工程实践
第61条　使用module管理包依赖320
61.1　Go语言包管理演进回顾320
61.2　Go module：Go包依赖管理的生产标准324
61.3　Go module代理339
61.4　升级module的主版本号342
第62条　构建最小Go程序容器镜像350
62.1　镜像：继承中的创新350
62.2　“镜像是个筐”：初学者的认知351
62.3　理性回归：builder模式的崛起353
62.4　“像赛车那样减重”：追求最小镜像355
62.5　“要有光”：对多阶段构建的支持357
第63条　自定义Go包的导入路径359
63.1　govanityurls360
63.2　使用govanityurls361
第64条　熟练掌握Go常用工具367
64.1　获取与安装367
64.2　包或module检视373
64.3　构建380
64.4　运行与诊断390
64.5　格式化与静态代码检查398
64.6　重构402
64.7　查看文档412
64.8　代码导航与洞察419
第65条　使用go generate驱动代码生成421
65.1　go generate：Go原生的代码生成“驱动器”421
65.2　go generate的工作原理423
65.3　go generate的应用场景425
第66条　牢记Go的常见“陷阱”430
66.1　语法规范类431
66.2　标准库类455

.　　希望写出更符合Go惯用法的高质量代码的Go语言开发者；
　　有Go语言面试需求的在校生或Go语言求职者；
　　已掌握其他编程语言且希望深入学习Go语言的开发者。
　　本书特色
　　本书的特色可以概括为以下几点。
　　进阶必备：精心总结的编程箴言助你掌握高效Go程序设计之道。
　　高屋建瓴：Go设计哲学与编程思想先行。
　　深入浅出：原理深入，例子简明，讲解透彻。
　　图文并茂：大量图表辅助学习，重点、难点轻松掌控。
　　如何阅读本书
　　本书内容共分为十部分，限于篇幅，分为两册出版，即《Go语言精进之路：从新手到高手的编程思想、方法和技巧1》和《Go语言精进之路：从新手到高手的编程思想、方法和技巧2》。其中，第1册包含第一～七部分，第2册包含第八～十部分。
　　第一部分熟知Go语言的一切
　　本部分将带领读者穿越时空，回顾历史，详细了解Go语言的诞生、演进以及发展现状。通过归纳总结Go语言的设计哲学和原生编程思维，让读者站在语言设计者的高度理解Go语言与众不同的设计，认同Go语言的设计理念。
　　第二部分项目结构、代码风格与标识符命名
　　每种编程语言都有自己惯用的代码风格，而遵循语言惯用风格是编写高质量Go代码的必要条件。本部分详细介绍了得到公认且广泛使用的Go项目的结构布局、代码风格标准、标识符命名惯例等。
　　第三部分声明、类型、语句与控制结构
　　本部分详述基础语法层面高质量Go代码的惯用法和有效实践，涵盖无类型常量的作用、定义Go的枚举常量、零值可用类型的意义、切片原理以及高效的原因、Go包导入路径的真正含义等。
　　第四部分函数与方法
　　函数和方法是Go程序的基本组成单元。本部分聚焦于函数与方法的设计和实现，涵盖init函数的使用、跻身“一等公民”行列的函数有何不同、Go方法的本质等。
　　第五部分接口
　　接口是Go语言中的“魔法师”。本部分聚焦于接口，涵盖接口的设计惯例、使用接口类型的注意事项以及接口类型对代码可测试性的影响等。
　　第六部分并发编程
　　Go以其轻量级的并发模型而闻名。本部分详细介绍Go基本执行单元—goroutine的调度原理、Go并发模型以及常见并发模式、Go支持并发的原生类型—channel的惯用模式等内容。
　　第七部分错误处理
　　Go语言十分重视错误处理，它有着相对保守的设计和显式处理错误的惯例。本部分涵盖Go错误处理的哲学以及在这套哲学下一些常见错误处理问题的优秀实践。
　　第八部分测试、性能剖析与调试
　　Go自带强大且为人所称道的工具链。本部分详细介绍Go在单元测试、性能基准测试与性能剖析以及代码调试方面的最佳实践。
　　第九部分标准库、反射与cgo
　　Go拥有功能强大且质量上乘的标准库，在多数情况下仅使用标准库即可实现应用的大部分功能，这大幅降低了学习成本以及代码依赖的管理成本。本部分详细说明高频使用的标准库包（如net/http、strings、bytes、time等）的正确使用方式，以及在使用reflect包、cgo时的注意事项。
　　第十部分工具链与工程实践
　　本部分涵盖在使用Go语言进行大型软件项目开发的过程中，我们很有可能会遇到的一些工程问题的解决方法，包括使用go module进行Go包依赖管理、Go程序容器镜像、Go相关工具使用以及Go语言的避“坑”指南。
　　勘误和支持
　　由于作者水平有限，写作时间仓促，以及技术的不断更新和迭代，书中难免会存在一些错误或者不准确的地方，恳请读者批评指正。书中的源文件可以从https://github.com/bigwhite/GoProgrammingFromBeginnerToMaster下载。如果你有更多的宝贵意见，欢迎发送邮件至邮箱bigwhite.cn@aliyun.com，期待你的真挚反馈。
　　致谢
　　感谢机械工业出版社华章公司的编辑杨福川与罗词亮，在这一年多的时间里，他们的支持与鼓励让我顺利完成全部书稿。
　　谨以此书献给Go语言社区的关注者和建设者！
　　白明
　　2021年12月
　　
　　
　　---------------------------8085127 - Go语言精进之路：从新手到高手的编程思想、方法和技巧 2---------------------------
　　
　　
　　为什么要写本书
　　Go是Google三位大师级人物Robert Griesemer、Rob Pike及Ken Thompson共同设计的一种静态类型、编译型编程语言。它于2009年11月正式开源，一经面世就凭借语法简单、原生支持并发、标准库强大、工具链丰富等优点吸引了大量开发者。经过十余年演进和发展，Go如今已成为主流云原生编程语言，很多云原生时代的杀手级平台、中间件、协议和应用都是采用Go语言开发的，比如Docker、Kubernetes、以太坊、Hyperledger Fabric超级账本、新一代互联网基础设施协议IPFS等。
　　Go是一门特别容易入门的编程语言，无论是刚出校门的新手还是从其他编程语言转过来的老手，都可以在短时间内快速掌握Go语法并编写Go代码。但很多Go初学者的疑问是：Go入门容易，但精进难，怎么才能像Go开发团队那样写出符合Go思维和语言惯例的高质量代码呢？这个问题引发了我的思考。在2017年GopherChina大会上，我以演讲的形式初次尝试回答这个问题，但鉴于演讲的时长有限，很多内容没能展开，效果不甚理想。而本书正是我对解答这个问题所做出的第二次尝试。
　　我这次解答的思路有两个。
　　思维层面：写出高质量Go代码的前提是思维方式的进阶，即用Go语言的思维写Go代码。
　　实践技巧层面：Go标准库和优秀Go开源库是挖掘符合Go惯用法的高质量Go代码的宝库，对其进行阅读、整理和归纳，可以得到一些能够帮助我们快速进阶的有效实践。
　　本书正是基于以上思路为想实现Go精进但又不知从何入手的你而写的。
　　首届图灵奖得主、著名计算机科学家Alan J. Perlis曾说过：“不能影响到你的编程思维方式的编程语言不值得学习和使用。”由此可见编程思维对编程语言学习和应用的重要性。只有真正领悟了一门编程语言的设计哲学和编程思维，并将其应用到日常编程当中，你才算真正精通了这门编程语言。
　　因此，本书将首先带领大家回顾Go语言的演进历程，一起了解Go语言设计者在设计Go语言时的所思所想，与他们产生思维上的共鸣，深刻体会那些看似随意实则经过深思熟虑的设计。
　　接下来，本书将基于对Go开发团队、Go社区高质量代码的分析与归纳，从项目结构和代码风格、基础语法、函数、方法、接口、并发、错误处理、测试与性能优化、标准库、工具链等多个方面，给出改善Go代码质量、写出符合Go思维和惯例的代码的箴言。
　　学习了本书中的这些箴言，你将拥有和Go专家一样的Go编程思维，写出符合Go惯例风格的高质量Go代码，从众多Go初学者中脱颖而出，快速实现从Go编程新手到专家的转变！
　　读者对象
　　本书主要适合以下人员阅读：
　　迫切希望在Go语言上精进并上升到新层次的Go语言初学者；
　　希望写出更符合Go惯用法的高质量代码的Go语言开发者；
　　有Go语言面试需求的在校生或Go语言求职者；
　　已掌握其他编程语言且希望深入学习Go语言的开发者。
　　本书特色
　　本书的特色可以概括为以下几点。
　　进阶必备：精心总结的编程箴言助你掌握高效Go程序设计之道。
　　高屋建瓴：Go设计哲学与编程思想先行。
　　深入浅出：原理深入，例子简明，讲解透彻。
　　图文并茂：大量图表辅助学习，重点、难点轻松掌控。
　　如何阅读本书
　　本书内容共分为十部分，限于篇幅，分为两册出版，即《Go语言精进之路：从新手到高手的编程思想、方法和技巧1》和《Go语言精进之路：从新手到高手的编程思想、方法和技巧2》。其中，第1册包含第一～七部分，第2册包含第八～十部分。
　　第一部分熟知Go语言的一切
　　本部分将带领读者穿越时空，回顾历史，详细了解Go语言的诞生、演进以及发展现状。通过归纳总结Go语言的设计哲学和原生编程思维，让读者站在语言设计者的高度理解Go语言与众不同的设计，认同Go语言的设计理念。
　　第二部分项目结构、代码风格与标识符命名
　　每种编程语言都有自己惯用的代码风格，而遵循语言惯用风格是编写高质量Go代码的必要条件。本部分详细介绍了得到公认且广泛使用的Go项目的结构布局、代码风格标准、标识符命名惯例等。
　　第三部分声明、类型、语句与控制结构
　　本部分详述基础语法层面高质量Go代码的惯用法和有效实践，涵盖无类型常量的作用、定义Go的枚举常量、零值可用类型的意义、切片原理以及高效的原因、Go包导入路径的真正含义等。
　　第四部分函数与方法
　　函数和方法是Go程序的基本组成单元。本部分聚焦于函数与方法的设计和实现，涵盖init函数的使用、跻身“一等公民”行列的函数有何不同、Go方法的本质等。
　　第五部分接口
　　接口是Go语言中的“魔法师”。本部分聚焦于接口，涵盖接口的设计惯例、使用接口类型的注意事项以及接口类型对代码可测试性的影响等。
　　第六部分并发编程
　　Go以其轻量级的并发模型而闻名。本部分详细介绍Go基本执行单元—goroutine的调度原理、Go并发模型以及常见并发模式、Go支持并发的原生类型—channel的惯用模式等内容。
　　第七部分错误处理
　　Go语言十分重视错误处理，它有着相对保守的设计和显式处理错误的惯例。本部分涵盖Go错误处理的哲学以及在这套哲学下一些常见错误处理问题的优秀实践。
　　第八部分测试、性能剖析与调试
　　Go自带强大且为人所称道的工具链。本部分详细介绍Go在单元测试、性能基准测试与性能剖析以及代码调试方面的最佳实践。
　　第九部分标准库、反射与cgo
　　Go拥有功能强大且质量上乘的标准库，在多数情况下仅使用标准库即可实现应用的大部分功能，这大幅降低了学习成本以及代码依赖的管理成本。本部分详细说明高频使用的标准库包（如net/http、strings、bytes、time等）的正确使用方式，以及在使用reflect包、cgo时的注意事项。
　　第十部分工具链与工程实践
　　本部分涵盖在使用Go语言进行大型软件项目开发的过程中，我们很有可能会遇到的一些工程问题的解决方法，包括使用go module进行Go包依赖管理、Go程序容器镜像、Go相关工具使用以及Go语言的避“坑”指南。
　　勘误和支持
　　由于作者水平有限，写作时间仓促，以及技术的不断更新和迭代，书中难免会存在一些错误或者不准确的地方，恳请读者批评指正。书中的源文件可以从https://github.com/bigwhite/GoProgrammingFromBeginnerToMaster下载。如果你有更多的宝贵意见，欢迎发送邮件至邮箱bigwhite.cn@aliyun.com，期待你的真挚反馈。
　　致谢
　　感谢机械工业出版社华章公司的编辑杨福川与罗词亮，在这一年多的时间里，他们的支持与鼓励让我顺利完成全部书稿。
　　谨以此书献给Go语言社区的关注者和建设者！
　　白明
　　2021年12月
　　

.　　
　　2017年我曾邀请白明到GopherChina分享过如何用Go风格来写Go代码，当时就很期待更多Go风格方面的技术干货。这次白老师给我们带来了这本书，它系统讲解了如何运用Go思维、Go风格、Go最佳实践来写好代码，鞭辟入里。
　　——谢孟军积梦智能CEO/GoCN社区和GopherChina发起人
　　这本书内容全面、翔实，涵盖Go基本语法、Go运行时底层实现、常用标准库和第三方库的使用、代码设计模式，以及官方工具链和常见第三方工具的使用。因此，本书既可以用来巩固Go知识，也可以用来开拓技术视野。
　　——老貘《Go语言101》作者
　　Go语言是一门入门相对简单的编程语言，我的很多使用其他编程语言的朋友，一天时间就可以学完Go语言的基础知识，但是当他们想进一步学习Go语言时，却又感到茫然，无从下手。目前市面上有一些Go入门的书，也有一些专门讲Go高级专题的书，但是鲜有帮助Go入门者提高的书，白明老师的这本书正好填补了这一空白。本书从思维和实践两个层面讲解如何写出地道的Go风格的代码，值得想进一步提高Go编程水平的朋友拥有。
　　——晁岳攀（鸟窝）微服务框架rpcx的作者/资深工程师
　　白明是国内Go语言圈子里的资深开发者，这本书脱胎于他丰富的编程经验，其中一条条的总结饱含着他对Go语言的热爱。对于广大的Go语言爱好者来说，通过这本书充分吸取一位高手的经验实在是一个难得的机会。相信本书能够帮助那些热爱Go语言编程的朋友们更上一层楼。
　　——郝林《Go语言核心36讲》和《Go并发编程实战》作者
　　本书有两大特色：第一，通过条目的方式覆盖Go语言的方方面面；第二，旨在道出如何写出符合Go思维和语言惯例的高质量代码。独特的组织方式让你在掌握Go语法的同时，更能写出Go风格的代码。白明老师是早期的Go语言布道者，写的博文通俗易懂，近些年还一直更新Gopher Daily，让大家第一时间掌握Go的动态。这本不一样的Go书，值得你拥有。
　　——徐新华（polarisxu）Go语言中文网站长/《Go语言编程之旅》作者