腳本之家服務器常用軟件

快捷導航

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

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

代碼在執(zhí)行的過程中可能因為一些邏輯上的問題而出現錯誤,我們稱之為異常,那么如何處理這些異常呢,下面小編就來和大家詳細聊聊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語言引入了一個關于錯誤處理的標準模式，即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函數返回的是讓程序崩潰的錯誤。

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

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

當然，如果直接調用內置的panic函數也會引發(fā)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

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

延遲調用defer

1、defer基本使用

函數定義完成后，只有調用函數才能夠執(zhí)行，并且一經調用立即執(zhí)行。例如：

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

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

基本用法如下：

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

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

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

2、 defer執(zhí)行順序

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

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

執(zhí)行的結果是：

你好
老王
hello

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

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

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í)行結果：

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

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

defer與匿名函數結合使用

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

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)

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

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

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

現在將程序做如下修改：

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)

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

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

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

recover函數

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

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

看下面例子：

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

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

使用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) //發(fā)生異常 中斷程序
	testC()
}
// 輸出結果
testA
testC

通過以上程序，我們發(fā)現雖然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

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

但是，如果程序沒有出錯，也就是數組下標沒有越界，會出現什么情況呢？

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

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

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

您可能感興趣的文章: