（1）尽可能的使用`:=`去初始化声明一个变量（在函数内部）； （2）尽可能的使用字符代替字符串； （3）尽可能的使用切片代替数组； （4）尽可能的使用数组和切片代替映射（详见参考文献15）； （5）如果只想获取切片中某项值，不需要值的索引，尽可能的使用`for range`去遍历切片，这比必须查询切片中的每个元素要快一些； （6）当数组元素是稀疏的（例如有很多`0`值或者空值`nil`），使用映射会降低内存消耗； （7）初始化映射时指定其容量； （8）当定义一个方法时，使用指针类型作为方法的接受者； （9）在代码中使用常量或者标志提取常量的值； （10）尽可能在需要分配大量内存时使用缓存； （11）使用缓存模板（参考[章节15.7](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/15.7.md)）。

如何在程序出错时终止程序： ~~~ if err != nil { fmt.Printf(“Program stopping with error %v”, err) os.Exit(1) } ~~~ 或者： ~~~ if err != nil { panic(“ERROR occurred: “ + err.Error()) } ~~~

## 18.9.1 模板： 制作、解析并使模板生效： ~~~ var strTempl = template.Must(template.New("TName").Parse(strTemplateHTML)) ~~~ 在网页应用中使用HTML过滤器过滤HTML特殊字符： `{{html .}}` 或者通过一个字段 `FieldName {{ .FieldName |html }}` 使用缓存模板（参考[章节15.7](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/15.7.md)）

出于性能考虑的建议： 实践经验表明，如果你使用并行运算获得高于串行运算的效率：在协程内部已经完成的大部分工作，其开销比创建协程和协程间通信还高。 1 出于性能考虑建议使用带缓存的通道： 使用带缓存的通道可以很轻易成倍提高它的吞吐量，某些场景其性能可以提高至10倍甚至更多。通过调整通道的容量，甚至可以尝试着更进一步的优化其性能。 2 限制一个通道的数据数量并将它们封装成一个数组： 如果使用通道传递大量单独的数据，那么通道将变成性能瓶颈。然而，将数据块打包封装成数组，在接收端解压数据时，性能可以提高至10倍。 创建：`ch := make(chan type,buf)` （1）如何使用`for`或者`for-range`遍历一个通道： ~~~ for v := range ch { // do something with v } ~~~ （2）如何检测一个通道`ch`是否关闭： ~~~ //read channel until it closes or error-condition for { if input, open := <-ch; !open { break } fmt.Printf("%s", input) } ~~~ 或者使用（1）自动检测。 （3）如何通过一个通道让主程序等待直到协程完成： （信号量模式）： ~~~ ch := make(chan int) // Allocate a channel. // Start something in a goroutine; when it completes, signal on the channel. go func() { // doSomething ch <- 1 // Send a signal; value does not matter. }() doSomethingElseForAWhile() <-ch // Wait for goroutine to finish; discard sent value. ~~~ 如果希望程序一直阻塞，在匿名函数中省略 `ch <- 1`即可。 （4）通道的工厂模板：以下函数是一个通道工厂，启动一个匿名函数作为协程以生产通道： ~~~ func pump() chan int { ch := make(chan int) go func() { for i := 0; ; i++ { ch <- i } }() return ch } ~~~ （5）通道迭代器模板： （6）如何限制并发处理请求的数量：参考[章节14.11](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.11.md) （7）如何在多核CPU上实现并行计算：参考[章节14.13](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.13.md) （8）如何终止一个协程：`runtime.Goexit()` （9）简单的超时模板： ~~~ timeout := make(chan bool, 1) go func() { time.Sleep(1e9) // one second timeout <- true }() select { case <-ch: // a read from ch has occurred case <-timeout: // the read from ch has timed out } ~~~ （10）如何使用输入通道和输出通道代替锁： ~~~ func Worker(in, out chan *Task) { for { t := <-in process(t) out <- t } } ~~~ （11）如何在同步调用运行时间过长时将之丢弃：参考[章节14.5](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.5.md) 第二个变体 （12）如何在通道中使用计时器和定时器：参考[章节14.5](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.5.md) （13）典型的服务器后端模型：参考[章节14.4](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.4.md)

（1）如何打开一个文件并读取： ~~~ file, err := os.Open("input.dat") if err != nil { fmt.Printf("An error occurred on opening the inputfile\n" + "Does the file exist?\n" + "Have you got acces to it?\n") return } defer file.Close() iReader := bufio.NewReader(file) for { str, err := iReader.ReadString('\n') if err != nil { return // error or EOF } fmt.Printf("The input was: %s", str) } ~~~ （2）如何通过切片读写文件： ~~~ func cat(f *file.File) { const NBUF = 512 var buf [NBUF]byte for { switch nr, er := f.Read(buf[:]); true { case nr < 0: fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", f.String(), er.String()) os.Exit(1) case nr == 0: // EOF return case nr > 0: if nw, ew := file.Stdout.Write(buf[0:nr]); nw != nr { fmt.Fprintf(os.Stderr, "cat: error writing from %s: %s\n", f.String(), ew.String()) } } } } ~~~

如何使用内建函数`recover`终止`panic`过程（参考[章节13.3](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/13.3.md)）： ~~~ func protect(g func()) { defer func() { log.Println("done") // Println executes normally even if there is a panic if x := recover(); x != nil { log.Printf("run time panic: %v", x) } }() log.Println("start") g() } ~~~

（1）如何检测一个值`v`是否实现了接口`Stringer`： ~~~ if v, ok := v.(Stringer); ok { fmt.Printf("implements String(): %s\n", v.String()) } ~~~ （2）如何使用接口实现一个类型分类函数： ~~~ func classifier(items ...interface{}) { for i, x := range items { switch x.(type) { case bool: fmt.Printf("param #%d is a bool\n", i) case float64: fmt.Printf("param #%d is a float64\n", i) case int, int64: fmt.Printf("param #%d is an int\n", i) case nil: fmt.Printf("param #%d is nil\n", i) case string: fmt.Printf("param #%d is a string\n", i) default: fmt.Printf("param #%d’s type is unknown\n", i) } } } ~~~

创建： ~~~ type struct1 struct { field1 type1 field2 type2 … } ms := new(struct1) ~~~ 初始化： ~~~ ms := &struct1{10, 15.5, "Chris"} ~~~ 当结构体的命名以大写字母开头时，该结构体在包外可见。 通常情况下，为每个结构体定义一个构建函数，并推荐使用构建函数初始化结构体（参考[例10.2](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/examples/chapter_10/person.go)）： ~~~ ms := Newstruct1{10, 15.5, "Chris"} func Newstruct1(n int, f float32, name string) *struct1 { return &struct1{n, f, name} } ~~~

创建： `map1 := make(map[keytype]valuetype)` 初始化： `map1 := map[string]int{"one": 1, "two": 2}` （1）如何使用`for`或者`for-range`遍历一个映射： ~~~ for key, value := range map1 { … } ~~~ （2）如何在一个映射中检测键`key1`是否存在： `val1, isPresent = map1[key1]` 返回值：键`key1`对应的值或者`0`, `true`或者`false` （3）如何在映射中删除一个键： `delete(map1, key1)`

创建： `arr1 := new([len]type)` `slice1 := make([]type, len)` 初始化： `arr1 := [...]type{i1, i2, i3, i4, i5}` `arrKeyValue := [len]type{i1: val1, i2: val2}` `var slice1 []type = arr1[start:end]` （1）如何截断数组或者切片的最后一个元素： `line = line[:len(line)-1]` （2）如何使用`for`或者`for-range`遍历一个数组（或者切片）： ~~~ for i:=0; i < len(arr); i++ { … = arr[i] } for ix, value := range arr { … } ~~~ （3）如何在一个二维数组或者切片`arr2Dim`中查找一个指定值`V`： ~~~ found := false Found: for row := range arr2Dim { for column := range arr2Dim[row] { if arr2Dim[row][column] == V{ found = true break Found } } } ~~~

（1）如何修改字符串中的一个字符： ~~~ str:="hello" c:=[]byte(str) c[0]='c' s2:= string(c) // s2 == "cello" ~~~ （2）如何获取字符串的子串： ~~~ substr := str[n:m] ~~~ （3）如何使用`for`或者`for-range`遍历一个字符串： ~~~ // gives only the bytes: for i:=0; i < len(str); i++ { … = str[i] } // gives the Unicode characters: for ix, ch := range str { … } ~~~ （4）如何获取一个字符串的字节数：`len(str)` 如何获取一个字符串的字符数： 最快速：`utf8.RuneCountInString(str)` `len([]int(str))` （5）如何连接字符串： 最快速： `with a bytes.Buffer`（参考[章节7.2](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/07.2.md)） `Strings.Join()`（参考[章节4.7](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/04.7.md)） 使用`+=`： ~~~ str1 := "Hello " str2 := "World!" str1 += str2 //str1 == "Hello World!" ~~~ （6）如何解析命令行参数：使用`os`或者`flag`包 （参考[例12.4](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/examples/chapter_12/fileinput.go)）

在学习本书第二部分和第三部分时，我们经常在一个表达式返回2个参数时使用这种模式：`，ok`，第一个参数是一个值或者`nil`，第二个参数是`true`/`false`或者一个错误`error`。在一个需要赋值的`if`条件语句中，使用这种模式去检测第二个参数值会让代码显得优雅简洁。这种模式在go语言编码规范中非常重要。下面总结了所有使用这种模式的例子： （1）在函数返回时检测错误（参考[第5.2小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/05.2.md)）: ~~~ value, err := pack1.Func1(param1) if err != nil { fmt.Printf(“Error %s in pack1.Func1 with parameter %v”, err.Error(), param1) return err } // 函数Func1没有错误: Process(value) e.g.: os.Open(file) strconv.Atoi(str) ~~~ 这段代码中的函数将错误返回给它的调用者，当函数执行成功时，返回的错误是`nil`，所以使用这种写法： ~~~ func SomeFunc() error { … if value, err := pack1.Func1(param1); err != nil { … return err } … return nil } ~~~ 这种模式也常用于通过`defer`使程序从`panic`中恢复执行（参考[第17.2（4）小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/17.2.md)）。 要实现简洁的错误检测代码，更好的方式是使用闭包，参考[第16.10.2小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/16.10.md) （2）检测映射中是否存在一个键值（参考[第8.2小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/08.2.md)）：`key1`在映射`map1`中是否有值？ ~~~ if value, isPresent = map1[key1]; isPresent { Process(value) } // key1不存在 … ~~~ （3）检测一个接口类型变量`varI`是否包含了类型`T`：类型断言（参考[第11.3小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/11.3.md)）： ~~~ if value, ok := varI.(T); ok { Process(value) } // 接口类型varI没有包含类型T ~~~ （4）检测一个通道`ch`是否关闭（参考[第14.3小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.3.md)）： ~~~ for input := range ch { Process(input) } ~~~ 或者: ~~~ for { if input, open := <-ch; !open { break // 通道是关闭的 } Process(input) } ~~~

依附于[第13章](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/13.0.md)模式的描述和[第17.1小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/17.1.md)与[第17.2.4小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/17.2.md)的总结。 ## [](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/16.10.md#16101-不要使用布尔值)16.10.1 不要使用布尔值： 像下面代码一样，创建一个布尔型变量用于测试错误条件是多余的： ~~~ var good bool // 测试一个错误，`good`被赋为`true`或者`false` if !good { return errors.New("things aren’t good") } ~~~ 立即检测一个错误： ~~~ ... err1 := api.Func1() if err1 != nil { … } ~~~ ## [](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/16.10.md#16102-避免错误检测使代码变得混乱)16.10.2 避免错误检测使代码变得混乱： 避免写出这样的代码： ~~~ ... err1 := api.Func1() if err1 != nil { fmt.Println("err: " + err.Error()) return } err2 := api.Func2() if err2 != nil { ... return } ~~~ 首先，包括在一个初始化的`if`语句中对函数的调用。但即使代码中到处都是以`if`语句的形式通知错误（通过打印错误信息）。通过这种方式，很难分辨什么是正常的程序逻辑，什么是错误检测或错误通知。还需注意的是，大部分代码都是致力于错误的检测。通常解决此问题的好办法是尽可能以闭包的形式封装你的错误检测，例如下面的代码： ~~~ func httpRequestHandler(w http.ResponseWriter, req *http.Request) { err := func () error { if req.Method != "GET" { return errors.New("expected GET") } if input := parseInput(req); input != "command" { return errors.New("malformed command") } // 可以在此进行其他的错误检测 } () if err != nil { w.WriteHeader(400) io.WriteString(w, err) return } doSomething() ... ~~~ 这种方法可以很容易分辨出错误检测、错误通知和正常的程序逻辑（更详细的方式参考[第13.5小节](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/13.5.md)）。 在开始阅读[第17章](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/17.0.md)前，先回答下列2个问题： * 问题 16.1：总结你能记住的所有关于`,ok`模式的情况。 * 问题 16.2：总结你能记住的所有关于`defer`模式的情况。

请看下面代码： ~~~ package main import ( "fmt" "time" ) var values = [5]int{10, 11, 12, 13, 14} func main() { // 版本A: for ix := range values { // ix是索引值 func() { fmt.Print(ix, " ") }() // 调用闭包打印每个索引值 } fmt.Println() // 版本B: 和A版本类似，但是通过调用闭包作为一个协程 for ix := range values { go func() { fmt.Print(ix, " ") }() } fmt.Println() time.Sleep(5e9) // 版本C: 正确的处理方式 for ix := range values { go func(ix interface{}) { fmt.Print(ix, " ") }(ix) } fmt.Println() time.Sleep(5e9) // 版本D: 输出值: for ix := range values { val := values[ix] go func() { fmt.Print(val, " ") }() } time.Sleep(1e9) } ~~~ /* 输出： ~~~ 0 1 2 3 4 4 4 4 4 4 1 0 3 4 2 10 11 12 13 14 ~~~ */ 版本A调用闭包5次打印每个索引值，版本B也做相同的事，但是通过协程调用每个闭包。按理说这将执行得更快，因为闭包是并发执行的。如果我们阻塞足够多的时间，让所有协程执行完毕，版本B的输出是：`4 4 4 4 4`。为什么会这样？在版本B的循环中，`ix`变量 实际是一个单变量，表示每个数组元素的索引值。因为这些闭包都只绑定到一个变量，这是一个比较好的方式，当你运行这段代码时，你将看见每次循环都打印最后一个索引值`4`，而不是每个元素的索引值。因为协程可能在循环结束后还没有开始执行，而此时`ix`值是`4`。 版本C的循环写法才是正确的：调用每个闭包是将`ix`作为参数传递给闭包。`ix`在每次循环时都被重新赋值，并将每个协程的`ix`放置在栈中，所以当协程最终被执行时，每个索引值对协程都是可用的。注意这里的输出可能是`0 2 1 3 4`或者`0 3 1 2 4`或者其他类似的序列，这主要取决于每个协程何时开始被执行。 在版本D中，我们输出这个数组的值，为什么版本B不能而版本D可以呢？ 因为版本D中的变量声明是在循环体内部，所以在每次循环时，这些变量相互之间是不共享的，所以这些变量可以单独的被每个闭包使用。

由于教学需要和对协程的工作原理有一个直观的了解，在[第14章](https://github.com/Unknwon/the-way-to-go_ZH_CN/blob/master/eBook/14.0.md)使用了一些简单的算法，举例说明了协程和通道的使用，例如生产者或者迭代器。在实际应用中，你不需要并发执行，或者你不需要关注协程和通道的开销，在大多数情况下，通过栈传递参数会更有效率。 但是，如果你使用`break`、`return`或者`panic`去跳出一个循环，很有可能会导致内存溢出，因为协程正处理某些事情而被阻塞。在实际代码中，通常仅需写一个简单的过程式循环即可。当且仅当代码中并发执行非常重要，才使用协程和通道。

将一个值类型作为一个参数传递给函数或者作为一个方法的接收者，似乎是对内存的滥用，因为值类型一直是传递拷贝。但是另一方面，值类型的内存是在栈上分配，内存分配快速且开销不大。如果你传递一个指针，而不是一个值类型，go编译器大多数情况下会认为需要创建一个对象，并将对象移动到堆上，所以会导致额外的内存分配：因此当使用指针代替值类型作为参数传递时，我们没有任何收获。

查看如下程序：`nexter`是一个接口类型，并且定义了一个`next()`方法读取下一字节。函数`nextFew`将`nexter`接口作为参数并读取接下来的`num`个字节，并返回一个切片：这是正确做法。但是`nextFew2`使用一个指向`nexter`接口类型的指针作为参数传递给函数：当使用`next()`函数时，系统会给出一个编译错误：n.next undefined (type *nexter has no field or method next) （译者注：n.next未定义（*nexter类型没有next成员或next方法）） 例 16.1 pointer_interface.go (不能通过编译): ~~~ package main import ( “fmt” ) type nexter interface { next() byte } func nextFew1(n nexter, num int) []byte { var b []byte for i:=0; i < num; i++ { b[i] = n.next() } return b } func nextFew2(n *nexter, num int) []byte { var b []byte for i:=0; i < num; i++ { b[i] = n.next() // 编译错误:n.next未定义（*nexter类型没有next成员或next方法） } return b } func main() { fmt.Println(“Hello World!”) } ~~~ 永远不要使用一个指针指向一个接口类型，因为它已经是一个指针。