Go36-12-函數

函數

在Go語言中，函數是一等（first-class）公民，函數類型也是一等的數據類型。
函數不但可以用於封裝代碼、分割功能、解耦邏輯，還可以化身爲普通的值，在其他函數間傳遞、賦予變量、做類型判斷和轉換等等。函數值可以由此成爲能夠被隨意傳播的獨立邏輯組件（或者說功能模塊）。

一等公民

開頭說的，函數是一等公民，函數類型是一等數據類型：

package main

import "fmt"

type calcFunc func(int, int) int

func add(x, y int) int {
    return x + y
}

func sub(x, y int) int {
    return x - y
}

func main() {
    var f1, f2 calcFunc
    f1, f2 = add, sub
    fmt.Println(f1(1, 2))
    fmt.Println(f2(100, 50))
}

這裏，先聲明瞭一個函數類型。在下面聲明的兩個函數的前面與caleFunc是一致的。因此都是caleFunc的一個實現。在main函數中，分別把兩個函數賦值給caleFunc類型的變量f1和f2，然後可以調用它們。
這里書寫函數簽名的方式與函數聲明的是一致的。只是緊挨在參數列表左邊的不是函數名稱，而是關鍵字func。這里函數名稱和func互換了一下位置而已。
函數簽名，就是函數的參數列表和結果列表的統稱，它定義了可用來鑑別不同函數的那些特徵，同時也定義了我們與函數交互的方式。
“函數是一等的公民”是函數式編程（functional programming）的重要特徵。Go語言在語言層面支持了函數式編程。

高階函數

高階函數可能具有如下兩個特點：

• 接收其他的函數作爲參數傳入
• 把其他的函數作爲結果返回

函數只要滿足了上面的任意一個特點，就可以說這個函數是一個高階函數。高階函數也是函數式編程中的重要概念和特徵。
在上面的例子的基礎上，寫一個高階函數，然後再main主函數裏調用執行：

package main

import (
    "errors"
    "fmt"
)

type calcFunc func(int, int) int

func add(x, y int) int {
    return x + y
}

func sub(x, y int) int {
    return x - y
}

func calculate(x, y int, f calcFunc) (int, error) {
    if f == nil {
        return 0, errors.New("invalid calcFunc")
    }
    return f(x, y), nil
}

func main() {
    res, err := calculate(1, 2, add)
    if err != nil {
        fmt.Println("ERROR:", err)
    }
    fmt.Println("Result:", res)
}

上面的calculate就是一個高階函數，“接收其他的函數作爲參數傳入”的這種高階函數。下面的示例是另外一種高階函數“把其他的函數作爲結果返回”：

package main

import (
    "errors"
    "fmt"
)

type calcFunc func(int, int) int

func add(x, y int) int {
    return x + y
}

func sub(x, y int) int {
    return x - y
}

type resFunc func(int, int) (int, error)

func genCalculator(f calcFunc) resFunc {
    return func(x, y int) (int, error) {
        if f == nil {
            return 0, errors.New("invalid calcFunc")
        }
        return f(x, y), nil
    }
}

func main() {
    f := genCalculator(sub)
    res, _ := f(10, 6)
    fmt.Println("Result:", res)
}

閉包

自由變量，在一個函數中存在對外來標識符的引用。所謂的外來標識符，是既不代表當前函數的任何參數或結果，也不是函數內部聲明的，它是直接從外邊拿過來的。
上面的例子中的genCalculator函數內部，實際上就實現了一個閉包。而genCalculator函數也是一個高階函數：

func genCalculator(f calcFunc) resFunc {
    return func(x, y int) (int, error) {
        if f == nil {
            return 0, errors.New("invalid calcFunc")
        }
        return f(x, y), nil
    }
}

genCalculator函數只做了一件事，那就是定義一個匿名的函數並把它作爲結果值返回。而這個匿名的函數就是一個閉包函數。它里面使用的變量f既不代表它的任何參數或結果也不是它自己聲明的，而是定義它的genCalculator函數的參數，所以是一個自由變量。而自由變量具體是什麼，並不是在定義閉包的時候確定的，而是在genCalculator函數被調用的時候確定的。

函數是Go語言支持函數式編程的主要體現。我們可以通過“把函數傳給函數”以及“讓函數返回函數”來編寫高階函數，也可以用高階函數來實現閉包，並以此做到部分程序邏輯的動態生成。

最後，還有一個閉包的典型例子：

package main

import "fmt"

func increment () func() {
    var x int
    return func () {
        x ++
        fmt.Println(x)
    }
}

func main() {
    f := increment()
    f()  // 打印1
    f()  // 打印2
    f()  // 打印3
}

主函數裏，每次調用執行的結果都會變化。變量x屬於閉包的一部分，但是是在閉包的函數外的，每次調用閉包後的x的狀態都會保留下來。