打开Go语言之门

通过不断思考和整理，作者编写了这本更具系统性也更通俗易懂的Go语言入门和进阶书籍，以帮助学习者少走弯路，比其他人更快一步提升职业竞争力。本书共包含 五 个部分：

第1部分：快速入门Go 语言。作者挑选了变量、常量、基础数据类型、函数和方法、结构体和接口等知识点进行介绍，这部分内容相对简洁，但已经足够让你掌握 Go 的基本程序结构了。

第2部分：Go 语言的高效并发。这部分主要介绍 goroutine、channel、同步原语等知识，让你对 Go 语言层面的并发支持有更深入的理解，并且可以编写自己的 Go 语言并发程序。这个部分有一章专门介绍常用的并发模式，可以拿来即用，以更好地控制并发。

第3部分：深入理解Go 语言。这部分讲解Go 语言底层原理和高级功能，比如 slice 的底层是怎样的、为什么这么高效等。这部分内容也是作者特意设计的，跟着作者一起研究底层原理，可避免初学者不求甚解的通病。总之，只有理解了底层原理，你才能更灵活地编写程序并高效地应对问题。

第4部分：Go 语言工程管理。学习一门语言，不光要掌握它本身的知识，还要掌握模块管理、性能优化等周边技能，因为这些技能可以帮助你更好地进行多人协作，提高开发效率，写出更高质量的代码。你可以在这个部分学到如何测试 Go 语言代码以提高代码质量、如何做好性能优化、如何使用第三方库来提高自己项目的开发效率等。

第5部分：Go 语言泛型。这是Go语言在1.18版本中新增的特性，也是大家期待已久的特性。在这一部分作者会带你学习Go语言泛型的使用，以及如何使用泛型来提高效率和简化代码。

飞雪无情

Go 语言早期的布道者、“Go语言实战笔记”作者，通过“飞雪无情”公众号与数万名读者交流 Go 语言技术，擅长用通俗的语言将底层机制讲得浅显易懂。
深耕技术领域近十年，前随手记技术VP、Go Meetup讲师、TGO鲲鹏会成员，目前在一家互联网公司担任副总裁，负责产品的研发管理和架构设计。

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

你好，我是飞雪无情，在技术领域从业近10年，目前在一家互联网公司担任副总裁，负责产品的研发管理和架构设计。

2014年，我因为Docker接触了Go语言，其简洁的语法、高效的开发效率和语言层面上的并发支持深深地吸引了我。经过不断学习和实践，我对Go语言有了更深入的了解，不久后，便带领团队转型Go语言开发，提升了团队开发效率和系统性能，降低了用人成本。

在带领团队转型Go语言的过程中，我不断地把自己学习Go语言的经验总结成文章，以方便大家利用碎片时间学习，于是“飞雪无情”公众号和知乎号就诞生了。现在，我已经发布了300多篇相关文章，在帮助数万名读者朋友有效学习Go语言的同时，还有幸拿到了知乎Go语言专题的最高赞。

为开发者需求而设计的Go语言

K8s、Docker、etcd这类耳熟能详的工具就是用Go语言开发的，而且很多大公司（如腾讯、字节跳动等）都在把原来的C/C++、Python、PHP技术栈迁往Go语言。

在我看来，Go语言备受推崇，与其本身的优势有直接的关系：

语法简洁，相比其他语言更容易上手，开发效率更高。

自带垃圾回收（GC）功能，不用手动申请释放内存，能够有效避免Bug，提高性能。

语言层面的并发支持让你能够很容易地开发出高性能程序。

提供强大的标准库，第三方库也足够丰富，可以拿来即用，提高开发效率。

可通过静态编译直接生成一个可执行文件，运行时不依赖其他库，部署方便，可伸缩能力强。

提供跨平台支持，很容易编译出跨各个系统平台直接运行的程序。

对比其他语言，Go的优势显著。比如Java虽然具备垃圾回收功能，但它是解释型语言，需要安装JVM才能运行；C语言虽然不用解释，可以直接编译运行，但是它不具备垃圾回收功能，需要开发者自己管理内存的申请和释放，容易出问题。而Go语言具备两者的优势。

如今微服务和云原生已经成为一种趋势，Go作为一门高性能的编译型语言，最适合承载微服务的落地实现，且容易生成跨平台的可执行文件，相比其他编程语言更容易部署在Docker容器中，实现灵活的自动伸缩服务。

总体来看，Go语言的整体设计理念就是以软件工程为目的，方便开发者更好地研发、管理软件项目，一切都是为开发者着想。

如果你是有1～3年经验的其他语言（如Python、PHP、C/C++）开发者，学习Go语言会比较容易，因为编程语言的很多概念是相通的。而如果你是有基本计算机知识但无开发经验的小白，也适合尽早学习Go语言，吃透它有助于加深你对编程语言的理解，也让你更有职业竞争力。

在与Go语言学习者进行交流和面试的过程中，我发现了一些典型问题，可概括为如下三点。

第一，学习者所学知识过于零碎，缺乏系统性，并且不是太深入，导致写不出高效的程序，也难以在面试中胜出。比如，我在面试时会问字符串拼接的效率问题，这个问题涉及加号（+）拼接、buffer拼接、builder拼接、并发安全等知识点，但应聘者通常只能答出最浅显的内容，缺乏对语言逻辑的深层思考。

第二，很多入门者已有其他语言基础，很难转换语言思维模式，尤其是在Go语言设计者还做了很多相对其他语言的改进和创新的情况下。作为从Java语言转到Go语言的过来人，我非常理解这种情况，比如对于错误的处理，Java语言使用Exception，Go语言则通过函数返回error，这会让人很不习惯。

第三，没有开源的、适合练手的项目。

在过去分享Go语言知识的过程中，我融入了应对上述问题的方法并得到好评，有读者称“你的文章给我拨云见日的感觉！”“通过你的文章我终于懂context的用法了！”……这些正向评价更坚定了我分享内容的信心。

于是在不断地思考、整理后，我希望编写一本更具系统性也更通俗易懂的Go语言入门和进阶书籍，以帮助学习者少走弯路，比其他人更快一步提升职业竞争力。

本书的亮点和设计思路

系统性设计：从基础知识、底层原理到实战，让你不仅可以学会使用这门语言，还能从该语言自身的逻辑、框架层面分析问题，并上手项目。这样当出现问题时，你可以不再盲目地搜索知识点。

案例实操：设计了很多便于运用知识点的代码示例，还特意站在学习者的视角，演示了一些容易出Bug的场景，帮你避雷；引入了很多生活化的场景，比如用“枪响后才能赛跑”的例子演示sync.Cond的使用，帮助你加深印象，缓解语言学习的枯燥感。

贴近实际：本书内容来源于众多学习者的反馈。笔者在与他们的不断交流中，总结了问题的共性，并有针对性地将其融入本书。

那么，我是怎么划分本书内容的呢？

作为初学者，不管你是否有编程经验，都需要先学习Go语言的基本语法。因此，我首先介绍Go语言的基本语法，然后，在此基础上介绍Go语言的核心特性—并发，这也是Go语言最自豪的功能。其基于协程的并发比我们平时使用的线程并发更轻量，可以随意地在一台普通的计算机上启动成百上千个协程，成本却非常低。

在你掌握了基本知识后，我会通过底层分析深入讲解原理。我会结合源码，并对比其他语言的同类知识，带你理解Go语言的设计思路和底层语言逻辑。

此时你可能还有一些疑惑，比如不知道如何将知识与实际工作结合起来，这就需要后面介绍的Go语言工程管理方面的知识了。最后，我会介绍Go语言最新的特性—泛型，以方便你进一步理解Go语言、简化代码和提升效率。

所以，我根据这个思路将本书划分成5个部分：

第一部分：快速入门Go语言。我挑选了变量、常量、基础数据类型、函数和方法、结构体和接口等知识点进行介绍。这部分内容相对简洁，但已经足够让你掌握Go语言的基本程序结构了。

第二部分：Go语言的高效并发。这部分主要介绍goroutine、channel、同步原语等知识，让你对Go语言层面的并发支持有更深入的理解，并且可以编写自己的Go语言并发程序。这部分有一章专门介绍常用的并发模式，可以拿来即用，以更好地控制并发。

第三部分：深入理解Go语言。这部分讲解Go语言底层原理和高级功能，比如slice的底层是怎样的、为什么这么高效等。这部分内容是我特意为初学者设计的，因为我在初学编程时也是只学习如何使用，而不想研究底层原理，导致在工作中遇到障碍后又不得不回头恶补这部分知识。总之，只有理解了底层原理，你才能更灵活地编写程序并高效地应对问题。

第四部分：Go语言工程管理。学习一门语言，不仅要掌握它本身的知识，还要掌握模块管理、性能优化等周边技能，因为这些技能可以帮助你更好地进行多人协作，提高开发效率，写出更高质量的代码。你可以在这部分学到如何测试Go语言代码以提高代码质量、如何做好性能优化、如何使用第三方库来提高自己项目的开发效率等。

第五部分：Go语言泛型。这是Go语言在1.18版本中新增的特性，也是大家期待已久的特性。在这部分中，我会带你学习Go语言泛型的使用，以及如何使用泛型来提高效率和简化代码。

作者寄语

我一直不厌其烦地跟团队小伙伴说，Go语言是一门现代编程语言，相比其他编程语言，它有更好的用户体验，因为它的目的就是让我们更专注于自己业务的实现，提高开发效率。与此同时，当下的云原生是一种趋势，Go语言非常适合部署在这种环境中，越早学习越有竞争力。

此外，我在上文中也反复强调了学习底层原理的重要性。编程语言有很多共通之处（比如概念、关键字、特性语法等），吃透后再学习其他编程语言会简单很多，原因就在于你理解了语言本身。所以在学习Go语言的过程中，我希望你多想多练，深入理解，融会贯通。

现在，跟我一起踏上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