爱上开源之golang入门至实战第四章函数(Func)(十)

爱上开源之golang入门至实战第四章函数(Func)(十)

前言

函数是各种编程语言里组成编程逻辑的主要部分；特别在Go语言中，Go语言削弱了面向对象编程的一些特性，比如构造函数，多态，抽象等，在函数式编程方面进行了类似于javascript和python等语言的借鉴，由此在咱们的第四章函数章节里，已经就细化了十个章节来进行各个方面的介绍。今天的这个文章，接着一文中对defer和recover的介绍，进一步深入的通过代码样例来学习函数。

 

Recover的顺序

我们把上一文中对processErrorPlus的调用代码，进行一下改造，把recover的processErrorPlus的defer调用，放在第二个defer之后，会有什么样的效果呢。

调整后的代码

func TestDeferFun8(t *testing.T) {
   defer fmt.Println("Defer Func 1")
​
   defer processErrorPlus(func(err error) {
      fmt.Printf("Defer Func 2 error: %v\n", err)
   })
​
   defer fmt.Println("Defer Func 3")
​
   fmt.Println("Test")
​
   panic("This is a testing")
}
​
​
===== OUTPUT =====
Test
Defer Func 3
Defer Func 2 error: This is a testing
Defer Func 1

可以看到Recover在Defer Func 2中已经成功调用， 对后面的defer次序没有影响。

Recover重复处理Error

现在在每个defer都进行processErrorPlus调用， 并且修改processErrorPlus函数，函数processErrorPlus分别对recover存在error进行处理，和没有进行处理，修改后的processErrorPlus；如下代码

type DoError func(err error)
type DoNotError func()
​
func processErrorPlus2(doError DoError, notError DoNotError) {
    if e := recover(); e != nil {
        if doError != nil {
            var err error
            switch x := e.(type) {
            case string:
                err = errors.New(x)
            case error:
                err = x
            default:
                err = errors.New("unknown panic")
            }
​
            doError(err)
        }
    } else {
        if notError != nil {
            notError()
        }
    }
}

如上代码，processErrorPlus2传入两个参数，都是函数类型的参数， 一个用来进行recover有error时的回调函数，一个用来进行recover没有error时的回调函数； 把主要的函数也进行修改， 三个defer函数都是用processErrorPlus2的函数处理；代码如下：

​
func TestDeferFun9(t *testing.T) {
    defer processErrorPlus2(func(err error) {
        fmt.Printf("Defer Func 1 error: %v\n", err)
    }, func() {
        fmt.Printf("Defer Func 1 \n")
    })
​
    defer processErrorPlus2(func(err error) {
        fmt.Printf("Defer Func 2 error: %v\n", err)
    }, func() {
        fmt.Printf("Defer Func 2 \n")
    })
​
    defer processErrorPlus2(func(err error) {
        fmt.Printf("Defer Func 3 error: %v\n", err)
    }, func() {
        fmt.Printf("Defer Func 3 \n")
    })
​
    fmt.Println("Test")
​
    panic("This is a testing")
}
​
​
===== OUTPUT =====
Test
Defer Func 3 error: This is a testing
Defer Func 2 
Defer Func 1 

通过上面的代码样例，从执行结果来看， 当主函数里使用panic声明出异常；在依次执行三个defer函数中，

先执行Defer Func 3这个processErrorPlus2的defer函数调用，在processErrorPlus2函数中，通过recover获取当前的error，此时error存在，故执行了传入的DoError的回调函数；也就输出了“Defer Func 3 error: This is a testing”；

Func3段执行结束后，接下来执行Func2这段的processErrorPlus2的defer函数调用，此时再从recover中获取error，error已经在上个defer中获取完毕， 此时在获取error就为nil了；也就只会执行DoNotError的回调函数了。所以此时输出“Defer Func 2”；

最后还有Func1的defer函数调用； 和第二个一样，前面的panic已经获取过了，这里recover的error亦然为nil；所以输出“Defer Func 1”；

recover中的panic

如果在回调里加入panic会是怎样了， 我们改下代码再来试试

​

func TestDeferFun10(t *testing.T) {
    defer processErrorPlus2(func(err error) {
        fmt.Printf("Defer Func 1 error: %v\n", err)
    }, func() {
        fmt.Printf("Defer Func 1 \n")
    })
​
    defer processErrorPlus2(func(err error) {
        panic(fmt.Sprintf("Func 2 panic: %v", err))
    }, func() {
        fmt.Printf("Defer Func 2 \n")
    })
​
    defer processErrorPlus2(func(err error) {
        panic(fmt.Sprintf("Func 3 panic: %v", err))
    }, func() {
        fmt.Printf("Defer Func 3 \n")
    })
​
    fmt.Println("Test")
​
    panic("This is a testing")
}

这段代码对比上面的TestDeferFun9代码，我们来看看，在Func3和Func2的defer processErrorPlus2有些差别； Func3和Func2这里不是简单的打印出error了，而是把recover获取到的error包装成新的error，继续通过panic进行声明；这个操作类似于java中的，在try catch中获取到了exception后，再次通过throw进行exception的上抛。 结果会是如何，让我们来看看执行的结果：

=== RUN   TestDeferFun10
Test
Defer Func 1 error: Func 2 panic: Func 3 panic: This is a testing
--- PASS: TestDeferFun10 (0.00s)
PASS

结束语

通过这两遍介绍defer和recover的文章， 我们可以使用defer和recover的方式，完全的实现java里的exception处理的效果。