第1条 了解Go语言的诞生与演进

在C语言的基础上，修正一些明显的缺陷，删除一些被诟病较多的特性，增加一些缺失的功能。具体功能和特性如下。

• 使用import替代include。
• 去掉宏（macro）。
• 理想情况是用一个源文件替代.h和.c文件，模块的接口应该被自动提取出来（而无须手动在.h文件中声明）。
• 语句像C语言一样，但需要修正switch语句的缺陷。
• 表达式像C语言一样，但有一些注意事项（比如是否需要逗号表达式）。
• 基本上是强类型的，但可能需要支持运行时类型。
• 数组应该总是有边界检查。
• 具备垃圾回收的机制。
• 支持接口（interface）。
• 支持嵌套和匿名函数/闭包。
• 一个简单的编译器。
• 各种语言机制应该能产生可预测的代码。

第2条 选择适当的Go语言版本

和绝大多数编程语言相似，Go语言也是“站在巨人的肩膀上的”，正如图2-1所示，Go继承了诸多编程语言的特性。

Go的基本语法参考了C语言，Go是“C家族语言”的一个分支；而Go的声明语法、包概念则受到了Pascal、Modula、Oberon的启发；一些并发的思想则来自受到Tony Hoare教授CSP理论[1]影响的编程语言，比如Newsqueak和Limbo。

第3条 理解Go语言的设计哲学

3.1 追求简单，少即是多

简单是一种伟大的美德，但我们需要更艰苦地努力才能实现它，并需要经过一个教育的过程才能去欣赏和领会它。但糟糕的是：复杂的东西似乎更有市场。——Edsger Dijkstra，图灵奖得主

当我们问Gopher“你为什么喜欢Go语言”时，我们通常会得到很多答案，如图3-1所示。

不同于那些通过相互借鉴而不断增加新特性的主流编程语言（如C++、Java等），Go的设计者们在语言设计之初就拒绝走语言特性融合的道路，而选择了“做减法”，选择了“简单”，他们把复杂性留给了语言自身的设计和实现，留给了Go核心开发组自己，而将简单、易用和清晰留给了广大Gopher。因此，今天呈现在我们眼前的是这样的Go语言：

• 简洁、常规的语法（不需要解析符号表），它仅有25个关键字；
• 内置垃圾收集，降低开发人员内存管理的心智负担；
• 没有头文件；
• 显式依赖（package）；
• 没有循环依赖（package）；
• 常量只是数字；
• 首字母大小写决定可见性；
• 任何类型都可以拥有方法（没有类）；
• 没有子类型继承（没有子类）；
• 没有算术转换；
• 接口是隐式的（无须implements声明）；
• 方法就是函数；
• 接口只是方法集合（没有数据）；
• 方法仅按名称匹配（不是按类型）；
• 没有构造函数或析构函数；
• n++和n--是语句，而不是表达式；
• 没有++n和--n；
• 赋值不是表达式；
• 在赋值和函数调用中定义的求值顺序（无“序列点”概念）；
• 没有指针算术；
• 内存总是初始化为零值；
• 没有类型注解语法（如C++中的const、static等）；
• 没有模板/泛型；
• 没有异常（exception）；
• 内置字符串、切片（slice）、map类型；
• 内置数组边界检查；
• 内置并发支持；
  ……

任何设计都存在权衡与折中。Go设计者选择的“简单”体现在，站在巨人肩膀上去除或优化在以往语言中已被证明体验不好或难于驾驭的语法元素和语言机制，并提出自己的一些创新性的设计，比如首字母大小写决定可见性，内存分配初始零值，内置以go关键字实现的并发支持等）。Go设计者推崇“最小方式”思维，即一件事情仅有一种方式或数量尽可能少的方式去完成，这大大减少了开发人员在选择路径方式及理解他人所选路径方式上的心智负担。

3.2 偏好组合，正交解耦

当我们有必要采用另一种方式处理数据时，我们应该有一些耦合程序的方式，就像花园里将浇水的软管通过预置的螺丝扣拧入另一段那样，这也是Unix IO采用的方式。——Douglas McIlroy，Unix管道的发明者（1964）

C++、Java等主流面向对象（以下简称OO）语言通过庞大的自上而下的类型体系、继承、显式接口实现等机制将程序的各个部分耦合起来，但在Go语言中我们找不到经典OO的语法元素、类型体系和继承机制，或者说Go语言本质上就不属于经典OO语言范畴。针对这种情况，很多人会问：那Go语言是如何将程序的各个部分有机地耦合在一起的呢？就像上面引述的Douglas McIlroy那句话中的浇水软管那样，Go语言遵从的设计哲学也是组合。

在诠释组合之前，我们可以先来了解一下Go在语法元素设计时是如何为组合哲学的应用奠定基础的。
在语言设计层面，Go提供了正交的语法元素供后续组合使用，包括：

• Go语言无类型体系（type hierarchy），类型之间是独立的，没有子类型的概念；
• 每个类型都可以有自己的方法集合，类型定义与方法实现是正交独立的；
• 接口（interface）与其实现之间隐式关联；
• 包（package）之间是相对独立的，没有子包的概念。

我们看到无论是包、接口还是一个个具体的类型定义（包括类型的方法集合），Go语言为我们呈现了这样一幅图景：一座座没有关联的“孤岛”，但每个岛内又都很精彩。现在摆在面前的工作就是以最适当的方式在这些孤岛之间建立关联（耦合），形成一个整体。Go采用了组合的方式，也是唯一的方式。

Go语言提供的最为直观的组合的语法元素是类型嵌入（typeembedding）。通过类型嵌入，我们可以将已经实现的功能嵌入新类型中，以快速满足新类型的功能需求。这种方式有些类似经典OO语言中的继承机制，但在原理上与其完全不同，这是一种Go设计者们精心设计的语法糖。被嵌入的类型和新类型之间没有任何关系，甚至相互完全不知道对方的存在，更没有经典OO语言中的那种父类、子类的关系以及向上、向下转型（type casting）。在通过新类型实例调用方法时，方法的匹配取决于方法名字，而不是类型。这种组合方式，笔者称之为“垂直组合”，即通过类型嵌入，快速让一个新类型复用其他类型已经实现的能力，实现功能的垂直扩展。
下面是一个类型嵌入的例子：

// $GOROOT/src/sync/pool.go
type poolLocal struct {
  private  interface{}
  shared   []interface{}
  Mutex
  pad      [128]byte
}

我们在poolLocal这个结构体类型中嵌入了类型Mutex，被嵌入的Mutex类型的方法集合会被提升到外面的类型（poolLocal）中。比如，这里的poolLocal将拥有Mutex类型的Lock和Unlock方法。但在实际调用时，方法调用会被传给poolLocal中的Mutex实例。

我们在标准库中还经常看到如下的interface类型嵌入的代码：

// $GOROOT/src/io/io.go
type ReadWriter interface {
  Reader
  Writer
}

通过在interface的定义中嵌入interface类型来实现接口行为的聚合，组成大接口，这种方式在标准库中尤为常用，并且已经成为Go语言的一种惯用法。

interface是Go语言中真正的“魔法”，是Go语言的一个创新设计，它只是方法集合，且与实现者之间的关系是隐式的，它让程序各个部分之间的耦合降至最低，同时是连接程序各个部分的“纽带”。隐式的interface实现会不经意间满足依赖抽象、里氏替换、接口隔离等设计原则，这在其他语言中是需要很刻意的设计谋划才能实现的，但在Go interface看来，一切却是自然而然的。

通过interface将程序各个部分组合在一起的方法，笔者称之为“水平组合”。水平组合的模式有很多，一种常见的方法是通过接受interface类型参数的普通函数进行组合，例如下面的代码。

// $GOROOT/src/io/ioutil/ioutil.go
func ReadAll(r io.Reader)([]byte, error)

// $GOROOT/src/io/io.go
func Copy(dst Writer, src Reader)(written int64, err error)

函数ReadAll通过io.Reader这个接口将io.Reader的实现与ReadAll所在的包以低耦合的方式水平组合在一起了。类似的水平组合模式还有wrapper、middleware等，这里就不展开了，在后面讲到interface时再详细叙述。

此外，Go语言内置的并发能力也可以通过组合的方式实现对计算能力的串联，比如通过goroutine+channel的组合实现类似Unix Pipe的能力。

综上，组合原则的应用塑造了Go程序的骨架结构

• 类型嵌入为类型提供垂直扩展能力
• interface是水平组合的关键，它好比程序肌体上的“关节”，给予连接“关节”的两个部分各自“自由活动”的能力，而整体上又实现了某种功能。

组合也让遵循简单原则的Go语言在表现力上丝毫不逊色于复杂的主流编程语言。

3.3 原生并发，轻量高效

并发是有关结构的，而并行是有关执行的。——Rob Pike（2012）

Go的设计者敏锐地把握了CPU向多核方向发展的这一趋势，在决定不再使用C++而去创建一门新语言的时候，果断将面向多核、原生内置并发支持作为新语言的设计原则之一。

Go语言原生支持并发的设计哲学体现在以下几点。
（1）Go语言采用轻量级协程并发模型，使得Go应用在面向多核硬件时更具可扩展性

Go果断放弃了传统的基于操作系统线程的并发模型，而采用了用户层轻量级线程或者说是类协程（coroutine），Go将之称为goroutine。goroutine占用的资源非常少，Go运行时默认为每个goroutine分配的栈空间仅2KB。goroutine调度的切换也不用陷入（trap）操作系统内核层完成，代价很低。因此，在一个Go程序中可以创建成千上万个并发的goroutine。所有的Go代码都在goroutine中执行，哪怕是Go的运行时代码也不例外。

不过，一个Go程序对于操作系统来说只是一个用户层程序。操作系统的眼中只有线程，它甚至不知道goroutine的存在。goroutine的调度全靠Go自己完成，实现Go程序内goroutine之间公平地竞争CPU资源的任务就落到了Go运行时头上。而将这些goroutine按照一定算法放到CPU上执行的程序就称为goroutine调度器（goroutine scheduler）。

（2）Go语言为开发者提供的支持并发的语法元素和机制

我们先来看看那些设计并诞生于单核年代的编程语言（如C、C++、Java）在语法元素和机制层面是如何支持并发的。

• 执行单元：线程。
• 创建和销毁的方式：调用库函数或调用对象方法。
• 并发线程间的通信：多基于操作系统提供的IPC机制，比如共享内存、Socket、Pipe等，当然也会使用有并发保护的全局变量。

与上述传统语言相比，Go提供了语言层面内置的并发语法元素和机制。

• 执行单元：goroutine。
• 创建和销毁方式：go+函数调用；函数退出即goroutine退出。
• 并发goroutine的通信：通过语言内置的channel传递消息或实现同步，并通过select实现多路channel的并发控制。

对比来看，Go对并发的原生支持将大大降低开发人员在开发并发程序时的心智负担。

（3）并发原则对Go开发者在程序结构设计层面的影响

由于goroutine的开销很小（相对线程），Go官方鼓励大家使用goroutine来充分利用多核资源。但并不是有了goroutine就一定能充分利用多核资源，或者说即便使用Go也不一定能写出好的并发程序。为此Rob Pike曾做过一次关于“并发不是并行”的主题分享，图文并茂地讲解了并发（Concurrency）和并行（Parallelism）的区别。RobPike认为：

• 并发是有关结构的，它是一种将一个程序分解成多个小片段并且每个小片段都可以独立执行的程序设计方法；并发程序的小片段之间一般存在通信联系并且通过通信相互协作。
• 并行是有关执行的，它表示同时进行一些计算任务。以上观点的重点是，并发是一种程序结构设计的方法，它使并行成为可能。

采用并发方案设计的程序在单核处理器上也是可以正常运行的（在单核上的处理性能可能不如非并发方案），并且随着处理器核数的增多，并发方案可以自然地提高处理性能，提升吞吐量。而非并发方案在处理器核数提升后，也仅能使用其中的一个核，无法自然扩展，这一切都是程序的结构所决定的。这告诉我们：并发程序的结构设计不要局限于在单核情况下处理能力的高低，而要以在多核情况下充分提升多核利用率、获得性能的自然提升为最终目的。

除此之外，并发与组合的哲学是一脉相承的，并发是一个更大的组合的概念，它在程序设计层面对程序进行拆解组合，再映射到程序执行层面：goroutine各自执行特定的工作，通过channel+select将goroutine组合连接起来。并发的存在鼓励程序员在程序设计时进行独立计算的分解，而对并发的原生支持让Go语言更适应现代计算环境。

3.4 面向工程，“自带电池”

软件工程指引着Go语言的设计。——Rob Pike（2012）

要想理解这条设计哲学，我们依然需要回到三位Go语言之父在设计Go语言时的初衷：面向真实世界中Google内部大规模软件开发存在的各种问题，为这些问题提供答案。主要的问题包括：

• 程序构建慢；
• 失控的依赖管理；
• 开发人员使用编程语言的不同子集（比如C++支持多范式，这样有些人用OO，有些人用泛型）；
• 代码可理解性差（代码可读性差、文档差等）；
• 功能重复实现；
• 升级更新消耗大；
• 实现自动化工具难度高；
• 版本问题；
• 跨语言构建问题。

第4条 使用Go语言原生编程思维来写Go代码