GO编程陷阱和常见错误

Binge 收录于 Go

2023-05-29 约 21388 字预计阅读 43 分钟本文总阅读量次

Go 是一种简单而有趣的语言，但是，与任何其他语言一样，它也有一些陷阱……其中许多陷阱并不完全是 Go 的错。其中一些错误是自然陷阱。其他是由于错误的假设和缺少细节。

概述

初学者:

不能将左大括号放在单独的行上
未使用的变量
未使用的进口
短变量声明只能在函数内部使用
使用短变量声明重新声明变量
不能使用短变量声明来设置字段值
意外变量阴影
不能使用“nil”来初始化没有显式类型的变量
使用“nil”切片和映射
地图容量
字符串不能为“nil”
数组函数参数
切片和数组“范围”子句中的意外值
切片和数组是一维的
访问不存在的映射键
字符串是不可变的
字符串和字节片之间的转换
字符串和索引运算符
字符串并不总是 UTF8 文本
字符串长度
多行切片/数组/映射文字中缺少逗号
log.Fatal 和 log.Panic 不仅仅是日志
内置数据结构操作不同步
“范围”子句中字符串的迭代值
使用“for range”子句遍历地图
“switch”语句中的失败行为
增量和减量
按位非运算符
运算符优先级差异
未导出的结构字段未编码
带有活动 Goroutines 的应用程序退出
目标接收器准备好后立即返回到无缓冲通道
发送到关闭的频道会导致恐慌
使用“零”通道
带有值接收器的方法不能更改原始值

中级初学者：

关闭 HTTP 响应正文
关闭 HTTP 连接
JSON 编码器添加换行符
JSON 包转义键和字符串值中的特殊 HTML 字符
将 JSON 数字解组为接口值
十六进制或其他非 UTF8 转义序列无法使用 JSON 字符串值
比较结构、数组、切片和映射
从恐慌中恢复
更新和引用切片、数组和映射“for range”子句中的项值
切片中的“隐藏”数据
切片数据损坏
“陈旧”切片
类型声明和方法
打破“for switch”和“for select”代码块
“for”语句中的迭代变量和闭包
延迟函数调用参数评估
延迟函数调用执行
失败的类型断言
阻塞的 Goroutines 和资源泄漏
不同零大小变量的相同地址
iota 的首次使用并不总是从零开始

高级初学者：

在值实例上使用指针接收器方法
更新 map 值字段
“nil”接口和“nil”接口值
堆栈和堆变量
GOMAXPROCS、并发和并行
读写操作重新排序
抢先调度

Cgo（又名勇敢的初学者）：

导入 C 和多行导入块
Import C 和 Cgo 注释之间没有空行
不能使用可变参数调用 C 函数

1.不能将左大括号放在单独的行上

级别：初学者

在大多数使用大括号的其他语言中，您可以选择放置它们的位置。您可以感谢这种行为的自动分号注入（没有前瞻）。是的，Go 确实有分号 :-)

Fails:

1
2
3
4
5
6
7
8
package main

import "fmt"

func main()  
{ //error, can't have the opening brace on a separate line
    fmt.Println("hello there!")
}

Compile Error:

/tmp/sandbox826898458/main.go:6: syntax error: unexpected semicolon or newline before {

Works:

1
2
3
4
5
6
7
package main

import "fmt"

func main() {  
    fmt.Println("works!")
}

2.未使用的变量

级别：初学者

如果您有一个未使用的变量，您的代码将无法编译。不过有一个例外。您必须使用在函数内部声明的变量，但如果您有未使用的全局变量，也可以。有未使用的函数参数也是可以的。

如果您为未使用的变量分配新值，您的代码仍将无法编译。您需要以某种方式使用变量值来使编译器满意。

Fails:

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

var gvar int //not an error

func main() {  
    var one int   //error, unused variable
    two := 2      //error, unused variable
    var three int //error, even though it's assigned 3 on the next line
    three = 3

    func(unused string) {
        fmt.Println("Unused arg. No compile error")
    }("what?")
}

Compile Errors:

/tmp/sandbox473116179/main.go:6: one declared and not used /tmp/sandbox473116179/main.go:7: two declared and not used /tmp/sandbox473116179/main.go:8: three declared and not used

Works:

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

import "fmt"

func main() {  
    var one int
    _ = one

    two := 2 
    fmt.Println(two)

    var three int 
    three = 3
    one = three

    var four int
    four = four
}

Another option is to comment out or remove the unused variables :-)

3.未使用的 import

级别：初学者

如果您在不使用任何导出函数、接口、结构或变量的情况下导入包，您的代码将无法编译。

如果您确实需要导入的包，可以使用空白标识符_, 作为其包名，以避免编译失败。空白标识符用于导入包的副作用。

Fails:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import (  
    "fmt"
    "log"
    "time"
)

func main() {  
}

Compile Errors:

/tmp/sandbox627475386/main.go:4: imported and not used:
“fmt” /tmp/sandbox627475386/main.go:5: imported and not used:
“log” /tmp/sandbox627475386/main.go:6: imported and not used: “time”

Works:

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

import (  
    _ "fmt"
    "log"
    "time"
)

var _ = log.Println

func main() {  
    _ = time.Now
}

4.短变量声明只能在函数内部使用

级别：初学者

Fails:

1
2
3
4
5
6
package main

myvar := 1 //error

func main() {  
}

Compile Error:

/tmp/sandbox265716165/main.go:3: non-declaration statement outside function body

Works:

1
2
3
4
5
6
package main

var myvar = 1

func main() {  
}

5.使用短变量声明重新声明变量

级别：初学者

您不能在独立语句中重新声明变量，但在至少声明一个新变量的多变量声明中是允许的。

重新声明的变量必须在同一个块中，否则您最终会得到一个阴影变量。

Fails:

1
2
3
4
5
6
package main

func main() {  
    one := 0
    one := 1 //error
}

Compile Error:

/tmp/sandbox706333626/main.go:5: no new variables on left side of :=

Works:

1
2
3
4
5
6
7
8
package main

func main() {  
    one := 0
    one, two := 1,2

    one,two = two,one
}

6.不能使用短变量声明来设置字段值

级别：初学者

Fails:

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

import (  
  "fmt"
)

type info struct {  
  result int
}

func work() (int,error) {  
    return 13,nil  
  }

func main() {  
  var data info

  data.result, err := work() //error
  fmt.Printf("info: %+v\n",data)
}

Compile Error:

prog.go:18: non-name data.result on left side of :=

使用临时变量或预先声明所有变量并使用标准赋值运算符。

Works:

 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
package main

import (  
  "fmt"
)

type info struct {  
  result int
}

func work() (int,error) {  
    return 13,nil  
  }

func main() {  
  var data info

  var err error
  data.result, err = work() //ok
  if err != nil {
    fmt.Println(err)
    return
  }

  fmt.Printf("info: %+v\n",data) //prints: info: {result:13}
}

7.变量覆盖（Variable Shadowing）

级别：初学者

简短的变量声明语法非常方便（特别是对于那些来自动态语言的语言），很容易将其视为常规赋值操作。如果您在新代码块中犯了这个错误，则不会出现编译器错误，但您的应用程序不会按照您的预期执行。

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

import "fmt"

func main() {  
    x := 1
    fmt.Println(x)     //prints 1
    {
        fmt.Println(x) //prints 1
        x := 2
        fmt.Println(x) //prints 2
    }
    fmt.Println(x)     //prints 1 (bad if you need 2)
}

即使对于经验丰富的 Go 开发人员来说，这也是一个非常常见的陷阱。它很容易制作，而且很难被发现。

您可以使用该vet命令来查找其中的一些问题。默认情况下，vet不会执行任何阴影变量检查。确保使用-shadow标志：go tool vet -shadow your_file.go

请注意，该vet命令不会报告所有阴影变量。用于go-nyet更积极的阴影变量检测。

8.不能使用“nil”来初始化没有显式类型的变量

级别：初学者

“nil”标识符可用作接口、函数、指针、映射、切片和通道的“零值”。如果您不指定变量类型，编译器将无法编译您的代码，因为它无法猜测类型。

Fails:

1
2
3
4
5
6
7
package main

func main() {  
    var x = nil //error

    _ = x
}

Compile Error:

/tmp/sandbox188239583/main.go:4: use of untyped nil

Works:

1
2
3
4
5
6
7
package main

func main() {  
    var x interface{} = nil

    _ = x
}

9.使用“nil”切片和映射

级别：初学者

可以将元素添加到“nil”切片，但对 map 执行相同操作会产生运行时panic 。

Works:

1
2
3
4
5
6
gopackage main

func main() {  
    var s []int
    s = append(s,1)
}

Fails:

1
2
3
4
5
6
7
package main

func main() {  
    var m map[string]int
    m["one"] = 1 //error

}

10.map 容量

级别：初学者

您可以在创建 map 时指定容量，但不能使用cap(map)函数计算容量。这是跟slice的不同点。

Fails:

1
2
3
4
5
6
package main

func main() {  
    m := make(map[string]int,99)
    cap(m) //error
}

Compile Error:

/tmp/sandbox326543983/main.go:5: invalid argument m (type map[string]int) for cap

11.字符串不能为“nil”

级别：初学者

对于习惯于将“nil”标识符分配给字符串变量的开发人员来说，这是一个陷阱。

Fails:

1
2
3
4
5
6
7
8
9
package main

func main() {  
    var x string = nil //error

    if x == nil { //error
        x = "default"
    }
}

Compile Errors:

/tmp/sandbox630560459/main.go:4: cannot use nil as type string in assignment
/tmp/sandbox630560459/main.go:6: invalid operation: x == nil (mismatched types string and nil)

Works:

1
2
3
4
5
6
7
8
9
package main

func main() {  
    var x string //defaults to "" (zero value)

    if x == "" {
        x = "default"
    }
}

12.数组函数参数：数组指针类型

级别：初学者

如果您是 C 或 C++ 开发人员，那么您的数组就是指针。当您将数组传递给函数时，函数引用相同的内存位置，因此它们可以更新原始数据。Go 中的数组是值，因此当您将数组传递给函数时，函数会获取原始数组数据的副本。如果您尝试更新数组数据，这可能是个问题。

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

import "fmt"

func main() {  
    x := [3]int{1,2,3}

    func(arr [3]int) {
        arr[0] = 7
        fmt.Println(arr) //prints [7 2 3]
    }(x)

    fmt.Println(x) //prints [1 2 3] (not ok if you need [7 2 3])
}

如果您需要更新原始数组数据，请使用数组指针类型。

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

import "fmt"

func main() {  
    x := [3]int{1,2,3}

    func(arr *[3]int) {
        (*arr)[0] = 7
        fmt.Println(arr) //prints &[7 2 3]
    }(&x)

    fmt.Println(x) //prints [7 2 3]
}

另一种选择是使用切片。即使您的函数获得了切片变量的副本，它仍然引用原始数据。

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

import "fmt"

func main() {  
    x := []int{1,2,3}

    func(arr []int) {
        arr[0] = 7
        fmt.Println(arr) //prints [7 2 3]
    }(x)

    fmt.Println(x) //prints [7 2 3]
}

13.切片和数组“range”子句中的意外值

级别：初学者

如果您习惯了其他语言中的“for-in”或“foreach”语句，就会发生这种情况。Go 中的“范围”子句是不同的。它生成两个值：第一个值是项目索引，而第二个值是项目数据。

Bad:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {  
    x := []string{"a","b","c"}

    for v := range x {
        fmt.Println(v) //prints 0, 1, 2
    }
}

Good:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {  
    x := []string{"a","b","c"}

    for _, v := range x {
        fmt.Println(v) //prints a, b, c
    }
}

14.切片和数组是一维的

级别：初学者

看起来 Go 似乎支持多维数组和切片，但事实并非如此。但是，可以创建数组数组或切片切片。对于依赖动态多维数组的数值计算应用程序，它在性能和复杂性方面远非理想。

您可以使用原始一维数组、“独立”切片的切片和“共享数据”切片的切片来构建动态多维数组。

如果您使用原始一维数组，您需要在数组需要增长时负责索引、边界检查和内存重新分配。

使用“独立”切片的切片创建动态多维数组是一个两步过程。首先，您必须创建外部切片。然后，您必须分配每个内部切片。内部切片彼此独立。您可以在不影响其他内部切片的情况下扩展和收缩它们。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

func main() {  
    x := 2
    y := 4

    table := make([][]int,x)
    for i:= range table {
        table[i] = make([]int,y)
    }
}

使用“共享数据”切片创建动态多维数组是一个三步过程。首先，您必须创建将保存原始数据的数据“容器”切片。然后，您创建外部切片。最后，通过重新切片原始数据切片来初始化每个内部切片。

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

import "fmt"

func main() {  
    h, w := 2, 4

    raw := make([]int,h*w)
    for i := range raw {
        raw[i] = i
    }
    fmt.Println(raw,&raw[4])
    //prints: [0 1 2 3 4 5 6 7] <ptr_addr_x>

    table := make([][]int,h)
    for i:= range table {
        table[i] = raw[i*w:i*w + w]
    }

    fmt.Println(table,&table[1][0])
    //prints: [[0 1 2 3] [4 5 6 7]] <ptr_addr_x>
}

有一个针对多维数组和切片的规范/建议，但目前看来它是一个低优先级的功能。

15.访问不存在的map的key

级别：初学者

对于希望获得“nil”标识符的开发人员来说，这是一个陷阱（就像在其他语言中所做的那样）。如果相应数据类型的“零值”为“nil”，则返回值为“nil”，但对于其他数据类型则不同。检查适当的“零值”可用于确定映射记录是否存在，但它并不总是可靠的（例如，如果您有一个布尔映射，其中“零值”为假，您会怎么做）。了解给定map记录是否存在的最可靠方法是检查map访问操作返回的第二个值。

Bad:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {  
    x := map[string]string{"one":"a","two":"","three":"c"}

    if v := x["two"]; v == "" { //incorrect
        fmt.Println("no entry")
    }
}

Good:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {  
    x := map[string]string{"one":"a","two":"","three":"c"}

    if _,ok := x["two"]; !ok {
        fmt.Println("no entry")
    }
}

16.字符串是不可变的

级别：初学者

尝试使用索引运算符更新字符串变量中的单个字符将导致失败。字符串是只读字节切片（带有一些额外的属性）。如果确实需要更新字符串，则在必要时使用字节切片而不是将其转换为字符串类型。

Fails:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import "fmt"

func main() {  
    x := "text"
    x[0] = 'T'

    fmt.Println(x)
}

Compile Error:

/tmp/sandbox305565531/main.go:7: cannot assign to x[0]

Works:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {  
    x := "text"
    xbytes := []byte(x)
    xbytes[0] = 'T'

    fmt.Println(string(xbytes)) //prints Text
}

请注意，这实际上并不是更新文本字符串中字符的正确方法，因为给定的字符可以存储在多个字节中。如果您确实需要对文本字符串进行更新，请先将其转换为符文切片。即使使用符文切片，单个字符也可能跨越多个符文，例如，如果您有带有重音的字符，就会发生这种情况。“字符”的这种复杂和模棱两可的性质是 Go 字符串被表示为字节序列的原因。

17.字符串和字节片之间的转换

级别：初学者

当您将字符串转换为字节切片（反之亦然）时，您将获得原始数据的完整副本。它不像其他语言中的强制转换操作，也不像重新切片新切片变量指向原始字节切片使用的相同底层数组的位置。

Go 确实对 []byte to string 和 string to []byte转换进行了一些优化，以避免额外的分配（对 todo 列表进行了更多优化）。

当 []byte 键用于查找 map[string] 集合中的条目时，第一个优化避免了额外的分配：m[string(key)]

第二个优化避免了 for range字符串转换为[]byte:的子句中的额外分配for i,v := range []byte(str) {…}

18.字符串和索引运算符

级别：初学者

字符串上的索引运算符返回一个字节值，而不是一个字符（就像在其他语言中所做的那样）。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {  
    x := "text"
    fmt.Println(x[0]) //print 116
    fmt.Printf("%T",x[0]) //prints uint8
}

如果您需要访问特定的字符串“字符”（unicode 代码点/符文），请使用该for range子句。官方的“unicode/utf8”包和实验性的utf8string包（golang.org/x/exp/utf8string）也很有用。utf8string 包包含一个方便的At()方法。将字符串转换为一片符文也是一种选择。

19.字符串并不总是 UTF8 文本

级别：初学者

字符串值不需要是 UTF8 文本。它们可以包含任意字节。字符串是 UTF8 的唯一时间是使用字符串文字时。即使这样，它们也可以使用转义序列包含其他数据。

要知道您是否有 UTF8 文本字符串，请使用ValidString()“unicode/utf8”包中的函数。

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

import (  
    "fmt"
    "unicode/utf8"
)

func main() {  
    data1 := "ABC"
    fmt.Println(utf8.ValidString(data1)) //prints: true

    data2 := "A\xfeC"
    fmt.Println(utf8.ValidString(data2)) //prints: false
}

20.字符串长度

级别：初学者

假设您是一名 python 开发人员，并且您有以下代码：

1
2
data = u'♥'  
print(len(data)) #prints: 1  

当您将其转换为类似的 Go 代码片段时，您可能会感到惊讶。

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {  
    data := "♥"
    fmt.Println(len(data)) //prints: 3
}

内置len()函数返回字节数，而不是像 Python 中的 unicode 字符串那样返回字符数。

要在 Go 中获得相同的结果，请使用 RuneCountInString() “unicode/utf8”包中的函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import (  
    "fmt"
    "unicode/utf8"
)

func main() {  
    data := "♥"
    fmt.Println(utf8.RuneCountInString(data)) //prints: 1

从技术上讲，该RuneCountInString()函数不返回字符数，因为单个字符可能跨越多个符文。

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

import (  
    "fmt"
    "unicode/utf8"
)

func main() {  
    data := "é"
    fmt.Println(len(data))                    //prints: 3
    fmt.Println(utf8.RuneCountInString(data)) //prints: 2
}

21.多行切片、数组和映射文字中缺少逗号

级别：初学者

Fails:

1
2
3
4
5
6
7
8
9
package main

func main() {  
    x := []int{
    1,
    2 //error
    }
    _ = x
}

Compile Errors:

/tmp/sandbox367520156/main.go:6: syntax error: need trailing comma before newline in composite literal /tmp/sandbox367520156/main.go:8: non-declaration statement outside function body /tmp/sandbox367520156/main.go:9: syntax error: unexpected }

Works:

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

func main() {  
    x := []int{
    1,
    2,
    }
    x = x

    y := []int{3,4,} //no error
    y = y
}

如果在将声明折叠为一行时留下尾随逗号，则不会出现编译器错误。

22.log.Fatal 和 log.Panic 不仅仅是日志

级别：初学者

日志库通常提供不同的日志级别。Fatal*()不像那些日志库，如果你调用Fatal*()和Panic*()函数，Go 中的日志包不仅仅做日志。当您的应用调用这些函数时，Go 也会终止您的应用 :-)

1
2
3
4
5
6
7
8
package main

import "log"

func main() {  
    log.Fatalln("Fatal Level: log entry") //app exits here
    log.Println("Normal Level: log entry")
}

23.内置数据结构操作不同步

级别：初学者

尽管 Go 有许多原生支持并发的特性，但并发安全数据集合并不是其中之一 :-) 确保数据集合更新是原子的是您的责任。Goroutines 和 channels 是实现这些原子操作的推荐方式，但如果它对您的应用程序有意义，您也可以利用“sync”包。

24.“range”子句中字符串的迭代值

级别：初学者

索引值（“range”操作返回的第一个值）是第二个值中返回的当前“字符”（unicode 码点/符文）的第一个字节的索引。它不是当前“字符”的索引，就像在其他语言中所做的那样。请注意，一个实际角色可能由多个符文表示。如果您需要使用字符，请务必查看“规范”包 (golang.org/x/text/unicode/norm)。

带有字符串变量的for range子句将尝试将数据解释为 UTF8 文本。对于它不理解的任何字节序列，它将返回 0xfffd 符文（又名 unicode 替换字符）而不是实际数据。如果您在字符串变量中存储了任意（非 UTF8 文本）数据，请确保将它们转换为字节切片以按原样获取所有存储的数据。

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

import "fmt"

func main() {  
    data := "A\xfe\x02\xff\x04"
    for _,v := range data {
        fmt.Printf("%#x ",v)
    }
    //prints: 0x41 0xfffd 0x2 0xfffd 0x4 (not ok)

    fmt.Println()
    for _,v := range []byte(data) {
        fmt.Printf("%#x ",v)
    }
    //prints: 0x41 0xfe 0x2 0xff 0x4 (good)
}

25.使用“for range”子句遍历map

级别：初学者

如果您希望项目按特定顺序排列（例如，按键值排序），这是一个问题。每次地图迭代都会产生不同的结果。Go 运行时尝试将迭代顺序随机化，但它并不总是成功，因此您可能会得到几个相同的map迭代。连续看到 5 次相同的迭代不要感到惊讶。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import "fmt"

func main() {  
    m := map[string]int{"one":1,"two":2,"three":3,"four":4}
    for k,v := range m {
        fmt.Println(k,v)
    }
}

如果您使用 Go Playground ( https://play.golang.org/ )，您将始终获得相同的结果，因为除非您进行更改，否则它不会重新编译代码。

26.“switch”语句中的失败行为

级别：初学者

默认情况下，“switch”语句中的“case”块会中断。这与其他语言不同，其他语言的默认行为是进入下一个“case”块。

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

import "fmt"

func main() {  
    isSpace := func(ch byte) bool {
        switch(ch) {
        case ' ': //error
        case '\t':
            return true
        }
        return false
    }

    fmt.Println(isSpace('\t')) //prints true (ok)
    fmt.Println(isSpace(' '))  //prints false (not ok)
}

您可以通过在每个“case”块末尾使用“fallthrough”语句来强制“case”块通过。您还可以重写您的 switch 语句以在“case”块中使用表达式列表。

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

import "fmt"

func main() {  
    isSpace := func(ch byte) bool {
        switch(ch) {
        case ' ', '\t':
            return true
        }
        return false
    }

    fmt.Println(isSpace('\t')) //prints true (ok)
    fmt.Println(isSpace(' '))  //prints true (ok)
}

27.增量和减量

级别：初学者

许多语言都有递增和递减运算符。与其他语言不同，Go 不支持操作的前缀版本。您也不能在表达式中使用这两个运算符。

Fails:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import "fmt"

func main() {  
    data := []int{1,2,3}
    i := 0
    ++i //error
    fmt.Println(data[i++]) //error
}

Compile Errors:

/tmp/sandbox101231828/main.go:8: syntax error: unexpected ++
/tmp/sandbox101231828/main.go:9: syntax error: unexpected ++, expecting :

Works:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import "fmt"

func main() {  
    data := []int{1,2,3}
    i := 0
    i++
    fmt.Println(data[i])
}

28.按位非运算符

级别：初学者

许多语言使用~一元 NOT 运算符（也称为按位补码），但 Go 重用了 XOR 运算符 ( ^)。

Fails:

1
2
3
4
5
6
7
package main

import "fmt"

func main() {  
    fmt.Println(~2) //error
}

Compile Error:

/tmp/sandbox965529189/main.go:6: the bitwise complement operator is ^

Works:

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {  
    var d uint8 = 2
    fmt.Printf("%08b\n",^d)
}

Go 仍然使用^XOR 运算符，这可能会让一些人感到困惑。

如果您愿意，您可以NOT 0x02用二进制 XOR 运算（例如）来表示一元 NOT 运算（例如0x02 XOR 0xff）。这可以解释为什么^要重用来表示一元 NOT 操作。

Go 还有一个特殊的“AND NOT”位运算符 ( &^)，这增加了 NOT 运算符的混淆。它看起来像是一个A AND (NOT B)不需要括号就可以支持的特殊功能/hack。

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

import "fmt"

func main() {  
    var a uint8 = 0x82
    var b uint8 = 0x02
    fmt.Printf("%08b [A]\n",a)
    fmt.Printf("%08b [B]\n",b)

    fmt.Printf("%08b (NOT B)\n",^b)
    fmt.Printf("%08b ^ %08b = %08b [B XOR 0xff]\n",b,0xff,b ^ 0xff)

    fmt.Printf("%08b ^ %08b = %08b [A XOR B]\n",a,b,a ^ b)
    fmt.Printf("%08b & %08b = %08b [A AND B]\n",a,b,a & b)
    fmt.Printf("%08b &^%08b = %08b [A 'AND NOT' B]\n",a,b,a &^ b)
    fmt.Printf("%08b&(^%08b)= %08b [A AND (NOT B)]\n",a,b,a & (^b))
}

29.运算符优先级差异

级别：初学者

除了“bit clear”操作符（&^）之外，Go 有一组标准操作符，许多其他语言都共享这些操作符。但是，运算符的优先级并不总是相同的。

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

import "fmt"

func main() {  
    fmt.Printf("0x2 & 0x2 + 0x4 -> %#x\n",0x2 & 0x2 + 0x4)
    //prints: 0x2 & 0x2 + 0x4 -> 0x6
    //Go:    (0x2 & 0x2) + 0x4
    //C++:    0x2 & (0x2 + 0x4) -> 0x2

    fmt.Printf("0x2 + 0x2 << 0x1 -> %#x\n",0x2 + 0x2 << 0x1)
    //prints: 0x2 + 0x2 << 0x1 -> 0x6
    //Go:     0x2 + (0x2 << 0x1)
    //C++:   (0x2 + 0x2) << 0x1 -> 0x8

    fmt.Printf("0xf | 0x2 ^ 0x2 -> %#x\n",0xf | 0x2 ^ 0x2)
    //prints: 0xf | 0x2 ^ 0x2 -> 0xd
    //Go:    (0xf | 0x2) ^ 0x2
    //C++:    0xf | (0x2 ^ 0x2) -> 0xf
}

30.未导出的结构字段未编码

级别：初学者

以小写字母开头的结构字段不会被（json、xml、gob 等）编码，因此当您解码结构时，您最终会在那些未导出的字段中得到零值。

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

import (  
    "fmt"
    "encoding/json"
)

type MyData struct {  
    One int
    two string
}

func main() {  
    in := MyData{1,"two"}
    fmt.Printf("%#v\n",in) //prints main.MyData{One:1, two:"two"}

    encoded,_ := json.Marshal(in)
    fmt.Println(string(encoded)) //prints {"One":1}

    var out MyData
    json.Unmarshal(encoded,&out)

    fmt.Printf("%#v\n",out) //prints main.MyData{One:1, two:""}
}

31.带有活动 Goroutines 的应用程序退出

级别：初学者

该应用程序不会等待您所有的 goroutine 完成。对于一般初学者来说，这是一个常见的错误。每个人都从某个地方开始，所以犯新手错误并不可耻:-)

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

import (  
    "fmt"
    "time"
)

func main() {  
    workerCount := 2

    for i := 0; i < workerCount; i++ {
        go doit(i)
    }
    time.Sleep(1 * time.Second)
    fmt.Println("all done!")
}

func doit(workerId int) {  
    fmt.Printf("[%v] is running\n",workerId)
    time.Sleep(3 * time.Second)
    fmt.Printf("[%v] is done\n",workerId)
}

You’ll see:

[0] is running [1] is running all done!

最常见的解决方案之一是使用“WaitGroup”变量。它将允许主 goroutine 等待，直到所有工作 goroutine 完成。如果您的应用程序有长时间运行的带有消息处理循环的工作人员，您还需要一种方法来通知这些 goroutine 是时候退出了。您可以向每个worker发送“kill”消息。另一种选择是关闭所有工人正在接收的通道。这是一次向所有 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
27
28
package main

import (  
    "fmt"
    "sync"
)

func main() {  
    var wg sync.WaitGroup
    done := make(chan struct{})
    workerCount := 2

    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go doit(i,done,wg)
    }

    close(done)
    wg.Wait()
    fmt.Println("all done!")
}

func doit(workerId int,done <-chan struct{},wg sync.WaitGroup) {  
    fmt.Printf("[%v] is running\n",workerId)
    defer wg.Done()
    <- done
    fmt.Printf("[%v] is done\n",workerId)
}

如果你运行这个应用程序，你会看到：

[0] is running [0] is done [1] is running [1] is done

看起来worker在主 goroutine 退出之前就完成了。但是! 您还会看到：

fatal error: all goroutines are asleep - deadlock!

那不是很好:-) 发生了什么事？为什么会出现死锁？工人们离开了，他们被处决了wg.Done()。该应用程序应该可以工作。

发生死锁是因为每个工作人员都获得了原始“WaitGroup”变量的副本。当worker执行wg.Done()时，它对主 goroutine 中的“WaitGroup”变量没有影响。

 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
package main

import (  
    "fmt"
    "sync"
)

func main() {  
    var wg sync.WaitGroup
    done := make(chan struct{})
    wq := make(chan interface{})
    workerCount := 2

    for i := 0; i < workerCount; i++ {
        wg.Add(1)
        go doit(i,wq,done,&wg)
    }

    for i := 0; i < workerCount; i++ {
        wq <- i
    }

    close(done)
    wg.Wait()
    fmt.Println("all done!")
}

func doit(workerId int, wq <-chan interface{},done <-chan struct{},wg *sync.WaitGroup) {  
    fmt.Printf("[%v] is running\n",workerId)
    defer wg.Done()
    for {
        select {
        case m := <- wq:
            fmt.Printf("[%v] m => %v\n",workerId,m)
        case <- done:
            fmt.Printf("[%v] is done\n",workerId)
            return
        }
    }
}

现在它按预期工作:-)

32.目标接收器准备好后立即返回到无缓冲通道

级别：初学者

在收件人处理您的消息之前，不会阻止发件人。根据您运行代码的机器，接收者 goroutine 可能有也可能没有足够的时间在发送者继续执行之前处理消息。主进程过早结束，导致消息事件会丢失。

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

import "fmt"

func main() {  
    ch := make(chan string)

    go func() {
        for m := range ch {
            fmt.Println("processed:",m)
        }
    }()

    ch <- "cmd.1"
    ch <- "cmd.2" //won't be processed
}

33.发送到关闭的通道会导致panic

级别：初学者

从封闭的渠道接收是安全的。接收语句中的ok返回值将被设置为false表示没有接收到数据。如果您从缓冲通道接收，您将首先获取缓冲数据，一旦它为空，ok返回值将为false.

将数据发送到关闭的通道会导致panic。这是一个记录在案的行为，但对于可能期望发送行为类似于接收行为的新 Go 开发人员来说，这并不是很直观。

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

import (  
    "fmt"
    "time"
)

func main() {  
    ch := make(chan int)
    for i := 0; i < 3; i++ {
        go func(idx int) {
            ch <- (idx + 1) * 2
        }(i)
    }

    //get the first result
    fmt.Println(<-ch)
    close(ch) //not ok (you still have other senders)
    //do other work
    time.Sleep(2 * time.Second)
}

根据您的应用程序，修复会有所不同。这可能是一个小的代码更改，或者可能需要更改您的应用程序设计。无论哪种方式，您都需要确保您的应用程序不会尝试将数据发送到关闭的通道。

错误示例可以通过使用特殊的取消通道来向剩余的工作人员发出不再需要他们的结果的信号来修复。

 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
package main

import (  
    "fmt"
    "time"
)

func main() {  
    ch := make(chan int)
    done := make(chan struct{})
    for i := 0; i < 3; i++ {
        go func(idx int) {
            select {
            case ch <- (idx + 1) * 2: fmt.Println(idx,"sent result")
            case <- done: fmt.Println(idx,"exiting")
            }
        }(i)
    }

    //get first result
    fmt.Println("result:",<-ch)
    close(done)
    //do other work
    time.Sleep(3 * time.Second)
}

34.使用“零”通道

级别：初学者

nil永远在通道块上发送和接收操作。这是一个有据可查的行为，但对于新的 Go 开发人员来说可能是一个惊喜。

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

import (  
    "fmt"
    "time"
)

func main() {  
    var ch chan int
    for i := 0; i < 3; i++ {
        go func(idx int) {
            ch <- (idx + 1) * 2
        }(i)
    }

    //get first result
    fmt.Println("result:",<-ch)
    //do other work
    time.Sleep(2 * time.Second)
}

如果您运行代码，您将看到如下运行时错误：fatal error: all goroutines are asleep - deadlock!

此行为可用作在语句中动态启用和禁用case块的一种方式。select

 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
package main

import "fmt"  
import "time"

func main() {  
    inch := make(chan int)
    outch := make(chan int)

    go func() {
        var in <- chan int = inch
        var out chan <- int
        var val int
        for {
            select {
            case out <- val:
                out = nil
                in = inch
            case val = <- in:
                out = outch
                in = nil
            }
        }
    }()

    go func() {
        for r := range outch {
            fmt.Println("result:",r)
        }
    }()

    time.Sleep(0)
    inch <- 1
    inch <- 2
    time.Sleep(3 * time.Second)
}

35.带有值接收器的方法不能更改原始值

级别：初学者

方法接收器就像常规函数参数。如果它被声明为一个值，那么您的函数/方法将获得您的接收器参数的副本。这意味着对接收器进行更改不会影响原始值，除非您的接收器是映射或切片变量，并且您正在更新集合中的项目或者您在接收器中更新的字段是指针。

 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
package main

import "fmt"

type data struct {  
    num int
    key *string
    items map[string]bool
}

func (this *data) pmethod() {  
    this.num = 7
}

func (this data) vmethod() {  
    this.num = 8
    *this.key = "v.key"
    this.items["vmethod"] = true
}

func main() {  
    key := "key.1"
    d := data{1,&key,make(map[string]bool)}

    fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items)
    //prints num=1 key=key.1 items=map[]

    d.pmethod()
    fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items) 
    //prints num=7 key=key.1 items=map[]

    d.vmethod()
    fmt.Printf("num=%v key=%v items=%v\n",d.num,*d.key,d.items)
    //prints num=7 key=v.key items=map[vmethod:true]
}

36.关闭 HTTP 响应正文

等级：中级

当您使用标准 http 库发出请求时，您会得到一个 http 响应变量。如果您不阅读响应正文，您仍然需要关闭它。请注意，您也必须为空响应执行此操作。这很容易忘记，尤其是对于新的 Go 开发人员。

一些新的 Go 开发人员确实尝试关闭响应体，但他们做错了地方。

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

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

func main() {  
    resp, err := http.Get("https://api.ipify.org?format=json")
    defer resp.Body.Close()//not ok
    if err != nil {
        fmt.Println(err)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}

此代码适用于成功的请求，但如果 http 请求失败，resp变量可能是nil，这将导致运行时 panic。

关闭响应正文的最常见原因是defer在 http 响应错误检查之后使用调用。

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

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

func main() {  
    resp, err := http.Get("https://api.ipify.org?format=json")
    if err != nil {
        fmt.Println(err)
        return
    }

    defer resp.Body.Close()//ok, most of the time :-)
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}

大多数情况下，当您的 http 请求失败时，resp变量将为nil， err为non-nill. 但是，当您遇到重定向失败时，两个变量都将是non-nil. 这意味着您仍然可能会出现泄漏。

non-nil您可以通过在 http 响应错误处理块中添加关闭响应主体的调用来修复此泄漏。另一种选择是使用一次defer调用来关闭所有失败和成功请求的响应主体。

 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
package main

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

func main() {  
    resp, err := http.Get("https://api.ipify.org?format=json")
    if resp != nil {
        defer resp.Body.Close()
    }

    if err != nil {
        fmt.Println(err)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}

原始 resp.Body.Close() 实现中，还读取并丢弃剩余的响应正文数据。这确保了如果启用了 keepalive http 连接行为，则可以将 http 连接重新用于另一个请求。最新的 http 客户端行为不同。现在，您有责任读取并丢弃剩余的响应数据。如果你不这样做，http 连接可能会被关闭而不是被重用。

如果重用 http 连接对您的应用程序很重要，您可能需要在响应处理逻辑的末尾添加类似这样的内容：

1
_, err = io.Copy(ioutil.Discard, resp.Body)  

如果您不立即阅读整个响应正文，则有必要这样做，如果您使用如下代码处理 json API 响应，则可能会发生这种情况：

1
json.NewDecoder(resp.Body).Decode(&data)  

37.关闭 HTTP 连接

等级：中级

一些 HTTP 服务器保持网络连接打开一段时间（基于 HTTP 1.1 规范和服务器“保持活动”配置）。默认情况下，标准 http 库仅在目标 HTTP 服务器请求时才会关闭网络连接。这意味着您的应用程序可能会在某些情况下用完套接字/文件描述符。

您可以通过将Close请求变量中的字段设置为来要求 http 库在请求完成后关闭连接true。

另一种选择是添加Connection请求标头并将其设置为close. 目标 HTTP 服务器也应该使用Connection: close标头响应。当 http 库看到这个响应头时，它也会关闭连接。

 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
package main

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

func main() {  
    req, err := http.NewRequest("GET","http://golang.org",nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    req.Close = true
    //or do this:
    //req.Header.Add("Connection", "close")

    resp, err := http.DefaultClient.Do(req)
    if resp != nil {
        defer resp.Body.Close()
    }

    if err != nil {
        fmt.Println(err)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(len(string(body)))
}

您还可以全局禁用 http 连接重用。您需要为其创建自定义 http 传输配置。

 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
package main

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

func main() {  
    tr := &http.Transport{DisableKeepAlives: true}
    client := &http.Client{Transport: tr}

    resp, err := client.Get("http://golang.org")
    if resp != nil {
        defer resp.Body.Close()
    }

    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(resp.StatusCode)

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(len(string(body)))
}

如果您向同一个 HTTP 服务器发送大量请求，则可以保持网络连接打开。但是，如果您的应用程序在短时间内向许多不同的 HTTP 服务器发送一个或两个请求，最好在您的应用程序收到响应后立即关闭网络连接。增加打开文件的限制也可能是个好主意。但是，正确的解决方案取决于您的应用程序。

38.JSON 编码器添加换行符

等级：中级

当您发现测试失败是因为您没有获得预期值时，您正在为 JSON 编码函数编写测试。发生了什么？如果您使用的是 JSON 编码器对象，那么您将在编码的 JSON 对象的末尾获得一个额外的换行符。

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

import (
  "fmt"
  "encoding/json"
  "bytes"
)

func main() {
  data := map[string]int{"key": 1}
  
  var b bytes.Buffer
  json.NewEncoder(&b).Encode(data)

  raw,_ := json.Marshal(data)
  
  if b.String() == string(raw) {
    fmt.Println("same encoded data")
  } else {
    fmt.Printf("'%s' != '%s'\n",raw,b.String())
    //prints:
    //'{"key":1}' != '{"key":1}\n'
  }
}

JSON Encoder 对象专为流式传输而设计。使用 JSON 进行流式传输通常意味着以换行符分隔的 JSON 对象，这就是 Encode 方法添加换行符的原因。这是记录在案的行为，但通常被忽视或遗忘。

39.JSON 包转义键和字符串值中的特殊 HTML 字符

等级：中级

这是一个记录在案的行为，但您必须仔细阅读所有 JSON 包文档才能了解它。SetEscapeHTML方法描述讨论了 and、小于和大于字符的默认编码行为。

出于多种原因，这是 Go 团队的一个非常不幸的设计决定。首先，您不能为json.Marshal调用禁用此行为。其次，这是一个实施得很糟糕的安全功能，因为它假定进行 HTML 编码足以防止所有 Web 应用程序中的 XSS 漏洞。有很多不同的上下文可以使用数据，每个上下文都需要自己的编码方法。最后，它很糟糕，因为它假定 JSON 的主要用例是网页，默认情况下会破坏配置库和 REST/HTTP API。

 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
package main

import (
  "fmt"
  "encoding/json"
  "bytes"
)

func main() {
  data := "x < y"
  
  raw,_ := json.Marshal(data)
  fmt.Println(string(raw))
  //prints: "x \u003c y" <- probably not what you expected
  
  var b1 bytes.Buffer
  json.NewEncoder(&b1).Encode(data)
  fmt.Println(b1.String())
  //prints: "x \u003c y" <- probably not what you expected
  
  var b2 bytes.Buffer
  enc := json.NewEncoder(&b2)
  enc.SetEscapeHTML(false)
  enc.Encode(data)
  fmt.Println(b2.String())
  //prints: "x < y" <- looks better
}

给 Go 团队的建议……让它成为一个选择加入。

40.将 JSON 数字解组为接口值

等级：中级

默认情况下，float64当您将 JSON 数据解码/解组到接口中时，Go 将 JSON 中的数值视为数字。这意味着以下代码将因 panic 而失败：

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

import (  
  "encoding/json"
  "fmt"
)

func main() {  
  var data = []byte(`{"status": 200}`)

  var result map[string]interface{}
  if err := json.Unmarshal(data, &result); err != nil {
    fmt.Println("error:", err)
    return
  }

  var status = result["status"].(int) //error
  fmt.Println("status value:",status)
}

运行时panic：

panic: interface conversion: interface is float64, not int

如果您尝试解码的 JSON 值是一个整数，那么您有多个选项。

选项一：按原样使用浮点值:-)

选项二：将浮点值转换为您需要的整数类型。

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

import (  
  "encoding/json"
  "fmt"
)

func main() {  
  var data = []byte(`{"status": 200}`)

  var result map[string]interface{}
  if err := json.Unmarshal(data, &result); err != nil {
    fmt.Println("error:", err)
    return
  }

  var status = uint64(result["status"].(float64)) //ok
  fmt.Println("status value:",status)
}

选项三：使用一种类型来解组 JSON，并告诉它使用接口类型Decoder来表示 JSON 数字。Number

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

import (  
  "encoding/json"
  "bytes"
  "fmt"
)

func main() {  
  var data = []byte(`{"status": 200}`)

  var result map[string]interface{}
  var decoder = json.NewDecoder(bytes.NewReader(data))
  decoder.UseNumber()

  if err := decoder.Decode(&result); err != nil {
    fmt.Println("error:", err)
    return
  }

  var status,_ = result["status"].(json.Number).Int64() //ok
  fmt.Println("status value:",status)
}

您可以使用Number值的字符串表示形式将其解组为不同的数字类型：

 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
package main

import (  
  "encoding/json"
  "bytes"
  "fmt"
)

func main() {  
  var data = []byte(`{"status": 200}`)

  var result map[string]interface{}
  var decoder = json.NewDecoder(bytes.NewReader(data))
  decoder.UseNumber()

  if err := decoder.Decode(&result); err != nil {
    fmt.Println("error:", err)
    return
  }

  var status uint64
  if err := json.Unmarshal([]byte(result["status"].(json.Number).String()), &status); err != nil {
    fmt.Println("error:", err)
    return
  }

  fmt.Println("status value:",status)
}

选项四：使用struct将您的数值映射到您需要的数值类型的类型。

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

import (  
  "encoding/json"
  "bytes"
  "fmt"
)

func main() {  
  var data = []byte(`{"status": 200}`)

  var result struct {
    Status uint64 `json:"status"`
  }

  if err := json.NewDecoder(bytes.NewReader(data)).Decode(&result); err != nil {
    fmt.Println("error:", err)
    return
  }

  fmt.Printf("result => %+v",result)
  //prints: result => {Status:200}
}

选项五：如果您需要延迟值解码，请使用struct将您的数值映射到类型的 a。json.RawMessage

如果您必须在字段类型或结构可能发生变化的情况下执行条件 JSON 字段解码，则此选项很有用。

 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
package main

import (  
  "encoding/json"
  "bytes"
  "fmt"
)

func main() {  
  records := [][]byte{
    []byte(`{"status": 200, "tag":"one"}`),
    []byte(`{"status":"ok", "tag":"two"}`),
  }

  for idx, record := range records {
    var result struct {
      StatusCode uint64
      StatusName string
      Status json.RawMessage `json:"status"`
      Tag string             `json:"tag"`
    }

    if err := json.NewDecoder(bytes.NewReader(record)).Decode(&result); err != nil {
      fmt.Println("error:", err)
      return
    }

    var sstatus string
    if err := json.Unmarshal(result.Status, &sstatus); err == nil {
      result.StatusName = sstatus
    }

    var nstatus uint64
    if err := json.Unmarshal(result.Status, &nstatus); err == nil {
      result.StatusCode = nstatus
    }

    fmt.Printf("[%v] result => %+v\n",idx,result)
  }
}

41.十六进制或其他非 UTF8 转义序列无法使用 JSON 字符串值

等级：中级

Go 期望字符串值是 UTF8 编码的。这意味着您的 JSON 字符串中不能有任意十六进制转义的二进制数据（并且您还必须转义反斜杠字符）。这确实是 Go 继承的 JSON 陷阱，但它在 Go 应用程序中经常发生，因此无论如何都要提及它。

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

import (
  "fmt"
  "encoding/json"
)

type config struct {
  Data string `json:"data"`
}

func main() {
  raw := []byte(`{"data":"\xc2"}`)
  var decoded config

  if err := json.Unmarshal(raw, &decoded); err != nil {
        fmt.Println(err)
    //prints: invalid character 'x' in string escape code
    }
  
}

如果 Go 看到一个十六进制转义序列，Unmarshal/Decode 调用将失败。如果您确实需要在字符串中使用反斜杠，请确保使用另一个反斜杠对其进行转义。如果您想使用十六进制编码的二进制数据，您可以转义反斜杠，然后使用 JSON 字符串中的解码数据进行自己的十六进制转义。

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

import (
  "fmt"
  "encoding/json"
)

type config struct {
  Data string `json:"data"`
}

func main() {
  raw := []byte(`{"data":"\\xc2"}`)
  
  var decoded config
  
  json.Unmarshal(raw, &decoded)
  
  fmt.Printf("%#v",decoded) //prints: main.config{Data:"\\xc2"}
  //todo: do your own hex escape decoding for decoded.Data  
}

另一种选择是在 JSON 对象中使用字节数组/切片数据类型，但二进制数据必须采用 base64 编码。

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

import (
  "fmt"
  "encoding/json"
)

type config struct {
  Data []byte `json:"data"`
}

func main() {
  raw := []byte(`{"data":"wg=="}`)
  var decoded config
  
  if err := json.Unmarshal(raw, &decoded); err != nil {
          fmt.Println(err)
      }
  
  fmt.Printf("%#v",decoded) //prints: main.config{Data:[]uint8{0xc2}}
}

其他需要注意的是 Unicode 替换字符 (U+FFFD)。Go 将使用替换字符而不是无效的 UTF8，因此 Unmarshal/Decode 调用不会失败，但你得到的字符串值可能不是你所期望的。

42.比较结构、数组、切片和映射

等级：中级

==如果每个结构字段都可以与相等运算符进行比较，则可以使用相等运算符 ,来比较结构变量。

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

import "fmt"

type data struct {  
    num int
    fp float32
    complex complex64
    str string
    char rune
    yes bool
    events <-chan string
    handler interface{}
    ref *byte
    raw [10]byte
}

func main() {  
    v1 := data{}
    v2 := data{}
    fmt.Println("v1 == v2:",v1 == v2) //prints: v1 == v2: true
}

如果任何结构字段不可比较，则使用相等运算符将导致编译时错误。请注意，只有当它们的数据项具有可比性时，数组才具有可比性。

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

import "fmt"

type data struct {  
    num int                //ok
    checks [10]func() bool //not comparable
    doit func() bool       //not comparable
    m map[string] string   //not comparable
    bytes []byte           //not comparable
}

func main() {  
    v1 := data{}
    v2 := data{}
    fmt.Println("v1 == v2:",v1 == v2)
}

Go 确实提供了许多辅助函数来比较无法使用比较运算符进行比较的变量。

最通用的解决方案是使用DeepEqual()反射包中的函数。

 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
package main

import (  
    "fmt"
    "reflect"
)

type data struct {  
    num int                //ok
    checks [10]func() bool //not comparable
    doit func() bool       //not comparable
    m map[string] string   //not comparable
    bytes []byte           //not comparable
}

func main() {  
    v1 := data{}
    v2 := data{}
    fmt.Println("v1 == v2:",reflect.DeepEqual(v1,v2)) //prints: v1 == v2: true

    m1 := map[string]string{"one": "a","two": "b"}
    m2 := map[string]string{"two": "b", "one": "a"}
    fmt.Println("m1 == m2:",reflect.DeepEqual(m1, m2)) //prints: m1 == m2: true

    s1 := []int{1, 2, 3}
    s2 := []int{1, 2, 3}
    fmt.Println("s1 == s2:",reflect.DeepEqual(s1, s2)) //prints: s1 == s2: true
}

除了速度很慢（这可能会或可能不会对您的应用程序造成破坏）之外，DeepEqual()它也有自己的问题。

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

import (  
    "fmt"
    "reflect"
)

func main() {  
    var b1 []byte = nil
    b2 := []byte{}
    fmt.Println("b1 == b2:",reflect.DeepEqual(b1, b2)) //prints: b1 == b2: false
}

DeepEqual()不认为空切片等于“nil”切片。此行为与您使用该bytes.Equal()函数获得的行为不同。bytes.Equal()认为“nil”和空切片是相等的。

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

import (  
    "fmt"
    "bytes"
)

func main() {  
    var b1 []byte = nil
    b2 := []byte{}
    fmt.Println("b1 == b2:",bytes.Equal(b1, b2)) //prints: b1 == b2: true
}

DeepEqual()比较切片并不总是完美的。

 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"
    "reflect"
    "encoding/json"
)

func main() {  
    var str string = "one"
    var in interface{} = "one"
    fmt.Println("str == in:",str == in,reflect.DeepEqual(str, in)) 
    //prints: str == in: true true

    v1 := []string{"one","two"}
    v2 := []interface{}{"one","two"}
    fmt.Println("v1 == v2:",reflect.DeepEqual(v1, v2)) 
    //prints: v1 == v2: false (not ok)

    data := map[string]interface{}{
        "code": 200,
        "value": []string{"one","two"},
    }
    encoded, _ := json.Marshal(data)
    var decoded map[string]interface{}
    json.Unmarshal(encoded, &decoded)
    fmt.Println("data == decoded:",reflect.DeepEqual(data, decoded)) 
    //prints: data == decoded: false (not ok)
}

如果您的字节切片（或字符串）包含文本数据，当您需要以不区分大小写的方式（在使用、或之前）比较值时，您可能想使用或来自“字节”和“字符串”ToUpper()包。它适用于英文文本，但不适用于许多其他语言的文本。并且应该被使用。ToLower()==bytes.Equal()bytes.Compare()strings.EqualFold()bytes.EqualFold()

如果您的字节切片包含需要针对用户提供的数据进行验证的机密（例如，加密哈希、令牌等），请不要使用reflect.DeepEqual(), bytes.Equal()，或者bytes.Compare()因为这些函数会使您的应用程序容易受到计时攻击。为避免泄漏计时信息，请使用“crypto/subtle”包中的函数（例如，subtle.ConstantTimeCompare()）。

43.从 panic 中恢复（ recover ）

等级：中级

该recover()函数可用于捕获/拦截panic。调用 recover()只有在 defer 延迟函数中完成时才会起作用。

Incorrect:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

import "fmt"

func main() {  
    recover() //doesn't do anything
    panic("not good")
    recover() //won't be executed :)
    fmt.Println("ok")
}

Works:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {  
    defer func() {
        fmt.Println("recovered:",recover())
    }()

    panic("not good")
}

调用recover()仅在您的延迟函数中直接调用时才有效。

Fails:

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

import "fmt"

func doRecover() {  
    fmt.Println("recovered =>",recover()) //prints: recovered => <nil>
}

func main() {  
    defer func() {
        doRecover() //panic is not recovered
    }()

    panic("not good")
}

44.在切片、数组和映射“range”子句中更新和引用item值

等级：中级

“range”子句中生成的数据值是实际集合元素的副本。它们不是对原始item的引用。这意味着更新值不会更改原始数据。这也意味着获取值的地址不会为您提供指向原始数据的指针。

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

import "fmt"

func main() {  
    data := []int{1,2,3}
    for _,v := range data {
        v *= 10 //original item is not changed
    }

    fmt.Println("data:",data) //prints data: [1 2 3]
}

如果您需要更新原始集合记录值，请使用索引运算符来访问数据。

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

import "fmt"

func main() {  
    data := []int{1,2,3}
    for i,_ := range data {
        data[i] *= 10
    }

    fmt.Println("data:",data) //prints data: [10 20 30]
}

如果您的集合包含指针值，则规则略有不同。如果您希望原始记录指向另一个值，您仍然需要使用索引运算符，但您可以使用“for range”子句中的第二个值更新存储在目标位置的数据。

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

import "fmt"

func main() {  
    data := []*struct{num int} {{1},{2},{3}}

    for _,v := range data {
        v.num *= 10
    }

    fmt.Println(data[0],data[1],data[2]) //prints &{10} &{20} &{30}
}

45.切片中的“隐藏”数据

等级：中级

重新切片切片时，新切片将引用原始切片的数组。如果您忘记了这种行为，如果您的应用程序分配大型临时切片从它们创建新切片以引用原始数据的小部分，则可能会导致意外的内存使用。

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

import "fmt"

func get() []byte {  
    raw := make([]byte,10000)
    fmt.Println(len(raw),cap(raw),&raw[0]) //prints: 10000 10000 <byte_addr_x>
    return raw[:3]
}

func main() {  
    data := get()
    fmt.Println(len(data),cap(data),&data[0]) //prints: 3 10000 <byte_addr_x>
}

为避免此陷阱，请确保从临时切片中复制所需的数据（而不是重新切片）。

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

import "fmt"

func get() []byte {  
    raw := make([]byte,10000)
    fmt.Println(len(raw),cap(raw),&raw[0]) //prints: 10000 10000 <byte_addr_x>
    res := make([]byte,3)
    copy(res,raw[:3])
    return res
}

func main() {  
    data := get()
    fmt.Println(len(data),cap(data),&data[0]) //prints: 3 3 <byte_addr_y>
}

46.切片数据覆盖

等级：中级

假设您需要重写路径（存储在切片中）。您重新切片路径以引用修改第一个文件夹名称的每个目录，然后组合名称以创建新路径。

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

import (  
    "fmt"
    "bytes"
)

func main() {  
    path := []byte("AAAA/BBBBBBBBB")
    sepIndex := bytes.IndexByte(path,'/')
    dir1 := path[:sepIndex]
    dir2 := path[sepIndex+1:]
    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAA
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => BBBBBBBBB

    dir1 = append(dir1,"suffix"...)
    path = bytes.Join([][]byte{dir1,dir2},[]byte{'/'})

    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAAsuffix
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => uffixBBBB (not ok)

    fmt.Println("new path =>",string(path))
}

它没有像你预期的那样工作。而不是“AAAAsuffix/BBBBBBBBB”，你最终得到的是“AAAAsuffix/uffixBBBB”。发生这种情况是因为两个目录切片都引用了原始路径切片中相同的底层数组数据。这意味着原始路径也被修改了。根据您的应用程序，这也可能是一个问题。

这个问题可以通过分配新切片和复制你需要的数据来解决。另一种选择是使用完整的切片表达式。

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

import (  
    "fmt"
    "bytes"
)

func main() {  
    path := []byte("AAAA/BBBBBBBBB")
    sepIndex := bytes.IndexByte(path,'/')
    dir1 := path[:sepIndex:sepIndex] //full slice expression
    dir2 := path[sepIndex+1:]
    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAA
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => BBBBBBBBB

    dir1 = append(dir1,"suffix"...)
    path = bytes.Join([][]byte{dir1,dir2},[]byte{'/'})

    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAAsuffix
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => BBBBBBBBB (ok now)

    fmt.Println("new path =>",string(path))
}

完整切片表达式中的额外参数控制新切片的容量。现在追加到该切片将触发新的缓冲区分配，而不是覆盖第二个切片中的数据。

47.切片中的“旧数据”

等级：中级

多个切片可以引用相同的数据。例如，当您从现有切片创建新切片时，可能会发生这种情况。如果您的应用程序依赖此行为来正常运行，那么您需要担心“陈旧”切片。

在某些时候，当原始数组无法容纳更多新数据时，将数据添加到其中一个切片将导致新的数组分配。现在其他切片将指向旧数组（带有旧数据）。

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

func main() {  
    s1 := []int{1,2,3}
    fmt.Println(len(s1),cap(s1),s1) //prints 3 3 [1 2 3]

    s2 := s1[1:]
    fmt.Println(len(s2),cap(s2),s2) //prints 2 2 [2 3]

    for i := range s2 { s2[i] += 20 }

    //still referencing the same array
    fmt.Println(s1) //prints [1 22 23]
    fmt.Println(s2) //prints [22 23]

    s2 = append(s2,4)

    for i := range s2 { s2[i] += 10 }

    //s1 is now "stale"
    fmt.Println(s1) //prints [1 22 23]
    fmt.Println(s2) //prints [32 33 14]
}

48.类型声明和方法

等级：中级

当您通过从现有（非接口）类型定义新类型来创建类型声明时，您不会继承为该现有类型定义的方法。

Fails:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "sync"

type myMutex sync.Mutex

func main() {  
    var mtx myMutex
    mtx.Lock() //error
    mtx.Unlock() //error  
}

Compile Errors:

/tmp/sandbox106401185/main.go:9: mtx.Lock undefined (type myMutex has no field or method Lock) /tmp/sandbox106401185/main.go:10: mtx.Unlock undefined (type myMutex has no field or method Unlock)

如果您确实需要原始类型的方法，您可以定义一个新的结构类型，将原始类型嵌入为匿名字段。

Works:

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

import "sync"

type myLocker struct {  
    sync.Mutex
}

func main() {  
    var lock myLocker
    lock.Lock() //ok
    lock.Unlock() //ok
}

接口类型声明也保留了它们的方法集。

Works:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "sync"

type myLocker sync.Locker

func main() {  
    var lock myLocker = new(sync.Mutex)
    lock.Lock() //ok
    lock.Unlock() //ok
}

49. 从“for switch”和“for select”代码块中 break

等级：中级

没有标签的“break”语句只会让你脱离内部 switch/select 块。如果使用“return”语句不是一个选项，那么为外部循环定义一个标签是下一个最好的事情。

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

import "fmt"

func main() {  
    loop:
        for {
            switch {
            case true:
                fmt.Println("breaking out...")
                break loop
            }
        }

    fmt.Println("out!")
}

“goto”语句也可以解决问题……

50.“for”语句中的迭代变量和闭包

等级：中级

这是 Go 中最常见的问题。for语句中的迭代变量在每次迭代中被重用。这意味着在for循环中创建的每个闭包（又名函数字面量）都将引用相同的变量（并且它们将在这些 goroutine 开始执行时获取该变量的值）。

Incorrect:

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

import (  
    "fmt"
    "time"
)

func main() {  
    data := []string{"one","two","three"}

    for _,v := range data {
        go func() {
            fmt.Println(v)
        }()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: three, three, three
}

最简单的解决方案（不需要对goroutine进行任何修改），是将当前迭代变量值保存到for循环内的局部变量中

Works:

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

import (  
    "fmt"
    "time"
)

func main() {  
    data := []string{"one","two","three"}

    for _,v := range data {
        vcopy := v // 循环体内局部变量
        go func() {
            fmt.Println(vcopy)
        }()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

另一种解决方案是将当前迭代变量作为参数传递给匿名 goroutine。

Works:

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

import (  
    "fmt"
    "time"
)

func main() {  
    data := []string{"one","two","three"}

    for _,v := range data {
        go func(in string) {
            fmt.Println(in)
        }(v)
    }

    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

这是一个稍微复杂一点的陷阱版本。

Incorrect:

 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
package main

import (  
    "fmt"
    "time"
)

type field struct {  
    name string
}

func (p *field) print() {  
    fmt.Println(p.name)
}

func main() {  
    data := []field{{"one"},{"two"},{"three"}}

    for _,v := range data {
        go v.print()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: three, three, three
}

Works:

 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
package main

import (  
    "fmt"
    "time"
)

type field struct {  
    name string
}

func (p *field) print() {  
    fmt.Println(p.name)
}

func main() {  
    data := []field{{"one"},{"two"},{"three"}}

    for _,v := range data {
        v := v
        go v.print()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

你认为当你运行这段代码时你会看到什么（为什么）？

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

import (  
    "fmt"
    "time"
)

type field struct {  
    name string
}

func (p *field) print() {  
    fmt.Println(p.name)
}

func main() {  
    data := []*field{{"one"},{"two"},{"three"}}

    for _,v := range data {
        go v.print()
    }

    time.Sleep(3 * time.Second)
}

51.延迟函数调用参数评估

等级：中级

延迟函数调用的参数是在评估defer语句时评估的（而不是在函数实际执行时）。当您推迟方法调用时，同样的规则也适用。结构值也与显式方法参数和封闭变量一起保存。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {  
    var i int = 1

    defer fmt.Println("result =>",func() int { return i * 2 }())
    i++
    //prints: result => 2 (not ok if you expected 4)
}

如果您有指针参数，则可以更改它们指向的值，因为在defer评估语句时只保存指针。

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

import (
  "fmt"
)

func main() {
  i := 1
  defer func (in *int) { fmt.Println("result =>", *in) }(&i)
  
  i = 2
  //prints: result => 2
}

52.延迟函数调用执行

等级：中级

延迟调用在包含函数的末尾执行（并且以相反的顺序），而不是在包含代码块的末尾。对于新的 Go 开发人员来说，将延迟代码执行规则与变量作用域规则混淆是一个容易犯的错误。如果你有一个长时间运行的函数，它有一个for循环尝试defer在每次迭代中清理资源调用，这可能会成为一个问题。

 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
package main

import (  
    "fmt"
    "os"
    "path/filepath"
)

func main() {  
    if len(os.Args) != 2 {
        os.Exit(-1)
    }

    start, err := os.Stat(os.Args[1])
    if err != nil || !start.IsDir(){
        os.Exit(-1)
    }

    var targets []string
    filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error {
        if err != nil {
            return err
        }

        if !fi.Mode().IsRegular() {
            return nil
        }

        targets = append(targets,fpath)
        return nil
    })

    for _,target := range targets {
        f, err := os.Open(target)
        if err != nil {
            fmt.Println("bad target:",target,"error:",err) //prints error: too many open files
            break
        }
        defer f.Close() //will not be closed at the end of this code block
        //do something with the file...
    }
}

解决问题的一种方法是将代码块包装在函数中。

 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
package main

import (  
    "fmt"
    "os"
    "path/filepath"
)

func main() {  
    if len(os.Args) != 2 {
        os.Exit(-1)
    }

    start, err := os.Stat(os.Args[1])
    if err != nil || !start.IsDir(){
        os.Exit(-1)
    }

    var targets []string
    filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error {
        if err != nil {
            return err
        }

        if !fi.Mode().IsRegular() {
            return nil
        }

        targets = append(targets,fpath)
        return nil
    })

    for _,target := range targets {
        func() {
            f, err := os.Open(target)
            if err != nil {
                fmt.Println("bad target:",target,"error:",err)
                return
            }
            defer f.Close() //ok
            //do something with the file...
        }()
    }
}

另一种选择是摆脱defer声明:-)

53.失败的类型断言

等级：中级

失败的类型断言返回断言语句中使用的目标类型的“零值”。当它与可变阴影混合时，这可能会导致意外行为。

Incorrect:

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

import "fmt"

func main() {  
    var data interface{} = "great"

    if data, ok := data.(int); ok {
        fmt.Println("[is an int] value =>",data)
    } else {
        fmt.Println("[not an int] value =>",data) 
        //prints: [not an int] value => 0 (not "great")
    }
}

Works:

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

import "fmt"

func main() {  
    var data interface{} = "great"

    if res, ok := data.(int); ok {
        fmt.Println("[is an int] value =>",res)
    } else {
        fmt.Println("[not an int] value =>",data) 
        //prints: [not an int] value => great (as expected)
    }
}

54.阻塞的 Goroutines 和资源泄漏

等级：中级

Rob Pike 在 2012 年 Google I/O 上的“Go Concurrency Patterns”演讲中谈到了一些基本的并发模式。从多个目标中获取第一个结果就是其中之一。

1
2
3
4
5
6
7
8
func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

该函数为每个搜索副本启动一个 goroutine。每个 goroutine 将其搜索结果发送到结果通道。返回结果通道的第一个值。

其他 goroutine 的结果如何？goroutines 本身呢？

函数中的结果通道First()是无缓冲的。这意味着只有第一个 goroutine 返回。所有其他 goroutine 都被困在试图发送它们的结果。这意味着如果您有多个副本，则每次调用都会泄漏资源。

为避免泄漏，您需要确保所有 goroutine 都退出。一种可能的解决方案是使用足够大的缓冲结果通道来保存所有结果。

1
2
3
4
5
6
7
8
func First(query string, replicas ...Search) Result {  
    c := make(chan Result,len(replicas))
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

另一种可能的解决方案是使用select带有案例的语句default和可以保存一个值的缓冲结果通道。该default案例确保即使结果通道无法接收消息，goroutines 也不会卡住。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
func First(query string, replicas ...Search) Result {  
    c := make(chan Result,1)
    searchReplica := func(i int) { 
        select {
        case c <- replicas[i](query):
        default:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

您还可以使用特殊的取消通道来中断worker。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
    done := make(chan struct{})
    defer close(done)
    searchReplica := func(i int) { 
        select {
        case c <- replicas[i](query):
        case <- done:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }

    return <-c
}

为什么演示文稿包含这些错误？Rob Pike 只是不想让幻灯片复杂化。这是有道理的，但对于新的 Go 开发人员来说，这可能是一个问题，他们会按原样使用代码而不考虑它可能有问题。

55.不同零大小变量的相同地址

等级：中级

如果您有两个不同的变量，它们不应该有不同的地址吗？好吧，Go 不是这种情况 :-) 如果你有零大小的变量，它们可能在内存中共享完全相同的地址。

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

import (
  "fmt"
)

type data struct {
}

func main() {
  a := &data{}
  b := &data{}
  
  if a == b {
    fmt.Printf("same address - a=%p b=%p\n",a,b)
    //prints: same address - a=0x1953e4 b=0x1953e4
  }
}

56.iota 的首次使用并不总是从零开始

等级：中级

看起来标识符iota就像一个增量运算符。你开始一个新的常量声明，第一次使用iota你得到零，第二次使用它你得到一个，依此类推。但情况并非总是如此。

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

import (
  "fmt"
)

const (
  azero = iota
  aone  = iota
)

const (
  info  = "processing"
  bzero = iota
  bone  = iota
)

func main() {
  fmt.Println(azero,aone) //prints: 0 1
  fmt.Println(bzero,bone) //prints: 1 2
}

iota确实是常量声明块中当前行的索引运算符，因此如果第一次使用的不是iota常量声明块中的第一行，则初始值不会为零。

57.在值实例上使用指针接收器方法

等级：高级

只要值是可寻址的，就可以对值调用指针接收器方法。换句话说，在某些情况下，您不需要该方法的值接收器版本。

不过，并非每个变量都是可寻址的。map元素不可寻址。通过接口引用的变量也是不可寻址的。

 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
package main

import "fmt"

type data struct {  
    name string
}

func (p *data) print() {  
    fmt.Println("name:",p.name)
}

type printer interface {  
    print()
}

func main() {  
    d1 := data{"one"}
    d1.print() //ok

    // var in printer = data{"two"} //error
    var in printer = &data{"two"} //good
    in.print()

    m := map[string]data {"x":data{"three"}}
    m["x"].print() //error
}

Compile Errors:

/tmp/sandbox017696142/main.go:21: cannot use data literal (type data) as type printer in assignment: data does not implement printer (print method has pointer receiver) /tmp/sandbox017696142/main.go:25: cannot call pointer method on m[“x”] /tmp/sandbox017696142/main.go:25: cannot take the address of m[“x”]

58.更新 map 值字段

等级：高级

如果您有结构值映射，则无法更新单个结构字段。

Fails:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

type data struct {  
    name string
}

func main() {  
    m := map[string]data {"x":{"one"}}
    m["x"].name = "two" //error
}

Compile Error:

/tmp/sandbox380452744/main.go:9: cannot assign to m[“x”].name

它不起作用，因为map元素不可寻址。

说明：map 在内存中的存储结构与数组和指针不同，它是由哈希表实现的，每个键值对都有一个哈希值作为索引，用于快速查找数据。如果 map 可以寻址，那么它的哈希值就会发生变化，导致无法快速查找数据，从而破坏了 map 的内部结构。

而且，map 的大小是动态变化的，它可以根据添加或删除键值对来动态扩容或缩小。如果 map 可以寻址，那么它的内部结构就会发生变化，因此 Golang 的设计者禁止了 map 的寻址。

在 Golang 中，如果我们需要修改 map 或 slice 中的值，可以使用索引或者指针来进行操作。

对于新的 Go 开发者来说，更令人困惑的是 slice 元素是可寻址的。

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

import "fmt"

type data struct {  
    name string
}

func main() {  
    s := []data {{"one"}}
    s[0].name = "two" //ok
    fmt.Println(s)    //prints: [{two}]
}

请注意，不久前可以在其中一个 Go 编译器 (gccgo) 中更新map元素字段，但该行为很快得到修复 :-) 它也被认为是 Go 1.3 的潜在功能。在那个时候支持它还不够重要，所以它仍然在待办事项列表上。

第一个解决方法是使用临时变量。

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

import "fmt"

type data struct {  
    name string
}

func main() {  
    m := map[string]data {"x":{"one"}}
    r := m["x"]
    r.name = "two"
    m["x"] = r
    fmt.Printf("%v",m) //prints: map[x:{two}]
}

另一种解决方法是使用指针映射。

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

import "fmt"

type data struct {  
    name string
}

func main() {  
    m := map[string]*data {"x":{"one"}}
    m["x"].name = "two" //ok
    fmt.Println(m["x"]) //prints: &{two}
}

顺便说一句，当你运行这段代码时会发生什么？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package main

type data struct {  
    name string
}

func main() {  
    m := map[string]*data {"x":{"one"}}
    m["z"].name = "what?" //???
}

59.“nil”接口和“nil”接口值

等级：高级

这是 Go 中第二个最常见的问题，因为接口不是指针，即使它们看起来像指针。只有当它们的*类型和值字段为“nil”*时，接口变量才会为“nil”。

接口类型和值字段是根据用于创建相应接口变量的变量的类型和值填充的。当您尝试检查接口变量是否等于“nil”时，这可能会导致意外行为。

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

import "fmt"

func main() {  
    var data *byte
    var in interface{}

    fmt.Println(data,data == nil) //prints: <nil> true
    fmt.Println(in,in == nil)     //prints: <nil> true

    in = data
    fmt.Println(in,in == nil)     //prints: <nil> false
    //'data' is 'nil', but 'in' is not 'nil'
}

当您有一个返回接口的函数时，请注意这个陷阱。

Incorrect:

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

import "fmt"

func main() {  
    doit := func(arg int) interface{} {
        var result *struct{} = nil

        if(arg > 0) {
            result = &struct{}{}
        }

        return result
    }

    if res := doit(-1); res != nil {
        fmt.Println("good result:",res) //prints: good result: <nil>
        //'res' is not 'nil', but its value is 'nil'
    }
}

Works:

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

import "fmt"

func main() {  
    doit := func(arg int) interface{} {
        var result *struct{} = nil

        if(arg > 0) {
            result = &struct{}{}
        } else {
            return nil //return an explicit 'nil'
        }

        return result
    }

    if res := doit(-1); res != nil {
        fmt.Println("good result:",res)
    } else {
        fmt.Println("bad result (res is nil)") //here as expected
    }
}

60.堆栈和堆变量

等级：高级

您并不总是知道您的变量是分配在堆栈还是堆上。在 C++ 中，使用new运算符创建变量始终意味着您有一个堆变量。在 Go 中，即使使用new() or make()函数，编译器也会决定分配变量的位置。编译器根据变量的大小和“转义分析”的结果选择存储变量的位置。这也意味着可以返回对局部变量的引用，这在 C 或 C++ 等其他语言中是不行的。

如果您需要知道变量的分配位置，请将“-m”gc 标志传递给“go build”或“go run”（例如，go run -gcflags -m app.go）。

61.GOMAXPROCS、并发和并行

等级：高级

Go 1.4 及以下版本仅使用一个执行上下文/操作系统线程。这意味着在任何给定时间只能执行一个 goroutine。从 1.5 开始，Go 将执行上下文的数量设置为由runtime.NumCPU(). 该数字可能与系统上的逻辑 CPU 内核总数匹配，也可能不匹配，具体取决于进程的 CPU 亲和性设置。您可以通过更改GOMAXPROCS环境变量或调用runtime.GOMAXPROCS()函数来调整此数字。

有一个常见的误解是GOMAXPROCS表示 Go 将用于运行 goroutine 的 CPU 数量。runtime.GOMAXPROCS()功能文档更加混乱。GOMAXPROCS变量描述（https://golang.org/pkg/runtime/ ）在谈论操作系统线程方面做得更好。

您可以设置GOMAXPROCS为超过 CPU 的数量。从 1.10 开始，GOMAXPROCS 不再有限制。曾经的最大值GOMAXPROCS是 256，后来在 1.9 中增加到 1024。

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

import (  
    "fmt"
    "runtime"
)

func main() {  
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: X (1 on play.golang.org)
    fmt.Println(runtime.NumCPU())       //prints: X (1 on play.golang.org)
    runtime.GOMAXPROCS(20)
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 20
    runtime.GOMAXPROCS(300)
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 256
}

62.读写操作重新排序

等级：高级

Go 可能会重新排序某些操作，但它可以确保发生它的 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
27
28
29
30
31
32
package main

import (  
    "runtime"
    "time"
)

var _ = runtime.GOMAXPROCS(3)

var a, b int

func u1() {  
    a = 1
    b = 2
}

func u2() {  
    a = 3
    b = 4
}

func p() {  
    println(a)
    println(b)
}

func main() {  
    go u1()
    go u2()
    go p()
    time.Sleep(1 * time.Second)
}

If you run this code a few times you might see these a and b variable combinations:

1 2
3 4
0 2
0 0
1 4

The most interesting combination for a and b is “02”. It shows that b was updated before a.

如果您需要跨多个 goroutine 保持读写操作的顺序，则需要使用通道或“同步”包中的适当构造。

63.抢先调度

等级：高级

可能有一个流氓 goroutine 会阻止其他 goroutine 运行。如果您有一个for不允许调度程序运行的循环，则可能会发生这种情况。

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

import "fmt"

func main() {  
    done := false

    go func(){
        done = true
    }()

    for !done {
    }
    fmt.Println("done!")
}

for循环不必为空。只要它包含不触发调度程序执行的代码，它就会成为一个问题。

调度程序将在 GC、“go”语句、阻塞通道操作、阻塞系统调用和锁定操作之后运行。它也可以在调用非内联函数时运行。

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

import "fmt"

func main() {  
    done := false

    go func(){
        done = true
    }()

    for !done {
        fmt.Println("not done!") //not inlined
    }
    fmt.Println("done!")
}

要确定您在for循环中调用的函数是否内联，请将“-m”gc 标志传递给“go build”或“go run”（例如，go build -gcflags -m）。

另一种选择是显式调用调度程序。您可以使用Gosched()“运行时”包中的功能来完成。

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

import (  
    "fmt"
    "runtime"
)

func main() {  
    done := false

    go func(){
        done = true
    }()

    for !done {
        runtime.Gosched()
    }
    fmt.Println("done!")
}

请注意，上面的代码包含竞争条件。故意这样做是为了显示出问题的陷阱。

64.导入 C 和多行导入块

等级：CGO

您需要导入“C”包才能使用 Cgo。你可以用一行import来做，也可以用一个import块来做。

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

/*
#include <stdlib.h>
*/
import (
  "C"
)

import (
  "unsafe"
)

func main() {
  cs := C.CString("my go string")
  C.free(unsafe.Pointer(cs))
}

如果您使用import块格式，则不能在同一块中导入其他包。

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

/*
#include <stdlib.h>
*/
import (
  "C"
  "unsafe"
)

func main() {
  cs := C.CString("my go string")
  C.free(unsafe.Pointer(cs))
}

Compile Error:

./main.go:13:2: could not determine kind of name for C.free

65.Import C 和 Cgo 注释之间没有空行

等级：CGO

Cgo 的第一个陷阱之一是import “C"语句上方的 cgo 注释的位置。

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

/*
#include <stdlib.h>
*/

import "C"

import (
  "unsafe"
)

func main() {
  cs := C.CString("my go string")
  C.free(unsafe.Pointer(cs))
}

Compile Error:

./main.go:15:2: could not determine kind of name for C.free

确保声明上方没有任何空行import “C”。

66.不能使用可变参数调用 C 函数

等级：CGO

您不能直接调用带有可变参数的 C 函数。

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

/*
#include <stdio.h>
#include <stdlib.h>
*/
import "C"

import (
  "unsafe"
)

func main() {
  cstr := C.CString("go")
  C.printf("%s\n",cstr) //not ok
  C.free(unsafe.Pointer(cstr))
}

Compile Error:

./main.go:15:2: unexpected type: …

您必须将可变参数 C 函数包装在具有已知数量参数的函数中。

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

/*
#include <stdio.h>
#include <stdlib.h>

void out(char* in) {
  printf("%s\n", in);
}
*/
import "C"

import (
  "unsafe"
)

func main() {
  cstr := C.CString("go")
  C.out(cstr) //ok
  C.free(unsafe.Pointer(cstr))
}

目录

GO编程陷阱和常见错误

概述

1.不能将左大括号放在单独的行上

2.未使用的变量

3.未使用的 import

4.短变量声明只能在函数内部使用

5.使用短变量声明重新声明变量

6.不能使用短变量声明来设置字段值

7.变量覆盖（Variable Shadowing）

8.不能使用“nil”来初始化没有显式类型的变量

9.使用“nil”切片和映射

10.map 容量

11.字符串不能为“nil”

12.数组函数参数：数组指针类型

13.切片和数组“range”子句中的意外值

14.切片和数组是一维的

15.访问不存在的map的key

16.字符串是不可变的

17.字符串和字节片之间的转换

18.字符串和索引运算符

19.字符串并不总是 UTF8 文本

20.字符串长度

21.多行切片、数组和映射文字中缺少逗号

22.log.Fatal 和 log.Panic 不仅仅是日志

23.内置数据结构操作不同步

24.“range”子句中字符串的迭代值

25.使用“for range”子句遍历map

26.“switch”语句中的失败行为

27.增量和减量

28.按位非运算符

29.运算符优先级差异

30.未导出的结构字段未编码

31.带有活动 Goroutines 的应用程序退出

32.目标接收器准备好后立即返回到无缓冲通道

33.发送到关闭的通道会导致panic

34.使用“零”通道

35.带有值接收器的方法不能更改原始值

36.关闭 HTTP 响应正文

37.关闭 HTTP 连接

38.JSON 编码器添加换行符

39.JSON 包转义键和字符串值中的特殊 HTML 字符

40.将 JSON 数字解组为接口值

41.十六进制或其他非 UTF8 转义序列无法使用 JSON 字符串值

42.比较结构、数组、切片和映射

43.从 panic 中恢复（ recover ）

44.在切片、数组和映射“range”子句中更新和引用item值

45.切片中的“隐藏”数据

46.切片数据覆盖

47.切片中的*“旧数据”*

48.类型声明和方法

49. 从“for switch”和“for select”代码块中 break

50.“for”语句中的迭代变量和闭包

51.延迟函数调用参数评估

52.延迟函数调用执行

53.失败的类型断言

54.阻塞的 Goroutines 和资源泄漏

55.不同零大小变量的相同地址

56.iota 的首次使用并不总是从零开始

57.在值实例上使用指针接收器方法

58.更新 map 值字段

59.“nil”接口和“nil”接口值

60.堆栈和堆变量

61.GOMAXPROCS、并发和并行

62.读写操作重新排序

63.抢先调度

64.导入 C 和多行导入块

65.Import C 和 Cgo 注释之间没有空行

66.不能使用可变参数调用 C 函数

原文参考

47.切片中的“旧数据”