Go 语言“避坑”与技巧
任何编程语言都不是完美的，Go 语言也是如此。Go 语言的某些特性在使用时如果不注意，也会造成一些错误，我们习惯上将这些造成错误的设计称为“坑”。
Go 语言的一些设计也具有与其他编程语言不一样的特性，能优雅、简单、高效地解决一些其他语言难以解决的问题。
本章将会对 Go 语言设计上可能发生错误的地方及 Go 语言本身的使用技巧进行总结和归纳。
goroutine（Go语言并发）如何使用才更加高效？
Go语言原生支持并发是被众人津津乐道的特性。goroutine 早期是 Inferno 操作系统的一个试验性特性，而现在这个特性与操作系统一起，将开发变得越来越简单。
很多刚开始使用 Go语言开发的人都很喜欢使用并发特性，而没有考虑并发是否真正能解决他们的问题。
了解 goroutine 的生命期时再创建 goroutine
在 Go语言中，开发者习惯将并发内容与 goroutine 一一对应地创建 goroutine。开发者很少会考虑 goroutine 在什么时候能退出和控制 goroutine 生命期，这就会造成 goroutine 失控的情况。下面来看一段代码。
失控的 goroutine：
package main
import (
"fmt"
"runtime"
)
// 一段耗时的计算函数
func consumer(ch chan int) {
// 无限获取数据的循环
for {
// 从通道获取数据
data := <-ch
// 打印数据
fmt.Println(data)
}
}
func main() {
// 创建一个传递数据用的通道
ch := make(chan int)
for {
// 空变量, 什么也不做
var dummy string
// 获取输入, 模拟进程持续运行
fmt.Scan(&dummy)
// 启动并发执行consumer()函数
go consumer(ch)
// 输出现在的goroutine数量
fmt.Println("goroutines:", runtime.NumGoroutine())
}
}代码说明如下：
第 9 行，consumer() 函数模拟平时业务中放到 goroutine 中执行的耗时操作。该函数从其他 goroutine 中获取和接收数据或者指令，处理后返回结果。
第 12 行，需要通过无限循环不停地获取数据。
第 15 行，每次从通道中获取数据。
第 18 行，模拟处理完数据后的返回数据。
第 26 行，创建一个整型通道。
第 34 行，使用 fmt.Scan() 函数接收数据时，需要提供变量地址。如果输入匹配的变量类型，将会成功赋值给变量。
第 37 行，启动并发执行 consumer() 函数，并传入 ch 通道。
第 40 行，每启动一个 goroutine，使用 runtime.NumGoroutine 检查进程创建的 goroutine 数量总数。
运行程序，每输入一个字符串+回车，将会创建一个 goroutine，结果如下：
a
goroutines: 2
b
goroutines: 3
c
goroutines: 4注意，结果中 a、b、c 为通过键盘输入的字符，其他为打印字符。
这个程序实际在模拟一个进程根据需要创建 goroutine 的情况。运行后，问题已经被暴露出来：随着输入的字符串越来越多，goroutine 将会无限制地被创建，但并不会结束。这种情况如果发生在生产环境中，将会造成内存大量分配，最终使进程崩溃。现实的情况也许比这段代码更加隐蔽：也许你设置了一个退出的条件，但是条件永远不会被满足或者触发。
为了避免这种情况，在这个例子中，需要为 consumer() 函数添加合理的退出条件，修改代码后如下：
package main
import (
"fmt"
"runtime"
)
// 一段耗时的计算函数
func consumer(ch chan int) {
// 无限获取数据的循环
for {
// 从通道获取数据
data := <-ch
if data == 0 {
break
}
// 打印数据
fmt.Println(data)
}
fmt.Println("goroutine exit")
}
func main() {
// 传递数据用的通道
ch := make(chan int)
for {
// 空变量, 什么也不做
var dummy string
// 获取输入, 模拟进程持续运行
fmt.Scan(&dummy)
if dummy == "quit" {
for i := 0; i < runtime.NumGoroutine()-1; i++ {
ch <- 0
}
continue
}
// 启动并发执行consumer()函数
go consumer(ch)
// 输出现在的goroutine数量
fmt.Println("goroutines:", runtime.NumGoroutine())
}
}代码中加粗部分是新添加的代码，具体说明如下：
第 17 行，为无限循环设置退出条件，这里设置 0 为退出。
第 41 行，当命令行输入 quit 时，进入退出处理的流程。
第 43 行，runtime.NumGoroutine 返回一个进程的所有 goroutine 数，main() 的 goroutine 也被算在里面。因此需要扣除 main() 的 goroutine 数。剩下的 goroutine 为实际创建的 goroutine 数，对这些 goroutine 进行遍历。
第 44 行，并发开启的 goroutine 都在竞争获取通道中的数据，因此只要知道有多少个 goroutine 需要退出，就给通道里发多少个 0。
修改程序并运行，结果如下：
a
goroutines: 2
b
goroutines: 3
quit
goroutine exit
goroutine exit
c
goroutines: 2避免在不必要的地方使用通道
通道（channel）和 map、切片一样，也是由 Go 源码编写而成。为了保证两个 goroutine 并发访问的安全性，通道也需要做一些锁操作，因此通道其实并不比锁高效。
下面的例子展示套接字的接收和并发管理。对于 TCP 来说，一般是接收过程创建 goroutine 并发处理。当套接字结束时，就要正常退出这些 goroutine。
本例完整代码请参考./src/chapter12/exitnotify/exitnotify.go。
本套教程所有源码下载地址：https://pan.baidu.com/s/1ORFVTOLEYYqDhRzeq0zIiQ 提取密码：hfyf
下面是对各个部分的详细分析。
1) 套接字接收部分
套接字在连接后，就需要不停地接收数据，代码如下：
// 套接字接收过程
func socketRecv(conn net.Conn, exitChan chan string) {
// 创建一个接收的缓冲
buff := make([]byte, 1024)
// 不停地接收数据
for {
// 从套接字中读取数据
_, err := conn.Read(buff)
// 需要结束接收, 退出循环
if err != nil {
break
}
}
// 函数已经结束, 发送通知
exitChan <- "recv exit"
}代码说明如下：
第 2 行传入的 net.Conn 是套接字的接口，exitChan 为退出发送同步通道。
第 5 行为套接字的接收数据创建一个缓冲。
第 8 行构建一个接收的循环，不停地接收数据。
第 11 行，从套接字中取出数据。这个例子中，不关注具体接收到的数据，只是关注错误，这里将接收到的字节数做匿名处理。
第 14 行，当套接字调用了 Close 方法时，会触发错误，这时需要结束接收循环。
第 21 行，结束函数时，与函数绑定的 goroutine 会同时结束，此时需要通知 main() 的 goroutine。
2) 连接、关闭、同步 goroutine 主流程部分
下面代码中尝试使用套接字的 TCP 协议连接一个网址，连接上后，进行数据接收，等待一段时间后主动关闭套接字，等待套接字所在的 goroutine 自然结束，代码如下：
func main() {
// 连接一个地址
conn, err := net.Dial("tcp", "www.163.com:80")
// 发生错误时打印错误退出
if err != nil {
fmt.Println(err)
return
}
// 创建退出通道
exit := make(chan string)
// 并发执行套接字接收
go socketRecv(conn, exit)
// 在接收时, 等待1秒
time.Sleep(time.Second)
// 主动关闭套接字
conn.Close()
// 等待goroutine退出完毕
fmt.Println(<-exit)
}代码说明如下：
第 4 行，使用 net.Dial 发起 TCP 协议的连接，调用函数就会发送阻塞直到连接超时或者连接完成。
第 7 行，如果连接发生错误，将会打印错误并退出。
第 13 行，创建一个通道用于退出信号同步，这个通道会在接收用的 goroutine 中使用。
第 16 行，并发执行接收函数，传入套接字和用于退出通知的通道。
第 19 行，接收需要一个过程，使用 time.Sleep() 等待一段时间。
第 22 行，主动关闭套接字，此时会触发套接字接收错误。
第 25 行，从 exit 通道接收退出数据，也就是等待接收 goroutine 结束。
在这个例子中，goroutine 退出使用通道来通知，这种做法可以解决问题，但是实际上通道中的数据并没有完全使用。
3) 优化：使用等待组替代通道简化同步
通道的内部实现代码在 Go语言开发包的 src/runtime/chan.go 中，经过分析后大概了解到通道也是用常见的互斥量等进行同步。因此通道虽然是一个语言级特性，但也不是被神化的特性，通道的运行和使用都要比传统互斥量、等待组（sync.WaitGroup）有一定的消耗。
所以在这个例子中，更建议使用等待组来实现同步，调整后的代码如下：
package main
import (
"fmt"
"net"
"sync"
"time"
)
// 套接字接收过程
func socketRecv(conn net.Conn, wg *sync.WaitGroup) {
// 创建一个接收的缓冲
buff := make([]byte, 1024)
// 不停地接收数据
for {
// 从套接字中读取数据
_, err := conn.Read(buff)
// 需要结束接收, 退出循环
if err != nil {
break
}
}
// 函数已经结束, 发送通知
wg.Done()
}
func main() {
// 连接一个地址
conn, err := net.Dial("tcp", "www.163.com:80")
// 发生错误时打印错误退出
if err != nil {
fmt.Println(err)
return
}
// 退出通道
var wg sync.WaitGroup
// 添加一个任务
wg.Add(1)
// 并发执行接收套接字
go socketRecv(conn, &wg)
// 在接收时, 等待1秒
time.Sleep(time.Second)
// 主动关闭套接字
conn.Close()
// 等待goroutine退出完毕
wg.Wait()
fmt.Println("recv done")
}调整后的代码说明如下：
第 45 行，声明退出同步用的等待组。
第 48 行，为等待组的计数器加 1，表示需要完成一个任务。
第 51 行，将等待组的指针传入接收函数。
第 60 行，等待等待组的完成，完成后打印提示。
第 30 行，接收完成后，使用 wg.Done() 方法将等待组计数器减一。
Go语言反射——性能和灵活性的双刃剑
现在的一些流行设计思想需要建立在反射基础上，如控制反转（Inversion Of Control，IOC）和依赖注入（Dependency Injection，DI）。Go语言中非常有名的 Web 框架 martini（https://github.com/go-martini/martini）就是通过依赖注入技术进行中间件的实现，例如使用 martini 框架搭建的 http 的服务器如下：
package main
import "github.com/go-martini/martini"
func main() {
m := martini.Classic()
m.Get("/", func() string {
return "Hello world!"
})
m.Run()
}第 7 行，响应路径/的代码使用一个闭包实现。如果希望获得 Go语言中提供的请求和响应接口，可以直接修改为：
m.Get("/", func(res http.ResponseWriter, req *http.Request) string {
// 响应处理代码……
})martini 的底层会自动通过识别 Get 获得的闭包参数情况，通过动态反射调用这个函数并传入需要的参数。martini 的设计广受好评，但同时也有人指出，其运行效率较低。其中最主要的因素是大量使用了反射。
虽然一般情况下，I/O 的延迟远远大于反射代码所造成的延迟。但是，更低的响应速度和更低的 CPU 占用依然是 Web 服务器追求的目标。因此，反射在带来灵活性的同时，也带上了性能低下的桎梏。
要用好反射这把双刃剑，就需要详细了解反射的性能。下面的一些基准测试从多方面对比了原生调用和反射调用的区别。
1) 结构体成员赋值对比
反射经常被使用在结构体上，因此结构体的成员访问性能就成为了关注的重点。下面例子中使用一个被实例化的结构体，访问它的成员，然后使用 Go语言的基准化测试可以迅速测试出结果。
反射性能测试的完整代码位于./src/chapter12/reflecttest/reflect_test.go，下面是对各个部分的详细说明。
本套教程所有源码下载地址：https://pan.baidu.com/s/1ORFVTOLEYYqDhRzeq0zIiQ 提取密码：hfyf
原生结构体的赋值过程：
// 声明一个结构体, 拥有一个字段
type data struct {
Hp int
}
func BenchmarkNativeAssign(b *testing.B) {
// 实例化结构体
v := data{Hp: 2}
// 停止基准测试的计时器
b.StopTimer()
// 重置基准测试计时器数据
b.ResetTimer()
// 重新启动基准测试计时器
b.StartTimer()
// 根据基准测试数据进行循环测试
for i := 0; i < b.N; i++ {
// 结构体成员赋值测试
v.Hp = 3
}
}代码说明如下：
第 2 行，声明一个普通结构体，拥有一个成员变量。
第 6 行，使用基准化测试的入口。
第 9 行，实例化 data 结构体，并给 Hp 成员赋值。
第 12～17 行，由于测试的重点必须放在赋值上，因此需要极大程度地降低其他代码的干扰，于是在赋值完成后，将基准测试的计时器复位并重新开始。
第 20 行，将基准测试提供的测试数量用于循环中。
第 23 行，测试的核心代码：结构体赋值。
接下来的代码分析使用反射访问结构体成员并赋值的过程。
func BenchmarkReflectAssign(b *testing.B) {
v := data{Hp: 2}
// 取出结构体指针的反射值对象并取其元素
vv := reflect.ValueOf(&v).Elem()
// 根据名字取结构体成员
f := vv.FieldByName("Hp")
b.StopTimer()
b.ResetTimer()
b.StartTimer()
for i := 0; i < b.N; i++ {
// 反射测试设置成员值性能
f.SetInt(3)
}
}代码说明如下：
第 6 行，取v的地址并转为反射值对象。此时值对象里的类型为 *data，使用值的 Elem() 方法取元素，获得 data 的反射值对象。
第 9 行，使用 FieldByName() 根据名字取出成员的反射值对象。
第 11～13 行，重置基准测试计时器。
第 18 行，使用反射值对象的 SetInt() 方法，给 data 结构的Hp字段设置数值 3。
这段代码中使用了反射值对象的 SetInt() 方法，这个方法的源码如下：
func (v Value) SetInt(x int64) {
v.mustBeAssignable()
switch k := v.kind(); k {
default:
panic(&ValueError{"reflect.Value.SetInt", v.kind()})
case Int:
*(*int)(v.ptr) = int(x)
case Int8:
*(*int8)(v.ptr) = int8(x)
case Int16:
*(*int16)(v.ptr) = int16(x)
case Int32:
*(*int32)(v.ptr) = int32(x)
case Int64:
*(*int64)(v.ptr) = x
}
}可以发现，整个设置过程都是指针转换及赋值，没有遍历及内存操作等相对耗时的算法。
2) 结构体成员搜索并赋值对比
func BenchmarkReflectFindFieldAndAssign(b *testing.B) {
v := data{Hp: 2}
vv := reflect.ValueOf(&v).Elem()
b.StopTimer()
b.ResetTimer()
b.StartTimer()
for i := 0; i < b.N; i++ {
// 测试结构体成员的查找和设置成员的性能
vv.FieldByName("Hp").SetInt(3)
}
}这段代码将反射值对象的 FieldByName() 方法与 SetInt() 方法放在循环里进行检测，主要对比测试 FieldByName() 方法对性能的影响。FieldByName() 方法源码如下：
func (v Value) FieldByName(name string) Value {
v.mustBe(Struct)
if f, ok := v.typ.FieldByName(name); ok {
return v.FieldByIndex(f.Index)
}
return Value{}
}底层代码说明如下：
第 3 行，通过名字查询类型对象，这里有一次遍历过程。
第 4 行，找到类型对象后，使用 FieldByIndex() 继续在值中查找，这里又是一次遍历。
经过底层代码分析得出，随着结构体字段数量和相对位置的变化，FieldByName() 方法比较严重的低效率问题。
3) 调用函数对比
反射的函数调用，也是使用反射中容易忽视的性能点，下面展示对普通函数的调用过程。
// 一个普通函数
func foo(v int) {
}
func BenchmarkNativeCall(b *testing.B) {
for i := 0; i < b.N; i++ {
// 原生函数调用
foo(0)
}
}
func BenchmarkReflectCall(b *testing.B) {
// 取函数的反射值对象
v := reflect.ValueOf(foo)
b.StopTimer()
b.ResetTimer()
b.StartTimer()
for i := 0; i < b.N; i++ {
// 反射调用函数
v.Call([]reflect.Value{reflect.ValueOf(2)})
}
}代码说明如下：
第 2 行，一个普通的只有一个参数的函数。
第 10 行，对原生函数调用的性能测试。
第 17 行，根据函数名取出反射值对象。
第 25 行，使用 reflect.ValueOf(2) 将 2 构造为反射值对象，因为反射函数调用的参数必须全是反射值对象，再使用 []reflect.Value 构造多个参数列表传给反射值对象的 Call() 方法进行调用。
反射函数调用的参数构造过程非常复杂，构建很多对象会造成很大的内存回收负担。Call() 方法内部就更为复杂，需要将参数列表的每个值从 reflect.Value 类型转换为内存。调用完毕后，还要将函数返回值重新转换为 reflect.Value 类型返回。因此，反射调用函数的性能堪忧。
4) 基准测试结果对比
测试结果如下：
$ go test -v -bench=.
goos: linux
goarch: amd64
BenchmarkNativeAssign-4 2000000000 0.32 ns/op
BenchmarkReflectAssign-4 300000000 4.42 ns/op
BenchmarkReflectFindFieldAndAssign-4 20000000 91.6 ns/op
BenchmarkNativeCall-4 2000000000 0.33 ns/op
BenchmarkReflectCall-4 10000000 163 ns/op
PASS结果分析如下：
第 4 行，原生的结构体成员赋值，每一步操作耗时 0.32 纳秒，这是参考基准。
第 5 行，使用反射的结构体成员赋值，操作耗时 4.42 纳秒，比原生赋值多消耗 13 倍的性能。
第 6 行，反射查找结构体成员且反射赋值，操作耗时 91.6 纳秒，扣除反射结构体成员赋值的 4.42 纳秒还富余，性能大概是原生的 272 倍。这个测试结果与代码分析结果很接近。SetInt 的性能可以接受，但 FieldByName() 的性能就非常低。
第 7 行，原生函数调用，性能与原生访问结构体成员接近。
第 8 行，反射函数调用，性能差到“爆棚”，花费了 163 纳秒，操作耗时比原生多消耗 494 倍。
经过基准测试结果的数值分析及对比，最终得出以下结论：
- 能使用原生代码时，尽量避免反射操作。
- 提前缓冲反射值对象，对性能有很大的帮助。
- 避免反射函数调用，实在需要调用时，先提前缓冲函数参数列表，并且尽量少地使用返回值。
Go语言接口的nil判断
nil 在 Go语言中只能被赋值给指针和接口。接口在底层的实现有两个部分：type 和 data。在源码中，显式地将 nil 赋值给接口时，接口的 type 和 data 都将为 nil。此时，接口与 nil 值判断是相等的。但如果将一个带有类型的 nil 赋值给接口时，只有 data 为 nil，而 type 为 nil，此时，接口与 nil 判断将不相等。
接口与 nil 不相等
下面代码使用 MyImplement() 实现 fmt 包中的 Stringer 接口，这个接口的定义如下：
type Stringer interface {
String() string
}在 GetStringer() 函数中将返回这个接口。通过 *MyImplement 指针变量置为 nil 提供 GetStringer 的返回值。在 main() 中，判断 GetStringer 与 nil 是否相等，代码如下：
package main
import "fmt"
// 定义一个结构体
type MyImplement struct{}
// 实现fmt.Stringer的String方法
func (m *MyImplement) String() string {
return "hi"
}
// 在函数中返回fmt.Stringer接口
func GetStringer() fmt.Stringer {
// 赋nil
var s *MyImplement = nil
// 返回变量
return s
}
func main() {
// 判断返回值是否为nil
if GetStringer() == nil {
fmt.Println("GetStringer() == nil")
} else {
fmt.Println("GetStringer() != nil")
}
}代码说明如下：
第 9 行，实现 fmt.Stringer 的 String() 方法。
第 21 行，s 变量此时被 fmt.Stringer 接口包装后，实际类型为 MyImplement，值为 nil 的接口。
第 27 行，使用 GetStringer() 的返回值与 nil 判断时，虽然接口里的 value 为 nil，但 type 带有 MyImplement 信息，使用 == 判断相等时，依然不为 nil。
发现 nil 类型值返回时直接返回 nil
为了避免这类误判的问题，可以在函数返回时，发现带有 nil 的指针时直接返回 nil，代码如下：
func GetStringer() fmt.Stringer {
var s *MyImplement = nil
if s == nil {
return nil
}
return s
}Go语言map的多键索引——多个数值条件可以同时查询
在大多数的编程语言中，映射容器的键必须以单一值存在。这种映射方法经常被用在诸如信息检索上，如根据通讯簿的名字进行检索。但随着查询条件越来越复杂，检索也会变得越发困难。下面例子中涉及通讯簿的结构，结构如下：
// 人员档案
type Profile struct {
Name string // 名字
Age int // 年龄
Married bool // 已婚
}并且准备好了一堆原始数据，需要算法实现构建索引和查询的过程，代码如下：
func main() {
list := []*Profile{
{Name: "张三", Age: 30, Married: true},
{Name: "李四", Age: 21},
{Name: "王麻子", Age: 21},
}
buildIndex(list)
queryData("张三", 30)
}需要用算法实现 buildIndex() 构建索引函数及 queryData() 查询数据函数，查询到结果后将数据打印出来。
下面，分别基于传统的基于哈希值的多键索引和利用 map 特性的多键索引进行查询。
基于哈希值的多键索引及查询
传统的数据索引过程是将输入的数据做特征值。这种特征值有几种常见做法：
- 将特征使用某种算法转为整数，即哈希值，使用整型值做索引。
- 将特征转为字符串，使用字符串做索引。
数据都基于特征值构建好索引后，就可以进行查询。查询时，重复这个过程，将查询条件转为特征值，使用特征值进行查询得到结果。
基于哈希的传统多键索引和查询的完整代码位于./src/chapter12/classic/classic.go，下面是对各个部分的分析。
本套教程所有源码下载地址：https://pan.baidu.com/s/1ORFVTOLEYYqDhRzeq0zIiQ 提取密码：hfyf
1) 字符串转哈希值
本例中，查询键（classicQueryKey）的特征值需要将查询键中每一个字段转换为整型，字符串也需要转换为整型值，这里使用一种简单算法将字符串转换为需要的哈希值，代码如下：
func simpleHash(str string) (ret int) {
// 遍历字符串中的每一个ASCII字符
for i := 0; i < len(str); i++ {
// 取出字符
c := str[i]
// 将字符的ASCII码相加
ret += int(c)
}
return
}代码说明如下：
第 1 行传入需要计算哈希值的字符串。
第 4 行，根据字符串的长度，遍历这个字符串的每一个字符，以 ASCII 码为单位。
第 9 行，c 变量的类型为 uint8，将其转为 int 类型并累加。
哈希算法有很多，这里只是选用一种大家便于理解的算法。哈希算法的选用的标准是尽量减少重复键的发生，俗称“哈希冲撞”，即同样两个字符串的哈希值重复率降到最低。
2) 查询键
有了哈希算法函数后，将哈希函数用在查询键结构中。查询键结构如下：
// 查询键
type classicQueryKey struct {
Name string // 要查询的名字
Age int // 要查询的年龄
}
// 计算查询键的哈希值
func (c *classicQueryKey) hash() int {
// 将名字的Hash和年龄哈希合并
return simpleHash(c.Name) + c.Age*1000000
}代码说明如下：
第 2 行，声明查询键的结构，查询键包含需要索引和查询的字段。
第 8 行，查询键的成员方法哈希，通过调用这个方法获得整个查询键的哈希值。
第 10 行，查询键哈希的计算方法：使用 simpleHash() 函数根据给定的名字字符串获得其哈希值。同时将年龄乘以 1000000 与名字哈希值相加。
哈希值构建过程如下图所示
3) 构建索引
本例需要快速查询，因此需要提前对已有的数据构建索引。前面已经准备好了数据查询键，使用查询键获得哈希即可对数据进行快速索引，参考下面的代码：
// 创建哈希值到数据的索引关系
var mapper = make(map[int][]*Profile)
// 构建数据索引
func buildIndex(list []*Profile) {
// 遍历所有的数据
for _, profile := range list {
// 构建数据的查询索引
key := classicQueryKey{profile.Name, profile.Age}
// 计算数据的哈希值, 取出已经存在的记录
existValue := mapper[key.hash()]
// 将当前数据添加到已经存在的记录切片中
existValue = append(existValue, profile)
// 将切片重新设置到映射中
mapper[key.hash()] = existValue
}
}代码说明如下：
第 2 行，实例化一个 map，键类型为整型，保存哈希值；值类型为 *Profile，为通讯簿的数据格式。
第 5 行，构建索引函数入口，传入数据切片。
第 8 行，遍历数据切片的所有数据元素。
第 11 行，使用查询键（classicQueryKey）来辅助计算哈希值，查询键需要填充两个字段，将数据中的名字和年龄赋值到查询键中进行保存。
第 14 行，使用查询键的哈希方法计算查询键的哈希值。通过这个值在 mapper 索引中查找相同哈希值的数据切片集合。因为哈希函数不能保证不同数据的哈希值一定完全不同，因此要考虑在发生哈希值重复时的处理办法。
第 17 行，将当前数据添加到可能存在的切片中。
第 20 行，将新添加好的数据切片重新赋值到相同哈希的 mapper 中。
具体哈希结构如下图所示。
图：哈希结构
这种多键的算法就是哈希算法。map 的多个元素对应哈希的“桶”。哈希函数的选择决定桶的映射好坏，如果哈希冲撞很厉害，那么就需要将发生冲撞的相同哈希值的元素使用切片保存起来。
4) 查询逻辑
从已经构建好索引的数据中查询需要的数据流程如下：
- 给定查询条件（名字、年龄）。
- 根据查询条件构建查询键。
- 查询键生成哈希值。
- 根据哈希值在索引中查找数据集合。
- 遍历数据集合逐个与条件比对。
- 获得结果。
func queryData(name string, age int) {
// 根据给定查询条件构建查询键
keyToQuery := classicQueryKey{name, age}
// 计算查询键的哈希值并查询, 获得相同哈希值的所有结果集合
resultList := mapper[keyToQuery.hash()]
// 遍历结果集合
for _, result := range resultList {
// 与查询结果比对, 确认找到打印结果
if result.Name == name && result.Age == age {
fmt.Println(result)
return
}
}
// 没有查询到时, 打印结果
fmt.Println("no found")
}代码说明如下：
第 1 行，查询条件（名字、年龄）。
第 4 行，根据查询条件构建查询键。
第 7 行，使用查询键计算哈希值，使用哈希值查询相同哈希值的所有数据集合。
第 10 行，遍历所有相同哈希值的数据集合。
第 13 行，将每个数据与查询条件进行比对，如果一致，表示已经找到结果，打印并返回。
第 20 行，没有找到记录时，打印 no found。
利用 map 特性的多键索引及查询
使用结构体进行多键索引和查询比传统的写法更为简单，最主要的区别是无须准备哈希函数及相应的字段无须做哈希合并。看下面的实现流程。
利用map特性的多键索引和查询的代码位于./src/chapter12/multikey/multikey.go，下面是对各个部分的分析。
本套教程所有源码下载地址：https://pan.baidu.com/s/1ORFVTOLEYYqDhRzeq0zIiQ 提取密码：hfyf
1) 构建索引
代码如下：
// 查询键
type queryKey struct {
Name string
Age int
}
// 创建查询键到数据的映射
var mapper = make(map[queryKey]*Profile)
// 构建查询索引
func buildIndex(list []*Profile) {
// 遍历所有数据
for _, profile := range list {
// 构建查询键
key := queryKey{
Name: profile.Name,
Age: profile.Age,
}
// 保存查询键
mapper[key] = profile
}
}代码说明如下：
第 2 行，与基于哈希值的查询键的结构相同。
第 8 行，在 map 的键类型上，直接使用了查询键结构体。注意，这里不使用查询键的指针。同时，结果只有 Profile 类型，而不是 Profile 切片，表示查到的结果唯一。
第 17 行，类似的，使用遍历到的数据的名字和年龄构建查询键。
第 23 行，更简单的，直接将查询键保存对应的数据。
2) 查询逻辑
// 根据条件查询数据
func queryData(name string, age int) {
// 根据查询条件构建查询键
key := queryKey{name, age}
// 根据键值查询数据
result, ok := mapper[key]
// 找到数据打印出来
if ok {
fmt.Println(result)
} else {
fmt.Println("no found")
}
}代码说明如下：
第 5 行，根据查询条件（名字、年龄）构建查询键。
第 8 行，直接使用查询键在 map 中查询结果。
第 12 行，找到结果直接打印。
第 14 行，没有找到结果打印 no found。
总结
基于哈希值的多键索引查询和利用 map 特性的多键索引查询的代码复杂程度显而易见。聪明的程序员都会利用 Go语言的特性进行快速的多键索引查询。
其实，利用 map 特性的例子中的 map 类型即便修改为下面的格式，也一样可以获得同样的结果：
var mapper = make(map[interface{}]*Profile)代码量大大减少的关键是：Go语言的底层会为 map 的键自动构建哈希值。能够构建哈希值的类型必须是非动态类型、非指针、函数、闭包。
- 非动态类型：可用数组，不能用切片。
- 非指针：每个指针数值都不同，失去哈希意义。
- 函数、闭包不能作为 map 的键。
Go语言与C/C++进行交互
本节将分别为大家讲解 Go语言是如何与 C/C++ 进行交互的。
与 C语言进行交互
工具 cgo 提供了对 FFI（外部函数接口）的支持，能够使用 Go语言代码安全地调用 C语言库，可以访问 cgo 文档主页：https://golang.google.cn/cmd/cgo/。cgo 会替代 Go 编译器来产生可以组合在同一个包中的 Go 和 C 代码。
在实际开发中一般使用 cgo 创建单独的 C 代码包。如果想要在 Go 程序中使用 cgo，则必须在单独的一行使用 import "C" 来导入，一般来说你可能还需要 import "unsafe" 。
然后，可以在 import "C" 之前使用注释（单行或多行注释均可）的形式导入 C语言库（甚至有效的 C语言代码），它们之间没有空行，例如：
// #include
// #include
import "C" 名称 "C" 并不属于标准库的一部分，这只是 cgo 集成的一个特殊名称用于引用 C 的命名空间。在这个命名空间里所包含的 C 类型都可以被使用，例如 C.uint 、C.long 等等，还有 libc 中的函数 C.random() 等也可以被调用。
当想要使用某个类型作为 C 中函数的参数时，必须将其转换为 C 中的类型，反之亦然，例如：
var i int
C.uint(i) // 从 Go 中的 int 转换为 C 中的无符号 int
int(C.random()) // 从 C 中 random() 函数返回的 long 转换为 Go 中的 int【示例 1】下面的 2 个 Go 函数 Random() 和 Seed() 分别调用了 C 中的 C.random() 和 C.srandom()。
package rand
// #include
import "C"
func Random() int {
return int(C.random())
}
func Seed(i int) {
C.srandom(C.uint(i))
} C语言当中并没有明确的字符串类型，如果你想要将一个 string 类型的变量从 Go 转换到 C 时，可以使用 C.CString(s)；同样，可以使用 C.GoString(cs) 从 C 转换到 Go 中的 string 类型。
Go 的内存管理机制无法管理通过 C 代码分配的内存。开发人员需要通过手动调用 C.free 来释放变量的内存：
defer C.free(unsafe.Pointer(Cvariable))这一行最好紧跟在使用 C 代码创建某个变量之后，这样就不会忘记释放内存了。
【示例 2】下面的代码展示了如何使用 cgo 创建变量、使用并释放其内存：
package print
// #include
// #include
import "C"
import "unsafe"
func Print(s string) {
cs := C.CString(s)
defer C.free(unsafe.Pointer(cs))
C.fputs(cs, (*C.FILE)(C.stdout))
} 构建 cgo 包
除了使用变量 GOFILES 之外，还需要使用变量 CGOFILES 来列出需要使用 cgo 编译的文件列表。例如，可以使用包含以下内容的 Makefile 文件来编译，可以使用 gomake 或 make：
include $(GOROOT)/src/Make.inc
TARG=rand
CGOFILES=\
c1.go\
include $(GOROOT)/src/Make.pkg与 C++ 进行交互
SWIG（简化封装器和接口生成器）支持在 Linux 系统下使用 Go语言代码调用 C 或者 C++ 代码。这里有一些使用 SWIG 的注意事项：
- 编写需要封装的库的 SWIG 接口。
- SWIG 会产生 C 的存根函数。
- 这些库可以使用 cgo 来调用。
- 相关的 Go 文件也可以被自动生成。
这类接口支持方法重载、多重继承以及使用 Go 代码实现 C++ 的抽象类。
目前使用 SWIG 存在的一个问题是它无法支持所有的 C++ 库，比如说它就无法解析 TObject.h。
Go语言文件读写
本节将通过示例来为大家介绍 Go语言中文件读写的相关操作。
读文件
在 Go语言中，文件使用指向 os.File 类型的指针来表示的，也叫做文件句柄。在前面章节使用到过标准输入 os.Stdin 和标准输出 os.Stdout ，他们的类型都是 *os.File 。让我们来看看下面这个程序：
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
inputFile, inputError := os.Open("input.dat")
if inputError != nil {
fmt.Printf("An error occurred on opening the inputfile\n" +
"Does the file exist?\n" +
"Have you got acces to it?\n")
return // exit the function on error
}
defer inputFile.Close()
inputReader := bufio.NewReader(inputFile)
for {
inputString, readerError := inputReader.ReadString('\n')
if readerError == io.EOF {
return
}
fmt.Printf("The input was: %s", inputString)
}
}变量 inputFile 是 *os.File 类型的。该类型是一个结构，表示一个打开文件的描述符（文件句柄）。然后，使用 os 包里的 Open 函数来打开一个文件。该函数的参数是文件名，类型为 string。在上面的程序中，我们以只读模式打开 input.dat 文件。
如果文件不存在或者程序没有足够的权限打开这个文件，Open 函数会返回一个错误：
inputFile, inputError = os.Open("input.dat")如果文件打开正常，我们就使用 defer.Close() 语句确保在程序退出前关闭该文件。然后，我们使用 bufio.NewReader 来获得一个读取器变量。
通过使用 bufio 包提供的读取器（写入器也类似），如上面程序所示，我们可以很方便的操作相对高层的 string 对象，而避免了去操作比较底层的字节。
接着，我们在一个无限循环中使用 ReadString('\n') 或 ReadBytes('\n') 将文件的内容逐行（行结束符 '\n'）读取出来。
注意：在之前的例子中，我们看到，Unix 和 Linux 的行结束符是 \n，而 Windows 的行结束符是 \r\n。在使用 ReadString 和 ReadBytes 方法的时候，我们不需要关心操作系统的类型，直接使用 \n 就可以了。另外，我们也可以使用 ReadLine() 方法来实现相同的功能。
一旦读取到文件末尾，变量 readerError 的值将变成非空（事实上，常亮 io.EOF 的值是 true），我们就会执行 return 语句从而退出循环。
其他类似函数：
1) 将整个文件的内容读到一个字符串里
如果想将整个文件的内容读到一个字符串里，可以使用 io/ioutil 包里的 ioutil.ReadFile() 方法，该方法第一个返回值的类型是 []byte ，里面存放读取到的内容，第二个返回值是错误，如果没有错误发生，第二个返回值为 nil。
【示例 1】使用函数 WriteFile() 将 []byte 的值写入文件。
package main
import (
"fmt"
"io/ioutil"
"os"
)
func main() {
inputFile := "products.txt"
outputFile := "products_copy.txt"
buf, err := ioutil.ReadFile(inputFile)
if err != nil {
fmt.Fprintf(os.Stderr, "File Error: %s\n", err)
// panic(err.Error())
}
fmt.Printf("%s\n", string(buf))
err = ioutil.WriteFile(outputFile, buf, 0x644)
if err != nil {
panic(err. Error())
}
}2) 带缓冲的读取
在很多情况下，文件的内容是不按行划分的，或者干脆就是一个二进制文件。在这种情况下，ReadString() 就无法使用了，我们可以使用 bufio.Reader 的 Read() ，它只接收一个参数：
buf := make([]byte, 1024)
...
n, err := inputReader.Read(buf)
if (n == 0) { break}变量 n 的值表示读取到的字节数.
3) 按列读取文件中的数据
如果数据是按列排列并用空格分隔的，你可以使用 fmt 包提供的以 FScan 开头的一系列函数来读取他们。
【示例 2】将 3 列的数据分别读入变量 v1、v2 和 v3 内，然后分别把他们添加到切片的尾部。
package main
import (
"fmt"
"os"
)
func main() {
file, err := os.Open("products2.txt")
if err != nil {
panic(err)
}
defer file.Close()
var col1, col2, col3 []string
for {
var v1, v2, v3 string
_, err := fmt.Fscanln(file, &v1, &v2, &v3)
// scans until newline
if err != nil {
break
}
col1 = append(col1, v1)
col2 = append(col2, v2)
col3 = append(col3, v3)
}
fmt.Println(col1)
fmt.Println(col2)
fmt.Println(col3)
}输出结果：
[ABC FUNC GO]
[40 56 45]
[150 280 356]注意：path 包里包含一个子包叫 filepath ，这个子包提供了跨平台的函数，用于处理文件名和路径。例如 Base() 函数用于获得路径中的最后一个元素（不包含后面的分隔符）：
import "path/filepath"
filename := filepath.Base(path)compress 包：读取压缩文件
compress 包提供了读取压缩文件的功能，支持的压缩文件格式为：bzip2、flate、gzip、lzw 和 zlib。
【示例 3】使用 Go语言读取一个 gzip 文件。
package main
import (
"fmt"
"bufio"
"os"
"compress/gzip"
)
func main() {
fName := "MyFile.gz"
var r *bufio.Reader
fi, err := os.Open(fName)
if err != nil {
fmt.Fprintf(os.Stderr, "%v, Can't open %s: error: %s\n", os.Args[0], fName,
err)
os.Exit(1)
}
fz, err := gzip.NewReader(fi)
if err != nil {
r = bufio.NewReader(fi)
} else {
r = bufio.NewReader(fz)
}
for {
line, err := r.ReadString('\n')
if err != nil {
fmt.Println("Done reading file")
os.Exit(0)
}
fmt.Println(line)
}
}写文件
请看以下程序：
package main
import (
"os"
"bufio"
"fmt"
)
func main () {
// var outputWriter *bufio.Writer
// var outputFile *os.File
// var outputError os.Error
// var outputString string
outputFile, outputError := os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)
if outputError != nil {
fmt.Printf("An error occurred with file opening or creation\n")
return
}
defer outputFile.Close()
outputWriter := bufio.NewWriter(outputFile)
outputString := "hello world!\n"
for i:=0; i<10; i++ {
outputWriter.WriteString(outputString)
}
outputWriter.Flush()
}除了文件句柄，我们还需要 bufio 的写入器。我们以只读模式打开文件 output.dat ，如果文件不存在则自动创建：
outputFile, outputError := os.OpenFile(“output.dat”, os.O_WRONLY|os.O_ CREATE, 0666)可以看到，OpenFile 函数有三个参数：文件名、一个或多个标志（使用逻辑运算符“|”连接），使用的文件权限。
我们通常会用到以下标志：
- os.O_RDONLY：只读
- os.WRONLY：只写
- os.O_CREATE：创建：如果指定文件不存在，就创建该文件。
- os.O_TRUNC：截断：如果指定文件已存在，就将该文件的长度截为 0。
在读文件的时候，文件的权限是被忽略的，所以在使用 OpenFile 时传入的第三个参数可以用 0。而在写文件时，不管是 Unix 还是 Windows，都需要使用 0666。
然后，我们创建一个写入器（缓冲区）对象：
outputWriter := bufio.NewWriter(outputFile)接着，使用一个 for 循环，将字符串写入缓冲区，写 10 次：
outputWriter.WriteString(outputString)缓冲区的内容紧接着被完全写入文件：outputWriter.Flush()
如果写入的东西很简单，我们可以使用fmt.Fprintf(outputFile, “Some test data.\n”)直接将内容写入文件。fmt 包里的 F 开头的 Print 函数可以直接写入任何 io.Writer，包括文件。
【示例 4】不使用 fmt.FPrintf 函数，使用其他函数如何写文件：
package main
import "os"
func main() {
os.Stdout.WriteString("hello, world\n")
f, _ := os.OpenFile("test", os.O_CREATE|os.O_WRONLY, 0)
defer f.Close()
f.WriteString("hello, world in a file\n")
}使用os.Stdout.WriteString("hello, world\n")，我们可以输出到屏幕。以只写模式创建或打开文件“test”，并且忽略了可能发生的错误：
f, _ := os.OpenFile(“test”, os.O_CREATE|os.O_WRONLY, 0)不使用缓冲区，直接将内容写入文件：f.WriteString()
Json数据编码和解码
数据结构要在网络中传输或保存到文件，就必须对其编码和解码；目前存在很多编码格式：JSON，XML，gob，Google 缓冲协议等等。Go语言支持所有这些编码格式。
结构可能包含二进制数据，如果将其作为文本打印，那么可读性是很差的。另外结构内部可能包含匿名字段，而不清楚数据的用意。
通过把数据转换成纯文本，使用命名的字段来标注，让其具有可读性。这样的数据格式可以通过网络传输，而且是与平台无关的，任何类型的应用都能够读取和输出，不与操作系统和编程语言的类型相关。
下面是一些术语说明：
数据结构 --> 指定格式 = 序列化 或 编码（传输之前）
指定格式 --> 数据格式 = 反序列化 或 解码（传输之后）
序列化是在内存中把数据转换成指定格式（data -> string），反之亦然（string -> data structure）编码也是一样的，只是输出一个数据流（实现了 io.Writer 口）；解码是从一个数据流（实现了
io.Reader）输出到一个数据结构。
也许大家比较熟悉 XML 格式，但有些时候 JSON 格式被作为首选，主要是由于其格式上非常简洁。通常 JSON 被用于 web 后端和浏览器之间的通讯，但是在其它场景也同样的有用。
这是一个简短的 JSON 片段：
{
"Person": {
"FirstName": "Laura",
"LastName": "Lynn"
}
}尽管 XML 被广泛的应用，但是 JSON 更加简洁、轻量（占用更少的内存、磁盘及网络带宽）和更好的可读性，这也说明它越来越受欢迎。
Go语言的 json 包可以让你在程序中方便的读取和写入 JSON 数据。代码如下所示：
// json.go.go
package main
import (
"encoding/json"
"fmt"
"log"
"os"
)
type Address struct {
Type string
City string
Country string
}
type VCard struct {
FirstName string
LastName string
Addresses []*Address
Remark string
}
func main() {
pa := &Address{"private", "Aartselaar", "Belgium"}
wa := &Address{"work", "Boom", "Belgium"}
vc := VCard{"Jan", "Kersschot", []*Address{pa, wa}, "none"}
// fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}:
// JSON format:
js, _ := json.Marshal(vc)
fmt.Printf("JSON format: %s", js)
// using an encoder:
file, _ := os.OpenFile("vcard.json", os.O_CREATE|os.O_WRONLY, 0)
defer file.Close()
enc := json.NewEncoder(file)
err := enc.Encode(vc)
if err != nil {
log.Println("Error in encoding json")
}
}json.Marshal() 的函数签名是func Marshal(v interface{}) ([]byte, error)，下面是数据编码后的 JSON 文本（实际上是一个 []bytes）：
{
"FirstName": "Jan",
"LastName": "Kersschot",
"Addresses": [{
"Type": "private",
"City": "Aartselaar",
"Country": "Belgium"
}, {
"Type": "work",
"City": "Boom",
"Country": "Belgium"
}],
"Remark": "none"
}出于安全考虑，在 web 应用中最好使用json.MarshalforHTML() 函数，其对数据执行 HTML 转码，所以文本可以被安全地嵌在 HTML