[正版]Go语言高级编程+Go语言核心编程 2册 golang教程实战自学基础入门精通实践开发 Go语言编程自学宝典图

Go语言核心编程   9787121349119  79.00

Go语言高级编程   9787115510365  89.00

Go语言核心编程 

Go语言精华部分 ——并发和小而美的类型系统。
Go陷阱——主要论述使用Go过程中大家很困惑或容易出错的地方。
Go语言的哲学——总结Go的设计哲学，懂得Go作者的设计意图，才能更好地使用该语言。
Go语言高级编程

截至2019年，Go语言已历经10 年，国内互联网公司的新兴项目已经在逐渐向Go语言生态转移。随着用户的不断积累，Go语言相关教程随之增加，这些教程主要涵盖Go语言基础编程、Web编程、并发编程和内部源码剖析等诸多内容。 本书聚焦于主流Go语言书中缺失的或刻意回避的部分主题，主要面向希望深入了解Go语言，特别是对Go语言和其他语言的混合编程、Go汇编语言的工作机制、构造Web框架和分布式开发等领域感兴趣的学生、工程师和研究人员。阅读本书需要读者对Go语言有一定的认识和使用经验。 本书关于CGO编程和Go汇编语言的讲解在中国乃至全球Go语言出版物中是非常有特色的。 本书主要内容 ● Go语言演化历史。 ● CGO编程技术。 ● Go汇编语言。 ● RPC和gRPC。 ● 构造Web框架的方法。 ● 分布式系统。

Go语言核心编程 
第1章 基础知识 
1.1 语言简介 
1.1.1 Go语言的诞生背景 
1.1.2 语言特性 
1.1.3 Go语言的特性 
1.1.4 总结 
1.2 初识Go程序 
1.3 Go词法单元 
1.3.1 token 
1.3.2 标识符 
1.3.3 操作符（operators）和分隔符（delimiters） 
1.3.4 字面常量 
1.3.5 总结 
1.4 变量和常量 
1.4.1 变量 
1.4.2 常量 
1.5 基本数据类型 
1.5.1 布尔类型 
1.5.2 整型 
1.5.3 浮点型 
1.5.4 复数类型 
1.5.5 字符串 
1.5.6 rune类型 
1.6 复合数据类型 
1.6.1 指针 
1.6.2 数组 
1.6.3 切片 
1.6.4 map 
1.6.5 struct 
1.7 控制结构 
1.7.1 if语句 
1.7.2 switch语句 
1.7.3 for语句 
1.7.4 标签和跳转 
第2章 函数 
2.1 基本概念 
2.1.1 函数定义 
2.1.2 多值返回 
2.1.3 实参到形参的传递 
2.1.4 不定参数 
2.2 函数签名和匿名函数 
2.2.1 函数签名 
2.2.2 匿名函数 
2.3 defer 
2.4 闭包 
2.4.1 概念 
2.4.2 闭包的价值 
2.5 panic和recover 
2.5.1 基本概念 
2.5.2 使用场景 
2.6 错误处理 
2.6.1 error 
2.6.2 错误和异常 
2.7 底层实现 
2.7.1 函数调用规约 
2.7.2 汇编基础 
2.7.3 多值返回分析 
2.7.4 闭包底层实现 
第3章 类型系统 
3.1 类型简介 
3.1.1 命名类型和未命名类型 
3.1.2 底层类型 
3.1.3 类型相同和类型赋值 
3.1.4 类型强制转换 
3.2 类型方法 
3.2.1 自定义类型 
3.2.2 方法 
3.3 方法调用 
3.3.1 一般调用 
3.3.2 方法值（method value） 
3.3.3 方法表达式（method expression） 
3.3.4 方法集（method set） 
3.3.5 值调用和表达式调用的方法集 
3.4 组合和方法集 
3.4.1 组合 
3.4.2 组合的方法集 
3.5 函数类型 
第4章 接口 
4.1 基本概念 
4.1.1 接口声明 
4.1.2 接口初始化 
4.1.3 接口方法调用 
4.1.4 接口的动态类型和静态类型 
4.2 接口运算 
4.2.1 类型断言（Type Assertion） 
4.2.2 类型查询（Type Switches） 
4.2.3 接口优点和使用形式 
4.3 空接口 
4.3.1 基本概念 
4.3.2 空接口的用途 
4.3.3 空接口和nil 
4.4 接口内部实现 
4.4.1 数据结构 
4.4.2 接口调用过程分析 
4.4.3 接口调用代价 
4.4.4 空接口数据结构 
第5章 并发 
5.1 并发基础 
5.1.1 并发和并行 
5.1.2 goroutine 
5.1.3 chan 
5.1.4 WaitGroup 
5.1.5 select 
5.1.6 扇入（Fan in）和扇出（Fan out） 
5.1.7 通知退出机制 
5.2 并发范式 
5.2.1 生成器 
5.2.2 管道 
5.2.3 每个请求一个goroutine 
5.2.4 固定worker工作池 
5.2.5 future模式 
5.3 context标准库 
5.3.1 context的设计目的 
5.3.2 基本数据结构 
5.3.3 API函数 
5.3.4 辅助函数 
5.3.5 context的用法 
5.3.6 使用context传递数据的争议 
5.4 并发模型 
5.4.1 CSP简介 
5.4.2 调度模型 
5.4.3 并发和调度 
第6章 反射 
6.1 基本概念 
6.1.1 基本数据结构和入口函数 
6.1.2 基础类型 
6.1.3 类型汇总 
6.2 反射规则 
6.2.1 反射API 
6.2.2 反射三定律 
6.3 inject库 
6.3.1 inject是什么 
6.3.2 依赖注入和控制反转 
6.3.3 inject实践 
6.3.4 inject原理分析 
6.4 反射的优缺点 
6.4.1 反射的优点 
6.4.2 反射的缺点 
6.4.3 反射的最佳实践 
第7章 语言陷阱 
7.1 多值赋值和短变量声明 
7.1.1 多值赋值 
7.1.2 短变量的声明和赋值 
7.2 range复用临时变量 
7.3 defer陷阱 
7.4 切片困惑 
7.4.1 数组 
7.4.2 切片 
7.5 值、指针和引用 
7.5.1 传值还是传引用 
7.5.2 函数名的意义 
7.5.3 引用语义 
7.6 习惯用法 
7.6.1 干净与强迫症 
7.6.2 comma,ok表达式 
7.6.3 简写模式 
7.6.4 包中的函数或方法设计 
7.6.5 多值返回函数 
第8章 工程管理 
8.1 编程环境 
8.1.1 环境搭建 
8.1.2 工程结构 
8.1.3 交叉编译 
8.2 命名空间和作用域 
8.2.1 命名空间 
8.2.2 作用域 
8.2.3 变量覆盖 
8.3 包的基本概念 
8.3.1 基本概念 
8.3.2 包引用 
8.3.3 包加载 
8.4 第三方包管理 
8.4.1 vendor 
8.4.2 dep 
第9章 编程哲学 
9.1 Go语言设计哲学 
9.1.1 少即是多 
9.1.2 世界是并行的 
9.1.3 组合优于继承 
9.1.4 非侵入式的接口 
9.1.5 总结 
9.2 Go语言发展史 
9.2.1 站在巨人的肩膀上 
9.2.2 里程碑 
9.3 未来 
9.3.1 争议 
9.3.2 Go 2

Go语言高级编程
第 1章 语言基础 1

1.1 Go语言创世纪 1

1.1.1 来自贝尔实验室特有基因 3

1.1.2 你好，世界 4

1.2 “Hello, World”的革命 5

1.2.1 B语言——Ken Thompson, 1969 5

1.2.2 C语言——Dennis Ritchie，1972—1989 5

1.2.3 Newsqueak——Rob Pike, 1989 7

1.2.4 Alef——Phil Winterbottom, 1993 9

1.2.5 Limbo——Sean Dorward, Phil Winterbottom, Rob Pike, 1995 10

1.2.6 Go语言——2007—2009 11

1.2.7 你好，世界!——V2.0 13

1.3 数组、字符串和切片 13

1.3.1 数组 14

1.3.2 字符串 17

1.3.3 切片 21

1.4 函数、方法和接口 27

1.4.1 函数 27

1.4.2 方法 31

1.4.3 接口 35

1.5 面向并发的内存模型 39

1.5.1 Goroutine和系统线程 40

1.5.2 原子操作 40

1.5.3 顺序一致性内存模型 44

1.5.4 初始化顺序 45

1.5.5 Goroutine的创建 46

1.5.6 基于通道的通信 46

1.5.7 不靠谱的同步 48

1.6 常见的并发模式 49

1.6.1 并发版本的“Hello, World” 50

1.6.2 生产者/消费者模型 52

1.6.3 发布/订阅模型 53

1.6.4 控制并发数 56

1.6.5 赢者为王 57

1.6.6 素数筛 58

1.6.7 并发的安全退出 59

1.6.8 context包 62

1.7 错误和异常 64

1.7.1 错误处理策略 65

1.7.2 获取错误的上下文 67

1.7.3 错误的错误返回 69

1.7.4 剖析异常 70

1.8 补充说明 73

第 2章 CGO编程 74

2.1 快速入门 74

2.1.1 最简CGO程序 74

2.1.2 基于C标准库函数输出字符串 75

2.1.3 使用自己的C函数 75

2.1.4 C代码的模块化 76

2.1.5 用Go重新实现C函数 77

2.1.6 面向C接口的Go编程 78

2.2 CGO基础 79

2.2.1 import "C"语句 79

2.2.2 #cgo语句 81

2.2.3 build标志条件编译 82

2.3 类型转换 83

2.3.1 数值类型 83

2.3.2 Go字符串和切片 85

2.3.3 结构体、联合和枚举类型 86

2.3.4 数组、字符串和切片 89

2.3.5 指针间的转换 91

2.3.6 数值和指针的转换 92

2.3.7 切片间的转换 93

2.4 函数调用 94

2.4.1 Go调用C函数 94

2.4.2 C函数的返回值 94

2.4.3 void函数的返回值 95

2.4.4 C调用Go导出函数 96

2.5 内部机制 97

2.5.1 CGO生成的中间文件 97

2.5.2 Go调用C函数 98

2.5.3 C调用Go函数 101

2.6 实战：封装qsort 103

2.6.1 认识qsort()函数 103

2.6.2 将qsort()函数从Go包导出 104

2.6.3 改进：闭包函数作为比较函数 106

2.6.4 改进：消除用户对unsafe包的依赖 108

2.7 CGO内存模型 110

2.7.1 Go访问C内存 110

2.7.2 C临时访问传入的Go内存 111

2.7.3 C长期持有Go指针对象 113

2.7.4 导出C函数不能返回Go内存 115

2.8 C 类包装 117

2.8.1 C 类到Go语言对象 117

2.8.2 Go语言对象到C 类 121

2.8.3 彻底解放C 的this指针 125

2.9 静态库和动态库 126

2.9.1 使用C静态库 126

2.9.2 使用C动态库 128

2.9.3 导出C静态库 129

2.9.4 导出C动态库 131

2.9.5 导出非main包的函数 131

2.10 编译和链接参数 133

2.10.1 编译参数：CFLAGS/CPPFLAGS/CXXFLAGS 133

2.10.2 链接参数：LDFLAGS 133

2.10.3 pkg-config 133

2.10.4 go get链 134

2.10.5 多个非main包中导出C函数 135

2.11 补充说明 135

第3章 Go汇编语言 136

3.1 快速入门 136

3.1.1 实现和声明 136

3.1.2 定义整数变量 137

3.1.3 定义字符串变量 138

3.1.4 定义main()函数 141

3.1.5 特殊字符 141

3.1.6 没有分号 142

3.2 计算机结构 142

3.2.1 图灵机和BrainFuck语言 143

3.2.2 《人力资源机器》游戏 144

3.2.3 X86-64体系结构 145

3.2.4 Go汇编中的伪寄存器 146

3.2.5 X86-64指令集 147

3.3 常量和全局变量 150

3.3.1 常量 150

3.3.2 全局变量 150

3.3.3 变量的内存布局 156

3.3.4 标识符规则和特殊标志 157

3.3.5 小结 158

3.4 函数 158

3.4.1 基本语法 158

3.4.2 函数参数和返回值 160

3.4.3 参数和返回值的内存布局 161

3.4.4 函数中的局部变量 163

3.4.5 调用其他函数 165

3.4.6 宏函数 166

3.5 控制流 167

3.5.1 顺序执行 167

3.5.2 if/goto跳转 169

3.5.3 for循环 171

3.6 再论函数 172

3.6.1 函数调用规范 172

3.6.2 高级汇编语言 173

3.6.3 PCDATA和FUNCDATA 176

3.6.4 方法函数 177

3.6.5 递归函数: 1到n求和 178

3.6.6 闭包函数 180

3.7 汇编语言的威力 182

3.7.1 系统调用 182

3.7.2 直接调用C函数 184

3.7.3 AVX指令 185

3.8 例子：Goroutine ID 187

3.8.1 故意设计没有goid 187

3.8.2 纯Go方式获取goid 187

3.8.3 从g结构体获取goid 189

3.8.4 获取g结构体对应的接口对象 190

3.8.5 goid的应用：局部存储 192

3.9 Delve调试器 194

3.9.1 Delve入门 194

3.9.2 调试汇编程序 198

3.10 补充说明 201

第4章 RPC和Protobuf 203

4.1 RPC入门 203

4.1.1 RPC版“Hello, World” 203

4.1.2 更安全的RPC接口 205

4.1.3 跨语言的RPC 207

4.1.4 HTTP上的RPC 209

4.2 Protobuf 210

4.2.1 Protobuf入门 210

4.2.2 定制代码生成插件 212

4.2.3 自动生成完整的RPC代码 215

4.3 玩转RPC 218

4.3.1 客户端RPC的实现原理 218

4.3.2 基于RPC实现监视功能 220

4.3.3 反向RPC 222

4.3.4 上下文信息 223

4.4 gRPC入门 224

4.4.1 gRPC技术栈 225

4.4.2 gRPC入门 225

4.4.3 gRPC流 227

4.4.4 发布和订阅模式 229

4.5 gRPC进阶 233

4.5.1 证书认证 233

4.5.2 Token认证 236

4.5.3 截取器 238

4.5.4 和Web服务共存 240

4.6 gRPC和Protobuf扩展 241

4.6.1 验证器 241

4.6.2 REST接口 244

4.6.3 Nginx 246

4.7 pbgo：基于Protobuf的框架 246

4.7.1 Protobuf扩展语法 246

4.7.2 插件中读取扩展信息 248

4.7.3 生成REST代码 249

4.7.4 启动REST服务 250

4.8 grpcurl工具 251

4.8.1 启动反射服务 251

4.8.2 查看服务列表 252

4.8.3 服务的方法列表 253

4.8.4 获取类型信息 253

4.8.5 调用方法 254

4.9 补充说明 255

第5章 Go和Web 256

5.1 Web开发简介 256

5.2 请求路由 260

5.2.1 httprouter 260

5.2.2 原理 262

5.2.3 压缩检索树创建过程 263

5.3 中间件 267

5.3.1 代码泥潭 267

5.3.2 使用中间件剥离非业务逻辑 269

5.3.3 更优雅的中间件写法 272

5.3.4 哪些事情适合在中间件中做 273

5.4 请求校验 274

5.4.1 重构请求校验函数 275

5.4.2 用请求校验器解放体力劳动 276

5.4.3 原理 277

5.5 Database 和数据库打交道 279

5.5.1 从database/sql讲起 279

5.5.2 提高生产效率的ORM和

SQL Builder 281

5.5.3 脆弱的数据库 283

5.6 服务流量限制 285

5.6.1 常见的流量限制手段 287

5.6.2 原理 289

5.6.3 服务瓶颈和 QoS 291

5.7 常见大型Web项目分层 291

5.8 接口和表驱动开发 297

5.8.1 业务系统的发展过程 297

5.8.2 使用函数封装业务流程 298

5.8.3 使用接口来做抽象 298

5.8.4 接口的优缺点 301

5.8.5 表驱动开发 303

5.9 灰度发布和A/B测试 303

5.9.1 通过分批次部署实现灰度发布 304

5.9.2 通过业务规则进行灰度发布 305

5.9.3 如何实现一套灰度发布系统 306

5.10 补充说明 310

第6章 分布式系统 311

6.1 分布式ID生成器 311

6.1.1 worker_id分配 312

6.1.2 开源实例 313

6.2 分布式锁 316

6.2.1 进程内加锁 317

6.2.2 尝试锁 317

6.2.3 基于Redis的setnx 319

6.2.4 基于ZooKeeper 321

6.2.5 基于etcd 321

6.2.6 如何选择合适的锁 322

6.3 延时任务系统 323

6.3.1 定时器的实现 323

6.3.2 任务分发 325

6.3.3 数据再平衡和幂等考量 326

6.4 分布式搜索引擎 327

6.4.1 搜索引擎 328

6.4.2 异构数据同步 336

6.5 负载均衡 337

6.5.1 常见的负载均衡思路 337

6.5.2 基于洗牌算法的负载均衡 338

6.5.3 ZooKeeper集群的随机节点挑选问题 340

6.5.4 负载均衡算法效果验证 340

6.6 分布式配置管理 341

6.6.1 场景举例 341

6.6.2 使用etcd实现配置更新 342

6.6.3 配置膨胀 345

6.6.4 配置版本管理 345

6.6.5 客户端容错 345

6.7 分布式爬虫 346

6.7.1 基于colly的单机爬虫 346

6.7.2 分布式爬虫 347

6.7.3 结合nats和colly的消息生产 350

6.7.4 结合colly的消息消费 352

6.8 补充说明 353

附录A 使用Go语言常遇到的问题 354

附录B 有趣的代码片段 363

Go语言核心编程 
写作背景
2007年，Go语言诞生于谷歌公司，2009年开源，2012年推出1.0版本，曾两次获得TIOBE年度语言（2009年和2016年）。2012年起，全球大量的开源项目开始使用Go语言进行开发，目前Go语言已经成为云计算领域事实上的标准语言，特别是在容器领域，诞生了一大批优秀的开源软件，如Docker、Kubernetes 等。2017年区块链技术在国内大热，区块链两个大的技术平台以太坊（Ethereum）和超级账本（Hyperledger）与项目Fabric都是基于Go语言构建的。Go语言的应用领域逐步扩大，目前在区块链、云计算、中间件和服务器编程领域显现出明显的优势。Go语言最先在云计算公司盛行，随后大量的互联网初创企业将Go语言作为后台主要开发语言。目前，无论互联网公司里的独角兽，还是BAT（百度、阿里巴巴、腾讯），都已将Go语言作为其技术栈的重要组成部分。市场对于Go语言编程人才的需求量也在持续上升。
目前，Go语言编程类图书有如下几个类别。
?    基础全面型
七牛团队写作和翻译的几本书（《Go 语言编程》《Go 程序设计语言》等），系统地介绍了Go 开发的基础知识，为Go 语言在国内的推广做出了很大的贡献。
?    源码深入型
雨痕的《Go 语言学习笔记》，上半部分是对 Go 语言基础知识的总结，下半部分对源码进行了分析，是学习Go语言内部原理非常好的参考书。
?    专业领域型
专注于介绍某个应用领域，比如谢孟军的《Go Web编程》，这类图书主要是介绍使用Go语言在某个领域进行开发的相关知识。
市面上Go语言的图书这么多了，为什么又要写一本，本书和市面上的图书有什么区别呢？这也是我写这本书之前就认真思考过的问题。我发现市面上缺少介绍Go语言核心特性和使用陷阱的书。Go 语言核心特性包括类型系统、接口、并发，这三部分是Go语言最精华、最优美、最重要的语言特性。于是我就围绕这三个主题写了本书，书名就叫《Go语言核心编程》。以类型系统为例，Go 语言中的类型涉及简单类型、复合类型、命名类型、未命名类型、静态类型、动态类型、底层类型、接口类型、具体类型及类型字面量等诸多概念，这些在先前的书籍里没有系统地介绍过，本书试图帮助读者梳理清楚这些类型的含义，建立概念，认清类型本质并学会使用；在并发编程中给出了5个并发编程范式并系统地介绍了context标准库，这也是本书特有的。
内容简介
本书共9章，围绕如下主题展开：基础知识（第1章）、语言核心（第2章～第7章）、工程管理（第8章）和编程哲学（第9章）。
基础知识
第1章介绍Go语言编程的基础知识。基础知识部分力求从系统性的角度讲述Go语言简洁的语法知识，试图帮助读者了解Go语言源程序基本结构，这是本书不同于其他书籍的地方。本章先对Go的源程序进行整体介绍，然后从词法分析的角度介绍Go语言的各个token，接着介绍Go语言的基础语法：变量和常量、数据类型及控制结构，让读者学习Go语言的语法知识时可以“既见树木，又见森林”。
语言核心
本书的第2～7章讲解Go语言核心知识，这部分是本书最核心、最重要的部分，主要围绕如下4个主题展开。
?    类型系统
本书用3章的篇幅来讲解Go语言的类型系统，分别是第2章函数、第3章类型系统和第4章接口。类型系统是Go语言的灵魂，Go语言小而美的类型系统是其区别于其他语言的显著特征。函数在Go语言中是“一等公民”，非侵入式的接口设计也很有特点。类型系统是本书的一条主要线索，几乎贯穿本书的所有章节，在反射章节里会对Go的类型系统做一个总结。掌握类型系统是写好Go程序的关键。
?    并发编程
第5章介绍Go并发编程，并发编程的原生支持是Go语言显著的语言特征。“不要通过共享内存来通信，而是通过通信来共享内存”，本章首先讲解语言层面对并发的支持，接着讲解context标准库的知识，最后讲解常用的并发范式和Go并发模型。
?    反射 
第6章介绍Go语言反射的相关知识。反射是Go语言的高级特性，反射是把“双刃剑”，用好了会有强大的威力，但由于其复杂性且易产生运行时panic，因此反射又表现出脆弱性。Go语言没有提供泛型支持，所以在开发框架和大型系统中反射是必须面对的一个技术点，市面上的图书对这部分的介绍不多，本书分类总结了Go的反射API，尽可能梳理出条理清晰的API结构；同时以类型系统和接口底层实现为基础来介绍反射；最后介绍著名的Web框架martini中使用的依赖注入库inject。
?    陷阱和习惯用法 
第7章介绍Go语言陷阱和一些习惯用法，包括Go语言使用过程中容易出错和初学者容易困惑的知识点。Go语言虽然设计简洁，但在某些方面还是有瑕疵的，比如 defer陷阱、短变量的声明、range临时变量共享等。同时Go又有其鲜明的书写格式和习惯用法，本章的最后会介绍这些内容。
工程管理
Go语言是一门面向工程的语言，而不是学术界的产物，第8章介绍Go语言工程管理方面的知识，主要介绍Go的编程环境、命名空间和包管理的相关内容。
编程哲学
第9章讨论编程哲学，这部分内容不是介绍编程细节知识，读者可以把它当作散文来读。先对Go语言编程哲学做一个总结：少即是多，世界是并行的，组合优于继承，面向接口编程，等等，试图从哲学的角度来阐述这些设计思想的先进性。最后介绍Go语言的里程碑事件及未来的发展方向。
相关约定
本书使用Go代表Go语言的简写，使用go表示Go语言的并发关键字，使用goroutine代表Go语言中的并发执行体。通道和chan都代表Go语言的通信管道。切片和slice都表示Go语言内置的可变数组。本书使用实例或者类型实例表示具体类型的变量，而没有使用传统语言对象的概念。标准库和标准包会混用，都是指Go语言自带的标准库。复制和拷贝具有相同的语义，都表示将数据复制一份并拷贝到另一处内存空间。本书是基于Go 1.10.2写作的，新版本的变动请读者以官方文档为准。截至本书出版时，Go 1.11发布，官方推出了新的包管理工具go mod，go mode兼容dep，dep仍可放心使用，go mod是新增的功能，可能需要一段时间才能成熟。
总结
本书绝大部分内容是我六年来在学习和实践Go语言过程中的总结和感悟，成书过程中也参阅了部分网上和官方资料，由于能力有限，疏忽和不足之处难免发生，欢迎读者指正，以便及时修订，我的邮箱是email.tata@qq.com。
感谢
本书原稿基于GitBook Markdown在Linux下使用Vim完成写作，原始稿件版式简单，非常感谢电子工业出版社博文视点编辑部的帮助，使其变成一本优美的纸质书。非常感谢曾刘刚通读全书，帮助审稿；同时感谢宫振飞、胡宸源、宋磊在成书过程中给予的宝贵意见。在时间碎片化的今天，一字一句地写完一本书是对自己毅力和耐心的极大考验，感谢在成书过程中妻子黄静给予的鼓励和支持。封面上可爱的地鼠来自上田拓也的作品，非常感谢上田先生欣然授权本书使用。