Shenlvmeng's Blog

又一年的开头，又一年的结尾，又一年的回首，又一年的新的惊喜。

回头看看去年写的，除了一些认为一定会发生的果然发生了之外，还出现了更多没想到的情况。又或许生活本就这么多意外，真是有趣。

2019

flag验收

• 内在素质：通过看书对做事的方法论有了比较清晰的认识，同时在“成为什么样的人”上也更有想法，更自信
  • 看了8本扎实的书（有趣的是数目和去年一样），范围不仅局限在技术（只有2本和技术相关），均有博客积累
    • 《高效能人士的七个习惯》——自我管理的理想模型
    • 关于《万历十五年》的一些思考
    • 《人生的智慧》 ——幸福与人生
    • 《经济学原理》 - 微观经济学原理笔记
    • 《程序员修炼之道》 —— 从小工到专家
    • 量子物理简史
    • 社会心理学 Part 1 - 导论 & 社会思维
    • 社会心理学 Part 2 - 社会影响
    • 社会心理学 Part 3 - 社会关系
    • 社会心理学 Part 4 - 应用
    • 《代码整洁之道》——有一个好的代码品味
  • 由于知识基数不够，尚未涌现出知识模型，还需要继续积累
• 个人形象：前半段（“干净会穿搭”）超额完成，有了些自己的sense，后半段（“身体健康开朗”）做得比较失败，甚至不如去年。
  • 工作日基本1点之后睡觉，起床时间9点半
  • 基本款各季衣物每月陆续置办中，有关注穿搭博主
    • 基本款长、短T
    • 牛仔/工装/9分/阔腿
    • 棒球帽/冬帽/渔夫帽
    • 卫衣/连帽卫衣
    • 牛仔/工装/飞行员/棒球外套
    • 皮/工装夹克
    • 手表/挂饰/围巾
    • 小白鞋/帆布鞋/板鞋/运动鞋
    • 香水/吹风机
  • 有了发型
  • 没有使用护肤产品
  • 锻炼身体上有退步，健康不如去年，体重增加
    • 游泳频率降低
    • 无器材健身频率降低
• 社交，可以更自如和陌生人交流，认识新的朋友。保持着和新朋友的亲密关系，也深交了新的异性朋友
• 生活情趣
  • 坚持着已有爱好
    • 拉琴：重拾了拉琴，但还没有明确的目标
    • 骑行：不如去年里程，爬坡有所退步，也没有出远门，但探索了北京东部、南部、西南部新路线。
      • 廊坊
      • 大兴机场
      • 香山
      • 唱歌：学习了恭太郎rap版《恋爱循环》和米津玄师的《LOSER》，KTV现场节目效果满分，还学了《I’m not afraid》半途而废
  • 去了丽江/大理/上海（之前去过）
  • 探索了新爱好，感觉很棒
    • 清吧喝酒
    • 剧本杀
• 工作事业
  • 超水平发挥，渐渐在寻找定位
  • 技术上还在积累，并没有突破
  • 业务上已经能handle一个小方向，并带实习生

好的 & 不好的

• 看书面变广是好事，书也是好书，不过数目还不够
• 穿搭进步太多，也有了自己想法。不过局限在休闲风，可以尝试更多风格（如成熟干练）
• 身体健康和作息习惯退步
• 找女朋友这一目标又拖了一年
• 对关系亲密的人有时反应太寡淡。容易伤人
• 生活情趣上更丰富，但还可以再多探索，另外热情不足，积累不足
• 工作事业比预想中顺利且乐观，要继续保持，适应新环境

2020

下面是2020的展望：

• 内在素质：在编程相关领域上有更多积累，以应对未来的职业挑战，要能形成知识体系则更好
  • 看完囤积的7本书（碰巧又和去年一样），形成研发知识体系积累
    • 学至少1门新语言
    • 了解至少1个其他领域
  • 看7本书之外的内容，积累通用素质和能力
• 个人形象：探索新风格，补充基本款，调整作息，维持体重
  • 每天最晚1点半前睡觉，9点起床
  • 控制饮食，体重回到<80
  • 补全基本款
    • 更多色系
    • 衬衫
    • 休闲西服、西裤、马甲、皮鞋
    • 篮球鞋、运动鞋
  • 尝试新发型
• 社交，更热情，在找对象上努努力
• 生活情趣
  • 去不止1个城市，最好是国外
  • 骑行：青海湖、百里画廊
  • 拉琴：有最少1首能拿出来展示的曲目
  • 探索新爱好
    • livehouse
    • 艺术展、灯光秀
    • 探店
• 工作事业
  • 能带小团队、带好团队
  • 能想清楚自己优势、定位
  • 将手里业务方向做到优秀

写了这么多，希望不是flag。我们明年拭目以待咯~

Bye~

更多：go官网

题解：https://github.com/shenlvmeng/go-learning-exercise

历史

Go语言构想与2007年9月，于2009年11月发布。主要思想来自3种语言：

• C，基础语法和编译
• Pascal，包概念
• CSP（Communication Sequential Process），并发思想

Go项目诞生是为了解决Google中系统复杂性太高的问题。因此，简单性是Go思想的重要部分。设计上，Go

• 没有隐式类型转换
• 没有构造和析构函数
• 没有运算符重载
• 没有形参默认值
• 没有继承
• 没有泛型
• 没有异常
• 没有宏（macro）
• 没有函数注记
• 没有线程局部存储

快速开始

范例1：Hello world

1
2
3
4
5
6
7

package main

import "fmt"

func main() {
    fmt.Println("Hello world!")
}

在诸多语言中，C对Go的影响是最深的。.go文件需要经过编译成二进制文件才可以运行。

• go run可以直接运行.go文件
• go build可以编译生成二进制文件，并在之后直接执行

在代码结构上，

• 先声明当前包名，其中命名为main的包名代表代码是可执行程序，而非一个库文件
• 再import依赖包，go自带100+内置包。在编译时，编译器会抛弃未被使用的包，减少体积
• 接下来是程序代码，命名为main的函数是执行的入口

Go代码有着标准的代码格式，并可以通过gofmt格式化代码。代码中不需要在行尾写分号，后面紧跟特定token的换行符会自动转成分号。因此，Go代码中换行会影响代码编译。

范例2：命令行参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// version 1
package main

import (
    "fmt"
    "os"
)
func main() {
    var s, sep string
    for i:= 1; i < len(os.Args); i++ {
        s += setp + os.Args[i]
        setp = " "
    }
    fmt.Println(s)
}

• 切片（slice）是序列数组元素的表示方式，可以用s[i]或s[m:n]（m或n缺失是表示头和尾元素位置）获取1或n-m个元素。使用len(s)获取长度。
• 注释以//开头
• import多个库时，可以用()包裹列表的形式声明，这种写法更为常见
• 使用var开头表示变量声明，未指定初始值的变量会隐式初始化为当前类型的“零值”（0或’’等）
• :=式的声明可以省去var更快地为一组变量初始化
• go中的for循环是唯一的循环语句，分为以下三部分。缺失initialization和condition时可以表示while循环

1
2
3

for initialization; condition; post {
    // zero or more statements
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// version 2
package main

import (
    "fmt"
    "os"
)

func main() {
    s, sep := "", ""
    for _, arg := os.Args[1:] {
        s += sep + arg
        sep = " "
    }
    fmt.Println(s)
}

• 在循环中，range可以生产一对值，index和value
• _专门用来替代不需要使用的变量名，否则go会报错
• 另外也可以直接用strings.Join方法实现效果

范例3：寻找重复行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package main

import (
    "fmt"
    "bufio"
    "os"
)

func main() {
    counts = make(map[string]int)
    input = bufio.NewScanner(os.Stdin)
    for input.Scan() {
        counts[input.Text()]++
    }
    for line, n := range counts {
        if n > 1 {
            fmt.Printf("%d\t%s\n", n, line)
        }
    }
}

• 同for循环一样，if语句也不需要()包裹
• 内置的make函数可以创建一个新的map。map也可以被for循环遍历，每次循环的pair分别是key和value
• counts[input.Text()]中当key不存在时，会返回零值0
• bufio库可以更方便地帮忙处理程序的输入（input）和输出（output）
  • input.Scan()获取下一行，并自动去掉末尾换行符，在没有内容时返回false
  • input.Text()获取当前位置的文本
• Printf和C语言风格类似，里面行如%s，%v的特殊符号称为verbs

从文件中寻找代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

func main() {
    counts := make(map[string]int)
    files := os.Args[1:]
    if len(files) == 0 {
        countlines(os.Stdin, counts)
    } else {
        for _, file := range files {
            f, err := os.Open(file)
            if err != nil {
                fmt.Fprintf(os.Stderr, "dup: %v\n", err)
                continue
            }
            countLines(f, counts)
            f.Close()
        }
    }
    for line, n := range counts {
        if n > 1 {
            fmt.Printf("%d\t%s\n", n, lines)
        }
    }
}

func countlines(f *os.File, counts map[string]int) {
    input := bufio.NewScanner(f)
    for input.Scan() {
        counts[input.Text()]++
    }
    // error handling
}

除了上面的流模式读取文件外，还可以直接把整个文件直接读进内存，再将二进制数据string化并处理。此处可以使用io/ioutil中的ReadFile方法。转换过程用string(data)完成。

日常使用时，通常借助bufio，ioutil等高层级API就可以完成任务，而不需要深入实现内部。

范例4：Gif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

package main

import (
	"image"
	"image/color"
	"image/gif"
	"io"
	"math"
	"math/rand"
	"os"
)

var palette = []color.Color{color.White, color.Black}

const (
	whiteIndex = 0
	blackIndex = 1
)

func main() {
	lissajous(os.Stdout)
}

func lissajous(out io.Writer) {
	const (
		cycles  = 5
		res     = 0.001
		size    = 100
		nframes = 64
		delay   = 8
	)
	freq := rand.Float64() * 3.0
	anim := gif.GIF{LoopCount: nframes}
	phase := 0.0
	for i := 0; i < nframes; i++ {
		rect := image.Rect(0, 0, 2*size+1, 2*size+1)
		img := image.NewPaletted(rect, palette)
		for t := 0.0; t < cycles*2*math.Pi; t += res {
			x := math.Sin(t)
			y := math.Sin(t*freq + phase)
			img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5), blackIndex)
		}
		phase += 0.1
		anim.Delay = append(anim.Delay, delay)
		anim.Image = append(anim.Image, img)
	}
	gif.EncodeAll(out, &anim)
}

• 使用const声明常量，常量的值只能是number，string或boolean
• gif.GIF{...}是合成字面量的写法，其类型是struct，可以字面量声明其field，未声明fields均为零值（zero value）
• image库API可以操作图像

范例5：fetch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

const prefix = "http://"

func main() {
	for _, url := range os.Args[1:] {
		if !strings.HasPrefix(url, prefix) {
			url = prefix + url
		}
		resp, err := http.Get(url)
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
			os.Exit(1)
		}
		_, err = io.Copy(os.Stdout, resp.Body)
		resp.Body.Close()
		if err != nil {
			fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n", url, err)
		}
	}
}

• 和网络相关的API都位于net库中，如http.Get(url)
• os.Exit(1)代表异常退出

范例6：并行fetch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main

import (
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"time"
)

func main() {
	start := time.Now()
	ch := make(chan string)
	for _, url := range os.Args[1:] {
		go fetch(url, ch)
	}
	for range os.Args[1:] {
		fmt.Println(<-ch)
	}
	fmt.Printf("%.2fs elapse\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
	start := time.Now()
	res, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprint(err)
		return
	}
	nbytes, err := io.Copy(ioutil.Discard, res.Body)
	res.Body.Close()
	if err != nil {
		ch <- fmt.Sprintf("while reading %s: %v", url, err)
		return
	}
	secs := time.Since(start).Seconds()
	ch <- fmt.Sprintf("%.2fs %7d %s", secs, nbytes, url)
}

• goroutine是go中并行执行函数的表示，channel是goroutine间相互沟通的方式，传递特定类型数据。goroutine相互沟通时，沟通的两者会对其他goroutine block，保证没有冲突
  • goroutine使用go创建，channel使用chan创建，ch <-表示向channel发送，<- ch表示从channel接收
• ioutil.Discard输出流会直接丢弃流内容

范例7：web server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", handler)
	log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Path = %q\n", r.URL.Path)
}

• 使用http库的HandleFunc和ListenAndServer可以便捷地启动一个服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main

import (
	"fmt"
	"log"
	"net/http"
	"sync"
)

var mu sync.Mutex
var count int

func main() {
	http.HandleFunc("/", handle)
	http.HandleFunc("/count", counter)
	log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

func handle(w http.ResponseWriter, r *http.Request) {
	mu.Lock()
	count++
	mu.Unlock()
	fmt.Fprintf(w, "path = %q\n", r.URL.Path)
}

func counter(w http.ResponseWriter, r *http.Request) {
	mu.Lock()
	fmt.Fprintf(w, "count %d\n", count)
	mu.Unlock()
}

• server会为每个请求创建一个新的goroutine处理，为了避免并发读写count时的bug，使用了mutex锁保证读写是都是串行的
• os.Stdout,ioutil.Discard, http.ResponseWriter都实现了io.Writer接口，因此可以用在任何需要输出流的地方
• if语句前可以增加前置语句，如if err:=xxx; err != nil

杂项

• go中的switch没有fall through机制，若需要，需要显示声明fallthrough。case支持表达式，switch后支持没有操作数，此时的switch称为tagless switch。break, continue, goto命令如常
• go中有命名类型，类似ts中的interface，行如type Point struct { X, Y int }
• go中有指针，*表示去指针对应的值，&表示取变量的指针，另外不支持指针上的算术运算
• go中的方法指命名类型上的函数，interface意义如常
• 可以去这里寻找标准库的包，或去这里寻找社区贡献的包
• 注释风格同其他语言，//表示单行注释，/* */表示多行注释。不支持嵌套注释

程序结构

命名

和JS类似

• 以**Unicode字母或下划线_**开头
• 后跟Unicode字母或数字或下划线
• 大小写敏感

go目前（2020/01/01）有25个不允许用来命名的关键字，其中几个可能是对前端较难想到的是

• select
• defer
• chan
• range
• fallthrough

另外，还有一些预定义常量、类型、函数可以用来命名，但很容易造成误解，下面举些例子：

• 常量：true iota nil
• 类型：int complex128 uintptr rune error
• 函数：make len imag panic close

包名始终小写，在函数域内命名的函数只在函数域内可见，否则在整个包域内可见。整个包内声明的变量用首字母区分可见性：

• 首字母大写的可以被其他包访问，如fmt.FPrintf
• 反之则只在包内可见

命名长度没有限制，但建议scope越大的变量命名越长。Go使用驼峰风格的变量命名，首字母缩略词和首字母同大写或同小写。

声明

声明有4钟：

• var 变量
• const 常量
• type 类型
• func 函数

声明在函数域内可见，或在整个包域内可见。函数返回可以是一组变量。

变量

1

var name type = expression

Go中的变量声明如上所示，其中的type部分或expression部分可以省略，但是不能同时省略。

• type缺失时，name的类型由expression字面量或返回值决定
• expression缺失时，name的值自动设置为type类型的“零值”（zero value）
  • 数值零值为0，字符串零值为""，布尔类型零值为false
  • 其余接口或引用类型零值为nil，如指针、map、切片、函数、channel
  • 聚合类型的零值即其所有组成元素的零值

所以，Go中不存在未初始化的变量。包级别变量在main函数开始前初始化，局部变量在声明过程中初始化。一组变量可以同时被初始化。

1
2

var b, f, s = true, 1.3, "string"
var f, err = os.Open(name)

简写式

在函数域内的局部变量声明可以使用简写式，即:=。在已知变量初始值时可以省去写var。在初始值并不重要或最好显式写明类型时，还是使用var foo type的形式比较好。和var声明一样，也可以同时用简写式声明多个局部变量。但要注意，不要把这种写法和元组赋值（tuple assignment）搞混了。

1
2
3
4
5

// multiple initialzier expression
i, j := 1, true

// tuple assignment
i, j = j, i

另外，简写式声明里可以写部分已经声明的局部变量，在这里会当做赋值处理。但是简写式声明中要至少包含一个未声明变量

1
2

in, err := os.OpenFile(infile)
out, err := os.OpenFile(outfile)

指针

Go中的指针和C中类似，用&表示取一个变量的地址，用*表示访问某个地址所在的位置。指针的零值为nil，因此可以用p != nil来判断指针是否指向变量。

new函数

可以通过new函数，声明类型T创建新的匿名变量，函数返回变量的指针即*T类型。这在不需要变量名时很好用。每次调用new函数新建变量时，返回的地址不同，除非类型不附加任何信息，如struct {}或[0]int。

1
2

p := new(int)
*p = 2

另外，由于new只是预定义函数，所以可以用来做变量名。

生命周期

生命周期即变量从创建到被回收的时间。包级别的变量会在整个程序执行过程中存在。局部变量则会在未被引用（unreachable）时释放内存。Go中的垃圾回收机制会自动帮你完成这件事。但是如果有下面这种情况出现，则会阻止垃圾回收释放内存。

1
2
3
4
5
6

var global *int
func f() {
	var x int
	x = 1
	global = &x
}

在上述情况下，x局部变量从f函数中逃逸，并不会在f函数返回时被回收，持久存储在堆（heap）中。应尽量避免这种情况带来的额外内存损耗。

赋值

和其余语言赋值没什么太大区别。

不同的是，额外增加了元组赋值。=右侧的一组变量会先求值，再赋给左侧变量。建议在不需要复杂运算时使用。同时，有些表达式和函数也会返回一组值，此时需要用元组赋值的方式接收。在不需要某个变量时，可以使用_占位。

1
2
3
4
5
6

x, y= y, x

f, err = os.Open("foo.txt")
v, ok = m[key]
v, ok = x.(T)
v, ok = <- ch

可赋值性

除了一些显式的赋值外，还有函数返回、字面量声明等。Go中的赋值当且仅当=左右的值和变量类型相同才可进行（对于==和!=的判断也是这样）。nil可以赋值给任何复杂类型或引用类型。

类型声明

Go中可以定义类型。Go中的类型定义储存值的符号、它们的大小、固有操作以及方法，使用type name underlying-name声明。它通常出现在包级别，有些也会通过首字母大写的形式export出去。

1
2
3
4
5
6
7
8
9

type Celsius float64
type Fahrenheit float64

func CTOF(c Celsius) Fahrenheit {
	return Fahrenheit(c * 9 / 5 + 32)
}
func FTOC(f Fahrenheit) Celsius {
	return Celsius((f - 32) * 5 / 9)
}

两个有着相同底层类型的命名类型并不是同一种类型，也不能直接相互赋值和比较。但是可以使用强制类型转换转换到想同类型来比较。所有的类型T都有对应的强制类型转换操作T(x)。两个有相同类层类型或指向相同底层类型的未命名指针可以相互强制转换。另外，Go中的强制类型转换从不会在运行时出错。

比较特别的是，类型上还可以声明方法。

1
2
3

func (c Celsius) String() string {
	return fmt.Sprintf("%g°C", c)
}

包和文件

Go中的包即其他语言中的库、模块。以实现模块化、封装、分发和重用。和Java类似，一个包的代码可以存放在多个文件内，通常位于同一个文件夹下。每个包都有相互隔离的命名空间，需要用·image.Decode的形式使用。需要export的变量、类型、函数使用首字母大写的形式。

建议在每个export出去的变量、类型、函数前使用注释说明。另外，建议在包开头留下doc comment，或将更多注释放在doc.go中。

import

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

package main
import (
	"fmt"
	"os"
	"strconv"
	"shenlvmeng/learning/tempconv"
)

func main() {
	for _, arg := range os.Args[1:] {
		t, err := strconv.ParseFloat(arg, 64)
		if err != nil {
			fmt.Fprintf(os.Strerr, "convert error: %v\n", err)
			os.Exit(1)
		}
		f := temconv.Fahrenheit(t)
		c := tempconv.Celsius(c)
		fmt.Printf("%s = %s, %s = %s\n", f, tempconv.FTOC(f), c, tempconv.CTOF(c))
	}
}

每一个包都有自己的import路径，Go语言标准并不定义如何解释import路径，这一步交给解释工具完成。每个包的包名通常和路径的最后一段同名。为避免包名冲突，import可以指定包的别名。

在引用了未被使用的包时会报错。，借助goimports等工具和正确的IDE配置，可以在保存代码时自动标准化代码格式。

包初始化

1
2
3

var a = b + c //third
var b = f() // second
var c = 1 // first

初始化时，先按照依赖的顺序初始化包级别变量。而.go文件的处理顺序则按照传给go编译器的顺序。初始化的过程是自底向上的，即当所有依赖包都初始化完成后，才会初始化main包，再执行main函数。对于初始化过程复杂的变量，可以在init函数中声明，而init是在程序启动时，按照声明的顺序一个一个执行的。

作用域

作用域是编译时的，和运行时的生命周期概念相对应。作用域描述一个声明的可见范围。和C系列语言类似，用大括号{}包裹会形成词法块作用域。Go在全局作用域下预定义了一些常量、函数、类型等。在函数外声明的作用域是包级别的，import进来的包作用域是文件级别的。局部声明只在块作用域内。内部作用域会覆盖外部作用域的同名声明。

另外，Go中还有一些隐式的作用域，比如for，if，switch表达式中的作用域。

1
2
3
4
5
6
7
8
9
10

func main() {
	x := "Hello"
	for i:= 0; i < len(x); i++ {
		x := x[i]
		if x != "o" {
			x := x + 'A' - 'a' // 类似upperCase
			fmt.Prinf("%c", x)
		}
	}
}

上面的for和if内部的x是一个单独的作用域。另外注意，简写式中会声明局部变量，会覆盖外部的同名变量，可能会带来意料之外的结果。可以通过var xxx type的形式声明变量。

1
2
3
4
5
6
7

var cwd string
func main() {
	cwd, err := os.Getwd() // compile error: unused cwd
	if err != nil {
		log.Fatalf("os.Getwd failed: %v", err)
	}
}

基础数据结构

Go有4大类数据类型：

• 基础类型，即数字、字符串、布尔值
• 聚合类型，即数组、struct
• 引用类型，包括函数、指针、slice、map、channel
• 接口类型

这一部分先说基础类型

整型

Go的数字类型包含了不同size的整型、浮点数和复数，以及它们的有无符号性。

整型有8、16、32、64四种长度，以及对应的signed和unsigned。组合一下即下面8种：

• int8
• int16
• int32
• int64
• uint8
• uint16
• uint32
• uint64

另外，rune是int32的别称，通常用来表示1个Unicode字符，byte是unit8的别称。uintptr用来表示一个可以承载任意指针值的无符号整型。

Go中对整型的处理和C风格很像。

• 用首位表示符号位（signed int中）
• 类型承载范围和C一样，如int8表示-128到127
• 和C一样的操作符以及优先级，唯一区别是&^表示位清除，x &^ y表示根据y各位将x各位清0
• <<左移位，空位取0，>>右移位，无符号数补零，有符号数补符号位
• 整型间除法会清除小数部分
• 取余%运算结果符号和被除数有关
• 超过位数的会溢出
• 0开头表示八进制（通常用来表示POSIX系统中文件权限设置），0x表示十六进制

不一样的是：

• 相同类型才可比较大小，否则需要用int()强制转换为1种类型再比较。某些类型转换只改变值的使用方式，有些则会改变值，如int和float之间的转换
• 用%d, %o, %x分别表示整型、八进制和十六进制数
• 用%c表示显示对应的Unicode字符，%q显示带引号版本

浮点数

浮点数有float32和float64两种类型，服从IEEE754标准。为保证精确性，通常使用flaot64。另外，还有以下特点

• .前后的0可以省略
• %g, %e和%f分别打印最合适展示精确度版本、指数版本和原始版本
• 有+Inf, -Inf和NaN特殊值，表现类似JS

复数

Go有两种复数类型：complex64和complex128，它们其实是由float32和float64组成的。复数可以通过complex内置函数初始化，或者直接使用字面量。

1
2

var x complex128 = complex(1, 2) // 1 + 2i
y := 3 - 4i

复数间可以判断相等性，无法判断大小。math/cmplx包里包含一些复数的数学运算。

布尔类型

即type bool，和其他语言类似，有短路行为，&&比||优先级更高。bool类型和整型之间不能相互隐式转换。

字符串

字符串表示一组不可修改的比特位序列，但通常用来承载可读的Unicode编码点。len返回字符串长度，[i]返回第i个字节处的值。越界读取会导致panic。

• s[i:j]表示自带的substring操作，其中i和j均可省略
• 字符串间可以比较大小和相等性，其中大小通过逐字节子母序比较
• +可表示字符串拼接
• 不可变性：不允许修改字符串的值（如s[0] = 'L'），这使得Go可以在底层复用字符串，节省内存

字面量字符串

用双引号"包裹，UTF-8编码。双引号中的反斜线\有特殊含义。如

• \n表示换行
• \t表示制表符
• \x表示后接十六进制的高低位
• \ooo表示三个八进制位

由反引号`` `包裹的表示纯文本字面量，其中的换行和格式也会被跨平台保留。可以用来书写多行字符串。

Unicode表示

Go中使用UTF-8变长编码：

• 0xxxxxxx表示ASCII码
• 11xxxxxx 10xxxxxx 表示两字节长度
• 110xxxxx 10xxxxxx 10xxxxxx表示三字节长度
• 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx 表示四字节长度

可以由\uhhhh表示16比特或\U表示32比特，如世界：\u4e16\u754c。unicode包和unicode/utf8包提供了编解码工具。utf6.DecodeRuneInString可以读取一个自然字符的数据，而非一个字节一个字节读取，utf8.RuneCountInString返回字符串的自然字符长度。幸运的是，range循环会自动调用utf8解码其中的自然字符。

1
2
3
4
5

import "unicode/uft8"

s := "Hello, 世界"
fmt.Println(len(s)) // 13
fmt.Println(utf8.RuneCountInString(s) // 9)

当Go Unicode解析失败时，会使用特殊的Unicode占位符\ufffd，显示为带有问号的特殊字符。另外，rune[]可以直接将字符串转成编码后的每个Unicode编码点。这个rune数组进行string()强制类型转换后即原始字符串。当然你也可以直接string()装换一个整型数，不合规的整形数会得到上面提到的特殊字符。

1
2
3
4
5
6

s := "世界"
r := []rune(s)
fmt.Println(string(r))

fmt.Println(string(65))
fmt.Printlf(string(12341234))

字符串和Byte Slices

bytes, strings, strconv, unicode是和string相关的几个包。strings提供基本的字符串搜索、比较、修改等操作，bytes提供修改字节数组的一些操作。有时，使用byte.Buffer类型，在操作字符串字节时会更有效率。strconv提供了将其他类型转成字符串和修饰字符串的操作函数。unicode提供了一些以rune为中心的函数，如IsDigit, IsLetter, isUpper等。

1
2
3
4
5
6
7
8
9

// basename removes directory and filename suffix
func basename(s string) string {
	slash := strings.LastIndex(s, "/")
	s = s[slash+1:]
	if dot := strings.LastIndex(s, "."); dot >= 0 {
		s = s[:dot]
	}
	return s
}

path和path/filepath包提供了更多文件夹和目录的操作函数。

尽管字符串中的字节序列是不可更改的。其对应的字节序列数组则是可以自由修改的。[]byte(s)会分配一个字符串s的字节序列拷贝，也可以对应用string(b)还原。bytes包提供的Buffer类型可以很方便地承载[]byte类型。

1
2
3
4
5
6
7
8
9
10
11
12

func intsToString(values []int) string {
	var buf bytes.Buffer
	buf.WriteByte('[')
	for i, v := range values {
		if i > 0 {
			buf.WriteString(", ")
		}
		fmt.Fprintf(&buf, "%d", v)
	}
	buf.WriteByte(']')
	return buf.String()
}

上述函数中，WriteString和WriteByte用于向Buffer中写入字节或字节序列，该类型还有许多其他应用场景。

字符串和整型间的转换

• 字符串 -> 整型，fmt.Sprintf或strconv.Itoa
• 整型 -> 字符串，strconv.FormatInt或strconv.FormatUint或strconv.ParseInt或Atoi

常量

常量有以下几个基本特点:

• 编译时即对编译器可知
• 必须是基础类型：boolean，string或number

常量使用const声明，形式看起来和使用var类似，不过值是常量。对常量进行的所有操作，如数学运算、逻辑运算、比较、内置函数求值，都是在编译期就确定了。

常量可以组声明，声明时可以不显式声明类型，此时将使用右侧操作数推断常量类型。

1
2
3
4
5
6
7

const (
	noDelay time.Duration = 0
	timeout = 5 * time.Minute
)

fmt.Printf("%T %[1]v\n", noDelay) // "time.Duration 0"
fmt.Printf("%T %[1]v\n", timeout) // "time.Duration 5m0s"

还有个不常用的点：组声明时，除了第一个常量，剩下的常量可以不写右侧操作数，此时会使用上一个常量来初始化。

1
2
3
4
5
6

const (
	a = 1
	b
	c = 2
	d
)

常量生成器iota

iota即常量生成器，它从0开始，每次常量声明后加一。利用这个规律可以方便地生成一组常量枚举。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

const (
	Sunday Weekday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

const (
	const _ = 1 << (10 * itoa)
	KB
	MB
	GB
	TB
	PB
	EB
	ZB
	YB
)

无类型常量

常量和变量不一样的点在，常量是可以不声明类型的，根据常量限定的类型，有下面一些类型：

• 无类型整型
• 无类型Boolean
• 无类型rune
• 无类型浮点数
• 无类型复数
• 无类型字符串

常量在使用时，会隐式转换成需要的类型，并在无法转换时抛出错误。

1
2
3
4

var f float64 = 3 + i // complex -> float64
f = 2 // integer -> float64
f = 1e123 // float -> float64
f = 'a' // rune -> float64

实际上，这些无类型常量有一个隐含类型，如:

• 无类型整型 -> int
• 无类型浮点数 -> float64
• 无类型复数 -> complex128
• 无类型rune -> int32（rune）

聚合类型

基本类型是数据结构的组成“原子”。原子的组合就构成了“分子”——聚合类型：

• array
• slices
• maps
• structs

其中array和structs是聚合类型的基础，它们都有着固定大小。而slice和map则是动态大小。

array

1
2
3

var a [3]int
fmt.Println(a[0])
fmt.Println(f[len(a)-1])

类似C风格，array表示由0或多个同一类型元素组成的定长序列。声明数组时，需要使用常量表达式作为数组长度。当数组元素全部列出时，可以用...代替长度。元素未声明初始值时，按零值（zero value）处理。

1
2
3

var q [3]int = [3]int{1, 2}
fmt.Println(1[2]) // 0
q = [...]int{3, 4, 5}

另外，当元素较多时，还可以用index到value的键值对形式声明，未声明的值为零值。下面的例子中，r长度100，除了最后一个元素为-1之外，其余都为0.

1

r := [...]int{99: -1}

若数组数组具有可比性，则数组也具有可比性。另外，不同长度的数组是不同类型。[4]int和[3]int不是同一类型。

1
2
3
4
5
6
7

import "crypto/sha256"

func main() {
	c1 := sha256.Sum256("x")
	c2 := sha256.Sum256("X")
	fmt.Printf("\t\n", c1 == c2)
}

Go中将数组作为参数传递时，传递的是复制的新数组，而不是传入数组的引用，这是Go和其他语言不大一样的地方。当然可以通过传入数组指针的方式，实现在函数内修改数组内容。由于数组是定长的，在更多时候，函数参数使用slice类型传入。

slice

slice和array类型紧密相关，使用[]T声明。每个slice的底层都基于一个array。slice只是一个指针指向array中的某一个元素作为开始，除此之外，它还有len和cap函数分别用来表示切片长度，和切片最大容量（从切片开始到底层array结尾）。

因此不同slice可以共享同一个array，它们之间可以相互重叠。s[i:j]是从创建slice的方式，遵从左闭右开原则，i和j均可省略，省略时分别表示0和数组最末尾元素。创建可以基于一个array变量或一个array指针或其他slice。创建超过array范围会引起panic，只超过len(s)则会拓展这个slice。因为string实际上是[]byte切片，所以s[i:j]和substring是一个意思。

从上面可以看到，slice即一个指向数组元素的指针，所以传递一个slice时，可以修改底层array的值。下面这个反转数组的函数不限数组长度：

1
2
3
4
5
6
7
8
9

func reverse(s []int) {
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		s[i], s[j] := s[j], s[i]
	}
}

s := []int{1, 2, 3, 4 ,5}
reverse(s)
fmt.Println(s) // [5 4 3 2 1]

上面的s是一个切片字面量，和array的区别在于没有声明长度。这种写法实际上会生成以后面值为全部元素的数组，并把切片指向这个数组。类似地，还可以使用make创建一个切片。

1
2

make([]T, len)
make([]T, len, cap)

由于切片只是引用，从效率和可理解性上考虑，切片间不具有可比性。不过切片可以和nil比较，nil表示空切片，而非“没有元素”的切片。不过Go中slice相关的函数对待这两种切片行为一样。

1
2
3
4

var s []int // s == nil
S = nil // s == nil
s = []int(nil) // s == nil
s = []int{} // len(s) == 0, s != nil

append和copy

append函数可以操作slice。如果append之后，slice长度超过了底层array的长度，append会自动拓展底层array长度。另外，append不仅可以追加单个元素，还可以追加任意个元素，或解构后的slice。

1
2
3
4
5
6
7
8
9
10

var runes []rune
for _, r := range "Hello, 世界" {
	runes = append(runes, r)
}

fmt.Printf("%q\n", runes)
var x []int
x = append(x, 1)
x = append(x, 2, 3)
x = append(x, x...)

在不借助append实现类似append功能时，就需要自己借助cap(x)和make完成底层array的长度扩充。如同下面的一段代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

func appendInt(x []int, y ...int)  {
	var z []int
	zlen := len(x) + len(y)
	if zlen <= cap(x) {
		z = x[:zlen]
	} else {
		zcap := zlen
		if zcap < 2 * len(x) {
			zcap := 2 * len(x)
		}
		z = make([]int, zlen, zcap)
		copy(z, x)
	}
	copy(z[len(x)], y)
	return z
}

上面的...表示剩余参数，

借助copy还能实现一些slice的原址操作。

1
2
3
4

func remove(slice []int, i int) []int {
	copy(slice[i:], slice[i+1:])
	return slice[:len(slice)-1]
}

map

map即键值对，其中key要求具有可比较性。map有两种构造方式：make或字面量：

1
2
3
4
5

ages := make(map[string]int)
ages := map[string]int {
	"Alice": 18,
	"Bob": 27
}

map使用下标访问，使用delete删除键。另外，访问不存在的key时，值是value类型的零值。因此可以免去一些多余的初始化步骤。由于map的值并不是变量，所以不能用&获取地址。

1
2
3
4
5
6

ages["Cindy"] = 23
delete(ages, "bob")
// 新的key
ages["Dred"] += 1 // 1

_ := &ages["Cindy"]

map在遍历时，顺序是随机的。因此如果需要确定顺序，需要事先手动排序。

1
2
3
4
5
6
7
8
9
10

import "sort"

var names []string
for name := range ages {
	names = append(names, name)
}
sort.Strings(names)
for _, names := range names {
	fmt.Printf("%s\t%d\n", name, ages[name])
}

map的delete，len，range和取值操作都可以对零值nil进行，但是存储到nilmap时会报错。由于访问map不存在的key会返回默认的零值，所以下标操作用第二个参数返回是否对应的key，*且参数通常命名ok*。

1
2
3

if age, ok := ages["Ed"]; !ok {
	// ...
}

Go中没有set类型，可以用map[string]bool等价。当key可能不可比较时（如用slice做key），可以用额外的序列化使用。

struct

struct类似ts中的interface。由零或多个fields组成，每个field使用点来访问。struct和field都是变量，所以可以用&获取地址。对地址也可以使用点来访问field。

1
2
3
4
5
6
7
8
9
10
11
12

type Employee struct {
	Id int
	Name string
	Address string
	DoB time.Time
	Position string
	Salary int
}
var e Employee
e.Salary = 1000
pos := &e.Position
*pos = "Senior " + *pos

相同类型的两个key可以在一起声明。在Go的struct中，field的组合和排序都意味着不同的type。和包一样，大写的field被导出可被访问，这也是Go的一种通用的设计。

1
2
3
4
5
6
7

type Employee2 struct {
	Id int
	Name, Address string
	DoB time.Time
	Position string
	Salary int
}

struct类型的field不能自指，但是允许包含自己类型的指针，比如最经典的二叉树场景。

1
2
3
4

type tree struct {
	value int
	left, right *tree
}

struct的零值由各field零值组成，不是nil，没有field的空struct写作struct{}。不携带信息，但可能在有些地方会有用。

字面量struct

两种声明方式：

1
2
3
4

type Point struct{ X, Y int }
p := Point{1, 2}

anim := git.GIF{LoopCount: nframes}

• 将所有fields按顺序声明，struct的fields有任何改动都需要修改，所以通常只在小规模struct以及包内部使用
• 使用键值对方式声明，可以省略field，且对顺序不敏感

另外，在Go中，所有的函数参数传递都是传值。因此，如果函数内部需要修改struct时，不能传递struct类型，而需要传递指针。由于struct传递指针的场景比较多，所以提供了类似p := &Point{1, 1}的简写语法糖。

1
2
3

func AwardAnnualPrize(e *Employee) {
	e.Salary = e.Salary * 2 + 1000
}

如果struct的所有field都具有可比性，则struct也具有可比性，可以比较是否相等。因此，struct在有些情况可以用来作为map的key。

struct嵌入与匿名域

匿名域用于struct之间的组合，可以达到类似类继承的效果。在struct声明中，如果field类型是有名称的，则可以忽略掉field名，得到一个匿名域。匿名域类型或类型内的各field对应用struct可见。有点类似TS中interface的extends。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

type Point struct {
	X, Y int
}
type Circle struct {
	Point
	Radius: int
}
type Wheel struct {
	Circle
	Spokes int
}

var w Wheel
w.X = 8
w.Y = 10
w.Radius = 5
w.Spokes = 20

换种说法，匿名域就是向下访问时可以省去不写的中间域。即使中间域类型是首字母小写不对外可见的，只要剩下域对外可见也可以访问。struct这种组合思想是Go在面向对象上的核心。

JSON

编解码JSON数据的方法都位于encoding/json，其中编解码整块数据的函数分别为json.Marshal和json.Unmarshal，前者传入Go数据结构，返回压缩后的JSON字符串，使用json.MarshalIndent可以返回美化后的JSON字符串。编码时，只有被导出的域才会出现在JSON字符串中。且field之后的field tag可以作为metadata修改JSON行为，如指定被JSON字符串化之后的key名。或用下面的omitempty忽略掉零值的key。

1
2
3
4
5
6

type Movie struct {
	Title string
	Year int `json:"released"`
	Color bool `json:"color,omitempty"`
	Actors []string
}

相反，在解码JSON数据时，需要显式声明struct结构来接收JSON数据。json.Unmarshal方法的第二个入参即struct的指针。在解析JSON时，对key是不区分大小写的，因此只需要对a_b类型的JSON key指定field tag。

对于stream格式的JSON数据，使用json.Encode和json.Decode编解码。

HTML和文本模板

text/template和html/template用于文本模板和HTML模板。它们都使用双花括号包裹带有逻辑的简单语句。其中，html/template还会默认对文本做escape脱敏处理（对template.HTML不会escape）。

• 使用template.New创建模板
• template.Funcs向模板内插入函数
• template.Must保证模板有内容
• template.Parse解析模板
• 使用模板的Execute方法生成解析后内容

1
2
3
4
5
6
7
8
9
10
11
12

var report = template.Must(template.New("issueList")).Funcs(
	template.FuncMap("daysAgo": daysAgo)
).Parse(templ)
func main() {
	result, err := github.SearchIssues(os.Args[1:])
	if err != nil {
		log.Fatal(err)
	}
	if err := report.Execute(os.Stdout, result); err != nil {
		log.Fatal(err)
	}
}

函数

声明

1
2
3

func add (x, y int) (z int) { z = x - y; return }
func first(x int, _ int) int { return x }
func zero (int, int) int { return 0 }

• 相同类型入参可以聚合x, y int
• 返回值为多个时，需要用()包裹
• 返回值也可以给予变量名，这种情况下，相当于提前为返回值声明变量
• 入参是传值，即入参会复制一份传递给函数内部，只有像slice、map、function、channel这种引用实现的类型在函数内改变会影响外部值
• 只有函数声明，没有函数体的函数表示函数由其他语言实现，如func Sin(x float64) float64

递归

Go的递归和其他语言无异。不同的是，传统语言的函数递归借助定长的栈实现，大小从64KB到2MB不等，而Go使用变长栈实现，避免的栈溢出的情况。

多返回值

1

func Size(rect image.Rectangle) (width, height int)

Go支持同时返回多个返回值。同类型返回值可以压缩，还可以声明有名称的返回值。在多返回值时，还可以直接传递给需要多个入参的函数，

1
2
3
4
5

log.Println(findLinks(url))

// 等同于
links, err := findLinks(url)
log.Println(links, err)

返回值有名称时，会作为函数体内最外层变量出现。因此，不需要显示return返回值，这种现象也称为“裸返回”（bare return）。由于裸返回时，return后不会跟随返回值，不利于代码可读性，所以只在需要的时候使用它。

错误

函数返回错误在Go中是普遍现象。有时，错误类型只需要有1种，这时通常用bool类型的ok表示。如对map类型的变量的访问。但大多数时候，错误原因可能要有比较多种，这时可以用error类型的err表示。

在Go中较少使用exception表示失败（尽管Go也有exception机制），Go只在真正的bug处，才使用异常打印stack trace信息。在Go中较常出现的是普通的error类型，它只作为普通控制流的一部分。

处理策略

error处理由调用方负责，有5种策略：

• 向上传递，在没有error时，可以用fmt.Errorf制造一个自定义错误信息的错误。Go建议仔细设计错误信息内容，不使用大写字母，不使用换行。建议函数的每一层补充上更多信息。
• 重试，在有些场景下，如测试服务端连接
• 退出，严重问题时，可以用os.Exit(1)退出，或者用log.Fatalf打印错误信息后退出
• 打印日志后继续，对于简单问题，可以打印日志后继续流程
• 忽略，在特殊情况下，可以直接忽略，如错误确实不会影响功能实现

Go建议是使用函数时考虑错误处理的场景。

EOF

EOF（End Of File）是一种特殊的错误类型，io.EOF表示输入流没有更多内容了。

1
2
3
4
5
6
7
8

in := bufio.NewReader(os.Stdin)
for {
    r, _, err := is.ReadRune()
    if err == io.EOF {
        break
    }
    // ...
}

作为值的函数

这一章很类似JS或TS

Go中函数是一级成员。这意味着，它可以作为一种类型，传递给变量、入参或者返回，就像其他值的类型一样。函数是一种引用类型，所以可以为nil，但是执行nil会导致panic。

1
2

var f func(int) nil
f(2) // call of nil panic

再次基础上，就可以对函数做更灵活而精准的设计，拆分函数关注点和抽象层次。构造出更灵活的程序。以strings.Map为例

1
2

func add1(r rune) rune { return r + 1 }
fmt.Println(strings.Map(add1, "Admin")) // Benjo

匿名函数

Go中只能在包级别声明有名函数，而匿名函数可以在块作用域、函数作用域内声明。因此，高阶函数、闭包等概念Go中也有。由于这些概念JS中也有，这里就不再赘述。

循环变量捕获

JS也有类似问题，不过原因不同

1
2
3
4
5
6
7
8

// 一段会有问题的代码
var rmdirs []func()
for _, dir := range tempDirs() {
    os.MkdirAll(dir, 0755)
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir)
    })
}

上面的for循环中，循环变量dir在append的回调中有使用，我们回忆一下，for循环中循环变量位于for语句块外，在整个for循环后才销毁。所以这会导致每一个回调执行时，dir都被更新为最新的值。将dir在循环体内再次赋值即可。

1
2
3
4
5
6
7
8
9

var rmdirs []func()
for _, dir := range tempDirs() {
    // 可以运行
    dir := dir
    os.MkdirAll(dir, 0755)
    rmdirs = append(rmdirs, func() {
        os.RemoveAll(dir)
    })
}

变长参数

1
2
3
4
5
6
7

func sum(vals ...int) int {
    total := 0
    for _, val := range vals {
        total += val
    }
    return total
}

类似JS中的剩余参数，Go中也使用rest ...type表示函数的剩余入参。rest需要声明类型，rest为slice类型。要注意的是，这种函数和直接传入一个slice参数的函数类型并不一样。另外，在剩余参数类型不明确时，可以用interface{}表示。

1
2
3

// 在变量后使用`...`表示解构
val := []int{1,2,3}
fmt.Println(sum(values...))

延迟函数调用（Deferred Function Calls）

在语句前加上defer标识符，会让defer后的函数调用推迟到所在函数的**return之后**执行。defer后的函数和表达式会立即求值。defer的函数调用在函数panic后仍然会被调用。可以用来执行一些释放资源的操作，如以下场景：

• open和close
• connect和disconnect
• lock和unlock

1
2
3
4
5
6
7

var mu sync.Mutex
var m = make(map[string]int)
func lookup(key string) int {
    mu.Lock()
    defer mu.Unlock()
    return m[key]
}

最合适的使用时机是在刚刚获得资源之后。还可以利用defer完成进入和离开函数的成对操作做一些调试。

1
2
3
4
5
6
7
8
9
10
11
12

func bigSlowOperation() {
    defer trace("bigSlowOperation")()
    // ...
    time.Sleep(10 * time.Second)
}
func trace(msg string) func() {
    start := time.Now()
    log.Printf("enter %s", msg)
    return func() {
        log.Printf("exit %s (%s)", msg, time.Since(start))
    }
}

由于defer在函数最后执行的特点，甚至可以在defer中获取和修改函数返回值。

1
2
3
4
5

func triple(x int) (result int) {
    defer func() { result += x }()
    return double(x)
}
fmt.Println(triple(4)) // "12"

同时也由于defer的这个特点，在for循环中使用defer一定要谨慎。

panic

Go中的panic类似于其他语言的exception，它一般代表程序中存在bug和不应该出现的情况。panic后，正常程序执行停止，defer的函数被倒序执行，然后函数崩溃并带有错误信息。

除了系统触发的panic，还可以直接通过panic("certain message")手动触发一个panic。一些包中以Must开头的API通常表示，在不符合规范的时候API会panic。建议只在内部可信任环境下使用这种API。

recover

就像其他语言中的try catch一样，Go中的panic同样有机制去妥善处理。Go有内置的recover函数，可以用于在panic中恢复。

• recover需要在defer的函数中使用
• recover函数会返回panic的value，在没有panic的情况下，该函数返回nil

下面是一些使用recover的建议：

• 不要毫无条件地从panic中recover，这可能会掩盖一些潜在的bug或资源泄露
• 在panic后，可以使用runtime.Stack这样的方法打印一下错误的详细信息，再recover
• 可以定义一些外部不可见的类型，在调用panic时传入，在recover返回时判断类型，从而做到针对特定情况panic执行recover，其余情况仍旧panic
• 对于预期中的error不使用panic

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func soleTitle(doc *html.Node) (title string, err error) {
    type bailout struct{}
    defer func() {
        switch p := recover(); p {
        case nil:
            // no panic
        case bailout{}:
            err = fmt.Errorf("multiple titles")
        default:
            panic(p) // resume panic
        }
    }()
    // ...
}

方法

Go也有OOP的特性，即对象上具有方法，方法需要关联在一个特定类型上。

声明

1
2
3
4
5
6

import "math"

type Point struct{ X, Y float64 }
func (p Point) Distance(q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

声明里，在普通声明的函数名前，增加函数绑定的类型receiver，即完成了方法的声明。Go中没有this和self这样的保留字。类型receiver中的变量，即方法可以访问的类型变量。变量名由于会比较常用，所以通常取类型首字母。

其他方法的行为类似其他OOP语言：诸如方法名和函数名不在一个命名空间，所以可以重名；方法名之间不能重名；方法名不能和属性名相同。由于Go中声明命名类型比较自由，而方法可以很方便绑定在命名类型上，所以可以给基础类型，如数字、字符串等，增加新方法。

指针receiver

上面提到，访问方法需要一个receiver。除了变量本身，指针也可以作为receiver。在Go中函数入参都是传值的，也就是传入值的复制。所以除了map、slice这种引用类型，其余类型的值在方法内改变并不会影响到外部。如果需要方法改变receiver本身的话，可以指定将方法绑定在指针类型上。

1
2
3
4
5
6
7
8

func (p *Point) ScaleBy(factor float64) {
    p.X *= factor
    p.Y *= factor
}

t := &Point{1, 2}
r.ScaleBy(2)
fmt.Println(*r)

通常会规定，如果类型上有方法是指针类型的receiver，所有的方法都需要有一个指针类型receiver。类似struct一节介绍的，如果变量具有类型T，而方法的receiver是*T，我们可以直接使用简写的p.ScaleBy(2)而不需要写成(&p).ScaleBy(2)。相反地，receiver要求类型T，变量传入*T也是可以的。

但是，直接将字面量传入给指针类型的receiver是不允许的，如Point{1, 2}.ScaleBy(2)。

Nil是合法的Receiver

Go中，nil在很多时候是合法的零值。同样也可以作为receiver。当然在你的命名类型中，最好对合法的nil类型加以说明。Go的内置类型和操作，如slice，map、struct、append、make等也可以正常地处理nil。

组合和struct embedding

在此前的struct一节中，已经介绍了Go的struct embedding设计。这里结合方法继续讨论一下。首先我们先回忆下struct embedding是啥。

1
2
3
4
5
6
7
8
9
10
11
12
13

import "image/color"

type Point struct{ X, Y float64 }
type ColoredPoint struct {
    Point
    Color color.RGBA
}

var cp ColoredPoint
cp.X = 1
fmt.Println(cp.Point.X)
cp.ScaleBy(2)
fmt.Print;n(cp.Y)

匿名的field会直接将field类型中的成员和方法都组合（composite）进当前类型中（和TS中的extends有点像）。如上面的ColoredPoint就直接拥有了Point的Distance和ScaleBy功能（当然也可以访问Point）。Go更希望用组合（composition）而非派生（derivation）构造更复杂的类型。比如，上面的ColoredPoint并不是一个Point，并不能当做一个Point访问和使用。

匿名field如果是指针类型，除了上面的特性，还能实现让两个变量共享一个底层的结构。

1
2
3
4
5
6
7

type ColoredPoint struct {
    *Point
    Color color.RGBA
}
p := ColoredPoint{&Point{1, 1}, red}
q := ColoredPoint{&Point{3, 4}, blue}
p.Point = q.Point

在访问receiver上的方法时，Go首先会去直接声明的field中寻找，然后再去embedded的field中寻找，再向下寻找。方法只能在命名类型和其指针类型上定义，但是借助struct embedding也可以实现，将功能聚合在一起。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

var (
    mu sync.Mutex
    mapping = make(map[string]string)
)
func Lookup(key string) string {
    mu.Lock()
    v := mapping[key]
    mu.Unlock()
    return v
}

// 重构后
var cache = struct {
    sync.Mutex
    mapping map[string]string
} {
    mapping: make(map[string]string),
}

func Lookup(key string) string {
    cache.Lock()
    v := cache.mapping[key]
    cache.Unlock()
    return v
}

上面重写之后的代码表现力明显更好了。

方法值（method value）和方法表达式（method expression）

1
2
3
4
5
6

p := Point{1, 2}
q := Point{4, 5}
distanceFromP := p.Distance
fmt.Println(distanceFromP(q))

time.AfterFunc(10 * time.Second(), r.Launch)

p.Distance会得到一个method value，它是一个绑定到了特定receiver上的一个方法，本身也是一个函数。可以当做函数类型的值用作入参或返回值。这个和JS还比较像。

类似的，Go中还有method expression的概念。即直接用类型名加点（.）访问方法得到一个method expression。它也是一个函数，可以看做是一个没有绑定receiver的方法。调用函数时，传入的第一个入参会当做receiver，后续的作为方法入参。这个特性在需要根据情况灵活选择方法时很好用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func (p Point) Add(q Point) Point { return Point{p.X + q.X, p.Y + q.Y} }
func (p Point) Sub(q Point) Point { return Point{p.X - q.X, p.Y - q.Y} }

type path []Point
func (path Path) TranslateBy(offset Point, add bool) {
    var op func(p, q Point) Point
    if add {
        op = Point.Add
    } else {
        op = Point.Sub
    }
    for i := range path {
        path[i] = op(path[i], offset)
    }
}

一个实例：bitset

• bytes.Buffer经常用来拼接字符串
• fmt的print打印字符串时会调用变量的String方法

封装

首先，Go的封装细粒度只到package一层，package内不控制可见性。所以当你想要控制可见性时，需要用拆分package实现。

封装用来掩盖不需要像使用者展示的信息和细节。Go中唯一用来控制可见性的手段是一个大小写约定：大写表示从包中导出，小写表示包内可见，对于struct中的field以及类型的method也是如此（包外访问不了，包内随便访问）。通常来讲，当需要封装对象时，我们都会使用struct。

1
2
3
4
5
6

// 建议
type IntSet struct {
    words []uint64
}
// 不建议
type IntSet []uint64

使用struct封装本来就很简单的类型有以下几个原因：

• 使用方无法修改对象值，这样只用查阅更少的声明，就能得到对象值大致的可能范围
• 对使用方掩盖实现细节，可以避免让使用方依赖那些可能改变的内容，也给开发者重构空间，开发者可以在不改变API兼容性的情况下灵活调整内部实现
• 避免使用方任意修改对象值，造成更多边缘情况，提高程序编写难度和程序不稳定性

有时，封装也会暴露出一些getter和setter。通常命名上，会直接使用field的首字母大写形式，省去不必要的Get，Fetch，Lookup前缀。实际上，Go并不禁止导出field，只是在有些情况下，导出field会影响代码可靠性。

封装并不总是必要的。有时，底层数据结构是目标数据结构的充要表示，不多不少，场景变数不多，这时可以不用struct封装。但是，像IntSet这种，实现细节变数多，程序实现稳定性低，需要被保护起来，避免影响使用者。从而要采取封装的方式，把那些变数变得“不透明”。

接口（interface）

如其他OOP语言一样，Go中也有用于标识抽象类型的接口描述。不同的是，Go中的接口都是隐式满足的，松耦合。

作为约定的接口

之前介绍过的所有类型都是具体类型（concrete type），具体类型指数据表示和行为实现在类型确定后，就已一清二楚。为了保证语言灵活性，Go中还有接口类型（interface type）。这种类型不暴露内在结构和实现细节，而是给出接口输入输出，作为一种约定交由具体实现方完成，从而实现依赖反转（DI）。这一概念的设计上和其他OOP语言无二。不过在使用上，Go并不要求实现方明确依赖关系，只需实现约定即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package fmt

func Fprintf(w io.Writer, format string, args ...interface{}) (int, error)

func Printf(format string, args ...interface{}) (int, error) {
    return Fprintf(os.Stdout, format, args...)
}
func Sprintf(format string, args ...interface {}) string {
    var buf bytes.Buffer
    Fprintf(&buf, format, args...)
    return buf.String()
}

package io

type Writer interface {
    // ...comments
    Write(p []byte) (n int, err error)
}

同样的，实现String方法也让类型隐式满足了fmt.Stringer的定义。Go中单方法interface的命名，通常以动词的名词形态为主。

1
2
3
4
5

package fmt

type Stringer interface {
    String() string
}

接口中也有类似struct embedding的嵌入式写法，简化interface的组合成本。另外，interface中方法的顺序不影响interface类型。

1
2
3
4
5
6
7
8
9
10
11
12
13

package io

type Reader interface {
    Read(p []byte) (n int, err error)
}
type Closer interface {
    Close() error
}

type ReadWriter interface {
    Reader
    Writer
}

接口的满足

Go中变量可以是接口类型，在给接口类型变量赋值时，需要检查值的方法是否满足了接口的类型定义，这一点和其他OOP语言相似。要注意，尽管Go有将变量T转成*T的隐式转换，但是类型T的方法和*T的方法receiver并不同。而通常具体类型中会在接口声明的方法中做一些写操作，因而指定receiver为指针类型，这有可能会导致无法满足接口定义。

接口覆盖了其包裹的内部类型，所以，即使内部类型满足其他方法，赋值给接口类型后，也只能方法接口拥有的方法。

1
2
3
4

var w io.Writer
w = os.Stdout
w.Write([]byte("hello")) // OK
w.Close() // compile error: io.Writer lacks Close method

Go中还有一个通用的不可或缺的类型interface{}它表示对类型没有任何要求，同时也意味着该类型变量上无法执行任何操作，类似ts中的Unknown。

1
2
3
4
5

var any interface{}
any = true
any = 12.34
any = "hello"
any = new(bytes.Buffer)

Go中具体类型对接口类型的满足都是隐式的，无需显式声明。所以一个具体类型可能会同时满足很多接口类型。可以把接口类型认为是将一些具体类型中公共的部分抽象出来的共同行为，将之作为grouping出来的共性。

使用flag.Value解析命令行参数

• fmt.Sscanf可以从输入中按格式解析出特定类型参数

接口值

1
2
3
4

var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

Go中，接口类型可以作为变量的合法类型。接口类型值因此具有动态类型和动态值。在Go中可以近似用类型描述符（type descriptor）表示，其中type表示具体类型，value表示具体值。在初始化时，type和value都是nil。

1
2
3
4
5

        +-----------+
type    |    nil    |
        +-----------+
value   |    nil    |
        +-----------+

而在第二和第三行，为w赋值为os.Stdout以及*bytes.Buffer类型时，type分别会变成os.Stdout和*bytes.Buffer，同时value也会被设置为对应初始值的指针。这个过程会完成类似于io.Writer(os.Stdout)的隐式类型转换。此时访问w的方法，会被动态分配到value上实现。而在最后又将w还原为初始值nil。

接口类型之间不一定可以比较，当接口值都为nil或接口值对应的具体类型相同以及具体值相同时，接口值相同。然而，如果具体类型不可比较时（如slice，function等），接口类型也不可比较。Go的fmt中，可以用%T打印变量类型。

陷阱：nil值可以存在于非nil的接口值中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

const debug = true
func main() {
    var buf *bytes.Buffer
    if debug {
        buf = new(bytes.Buffer)
    }
    f(buf)
    if debug {
        // ...
    }
}

func f(out io.Writer) {
    if out != nil {
        out.Write([]byte("woops!\n")) // panic: nil pointer derefence
    }
}

在上面的判断中，out已经有了具体的类型，因此接口类型的out不等于nil，然而out的具体值却是nil，这使得Write行为无法保证。解决办法是，在一开始为buf声明为io.Writer类型即可。

sort.Interface

Go使用sort包中的sort.Interface实现排序功能。同时对于常见类型string、int等也有事先封装好的sort.Strings()，sort.Int()。对于自定义类型，在实现sort.Interface接口后，也可使用sort.Sort排序。接口定义如下：

1
2
3
4
5
6
7

package sort

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

三个方法分别用来返回长度、比较大小和交换顺序。这也是排序的几个基本操作。下面给出了字符串排序的内部实现：

1
2
3
4
5

type StringSlice []string

func (s StringSlice) Len() int { return len(s) }
func (s StringSlice) Less(i, j int) bool { return p[i] < p[j] }
func (s StringSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

在排序struct等复杂类型slice时，建议定义指针类型数组，这样可以让swap时速度更快。

sort还有一个方便的反向排序方法sort.Reverse，它借助了struct embedding，用一个内部类型reverse封装了外部实现接口的类型，另外，直接在reverse上定义了Less，覆盖了Interface的实现，从而实现了反向排序：

1
2
3
4
5
6

package sort
type reverse struct { Interface }
func (r reverse) Less (i, j int) bool { return r.Interface.Less(j, i) }
func Reverse(i Interface) Interface { return reverse{i} }

sort.Sort(sort.Reverse(byArtist(tracks)))

除了slice类型外，其他实现了sort.Interface接口的类型一样可以排序：

1
2
3
4
5
6
7
8

type customSort struct {
    t []*Track
    less func(x, y *Track) bool
}

func (x customSort) Len() int { return len(x.t) }
func (x customSort) Less(i, j int) bool { return x.less(x.t[i], x.t[j]) }
func (x customSort) Swap(i, j int) { x.t[i], x.t[j] = x.t[j], x.t[i] }

http.Handler接口

1
2
3
4
5
6

package http

type Handler interface {
    ServeHTTP(w ResponseWriter, r *Request)
}
func ListenAndServe(address string, h Handler) error

实现了这个接口的可以传递给ListenAndServe。但通常用不到这种原始的方式。Go的http包提供的ServeMux类型可以给请求分路，聚合一堆http.Handlers。写起来像下面这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func main() {
    db := database{"shoe": 50, "socks": 5}
    mux := http.NewServeMux()
    mux.Handle("/list", http.HandlerFunc(db.list))
    mux.Handle("/price", http.HandlerFunc(db.price))
}
type database map[string]int
func (db database) list(w http.ResponseWriter, req *http.Request) {
    for item, price := range db {
        fmt.Fprintf(w, "%s: %s\n", item, price)
    }
}
func (db database) price(w http.ResponseWriter, req *http.Request) {
    // ...
}

其中http.HandlerFunc将传入的函数包裹成了满足Handler接口的类型。

1
2
3
4
5
6
7

package http

type HandlerFunc func(w ResponseWriter, r *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)
}

对于上面的使用还是要写一些模板代码，对此可以将mux.Handler简写成mux.HandlerFunc("list", db.list)。可以再减少一点代码。实际上，http还提供了一个全局的ServeMux对象实例DefaultServeMux，不需要手动创建。

1
2
3
4
5
6

func main() {
    db := database{"shoes": 50, "socks": 5}
    http.HandlerFunc("/list", db.list)
    http.HandlerFunc("/price", db.price)
    log.Fatal(http.ListenAndServe("localhost:8000", nil)
}

go中每一个handler都在一个单独的goroutine上，要妥善处理好并发的情况。

error接口

1
2
3

type error interface {
    Error() string
}

error类型实现了error接口。整个errors包都围绕这个接口设计，除了errors.New()方法，还可以直接通过fmt.Errorf返回一个格式化后的error值。

1
2
3
4
5
6
7
8
9
10
11
12

package errors
func New(text string) error { return &errorString{text} }
type errorString struct { text string }
func (e *errorString) Error() string { return e.text }

package fmt

import "errors"

func Errorf(format string, arags ...interface{}) error {
    return errors.New(Sprintf(format, args...))
}

简单的数学表达式求值器

递归的AST解析

略。

类型断言

类型断言（type assertion），写作x.(T)，通常用来将动态类型限定到更严格的类型。

• T是具体类型时，会判断x类型是否和T一致，是则将x类型设置为T，否则panic
• T是抽象类型interface时，会判断x是否满足T接口，是则将x类型设置为接口T，否则panic

1
2
3
4
5
6
7

var w io.Writer
w = os.Stdout
f := w.(*os.File)
c := w.(*bytes.Buffer) // panic

w = new(ByteCounter)
rw := w.(io.ReadWriter) // panic

当对nil进行类型断言时时，断言一定失败。另外，类型断言可以支持第二个返回参数ok表示是否成功，此时不会panic。

1
2
3

if w, ok := w.(*os.File); ok {
    // ...use w...
}

应用：错误类型区分

借助类型断言，可以将判断抛出的具体错误类型，os包提供了IsExist，isNotExist，isPermission用来区分文件已存在，文件不存在，不允许几种错误。我们以文件不存在为例，此时抛出的PathError类型错误包含了具体的错误类型。

1
2
3
4
5
6
7
8
9
10
11
12
13

type PathError struct {
    Op string
    Path string
    Err error
}
// 满足Error接口
func (e *PathError) Error() string {
    return e.Op + " " + e.Path + ": " + e.Err.Error()
}

_, err := os.Open("/no/such/path")
fmt.Printf("%#v\n", err)
// Output: &os.PathError{Op:"open", Path:"/no/such/path", Err:0x2}

使用断言后，就可以从err中拿到具体错误类型，从而判断是否是文件不存在导致的：

1
2
3
4
5
6
7
8
9
10

import (
    "errors"
    "syscall"
)
func IsNotExist(err error) bool {
    if pe, ok := err.(*PathError); ok {
        err = pe.Err
    }
    return err == syscall.ENOENT || err == ErrNotExist
}

另外，建议在错误抛出时就进行检测，在聚合后，原始错误的数据结构可能会丢失从而无法判断。

方法查询

抽象类型如io.Writer可能缺少使用者需要的方法如io.WriteString（尽管满足io.Writer的大多数具体类型除了必须满足的Write方法外，都对写入字符串支持了WriteString方法）。

可以定义一个临时接口类型，判断满足抽象类型的变量是否具有指定方法。因为Go中接口的满足是隐式的（类似鸭子类型），不像许多强类型语言一样，需要显式声明。之前使用弱类型语言的可能能很好接受。

1
2
3
4
5
6
7
8
9

func writeString(w io.Writer, s string) (n int, err error) {
    type stringWriter interface {
        WriteString(string) (n int, err error)
    }
    if sw, ok := w.(stringWriter); ok {
        return sw.WriteString(s) // 更有效率的方案
    }
    return w.Write([]byte(s))  // 兜底方案
}

实际上，fmt.Sprintf打印不同类型的变量时，也借助了类型断言，对于特定类型调用特定方法，最后再使用反射处理其他类型。

1
2
3
4
5
6
7
8
9
10
11

package fmt

func formatOnValue(x interface{}) string {
    if err, ok := x.(error); ok {
        return err.Error()
    }
    if str, ok := x.(Stringer); ok {
        return str.String()
    }
    // ...
}

Type switch

interface除了之前说的让多个具体类型有一致表现的用法外，还可以作为可区分具体类型的合集来使用。这种时候需要结合type switch的用法。如下所示：

1
2
3
4
5
6
7

switch x.(type) {
case nil: //...
case int, uint: //...
case bool: //...
case string: //...
default: //...
}

通常在确定了x的类型后，还需要直接使用x。此时可以写作switch x:= x.(type)。

这种用法和之前的用法不同在于：这里接口不作为有一致表现而存在，它只是用来暂存将要区分开的具体类型，而这些具体类型往往时有不同表现的。所以这种用法里的接口几乎没有方法。换一种说法，之前的用法里，接口背后的具体类型细节需要被掩盖来使用，而这里需要使用具体类型的细节。

一些忠告

和上一章方法类似，接口是一种很好使用的面向对象的特性。但不建议上来就从定义一堆接口开始，这样通常会产生一大堆只有一个具体类型实现的接口。接口是抽象类型，是通过具体类型抽象得来的。通常是在需要用统一的方式处理不同类型时，拿来使用。

同时，大多数Go程序中，接口往往小且包含比较少的方法。像是io.Writer或fmt.Stringer。和方法一章一样，它们虽然是面向对象的特性，但是不是Go中一定要使用的语言特性。只在需要的时候使用。大多数时候，直接使用函数就足够了。在书中，方法如input.Write的使用就远不如函数如fmt.Printf来得频繁。

goroutine和信道

Go支持两种并发编程的风格，第一种在本章介绍，通过goroutines和channels支持通信顺序进程（Communicating sequential processes，CSP），这种情况下，值会在goroutine间来回传递，而变量在多数情况下被限制自单个活动中。下一章介绍的共享变量风格的并发编程更接近传统的并发风格。

认识goroutine

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

func main() {
    go spinner(100 * time.Millisecond)
    const n = 45
    fibN := fib(n) // slow
    fmt.Printf("\rFibonacci(%d) = %d\n", n, fibN)
}

func spinner(delay time.Duration) {
    for {
        for _, r = range `-\|/` {
            fmt.Printf("\r%c", r)
            time.Sleep(delay)
        }
    }
}
func fib(x int) int {
    if x < 2 {
        return x
    }
    return fib(x-1) + fib(x-2)
}

• goroutine类似线程，有着定量而非定性的差异
• main函数也会启动一个main goroutine
• goroutine通过go启动一个函数或方法调用，并在声明后立即返回
• 除了main函数返回或程序结束（os.Exit）外，一个goroutine没有办法直接停止另一个，但可以通过传值的方式间接实现。

简单示例

服务器处理请求是最典型的并发场景。

1. Clock Server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

package main

import (
    "io"
    "log"
    "net"
    "time"
)

func main() {
    listener, err := net.Listen("tcp", "localhost:8000")
    if err != nil {
        log.Fatal(err)
    }
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Print(err)
            continue
        }
        handleConn(conn) // go handleConn(conn)
    }
}

func handleConn(c net.Conn) {
    defer c.Close()
    for {
        _, err := io.WriteString(c, time.Now().Format("15:04:05\n"))
        if err != nil {
            return // e.g. client disconnect
        }
        time.Sleep(1 * time.Second)
    }
}

• listener.Accept会在接收到TCP连接请求前一直阻塞
• time.Format方法通过一个特殊的样例（15:04:05）表示要格式化的格式，time.Parse也是如此
• client端可以用net.Dial发起一个TCP连接请求

上述的服务端是串行处理client的请求，并每秒打印当前时间，在handleConn(conn)前加上go关键字后，即可让服务端并行处理client的请求。

2. Echo Server

上面的例子是在一个连接中使用一个goroutine，当然每个连接也可以创建多个goroutine。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// server
func echo(c net.Conn, shout string, delay time.Duration) {
    fmt.Fprintln(c, "\t", strings.ToUpper(shout))
    time.Sleep(delay)
    fmt.Fprintln(c, "\t", shout)
    time.Sleep(delay)
    fmt.Fprintln(c, "\t", strings.ToLower(shout))
}
func handleConn(c net.Conn) {
    input := bufio.NewScanner(c)
    for input.Scan() {
        echo(c, input.Text(), 1*time.Second) // go echo(...)
    }
    c.Close()
}

// client
func main() {
    conn, err := net.Dial("tcp", "localhost:8000")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    go mustCopy(os.Stdout, conn)
    mustCopy(conn, os.Stdin)
}

在echo前加上go即可让服务器同时相应多个请求，返回“回声”。同理，在client端打印服务端返回的代码前加上go即可让使用者输入的同时打印返回的“回声”。

信道（channel）

go启动并行的活动，信道作为活动间通信的通道，借助它可以发送和接收消息。信道通过make构造，需要指定传输消息的类型，作为信道类型。可以使用close关闭信道。后续的发送操作会panic，接收操作会得所有到已发送的值，而再之后的后续接收操作只能得到信道类型对应的零值。

1
2
3
4
5
6
7
8

ch := make(chan int)

ch <- x
x = <-ch
// 直接丢弃channel来的值
<-ch

close(ch)

信道还分为有缓冲区和无缓冲区两种类型，上述的make构造的都是无缓冲区的信道，指定第二个参数可以构造有缓冲区的信道。

1
2
3

ch = make(chan int) // 无缓冲区
ch = make(chan int, 0) // 无缓冲区
ch = make(chan int, 3) // 有缓冲区

无缓冲信道（Unbuffered Channels）

向无缓冲区发送消息会阻塞发送所在的goroutine，直到对应的goroutine在同一个信道上执行接收操作。相反地，接收消息在先的话，也会阻塞直到同一个信道上执行了发送操作。这种机制会同步两个goroutine的执行进度。如果发送信息在先，则接收信息会在发送所在的goroutine之前发生。从而，我们可以基于这个假设的前提保证一些事实。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func main() {
    conn, err := net.Dial("tcp", "localhost:8000")
    if err != nil {
        log.Fatal(err)
    }
    done := make(chan struct{})
    go func() {
        io.Copy(os.Stdout, conn)
        log.Println("done")
        done <- struct{}{} // signal the main goroutine
    }()
    mustCopy(conn, os.Stdin)
    conn.Close()
    <-done // wait for background goroutine to finish
}

上述程序里，会在接收完服务端返回后，才会关闭客户端。这里需要的是一个事件，使用的信道类型其实并不重要，所以使用了struct{}。实际应用中会使用bool或是int这样的简单类型。

流水线

借助上面提到的无缓冲区信道，可以实现多个goroutine之间的接续传递，也可以叫做流水线。

1
2
3

+-----------+         +-----------+         +-----------+
|  Counter  |   -->   |  Squarer  |   -->   |  Printer  |
+-----------+         +-----------+         +-----------+

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

func main() {
    naturals: make(chan int)
    squares: make(chan int)
    // Counter
    go func() {
        for x := 0; x < 100 ;x++ {
            naturals <- x
        }
        close(naturals)
    }()
    // Squarer
    go func() {
        for {
            x := <-naturals
            squares <- x * x
        }
    }
    for {
        fmt.Println(<-squares)
    }
}

上面的流水线中，Counter在打印100个自然数后，会关闭信道。会有之前所说的一些特性：

• 向关闭信道写入消息会panic
• 从关闭信道读取信息会得到所有未发送的消息，再之后只能得到零值
• 关闭信道不会影响其他goroutine执行

所以在上面的程序中，Printer会继续打印0，只有Counter正常退出。Go中没有直接的获取信道是否关闭的方法，但是对于从信道中读取消息有第二个ok参数，为false时表示信道已关闭且读取完所有消息。

1
2