defer

Go語言中有種不錯的設計，即延遲（defer）語句，你可以在函式中新增多個defer語句。當函式執行到最後時，這些defer語句會按照逆序執行，最後該函式返回。特別是當你在進行一些開啟資源的操作時，遇到錯誤需要提前返回，在返回前你需要關閉相應的資源，不然很容易造成資源洩露等問題。如下程式碼所示，我們一般寫開啟一個資源是這樣操作的：

func ReadWrite() bool {
    file.Open("file")
// 做一些工作
    if failureX {
        file.Close()
        return false
    }

    if failureY {
        file.Close()
        return false
    }

    file.Close()
    return true
}

我們看到上面有很多重複的程式碼，Go的defer有效解決了這個問題。使用它後，不但程式碼量減少了很多，而且程式變得更優雅。在defer後指定的函式會在函式退出前呼叫。

func ReadWrite() bool {
    file.Open("file")
    defer file.Close()
    if failureX {
        return false
    }
    if failureY {
        return false
    }
    return true
}

如果有很多呼叫defer，那麼defer是採用後進先出模式，所以如下程式碼會輸出4 3 2 1 0

for i := 0; i < 5; i++ {
    defer fmt.Printf("%d ", i)
}

defer 給我的第一印象就是，類似java中的

try {

}finally {

}

我目前的理解就是，在函式塊中使用defer，就是函式對應的有一個棧空間，先進後出。需要函式結束後呼叫棧，來出發defer操作。

如果，一個物件的建立，很消耗記憶體，需要及時關閉，defer無法像try finnaly哪樣準確。

package main

import "fmt"
import "time"

type User struct {
        username string
}

func (this *User) Close() {
        fmt.Println(this.username, "Closed !!!")
}

func main() {
        u1 := &User{"jack"}
        defer u1.Close()
        u2 := &User{"lily"}
        defer u2.Close()

        time.Sleep(10 * time.Second)

        fmt.Println("Done !")

}
[
 
[email protected] goroutine]$

[[email protected] goroutine]$ go run deferTest1.go
Done !
lily Closed !!!
jack Closed !!!
[[email protected] goroutine]$

實際上，執行緒Sleep的10秒，u1，和u2早就可以Close()了，但卻需要依賴main()函式的結束，才能defer執行。

那麼嘗試給defer新增內部程式碼區：

package main

import "fmt"
import "time"

type User struct {
        username string
}

func (this *User) Close() {
        fmt.Println(this.username, "Closed !!!")
}

func main() {
        {
                // 即便加了程式碼快範圍，依舊也要主函式體結束才執行defer
                u1 := &User{"jack"}
                defer u1.Close()
        }
        u2 := &User{"lily"}
        defer u2.Close()

        time.Sleep(10 * time.Second)

        fmt.Println("Done !")

}

Done !
lily Closed !!!
jack Closed !!!
[[email protected] goroutine]$

依舊defer的執行在Done！後。那麼如何才能達到try finally 哪樣準確的Close呢？

package main

import "fmt"
import "time"

type User struct {
        username string
}

func (this *User) Close() {
        fmt.Println(this.username, "Closed !!!")
}

func main() {
        u1 := &User{"jack"}
        f(u1) // 這樣的方式，u1才會不依賴main函式的執行

        // 這樣的方式，u2也不會依賴main函式的執行
        u2 := &User{"lily"}
        // m := func() {
        //         defer u2.Close()
        //         // u2 do somthing
        // }
        // m()

        func() {
                 defer u2.Close()
                 // u2 do somthing
        }()

time.Sleep(10 * time.Second) fmt.Println("Done !")}func f(u *User) { defer u.Close() // u1 do gomething}
[[email protected] goroutine]$ go run deferTest3.go
jack Closed !!!
lily Closed !!!
Done !

這樣的使用方式，視乎不太合理，但卻有存在的必要性。大多數情況下，可以用於 u1,u2  之類非常消耗記憶體，或者cpu，其後執行時間過程且沒有太多關聯的情況。既保留了defer的功能特性，也滿足範圍精確控制的條件！