一文帶你掌握go中的異常處理

更新時間：2023年09月14日 09:04:30 作者：季布，

代碼在執(zhí)行的過程中可能因為一些邏輯上的問題而出現(xiàn)錯誤,我們稱之為異常,那么如何處理這些異常呢,下面小編就來和大家詳細聊聊golang中的異常處理機制吧

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語言引入了一個關(guān)于錯誤處理的標準模式，即error接口，它是Go語言內(nèi)建的接口類型，該接口的定義如下：

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

這種用法是非常常見的，例如，后面講解到文件操作時，涉及到文件的打開，如下：

在打開文件時，如果文件不存在，或者文件在磁盤上存儲的路徑寫錯了，都會出現(xiàn)異常，這時可以使用error記錄相應的錯誤信息。

panic函數(shù)

error返回的是一般性的錯誤，但是panic函數(shù)返回的是讓程序崩潰的錯誤。

也就是當遇到不可恢復的錯誤狀態(tài)的時候，如數(shù)組訪問越界、空指針引用等，這些運行時錯誤會引起panic異常，在一般情況下，我們不應通過調(diào)用panic函數(shù)來報告普通的錯誤，而應該只把它作為報告致命錯誤的一種方式。當某些不應該發(fā)生的場景發(fā)生時，我們就應該調(diào)用panic。

一般而言，當panic異常發(fā)生時，程序會中斷運行。隨后，程序崩潰并輸出日志信息。日志信息包括panic value和函數(shù)調(diào)用的堆棧跟蹤信息。

當然，如果直接調(diào)用內(nèi)置的panic函數(shù)也會引發(fā)panic異常，panic函數(shù)接受任何值作為參數(shù)。

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

通過觀察錯誤信息，發(fā)現(xiàn)確實是panic異常，導致了整個程序崩潰。

延遲調(diào)用defer

1、defer基本使用

函數(shù)定義完成后，只有調(diào)用函數(shù)才能夠執(zhí)行，并且一經(jīng)調(diào)用立即執(zhí)行。例如：

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

先輸出“hello”,然后再輸出“老王”。但是關(guān)鍵字defer?于延遲一個函數(shù)（或者當前所創(chuàng)建的匿名函數(shù)）的執(zhí)行。注意，defer語句只能出現(xiàn)在函數(shù)的內(nèi)部。

基本用法如下：

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

以上兩行代碼，輸出的結(jié)果為，先輸出“老王”，然后輸出“hello”。

defer的應用場景：文件操作，先打開文件，執(zhí)行讀寫操作，最后關(guān)閉文件。為了保證文件的關(guān)閉能夠正確執(zhí)行，可以使用defer。

2、 defer執(zhí)行順序

先看如下程序執(zhí)行結(jié)果是：

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

執(zhí)行的結(jié)果是：

你好
老王
hello

總結(jié)：如果一個函數(shù)中有多個defer語句，它們會以后進先出的順序執(zhí)行。

如下程序執(zhí)行的結(jié)果：

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

執(zhí)行結(jié)果：

你好
老王
hello
panic: runtime error: integer divide by zero

即使函數(shù)或某個延遲調(diào)用發(fā)生錯誤，這些調(diào)用依舊會被執(zhí)?。

defer與匿名函數(shù)結(jié)合使用

我們先看以下程序的執(zhí)行結(jié)果：

a := 10
b := 20
defer func() {
  fmt.Println("匿名函數(shù)a", a)
  fmt.Println("匿名函數(shù)b", b)
}()
???????a = 100
b = 200
fmt.Println("main函數(shù)a", a)
fmt.Println("main函數(shù)b", b)

執(zhí)行的結(jié)果如下：

main函數(shù)a 100
main函數(shù)b 200
匿名函數(shù)a 100
匿名函數(shù)b 200

前面講解過，defer會延遲函數(shù)的執(zhí)行，雖然立即調(diào)用了匿名函數(shù)，但是該匿名函數(shù)不會執(zhí)行，等整個main()函數(shù)結(jié)束之前在去調(diào)用執(zhí)行匿名函數(shù)，所以輸出結(jié)果如上所示。

現(xiàn)在將程序做如下修改：

a := 10
b := 20
defer func(a,b int) {    //添加參數(shù)
  fmt.Println("匿名函數(shù)a", a)
  fmt.Println("匿名函數(shù)b", b)
}(a,b) //傳參
???????a = 100
b = 200
fmt.Println("main函數(shù)a", a)
fmt.Println("main函數(shù)b", b)

該程序的執(zhí)行結(jié)果如下：

main函數(shù)a 100
main函數(shù)b 200
匿名函數(shù)a 10
匿名函數(shù)b 20

從執(zhí)行結(jié)果上分析，由于匿名函數(shù)前面加上了defer所以，匿名函數(shù)沒有立即執(zhí)行。但是問題是，程序從上開始執(zhí)行當執(zhí)行到匿名函數(shù)時，雖然沒有立即調(diào)用執(zhí)行匿名函數(shù)，但是已經(jīng)完成了參數(shù)的傳遞。

recover函數(shù)

運行時panic異常一旦被引發(fā)就會導致程序崩潰。這當然不是我們愿意看到的，因為誰也不能保證程序不會發(fā)生任何運行時錯誤。

Go語言為我們提供了專用于“攔截”運行時panic的內(nèi)建函數(shù)——recover。它可以是當前的程序從運行時panic的狀態(tài)中恢復并重新獲得流程控制權(quán)。

看下面例子：

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) //發(fā)生異常 中斷程序
	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

函數(shù)B發(fā)生了異常就不會再往下執(zhí)行了

使用recover

func testA() {
	fmt.Println("testA")
}
func testB(x int) {
	//設(shè)置recover()
	//在defer調(diào)用的函數(shù)中使用recover()
	defer func() {
		//防止程序崩潰
		recover()
	}() //匿名函數(shù)
	var a [3]int
	a[x] = 999
}
func testC() {
	fmt.Println("testC")
}
func main() {
	testA()
	testB(3) //發(fā)生異常 中斷程序
	testC()
}
// 輸出結(jié)果
testA
testC

通過以上程序，我們發(fā)現(xiàn)雖然TestB()函數(shù)會導致整個應用程序崩潰，但是由于在改函數(shù)中調(diào)用了recover()函數(shù)，所以整個函數(shù)并沒有崩潰。雖然程序沒有崩潰，但是我們也沒有看到任何的提示信息，那么怎樣才能夠看到相應的提示信息呢？

可以直接打印recover()函數(shù)的返回結(jié)果，如下所示：

func testB(x int)  {
    //設(shè)置recover()
    //在defer調(diào)用的函數(shù)中使用recover()
    defer func() {
        //防止程序崩潰
        //recover()
        fmt.Println(recover())    //直接打印
    }()  //匿名函數(shù)
    var a [3]int
    a[x] = 999
}

輸出結(jié)果如下：

testA
runtime error: index out of range
testC

從輸出結(jié)果發(fā)現(xiàn)，確實打印出了相應的錯誤信息。

但是，如果程序沒有出錯，也就是數(shù)組下標沒有越界，會出現(xiàn)什么情況呢？

func testA()  {
    fmt.Println("testA")
}
func testB(x int)  {
    //設(shè)置recover()
    //在defer調(diào)用的函數(shù)中使用recover()
    defer func() {
        //防止程序崩潰
        //recover()
        fmt.Println(recover())
    }()  //匿名函數(shù)
    var a [3]int
    a[x] = 999
}
func testC()  {
    fmt.Println("testC")
}
func main() {
    testA()
    testB(0)  //發(fā)生異常 中斷程序
    testC()
}

輸入的結(jié)果如下：

testA
<nil>
testC

這時輸出的是空，但是我們希望程序沒有錯誤的時候，不輸出任何內(nèi)容。

所以，程序修改如下：

func testA()  {
    fmt.Println("testA")
}
func testB(x int)  {
    //設(shè)置recover()
    //在defer調(diào)用的函數(shù)中使用recover()
    defer func() {
        //防止程序崩潰
        //recover()
        //fmt.Println(recover())
        if err := recover();err != nil {
            fmt.Println(err)
        }
    }()  //匿名函數(shù)
    var a [3]int
    a[x] = 999
}
func testC()  {
    fmt.Println("testC")
}
func main() {
    testA()
    testB(0)  //發(fā)生異常 中斷程序
    testC()
}

通過以上代碼，發(fā)現(xiàn)其實就是加了一層判斷。這樣就不會使得程序崩潰。

以上就是一文帶你掌握go中的異常處理的詳細內(nèi)容，更多關(guān)于go異常處理的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: