概述
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 确实有分号 :-)
失败:
编译错误:
/tmp/sandbox826898458/main.go:6:语法错误:意外的分号或换行符之前 {
正确方式:
2.未使用的变量
级别:初学者
如果您有一个未使用的变量,您的代码将无法编译。不过有一个例外。您必须使用在函数内部声明的变量,但如果您有未使用的全局变量,也可以。有未使用的函数参数也是可以的。
如果您为未使用的变量分配新值,您的代码仍将无法编译。您需要以某种方式使用变量值来使编译器满意。
失败:
编译错误:
/tmp/sandbox473116179/main.go:6: 一个已声明但未使用 /tmp/sandbox473116179/main.go:7: 两个已声明但未使用 /tmp/sandbox473116179/main.go:8: 三个已声明但未使用
正确方式:
另一种选择是注释掉或删除未使用的变量:-)
3.未使用的 import
级别:初学者
如果您在不使用任何导出函数、接口、结构或变量的情况下导入包,您的代码将无法编译。
如果您确实需要导入的包,可以使用空白标识符_, 作为其包名,以避免编译失败。空白标识符用于导入包的副作用。
失败:
编译错误:
/tmp/sandbox627475386/main.go:4:导入但未使用:“fmt”/tmp/sandbox627475386/main.go:5:导入但未使用:“log”/tmp/sandbox627475386/main.go:6:导入而未使用:“时间”
正确方式:
另一种选择是删除或注释掉未使用的导入 :-) 该 goimports工具可以帮助您。
4.短变量声明只能在函数内部使用
级别:初学者
失败:
package main
myvar := 1 //error
func main() {
}
编译错误:
/tmp/sandbox265716165/main.go:3:函数体外的非声明语句
正确方式:
5.使用短变量声明重新声明变量
级别:初学者
您不能在独立语句中重新声明变量,但在至少声明一个新变量的多变量声明中是允许的。
重新声明的变量必须在同一个块中,否则您最终会得到一个阴影变量。
失败:
编译错误:
/tmp/sandbox706333626/main.go:5: := 左侧没有新变量
正确方式:
6.不能使用短变量声明来设置字段值
级别:初学者
失败:
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)
}
编译错误:
prog.go:18: non-name data.result on left side of :=
使用临时变量或预先声明所有变量并使用标准赋值运算符。
正确方式:
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)
级别:初学者
简短的变量声明语法非常方便(特别是对于那些来自动态语言的语言),很容易将其视为常规赋值操作。如果您在新代码块中犯了这个错误,则不会出现编译器错误,但您的应用程序不会按照您的预期执行。
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”标识符可用作接口、函数、指针、映射、切片和通道的“零值”。如果您不指定变量类型,编译器将无法编译您的代码,因为它无法猜测类型。
失败:
package main
func main() {
var x = nil //error
_ = x
}
编译错误:
/tmp/sandbox188239583/main.go:4: 使用无类型 nil
正确方式:
package main
func main() {
var x interface{} = nil
_ = x
}
9.使用“nil”切片和映射
级别:初学者
可以将元素添加到“nil”切片,但对 map 执行相同操作会产生运行时panic 。
正确:
package main
func main() {
var s []int
s = append(s,1)
}
失败:
package main
func main() {
var m map[string]int
m["one"] = 1 //error
}
10.map 容量
级别:初学者
您可以在创建 map 时指定容量,但不能使用cap(map)函数计算容量。
失败:
编译错误:
/tmp/sandbox326543983/main.go:5: cap 的无效参数 m (type map[string]int)
11.字符串不能为“nil”
级别:初学者
对于习惯于将“nil”标识符分配给字符串变量的开发人员来说,这是一个陷阱。
失败:
package main
func main() {
var x string = nil //error
if x == nil { //error
x = "default"
}
}
编译错误:
/tmp/sandbox630560459/main.go:4:不能在赋值中使用 nil 作为类型字符串 /tmp/sandbox630560459/main.go:6:无效操作:x == nil(不匹配的类型字符串和 nil)
正确方式:
package main
func main() {
var x string //defaults to "" (zero value)
if x == "" {
x = "default"
}
}
12.数组函数参数:数组指针类型
级别:初学者
如果您是 C 或 C++ 开发人员,那么您的数组就是指针。当您将数组传递给函数时,函数引用相同的内存位置,因此它们可以更新原始数据。Go 中的数组是值,因此当您将数组传递给函数时,函数会获取原始数组数据的副本。如果您尝试更新数组数据,这可能是个问题。
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])
}
如果您需要更新原始数组数据,请使用数组指针类型。
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]
}
另一种选择是使用切片。即使您的函数获得了切片变量的副本,它仍然引用原始数据。
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.切片和数组“范围”子句中的意外值
级别:初学者
如果您习惯了其他语言中的“for-in”或“foreach”语句,就会发生这种情况。Go 中的“范围”子句是不同的。它生成两个值:第一个值是项目索引,而第二个值是项目数据。
坏的:
package main
import "fmt"
func main() {
x := []string{"a","b","c"}
for v := range x {
fmt.Println(v) //prints 0, 1, 2
}
}
好的:
package main
import "fmt"
func main() {
x := []string{"a","b","c"}
for _, v := range x {
fmt.Println(v) //prints a, b, c
}
}
14.切片和数组是一维的
级别:初学者
看起来 Go 似乎支持多维数组和切片,但事实并非如此。但是,可以创建数组数组或切片切片。对于依赖动态多维数组的数值计算应用程序,它在性能和复杂性方面远非理想。
您可以使用原始一维数组、“独立”切片的切片和“共享数据”切片的切片来构建动态多维数组。
如果您使用原始一维数组,您需要在数组需要增长时负责索引、边界检查和内存重新分配。
使用“独立”切片的切片创建动态多维数组是一个两步过程。首先,您必须创建外部切片。然后,您必须分配每个内部切片。内部切片彼此独立。您可以在不影响其他内部切片的情况下扩展和收缩它们。
package main
func main() {
x := 2
y := 4
table := make([][]int,x)
for i:= range table {
table[i] = make([]int,y)
}
}
使用“共享数据”切片创建动态多维数组是一个三步过程。首先,您必须创建将保存原始数据的数据“容器”切片。然后,您创建外部切片。最后,通过重新切片原始数据切片来初始化每个内部切片。
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.访问不存在的映射键
级别:初学者
对于希望获得“nil”标识符的开发人员来说,这是一个陷阱(就像在其他语言中所做的那样)。如果相应数据类型的“零值”为“nil”,则返回值为“nil”,但对于其他数据类型则不同。检查适当的“零值”可用于确定映射记录是否存在,但它并不总是可靠的(例如,如果您有一个布尔映射,其中“零值”为假,您会怎么做)。了解给定地图记录是否存在的最可靠方法是检查地图访问操作返回的第二个值。
坏的:
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")
}
}
好的:
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.字符串是不可变的
级别:初学者
尝试使用索引运算符更新字符串变量中的单个字符将导致失败。字符串是只读字节切片(带有一些额外的属性)。如果确实需要更新字符串,则在必要时使用字节切片而不是将其转换为字符串类型。
失败:
package main
import "fmt"
func main() {
x := "text"
x[0] = 'T'
fmt.Println(x)
}
编译错误:
/tmp/sandbox305565531/main.go:7: 不能分配给 x[0]
正确方式:
package main
import "fmt"
func main() {
x := "text"
xbytes := []byte(x)
xbytes[0] = 'T'
fmt.Println(string(xbytes)) //prints Text
}
请注意,这实际上并不是更新文本字符串中字符的正确方法,因为给定的字符可以存储在多个字节中。如果您确实需要对文本字符串进行更新,请先将其转换为符文切片。即使使用符文切片,单个字符也可能跨越多个符文,例如,如果您有带有重音的字符,就会发生这种情况。“字符”的这种复杂和模棱两可的性质是 Go 字符串被表示为字节序列的原因。
17.字符串和字节片之间的转换
级别:初学者
当您将字符串转换为字节切片(反之亦然)时,您将获得原始数据的完整副本。它不像其他语言中的强制转换操作,也不像重新切片新切片变量指向原始字节切片使用的相同底层数组的位置。
Go 确实对[]bytetostring和stringto[]byte转换进行了一些优化,以避免额外的分配(对 todo 列表进行了更多优化)。
当[]byte键用于查找map[string]集合中的条目时,第一个优化避免了额外的分配:m[string(key)].
第二个优化避免了for range字符串转换为[]byte:的子句中的额外分配for i,v := range []byte(str) {...}。
18.字符串和索引运算符
级别:初学者
字符串上的索引运算符返回一个字节值,而不是一个字符(就像在其他语言中所做的那样)。
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”包中的函数。
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 开发人员,并且您有以下代码:
data = u'♥'
print(len(data)) #prints: 1
当您将其转换为类似的 Go 代码片段时,您可能会感到惊讶。
package main
import "fmt"
func main() {
data := "♥"
fmt.Println(len(data)) //prints: 3
}
内置len()函数返回字节数,而不是像 Python 中的 unicode 字符串那样返回字符数。
要在 Go 中获得相同的结果,请使用 RuneCountInString() “unicode/utf8”包中的函数。
package main
import (
"fmt"
"unicode/utf8"
)
func main() {
data := "♥"
fmt.Println(utf8.RuneCountInString(data)) //prints: 1
从技术上讲,该RuneCountInString()函数不返回字符数,因为单个字符可能跨越多个符文。
package main
import (
"fmt"
"unicode/utf8"
)
func main() {
data := "é"
fmt.Println(len(data)) //prints: 3
fmt.Println(utf8.RuneCountInString(data)) //prints: 2
}
21.多行切片、数组和映射文字中缺少逗号
级别:初学者
失败:
package main
func main() {
x := []int{
1,
2 //error
}
_ = x
}
编译错误:
/tmp/sandbox367520156/main.go:6:语法错误:复合文字中的换行符之前需要尾随逗号/tmp/sandbox367520156/main.go:8:函数体外的非声明语句/tmp/sandbox367520156/main.go:9 :语法错误:意外}
正确方式:
package main
func main() {
x := []int{
1,
2,
}
x = x
y := []int{3,4,} //no error
y = y
}
如果在将声明折叠为一行时留下尾随逗号,则不会出现编译器错误。
22.log.Fatal 和 log.Panic 不仅仅是日志
级别:初学者
日志库通常提供不同的日志级别。Fatal*()不像那些日志库,如果你调用它的和Panic*()函数,Go 中的日志包不仅仅做日志。当您的应用调用这些函数时,Go 也会终止您的应用 :-)
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.“范围”子句中字符串的迭代值
级别:初学者
索引值(“范围”操作返回的第一个值)是第二个值中返回的当前“字符”(unicode 代码点/符文)的第一个字节的索引。它不是当前“字符”的索引,就像在其他语言中所做的那样。请注意,一个实际角色可能由多个符文表示。如果您需要使用字符,请务必查看“规范”包 (golang.org/x/text/unicode/norm)。
带有字符串变量的for range子句将尝试将数据解释为 UTF8 文本。对于它不理解的任何字节序列,它将返回 0xfffd 符文(又名 unicode 替换字符)而不是实际数据。如果您在字符串变量中存储了任意(非 UTF8 文本)数据,请确保将它们转换为字节切片以按原样获取所有存储的数据。
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 运行时尝试将迭代顺序随机化,但它并不总是成功,因此您可能会得到几个相同的地图迭代。连续看到 5 次相同的迭代不要感到惊讶。
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”块。
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”块中使用表达式列表。
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 不支持操作的前缀版本。您也不能在表达式中使用这两个运算符。
失败:
package main
import "fmt"
func main() {
data := []int{1,2,3}
i := 0
++i //error
fmt.Println(data[i++]) //error
}
编译错误:
/tmp/sandbox101231828/main.go:8:语法错误:意外 ++ /tmp/sandbox101231828/main.go:9:语法错误:意外 ++,预期:
正确方式:
package main
import "fmt"
func main() {
data := []int{1,2,3}
i := 0
i++
fmt.Println(data[i])
}
28.按位非运算符
级别:初学者
许多语言使用~一元 NOT 运算符(也称为按位补码),但 Go 重用了 XOR 运算符 ( ^)。
失败:
package main
import "fmt"
func main() {
fmt.Println(~2) //error
}
编译错误:
/tmp/sandbox965529189/main.go:6:按位补码运算符是 ^
正确方式:
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。
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 有一组标准操作符,许多其他语言都共享这些操作符。但是,运算符的优先级并不总是相同的。
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 等)编码,因此当您解码结构时,您最终会在那些未导出的字段中得到零值。
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 完成。对于一般初学者来说,这是一个常见的错误。每个人都从某个地方开始,所以犯新手错误并不可耻:-)
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)
}
你会看到的:
[0] 正在运行
[1] 正在运行
全部完成!
最常见的解决方案之一是使用“WaitGroup”变量。它将允许主 goroutine 等待,直到所有工作 goroutine 完成。如果您的应用程序有长时间运行的带有消息处理循环的工作人员,您还需要一种方法来通知这些 goroutine 是时候退出了。您可以向每个工作人员发送“杀死”消息。另一种选择是关闭所有工人正在接收的频道。这是一次向所有 goroutine 发出信号的简单方法。
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] 正在运行
[0] 已完成
[1] 正在运行
[1] 已完成
看起来工作人员在主 goroutine 退出之前就完成了。但是! 您还会看到:
致命错误:所有 goroutine 都处于休眠状态 - 死锁!
那不是很好:-) 发生了什么事?为什么会出现死锁?工人们离开了,他们被处决了wg.Done()。该应用程序应该可以工作。
发生死锁是因为每个工作人员都获得了原始“WaitGroup”变量的副本。当工作人员执行wg.Done()时,它对主 goroutine 中的“WaitGroup”变量没有影响。
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 可能有也可能没有足够的时间在发送者继续执行之前处理消息。
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.
将数据发送到关闭的通道会导致恐慌。这是一个记录在案的行为,但对于可能期望发送行为类似于接收行为的新 Go 开发人员来说,这并不是很直观。
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)
}
根据您的应用程序,修复会有所不同。这可能是一个小的代码更改,或者可能需要更改您的应用程序设计。无论哪种方式,您都需要确保您的应用程序不会尝试将数据发送到关闭的通道。
错误示例可以通过使用特殊的取消通道来向剩余的工作人员发出不再需要他们的结果的信号来修复。
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 开发人员来说可能是一个惊喜。
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
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.带有值接收器的方法不能更改原始值
级别:初学者
方法接收器就像常规函数参数。如果它被声明为一个值,那么您的函数/方法将获得您的接收器参数的副本。这意味着对接收器进行更改不会影响原始值,除非您的接收器是映射或切片变量,并且您正在更新集合中的项目或者您在接收器中更新的字段是指针。
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 开发人员确实尝试关闭响应体,但他们做错了地方。
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 响应错误检查之后使用调用。
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变量将为. 但是,当您遇到重定向失败时,两个变量都将是. 这意味着您仍然可能会出现泄漏。nilerrnon-nilnon-nil
non-nil您可以通过在 http 响应错误处理块中添加关闭响应主体的调用来修复此泄漏。另一种选择是使用一次defer调用来关闭所有失败和成功请求的响应主体。
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 连接对您的应用程序很重要,您可能需要在响应处理逻辑的末尾添加类似这样的内容:
_, err = io.Copy(ioutil.Discard, resp.Body)
如果您不立即阅读整个响应正文,则有必要这样做,如果您使用如下代码处理 json API 响应,则可能会发生这种情况:
json.NewDecoder(resp.Body).Decode(&data)
37.关闭 HTTP 连接
等级:中级
一些 HTTP 服务器保持网络连接打开一段时间(基于 HTTP 1.1 规范和服务器“保持活动”配置)。默认情况下,标准 http 库仅在目标 HTTP 服务器请求时才会关闭网络连接。这意味着您的应用程序可能会在某些情况下用完套接字/文件描述符。
您可以通过将Close请求变量中的字段设置为 来要求 http 库在请求完成后关闭连接true。
另一种选择是添加Connection请求标头并将其设置为close. 目标 HTTP 服务器也应该使用Connection: close标头响应。当 http 库看到这个响应头时,它也会关闭连接。
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 传输配置。
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 对象的末尾获得一个额外的换行符。
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。
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 而失败:
运行时panic:
panic:接口转换:接口是float64,而不是int
如果您尝试解码的 JSON 值是一个整数,那么您有多个选项。
选项一:按原样使用浮点值:-)
选项二:将浮点值转换为您需要的整数类型。
选项三:使用一种类型来解组 JSON,并告诉它使用接口类型Decoder来表示 JSON 数字。Number
您可以使用Number值的字符串表示形式将其解组为不同的数字类型:
选项四:使用struct将您的数值映射到您需要的数值类型的类型。
选项五:如果您需要延迟值解码,请使用struct将您的数值映射到类型的 a。json.RawMessage
如果您必须在字段类型或结构可能发生变化的情况下执行条件 JSON 字段解码,则此选项很有用。
41.十六进制或其他非 UTF8 转义序列无法使用 JSON 字符串值
59.“nil”接口和“nil”接口值
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。