一文带你掌握go中的异常处理

代码在执行的过程中可能因为一些逻辑上的问题而出现错误 func test1(a, b int) int {result := a breturn resul

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

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

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

这种用法是非常常见的，例如，后面讲解到文件操作时，涉及到文件的打开，如下：

在打开文件时，如果文件不存在，或者文件在磁盘上存储的路径写错了，都会出现异常，这时可以使用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

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

延迟调用defer

1、defer基本使用

函数定义完成后，只有调用函数才能够执行，并且一经调用立即执行。例如：

fmt.Println("hello")
fmt.Println("老王")

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

基本用法如下：

defer fmt.Println("hello")
fmt.Println("老王")

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

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

2、 defer执行顺序

先看如下程序执行结果是：

defer fmt.Println("hello")
defer fmt.Println("老王")
defer fmt.Println("你好")

执行的结果是：

你好
老王
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("你好")
}

执行结果：

你好
老王
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)

执行的结果如下：

main函数a 100
main函数b 200
匿名函数a 100
匿名函数b 200

前面讲解过，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)

该程序的执行结果如下：

main函数a 100
main函数b 200
匿名函数a 10
匿名函数b 20

从执行结果上分析，由于匿名函数前面加上了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

函数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

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

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

func testB(x int)  {
    //设置recover()
    //在defer调用的函数中使用recover()
    defer func() {
        //防止程序崩溃
        //recover()
        fmt.Println(recover())    //直接打印
    }()  //匿名函数
    var a [3]int
    a[x] = 999
}

输出结果如下：

testA
runtime error: index out of range
testC

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

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

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()
}

输入的结果如下：

testA
<nil>
testC

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

所以，程序修改如下：

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()
}

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

以上就是一文带你掌握go中的异常处理的详细内容，更多关于go异常处理的资料请关注好代码网其它相关文章！