您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > Go语言

Go 项目开发中 10 个最常见的错误

时间:2020-01-17 12:37:49  来源:  作者:

以下文章来源于Golang来啦 ,作者Seekload

 

Go 项目开发中 10 个最常见的错误

 

 

原文地址:https://itnext.io/the-top-10-most-common-mistakes-ive-seen-in-go-projects-4b79d4f6cd65

原文作者:Teiva Harsanyi

 

四哥翻译水平有限,如有翻译或理解错误,烦请帮忙指出,感谢!

原文如下:


这篇文章列举了我在 Go 项目中遇见的最常见错误,排序先后不重要。

1.未知的枚举值

来看个简单的例子:

type Status uint32

const (
    StatusOpen Status = iota
    StatusClosed
    StatusUnknown
)

我们使用 iota 创建了枚举值,结果如下:

StatusOpen = 0
StatusClosed = 1
StatusUnknown = 2

现在,我们假设 Status 类型是 JSON 请求的一部分,将会被 marshalled/unmarshalled。设计的结构体如下:

type Request struct {
    ID        int    `json:"Id"`
    Timestamp int    `json:"Timestamp"`
    Status    Status `json:"Status"`
}

接收到请求的结果如下:

{
  "Id": 1234,
  "Timestamp": 1563362390,
  "Status": 0
}

这没什么特殊的,Status 会被解析成 StatusOpen,没错吧?

好,我们再请求一次,得到的结果没有设置 Status(不管什么原因):

{
  "Id": 1235,
  "Timestamp": 1563362390
}

这个例子中,Request 结构体的 Status 字段会初始化为零值(对于 uint32 类型来说是 0)。因此,对应的是 StatusOpen 而不是 StatusUnknown。

最好的做法就是将未知的值设置为枚举值 0:

type Status uint32

const (
    StatusUnknown Status = iota
    StatusOpen
    StatusClosed
)

这样,即使 Status 不是请求 JSON 的一部分,就像我们所期望的那样,它也会初始化为 StatusUnknown。

2.基准测试

想要准确无误地进行基准测试很难,因为有太多因素会对结果产生影响。

最常见的错误之一就是代码会被编译器优化,我们来看一个具体的例子,这个例子选自 teivah/bitvector[1] 库:

func clear(n uint64, i, j uint8) uint64 {
    return (math.MaxUint64<<j | ((1 << i) - 1)) & n
}

在这个基准测试中,编译器注意到 clear() 函数是一个叶子函数(没有调用其他函数),会将它优化成内联函数。一旦 clear() 函数被内联,编译器注意到它没有任何的副作用,因此编译器会将它移除,从而导致错误的结果。

一种可行的方案是将结果作为全局变量,就像下面这样:

var result uint64

func BenchmarkCorrect(b *testing.B) {
    var r uint64
    for i := 0; i < b.N; i++ {
        r = clear(1221892080809121, 10, 63)
    }
    result = r
}

这样,编译器不知道调用是否会产生副作用。因此,基准测试结果是正确的。

拓展阅读:High Performance Go Workshop[2]

3.指针!到处都是指针!

变量传值会创建变量的副本;如果传指针,复制的则是内存地址。

因此,传指针通常会更快,是这样吗?

如果你相信这是真的,请看下这个例子[3]。这是一个基准测试,对一个 0.3 KB 的结构体分别做传值和传指针的对比。0.3 KB 不算大,与我们每天接触的结构体的大小相差不远。

当在我本地环境执行基准测试,传值要比传指针快 4 倍,是不是有点违反直觉?

这个答案的解释与 Go 的内存管理有关。我无法像 William Kennedy 一样出色地解释,但不妨碍我们来总结一下:

一个变量可以分配在堆上或者栈上:

•栈中存储当前 goroutine 正在使用的变量,一旦函数返回,变量便会从栈中弹出;•堆存储共享变量(全局变量等);

我们来看一个返回值的例子:

func getFooValue() foo {
    var result foo
    // Do something
    return result
}

示例中,当前 goroutine 创建了变量 result,被推入当前的栈中。函数返回的时候,函数调用者将会接收到变量的副本。而变量 result 本身被当前 goroutine 弹出栈。但它依然存储在内存里(但再也不能访问),直到被其他变量覆盖。

来看一个传指针的例子:

func getFooPointer() *foo {
    var result foo
    // Do something
    return &result
}

当前 goroutine 创建了变量 result,但函数调用者将接收到一个指针(变量地址的副本),如果变量 result 被弹出栈,函数调用者将再也不能访问它。

在这种情况下,Go 编译器会将变量 result 逃逸到一个变量可以共享的地方:堆。

来看下传指针的另外一种情况:


 

因为我们在同一个 goroutine 里调用 f() 函数,变量 p 不会被逃逸。只是被推入栈中,子函数任然可以访问它。

这也是 io.Reader 接口中 Read 方法接收切片而不是返回切片的直接原因,如果返回一个切片,它将会逃逸到堆中。

为什么栈会如此之快?有两个主要的原因:

栈不需要垃圾回收机制。我们说过,变量创建的时候便会被推入栈中,函数返回时会被弹出栈。不需要一个复杂的过程回收未使用的变量。•栈属于一个 goroutine,与堆相比,将变量存储在栈中不需要同步机制。这也可以提高性能。

总之,当我们创建函数时,默认应该是使用值而不是指针。只有在我们想要共享变量时才应使用指针。

当我们遭遇性能问题时,在一些特定情况下,可能的优化策略是检查下指针,这获取对我们有所帮助。通过使用下面这条命令,可以知道编译器何时将变量转义到堆:


 

再次强调下,对于大多数日常用例来说,值传递是最合适的。

拓展阅读:Language Mechanics On Stacks And Pointers[4]

4.使用 break 跳出 for/switch 或者 for/select

下面的例子中,如果函数 f() 返回 true 将会发生什么:

for {
  switch f() {
  case true:
    break
  case false:
    // Do something
  }
}

将会走 break 语句,跳出 switch 语句而不是终止 for 循环。

下面是同样的问题:


 

break 只会跳出 select 语句,而不是终止 for 循环。

上述问题的一种可行方法是使用标记,就像下面这样:

loop:
    for {
        select {
        case <-ch:
        // Do something
        case <-ctx.Done():
            break loop
        }
    }

5.错误管理

Go 在错误处理方面仍然有待提高,这也是 Go2.0 最令人期待的特性之一。

当前标准库(Go1.13 之前)只提供构建错误的功能,如果查看 pkg/errors[5] 包,会发现对于错误处理的规则,它并不完全遵守:

一个错误只被处理一次,记录错误就是在处理错误。所以,错误要么被记录要么被收集。

使用当前的标准库,很难遵守以上规则,因为总是希望对错误加一些上下文信息或者让其具有某种层次结构。

让我们来看一个例子,希望能通过 REST 调用查看一个数据库的问题:

unable to serve HTTP POST request for customer 1234
 |_ unable to insert customer contract abcd
     |_ unable to commit transaction

如果我们使用 pkg/errors 包,可以这样做:

func postHandler(customer Customer) Status {
    err := insert(customer.Contract)
    if err != nil {
        log.WithError(err).Errorf("unable to serve HTTP POST request for customer %s", customer.ID)
        return Status{ok: false}
    }
    return Status{ok: true}
}

func insert(contract Contract) error {
    err := dbQuery(contract)
    if err != nil {
        return errors.Wrapf(err, "unable to insert customer contract %s", contract.ID)
    }
    return nil
}

func dbQuery(contract Contract) error {
    // Do something then fail
    return errors.New("unable to commit transaction")
}

刚开始的时候,错误由 errors.New 函数创建;并在函数 insert() 中,通过 errors.Wrapf() 添加一些上下文信息包装次错误;最后,在父级函数中通过 log 包来记录错误。每个层级都会返回或处理错误。

有时候我们想通过检查错误原因来判断是否应该重试。假设有一个来自外部库的 db 包,用来处理数据库访问。该库可能会返回一个名为 db.DBError 的临时性错误。我们需要检查错误原因来决定是否需要重试:

func postHandler(customer Customer) Status {
    err := insert(customer.Contract)
    if err != nil {
        switch errors.Cause(err).(type) {
        default:
            log.WithError(err).Errorf("unable to serve HTTP POST request for customer %s", customer.ID)
            return Status{ok: false}
        case *db.DBError:
            return retry(customer)
        }

    }
    return Status{ok: true}
}

func insert(contract Contract) error {
    err := db.dbQuery(contract)
    if err != nil {
        return errors.Wrapf(err, "unable to insert customer contract %s", contract.ID)
    }
    return nil
}

这样,通过使用 pkg/errors 包的 errors.Cause() 函数实现重试。

我见过的使用 pkg/errors 包处理错误的常见错误方式如下:

switch err.(type) {
default:
  log.WithError(err).Errorf("unable to serve HTTP POST request for customer %s", customer.ID)
  return Status{ok: false}
case *db.DBError:
  return retry(customer)
}

在这个例子中,如果 db.DBError 被包装过,将永远不会触发 retry() 函数。

拓展阅读:Don’t just check errors, handle them gracefully[6]

6.初始化切片

一些情况下,我们知道一个切片的最终长度。例如,假设我们将一个切片 转化成一个切片 Bar,很明显我们知道这两个切片有相同的长度。

我经常看到使用下面这种方式对切片进行初始化:

var bars []Bar
bars := make([]Bar, 0)

切片并不是一个神奇的结构。在底层,切片实现了自动增长策略,如果当前切片没有足够容量可用时候会自动增长。这种情况下,会自动创建一个新的更大长度[7]的数组,原有的数组元素会拷贝到新数组。

现在,让我们想象下,当 []Foo 有成千上万个元素时,是不是需要多次重复自增长操作?插入操作的时间复杂度仍然是 O(1),但实际上这个会严重的影响程序的性能。

所以,如果我们知道切片的最终长度,可以选择下面两种做法之一:

•使用预定义长度初始化;

func convert(foos []Foo) []Bar {
    bars := make([]Bar, len(foos))
    for i, foo := range foos {
        bars[i] = fooToBar(foo)
    }
    return bars
}

使用 0 长度和预定义的容量对其进行初始化;

func convert(foos []Foo) []Bar {
    bars := make([]Bar, 0, len(foos))
    for _, foo := range foos {
        bars = Append(bars, fooToBar(foo))
    }
    return bars
}

到底哪种才是最佳的方式呢?第一种会稍稍快一点。然而,你可以更喜欢第二种,因为它更加有一致性:不管我们是否知道初始大小,都可以使用 append 在切片的末尾添加元素。

7.Context 管理

context.Context 经常被开发者误解,根据官方文档描述:

A Context carries a deadline, a cancelation signal, and other values across API boundaries.

这个描述非常通用,通用的足以让很多人对为什么要使用和如何去使用 context 感到非常疑惑。

让我们详细描述下,一个 context 可以包含:

•一个截止时间。意味着,一个时间段(例如 250 ms)结束之后或者到了某一个时间点(例如 2019-01-08 01:00:00),我们必须取消正在进行的操作(例如:I/O 请求、等待一个协程输入等)。•一个取消信号(基本上都是 <-chan struct{})。在这里,行为与之前的是类似的。一旦我们接收到信号,我们必须停止正在进行的活动。例如,假设我们接收到两个请求:第一个是插入数据,而另一个是取消第一个请求(这两个请求是不相关的)。这可以通过在第一个调用中使用可取消的 context 来实现,一旦我们收到第二个请求的时候就可以调用这个 context 发送信号,进而让第一个请求停止执行。•一个 key/value 对的列表(都是 interface{}类型)。

补充两点:第一,上下文是可组合的。因此,我们可以有一个包含截止时间和 key/value 列表的上下文;第二,多个 goroutine 可以共享同一 context,因此取消信号可能会终止多个活动。

言归正传,下面是我见过的一个具体错误。

一个 Go 应用基于 urfave/cli[8](一个非常好用的可创建命令行引用的第三方包)。一旦引用启动,开发人员将继承一种应用的 context,这意味着当应用停止之后,库将使用次 context 发送取消信号。

我遇到的情况是,在我调用 gRPC 服务的时候,这个 context 被直接传递过去了。这并不是我们想要的。

相反,我们希望指示 gRPC库:请在程序停止或者 100ms 以后取消这个请求。为此,我们可以简单的创建一个组合的 context,如果 parent 是应用 context 的名字,我们可以简单的这样做:

ctx, cancel := context.WithTimeout(parent, 100 * time.Millisecond)
response, err := grpcClient.Send(ctx, request)

context 理解起来并不复杂,而且我认为它是 Go 语言的最佳特性之一。

拓展阅读:1 Understanding the context package in golang[9] 2 gRPC and Deadlines[10]

8.不使用 -race 选项

测试 Go 应用的时候,我经常碰到的一个错误是没有 -race 选项。正如在这份报告[11]里描述的一样,尽管 Go 语言的设计旨在“使并发编程变得更容易且不容易出错”,我们依然会遇到各种并发问题。

显然,Go 的竞争检查(race detector)无法解决每一个并发问题。不过,它依然是有使用价值的工具,在测试 Go 应用的时候,应当开启它。

拓展阅读:Does the Go race detector catch all data race bugs?[12]

9.使用文件名作为输入参数

另一个常见的错误是将一个文件名作为参数传递。

假设我们要编写一个函数,实现计算文件里空行的数目的功能。最常见的做法就是像下面这样:


 

文件名作为参数传递,然后在函数里打开它,接着实现其他的逻辑,应当是这样吗?

现在,假设我们想要基于这个函数实现单元测试,测试普通文件、空文件或者不同编码类型的文件等。这会变得难以管理。

再比如,如果是从一个 HTTP Body 接收内容去实现相同的逻辑(计算空行数目), 那就不得不为此再创建一个函数。

Go 语言里面有两个非常棒的抽象函数:io.Reader 和 io.Writer。我们可以传递一个抽象方法 io.Reader 代替传文件名,这就可以使得函数更具通用性了。

不管输入源是文件、HTTP 包体还是一个字节 Buffer,都不重要,我们都可以使用同一个读取方法实现相同功能。

在我们的例子中,我们甚至可以通过逐行读取的方式将输入缓存起来,因此,我们可以使用 bufio.Reader 和 ReadLine 方法:

func count(reader *bufio.Reader) (int, error) {
    count := 0
    for {
        line, _, err := reader.ReadLine()
        if err != nil {
            switch err {
            default:
                return 0, errors.Wrapf(err, "unable to read")
            case io.EOF:
                return count, nil
            }
        }
        if len(line) == 0 {
            count++
        }
    }
}

至于打开文件的操作就可以交给 count() 函数调用者去实现:

file, err := os.Open(filename)
if err != nil {
  return errors.Wrapf(err, "unable to open %s", filename)
}
defer file.Close()
count, err := count(bufio.NewReader(file))

通过第二种方法,不管实际的数据来源是什么,都可以通过调用该函数来实现相同功能。与此同时,这也有助于我们的单元测试,因为我们可以简单地从字符串创建 bufio.Reader 即可:

count, err := count(bufio.NewReader(strings.NewReader("input")))

10.协程和循环变量

最后一个常见的错误是使用循环变量的方式创建 goroutine。

下面的例子输出什么?

ints := []int{1, 2, 3}
for _, i := range ints {
  go func() {
    fmt.Printf("%vn", i)
  }()
}

正如所希望的一样,按顺序输出 1 2 3,不过真的是这样吗?

在这个例子中,每一个 goroutine 共享相同的变量,所以会输出 3 3 3(最有可能)。

这个问题有两个解决办法,第一种是将变量 i 的值传递给闭包(内部的函数):


 

第二种解决办法是在 for-range 循环体内创建一个临时变量:

ints := []int{1, 2, 3}
for _, i := range ints {
  i := i
  go func() {
    fmt.Printf("%vn", i)
  }()
}

这行代码 i := i 看起来有些奇怪,但完全是有效的。进入循环体里就是进入另一个变量作用域,因此 i:=i 创建了一个新的、名称相同的变量 i。当然为了提高可读性,我们也可以使用其他的变量名。

拓展阅读:Common Mistakes:Using goroutines on loop iterator variables[13]



Tags:Go   点击:()  评论:()
声明:本站部分内容来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系,我们将及时更正、删除,谢谢。
▌相关评论
发表评论 共有条评论
用户名: 密码:
验证码: 匿名发表
▌相关推荐
概述Go语言作为一门开源的编程语言,以简洁、快速、安全著称。尤其在高性能的分布式服务器领域得到广泛应用。技多不压身,在学习过程中记录下来,以备后续参考,希望对有同样需求的...【详细内容】
2020-11-12   Go  点击:(2)  评论:(0)  加入收藏
作为一个后端开发人员来说,微信开发已经是必备的技能之一了,今天小编就来分享一个相关的类库shenghui0779/gochat(以下简称wechat)。这个类库简单易用,看源码的时候目录结构一...【详细内容】
2020-11-12   Go  点击:(4)  评论:(0)  加入收藏
一、Drogon是一个基于C++14/17的Http应用框架,使用Drogon可以方便的使用C++构建各种类型的Web应用服务端程序。 本版本库是github上Drogon工程的镜像库。Drogon是作者非常喜...【详细内容】
2020-11-12   Go  点击:(3)  评论:(0)  加入收藏
Redis定位在"快",MongoDB定位在"灵活",HBase定位于"大"。在一般使用情况下,MongoDB可以当作简单场景下的但是性能高数倍的MySQL,Redis基本只会用来做缓存,HBase用来存储海量数据...【详细内容】
2020-11-11   Go  点击:(2)  评论:(0)  加入收藏
在这篇综述性文章中,作者详尽地介绍了多智能强化学习的理论基础,并阐述了解决各类多智能问题的经典算法。此外,作者还以 AlphaGo、AlphaStar为例,概述了多智能体强化学习的实际应用。...【详细内容】
2020-11-05   Go  点击:(4)  评论:(0)  加入收藏
在微服务中服务间依赖非常常见,比如评论服务依赖审核服务而审核服务又依赖反垃圾服务,当评论服务调用审核服务时,审核服务又调用反垃圾服务,而这时反垃圾服务超时了,由于审核服务...【详细内容】
2020-10-28   Go  点击:(5)  评论:(0)  加入收藏
这篇文章是为不熟悉 Go 的指针或指针类型的程序员而准备的。什么是指针?简单点说,指针是指向另一个地址的值。这是教科书上的解释,但如果你转自一门不用谈论变量地址的开发语言...【详细内容】
2020-10-23   Go  点击:(7)  评论:(0)  加入收藏
流处理(Stream processing)是一种计算机编程范式,其允许给定一个数据序列(流处理数据源),一系列数据操作(函数)被应用到流中的每个元素。同时流处理工具可以显著提高程序员的...【详细内容】
2020-10-19   Go  点击:(6)  评论:(0)  加入收藏
go-zero微服务框架中提供了许多开箱即用的工具,好的工具不仅能提升服务的性能而且还能提升代码的鲁棒性避免出错,实现代码风格的统一方便他人阅读等等。本文主要讲述进程内共...【详细内容】
2020-10-18   Go  点击:(4)  评论:(0)  加入收藏
算法05:Golang快速排序Quick Sort1.什么是快速排序(Quick Sort)快速排序是由东尼&middot;霍尔所发展的一种排序算法.在平均状况下,排序 n 个项目要 &Omicron;(nlogn) 次比...【详细内容】
2020-10-12   Go  点击:(9)  评论:(0)  加入收藏
Google 黑客 - 简介Google hacker (Google黑客)是利用GOOGLE提供的搜索功能查找黑客们想找到的信息,一般是查找网站后台,网管的个人信息,也可以用来查找某人在网络上的活动信息...【详细内容】
2020-09-30   Go  点击:(9)  评论:(0)  加入收藏
最近,我一直想开发一些桌面(主要是 Windows,但也可以考虑 MacOS 或 Linux)应用程序。虽然 Go 不是开发 UI 应用程序时首选语言,但是该语言的简单性和健壮性仍然使它成为我的首选...【详细内容】
2020-09-29   Go  点击:(27)  评论:(0)  加入收藏
Django框架是PythonWeb三大主流框架之一,以其功能强大全面而受到众多开发者追捧,现如今Django已经更新到3版本,但是并不推荐使用,更多建议使用1版本。Django版本Python版本1.112...【详细内容】
2020-09-27   Go  点击:(6)  评论:(0)  加入收藏
go-fly基于GO语言实现的web客服即时通讯与客服管理系统。非常适合给自己的网站增加在线客服功能,代码简单也适合学习。Github地址:https://github.com/taoshihan1991/go-fly1....【详细内容】
2020-09-25   Go  点击:(14)  评论:(0)  加入收藏
首先,如果用yum安装mongodb数据库的话,后期是无法使用自带mongodump工具进行导入导出的,另外MongoDB Compass工具无法整个库导出,很不方便,这里就会用到一个mongodb很实用的可视...【详细内容】
2020-09-25   Go  点击:(28)  评论:(0)  加入收藏
在 Zerologon 漏洞开始疯狂传播之后,美国国土安全局责令政府网络管理员责令政府网络管理员立即给 Windows Server 2008 及以上版本(包括 Windows 10 Server)打补丁。现在,微软也...【详细内容】
2020-09-25   Go  点击:(7)  评论:(0)  加入收藏
这份文档是Google Java编程风格规范的完整定义。当且仅当一个Java源文件符合此文档中的规则, 我们才认为它符合Google的Java编程风格。与其它的编程风格指南一样,这里所讨论的...【详细内容】
2020-09-25   Go  点击:(9)  评论:(0)  加入收藏
Illustration created for “A Journey With Go”, made from the original Go Gopher, created by Renee Fℹ️ 这篇文章基于 Go 1.13。在内存从分配到回收的生命周期中,内存...【详细内容】
2020-09-24   Go  点击:(10)  评论:(0)  加入收藏
MongoDB作为一款NoSQL数据库,常应用在游戏开发领域。 作为一个后端程序,进行CRUD操作是家常便饭,但如果不看源码,便不会知道MongoDB底层是如何实现的,对自己写的CRUD代码,心里就没...【详细内容】
2020-09-23   Go  点击:(18)  评论:(0)  加入收藏
前言不管是C语言还是golang语言,都有自己的函数调用流程,主要是在函数调用过程中,各种寄存器和内存堆栈的变化. 理解清楚整个函数调用流程,可以加深对golang语言的了解.编译...【详细内容】
2020-09-22   Go  点击:(5)  评论:(0)  加入收藏
最新更新
栏目热门
栏目头条