使用 Go 编程语言 66 个陷阱：Golang 开发者的陷阱和常见错误指北
Posted 禅与计算机程序设计艺术
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了使用 Go 编程语言 66 个陷阱：Golang 开发者的陷阱和常见错误指北相关的知识，希望对你有一定的参考价值。
概述
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 确实有分号 :-)
失败：
package main
import "fmt"
func main()
//error, can't have the opening brace on a separate line
fmt.Println("hello there!")
编译错误：
/tmp/sandbox826898458/main.go:6：语法错误：意外的分号或换行符之前
正确方式：
package main
import "fmt"
func main()
fmt.Println("works!")
2.未使用的变量
级别：初学者
如果您有一个未使用的变量，您的代码将无法编译。不过有一个例外。您必须使用在函数内部声明的变量，但如果您有未使用的全局变量，也可以。有未使用的函数参数也是可以的。
如果您为未使用的变量分配新值，您的代码仍将无法编译。您需要以某种方式使用变量值来使编译器满意。
失败：
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?")
编译错误：
/tmp/sandbox473116179/main.go:6: 一个已声明但未使用 /tmp/sandbox473116179/main.go:7: 两个已声明但未使用 /tmp/sandbox473116179/main.go:8: 三个已声明但未使用
正确方式：
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
另一种选择是注释掉或删除未使用的变量:-)
3.未使用的 import
级别：初学者
如果您在不使用任何导出函数、接口、结构或变量的情况下导入包，您的代码将无法编译。
如果您确实需要导入的包，可以使用空白标识符_, 作为其包名，以避免编译失败。空白标识符用于导入包的副作用。
失败：
package main
import (
"fmt"
"log"
"time"
)
func main()
编译错误：
/tmp/sandbox627475386/main.go:4：导入但未使用：“fmt”/tmp/sandbox627475386/main.go:5：导入但未使用：“log”/tmp/sandbox627475386/main.go:6：导入而未使用：“时间”
正确方式：
package main
import (
_ "fmt"
"log"
"time"
)
var _ = log.Println
func main()
_ = time.Now
另一种选择是删除或注释掉未使用的导入 :-) 该 goimports工具可以帮助您。
4.短变量声明只能在函数内部使用
级别：初学者
失败：
package main
myvar := 1 //error
func main()
编译错误：
/tmp/sandbox265716165/main.go:3：函数体外的非声明语句
正确方式：
package main
var myvar = 1
func main()
5.使用短变量声明重新声明变量
级别：初学者
您不能在独立语句中重新声明变量，但在至少声明一个新变量的多变量声明中是允许的。
重新声明的变量必须在同一个块中，否则您最终会得到一个阴影变量。
失败：
package main
func main()
one := 0
one := 1 //error
编译错误：
/tmp/sandbox706333626/main.go:5: := 左侧没有新变量
正确方式：
package main
func main()
one := 0
one, two := 1,2
one,two = two,one
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)函数计算容量。
失败：
package main
func main()
m := make(map[string]int,99)
cap(m) //error
编译错误：
/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]int1,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]int1,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 := []int1,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 := []int3,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 := []int1,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 := []int1,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 := MyData1,"two"
fmt.Printf("%#v\\n",in) //prints main.MyDataOne: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.MyDataOne: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)
[翻译]Go的50坑：新Golang开发者要注意的陷阱技巧和常见错误[1]
Go的50度灰：Golang新开发者要注意的陷阱和常见错误（转）