Golang異常處理-panic與recover

　　　　　　　　　　　　　　　　　　　　Golang異常處理-panic與recover

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑

版權聲明：原創作品，謝絕轉載！否則將追究法律責任。

 

 

　　在程序設計中，容錯是相當重要的一部分工作，在 Go中它是通過錯誤處理來實現的，error 雖然只是一個接口，但是其變化卻可以有很多，我們可以根據自己的需求來實現不同的處理。任何時候當你需要一個新的錯誤類型，都可以用 errors （必須先 import）包的 errors.New 函數接收合適的錯誤信息來創建。

 

 

一.自定義的一個錯誤類型

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/

package main

import (
    "errors"
    "fmt"
)

var (
    CustomError error            //用於定義錯誤的變量。
    PromptInformation string    //用於定義提示信息的變量。
)

func main() {
    PromptInformation = "這是自定義的一個錯誤類型！"
    CustomError = errors.New(PromptInformation) //errors包的New方法就可以創建一個error類型的數據，不過他需要你傳入一個字符串類型用於給用戶的提示信息。
    fmt.Printf("error: %v", CustomError)
}



#以上代碼執行結果如下：
error: 這是自定義的一個錯誤類型！

 

二.調用自定義的錯誤

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/

package main

import (
    "errors"
    "fmt"
)

type Customer struct {
    Name string
    Deposit float64
}

func CustomError()error {  //這是我們自己定義的錯誤
    return errors.New("對不起，您的余額已不足。")
}

func TransferAccounts(name1, name2 Customer,money float64) (Customer,Customer,error) {    //這個函數是用來實現轉賬的功能。
    if name1.Deposit - money < 0 {
        return name1,name2, CustomError()
    }else {
         name1.Deposit = name1.Deposit - money
         name2.Deposit = name2.Deposit + money
    }
    return name1,name2, nil
}

func main() {
    yzj := Customer{"尹正傑",1000000}
    Linus := Customer{"林納斯·托瓦茲",100}

    name1,name2,err := TransferAccounts(yzj,Linus,50000) //如果在賬戶余額充足的情況下，是不會報錯的，我們讓他輸入兩個人各自的余額。
    if err != nil {
        fmt.Println(err)
    }else {
        fmt.Println(name1,name2)
    }

    name1,name2,err = TransferAccounts(yzj,Linus,600000000000000)  //注意，這是第二次調轉賬啦。這回我們故意把轉賬的金額寫的遠遠大於存款。就會拋出我們定義的錯誤。
    if err != nil {
        fmt.Println(err)
    }else {
        fmt.Println(name1,name2)
    }
}



#以上代碼執行結果如下：
{尹正傑 950000} {林納斯·托瓦茲 50100}
對不起，您的余額已不足。

 

 

三.用 fmt 創建錯誤對象

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/

package main

import (
    "fmt"
)

type Customer struct {
    Name string
    Deposit float64
}

func TransferAccounts(name1, name2 Customer,money float64) (Customer,Customer,error) {    //這個函數是用來實現轉賬的功能。
    if name1.Deposit - money < 0 {
        return name1,name2, fmt.Errorf("對不起，【%s】的用戶余額已不足!",name1.Name)    //通常你想要返回包含錯誤參數的更有信息量的字符串就可以用可以用 fmt.Errorf() 來實現。
    }else {
        name1.Deposit = name1.Deposit - money
        name2.Deposit = name2.Deposit + money
    }
    return name1,name2, nil
}

func main() {
    yzj := Customer{"尹正傑",1000000}
    Linus := Customer{"林納斯·托瓦茲",100}

    name1,name2,err := TransferAccounts(yzj,Linus,50000) //如果在賬戶余額充足的情況下，是不會報錯的，我們讓他輸入兩個人各自的余額。
    if err != nil {
        fmt.Println(err)
    }else {
        fmt.Println(name1,name2)
    }

    name1,name2,err = TransferAccounts(yzj,Linus,600000000000000)  //注意，這是第二次調轉賬啦。這回我們故意把轉賬的金額寫的遠遠大於存款。就會拋出我們定義的錯誤。
    if err != nil {
        fmt.Println(err)
    }else {
        fmt.Println(name1,name2)
    }
}



#以上代碼執行結果如下：
{尹正傑 950000} {林納斯·托瓦茲 50100}
對不起，【尹正傑】的用戶余額已不足!

 

 

四.運行時異常和 panic

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/


package main

import (
    "bufio"
    "os"
    "fmt"
)

var   (
    String string
    Input string
)

func main()  {
    f := bufio.NewReader(os.Stdin) //讀取輸入的內容
    for {
        fmt.Print("請輸入您的用戶名>")
        Input,_ = f.ReadString('\n') //定義一行輸入的內容分隔符。
        if len(Input) == 1 {
            continue //如果用戶輸入的是一個空行就讓用戶繼續輸入。
        }
        fmt.Printf("您輸入的是:%s",Input)
        fmt.Sscan(Input,&String)
        if String == "stop" {
            break
        }
        if String == "yinzhengjie" {
            fmt.Println("歡迎登陸！")
        }else {
            panic("您輸入的用戶不存在！")        //該程序要求用戶輸入一個字符串，一旦輸入的字符串不是“yinzhengjie”就讓程序直接崩潰掉。
        }
    }
}



#以上代碼執行結果如下：
請輸入您的用戶名>yinzhengjie
您輸入的是:yinzhengjie
歡迎登陸！
請輸入您的用戶名>linus
您輸入的是:linus
panic: 您輸入的用戶不存在！

goroutine 1 [running]:
main.main()
    E:/Code/Golang/Golang_Program/錯誤處理/4.運行時異常和 panic.go:38 +0x3b1

Process f

 

 

五.從 panic 中恢復（Recover）

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/

package main

import (
    "fmt"
)

func badCall() {        //定義一個讓程序運行時崩潰的函數
    panic("bad end")
}

func test() {
    defer func() {
        if e := recover(); e != nil {
            fmt.Printf("Panicing %s\n", e)   //我們知道這個程序已經拋出了panic的錯誤了，但是我們用recover函數是可以處理這個錯誤的，我們這里的做法就是打印這個錯誤的輸出並且不讓程序崩潰。
        }
    }()
    badCall()    //調用這個運行時崩潰的函數，因此下面的一行代碼是不會被執行的，而是直接結束當前函數，而結束函數之后就會觸發defer關鍵字，因此會被recover函數捕捉。
    fmt.Printf("After bad call\r\n") // <-- wordt niet bereikt
}

func main() {
    fmt.Printf("Calling test\r\n")
    test()    //調用我們定義的函數，發現程序並沒有崩潰，而是可以繼續執行下一行代碼的喲！
    fmt.Printf("Test completed\r\n")
}




#以上代碼執行結果如下：
Calling test
Panicing bad end
Test completed

 

六.自定義包中的錯誤處理和 panicking

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/

package main

import (
    "fmt"
    "strings"
    "strconv"
)


type ParseError struct {  //定義一個處理錯誤的結構體
    key int
    Value string
    Err error
}

func (p *ParseError) String() string {  //給ParseError定義一個String()方法。
    return fmt.Sprintf(" [%q] type is not int!" , p.Value)
}


func JudgmentType(fields []string) (numbers []int) {  //這個函數是判斷fields切片中的每個元素是否都可以轉換成INT類型的。
    if len(fields) == 0 {
        panic("Nothing can be explained!")
    }
    for key, value := range fields {
        num, err := strconv.Atoi(value)    //這里是講每一個切片元素中的字符串進行轉換。
        if err != nil {
            panic(&ParseError{key, value, err})  //如果解析出錯就將自定義的ParseError結構體的error對象返回。
        }
        numbers = append(numbers, num)        //如果轉換成int類型沒有出錯的話就會被追加到一個提前定義好的切片中。
    }
    return  //我們這里可以寫numbers，說白了只要寫一個[]int類型的都可以，當然，如果你不寫的話默認就會返回我們提前定義好的numbers喲。
}


func StringParse(input string) (numbers []int, err error) {     //這個函數是用來解析字符串的。
    defer func() {                                              //用recover函數來接受panic拋出的錯誤信息。
        if ErrorOutput := recover(); ErrorOutput != nil {
            var ok  bool
            err, ok = ErrorOutput.(error)                        //很顯然，這里是一種斷言操作，即判斷是否有error類型出現。
            if !ok {
                err = fmt.Errorf("Parse error: %v", ErrorOutput)
            }
        }
    }()
    fields := strings.Fields(input)
    numbers = JudgmentType(fields)
    return
}

func main() {
    var yzj = []string{
        "100 200 300",
        "1 2 2.5 3",
        "30 * 40",
        "yinzhengjie Golang",
        "",
    }

    for _, ex := range yzj {
        fmt.Printf("正在解析[ %q]:\n ", ex)
        result, err := StringParse(ex)
        if err != nil {
            fmt.Println("解析結果：",err)
            continue
        }
        fmt.Println("解析結果：",result)
    }
}



#以上代碼執行結果如下：
正在解析[ "100 200 300"]:
 解析結果： [100 200 300]
正在解析[ "1 2 2.5 3"]:
 解析結果： Parse error:  ["2.5"] type is not int!
正在解析[ "30 * 40"]:
 解析結果： Parse error:  ["*"] type is not int!
正在解析[ "yinzhengjie Golang"]:
 解析結果： Parse error:  ["yinzhengjie"] type is not int!
正在解析[ ""]:
 解析結果： Parse error: Nothing can be explained!

 

七.一種用閉包處理錯誤的模式

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:[e-mail]
*/

package main

import "fmt"

func A() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in A", r)
        }
    }()
    fmt.Println("Calling A.")
    B(0)
    fmt.Println("Returned normally from g.")
}

func B(i int) {
    if i > 3 {
        fmt.Println("Panicking!")
        panic(fmt.Sprintf("%v", i))
    }
    defer fmt.Println("Defer in B", i)
    fmt.Println("Printing in B", i)
    B(i + 1)          //這里是一個遞歸函數函數。
}

func main() {
    A()
    fmt.Println("程序結束！")
}



#以上地面執行結果如下：
Calling A.
Printing in B 0
Printing in B 1
Printing in B 2
Printing in B 3
Panicking!
Defer in B 3
Defer in B 2
Defer in B 1
Defer in B 0
Recovered in A 4
程序結束！