Golanglang语言，相对而言是一个比较年轻的少年，才不到14岁，但是在当今的语言届已经独挡一面。Golanglang带来了许多独特的功能，比如通道和协程（Golangroutines）、结构类型、类型嵌入、GC垃圾收集等。但是作为一个新的语言，其标准库还有一些不足之处，而且它的生态系统虽然已经比较完善但是还不是很丰富。泛型的支持也是最近的1.18版本才推出。Golanglang语言中也有很多坑需要注意，本文就简单总结一下，Golanglang中容易犯错误的地方，给大家踩坑防跌。

小心:=

Golang有两个赋值运算符，=和:=：

var num int
num = 3
name := "chongchong"

:=非常有用，可以在赋值之前避免对变量进行声明。这实际上是当今许多类型语言中的常见做法（例如C#的var）。它非常方便并且使代码保持干净。

尽管这很可爱，但当与Golang 中的其他一些行为、作用域和多个返回值结合使用时，可能会遇到意外的行为。考虑以下示例：

var data []string
data, err := getData()
if err != nil {
panic("ERROR!")
}
for _, item := range data {
fmt.Println(item)
}
func getData() ([]string, error) {
return []string{"Hello","Chong","Chong"}, nil
}

在此示例中，我们从某处读取字符串数组并打印它：

Hello
Chong
Chong

请注意使用:=

data, err := getData()

请注意，即使dat已经声明过了,仍然可以使用:=。

现在让我们稍微修改一下代码：

var data []string
killswitch := os.Getenv("KILLSWITCH")
if killswitch == "" {
fmt.Println("kill switch is off")
data, err := getData()
if err != nil {
panic("ERROR!")
}

fmt.Printf("Data was fetched! %d\n", len(data))
for _, item := range data {
fmt.Println(item)
}
}

这段代码会产生什么结果？

kill switch is off
Data was fetched! 3

很奇怪，不是吗？ 由于终止开关关闭，我们确实加载了数据。甚至还打印出了它的长度。那么为什么代码不像以前那样打印它呢？

猜对了，因为“:=”！

Golang中的范围（像大多数现代语言一样）定义为{}。 此处这个if创建一个新范围：

if killswitch == "" {
...
}

因为我们使用:=, Go会同时对待两者data和err作为新变量！IE dataif 子句中实际上是一个新变量，当作用域关闭时该变量将被丢弃。

我们在初始化流程中多次遇到这种行为，通常会公开某种包变量，完全按照此处所述进行初始化，并带有终止开关以允许我们在生产中禁用某些行为。上述实现将导致系统处于无效状态。

在某些情况下，如果内部变量在if不使用子句，例如：

if killswitch == "" {
fmt.Println("kill switch is off")
data, err := getData()
if err != nil {
panic("ERROR!")
}
}
// Will issue an error :
data declared but not used

因此，请注意编译时的警告。

然而，有时确实在作用域内使用了变量，因此不会发出错误。

无论如何，最好的做法是尽量避免:=，特别是当它与多个返回值和错误处理相关时，在决定使用它时要格外注意：

var data []string
var err error
killswitch := os.Getenv("KILLSWITCH")
if killswitch == "" {
fmt.Println("kill switch is off")
data, err = getData()

if err != nil {
panic("ERROR!")
}

fmt.Printf("Data was fetched! %d\n", len(data))
}
for _, item := range data {
fmt.Println(item)
}
}

将导致：

kill switch is off
Data was fetched! 3
Hello
Chong
Chong

请记住，随着代码的发展，不同的开发人员会对其进行修改。以前不在不同作用域中的代码可能会在将来出现。当修改现有代码时，尤其是在将其移动到不同的范围时，请务必小心。

range

Golang使用range来处理切片类型的遍历和迭代。比如：

values := []string{"C", "h", "o","n", "g"}
for index, value := range values {
fmt.Println(index, value)
}
结果：

0, C
1, h
2, o
3, n
4, g

其返回值中有索引和值，这可以用来编写传统的C样式for循环以及for-each循环。

也可以只为该范围声明一个变量。令人惊讶的是，这样做会为提供索引，而不是切片的元素。如果该集合类型为非整类型，int操作会得到一个编译时错误。

对一个整数的集合则会有不可预测的后果：

values := []int{4, 8, 15, 16, 23, 42}
for value := range values {
fmt.Println(value)
}

结果：

0
1
2
3
4
5

如上，没有错误。没有警告。但是结果乱似一锅粥。

多值解构

Golang最耀眼的功能之一是支持返回多个值的函数。通常这用于返回一个可选的错误值（因为Golang 没有异常，常用panics来代替 ，但，这是非常不建议的。）

func doRiskyOperation() (Result, error) { … }

请注意，这些函数不返回元组。元组不是内置类型。 因此，不能将组合的返回值存储在变量中，不能对其进行索引，也不能将结果传递到另一个函数中，除非该函数采用完全相同的类型、相同的顺序。

resultAndError := doRiskyOperation() // not allowed
result := doRiskyOperation()[0] // not allowed
fmt.Println("Output: ", doRiskyOperation()) // not allowed
fmt.Println(doRiskyOperation()) // this one, strangely, is allowed

可以对多个返回值执行的唯一操作是：

解构并将它们分配给新声明的变量（使用:=或者var）

将它们分配给现有变量（使用=）

将它们传递给一个函数，该函数以相同的顺序采用完全相同数量和类型的参数。

从返回完全相同数量的类型参数的函数以相同的顺序返回它们。

这里有一个巧妙地方法，其中包含选项（1）和（2）：这两个选项之间没有混合和匹配：要么声明左侧的每个变量，要么都不声明。

考虑到这一点，请考虑以下示例，该示例将一系列转换应用于对象，返回包含每个转换结果的切片：

type Transformation func(Node) (Node, error)
func applyTransformations(n Node, ts []Transformation) ([]Node, error) {
var steps []Node
for _, t := range ts {
n, err := t(n)
if err != nil {
return nil, err
}
steps = append(steps, n)
}
return steps, nil
}

这段代码看起来是正确的，甚至可以在没有警告的情况下编译通过……但它不起作用。它将每个变换应用于原始变换，而不是按顺序应用每个变换。这是因为该行n, err := t(n)是一个声明语句它声明了两个新变量：err它存储潜在的错误，以及它存储新节点，隐藏原始变量n。这个新变量的仅存在于该范围的该迭代中，因此在下一次迭代中不会看到它的新值。

解决这个问题的第一反应是更换:=在行中n, err:= t(n)和=，但这也行不通。 至少这次你会得到一个编译时错误，告诉正在尝试分配给err没有声明它。

问题在于尝试将声明与赋值混合搭配。我们可以通过对这两个组件进行赋值来解决这个问题：

type Transformation func(Node) (Node, error)
func applyTransformations(n Node, ts []Transformation) ([]Node, error) {
var steps
for _, t := range ts {
var err error
n, err = t(n)
if err != nil {
return nil, err
}
steps = append(steps, n)
}
return steps, nil
}

或者通过将两个组件都声明为：

type Transformation func(Node) (Node, error)
func applyTransformations(n Node, ts []Transformation) ([]Node, error) {
var steps
for _, t := range ts {
newNode, err := t(n)
n = newNode
if err != nil {
return nil, err
}
steps = append(steps, n)
}
return steps, nil
}

这两个都需要一点额外的冗长。

类型嵌入

当结构嵌入类型时，它会继承该类型的所有字段和方法。这不是传统的面向对象意义上的继承：它基本上是用于在外部结构上定义这些成员并将这些调用/访问委托给内部对象的语法糖。它可以让我们避免显式访问内部对象。

type Nameable interface {
Name() string
}
type Node struct{
name string
}
func (n Node) Name() string {
return n.name
}
type Wrapper struct {
Node
}
tim := Wrapper{Node{"Tim"}}
// The expressions below are equivalent
tim.Name() // prints "Tim"
tim.Node.Name() // prints "Tim"
// As are these
tim.name // prints "Tim"
tim.Node.name // prints "Tim"

使用类型嵌入，很容易养成总是排除内部类型名称的习惯。毕竟，假设外部结构没有任何名称与内部对象冲突的成员，那么在需要其接口之一的任何地方传入外部结构应该始终是安全的，对吗？

不完全是。因为类型断言仍然是一件事。

func Print(n Nameable) {
wrapper, ok := n.(Wrapper)
if ok {
fmt.Printf("Wrapper: %s", n.Name())
} else {
fmt.Printf(n.Name())
}
}
Print(tim.Node) // prints "Tim"
Print(tim) // prints "Wrapper: Tim"

样式指南可能会争论类型断言是否是一个好的实践。但有时它们是避免接口或依赖关系图过于复杂的最佳方法，因此我们使用它们。虽然嵌入类型可能会欺骗编译时类型检查器，但无法欺骗类型断言。

按值传递

在Golang中实现一个方法时，有两个选择：

func (n Node) Name() string {...} // Value Receiver
func (n *Node) Name() string {...} // Pointer Receiver

这与将值与指针作为常规函数参数传递的行为方式相同：按值传递会创建结构体的副本，而按指针传递则不会。 只要记住这一点并像对待常规函数参数一样对待它，就安全了。但很容易忘记：毕竟，大多数语言只有方法的指针接收器。人们很容易养成假设方法接收器是指针的习惯，即使它不是指针，这会导致容易误入的坑：

func (n Node) SetName(newName string) {
n.name = newName
}
n := Node{name: "Tim"}
n.SetName("Aaron")
fmt.Println(n.Name) // prints "Tim"!

SetName方法什么也不会做。因为有值接收器的方法会创建接收器对象的副本，并且调用者不会看到对该对象所做的更改。

同样，如果记得非指针接收器的行为就像任何其他非指针参数一样，那就没问题了。但这仍然与其他主流面向对象语言不同，后者的接收者始终是指针。

在实践中，几乎总是希望在方法中使用指针接收器：它们可以防止昂贵的复制并且陷阱更少。不幸的是，使用他们也要求记住添加*。

Nil

Golang 中的Nil不仅仅是空指针值；对于许多类型来说，它也表示零值，包括切片和映射。

声明一个切片而不给它赋值是完全可以的：它被赋值为 nil，这与空切片相同：

var slice []int
fmt.Println(len(slice)) // prints 0
slice = append(slice, 42) // okay
fmt.Println(len(slice)) // prints 1

但尝试对Map执行类似操作时要小心：

var gpa map[string]float
fmt.Println(len(gpa)) // prints 0
m["Neal"] = 4.0 // nil panic!

当切片示例很好时，为什么这是一个问题？ 前面说过nil是Map零值，就像切片的零值一样吗？ 嗯，确实如此……但 nil 也是不可变的。

切片就像其他语言中的数组：它们的内容可以修改，但不能调整大小。这就是为什么append是一个函数而不是方法：它不会改变切片，而是创建一个大小增加的新切片并返回它。

而map不是这样工作的。插入和删除是修改映射值（和大小）而不创建新映射的操作。Nil map仍然是有效的map，就像nil slice 仍然是一个有效的切片。甚至可以安全地读取它（尽管它是空的，所以没有太多可读的内容）。但是无法给其插入，因为它没有初始化数据结构的支持：没有分配的空间可以插入！

如果想插入值到map中，则必须如下初始化它：

gpa := make(map[string]float)
fmt.Println(len(gpa)) // prints 0
m["Neal"] = 4.0 // okay!
fmt.Println(len(gpa)) // prints 1

结论

本文是个Golang初学者的一个避坑指南，当然这只是常见一些坑，但是不是全部的坑。避坑的万能法则是先踩坑，只有大量踩坑了，才可以留下深刻的影响，从而以后保证不会再犯！