golang閉包學習筆記

golang閉包學習筆記

在開發中，常常會將一個方法的參數設置爲可選，並設置一些默認值，使代碼更通用簡潔。在不少語言中這很容易，好比在C類語言中,可使用相同方法名不一樣參數的多個版本(重寫)， 而在像python這樣的語言中, 能夠給參數一個默認值，並在調用方法時忽略它們。可是在 Go中, 這兩種方式都用不了

• 經過閉包的方式來解決這個問題

package main

import "fmt"

//用於初始化參數不定的狀況，能夠傳入任意個參數
//能夠給每一個參數一個初始默認值，
//若是傳入了ServerOption函數，就能夠自定義這個字段的值，沒傳入這個字段的ServerOption則使用默認值

type options struct {
        a int
        b string
}

//定義了ServerOption爲一個函數，參數是*options
type ServerOption func(*options)

func NewOption(opt ...ServerOption) *options {
        r := new(options)
        for _, o := range opt {
                o(r)
        }
        return r
}

func InitA(a int) ServerOption {
        return func(o *options) {
                o.a = a
        }
}

func InitB(b string) ServerOption {
        return func(o *options) {
                o.b = b
        }
}

func main() {
        initFuncs := []ServerOption{
                InitA(100),
                InitB("hello"),
        }
        //將須要初始化的字段對應的函數傳入便可
        opts := NewOption(initFuncs...)
        fmt.Printf("opts = %+v\n", opts)
}

• 對閉包的深刻分析

在過去近十年時間裏，面向對象編程大行其道，以致於在大學的教育裏，老師也只會教給咱們兩種編程模型，面向過程和麪向對象。孰不知，在面向對象思想產生以前，函數式編程已經有了數十年的歷史。就讓咱們回顧這個古老又現代的編程模型，看看到底是什麼魔力將這個概念在21世紀的今天再次拉入咱們的視野

閉包是函數式編程語言中的概念，沒有研究過函數式語言的人可能很難理解閉包的強大

閉包=函數+引用環境

package main

import "fmt"

func main() {
        f := add()
        fmt.Printf("f(1) = %+v\n", f(1)) //1
        fmt.Printf("f(1) = %+v\n", f(1)) //1

        p := pp(0)
        fmt.Printf("p() = %+v\n", p()) //1
        fmt.Printf("p() = %+v\n", p()) //2
        fmt.Printf("p() = %+v\n", p()) //3
        fmt.Printf("p() = %+v\n", p()) //4
        fmt.Printf("p() = %+v\n", p()) //5

        lv := localVar()
        fmt.Printf("lv(0) = %+v\n", lv(0)) //0
        fmt.Printf("lv(1) = %+v\n", lv(1)) //1
        fmt.Printf("lv(2) = %+v\n", lv(2)) //3
        fmt.Printf("lv(3) = %+v\n", lv(3)) //6
        fmt.Printf("lv(4) = %+v\n", lv(4)) //10
}

func add() func(i int) int {
        num := 0
        return func(i int) int {
                return num + i
        }
}

//每次調用後，局部變量i的值會被保存
func pp(i int) func() int {
        return func() int {
                i++
                return i
        }
}

//每次調用後，局部變量sum會被保存
func localVar() func(int) int {
        sum := 0
        return func(x int) int {
                sum += x
                return sum
        }
}

閉包是匿名函數與匿名函數所引用環境的組合
匿名函數和它引用的變量以及環境，相似常規函數引用全局變量處於一個包的環境。

sum := 0
return func(x int) int {
    sum += x
    return sum
}

sum類比於全局變量，所以每次被賦值後，都會改變。
閉包被返回賦予一個同類型的變量時，同時賦值的是整個閉包的狀態，該狀態會一直存在外部被賦值的變量lv中，直到lv被銷燬，整個閉包也被銷燬。

• 參考資料：

https://blog.csdn.net/qq_3597...
https://www.cnblogs.com/landv...
https://blog.keyboardman.me/2...
https://www.jianshu.com/p/034...