• Go 异常处理


    代码在执行的过程中可能因为一些逻辑上的问题而出现错误

    func test1(a, b int) int {
    	result := a / b
    	return result
    }
    func main() {
    	resut := test1(10, 0)
    	fmt.Println(resut)
    }
    
    
    panic: runtime error: integer divide by zero          
                                                          
    goroutine 1 [running]:                                
    main.test1(...)                                       
            C:/Users/nlp_1/goWorkspace/src/main.go:6      
    main.main()                                           
            C:/Users/nlp_1/goWorkspace/src/main.go:11 +0xa
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    error接口

    Go语言引入了一个关于错误处理的标准模式,即error接口,它是Go语言内建的接口类型,该接口的定义如下:

    func test1(a, b int) (result int, err error) {
    	err = nil
    	if b == 0 {
    		fmt.Println("err=", err)
    	} else {
    		result = a / b
    	}
    	return
    }
    func main() {
    	result, err := test1(10, 0)
    	if err != nil {
    		fmt.Println("err=", err)
    	} else {
    		fmt.Println("err=", result)
    	}
    }
    
    err= <nil>
    err= 0
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    这种用法是非常常见的,例如,后面讲解到文件操作时,涉及到文件的打开,如下:
    在这里插入图片描述
    在打开文件时,如果文件不存在,或者文件在磁盘上存储的路径写错了,都会出现异常,这时可以使用error记录相应的错误信息。

    panic函数

    error返回的是一般性的错误,但是panic函数返回的是让程序崩溃的错误。

    也就是当遇到不可恢复的错误状态的时候,如数组访问越界、空指针引用等,这些运行时错误会引起panic异常,在一般情况下,我们不应通过调用panic函数来报告普通的错误,而应该只把它作为报告致命错误的一种方式。当某些不应该发生的场景发生时,我们就应该调用panic。

    一般而言,当panic异常发生时,程序会中断运行。随后,程序崩溃并输出日志信息。日志信息包括panic value和函数调用的堆栈跟踪信息。

    当然,如果直接调用内置的panic函数也会引发panic异常,panic函数接受任何值作为参数。

    func test1(i int) {
    	var arr [3]int
    	arr[i] = 999
    	fmt.Println(arr)
    }
    func main() {
    	test1(3)
    }
    
    panic: runtime error: index out of range [3] with length 3
                                                              
    goroutine 1 [running]:                                    
    main.test1(0xc000052000?)                                 
            C:/Users/nlp_1/goWorkspace/src/main.go:7 +0x87    
    main.main()                                               
            C:/Users/nlp_1/goWorkspace/src/main.go:11 +0x18  
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    通过观察错误信息,发现确实是panic异常,导致了整个程序崩溃。

    延迟调用defer

    一、defer基本使用
    函数定义完成后,只有调用函数才能够执行,并且一经调用立即执行。例如:

    fmt.Println("hello")
    fmt.Println("老王")
    
    • 1
    • 2

    先输出“hello”,然后再输出“老王”。但是关键字defer⽤于延迟一个函数(或者当前所创建的匿名函数)的执行。注意,defer语句只能出现在函数的内部。

    基本用法如下:

    defer fmt.Println("hello")
    fmt.Println("老王")
    
    • 1
    • 2

    以上两行代码,输出的结果为,先输出“老王”,然后输出“hello”。

    defer的应用场景:文件操作,先打开文件,执行读写操作,最后关闭文件。为了保证文件的关闭能够正确执行,可以使用defer。

    2、 defer执行顺序
    先看如下程序执行结果是:

    defer fmt.Println("hello")
    defer fmt.Println("老王")
    defer fmt.Println("你好")
    
    • 1
    • 2
    • 3

    执行的结果是:

    你好

    老王

    hello

    总结:如果一个函数中有多个defer语句,它们会以后进先出的顺序执行。

    如下程序执行的结果:

    func test03(x int) {
    	v := 100 / x
    	fmt.Println(v)
    }
    func main() {
    
    	defer fmt.Println("hello")
    	defer fmt.Println("老王")
    	defer test03(0)
    	defer fmt.Println("你好")
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    执行结果:
    你好
    老王
    hello
    panic: runtime error: integer divide by zero

    即使函数或某个延迟调用发生错误,这些调用依旧会被执⾏。

    三、defer与匿名函数结合使用

    我们先看以下程序的执行结果:

    a := 10
    b := 20
    defer func() {
      fmt.Println("匿名函数a", a)
      fmt.Println("匿名函数b", b)
    }()
    
    a = 100
    b = 200
    fmt.Println("main函数a", a)
    fmt.Println("main函数b", b)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    执行的结果如下:

    main函数a 100
    main函数b 200
    匿名函数a 100
    匿名函数b 200
    
    • 1
    • 2
    • 3
    • 4

    前面讲解过,defer会延迟函数的执行,虽然立即调用了匿名函数,但是该匿名函数不会执行,等整个main()函数结束之前在去调用执行匿名函数,所以输出结果如上所示。

    现在将程序做如下修改:

    a := 10
    b := 20
    defer func(a,b int) {	//添加参数
      fmt.Println("匿名函数a", a)
      fmt.Println("匿名函数b", b)
    }(a,b) //传参
    
    a = 100
    b = 200
    fmt.Println("main函数a", a)
    fmt.Println("main函数b", b)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    该程序的执行结果如下:

    main函数a 100
    main函数b 200
    匿名函数a 10
    匿名函数b 20
    
    • 1
    • 2
    • 3
    • 4

    从执行结果上分析,由于匿名函数前面加上了defer所以,匿名函数没有立即执行。但是问题是,程序从上开始执行当执行到匿名函数时,虽然没有立即调用执行匿名函数,但是已经完成了参数的传递。

    recover函数

    运行时panic异常一旦被引发就会导致程序崩溃。这当然不是我们愿意看到的,因为谁也不能保证程序不会发生任何运行时错误。

    Go语言为我们提供了专用于“拦截”运行时panic的内建函数——recover。它可以是当前的程序从运行时panic的状态中恢复并重新获得流程控制权。

    看下面例子:

    package main
    
    import "fmt"
    
    func testA() {
    	fmt.Println("testA")
    
    }
    
    func testB(x int) {
    
    	var a [3]int
    	a[x] = 999
    }
    
    func testC() {
    	fmt.Println("testC")
    }
    func main() {
    	testA()
    	testB(3) //发生异常 中断程序
    	testC()
    }
    
    testA
    panic: runtime error: index out of range [3] with length 3
                                                              
    goroutine 1 [running]:                                    
    main.testB(...)                                           
            C:/Users/nlp_1/goWorkspace/src/main.go:13         
    main.main()                                               
            C:/Users/nlp_1/goWorkspace/src/main.go:21 +0x5b   
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    函数B发生了异常就不会再往下 执行了

    使用recover

    func testA() {
    	fmt.Println("testA")
    
    }
    
    func testB(x int) {
    	//设置recover()
    
    	//在defer调用的函数中使用recover()
    	defer func() {
    		//防止程序崩溃
    		recover()
    	}() //匿名函数
    
    	var a [3]int
    	a[x] = 999
    }
    
    func testC() {
    	fmt.Println("testC")
    }
    func main() {
    	testA()
    	testB(3) //发生异常 中断程序
    	testC()
    }
    
    // 输出结果
    testA
    testC
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    通过以上程序,我们发现虽然TestB()函数会导致整个应用程序崩溃,但是由于在改函数中调用了recover()函数,所以整个函数并没有崩溃。虽然程序没有崩溃,但是我们也没有看到任何的提示信息,那么怎样才能够看到相应的提示信息呢?

    可以直接打印recover()函数的返回结果,如下所示:

    func testB(x int)  {
        //设置recover()
    
        //在defer调用的函数中使用recover()
        defer func() {
            //防止程序崩溃
            //recover()
            fmt.Println(recover())    //直接打印
        }()  //匿名函数
    
        var a [3]int
        a[x] = 999
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    输出结果如下:

    testA
    runtime error: index out of range
    testC
    
    • 1
    • 2
    • 3

    从输出结果发现,确实打印出了相应的错误信息。

    但是,如果程序没有出错,也就是数组下标没有越界,会出现什么情况呢?

    func testA()  {
        fmt.Println("testA")
    
    }
    func testB(x int)  {
        //设置recover()
    
        //在defer调用的函数中使用recover()
        defer func() {
            //防止程序崩溃
            //recover()
            fmt.Println(recover())
        }()  //匿名函数
    
        var a [3]int
        a[x] = 999
    }
    
    func testC()  {
        fmt.Println("testC")
    }
    func main() {
        testA()
        testB(0)  //发生异常 中断程序
        testC()
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    输入的结果如下:

    testA
    <nil>
    testC
    
    • 1
    • 2
    • 3

    这时输出的是空,但是我们希望程序没有错误的时候,不输出任何内容。

    所以,程序修改如下:

    func testA()  {
        fmt.Println("testA")
    }
    
    func testB(x int)  {
        //设置recover()
    
        //在defer调用的函数中使用recover()
        defer func() {
            //防止程序崩溃
            //recover()
            //fmt.Println(recover())
    
            if err := recover();err != nil {
                fmt.Println(err)
            }
        }()  //匿名函数
    
        var a [3]int
        a[x] = 999
    }
    
    func testC()  {
        fmt.Println("testC")
    }
    func main() {
        testA()
        testB(0)  //发生异常 中断程序
        testC()
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    通过以上代码,发现其实就是加了一层判断。这样就不会使得程序崩溃。

  • 相关阅读:
    5.14 Get Log Page Command
    查看服务器的配置,系统,cpu等信息
    [附源码]java毕业设计健身健康规划系统
    P13 JDBC 简介
    strncpy,strncat,strncmp字符串函数详解(长度受限制)
    【SSM】我的第一个SSM整合项目
    231n--CNN 卷积神经网络
    MySQL数据库进阶第五篇(锁)
    Shell脚本:Linux Shell脚本学习指南(第一部分Shell基础)一
    Linux-Nginx安装
  • 原文地址:https://blog.csdn.net/weixin_47906106/article/details/132859944