在程序 function_return.go 中我们将会看到函数 Add2 和 Adder 均会返回签名为 func(b int) int 的函数：

    1. func Add2() (func(b int) int)
    2. func Adder(a int) (func(b int) int)

    函数 Add2 不接受任何参数，但函数 Adder 接受一个 int 类型的整数作为参数。

    我们也可以将 Adder 返回的函数存到变量中（function_return.go）。

    1. package main
    3. import "fmt"
    5. func main() {
    6.     // make an Add2 function, give it a name p2, and call it:
    7.     p2 := Add2()
    8.     fmt.Printf("Call Add2 for 3 gives: %v\n", p2(3))
    9.     // make a special Adder function, a gets value 2:
    10.     TwoAdder := Adder(2)
    11.     fmt.Printf("The result is: %v\n", TwoAdder(3))
    12. }
    14. func Add2() func(b int) int {
    15.     return func(b int) int {
    16.         return b + 2
    17.     }
    18. }
    20. func Adder(a int) func(b int) int {
    21.     return func(b int) int {
    22.         return a + b
    23.     }
    24. }

    输出：

    1. Call Add2 for 3 gives: 5
    2. The result is: 5

    下例为一个略微不同的实现（function_closure.go）：

    1. package main
    3. import "fmt"
    5. func main() {
    6.     var f = Adder()
    7.     fmt.Print(f(1), " - ")
    8.     fmt.Print(f(20), " - ")
    9.     fmt.Print(f(300))
    10. }
    12. func Adder() func(int) int {
    13.     var x int
    14.     return func(delta int) int {
    15.         x += delta
    16.         return x
    17.     }
    18. }

    函数 Adder () 现在被赋值到变量 f 中（类型为 func(int) int）。

    输出：

    1. 1 - 21 - 321

    三次调用函数 f 的过程中函数 Adder () 中变量 delta 的值分别为：1、20 和 300。

    我们可以看到，在多次调用中，变量 x 的值是被保留的，即 0 + 1 = 1，然后 1 + 20 = 21，最后 21 + 300 = 321：闭包函数保存并积累其中的变量的值，不管外部函数退出与否，它都能够继续操作外部函数中的局部变量。

    这些局部变量同样可以是参数，例如之前例子中的 Adder(as int)。

    这些例子清楚地展示了如何在 Go 语言中使用闭包。

    在闭包中使用到的变量可以是在闭包函数体内声明的，也可以是在外部函数声明的：

    1. var g int
    2. go func(i int) {
    3.     s := 0
    4.     for j := 0; j < i; j++ { s += j }
    5.     g = s
    6. }(1000) // Passes argument 1000 to the function literal.

    这样闭包函数就能够被应用到整个集合的元素上，并修改它们的值。然后这些变量就可以用于表示或计算全局或平均值。

    练习 6.9 不使用递归但使用闭包改写第 6.6 节中的斐波那契数列程序。

    练习 6.10

    学习并理解以下程序的工作原理：

    一个返回值为另一个函数的函数可以被称之为工厂函数，这在您需要创建一系列相似的函数的时候非常有用：书写一个工厂函数而不是针对每种情况都书写一个函数。下面的函数演示了如何动态返回追加后缀的函数：

    1. func MakeAddSuffix(suffix string) func(string) string {
    2.     return func(name string) string {
    3.         if !strings.HasSuffix(name, suffix) {
    4.             return name + suffix
    5.         }
    6.         return name
    7.     }
    8. }

    现在，我们可以生成如下函数：

    1. addBmp := MakeAddSuffix(".bmp")
    2. addJpeg := MakeAddSuffix(".jpeg")

    然后调用它们：

    1. addBmp("file") // returns: file.bmp
    2. addJpeg("file") // returns: file.jpeg

    可以返回其它函数的函数和接受其它函数作为参数的函数均被称之为高阶函数，是函数式语言的特点。我们已经在第 6.7 中得知函数也是一种值，因此很显然 Go 语言具有一些函数式语言的特性。闭包在 Go 语言中非常常见，常用于 goroutine 和管道操作（详见第 14.8-14.9 节）。在第 11.14 节的程序中，我们将会看到 Go 语言中的函数在处理混合对象时的强大能力。