Golang遞歸函數、函數類型、匿名函數和閉包

1. 遞歸函數

遞歸指函數可以直接或間接的調用自身。

遞歸函數通常有相同的結構：一個跳出條件和一個遞歸體。所謂跳出條件就是根據傳入的參數判斷是否需要停止遞歸，而遞歸體則是函數自身所做的一些處理。
通過循環實現1+2+3……+100

func Test01() int {
    i := 1
    sum := 0
    for i = 1; i <= 100; i++ {
        sum += i
    }
    return sum
}

通過遞歸實現1+2+3……+100

func Test02(num int) int {
    if num == 1 {
        return 1
    }

    return num + Test02(num-1) //函數調用本身
}

通過遞歸實現1+2+3……+100

func Test03(num int) int {
    if num == 100 {
        return 100
    }

    return num + Test03(num+1) //函數調用本身
}

func main() {

    fmt.Println(Test01())    //5050
    fmt.Println(Test02(100)) //5050
    fmt.Println(Test03(1))   //5050
}

2. 函數類型

在Go語言中，函數也是一種數據類型，我們可以通過type來定義它，它的類型就是所有擁有相同的參數，相同的返回值的一種類型。

type FuncType func(int, int) int //聲明一個函數類型, func後面沒有函數名

//函數中有一個參數類型爲函數類型：f FuncType
func Calc(a, b int, f FuncType) (result int) {
    result = f(a, b) //通過調用f()實現任務
    return
}

func Add(a, b int) int {
    return a + b
}

func Minus(a, b int) int {
    return a - b
}

func main() {
    //函數調用，第三個參數爲函數名字，此函數的參數，返回值必須和FuncType類型一致
    result := Calc(1, 1, Add)
    fmt.Println(result) //2

    var f FuncType = Minus
    fmt.Println("result = ", f(10, 2)) //result = 8
}

3. 匿名函數與閉包

所謂閉包就是一個函數“捕獲”了和它在同一作用域的其它常量和變量。這就意味着當閉包被調用的時候，不管在程序什麼地方調用，閉包能夠使用這些常量或者變量。它不關心這些捕獲了的變量和常量是否已經超出了作用域，所以只有閉包還在使用它，這些變量就還會存在。

在Go語言裏，所有的匿名函數(Go語言規範中稱之爲函數字面量)都是閉包。匿名函數是指不需要定義函數名的一種函數實現方式。

func main() {
    i := 0
    str := "mike"

    //方式1
    f1 := func() { //匿名函數，無參無返回值
        //引用到函數外的變量
        fmt.Printf("方式1：i = %d, str = %s\n", i, str)
    }

    f1() //函數調用

    //方式1的另一種方式
    type FuncType func() //聲明函數類型, 無參無返回值
    var f2 FuncType = f1
    f2() //函數調用

    //方式2
    var f3 FuncType = func() {
        fmt.Printf("方式2：i = %d, str = %s\n", i, str)
    }
    f3() //函數調用

    //方式3
    func() { //匿名函數，無參無返回值
        fmt.Printf("方式3：i = %d, str = %s\n", i, str)
    }() //別忘了後面的(), ()的作用是，此處直接調用此匿名函數

    //方式4, 匿名函數，有參有返回值
    v := func(a, b int) (result int) {
        result = a + b
        return
    }(1, 1) //別忘了後面的(1, 1), (1, 1)的作用是，此處直接調用此匿名函數， 並傳參
    fmt.Println("v = ", v)

}
閉包捕獲外部變量特點：

func main() {
    i := 10
    str := "mike"

    func() {
        i = 100
        str = "go"
        //內部：i = 100, str = go
        fmt.Printf("內部：i = %d, str = %s\n", i, str)
    }() //別忘了後面的(), ()的作用是，此處直接調用此匿名函數

    //外部：i = 100, str = go
    fmt.Printf("外部：i = %d, str = %s\n", i, str)
}
函數返回值爲匿名函數：

// squares返回一個匿名函數，func() int
// 該匿名函數每次被調用時都會返回下一個數的平方。
func squares() func() int {
    var x int
    return func() int {//匿名函數
        x++ //捕獲外部變量
        return x * x
    }
}

func main() {
    f := squares()
    fmt.Println(f()) // "1"
    fmt.Println(f()) // "4"
    fmt.Println(f()) // "9"
    fmt.Println(f()) // "16"
}

函數squares返回另一個類型爲 func() int 的函數。對squares的一次調用會生成一個局部變量x並返回一個匿名函數。每次調用時匿名函數時，該函數都會先使x的值加1，再返回x的平方。第二次調用squares時，會生成第二個x變量，並返回一個新的匿名函數。新匿名函數操作的是第二個x變量。

通過這個例子，我們看到變量的生命週期不由它的作用域決定：squares返回後，變量x仍然隱式的存在於f中。