前言
Go 是一门简单有趣的编程语言，与其他语言一样，在使用时不免会遇到很多坑，不过它们大多不是 Go 本身的设计缺陷。如果你刚从其他语言转到 Go，那这篇文章里的坑多半会踩到。
如果花时间学习官方 doc、wiki、讨论邮件列表、 Rob Pike 的大量文章以及 Go 的源码，会发现这篇文章中的坑是很常见的，新手跳过这些坑，能减少大量调试代码的时间。
{{;)// 错误示例// 错误示例func main() func main() {{ println("hello world") println("hello world")}}// 等效于// 等效于func main(); // 无函数体 func main(); // 无函数体 {{ println("hello world") println("hello world")}}./main.go: missing function body ./main.go: syntax error: unexpected semicolon or newline before {
// 正确示例// 正确示例func main() {func main() { println("hello world") println("hello world")} } 2. 未使用的变量
如果在函数体代码中有未使用的变量，则无法通过编译，不过全局变量声明但不使用是可以的。
即使变量声明后为变量赋值，依旧无法通过编译，需在某处使用它：
// 错误示例// 错误示例var gvar int // 全局变量，声明不使用也可以var gvar int // 全局变量，声明不使用也可以func main() {func main() { var one int // error: one declared and not used var one int // error: one declared and not used two := 2 // error: two declared and not used two := 2 // error: two declared and not used var three int // error: three declared and not used var three int // error: three declared and not used three = 3 three = 3 }}// 正确示例// 正确示例// 可以直接注释或移除未使用的变量// 可以直接注释或移除未使用的变量func main() {func main() { var one int var one int _ = one _ = one two := 2 two := 2 println(two) println(two) var three int var three int one = three one = three var four int var four int four = four four = four}}3. 未使用的 import
如果你 import 一个包，但包中的变量、函数、接口和结构体一个都没有用到的话，将编译失败。
_init()// 错误示例// 错误示例import(import( "fmt" // imported and not used: "fmt" "fmt" // imported and not used: "fmt" "log" // imported and not used: "log" "log" // imported and not used: "log" "time" // imported and not used: "time" "time" // imported and not used: "time"))func main() {func main() {}}// 正确示例// 正确示例// 可以使用 goimports 工具来注释或移除未使用到的包// 可以使用 goimports 工具来注释或移除未使用到的包import(import( _ "fmt" _ "fmt" "log" "log" "time" "time"))func main() {func main() { _ = log.Println _ = log.Println _ = time.Now _ = time.Now}}4. 简短声明的变量只能在函数内部使用
// 错误示例// 错误示例myvar := 1 // syntax error: non-declaration statement outside function bodymyvar := 1 // syntax error: non-declaration statement outside function bodyfunc main() {func main() {}}// 正确示例// 正确示例var myvar = 1var myvar = 1func main() {func main() {}}5. 使用简短声明来重复声明变量
:=// 错误示例// 错误示例func main() { func main() { one := 0 one := 0 one := 1// error: no new variables on left side of := one := 1// error: no new variables on left side of :=}}// 正确示例// 正确示例func main() {func main() { one := 0 one := 0 one, two := 1, 2 // two 是新变量，允许 one 的重复声明。比如 error 处理经常用同名变量 err one, two := 1, 2 // two 是新变量，允许 one 的重复声明。比如 error 处理经常用同名变量 err one, two = two, one // 交换两个变量值的简写 one, two = two, one // 交换两个变量值的简写}}6. 不能使用简短声明来设置字段的值
:=// 错误示例// 错误示例type info struct{type info struct{ result int result int}}func work() (int, error) {func work() (int, error) { return3, nil return3, nil}}func main() {func main() { var data info var data info data.result, err := work() // error: non-name data.result on left side of := data.result, err := work() // error: non-name data.result on left side of := fmt.Printf("info: %+v\n", data) fmt.Printf("info: %+v\n", data)}}// 正确示例// 正确示例func main() {func main() { var data info var data info var err error // err 需要预声明 var err error // err 需要预声明 data.result, err = work() data.result, err = work() if err != nil{ if err != nil{ fmt.Println(err) fmt.Println(err) return return } } fmt.Printf("info: %+v\n", data) fmt.Printf("info: %+v\n", data)}}7. 不小心覆盖了变量
:=:=func main() {func main() { x := 1 x := 1 println(x) // 1 println(x) // 1 { { println(x) // 1 println(x) // 1 x := 2 x := 2 println(x) // 2 // 新的 x 变量的作用域只在代码块内部 println(x) // 2 // 新的 x 变量的作用域只在代码块内部 } } println(x) // 1 println(x) // 1}}这是 Go 开发者常犯的错，而且不易被发现。
-shadow> go tool vet -shadow main.go> go tool vet -shadow main.gomain.go:9: declaration of "x" shadows declaration at main.go:5main.go:9: declaration of "x" shadows declaration at main.go:5注意 vet 不会报告全部被覆盖的变量，可以使用 go-nyet 来做进一步的检测：
> $GOPATH/bin/go-nyet main.go> $GOPATH/bin/go-nyet main.gomain.go:10:3:Shadowing variable `x`main.go:10:3:Shadowing variable `x`8. 显式类型的变量无法使用 nil 来初始化
nil// 错误示例// 错误示例func main() {func main() { var x = nil // error: use of untyped nil var x = nil // error: use of untyped nil _ = x _ = x}}// 正确示例// 正确示例func main() {func main() { var x interface{} = nil var x interface{} = nil _ = x _ = x} } 9. 直接使用值为 nil 的 slice、map
允许对值为 nil 的 slice 添加元素，但对值为 nil 的 map 添加元素则会造成运行时 panic
// map 错误示例// map 错误示例func main() {func main() { var m map[string]int var m map[string]int m["one"] = 1 // error: panic: assignment to entry in nil map m["one"] = 1 // error: panic: assignment to entry in nil map // m := make(map[string]int)// map 的正确声明，分配了实际的内存 // m := make(map[string]int)// map 的正确声明，分配了实际的内存} } // slice 正确示例// slice 正确示例func main() {func main() { var s []int var s []int s = append(s, 1) s = append(s, 1)}}10. map 容量
cap()// 错误示例// 错误示例func main() {func main() { m := make(map[string]int, 99) m := make(map[string]int, 99) println(cap(m)) // error: invalid argument m1 (type map[string]int) for cap println(cap(m)) // error: invalid argument m1 (type map[string]int) for cap } } 11. string 类型的变量值不能为 nil
nil// 错误示例// 错误示例func main() {func main() { var s string= nil // cannot use nil as type string in assignment var s string= nil // cannot use nil as type string in assignment if s == nil{ // invalid operation: s == nil (mismatched types string and nil) if s == nil{ // invalid operation: s == nil (mismatched types string and nil) s = "default" s = "default" } }}}// 正确示例// 正确示例func main() {func main() { var s string // 字符串类型的零值是空串 "" var s string // 字符串类型的零值是空串 "" if s == ""{ if s == ""{ s = "default" s = "default" } }}}12. Array 类型的值作为函数参数
在 C/C++ 中，数组(名)是指针。将数组作为参数传进函数时，相当于传递了数组内存地址的引用，在函数内部会改变该数组的值。
在 Go 中，数组是值。作为参数传进函数时，传递的是数组的原始值拷贝，此时在函数内部是无法更新该数组的：
// 数组使用值拷贝传参// 数组使用值拷贝传参func main() {func main() { x := [3]int{1,2,3} x := [3]int{1,2,3} func(arr [3]int) { func(arr [3]int) { arr[0] = 7 arr[0] = 7 fmt.Println(arr) // [7 2 3] fmt.Println(arr) // [7 2 3] }(x) }(x) fmt.Println(x) // [1 2 3] // 并不是你以为的 [7 2 3] fmt.Println(x) // [1 2 3] // 并不是你以为的 [7 2 3]}}如果想修改参数数组：
1、直接传递指向这个数组的指针类型
// 传址会修改原数据// 传址会修改原数据func main() {func main() { x := [3]int{1,2,3} x := [3]int{1,2,3} func(arr *[3]int) { func(arr *[3]int) { (*arr)[0] = 7 (*arr)[0] = 7 fmt.Println(arr) // &[7 2 3] fmt.Println(arr) // &[7 2 3] }(&x) }(&x) fmt.Println(x) // [7 2 3] fmt.Println(x) // [7 2 3]}}2、直接使用 slice：即使函数内部得到的是 slice 的值拷贝，但依旧会更新 slice 的原始数据(底层 array)
// 会修改 slice 的底层 array，从而修改 slice// 会修改 slice 的底层 array，从而修改 slicefunc main() {func main() { x := []int{1, 2, 3} x := []int{1, 2, 3} func(arr []int) { func(arr []int) { arr[0] = 7 arr[0] = 7 fmt.Println(x) // [7 2 3] fmt.Println(x) // [7 2 3] }(x) }(x) fmt.Println(x) // [7 2 3] fmt.Println(x) // [7 2 3]}}13. range 遍历 slice 和 array 时混淆了返回值
for-inforeachrange// 错误示例// 错误示例func main() {func main() { x := []string{"a", "b", "c"} x := []string{"a", "b", "c"} for v := range x { for v := range x { fmt.Println(v) // 1 2 3 fmt.Println(v) // 1 2 3 } }}}// 正确示例// 正确示例func main() {func main() { x := []string{"a", "b", "c"} x := []string{"a", "b", "c"} for _, v := range x { // 使用 _ 丢弃索引 for _, v := range x { // 使用 _ 丢弃索引 fmt.Println(v) fmt.Println(v) } }}}14. slice 和 array 其实是一维数据
看起来 Go 支持多维的 array 和 slice，可以创建数组的数组、切片的切片，但其实并不是。
对依赖动态计算多维数组值的应用来说，就性能和复杂度而言，用 Go 实现的效果并不理想。
可以使用原始的一维数组、“独立“ 的切片、“共享底层数组”的切片来创建动态的多维数组。
1、使用原始的一维数组：要做好索引检查、溢出检测、以及当数组满时再添加值时要重新做内存分配。
2、使用“独立”的切片分两步：
创建外部 slice
对每个内部 slice 进行内存分配(注意内部的 slice 相互独立，使得任一内部 slice 增缩都不会影响到其他的 slice)
// 使用各自独立的 6 个 slice 来创建 [2][3] 的动态多维数组// 使用各自独立的 6 个 slice 来创建 [2][3] 的动态多维数组func main() {func main() { x := 2 x := 2 y := 4 y := 4 table := make([][]int, x) table := make([][]int, x) for i := range table { for i := range table { table[i] = make([]int, y) table[i] = make([]int, y) } }}}3、使用“共享底层数组”的切片
创建一个存放原始数据的容器 slice
创建其他的 slice
切割原始 slice 来初始化其他的 slice
func main() {func main() { h, w := 2, 4 h, w := 2, 4 raw := make([]int, h*w) raw := make([]int, h*w) for i := range raw { for i := range raw { raw[i] = i raw[i] = i } } // 初始化原始 slice // 初始化原始 slice fmt.Println(raw, &raw[4]) // [0 1 2 3 4 5 6 7] 0xc420012120 fmt.Println(raw, &raw[4]) // [0 1 2 3 4 5 6 7] 0xc420012120 table := make([][]int, h) table := make([][]int, h) for i := range table { for i := range table { // 等间距切割原始 slice，创建动态多维数组 table // 等间距切割原始 slice，创建动态多维数组 table // 0: raw[0*4: 0*4 + 4] // 0: raw[0*4: 0*4 + 4] // 1: raw[1*4: 1*4 + 4] // 1: raw[1*4: 1*4 + 4] table[i] = raw[i*w : i*w + w] table[i] = raw[i*w : i*w + w] } } fmt.Println(table, &table[1][0]) // [[0 1 2 3] [4 5 6 7]] 0xc420012120 fmt.Println(table, &table[1][0]) // [[0 1 2 3] [4 5 6 7]] 0xc420012120}}更多关于多维数组的参考：
go-how-is-two-dimensional-arrays-memory-representation
what-is-a-concise-way-to-create-a-2d-slice-in-go
15. 访问 map 中不存在的 key
和其他编程语言类似，如果访问了 map 中不存在的 key 则希望能返回 nil，比如在 PHP 中：
> php -r '$v = ["x"=>1, "y"=>2]; @var_dump($v["z"]);'> php -r '$v = ["x"=>1, "y"=>2]; @var_dump($v["z"]);'NULLNULLnil''false检查 key 是否存在可以用 map 直接访问，检查返回的第二个参数即可：
// 错误的 key 检测方式// 错误的 key 检测方式func main() {func main() { x := map[string]string{"one": "2", "two": "", "three": "3"} x := map[string]string{"one": "2", "two": "", "three": "3"} if v := x["two"]; v == ""{ if v := x["two"]; v == ""{ fmt.Println("key two is no entry") // 键 two 存不存在都会返回的空字符串 fmt.Println("key two is no entry") // 键 two 存不存在都会返回的空字符串 } }}}// 正确示例// 正确示例func main() {func main() { x := map[string]string{"one": "2", "two": "", "three": "3"} x := map[string]string{"one": "2", "two": "", "three": "3"} if _, ok := x["two"]; !ok { if _, ok := x["two"]; !ok { fmt.Println("key two is no entry") fmt.Println("key two is no entry") } }}}16. string 类型的值是常量，不可更改
尝试使用索引遍历字符串，来更新字符串中的个别字符，是不允许的。
string 类型的值是只读的二进制 byte slice，如果真要修改字符串中的字符，将 string 转为 []byte 修改后，再转为 string 即可：
// 修改字符串的错误示例// 修改字符串的错误示例func main() {func main() { x := "text" x := "text" x[0] = "T" // error: cannot assign to x[0] x[0] = "T" // error: cannot assign to x[0] fmt.Println(x) fmt.Println(x)}}// 修改示例// 修改示例func main() {func main() { x := "text" x := "text" xBytes := []byte(x) xBytes := []byte(x) xBytes[0] = 'T'// 注意此时的 T 是 rune 类型 xBytes[0] = 'T'// 注意此时的 T 是 rune 类型 x = string(xBytes) x = string(xBytes) fmt.Println(x) // Text fmt.Println(x) // Text}}注意： 上边的示例并不是更新字符串的正确姿势，因为一个 UTF8 编码的字符可能会占多个字节，比如汉字就需要 3~4 个字节来存储，此时更新其中的一个字节是错误的。
更新字串的正确姿势：将 string 转为 rune slice(此时 1 个 rune 可能占多个 byte)，直接更新 rune 中的字符。
func main() {func main() { x := "text" x := "text" xRunes := []rune(x) xRunes := []rune(x) xRunes[0] = '我' xRunes[0] = '我' x = string(xRunes) x = string(xRunes) fmt.Println(x) // 我ext fmt.Println(x) // 我ext}}17. string 与 byte slice 之间的转换
当进行 string 和 byte slice 相互转换时，参与转换的是拷贝的原始值。这种转换的过程，与其他编程语的强制类型转换操作不同，也和新 slice 与旧 slice 共享底层数组不同。
Go 在 string 与 byte slice 相互转换上优化了两点，避免了额外的内存分配：
map[string][]bytem[string(key)]forrangefori,v:=range[]byte(str){...}雾：参考原文
18. string 与索引操作符
对字符串用索引访问返回的不是字符，而是一个 byte 值。
这种处理方式和其他语言一样，比如 PHP 中：
> php -r '$name="中文"; var_dump($name);' # "中文" 占用 6 个字节> php -r '$name="中文"; var_dump($name);' # "中文" 占用 6 个字节string(6) "中文"string(6) "中文"> php -r '$name="中文"; var_dump($name[0]);'# 把第一个字节当做 Unicode 字符读取，显示 U+FFFD> php -r '$name="中文"; var_dump($name[0]);'# 把第一个字节当做 Unicode 字符读取，显示 U+FFFDstring(1) "�" string(1) "�" > php -r '$name="中文"; var_dump($name[0].$name[1].$name[2]);'> php -r '$name="中文"; var_dump($name[0].$name[1].$name[2]);'string(3) "中"string(3) "中"func main() {func main() { x := "ascii" x := "ascii" fmt.Println(x[0]) // 97 fmt.Println(x[0]) // 97 fmt.Printf("%T\n", x[0])// uint8 fmt.Printf("%T\n", x[0])// uint8}}forrange"unicode/utf8"func(s*String)At(iint)rune19. 字符串并不都是 UTF8 文本
string 的值不必是 UTF8 文本，可以包含任意的值。只有字符串是文字字面值时才是 UTF8 文本，字串可以通过转义来包含其他数据。
ValidString()func main() {func main() { str1 := "ABC" str1 := "ABC" fmt.Println(utf8.ValidString(str1)) // true fmt.Println(utf8.ValidString(str1)) // true str2 := "A\xfeC" str2 := "A\xfeC" fmt.Println(utf8.ValidString(str2)) // false fmt.Println(utf8.ValidString(str2)) // false str3 := "A\\xfeC" str3 := "A\\xfeC" fmt.Println(utf8.ValidString(str3)) // true // 把转义字符转义成字面值 fmt.Println(utf8.ValidString(str3)) // true // 把转义字符转义成字面值}}20. 字符串的长度
在 Python 中：
data = u'♥' data = u'♥' print(len(data)) # 1print(len(data)) # 1然而在 Go 中：
func main() {func main() { char:= "♥" char:= "♥" fmt.Println(len(char)) // 3 fmt.Println(len(char)) // 3}}len()RuneCountInString(strstring)(nint)func main() {func main() { char:= "♥" char:= "♥" fmt.Println(utf8.RuneCountInString(char)) // 1 fmt.Println(utf8.RuneCountInString(char)) // 1}}RuneCountInStringfunc main() {func main() { char:= "é" char:= "é" fmt.Println(len(char)) // 3 fmt.Println(len(char)) // 3 fmt.Println(utf8.RuneCountInString(char)) // 2 fmt.Println(utf8.RuneCountInString(char)) // 2 fmt.Println("cafe\u0301") // café // 法文的 cafe，实际上是两个 rune 的组合 fmt.Println("cafe\u0301") // café // 法文的 cafe，实际上是两个 rune 的组合}}参考：normalization
,func main() {func main() { x := []int{ x := []int{ 1, 1, 2 // syntax error: unexpected newline, expecting comma or } 2 // syntax error: unexpected newline, expecting comma or } } } y := []int{1,2,} y := []int{1,2,} z := []int{1,2} z := []int{1,2} // ... // ...}}},log.Fatallog.PanicFatal*()Panic*()func main() {func main() { log.Fatal("Fatal level log: log entry") // 输出信息后，程序终止执行 log.Fatal("Fatal level log: log entry") // 输出信息后，程序终止执行 log.Println("Nomal level log: log entry") log.Println("Nomal level log: log entry")}}23. 对内建数据结构的操作并不是同步的
尽管 Go 本身有大量的特性来支持并发，但并不保证并发的数据安全，用户需自己保证变量等数据以原子操作更新。
goroutine 和 channel 是进行原子操作的好方法，或使用 "sync" 包中的锁。
24. range 迭代 string 得到的值
range 得到的索引是字符值(Unicode point / rune)第一个字节的位置，与其他编程语言不同，这个索引并不直接是字符在字符串中的位置。
注意一个字符可能占多个 rune，比如法文单词 café 中的 é。操作特殊字符可使用norm 包。
for range 迭代会尝试将 string 翻译为 UTF8 文本，对任何无效的码点都直接使用 0XFFFD rune(�)UNicode 替代字符来表示。如果 string 中有任何非 UTF8 的数据，应将 string 保存为 byte slice 再进行操作。
func main() {func main() { data := "A\xfe\x02\xff\x04" data := "A\xfe\x02\xff\x04" for _, v := range data { for _, v := range data { fmt.Printf("%#x ", v) // 0x41 0xfffd 0x2 0xfffd 0x4 // 错误 fmt.Printf("%#x ", v) // 0x41 0xfffd 0x2 0xfffd 0x4 // 错误 } } for _, v := range []byte(data) { for _, v := range []byte(data) { fmt.Printf("%#x ", v) // 0x41 0xfe 0x2 0xff 0x4 // 正确 fmt.Printf("%#x ", v) // 0x41 0xfe 0x2 0xff 0x4 // 正确 } }}}25. range 迭代 map
如果你希望以特定的顺序(如按 key 排序)来迭代 map，要注意每次迭代都可能产生不一样的结果。
Go 的运行时是有意打乱迭代顺序的，所以你得到的迭代结果可能不一致。但也并不总会打乱，得到连续相同的 5 个迭代结果也是可能的，如：
func main() {func main() { m := map[string]int{"one": 1, "two": 2, "three": 3, "four": 4} m := map[string]int{"one": 1, "two": 2, "three": 3, "four": 4} for k, v := range m { for k, v := range m { fmt.Println(k, v) fmt.Println(k, v) } }}}如果你去 Go Playground 重复运行上边的代码，输出是不会变的，只有你更新代码它才会重新编译。重新编译后迭代顺序是被打乱的：
26. switch 中的 fallthrough 语句
switchcasefallthroughfunc main() {func main() { isSpace := func(charbyte) bool{ isSpace := func(charbyte) bool{ switchchar{ switchchar{ case' ': // 空格符会直接 break，返回 false // 和其他语言不一样 case' ': // 空格符会直接 break，返回 false // 和其他语言不一样 // fallthrough // 返回 true // fallthrough // 返回 true case'\t': case'\t': returntrue returntrue } } returnfalse returnfalse } } fmt.Println(isSpace('\t')) // true fmt.Println(isSpace('\t')) // true fmt.Println(isSpace(' ')) // false fmt.Println(isSpace(' ')) // false}}fallthrough也可以改写 case 为多条件判断：
func main() {func main() { isSpace := func(charbyte) bool{ isSpace := func(charbyte) bool{ switchchar{ switchchar{ case' ', '\t': case' ', '\t': returntrue returntrue } } returnfalse returnfalse } } fmt.Println(isSpace('\t')) // true fmt.Println(isSpace('\t')) // true fmt.Println(isSpace(' ')) // true fmt.Println(isSpace(' ')) // true}}27. 自增和自减运算
++--++—// 错误示例// 错误示例func main() {func main() { data := []int{1, 2, 3} data := []int{1, 2, 3} i := 0 i := 0 ++i // syntax error: unexpected ++, expecting } ++i // syntax error: unexpected ++, expecting } fmt.Println(data[i++]) // syntax error: unexpected ++, expecting : fmt.Println(data[i++]) // syntax error: unexpected ++, expecting :}}// 正确示例// 正确示例func main() {func main() { data := []int{1, 2, 3} data := []int{1, 2, 3} i := 0 i := 0 i++ i++ fmt.Println(data[i]) // 2 fmt.Println(data[i]) // 2}}28. 按位取反
~^// 错误的取反操作// 错误的取反操作func main() {func main() { fmt.Println(~2) // bitwise complement operator is ^ fmt.Println(~2) // bitwise complement operator is ^}}// 正确示例// 正确示例func main() {func main() { var d uint8 = 2 var d uint8 = 2 fmt.Printf("%08b\n", d) // 00000010 fmt.Printf("%08b\n", d) // 00000010 fmt.Printf("%08b\n", ^d) // 11111101 fmt.Printf("%08b\n", ^d) // 11111101}}^NOT0x020x22XOR0xff&^func main() {func main() { var a uint8 = 0x82 var a uint8 = 0x82 var b uint8 = 0x02 var b uint8 = 0x02 fmt.Printf("%08b [A]\n", a) fmt.Printf("%08b [A]\n", a) fmt.Printf("%08b [B]\n", b) fmt.Printf("%08b [B]\n", b) fmt.Printf("%08b (NOT 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 [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 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 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) 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))}}10000010[A]10000010[A]00000010[B]00000010[B]11111101(NOT B)11111101(NOT B)00000010^ 11111111= 11111101[B XOR 0xff]00000010^ 11111111= 11111101[B XOR 0xff]10000010^ 00000010= 10000000[A XOR B]10000010^ 00000010= 10000000[A XOR B]10000010& 00000010= 00000010[A AND B]10000010& 00000010= 00000010[A AND B]10000010&^00000010= 10000000[A 'AND NOT' B]10000010&^00000010= 10000000[A 'AND NOT' B]10000010&(^00000010)= 10000000[A AND (NOT B)]10000010&(^00000010)= 10000000[A AND (NOT B)]29. 运算符的优先级
除了位清除(bit clear)操作符，Go 也有很多和其他语言一样的位操作符，但优先级另当别论。
func main() {func main() { fmt.Printf("0x2 & 0x2 + 0x4 -> %#x\n", 0x2&0x2+0x4) // & 优先 + fmt.Printf("0x2 & 0x2 + 0x4 -> %#x\n", 0x2&0x2+0x4) // & 优先 + //prints: 0x2 & 0x2 + 0x4 -> 0x6 //prints: 0x2 & 0x2 + 0x4 -> 0x6 //Go: (0x2 & 0x2) + 0x4 //Go: (0x2 & 0x2) + 0x4 //C++: 0x2 & (0x2 + 0x4) -> 0x2 //C++: 0x2 & (0x2 + 0x4) -> 0x2 fmt.Printf("0x2 + 0x2 << 0x1 -> %#x\n", 0x2+0x2<<0x1) // << 优先 + fmt.Printf("0x2 + 0x2 << 0x1 -> %#x\n", 0x2+0x2<<0x1) // << 优先 + //prints: 0x2 + 0x2 << 0x1 -> 0x6 //prints: 0x2 + 0x2 << 0x1 -> 0x6 //Go: 0x2 + (0x2 << 0x1) //Go: 0x2 + (0x2 << 0x1) //C++: (0x2 + 0x2) << 0x1 -> 0x8 //C++: (0x2 + 0x2) << 0x1 -> 0x8 fmt.Printf("0xf | 0x2 ^ 0x2 -> %#x\n", 0xf|0x2^0x2) // | 优先 ^ fmt.Printf("0xf | 0x2 ^ 0x2 -> %#x\n", 0xf|0x2^0x2) // | 优先 ^ //prints: 0xf | 0x2 ^ 0x2 -> 0xd //prints: 0xf | 0x2 ^ 0x2 -> 0xd //Go: (0xf | 0x2) ^ 0x2 //Go: (0xf | 0x2) ^ 0x2 //C++: 0xf | (0x2 ^ 0x2) -> 0xf //C++: 0xf | (0x2 ^ 0x2) -> 0xf}}优先级列表：
Precedence OperatorPrecedence Operator 5 * / % << >> & &^ 5 * / % << >> & &^ 4 + - | ^ 4 + - | ^ 3 == != < <= > >= 3 == != < <= > >= 2 && 2 && 1 || 1 ||30. 不导出的 struct 字段无法被 encode
structfunc main() {func main() { in:= MyData{1, "two"} in:= MyData{1, "two"} fmt.Printf("%#v\n", in) // main.MyData{One:1, two:"two"} fmt.Printf("%#v\n", in) // main.MyData{One:1, two:"two"} encoded, _ := json.Marshal(in) encoded, _ := json.Marshal(in) fmt.Println(string(encoded)) // {"One":1} // 私有字段 two 被忽略了 fmt.Println(string(encoded)) // {"One":1} // 私有字段 two 被忽略了 varoutMyData varoutMyData json.Unmarshal(encoded, &out) json.Unmarshal(encoded, &out) fmt.Printf("%#v\n", out) // main.MyData{One:1, two:""} fmt.Printf("%#v\n", out) // main.MyData{One:1, two:""}}}31. 程序退出时还有 goroutine 在执行
程序默认不等所有 goroutine 都执行完才退出，这点需要特别注意：
// 主程序会直接退出// 主程序会直接退出func main() {func main() { workerCount := 2 workerCount := 2 for i := 0; i < workerCount; i++ { for i := 0; i < workerCount; i++ { go doIt(i) go doIt(i) } } time.Sleep(1* time.Second) time.Sleep(1* time.Second) fmt.Println("all done!") fmt.Println("all done!")}}func doIt(workerID int) {func doIt(workerID int) { fmt.Printf("[%v] is running\n", workerID) fmt.Printf("[%v] is running\n", workerID) time.Sleep(3* time.Second) // 模拟 goroutine 正在执行 time.Sleep(3* time.Second) // 模拟 goroutine 正在执行 fmt.Printf("[%v] is done\n", workerID) fmt.Printf("[%v] is done\n", workerID)}}main()
常用解决办法：使用 "WaitGroup" 变量，它会让主程序等待所有 goroutine 执行完毕再退出。
kill// 等待所有 goroutine 执行完毕// 等待所有 goroutine 执行完毕// 进入死锁// 进入死锁func main() {func main() { var wg sync.WaitGroup var wg sync.WaitGroup done:= make(chan struct{}) done:= make(chan struct{}) workerCount := 2 workerCount := 2 for i := 0; i < workerCount; i++ { for i := 0; i < workerCount; i++ { wg.Add(1) wg.Add(1) go doIt(i, done, wg) go doIt(i, done, wg) } } close(done) close(done) wg.Wait() wg.Wait() fmt.Println("all done!") fmt.Println("all done!")}}func doIt(workerID int, donestruct{}, wg sync.WaitGroup) {func doIt(workerID int, donestruct{}, wg sync.WaitGroup) { fmt.Printf("[%v] is running\n", workerID) fmt.Printf("[%v] is running\n", workerID) defer wg.Done() defer wg.Done() done done fmt.Printf("[%v] is done\n", workerID) fmt.Printf("[%v] is done\n", workerID)}}执行结果：
看起来好像 goroutine 都执行完了，然而报错：
fatal error: all goroutines are asleep - deadlock!
wg.Done()varwgWaitGroupdoIt()wg.Done()wg// 等待所有 goroutine 执行完毕// 等待所有 goroutine 执行完毕// 使用传址方式为 WaitGroup 变量传参// 使用传址方式为 WaitGroup 变量传参// 使用 channel 关闭 goroutine// 使用 channel 关闭 goroutinefunc main() {func main() { var wg sync.WaitGroup var wg sync.WaitGroup done:= make(chan struct{}) done:= make(chan struct{}) ch := make(chan interface{}) ch := make(chan interface{}) workerCount := 2 workerCount := 2 for i := 0; i < workerCount; i++ { for i := 0; i < workerCount; i++ { wg.Add(1) wg.Add(1) go doIt(i, ch, done, &wg) // wg 传指针，doIt() 内部会改变 wg 的值 go doIt(i, ch, done, &wg) // wg 传指针，doIt() 内部会改变 wg 的值 } } for i := 0; i < workerCount; i++ { // 向 ch 中发送数据，关闭 goroutine for i := 0; i < workerCount; i++ { // 向 ch 中发送数据，关闭 goroutine ch ch } } close(done) close(done) wg.Wait() wg.Wait() close(ch) close(ch) fmt.Println("all done!") fmt.Println("all done!")}}func doIt(workerID int, ch interface{}, donestruct{}, wg *sync.WaitGroup) {func doIt(workerID int, ch interface{}, donestruct{}, wg *sync.WaitGroup) { fmt.Printf("[%v] is running\n", workerID) fmt.Printf("[%v] is running\n", workerID) defer wg.Done() defer wg.Done() for{ for{ select{ select{ case m := case m := fmt.Printf("[%v] m => %v\n", workerID, m) fmt.Printf("[%v] m => %v\n", workerID, m) casedone: casedone: fmt.Printf("[%v] is done\n", workerID) fmt.Printf("[%v] is done\n", workerID) return return } } } }}}运行效果：
32. 向无缓冲的 channel 发送数据，只要 receiver 准备好了就会立刻返回
只有在数据被 receiver 处理时，sender 才会阻塞。因运行环境而异，在 sender 发送完数据后，receiver 的 goroutine 可能没有足够的时间处理下一个数据。如：
func main() {func main() { ch := make(chan string) ch := make(chan string) go func() { go func() { for m := range ch { for m := range ch { fmt.Println("Processed:", m) fmt.Println("Processed:", m) time.Sleep(1* time.Second) // 模拟需要长时间运行的操作 time.Sleep(1* time.Second) // 模拟需要长时间运行的操作 } } }() }() ch "cmd.1" ch "cmd.1" ch "cmd.2"// 不会被接收处理 ch "cmd.2"// 不会被接收处理}}运行效果：
33. 向已关闭的 channel 发送数据会造成 panic
从已关闭的 channel 接收数据是安全的：
okfalsefalse向已关闭的 channel 中发送数据会造成 panic：
func main() {func main() { ch := make(chan int) ch := make(chan int) for i := 0; i < 3; i++ { for i := 0; i < 3; i++ { go func(idx int) { go func(idx int) { ch ch }(i) }(i) } } fmt.Println(// 输出第一个发送的值 fmt.Println(// 输出第一个发送的值 close(ch) // 不能关闭，还有其他的 sender close(ch) // 不能关闭，还有其他的 sender time.Sleep(2* time.Second) // 模拟做其他的操作 time.Sleep(2* time.Second) // 模拟做其他的操作}}运行结果：
done{}func main() {func main() { ch := make(chan int) ch := make(chan int) done:= make(chan struct{}) done:= make(chan struct{}) for i := 0; i < 3; i++ { for i := 0; i < 3; i++ { go func(idx int) { go func(idx int) { select{ select{ case ch 1) * 2: case ch 1) * 2: fmt.Println(idx, "Send result") fmt.Println(idx, "Send result") casedone: casedone: fmt.Println(idx, "Exiting") fmt.Println(idx, "Exiting") } } }(i) }(i) } } fmt.Println("Result: ", fmt.Println("Result: ", close(done) close(done) time.Sleep(3* time.Second) time.Sleep(3* time.Second)}}运行效果：
nil在一个值为 nil 的 channel 上发送和接收数据将永久阻塞：
func main() {func main() { var ch chan int// 未初始化，值为 nil var ch chan int// 未初始化，值为 nil for i := 0; i < 3; i++ { for i := 0; i < 3; i++ { go func(i int) { go func(i int) { ch ch }(i) }(i) } } fmt.Println("Result: ", fmt.Println("Result: ", time.Sleep(2* time.Second) time.Sleep(2* time.Second)}}runtime 死锁错误：
fatal error: all goroutines are asleep - deadlock! goroutine 1 [chan receive (nil chan)]
利用这个死锁的特性，可以用在 select 中动态的打开和关闭 case 语句块：
func main() {func main() { inCh := make(chan int) inCh := make(chan int) outCh := make(chan int) outCh := make(chan int) go func() { go func() { varinint= inCh varinint= inCh varout chanint varout chanint var val int var val int for{ for{ select{ select{ caseout caseout println("--------") println("--------") out= nil out= nil in= inCh in= inCh case val = in: case val = in: println("++++++++++") println("++++++++++") out= outCh out= outCh in= nil in= nil } } } } }() }() go func() { go func() { for r := range outCh { for r := range outCh { fmt.Println("Result: ", r) fmt.Println("Result: ", r) } } }() }() time.Sleep(0) time.Sleep(0) inCh 1 inCh 1 inCh 2 inCh 2 time.Sleep(3* time.Second) time.Sleep(3* time.Second)}}运行效果：
34. 若函数 receiver 传参是传值方式，则无法修改参数的原有值
方法 receiver 的参数与一般函数的参数类似：如果声明为值，那方法体得到的是一份参数的值拷贝，此时对参数的任何修改都不会对原有值产生影响。
除非 receiver 参数是 map 或 slice 类型的变量，并且是以指针方式更新 map 中的字段、slice 中的元素的，才会更新原有值:
type data struct{type data struct{ num int num int key *string key *string items map[string]bool items map[string]bool}}func (this*data) pointerFunc() {func (this*data) pointerFunc() { this.num = 7 this.num = 7}}func (this data) valueFunc() {func (this data) valueFunc() { this.num = 8 this.num = 8 *this.key = "valueFunc.key" *this.key = "valueFunc.key" this.items["valueFunc"] = true this.items["valueFunc"] = true}}func main() {func main() { key := "key1" key := "key1" d := data{1, &key, make(map[string]bool)} d := data{1, &key, make(map[string]bool)} fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items) fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items) d.pointerFunc() // 修改 num 的值为 7 d.pointerFunc() // 修改 num 的值为 7 fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items) fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items) d.valueFunc() // 修改 key 和 items 的值 d.valueFunc() // 修改 key 和 items 的值 fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items) fmt.Printf("num=%v key=%v items=%v\n", d.num, *d.key, d.items)}}运行结果：
总结
感谢原作者 kcqon 总结的这篇博客，让我受益匪浅。
由于译者水平有限，不免出现理解失误，望读者在下评论区指出，不胜感激。
后续再更新类似高质量文章的翻译 ?