SUMMARY.md

• 介绍

• [0 前言]

  • 00.1 前言
  • 00.2 面向读者
  • 00.3 章节概览
  • 00.4 更多信息
    • 00.4.1 代码规范约定

• [1 Go与操作系统]

  • 01.1 本书结构
  • 01.2 Go的历史
  • 01.3 为什么是Go
  • 01.4 Go的优点
    • 01.4.1 Go是完美的么

• [2 Go内部机制]

  • 02.1 本章概述
  • 02.2 编译器
  • 02.3 垃圾回收
    • 02.3.1 三色算法
    • 02.3.2 垃圾回收器背后的更多操作
    • 02.3.3 Unsafe code
    • 02.3.4 关于unsafe包
    • 02.3.5 另一个usafe包的例子
  • 02.5 C中调用Go函数
    • 02.5.1 Go Package
    • 02.5.2 C代码
  • 02.6 defer关键字
  • 02.7 Panic和Recover

• [3 Go基本数据类型]

  • 03.1 Go循环
    • 03.1.1 for循环
    • 03.1.2 while循环
    • 03.1.3 range关键字
    • 03.1.4 for循环代码示例
  • 03.3 Go切片
    • 03.3.1 切片基本操作
    • 03.3.2 切片的扩容
    • 03.3.3 字节切片
    • 03.3.4 copy()函数
    • 03.3.5 多维切片
    • 03.3.6 使用切片的代码示例
    • 03.3.7 使用sort.Slice()排序
  • 03.4 Go 映射(map)
    • 03.4.1 Map值为nil的坑
    • 03.4.2 何时该使用Map?
  • 03.5 Go 常量
    • 03.5.1 常量生成器：iota
  • 03.6 Go 指针
  • 03.7 时间与日期的处理技巧
    • 03.7.1 解析时间
    • 03.7.2 解析时间的代码示例
    • 03.7.3 解析日期
    • 03.7.4 解析日期的代码示例
    • 03.7.5 格式化时间与日期
  • 03.8 延伸阅读
  • 03.9 练习
  • 03.10 本章小结

• 4 组合类型的使用

  • 04.1 关于组合类型
  • 04.2 结构体
    • 04.2.1 结构体指针
    • 04.2.2 使用new关键字
  • 04.3 元组
  • 04.4 正则表达式与模式匹配
    • 04.4.1 理论知识
    • 04.4.2 简单的正则表达式示例
    • 04.4.3 高级的正则表达式示例
    • 04.4.4 正则匹配IPv4地址
  • 04.5 字符串
    • 04.5.1 rune是什么？
    • 04.5.2 关于Unicode的包
    • 04.5.3 关于字符串处理的包
  • 04.6 switch语句
  • 04.7 计算Pi的精确值
  • 04.8 实现简单的K-V存储
  • 04.9 延展阅读
  • 04.10 练习
  • 04.11 本章小结

• 5 数据结构

  • 05.1 图和节点
  • 05.2 算法复杂度
  • 05.3 Go 语言中的二叉树
    • 05.3.1 Go 语言实现二叉树
    • 05.3.2 二叉树的优点
  • 05.4 Go 语言中的哈希表
    • 05.4.1 Go 语言实现哈希表
    • 05.4.2 实现查找功能
    • 05.4.3 哈希表的优点
  • 05.5 Go 语言中的链表
    • 05.5.1 Go 语言实现链表
    • 05.5.2 链表的优点
  • 05.6 Go 语言中的双向链表
    • 05.6.1 Go 语言实现双向链表
    • 05.6.2 双向链表的优点
  • 05.7 Go 语言中的队列
    • 05.7.1 Go 语言实现队列
  • 05.8 Go 语言中的栈
    • 05.8.1 Go 语言实现栈
  • 05.9 container 包
    • 05.9.1 使用 container/heap
    • 05.9.2 使用 container/list
    • 05.9.3 使用 container/ring
  • 05.10 生成随机数
    • 05.10.1 生成随机字符串
  • 05.11 延展阅读
  • 05.12 练习
  • 05.13 本章小结

• 6 Go package中不为人知的知识

  • 06.1 关于Go packages
  • 06.2 Go函数
    • 06.2.1 匿名函数
    • 06.2.2 多返回值的函数
    • 06.2.3 可命名的函数返回值
    • 06.2.4 参数为指针的函数
    • 06.2.5 返回值为指针的函数
    • 06.2.6 闭包
    • 06.2.7 函数作为参数
  • 06.3 设计你的Go packages

• [7 反射和接口]

  • 07.1 类型方法
  • 07.2 Go的接口
  • 07.3 类型断言
  • 07.4 设计接口
    • 07.4.1 接口的使用
    • 07.4.2 Switch用于类型判断
  • 07.5 反射
    • 07.5.1 使用反射的简单示例
    • 07.5.2 反射进阶
    • 07.5.3 反射的三个缺点
  • 07.6 Go的OOP思想
  • 07.7 延展阅读
  • 07.8 练习
  • 07.9 本章小结

• 8 Go UNIX系统编程

  • 08.1 关于UNIX进程
  • 08.2 flag包
  • 08.3 io.Reader和io.Writer接口
    • 08.3.1 缓冲和无缓冲的文件输入和输出
  • 08.4 bufio包
  • 08.5 读取文本文件
    • 08.5.1 逐行读取文本文件
    • 08.5.2 逐词读取文本文件
    • 08.5.3 逐字符读取文本文件
    • 08.5.4 从/dev/random中读取
  • 08.6 从文件中读取所需的数据量
  • 08.7 为什么我们使用二进制格式
  • 08.8 读取CSV文件
  • 08.9 写入文件
  • 08.10 从磁盘加载和保存数据
  • 08.11 再看strings包
  • 08.12 关于bytes包
  • 08.13 文件权限
  • 08.14 处理Unix信号
    • 08.14.1 处理两种信号
    • 08.14.2 处理所有信号
  • 08.15 Unix管道编程
  • 08.16 遍历目录树
  • 08.17 使用ePBF
  • 08.18 关于syscall.PtraceRegs
  • 08.19 跟踪系统调用
  • 08.20 User ID和group ID
  • 08.21 其他资源
  • 08.22 练习
  • 08.23 总结

• 9 并发-Goroutines,Channel和Pipeline

  • 09.1 关于进程，线程和Go协程
    • 09.1.1 Go调度器
    • 09.1.2 并发与并行
  • 09.2 Goroutines
    • 09.2.1 创建一个Goroutine
    • 09.2.2 创建多个Goroutine
  • 09.3 优雅地结束goroutines
    • 09.3.1 当Add()和Done()的数量不匹配时会发生什么？
  • 09.4 Channel(通道)
    • 09.4.1 通道的写入
    • 09.4.2 从通道接收数据
    • 09.4.3 通道作为函数参数传递
  • 09.5 管道
  • 09.6 延展阅读
  • 09.7 练习
  • 09.8 本章小结

• 10 Go 并发-进阶讨论

  • 10.1 重温调度器
    • 10.1.1 环境变量 GOMAXPROCS
  • 10.2 select关键字
  • 10.3 goroutine超时检查的两种方式
    • 10.3.1 方式1
    • 10.3.2 方式2
  • 10.4 重温Channel（通道）
    • 10.4.1 信号通道
    • 10.4.2 可缓冲通道
    • 10.4.3 值为nil的通道
    • 10.4.4 传送channel的通道
    • 10.4.5 指定通道的执行顺序
  • 10.5 通过共享变量来共享内存
    • 10.5.1 sync.Mutex类型
      • 10.5.1.1 忘记解锁mutex的后果
    • 10.5.2 sync.RWMutex类型
    • 10.5.3 通过goroutine共享内存
  • 10.6 竞争状态
  • 10.7 关于context包
    • 10.7.1 context使用的高级示例
    • 10.7.2 工作池
  • 10.8 延展阅读
  • 10.9 练习
  • 10.10 本章小结

• 11 代码测试，优化及分析

  • 11.1 本章使用的Go版本
  • 11.1.1 1.10和1.9版本对比
  • 11.2 安装beta或者RC版本
  • 11.3 关于优化
  • 11.4 优化你的Go代码
  • 11.5 分析Go代码
    • 11.5.1 标准库net/http/pprof
    • 11.5.2 代码分析示例
    • 11.5.3 用于分析的第三方包
    • 11.5.4 Go分析器的web接口
      • 11.5.4.1 使用web接口的分析示例
      • 11.5.4.2 Graphviz快览
  • 11.6 go tool的代码追踪
  • 11.7 测试
    • 11.7.1 编程测试代码
  • 11.8 基准测试
    • 11.8.1 基准测试示例
    • 11.8.2 错误的基准测试函数
  • 11.9 基准测试的缓冲写入
  • 11.10 揪出隐藏的代码
  • 11.11 交叉编译
  • 11.12 创建示例函数
  • 11.13 生成文档
  • 11.14 延展阅读
  • 11.15 练习
  • 11.16 本章小结

• 12 Go网络编程基础

  • 12.1 关于net/http,net和http.RoundTripper
    • 12.1.1 http.Response类型
    • 12.1.2 http.Request类型
    • 12.1.3 http.Transport类型
  • 12.2 关于TCP/IP
  • 12.3 关于IPv4和IPv6
  • 12.4 命令行工具netcat
  • 12.5 读取网络接口的配置文件
  • 12.6 实现DNS查询
    • 12.6.1 获取域名的 NS记录
    • 12.6.2 获取域名的 MX 记录
  • 12.7 Go实现web服务器
    • 12.7.1 分析HTTP服务
    • 12.7.2 用Go创建网站
  • 12.8 追踪 HTTP
    • 12.8.1 测试 HTTP handler
  • 12.9 Go实现web客户端
    • 12.9.1 Go web客户端进阶
  • 12.10 HTTP连接超时
    • 12.10.1 SetDeadline 介绍
    • 12.10.2 服务端设置超时时间
    • 12.10.3 设置超时的另外一种方法
  • 12.11 抓包工具Wireshark和tshark
  • 12.12 延展阅读
  • 12.13 练习
  • 12.14 本章小结

• 13 网络编程 - 构建服务器与客户端

  • 13.1 Go 标准库-net
  • 13.2 TCP 客户端
    • 13.2.1 另一个版本的 TCP 客户端
  • 13.3 TCP 服务器
    • 13.3.1 另一个版本的 TCP 服务器
  • 13.4 UDP 客户端
  • 13.5 UDP 服务器
  • 13.6 并发 TCP 服务器
    • 13.6.1 简洁的并发TCP服务器
  • 13.7 远程调用（RPC）
    • 13.7.1 RPC 客户端
    • 13.7.2 RPC 服务器
  • 13.8 底层网络编程
    • 13.8.1 获取ICMP数据
  • 13.9 接下来的任务
  • 13.10 延展阅读
  • 13.11 练习
  • 13.12 本章小节