Effective Go

• 每个包都应包含一段包注释 ，即放置在包子句前的一个块注释
• 对于包含多个文件的包， 包注释只需出现在其中的任一文件中即可
• 包注释应在整体上对该包进行介绍，并提供包的相关信息。 它将出现在 godoc 页面中的最上面，并为紧随其后的内容建立详细的文档

  /*
          regexp 包为正则表达式实现了一个简单的库。
  
          该库接受的正则表达式语法为：
  
          正则表达式:
                  串联 { '|' 串联 }
          串联:
                  { 闭包 }
          闭包:
                  条目 [ '*' | '+' | '?' ]
          条目:
                  '^'
                  '$'
                  '.'
                  字符
                  '[' [ '^' ] 字符遍历 ']'
                  '(' 正则表达式 ')'
  */
  package regexp
  

• 若某个包比较简单，包注释同样可以简洁些

// path 包实现了一些常用的工具，以便于操作用反斜杠分隔的路径.

注释无需进行额外的格式化，如用星号来突出等。生成的输出甚至可能无法以等宽字体显示， 因此不要依赖于空格对齐，godoc 会像 gofmt 那样处理好这一切。 注释是不会被解析的纯文本，因此像HTML或其它类似于 这样 的东西将按照 原样 输出，因此不应使用它们。godoc 所做的调整， 就是将已缩进的文本以等宽字体显示，来适应对应的程序片段。 fmt 包的注释就用了这种不错的效果

godoc 是否会重新格式化注释取决于上下文，因此必须确保它们看起来清晰易辨： 使用正确的拼写、标点和语句结构以及折叠长行等

• 在包中 任何顶级声明前面的注释都将作为该声明的文档注释
• 在程序中 每个可导出（首字母大写）的名称都应该有文档注释
• 文档注释最好是 完整的句子，这样它才能适应各种自动化的展示。 第一句应当以被声明的东西开头，并且是单句的摘要

// Compile 用于解析正则表达式并返回，如果成功，则 Regexp 对象就可用于匹配所针对的文本。
func Compile(str string) (regexp *Regexp, err error) {

• 若注释总是以名称开头，godoc 的输出就能通过 grep 变得更加有用
• Go的声明语法允许成组声明。单个文档注释应介绍一组相关的常量或变量。 由于是整体声明，这种注释往往较为笼统

// 表达式解析失败后返回错误代码。
var (
        ErrInternal      = errors.New("regexp: internal error")
        ErrUnmatchedLpar = errors.New("regexp: unmatched '('")
        ErrUnmatchedRpar = errors.New("regexp: unmatched ')'")
        ...
)

• 即便是对于私有名称，也可通过成组声明来表明各项间的关系，例如某一组由互斥体保护的变量

var (
        countLock   sync.Mutex
        inputCount  uint32
        outputCount uint32
        errorCount  uint32
)

当一个包被导入后， 包名就会成了内容的访问器

import "bytes"

之后，被导入的包就能通过 bytes.Buffer 来引用了。 若所有人都以相同的名称来引用其内容将大有裨益， 这也就意味着包应当有个恰当的名称：其名称应该简洁明了而易于理解。按照惯例， 包应当以小写的单个单词来命名，且不应使用下划线或驼峰记法 。err 的命名就是出于简短考虑的，因为任何使用该包的人都会键入该名称。 不必担心引用次序的冲突。 包名就是导入时所需的唯一默认名称， 它并不需要在所有源码中保持唯一，即便在少数发生冲突的情况下， 也可为导入的包选择一个别名来局部使用 无论如何，通过文件名来判定使用的包，都是不会产生混淆的

另一个约定就是包名应为其源码目录的基本名称。在 src/pkg/encoding/base64 中的包应作为 encoding/base64 导入，其包名应为 base64 而非 encoding_base64 或 encodingBase64

包的导入者可通过包名来引用其内容，因此包中的可导出名称可以此来避免冲突。 （请勿使用 import . 记法 ，它可以简化必须在被测试包外运行的测试， 除此之外应尽量避免使用）例如，bufio 包中的缓存读取器类型叫做 Reader 而非 BufReader，因为用户将它看做 bufio.Reader ，这是个清楚而简洁的名称。 此外，由于被导入的项总是通过它们的包名来确定，因此 bufio.Reader 不会与 io.Reader 发生冲突。同样，用于创建 ring.Ring 的新实例的函数（这就是Go中的构造函数）一般会称之为 NewRing ，但由于 Ring 是该包所导出的唯一类型，且该包也叫 ring，因此它可以只叫做 New ，它跟在包的后面，就像 ring.New 使用包结构可以帮助你选择好的名称

另一个简短的例子是 once.Do ，once.Do(setup) 表述足够清晰， 使用 once.DoOrWaitUntilDone(setup) 完全就是画蛇添足。 长命名并不会使其更具可读性。一份有用的说明文档通常比额外的长名更有价值

Go并不对获取器（getter）和设置器（setter）提供自动支持。 你应当自己提供获取器和设置器，通常很值得这样做，但 若要将 Get 放到获取器的名字中，既不符合习惯，也没有必要 。*若你有个名为 owner （小写，未导出）的字段，其获取器应当名为 Owner（大写，可导出）而非 GetOwner* 。大写字母即为可导出的这种规定为区分方法和字段提供了便利。 若要提供设置器方法，SetOwner 是个不错的选择 。两个命名看起来都很合理：

owner := obj.Owner()
if owner != user {
        obj.SetOwner(user)
}

按照约定， 只包含一个方法的接口应当以该方法的名称加上-er后缀来命名 如 Reader、Writer、 Formatter、CloseNotifier 等。

诸如此类的命名有很多，遵循它们及其代表的函数名会让事情变得简单。 Read、Write、Close、Flush、 String 等都具有典型的签名和意义。 为避免冲突，请不要用这些名称为你的方法命名， 除非你明确知道它们的签名和意义相同 。反之，若你的类型实现了的方法， 与一个众所周知的类型的方法拥有相同的含义，那就使用相同的命名。 请将字符串转换方法命名为 String 而非 ToString

Go中约定使用驼峰记法 MixedCaps 或 mixedCaps

在Go中，一个简单的 if 语句看起来像这样：

if x > 0 {
        return y
}

强制的大括号促使你将简单的 if 语句分成多行。特别是在主体中包含 return 或 break 等控制语句时，这种编码风格的好处一比便知

由于 if 和 switch 可接受初始化语句， 因此 用它们来设置局部变量十分常见

if err := file.Chmod(0664); err != nil {
        log.Print(err)
        return err
}

在Go的库中，你会发现若 if 语句不会执行到下一条语句时，亦即其 执行体 以 break、continue、goto 或 return 结束时，不必要的 else 会被省略

f, err := os.Open(name)
if err != nil {
        return err
}
codeUsing(f)

下例是一种常见的情况，代码必须防范一系列的错误条件。若控制流成功继续， 则说明程序已排除错误。由于出错时将以return 结束， 之后的代码也就无需 else 了

f, err := os.Open(name)
if err != nil {
        return err
}
d, err := f.Stat()
if err != nil {
        f.Close()
        return err
}
codeUsing(f, d)

Go的 for 循环类似于C，但却不尽相同

• 它统一了 for 和 while，不再有 do-while 了，它有三种形式，但只有一种需要分号

// 如同C的for循环
for init; condition; post { }

// 如同C的while循环
for condition { }

// 如同C的for(;;)循环
for { }

• 简短声明能更容易在循环中声明下标变量：

sum := 0
for i := 0; i < 10; i++ {
        sum += i
}

• 若你想遍历数组、切片、字符串或者映射，或从信道中读取消息， range 子句能够帮你轻松实现循环

for key, value := range oldMap {
        newMap[key] = value
}

• 若只需要该遍历中的第一个项（键或下标），去掉第二个就行了

for key := range m {
        if key.expired() {
                delete(m, key)
        }
}

• 若你只需要该遍历中的第二个项（值），请使用空白标识符，即下划线来丢弃第一个值

sum := 0
for _, value := range array {
        sum += value
}

对于字符串，range 能够提供更多便利。它能通过解析UTF-8， 将每个独立的Unicode码点分离出来。错误的编码将占用一个字节，并以符文U+FFFD来代替。 （名称 符文 和内建类型 rune 是Go对单个Unicode码点的成称谓。 详情见语言规范）

for pos, char := range "日本\x80語" { // \x80 是个非法的UTF-8编码
        fmt.Printf("字符 %#U 始于字节位置 %d\n", char, pos)
}

字符 U+65E5 '日' 始于字节位置 0
字符 U+672C '本' 始于字节位置 3
字符 U+FFFD '?' 始于字节位置 6
字符 U+8A9E '語' 始于字节位置 7

• 若想要在 for 中使用多个变量，应采用平行赋值的方式，它会拒绝 ++ 和 –

// 反转 a
for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
        a[i], a[j] = a[j], a[i]
}

Go的 switch 比C的更通用。 其表达式无需为常量或整数 case 语句会自上而下逐一进行求值直到匹配为止。若 switch 后面没有表达式，它将匹配 true，因此，可以将 if-else-if-else 链写成一个 switch，这也更符合Go的风格

func unhex(c byte) byte {
        switch {
        case '0' <= c && c <= '9':
                return c - '0'
        case 'a' <= c && c <= 'f':
                return c - 'a' + 10
        case 'A' <= c && c <= 'F':
                return c - 'A' + 10
        }
        return 0
}

• switch 并不会自动下溯，但 case 可通过逗号分隔来列举相同的处理条件

func shouldEscape(c byte) bool {
        switch c {
        case ' ', '?', '&', '=', '#', '+', '%':
                return true
        }
        return false
}

Go与众不同的特性之一就是函数和方法可返回多个值。这种形式可以改善C中一些笨拙的习惯： 将错误值返回（例如用 -1 表示 EOF）和修改通过地址传入的实参

在C中，写入操作发生的错误会用一个负数标记，而错误码会隐藏在某个不确定的位置。 而在Go中，Write 会返回写入的字节数以及一个错误： 是的，您写入了一些字节，但并未全部写入，因为设备已满 。在 os 包中，File.Write 的签名为：

func (file *File) Write(b []byte) (n int, err error)

正如文档所述，它返回写入的字节数，并在n != len(b) 时返回一个非 nil 的 error 错误值

• 可以采用一种简单的方法。来避免为模拟引用参数而传入指针。 以下简单的函数可从字节数组中的特定位置获取其值，并返回该数值和下一个位置

func nextInt(b []byte, i int) (int, int) {
        for ; i < len(b) && !isDigit(b[i]); i++ {
        }
        x := 0
        for ; i < len(b) && isDigit(b[i]); i++ {
                x = x*10 + int(b[i]) - '0'
        }
        return x, i
}

可以像下面这样，通过它扫描输入的切片 b 来获取数字

for i := 0; i < len(b); {
        x, i = nextInt(b, i)
        fmt.Println(x)
}

Go函数的返回值或结果 形参 可被命名，并作为常规变量使用，就像传入的形参一样。 命名后，一旦该函数开始执行，它们就会被初始化为与其类型相应的零值, 若该函数执行了一条不带实参的 return 语句，则结果形参的当前值将被返回

此名称不是强制性的，但它们能使代码更加简短清晰：它们就是文档。若我们命名了 nextInt 的结果，那么它返回的 int 就值如其意了

func nextInt(b []byte, pos int) (value, nextPos int) {

由于被命名的结果已经初始化，且已经关联至无参数的返回，它们就能让代码简单而清晰。 下面的 io.ReadFull 就是个很好的例子：

func ReadFull(r Reader, buf []byte) (n int, err error) {
        for len(buf) > 0 && err == nil {
                var nr int
                nr, err = r.Read(buf)
                n += nr
                buf = buf[nr:]
        }
        return // 无需写return n, err
}

Go的 defer 语句用于预设一个函数调用（ 推迟执行函数 ）， 该函数会在执行 defer 的函数返回之前立即执行。它显得非比寻常， 但却是处理一些事情的有效方式，例如无论以何种路径返回，都必须释放资源的函数。 典型的例子就是 解锁互斥和关闭文件

// Contents 将文件的内容作为字符串返回。
func Contents(filename string) (string, error) {
        f, err := os.Open(filename)
        if err != nil {
                return "", err
        }
        defer f.Close()  // f.Close 会在我们结束后运行。

        var result []byte
        buf := make([]byte, 100)
        for {
                n, err := f.Read(buf[0:])
                result = append(result, buf[0:n]...) // append 将在后面讨论。
                if err != nil {
                        if err == io.EOF {
                                break
                        }
                        return "", err  // 我们在这里返回后，f 就会被关闭。
                }
        }
        return string(result), nil // 我们在这里返回后，f 就会被关闭。
}

推迟诸如 Close 之类的函数调用有两点好处：

1. 它能确保你不会忘记关闭文件。如果你以后又为该函数添加了新的返回路径时， 这种情况往往就会发生
2. 它意味着 关闭 离 打开 很近， 这总比将它放在函数结尾处要清晰明了

被推迟函数的实参（如果该函数为方法则还包括接收者）在推迟执行时就会求值， 而不是在调用执行时才求值 这样不仅无需担心变量值在函数执行时被改变， 同时还意味着单个已推迟的调用可推迟多个函数的执行。下面是个简单的例子

for i := 0; i < 5; i++ {
        defer fmt.Printf("%d ", i)
}

被推迟的函数按照 后进先出 （LIFO）的顺序执行，因此以上代码在函数返回时会打印 4 3 2 1 0。一个更具实际意义的例子是通过一种简单的方法， 用程序来跟踪函数的执行。可以编写一对简单的跟踪例程：

func trace(s string)   { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }

// 像这样使用它们：
func a() {
        trace("a")
        defer untrace("a")
        // 做一些事情....

可以充分利用这个特点，即被推迟函数的实参在 defer 执行时才会被求值。 跟踪例程可针对反跟踪例程设置实参。以下例子：

func trace(s string) string {
        fmt.Println("entering:", s)
        return s
}

func un(s string) {
        fmt.Println("leaving:", s)
}

func a() {
        defer un(trace("a"))
        fmt.Println("in a")
}

func b() {
        defer un(trace("b"))
        fmt.Println("in b")
        a()
}

func main() {
        b()
}

entering: b
in b
entering: a
in a
leaving: a
leaving: b

对于习惯其它语言中块级资源管理的程序员，defer 似乎有点怪异， 但它 最有趣而强大的应用恰恰来自于其基于函数而非块的特点

Go提供了两种分配原语，即内建函数 new 和 make。 它们所做的事情不同，所应用的类型也不同。它们可能会引起混淆，但规则却很简单。 让我们先来看看 new。这是个 用来分配内存的内建函数 ， 但与其它语言中的同名函数不同， 它 不会初始化内存 ，只会将 内存置零 。 也就是说， new(T) 会为类型为 T 的新项分配已置零的内存空间， 并返回它的地址，也就是一个类型为 *T 的值 用Go的术语来说，*它返回一个指针， 该指针指向新分配的，类型为 T 的零值*

既然 new 返回的内存已置零，那么 当你设计数据结构时， 每种类型的零值就不必进一步初始化了，这意味着该数据结构的使用者只需用 new 创建一个新的对象就能正常工作 例如，bytes.Buffer 的文档中提到 零值的 Buffer 就是已准备就绪的缓冲区 同样， sync.Mutex 并没有显式的构造函数或 Init 方法， 而是零值的 sync.Mutex 就已经被定义为已解锁的互斥锁了

零值属性 可以带来各种好处。考虑以下类型声明：

type SyncedBuffer struct {
        lock    sync.Mutex
        buffer  bytes.Buffer
}

SyncedBuffer 类型的值也是在 声明时就分配好内存就绪 后续代码中， p 和 v 无需进一步处理即可正确工作

p := new(SyncedBuffer)  // type *SyncedBuffer
var v SyncedBuffer      // type  SyncedBuffer

内建函数 make(T, args) 的目的不同于 new(T)。它只用于创建 切片、映射和信道 ，并返回类型为 T （而非 *T ）的一个 已初始化 （而 非置零 ）的值

出现这种用差异的原因在于: 这三种类型本质上为 引用数据类型，它们在使用前必须初始化 例如，切片是一个具有三项内容的描述符，包含一个指向（数组内部）数据的指针、长度以及容量， 在这三项被初始化之前，该切片为 nil。对于切片、映射和信道， make 用于初始化其内部的数据结构并准备好将要使用的值

make([]int, 10, 100)

会分配一个具有100个 int 的数组空间，接着创建一个长度为10， 容量为100并指向该数组中前10个元素的切片结构。与此相反，new([]int) 会返回一个指向新分配的，已置零的切片结构， 即一个指向 nil 切片值的指针

下面的例子阐明了 new 和 make 之间的区别：

var p *[]int = new([]int)       // 分配切片结构；*p == nil；基本没用
var v  []int = make([]int, 100) // 切片 v 现在引用了一个具有 100 个 int 元素的新数组

// 没必要的复杂：
var p *[]int = new([]int)
*p = make([]int, 100, 100)

// 习惯用法：
v := make([]int, 100)

请记住:

• make 只适用于映射、切片和信道且不返回指针
• 若要获得明确的指针， 请使用 new 分配内存

在详细规划内存布局时，数组是非常有用的，有时还能避免过多的内存分配， 但它们主要用作切片的构件

以下为数组在Go和C中的主要区别。在Go中，

• 数组是值: 将一个数组赋予另一个数组会复制其所有元素
• 若将某个数组传入某个函数，它将接收到该数组的一份副本而非指针
• 数组的大小是其类型的一部分。类型 [ 10 ]int 和 [ 20 ]int 是不同的

数组为值的属性很有用，但代价高昂。*若你想要C那样的行为和效率，可以传递一个指向该数组的指针*

func Sum(a *[3]float64) (sum float64) {
        for _, v := range *a {
                sum += v
        }
        return
}

array := [...]float64{7.0, 8.5, 9.1}
x := Sum(&array)  // 注意显式的取址操作

但这并不是Go的习惯用法 切片 才是

切片通过对数组进行封装，为数据序列提供了更通用、强大而方便的接口。 除了 矩阵变换 这类需要明确维度的情况外，Go中的大部分数组编程都是通过切片来完成的

• 切片保存了对底层数组的引用， 若将某个切片赋予另一个切片，它们会引用同一个数组
• 若某个函数将一个切片作为参数传入，则它对该切片元素的修改对调用者而言同样可见， 这可以理解为传递了底层数组的指针

Read 函数可接受一个切片实参 而非一个指针和一个计数, 切片的长度决定了可读取数据的上限 以下为 os 包中 File 类型的 Read 方法签名:

func (file *File) Read(buf []byte) (n int, err error)

该方法返回读取的字节数和一个错误值（若有的话）。若要从更大的缓冲区 b 中读取前32个字节，只需对其进行切片即可

n, err := f.Read(buf[0:32])

这种切片的方法常用且高效。若不谈效率，以下片段同样能读取该缓冲区的前32个字节

var n int
var err error
for i := 0; i < 32; i++ {
        nbytes, e := f.Read(buf[i:i+1])  // 读取一个字节
        if nbytes == 0 || e != nil {
                err = e
                break
        }
        n += nbytes
}

• 只要切片不超出底层数组的限制， 它的长度就是可变的，只需将它赋予其自身的切片即可
• 切片的容量可通过内建函数 cap 获得，它将给出该切片可取得的最大长度

以下是将数据追加到切片的函数。若数据超出其容量，则会重新分配该切片。返回值即为所得的切片。 该函数中所使用的 len 和 cap 在应用于 nil 切片时是合法的，它会返回0

func Append(slice, data []byte) []byte {
        l := len(slice)
        if l + len(data) > cap(slice) {  // 重新分配
                // 为了后面的增长，需分配两份。
                newSlice := make([]byte, (l+len(data))*2)
                // copy 函数是预声明的，且可用于任何切片类型。
                copy(newSlice, slice)
                slice = newSlice
        }
        slice = slice[0:l+len(data)]
        for i, c := range data {
                slice[l+i] = c
        }
        return slice
}

最终我们必须返回切片，因为尽管 Append 可修改 slice 的元素，但 切片自身（其运行时数据结构包含指针、长度和容量）是通过值传递的

映射是方便而强大的内建数据结构：

• 可以关联不同类型的值。 其键可以是任何相等性操作符支持的类型 如整数、浮点数、复数、字符串、指针、接口（只要其动态类型支持相等性判断）、结构以及数组
• 切片不能用作映射键 因为它们的相等性还未定义
• 与切片一样，映射也是引用类型。 若将映射传入函数中，并更改了该映射的内容，则此修改对调用者同样可见

映射可使用一般的复合字面语法进行构建，其键-值对使用冒号分隔，因此可在初始化时很容易地构建它们

var timeZone = map[string]int{
        "UTC":  0*60*60,
        "EST": -5*60*60,
        "CST": -6*60*60,
        "MST": -7*60*60,
        "PST": -8*60*60,
}

赋值和获取映射值的语法类似于数组，不同的是映射的索引不必为整数

offset := timeZone["EST"]

若试图通过映射中不存在的键来取值，就会返回与该映射中项的类型对应的零值。 例如，若某个映射包含整数，当查找一个不存在的键时会返回 0。 集合可实现成一个值类型为 bool 的映射。将该映射中的项置为 true 可将该值放入集合中，此后通过简单的索引操作即可判断是否存在

attended := map[string]bool{
        "Ann": true,
        "Joe": true,
        ...
}

if attended[person] { // 若某人不在此映射中，则为 false
        fmt.Println(person, "正在开会")
}

有时需要区分某项是不存在还是其值为零值。如对于一个值本应为零的 "UTC" 条目，也可能是由于不存在该项而得到零值。可以使用多重赋值的形式来分辨这种情况

var seconds int
var ok bool
seconds, ok = timeZone[tz]

在下面的例子中，若 tz 存在， seconds 就会被赋予适当的值，且 ok 会被置为 true； 若不存在，seconds 则会被置为零，而 ok 会被置为 false

func offset(tz string) int {
        if seconds, ok := timeZone[tz]; ok {
                return seconds
        }
        log.Println("unknown time zone:", tz)
        return 0
}

若仅需判断映射中是否存在某项而不关心实际的值，可使用空白标识符 （_{）来代替该值的一般变量}

_, present := timeZone[tz]

要删除映射中的某项，可使用内建函数 delete 它以映射及要被删除的键为实参。 即便对应的键不在该映射中，此操作也是安全的

delete(timeZone, "PDT")  // 现在用标准时间

Go采用的 格式化打印 风格和C的 printf 族类似，但却更加丰富而通用。 这些函数位于 fmt 包中，且函数名首字母均为大写：如 fmt.Printf、fmt.Fprintf，fmt.Sprintf 等。 字符串函数（Sprintf 等）会返回一个字符串，而非填充给定的缓冲区

无需提供一个格式字符串。每个 Printf、Fprintf 和 Sprintf 都分别对应另外的函数，如 Print 与 Println。 这些函数并 不接受格式字符串，而是为每个实参生成一种默认格式 。 Println 系列的函数还会在实参中插入空格，并在输出时追加一个换行符 ，而 Print 版本仅在 操作数两侧都没有字符串时才添加空白

以下示例中各行产生的输出都是一样的

fmt.Printf("Hello %d\n", 23) //格式化打印
fmt.Fprint(os.Stdout, "Hello ", 23, "\n") //格式化打印到标准输出流
fmt.Println("Hello", 23) // Hello和23之间插入空格
fmt.Println(fmt.Sprint("Hello ", 23)) // Springt返回一个字符串

fmt.Fprint 一类的格式化打印函数可接受任何实现了 io.Writer 接口的对象作为第一个实参, 变量os.Stdout 与 os.Stderr 都是人们熟知的例子

与C的不同：

• 像 %d 这样的数值格式并不接受表示符号或大小的标记， 打印例程会根据实参的类型来决定这些属性

var x uint64 = 1<<64 - 1
fmt.Printf("%d %x; %d %x\n", x, x, int64(x), int64(x))

18446744073709551615 ffffffffffffffff; -1 -1 

• 若你只想要默认的转换，如使用十进制的整数，你可以使用通用的格式 %v（对应值）；其结果与 Print 和 Println 的输出完全相同。此外，这种格式还能打印任意值，甚至包括数组、结构体和映射。 以下是打印上一节中定义的时区映射的语句

fmt.Printf("%v\n", timeZone)  // 或只用 fmt.Println(timeZone)

map[CST:-21600 PST:-28800 EST:-18000 UTC:0 MST:-25200]

映射中的键可能按任意顺序输出

• 当打印结构体时
  • %+v 会为结构体的每个字段添上字段名
  • %#v 将完全按照Go的语法打印值

type T struct {
        a int
        b float64
        c string
}
t := &T{ 7, -2.35, "abc\tdef" }
fmt.Printf("%v\n", t)
fmt.Printf("%+v\n", t)
fmt.Printf("%#v\n", t)
fmt.Printf("%#v\n", timeZone)

&{7 -2.35 abc   def}
&{a:7 b:-2.35 c:abc     def}
&main.T{a:7, b:-2.35, c:"abc\tdef"}
map[string] int{"CST":-21600, "PST":-28800, "EST":-18000, "UTC":0, "MST":-25200}

• 请注意其中的&符号 当遇到 string 或 []byte 值时：
  • 可使用 %q 产生带引号的字符串（%q 格式也可用于整数和符文，它会产生一个带单引号的符文常量）
  • 而格式 %#q 会尽可能使用反引号
  • %x 还可用于字符串、字节数组以及整数，并生成一个很长的十六进制字符串
  • 带空格的格式（% x）还会在字节之间插入空格
• 另一种实用的格式是 %T，它会打印某个值的类型

fmt.Printf("%T\n", timeZone)

map[string] int

• 若想控制自定义类型的默认格式，只需为该类型定义一个具有 String() string 签名的方法。对于简单的类型 T，可进行如下操作

func (t *T) String() string {
        return fmt.Sprintf("%d/%g/%q", t.a, t.b, t.c)
}
fmt.Printf("%v\n", t)

7/-2.35/"abc\tdef"

如果需要像指向 T 的指针那样打印类型 T 的值， String 的接收者就必须是值类型的；上面的例子中接收者是一个指针， 因为这对结构来说更高效而通用

String 方法也可调用 Sprintf， 因为打印例程可以完全重入并按这种方式封装。不过要理解这种方式，还有一个重要的细节： 请勿通过调用 Sprintf 来构造 String 方法，因为它会无限递归你的的 String 方法!!!

type MyString string

func (m MyString) String() string {
        return fmt.Sprintf("MyString=%s", m) // 错误：会无限递归
}

要解决这个问题也很简单：将该实参转换为基本的字符串类型，它没有这个方法

type MyString string
func (m MyString) String() string {
        return fmt.Sprintf("MyString=%s", string(m)) // 可以：注意转换
}

• 另一种打印技术就是将打印例程的实参直接传入另一个这样的例程。Printf 的签名为其最后的实参使用了 …interface{} 类型，这样格式的后面就能出现任意数量，任意类型的形参了

func Printf(format string, v ...interface{}) (n int, err error)

在 Printf 函数中，v 看起来更像是 []interface{} 类型的变量，但如果将它传递到另一个变参函数中，它就像是常规实参列表了。 以下是之前用过的 log.Println 的实现。它直接将其实参传递给 fmt.Sprintln 进行实际的格式化

// Println 通过 fmt.Println 的方式将日志打印到标准记录器。
func Println(v ...interface{}) {
        std.Output(2, fmt.Sprintln(v...))  // Output 接受形参 (int, string) , 将 ... 写在 v 之后来告诉编译器将 v 视作一个实参列表
}

该 Sprintln 嵌套调用中，我们 将 … 写在 v 之后来告诉编译器将 v 视作一个实参列表 ，否则它会将 v 当做单一的切片实参来传递

顺便一提，… 形参可指定具体的类型，例如从整数列表中选出最小值的函数 min，其形参可为 …int 类型

func Min(a ...int) int {
        min := int(^uint(0) >> 1)  // 最大的 int
        for _, i := range a {
                if i < min {
                        min = i
                }
        }
        return min
}

现在要对内建函数 append 的设计进行补充说明。append 函数的签名不同于前面我们自定义的 Append 函数。大致来说，它就像这样：

func append(slice []T, 元素 ...T) []T

其中的 T 为 任意给定类型的占位符 实际上，无法在Go中编写一个类型 T 由调用者决定的函数。这也就是为何 append 为内建函数的原因：它需要编译器的支持

append 会在 切片末尾追加元素并返回结果 必须返回结果， 原因与手写的 Append 一样，即底层数组可能会被改变。以下简单的例子

x := []int{1,2,3}
x = append(x, 4, 5, 6)
fmt.Println(x)

[1 2 3 4 5 6]

append 有点像 Printf 那样 可接受任意数量的实参

但如果要像 Append 那样将一个切片追加到另一个切片中呢？ 很简单：在调用的地方使用 …，就像在上面调用 Output 那样。以下代码片段的输出与上一个相同

x := []int{1,2,3}
y := []int{4,5,6}
x = append(x, y...) // 而不是append(x, y) 
fmt.Println(x)

如果没有 …，它就会由于 类型错误而无法编译 因为 y 不是 int 类型的

Go中的常量就是不变量：

• 在 编译时创建，即便它们可能是函数中定义的局部变量
• 只能是 数字、字符（符文）、字符串或布尔值
• 由于编译时的限制， 定义它们的表达式必须也是可被编译器求值的常量表达式
  • 1<<3 就是一个常量表达式，而 math.Sin(math.Pi/4) 则不是，因为对 math.Sin 的函数调用 在运行时才会发生

在Go中，枚举常量使用枚举器 iota 创建。由于 iota 可为表达式的一部分，而表达式可以被隐式地重复，这样也就更容易构建复杂的值的集合了

type ByteSize float64

const (
        // 通过赋予空白标识符来忽略第一个值
        _           = iota // ignore first value by assigning to blank identifier
        KB ByteSize = 1 << (10 * iota)
        MB
        GB
        TB
        PB
        EB
        ZB
        YB
)

由于可将 String 之类的方法附加在用户定义的类型上， 因此它就为打印时自动格式化任意值提供了可能性，即便是作为一个通用类型的一部分。 尽管常常会看到这种技术应用于结构体，但它对于像 ByteSize 之类的浮点数标量等类型也是有用的

func (b ByteSize) String() string {
        switch {
        case b >= YB:
                return fmt.Sprintf("%.2fYB", b/YB)
        case b >= ZB:
                return fmt.Sprintf("%.2fZB", b/ZB)
        case b >= EB:
                return fmt.Sprintf("%.2fEB", b/EB)
        case b >= PB:
                return fmt.Sprintf("%.2fPB", b/PB)
        case b >= TB:
                return fmt.Sprintf("%.2fTB", b/TB)
        case b >= GB:
                return fmt.Sprintf("%.2fGB", b/GB)
        case b >= MB:
                return fmt.Sprintf("%.2fMB", b/MB)
        case b >= KB:
                return fmt.Sprintf("%.2fKB", b/KB)
        }
        return fmt.Sprintf("%.2fB", b)
}

表达式 YB 会打印出 1.00YB，而 ByteSize(1e13) 则会打印出 9.09

在这里用 Sprintf 实现 ByteSize 的 String 方法很安全（不会无限递归），这倒不是因为类型转换，而是它以 %f 调用了 Sprintf，它并不是一种字符串格式：Sprintf 只会在它需要字符串时才调用 String 方法，而 %f 需要一个浮点数值

变量的初始化与常量类似，但其 初始值也可以是在运行时才被计算的一般表达式

var (
        home   = os.Getenv("HOME")
        user   = os.Getenv("USER")
        gopath = os.Getenv("GOPATH")
)

每个源文件都可以通过定义自己的无参数 init 函数来设置一些必要的状态。 （ 每个文件都可以拥有多个 init 函数 ）而它的结束就意味着初始化结束： 只有该包中的所有变量声明都通过它们的初始化器求值后 init 才会被调用， 而那些 init 只有在所有已导入的包都被初始化后才会被求值

除了那些不能被表示成声明的初始化外，init 函数还常被用在 程序真正开始执行前，检验或校正程序的状态

func init() {
        if user == "" {
                log.Fatal("$USER not set")
        }
        if home == "" {
                home = "/home/" + user
        }
        if gopath == "" {
                gopath = home + "/go"
        }
        // gopath 可通过命令行中的 --gopath 标记覆盖掉。
        flag.StringVar(&gopath, "gopath", gopath, "override default GOPATH")
}

正如 ByteSize 那样，可以为任何已命名的类型（除了指针或接口）定义方法； 接收者可不必为结构体

在之前讨论切片时，编写了一个 Append 函数。 也可将其定义为切片的方法。为此，首先要声明一个已命名的类型来绑定该方法， 然后使该方法的接收者成为该类型的值

type ByteSlice []byte

func (slice ByteSlice) Append(data []byte) []byte {
        // 主体和前面相同。
}

仍然需要该方法返回更新后的切片 为了消除这种不便，可通过重新定义该方法， 将一个指向 ByteSlice 的指针作为该方法的接收者， 这样该方法就能重写调用者提供的切片了

func (p *ByteSlice) Append(data []byte) {
        slice := *p
        // 主体和前面相同，但没有 return。
        *p = slice
}

其实可以做得更好。若将函数修改为与标准 Write 类似的方法，就像这样

func (p *ByteSlice) Write(data []byte) (n int, err error) {
        slice := *p
        // 依旧和前面相同。
        *p = slice
        return len(data), nil
}

那么类型 *ByteSlice 就满足了标准的 io.Writer 接口，这将非常实用。 例如可以通过打印将内容写入

var b ByteSlice
fmt.Fprintf(&b, "This hour has %d days\n", 7)

将 ByteSlice 的地址传入，因为只有 *ByteSlice 才满足 io.Writer

以指针或值为接收者的区别在于 值方法可通过指针和值调用， 而指针方法只能通过指针来调用

因为指针方法可以修改接收者；通过值调用它们会导致方法接收到该值的副本， 因此任何修改都将被丢弃，因此该语言不允许这种错误。不过有个方便的例外 若该值是可寻址的， 那么该语言就会自动插入取址操作符来对付一般的通过值调用的指针方法 在例子中，变量 b 是可寻址的，因此只需通过 b.Write 来调用它的 Write 方法，编译器会将它重写为 (&b).Write

Go中的接口为指定对象的行为提供了一种方法：如果某样东西可以完成 这个 那么它就可以用在 这里 已经见过许多简单的示例了：通过实现 String 方法，可以自定义打印函数，而通过 Write 方法，Fprintf 则能对任何对象产生输出。在Go代码中， 仅包含一两种方法的接口很常见，且其名称通常来自于实现它的方法， 如 io.Writer 就是实现了 Write 的一类对象

每种类型都能实现多个接口。例如一个实现了 sort.Interface 接口的集合就可通过 sort 包中的例程进行排序。该接口包括 Len()、Less(i, j int) bool 以及 Swap(i, j int)，另外，该集合仍然可以有一个自定义的格式化器。 以下特意构建的例子 Sequence 就同时满足这两种情况

type Sequence []int

// Methods required by sort.Interface.
// sort.Interface 所需的方法。
func (s Sequence) Len() int {
        return len(s)
}
func (s Sequence) Less(i, j int) bool {
        return s[i] < s[j]
}
func (s Sequence) Swap(i, j int) {
        s[i], s[j] = s[j], s[i]
}

// Method for printing - sorts the elements before printing.
// 用于打印的方法 - 在打印前对元素进行排序。
func (s Sequence) String() string {
        sort.Sort(s)
        str := "["
        for i, elem := range s {
                if i > 0 {
                        str += " "
                }
                str += fmt.Sprint(elem)
        }
        return str + "]"
}

Sequence 的 String 方法重新实现了 Sprint 为切片实现的功能。若在调用 Sprint 之前将 Sequence 转换为纯粹的 []int，就能共享已实现的功能

func (s Sequence) String() string {
        sort.Sort(s)
        return fmt.Sprint([]int(s)) //将 Sequence 转换为纯粹的 []int
}

该方法是通过类型转换技术，在 String 方法中安全调用 Sprintf 的另个一例子。若忽略类型名的话，这两种类型（Sequence和 []int）其实是相同的，因此在二者之间进行转换是合法的。 转换过程并不会创建新值，它只是值暂让现有的时看起来有个新类型而已 （ 还有些合法转换则会创建新值，如从整数转换为浮点数等 ）

在Go程序中，为访问不同的方法集而进行类型转换的情况非常常见。 例如，可使用现有的 sort.IntSlice 类型来简化整个示例：

type Sequence []int

// // 用于打印的方法 - 在打印前对元素进行排序。
func (s Sequence) String() string {
        sort.IntSlice(s).Sort()
        return fmt.Sprint([]int(s))
}

现在，不必让 Sequence 实现多个接口（排序和打印）， 可通过将数据条目转换为多种类型（Sequence、sort.IntSlice 和 []int）来使用相应的功能，每次转换都完成一部分工作 这在实践中虽然有些不同寻常，但往往却很有效

若某种现有的类型仅实现了一个接口，且除此之外并无可导出的方法，则该类型本身就无需导出。 仅导出该接口能更专注于其行为而非实现，其它属性不同的实现则能镜像该原始类型的行为 这也能够避免为每个通用接口的实例重复编写文档。

在这种情况下 构造函数应当返回一个接口值而非实现的类型 例如在 hash 库中，crc32.NewIEEE 和 adler32.New 都返回接口类型 hash.Hash32。要在Go程序中用Adler-32算法替代CRC-32， 只需修改构造函数调用即可，其余代码则不受算法改变的影响

同样的方式能将 crypto 包中多种联系在一起的流密码算法与块密码算法分开。 crypto/cipher 包中的 Block 接口指定了块密码算法的行为， 它为单独的数据块提供加密。接着，和 bufio 包类似，任何实现了该接口的密码包都能被用于构造以 Stream 为接口表示的流密码，而无需知道块加密的细节

crypto/cipher 接口看其来就像这样：

type Block interface {
        BlockSize() int
        Encrypt(src, dst []byte)
        Decrypt(src, dst []byte)
}

type Stream interface {
        XORKeyStream(dst, src []byte)
}

这是计数器模式CTR流的定义，它将块加密改为流加密，注意 块加密的细节已被抽象化了

// NewCTR 返回一个 Stream，其加密/解密使用计数器模式中给定的 Block 进行
// iv 的长度必须与 Block 的块大小相同
func NewCTR(block Block, iv []byte) Stream

NewCTR 的应用并不仅限于特定的加密算法和数据源，它适用于任何对 Block 接口和 Stream 的实现。因为它们返回接口值， 所以用其它加密模式来代替CTR只需做局部的更改。构造函数的调用过程必须被修改， 但由于其周围的代码只能将它看做 Stream，因此它们不会注意到其中的区别

由于几乎任何类型都能添加方法，因此几乎任何类型都能满足一个接口 一个很直观的例子就是 http 包中定义的 Handler 接口。任何实现了 Handler 的对象都能够处理HTTP请求

type Handler interface {
        ServeHTTP(ResponseWriter, *Request)
}

ResponseWriter 接口提供了对方法的访问，这些方法需要响应客户端的请求:

• 由于这些方法包含了标准的 Write 方法，因此 http.ResponseWriter 可用于任何 io.Writer 适用的场景
• Request 结构体包含已解析的客户端请求

为简单起见，假设所有的HTTP请求都是GET方法，而忽略POST方法， 这种简化不会影响处理程序的建立方式。这里有个短小却完整的处理程序实现， 它用于记录某个页面被访问的次数

// 简单的计数器服务。
type Counter struct {
        n int
}

func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
        ctr.n++
        fmt.Fprintf(w, "counter = %d\n", ctr.n) // 注意 Fprintf 如何能输出到 http.ResponseWriter
}

作为参考，这里演示了如何将这样一个服务器添加到URL树的一个节点上

import "net/http"
...
ctr := new(Counter)
http.Handle("/counter", ctr)

但为什么 Counter 要是结构体呢？一个整数就够了。 但是接收者必须为指针，增量操作对于调用者才可见

// 简单的计数器服务。
type Counter int

func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
        *ctr++
        fmt.Fprintf(w, "counter = %d\n", *ctr)
}

当页面被访问时，怎样通知你的程序去更新一些内部状态呢？ 为Web页面绑定个信道吧

// 每次浏览该信道都会发送一个提醒。
// （可能需要带缓冲的信道。）
type Chan chan *http.Request

func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
        ch <- req
        fmt.Fprint(w, "notification sent")
}

最后，假设我们需要输出调用服务器二进制程序时使用的实参 /args。 很简单，写个打印实参的函数就行了

func ArgServer() {
        fmt.Println(os.Args)
}

如何将它转换为HTTP服务器呢？ 可以将 ArgServer 实现为某种可忽略值的方法，不过还有种更简单的方法。 既然可以为除指针和接口以外的任何类型定义方法，同样也能为一个函数写一个方法 http 包包含以下代码：

// HandlerFunc 类型是一个适配器，它允许将普通函数用做HTTP处理程序。
// 若 f 是个具有适当签名的函数，HandlerFunc(f) 就是个调用 f 的处理程序对象。
type HandlerFunc func(ResponseWriter, *Request) //这是一个以前C语言的函数指针！！！

// ServeHTTP calls f(c, req).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
        f(w, req)
}

HandlerFunc 是个具有 ServeHTTP 方法的类型， 因此该类型的值就能处理HTTP请求。来看看该方法的实现： 接收者是一个函数 f，而该方法调用 f。这看起来很奇怪，但不必大惊小怪， 区别在于接收者变成了一个信道，而方法通过该信道发送消息

为了将 ArgServer 实现成HTTP服务器，首先得让它拥有合适的签名

// 实参服务器。
func ArgServer(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintln(w, os.Args)
}

ArgServer 和 HandlerFunc 现在拥有了相同的签名， 因此我们可将其转换为这种类型以访问它的方法，就像我们将 Sequence 转换为 IntSlice 以访问 IntSlice.Sort 那样。 建立代码非常简单：

http.Handle("/args", http.HandlerFunc(ArgServer)) //注意，这里是类型转换，而不是函数调用！！！

1. 当有人访问 /args 页面时，安装到该页面的处理程序就有了值 ArgServer 和类型 HandlerFunc
2. HTTP服务器会以 ArgServer 为接收者，调用该类型的 ServeHTTP 方法
3. 会反过来调用 ArgServer（通过 f(c, req)）
4. 接着实参就会被显示出来

在这里，通过一个结构体，一个整数，一个信道和一个函数，建立了一个HTTP服务器， 这一切都是因为接口只是方法的集和，而几乎任何类型都能定义方法

for range 循环中对空表标识符的用法是一种具体情况，更一般的情况即为 多重赋值

若某次赋值需要匹配多个左值，但其中某个变量不会被程序使用， 那么用空白标识符来代替该变量可避免创建无用的变量，并能清楚地表明该值将被丢弃 例如，当调用某个函数时，它会返回一个值和一个错误，但只有错误很重要，那么可使用空白标识符来丢弃无关的值

if _, err := os.Stat(path); os.IsNotExist(err) {
        fmt.Printf("%s does not exist\n", path)
}

偶尔会看见为忽略错误而丢弃错误值的代码，这是种糟糕的实践 请务必检查错误返回， 它们会提供错误的理由

// 烂代码！若路径不存在，它就会崩溃
fi, _ := os.Stat(path)
if fi.IsDir() {
        fmt.Printf("%s is a directory\n", path)
}

若导入某个包或声明某个变量而不使用它就会产生错误。未使用的包会让程序膨胀并拖慢编译速度， 而已初始化但未使用的变量不仅会浪费计算能力，还有可能暗藏着更大的Bug。然而 在程序开发过程中，经常会产生未使用的导入和变量。虽然以后会用到它们， 但为了完成编译又不得不删除它们才行 这很让人烦恼。空白标识符就能提供一个工作空间

这个写了一半的程序有两个未使用的导入（fmt 和 io）以及一个未使用的变量（fd），因此它不能编译， 但若到目前为止代码还是正确的，我们还是很乐意看到它们的

package main

import (
        "fmt"
        "io"
        "log"
        "os"
)

func main() {
        fd, err := os.Open("test.go")
        if err != nil {
                log.Fatal(err)
        }
        // TODO: use fd.
}

要让编译器停止关于未使用导入的抱怨，需要空白标识符来引用已导入包中的符号。 同样，将未使用的变量 fd 赋予空白标识符也能关闭未使用变量错误。 该程序的以下版本可以编译

package main

import (
    "fmt"
    "io"
    "log"
    "os"
)

var _ = fmt.Printf // For debugging; delete when done. // 用于调试，结束时删除。
var _ io.Reader    // For debugging; delete when done. // 用于调试，结束时删除。

func main() {
    fd, err := os.Open("test.go")
    if err != nil {
        log.Fatal(err)
    }
    // TODO: use fd.
    _ = fd
}

按照惯例，应在导入并加以注释后，再使全局声明导入错误静默，这样可以让它们更易找到， 并作为以后清理它的提醒

像前例中 fmt 或 io 这种未使用的导入总应在最后被使用或移除： 空白赋值会将代码标识为工作正在进行中。但有时 导入某个包只是为了其副作用，而没有任何明确的使用 。例如，在 net/http/pprof 包的 init 函数中记录了HTTP处理程序的调试信息。它有个可导出的API， 但大部分客户端只需要该处理程序的记录和通过Web叶访问数据。只为了其副作用来导入该包， 只需将包重命名为空白标识符：

import _ "net/http/pprof"

这种导入格式能明确表示该包是为其副作用而导入的，因为没有其它使用该包的可能： 在此文件中，它没有名字。（若它有名字而没有使用，编译器就会拒绝该程序! ）

就像在前面接口中讨论的那样， 一个类型无需显式地声明它实现了某个接口。取而代之 该类型只要实现了某个接口的方法， 其实就实现了该接口 在实践中，大部分接口转换都是静态的，因此会在编译时检测。 例如，将一个 *os.File 传入一个预期的 io.Reader 函数将不会被编译， 除非 *os.File 实现了 io.Reader 接口

尽管有些接口检查会在运行时进行。encoding/json 包中就有个实例它定义了一个 Marshaler 接口。当JSON编码器接收到一个实现了该接口的值，那么该编码器就会调用该值的编组方法， 将其转换为JSON，而非进行标准的类型转换。 编码器在运行时通过类型断言检查其属性，就像这样：

m, ok := val.(json.Marshaler)

若只需要判断某个类型是否是实现了某个接口，而不需要实际使用接口本身 （可能是错误检查部分），就使用空白标识符来忽略类型断言的值：

if _, ok := val.(json.Marshaler); ok {
        fmt.Printf("value %v of type %T implements json.Marshaler\n", val, val)
}

当需要确保某个包中实现的类型一定满足该接口时，就会遇到这种情况。 若某个类型（例如 json.RawMessage） 需要一种定制的JSON表现时，它应当实现 json.Marshaler， 不过现在没有静态转换可以让编译器去自动验证它。 若该类型通过忽略转换失败来满足该接口， 那么JSON编码器仍可工作，但它却不会使用定制的实现 为确保其实现正确， 可在该包中用空白标识符声明

var _ json.Marshaler = (*RawMessage)(nil)

在此声明中，调用了一个 *RawMessage 转换并将其赋予了 Marshaler，以此来要求 *RawMessage 实现 Marshaler，这时其属性就会在编译时被检测。 若 json.Marshaler 接口被更改，此包将无法通过编译， 而则会注意到它需要更新

在这种结构中出现空白标识符， 即表示该声明的存在只是为了类型检查 。 不过 请不要为满足接口就将它用于任何类型 。作为约定， 仅当代码中不存在静态类型转换时才能这种声明 毕竟这是种罕见的情况

在并发编程中，为实现对共享变量的正确访问需要精确的控制，这在多数环境下都很困难。 Go语言另辟蹊径，它将共享的值通过信道传递，实际上，多个独立执行的线程从不会主动共享。 在任意给定的时间点，只有一个Go程能够访问该值。数据竞争从设计上就被杜绝了。 为了提倡这种思考方式，将它简化为一句口号：

   不要通过共享内存来通信，而应通过通信来共享内存

这种方法意义深远。例如，引用计数通过为整数变量添加互斥锁来很好地实现。 但作为一种高级方法，通过信道来控制访问能够让你写出更简洁，正确的程序。

可以从典型的单线程运行在单CPU之上的情形来审视这种模型。它无需提供同步原语。 现在考虑另一种情况，它也无需同步。现在让它们俩进行通信。若将通信过程看做同步， 那就完全不需要其它同步了。例如，Unix管道就与这种模型完美契合。 尽管Go的并发处理方式来源于Hoare的通信顺序处理（CSP）， 它依然可以看做是类型安全的Unix管道的实现

Go程是因为现有的术语—线程、协程、进程等等—无法准确传达它的含义。 Go程具有简单的模型：它是 与其它Go程并发运行在同一地址空间的函数 。它是轻量级的， 所有小号几乎就只有栈空间的分配。而且栈最开始是非常小的，所以它们很廉价， 仅在需要时才会随着堆空间的分配（和释放）而变化

Go程在多线程操作系统上 可实现多路复用，因此若一个线程阻塞，比如说等待I/O， 那么其它的线程就会运行 Go程的设计隐藏了线程创建和管理的诸多复杂性。

在函数或方法前添加 go 关键字能够在新的Go程中调用它。当调用完成后， 该Go程也会安静地退出。（ 效果有点像Unix Shell中的 & 符号，它能让命令在后台运行 ）

go list.Sort()  // 并发运行 list.Sort，无需等它结束

匿名函数在Go程调用中非常有用

func Announce(message string, delay time.Duration) {
        go func() {
                time.Sleep(delay)
                fmt.Println(message)
        }()  // 注意括号 - 必须调用该函数
}

在Go中，匿名函数都是闭包： 其实现在保证了函数内引用变量的生命周期与函数的活动时间相同

这些函数没什么实用性，因为它们没有实现完成时的信号处理。因此，需要 信道

信道与映射一样，也需要通过 make 来分配内存。其结果值充当了 对底层数据结构的引用 若提供了一个可选的整数形参，它就会 为该信道设置缓冲区大小，默认值是零，表示不带缓冲的或同步的信道

ci := make(chan int)            // 整数类型的无缓冲信道
cj := make(chan int, 0)         // 整数类型的无缓冲信道
cs := make(chan *os.File, 100)  // 指向文件指针的带缓冲信道

无缓冲信道在通信时会同步交换数据，它能确保（两个Go程的）计算处于确定状态

信道有很多惯用法，从这里开始了解。在上一节中，在后台启动了排序操作。 信道使得启动的Go程等待排序完成

c := make(chan int)  // 分配一个信道

// 在Go程中启动排序。当它完成后，在信道上发送信号
go func() {
        list.Sort()
        c <- 1  // 发送信号，什么值无所谓。
}()

doSomethingForAWhile()
<-c   // 等待排序结束，丢弃发来的值

接收者在收到数据前会一直阻塞：

• 若信道是不带缓冲的，那么在接收者收到值前，发送者会一直阻塞
• 若信道是带缓冲的，则发送者仅在值被复制到缓冲区前阻塞
  • 若缓冲区已满，发送者会一直等待直到某个接收者取出一个值为止

带缓冲的信道可被用作信号量，例如限制吞吐量。在下例中，进入的请求会被传递给 handle，它从信道中接收值，处理请求后将值发回该信道中，以便让该 信号量 准备迎接下一次请求。信道缓冲区的容量决定了 同时调用 process 的数量上限，因此在初始化时首先要填充至它的容量上限

var sem = make(chan int, MaxOutstanding)

func handle(r *Request) {
        sem <- 1 // 像信道发送值1, 如果信道满了，则等待缓存区清空
        process(r)  // 可能需要很长时间
        <-sem    // 完成后清空一个缓存区信号；使下一个请求可以运行
}

func Serve(queue chan *Request) {
        for {
                req := <-queue //queue中获取的消息被赋值给req
                go handle(req)  // 无需等待 handle 结束。
        }
}

由于数据同步发生在信道的接收端 （也就是说发送发生在>接受之前），因此 信号必须在信道的接收端获取，而非发送端 。然而，它却有个设计问题：尽管只有 MaxOutstanding 个Go程能同时运行，但 Serve 还是 为每个进入的请求都创建了新的Go程 其结果就是，若请求来得很快， 该程序就会无限地消耗资源。为了弥补这种不足，必须通过修改 Serve 来 限制创建Go程 这是个明显的解决方案，但要当心修复后出现的Bug

func Serve(queue chan *Request) {
        //不断从 channel 接收值，直到它被关闭
        //只有发送者才能关闭 channel，而不是接收者！
        //向一个已经关闭的 channel 发送数据会引起 panic！
        //通常不需要关闭 channel，除非是想停止循环！
        for req := range queue {
                sem <- 1
                go func() {
                        process(req) // 这儿有Bug，解释见下。
                        <-sem
                }()
        }
}

Bug出现在Go的 for 循环中 该循环变量在每次迭代时会被重用，因此 req 变量会在所有的Go程间共享 这不是我们想要的。需要确保 req 对于每个Go程来说都是唯一的。有一种方法能够做到，就是 将 req 的值作为实参传入到该Go程的闭包中 ：

func Serve(queue chan *Request) {
        for req := range queue {
                sem <- 1
                go func(r *Request) {
                        process(r)
                        <-sem
                }(req)
        }
}

比较前后两个版本，观察该闭包声明和运行中的差别。 另一种解决方案就是 以相同的名字创建新的变量 如例中所示：

func Serve(queue chan *Request) {
        for req := range queue {
                req := req // 为该Go程创建 req 的新实例
                sem <- 1
                go func() {
                        process(req)
                        <-sem
                }()
        }
}

它的写法看起来有点奇怪

req := req

但在Go中这样做是合法且惯用的。用相同的名字获得了该变量的一个新的版本， 以此来局部地刻意屏蔽循环变量，使它对每个Go程保持唯一

回到编写服务器的一般问题上来。另一种管理资源的好方法就是 启动固定数量的 handle Go程，一起从请求信道中读取数据。Go程的数量限制了同时调用 process 的数量 Serve 同样会接收一个通知退出的信道， 在启动所有Go程后，它将阻塞并暂停从信道中接收消息

func handle(queue chan *Request) {
        for r := range queue {
                process(r)
        }
}

func Serve(clientRequests chan *Request, quit chan bool) {
        // 启动处理程序
        for i := 0; i < MaxOutstanding; i++ {
                go handle(clientRequests)
        }
        <-quit  // 等待通知退出
}

如果计算过程能够被分为几块可独立执行的过程，它就可以在每块计算结束时向信道发送信号，从而实现并行处理

对一系列向量项进行极耗资源的操作， 而每个项的值计算是完全独立的

type Vector []float64

// 将此操应用至 v[i], v[i+1] ... 直到 v[n-1]
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
        for ; i < n; i++ {
                v[i] += u.Op(v[i])
        }
        c <- 1    // 发信号表示这一块计算完成。
}

在循环中启动了独立的处理块，每个CPU将执行一个处理。 它们有可能以乱序的形式完成并结束，但这没有关系，只需在所有Go程开始后接收，并统计信道中的完成信号即可

const NCPU = 4  // CPU核心数

func (v Vector) DoAll(u Vector) {
        c := make(chan int, NCPU)  // 缓冲区是可选的，但明显用上更好
        for i := 0; i < NCPU; i++ {
                go v.DoSome(i*len(v)/NCPU, (i+1)*len(v)/NCPU, u, c)
        }
        // 排空信道
        for i := 0; i < NCPU; i++ {
                <-c    // 等待任务完成
        }
        // 一切完成
}

目前Go运行时的实现默认 并不会并行执行代码，它只为用户层代码提供单一的处理核心 任意数量的Go程都可能在系统调用中被阻塞，而在任意时刻默认只有一个会执行用户层代码。 它应当变得更智能，而且它将来肯定会变得更智能。但现在 若你希望CPU并行执行， 就必须告诉运行时你希望同时有多少Go程能执行代码 有两种途径可意识形态：

1. 在运行你的工作时将 GOMAXPROCS 环境变量设为你要使用的核心数
2. 要么导入 runtime 包并调用 runtime.GOMAXPROCS(NCPU)。 runtime.NumCPU() 的值可能很有用，它会返回当前机器的逻辑CPU核心数。 当然，随着调度算法和运行时的改进，将来会不再需要这种方法。

注意不要混淆并发和并行的概念：

• 并发是用可独立执行的组件构造程序的方法
• 而并行则是为了效率在多CPU上平行地进行计算

尽管Go的并发特性能够让某些问题更易构造成并行计算， 但Go仍然是种并发而非并行的语言，且Go的模型并不适合所有的并行问题

并发编程的工具甚至能很容易地表达非并发的思想。这里有个提取自RPC包的例子。 客户端Go程从某些来源，可能是网络中循环接收数据。为避免分配和释放缓冲区， 它保存了一个空闲链表，使用一个带缓冲信道表示。若信道为空，就会分配新的缓冲区。 一旦消息缓冲区就绪，它将通过 serverChan 被发送到服务器

var freeList = make(chan *Buffer, 100)
var serverChan = make(chan *Buffer)

func client() {
        for {
                var b *Buffer
                // 若缓冲区可用就用它，不可用就分配个新的
                select {
                case b = <-freeList:
                        // 获取一个，不做别的
                default:
                        // 非空闲，因此分配一个新的
                        b = new(Buffer)
                }
                load(b)              // 从网络中读取下一条消息
                serverChan <- b   // 发送至服务器
        }
}

服务器从客户端循环接收每个消息，处理它们，并将缓冲区返回给空闲列表

func server() {
        for {
                b := <-serverChan    // 等待工作
                process(b)
                // 若缓冲区有空间就重用它
                select {
                case freeList <- b:
                        // 将缓冲区放大空闲列表中，不做别的
                default:
                        // 空闲列表已满，保持就好
                }
        }
}

客户端试图从 freeList 中获取缓冲区；若没有缓冲区可用，它就将分配一个新的。服务器将 b 放回空闲列表 freeList 中直到列表已满，此时缓冲区将被丢弃，并被垃圾回收器回收。（select 语句中的 default 子句在没有条件符合时执行，这也就意味着 selects 永远不会被阻塞。） 依靠带缓冲的信道和垃圾回收器的记录， 仅用短短几行代码就构建了一个可能导致缓冲区槽位泄露的空闲列表

向调用者报告错误的一般方式就是将 error 作为额外的值返回。 标准的 Read 方法就是个众所周知的实例，它返回一个字节计数和一个 error。但如果错误时不可恢复的呢？有时程序就是不能继续运行

为此，提供了内建的 panic 函数，它会产生一个运行时错误并终止程序。该函数接受一个任意类型的实参（一般为字符串），并在程序终止时打印。 它还能表明发生了意料之外的事情，比如从无限循环中退出了

// 用牛顿法计算立方根的一个玩具实现。
func CubeRoot(x float64) float64 {
        z := x/3   // 任意初始值
        for i := 0; i < 1e6; i++ {
                prevz := z
                z -= (z*z*z-x) / (3*z*z)
                if veryClose(z, prevz) {
                        return z
                }
        }
        // 一百万次迭代并未收敛，事情出错了。
        panic(fmt.Sprintf("CubeRoot(%g) did not converge", x))
}

• 这仅仅是个示例 实际的库函数应避免 panic 若问题可以被屏蔽或解决，最好就是让程序继续运行而不是终止整个程序
  • 一个 可能的反例就是初始化 ：若某个库真的不能让自己工作，且有足够理由产生Panic，那就由它去吧

var user = os.Getenv("USER")

func init() {
        if user == "" {
                panic("no value for $USER")
        }
}