Go语言异常处理

淡淡的烟草味﹌ 2023-10-09 22:06 1阅读 0赞

#### 阅读目录 ####

*  异常处理
 *   *  打印异常信息
     *  中断程序
     *  恢复程序通过 defer 和 recover 实现

> 一个人走的太慢，一群人才能走的更远。

## 异常处理 ##

程序运行时，发生不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。

golang中提供了两种处理异常的方式：

*  一种是程序发生异常时, 将异常信息反馈给使用者。
 *  一种是程序发生异常时, 立刻退出终止程序继续运行。

### 打印异常信息 ###

Go语言中提供了两种创建异常信息的方式。

方式一:  
通过 fmt 包中的 Errorf 函数创建错误信息, 然后打印。

package main
    
    import "fmt"
    
    func main() {
        
    	// 1.创建错误信息
    	var err error = fmt.Errorf("这里是错误信息")
    	// 2.打印错误信息
    	fmt.Println(err) // 这里是错误信息
    }

方式二:  
通过 errors 包中的 New 函数创建错误信息，然后打印。

package main
    
    import (
    	"errors"
    	"fmt"
    )
    
    func main() {
        
    	// 1.创建错误信息
    	var err error = errors.New("这里是错误信息")
    	// 2.打印错误信息
    	fmt.Println(err) // 这里是错误信息
    }

应用示例

package main
    
    import (
    	"errors"
    	"fmt"
    )
    
    func div(a, b int) (res int, err error) {
        
    	if b == 0 {
        
    		// 一旦传入的除数为0, 就会返回error信息
    		err = errors.New("除数不能为0")
    	} else {
        
    		res = a / b
    	}
    	return
    }
    func main() {
        
    	//res, err := div(10, 5)
    	res, err := div(10, 0)
    	if err != nil {
        
    		fmt.Println(err) // 除数不能为0
    	} else {
        
    		fmt.Println(res) // 2
    	}
    	fmt.Println("嘿嘿")
    }

root@debiancc:~/www/test# go run test.go 
    除数不能为0
    嘿嘿
    root@debiancc:~/www/test#

### 中断程序 ###

Go语言中提供了一个叫做 panic 函数, 用于发生异常时终止程序继续运行。

package main
    
    import "fmt"
    
    func div(a, b int) (res int) {
        
    	if b == 0 {
        
    		//一旦传入的除数为0, 程序就会终止
    		panic("除数不能为0")
    	} else {
        
    		res = a / b
    	}
    	return
    }
    func main() {
        
    	res := div(10, 0)
    	fmt.Println(res)
    }

root@debiancc:~/www/test# go run test.go 
    panic: 除数不能为0
    
    goroutine 1 [running]:
    main.div(...)
            /root/www/test/test.go:8
    main.main()
            /root/www/test/test.go:15 +0x27
    exit status 2
    root@debiancc:~/www/test#

Go语言中有两种方式可以触发panic终止程序。

1 自己手动调用 panic 函数。  
2 程序内部出现问题自动触发 panic 函数。

package main
    
    import "fmt"
    
    func main() {
        
    	// 例如:数组角标越界, 就会自动触发panic
    	var arr = [3]int{
        1, 3, 5}
    	arr[5] = 666 // 报错
    	fmt.Println(arr)
    
    	// 例如:除数为0, 就会自动触发panic
    	var res = 10 / 0
    	fmt.Println(res)
    }

除非是不可恢复性、导致系统无法正常工作的错误, 否则不建议使用 panic。

### 恢复程序通过 defer 和 recover 实现 ###

程序和人一样都需要具备一定的容错能力, 学会知错就改。

所以如果不是不可恢复性、导致系统无法正常工作的错误, 如果发生了 panic 我们需要恢复程序, 让程序继续执行，并且需要记录到底犯了什么错误。

Go语言中我们可以通过 defer 和 recover 来实现 panic 异常的捕获, 让程序继续执行。

package main
    
    import "fmt"
    
    func div(a, b int) (res int) {
        
    	// 定义一个延迟调用的函数, 用于捕获panic异常
    	// 注意: 一定要在panic之前定义
    	defer func() {
        
    		if err := recover(); err != nil {
        
    			res = -1
    			fmt.Println(err) // 除数不能为0
    		}
    	}()
    	if b == 0 {
        
    		//err = errors.New("除数不能为0")
    		panic("除数不能为0")
    	} else {
        
    		res = a / b
    	}
    	return
    }
    
    func main() {
        
    	res := div(10, 0)
    	fmt.Println(res) // -1
    }

> panic注意点  
> panic 异常会沿着调用堆栈向外传递, 所以也可以在外层捕获。

package main
    
    import "fmt"
    
    func div(a, b int) (res int) {
        
    	if b == 0 {
        
    		//err = errors.New("除数不能为0")
    		panic("除数不能为0")
    	} else {
        
    		res = a / b
    	}
    	return
    }
    func main() {
        
    	// panic异常会沿着调用堆栈向外传递, 所以也可以在外层捕获
    	defer func() {
        
    		if err := recover(); err != nil {
        
    			fmt.Println(err) // 除数不能为0
    		}
    	}()
    	div(10, 0)
    }

多个异常,只有第一个会被捕获。

package main
    
    import "fmt"
    
    func test1(a, b int) {
        
    	// 多个异常,只有第一个会被捕获
    	defer func() {
        
    		if err := recover(); err != nil {
        
    			fmt.Println(err, "cccc") // 异常A
    		}
    	}()
    	panic("异常A") // 相当于return, 后面代码不会继续执行
    	panic("异常B")
    }
    func main() {
        
    	test1(10, 0)
    }

如果有异常写在 defer 中, 那么只有 defer 中的异常会被捕获。

package main
    
    import "fmt"
    
    func test2(c, d int) {
        
    	// 如果有异常写在defer中, 并且其它异常写在defer后面, 那么只有defer中的异常会被捕获
    	defer func() {
        
    		if err := recover(); err != nil {
        
    			fmt.Println(err) // 异常B
    		}
    	}()
    
    	defer func() {
        
    		panic("异常B")
    	}()
    	panic("异常A")
    }
    func main() {
        
    	test2(10, 0)
    }