Go程序员踩过的defer坑错误处理

目录
  • 前言
  • 一、简单的例子
  • 二、一定不要在 for 循环中使用 defer 语句
  • 三、定义函数时就不要使用命名返回值
  • 四、defer 表达式的函数如果在 panic 后面,则这个函数无法被执行。
  • 五、执行顺序
  • 五、捕获异常执行顺序
  • 六、函数执行顺序
  • 七、外部函数捕获异常执行顺序
  • 八、recover 的返回值问题

前言

先声明:我被坑过。

之前写 Go 专栏时,写过一篇文章:Go 专栏|错误处理:defer,panic 和 recover。有小伙伴留言说:道理都懂,但还是不知道怎么用,而且还总出现莫名奇妙的问题。

出问题就对了,这个小东西坏的很,一不留神就出错。

所以,面对这种情况,我们今天就不讲道理了。直接把我珍藏多年的代码一把梭,凭借多年踩坑经历和写 BUG 经验,我要站着把这个坑迈过去。

一、简单的例子

先来一个简单的例子热热身:

package main
import (
    "fmt"
)
func main() {
    defer func() {
        fmt.Println("first")
    }()
    defer func() {
        fmt.Println("second")
    }()
    fmt.Println("done")
}

输出:

done
second
first

这个比较简单,defer 语句的执行顺序是按调用 defer 语句的倒序执行。

二、一定不要在 for 循环中使用 defer 语句

看看这段代码有什么问题?

for _, filename := range filenames {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close()
}

这段代码其实很危险,很可能会用尽所有文件描述符。因为 defer 语句不到函数的最后一刻是不会执行的,也就是说文件始终得不到关闭。所以切记,一定不要在 for 循环中使用 defer 语句。

那怎么优化呢?可以将循环体单独写一个函数,这样每次循环的时候都会调用关闭函数。

如下:

for _, filename := range filenames {
    if err := doFile(filename); err != nil {
        return err
    }
}
func doFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close()
}

三、定义函数时就不要使用命名返回值

看看这三个函数的输出结果是什么?

package main
import (
    "fmt"
)
func a() (r int) {
    defer func() {
        r++
    }()
    return 0
}
func b() (r int) {
    t := 5
    defer func() {
        t = t + 5
    }()
    return t
}
func c() (r int) {
    defer func(r int) {
        r = r + 5
    }(r)
    return 1
}
func main() {
    fmt.Println("a = ", a())
    fmt.Println("b = ", b())
    fmt.Println("c = ", c())
}

公布答案:

a =  1
b =  5
c =  1

你答对了吗?

说实话刚开始看到这个结果时,我是相当费解,完全不知道怎么回事。

但可以看到,这三个函数都有一个共同特点,它们都有一个命名返回值,并且都在函数中引用了这个返回值。

引用的方式分两种:分别是闭包和函数参数。

先看 a() 函数:

闭包通过 r++ 修改了外部变量,返回值变成了 1。

相当于:

func aa() (r int) {
    r = 0
    // 在 return 之前,执行 defer 函数
    func() {
        r++
    }()
    return
}

再看 b() 函数:

闭包内修改的只是局部变量 t,而外部变量 t 不受影响,所以还是返回 5。

相当于:

func bb() (r int) {
    t := 5
    // 赋值
    r = t
    // 在 return 之前,执行 defer 函数
    // defer 函数没有对返回值 r 进行修改,只是修改了变量 t
    func() {
        t = t + 5
    }()
    return
}

最后是 c 函数:

参数传递是值拷贝,实参不受影响,所以还是返回 1。

相当于:

func cc() (r int) {
    // 赋值
    r = 1
    // 这里修改的 r 是函数形参的值
    // 值拷贝,不影响实参值
    func(r int) {
        r = r + 5
    }(r)
    return
}

那么,为了避免写出这么令人意外的代码,最好在定义函数时就不要使用命名返回值。或者如果使用了,就不要在 defer 中引用。

再看下面两个例子:

func d() int {
    r := 0
    defer func() {
        r++
    }()
    return r
}
func e() int {
    r := 0
    defer func(i int) {
        i++
    }(r)
    return 0
}

d =  0
e =  0

返回值符合预期,再也不用绞尽脑汁猜了。

四、defer 表达式的函数如果在 panic 后面,则这个函数无法被执行。

func main() {
    panic("a")
    defer func() {
        fmt.Println("b")
    }()
}

输出如下,b 没有打印出来。

panic: a
goroutine 1 [running]:
main.main()
    xxx.go:87 +0x4ce
exit status 2

而如果 defer 在前,则可以执行。

func main() {
    defer func() {
        fmt.Println("b")
    }()
    panic("a")
}

输出:

b
panic: a
goroutine 1 [running]:
main.main()
    xxx.go:90 +0x4e7
exit status 2

五、执行顺序

看看下面这段代码的执行顺序:

func G() {
    defer func() {
        fmt.Println("c")
    }()
    F()
    fmt.Println("继续执行")
}
func F() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err)
        }
        fmt.Println("b")
    }()
    panic("a")
}
func main() {
    G()
}

顺序如下:

  • 调用 G() 函数;
  • 调用 F() 函数;
  • F() 中遇到 panic,立刻终止,不执行 panic 之后的代码;
  • 执行 F() 中 defer 函数,遇到 recover 捕获错误,继续执行 defer 中代码,然后返回;
  • 执行 G() 函数后续代码,最后执行 G() 中 defer 函数。

输出:

捕获异常: a
b
继续执行
c

五、捕获异常执行顺序

看看下面这段代码的执行顺序:

func G() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err)
        }
        fmt.Println("c")
    }()
    F()
    fmt.Println("继续执行")
}
func F() {
    defer func() {
        fmt.Println("b")
    }()
    panic("a")
}
func main() {
    G()
}

顺序如下:

  • 调用 G() 函数;
  • 调用 F() 函数;
  • F() 中遇到 panic,立刻终止,不执行 panic 之后的代码;
  • 执行 F() 中 defer 函数,由于没有 recover,则将 panic 抛到 G() 中;
  • G() 收到 panic 则不会执行后续代码,直接执行 defer 函数;
  • defer 中捕获 F() 抛出的异常 a,然后继续执行,最后退出。

输出:

b
捕获异常: a
c

六、函数执行顺序

看看下面这段代码的执行顺序:

func G() {
    defer func() {
        fmt.Println("c")
    }()
    F()
    fmt.Println("继续执行")
}
func F() {
    defer func() {
        fmt.Println("b")
    }()
    panic("a")
}
func main() {
    G()
}

顺序如下:

  • 调用 G() 函数;
  • 调用 F() 函数;
  • F() 中遇到 panic,立刻终止,不执行 panic 之后的代码;
  • 执行 F() 中 defer 函数,由于没有 recover,则将 panic 抛到 G() 中;
  • G() 收到 panic 则不会执行后续代码,直接执行 defer 函数;
  • 由于没有 recover,直接抛出 F() 抛过来的异常 a,然后退出。

输出:

b
c
panic: a
goroutine 1 [running]:
main.F()
    xxx.go:90 +0x5b
main.G()
    xxx.go:82 +0x48
main.main()
    xxx.go:107 +0x4a5
exit status 2

七、外部函数捕获异常执行顺序

看看下面这段代码的执行顺序:

func G() {
    defer func() {
        // goroutine 外进行 recover
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err)
        }
        fmt.Println("c")
    }()
    // 创建 goroutine 调用 F 函数
    go F()
    time.Sleep(time.Second)
}
func F() {
    defer func() {
        fmt.Println("b")
    }()
    // goroutine 内部抛出panic
    panic("a")
}
func main() {
    G()
}

顺序如下:

  • 调用 G() 函数;
  • 通过 goroutine 调用 F() 函数;
  • F() 中遇到 panic,立刻终止,不执行 panic 之后的代码;
  • 执行 F() 中 defer 函数,由于没有 recover,则将 panic 抛到 G() 中;
  • 由于 goroutine 内部没有进行 recover,则 goroutine 外部函数,也就是 G() 函数是没办法捕获的,程序直接崩溃退出。

输出:

b
panic: a
goroutine 6 [running]:
main.F()
    xxx.go:96 +0x5b
created by main.G
    xxx.go:87 +0x57
exit status 2

八、recover 的返回值问题

defer func() {
    if err := recover(); err != nil {
        fmt.Println("捕获异常:", err.Error())
    }
}()
panic("a")

recover 返回的是 interface {} 类型,而不是 error 类型,所以这样使用的话会报错:

err.Error undefined (type interface {} is interface with no methods)

可以这样来转换一下:

defer func() {
    if err := recover(); err != nil {
        fmt.Println("捕获异常:", fmt.Errorf("%v", err).Error())
    }
}()
panic("a")

或者直接打印结果:

defer func() {
    if err := recover(); err != nil {
        fmt.Println("捕获异常:", err)
    }
}()
panic("a")

输出:

捕获异常: a

以上就是本文的全部内容,其实写过其他的语言的同学都知道,关闭文件句柄,释放锁等操作是很容易忘的。而 Go 语言通过 defer 很好地解决了这个问题,但在使用过程中还是要小心。

源码地址:https://github.com/yongxinz/gopher/tree/main/sc

以上就是Go程序员踩过的defer坑错误处理的详细内容,更多关于Go defer错误处理的资料请关注我们其它相关文章!

(0)

相关推荐

  • C++实现Go的defer功能(示例代码)

    在Go语言中有一个关键字:defer,它的作用就是延迟执行后面的函数,在资源释放方面特别有用,比如下面一段C/C++的示例代码: void test() { FILE* fp = fopen("test.txt", "r"); if (nullptr == fp) return; if (...) { fclose(fp); return; } if (...) { fclose(fp); return; } if (...) { fclose(fp); retur

  • 聊聊golang中多个defer的执行顺序

    golang 中多个 defer 的执行顺序 引用 Ture Go 中的一个示例: package main import "fmt" func main() { fmt.Println("counting") for i := 0; i < 10; i++ { defer fmt.Println(i) } fmt.Println("done") } 程序执行结果为: counting done 9 8 7 6 5 4 3 2 1 0 从结

  • Go中defer使用场景及注意事项

    目录 1. 简介 1.1 使用场景 1.2 注意事项 2. defer 数据结构 3. 执行机制 3.1 栈上分配 3.2 开放编码 4. 参考 1. 简介 defer 会在当前函数返回前执行传入的函数,它会经常被用于关闭文件描述符.关闭数据库连接以及解锁资源. 理解这句话主要在三个方面: 当前函数 返回前执行,当然函数可能没有返回值 传入的函数,即 defer 关键值后面跟的是一个函数,包括普通函数如(fmt.Println), 也可以是匿名函数 func() 1.1 使用场景 使用 defe

  • Go语言使用defer+recover解决panic导致程序崩溃的问题

    案例:如果我们起了一个协程,但这个协程出现了panic,但我们没有捕获这个协程,就会造成程序的崩溃,这时可以在goroutine中使用recover来捕获panic,进行处理,这样主线程不会受到影响. 代码如下: package main import ( "fmt" "time" ) func sayHello() { for i := 0; i < 10; i++ { time.Sleep(time.Second) fmt.Println("he

  • Go语言defer语句的三种机制整理

    Golang 的 1.13 版本 与 1.14 版本对 defer 进行了两次优化,使得 defer 的性能开销在大部分场景下都得到大幅降低,其中到底经历了什么原理? 这是因为这两个版本对 defer 各加入了一项新的机制,使得 defer 语句在编译时,编译器会根据不同版本与情况,对每个 defer 选择不同的机制,以更轻量的方式运行调用. 堆上分配 在 Golang 1.13 之前的版本中,所有 defer 都是在堆上分配,该机制在编译时会进行两个步骤: 在 defer 语句的位置插入 ru

  • Go程序员踩过的defer坑错误处理

    目录 前言 一.简单的例子 二.一定不要在 for 循环中使用 defer 语句 三.定义函数时就不要使用命名返回值 四.defer 表达式的函数如果在 panic 后面,则这个函数无法被执行. 五.执行顺序 五.捕获异常执行顺序 六.函数执行顺序 七.外部函数捕获异常执行顺序 八.recover 的返回值问题 前言 先声明:我被坑过. 之前写 Go 专栏时,写过一篇文章:Go 专栏|错误处理:defer,panic 和 recover.有小伙伴留言说:道理都懂,但还是不知道怎么用,而且还总出现

  • C#程序员最易犯的编程错误

    本文介绍了10种最常见的编程错误,或是C#程序员要避免的陷阱. 常见错误1: 像使用值一样使用参考或过来用 C++以及许多其他语言的程序员习惯于控制他们分配给变量的值是否为简易的值或现有对象的引用.在C#中呢,这将由写该对象的程序员决定,而不是由实例化该对象并对它进行变量赋值的程序员决定.这是新手C#程序员们的共同"问题". 如果你不知道你正在使用的对象是否是值类型或引用类型,你可能会遇到一些惊喜.例如: Point point1 = new Point(20, 30); Point

  • Java程序员常犯的五个错误

    下面针对每一个错误用文字说明结合代码详解的方式展示给大家,具体内容如下: 1. Null 的过度使用 避免过度使用 null 值是一个最佳实践.例如,更好的做法是让方法返回空的 array 或者 collection 而不是 null 值,因为这样可以防止程序抛出 NullPointerException.下面代码片段会从另一个方法获得一个集合: List<String> accountIds = person.getAccountIds(); for (String accountId :

  • 让程序员都费解的10大编程语言特性

    每种语言都有自己的独到之处,或奇特的语法,或不常见的函数,或非标准的执行方式.因此,不论新丁还是老手,看着某个特性会突然醉了.文中总结了10个经常被提及的"奇异"特性. 1. Javascript: + 是一个连接符 问题描述: 在JS中,+ 号用在数字间,可以用作常规加法:但如果遇上字符,又可作为字符连接符.例如:'1'+ 1的结果是11. 成因分析: 根本性原因是JS属于弱类型语言.比方说Python,同样地使用+ 号作为字符连接符,但由于它是强类型语言,一旦发现一个字符与一个整数

  • java程序员常见的sql错误

    前言 你可能看到Java程序员每周的工作是编码开发一个可伸缩的Web应用程序,或创建一个动态的网站,或者开发高效的电子商务产品页面,也可能是开发一个Android应用程序等等.但是,即使他们致力于不同的项目,却往往都有一个共同点,那就是编程! 他们的职业要求长时间的工作来积累更多的编程知识.Java程序员还需要了解项目的需求.设计和开发一个属于自己的原型项目.为了使自己始终跟随行业变换的脚步,他们还必须具备其他语言的基础知识,比如HTML.SQL等等. Java程序员的职业生涯并不是一帆风顺的,

  • 程序员最实用的 SQL 语句收藏,看完这篇就够了

    前言 文章沿着设计一个假想的应用 awesome_app 为主线,从零创建修改数据库,表格,字段属性,索引,字符集,默认值,自增,增删改查,多表查询,内置函数等实用 SQL 语句.收藏此文,告别零散又低效地搜索经常使用的 SQL 语句.所有 SQL 都在 MySQL 下通过验证,可留着日后回顾参考,也可跟着动手一起做,如果未安装 MySQL 可参考 <macOS 安装 mysql> (windows 安装大同小异). 1. 创建 1.1 创建数据库 语法:create database db_

  • 99%的程序员都会收藏的书单 你读过几本?

    人丑就要多读书,颜值不够知识来凑,至少你可以用书籍来武装你的大脑,拯救你的人生.  01 顶级程序员必备书籍,雷军都点赞的书单! (点击这里,查看原文) 拿到了一份雷军点赞的程序员必读书单, 让我们看看, 想成为程序员大神,需要哪些书籍! 软件工程本身就是一个需要实践的行业, 在实践的同时,针对读书, 我的看法是:不能不读! 读了之后在实际开发的过程中, 能够避免一些坑! 好的书籍每年都会有新的产出, 雷军推荐的顶级程序员书单都有哪些书呢? 02 Python书单,不将就(部分pdf电子书下载)

  • PHP程序员的技术成长规划

    按照了解的很多PHP/LNMP程序员的发展轨迹,结合个人经验体会,抽象出很多程序员对未来的迷漫,特别对技术学习的盲目和慌乱,简单梳理了这个每个阶段PHP程序员的技术要求,来帮助很多PHP程序做对照设定学习成长目标. 本文按照目前主流技术做了一个基本的梳理,整个是假设PHP程序员不是基础非常扎实的情况进行的设定,并且所有设定都非常具体明确清晰,可能会让人觉得不适,请理解仅代表一家之言.(未来技术变化不在讨论范围) 第一阶段:基础阶段(基础PHP程序员) 重点:把LNMP搞熟练(核心是安装配置基本操

  • 中高级PHP程序员应该掌握哪些技术?

    本文把php程序员划分为中.高级程序员两大类程序员,并针对这两大程序员应具备的技能进行分类探索. 中级PHP程序员  1.Linux  能够流畅的使用Shell脚本来完成很多自动化的工作:awk/sed/perl 也操作的不错,能够完成很多文本处理和数据统计等工作:基本能够安装大 部分非特殊的Linux程序(包括各种库.包.第三方依赖等等,比如MongoDB/Redis/Sphinx/Luncene/SVN之类的):了解基 本的Linux服务,知道如何查看Linux的性能指标数据,知道基本的Li

  • 最新Javascript程序员面试试题和解题方法

    现在面试JS程序员很多都是直接上机解决公司提前准备好的Javascript问题,或者干脆直接写在纸上,体现出程序员的思路等,小编为大家整理了最新的JS面试试题以及解决办法和思路,一下来看下. 闭包: function fun(n,o) { console.log(o) return { fun:function(m){ return fun(m,n); } }; } var a = fun(0); a.fun(1); a.fun(2); a.fun(3);//undefined,?,?,? va

随机推荐