避免的陷阱:Golang编程指南

发表时间: 2023-08-22 08:30


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

小心:=

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

var num intnum = 3name := "chongchong"

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

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

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

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

HelloChongChong

请注意使用:=

data, err := getData()

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

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

var data []stringkillswitch := 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 offData 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 []stringvar err errorkillswitch := 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 offData was fetched! 3HelloChongChong

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

range

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

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

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

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

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

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

结果:

012345

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

多值解构

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

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

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

resultAndError := doRiskyOperation() // not allowedresult := doRiskyOperation()[0] // not allowedfmt.Println("Output: ", doRiskyOperation()) // not allowedfmt.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 []Nodefor _, 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 stepsfor _, t := range ts {var err errorn, 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 stepsfor _, t := range ts {newNode, err := t(n)n = newNodeif 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 equivalenttim.Name() // prints "Tim"tim.Node.Name() // prints "Tim"// As are thesetim.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 Receiverfunc (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 []intfmt.Println(len(slice)) // prints 0slice = append(slice, 42) // okayfmt.Println(len(slice)) // prints 1

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

var gpa map[string]floatfmt.Println(len(gpa)) // prints 0m["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 0m["Neal"] = 4.0 // okay!fmt.Println(len(gpa)) // prints 1

结论

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