1. 闭包、递归

    闭包的应该都听过，但到底什么是闭包呢？

    闭包是由函数及其相关引用环境组合而成的实体(即：闭包=函数+引用环境)。

    “官方”的解释是：所谓“闭包”，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。

    维基百科讲，闭包（Closure），是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。

    看着上面的描述，会发现闭包和匿名函数似乎有些像。可是可能还是有些云里雾里的。因为跳过闭包的创建过程直接理解闭包的定义是非常困难的。目前在JavaScript、Go、PHP、Scala、Scheme、Common Lisp、Smalltalk、Groovy、Ruby、 Python、Lua、objective c、Swift 以及Java8以上等语言中都能找到对闭包不同程度的支持。通过支持闭包的语法可以发现一个特点，他们都有垃圾回收(GC)机制。 javascript应该是普及度比较高的编程语言了，通过这个来举例应该好理解写。看下面的代码，只要关注script里方法的定义和调用就可以了。

    这段代码有两个特点：

    函数b嵌套在函数a内部 函数a返回函数b 这样在执行完var c=a()后，变量c实际上是指向了函数b()，再执行函数c()后就会显示i的值，第一次为1，第二次为2，第三次为3，以此类推。 其实，这段代码就创建了一个闭包。因为函数a()外的变量c引用了函数a()内的函数b()，就是说：

    在给定函数被多次调用的过程中，这些私有变量能够保持其持久性。变量的作用域仅限于包含它们的函数，因此无法从其它程序代码部分进行访问。不过，变量的生存期是可以很长，在一次函数调用期间所创建所生成的值在下次函数调用时仍然存在。正因为这一特点，闭包可以用来完成信息隐藏，并进而应用于需要状态表达的某些编程范型中。 下面来想象另一种情况，如果a()返回的不是函数b()，情况就完全不同了。因为a()执行完后，b()没有被返回给a()的外界，只是被a()所引用，而此时a()也只会被b()引 用，因此函数a()和b()互相引用但又不被外界打扰（被外界引用），函数a和b就会被GC回收。所以直接调用a();是页面并没有信息输出。

    下面来说闭包的另一要素引用环境。c()跟c2()引用的是不同的环境，在调用i++时修改的不是同一个i，因此两次的输出都是1。函数a()每进入一次，就形成了一个新的环境，对应的闭包中，函数都是同一个函数，环境却是引用不同的环境。这和c()和c()的调用顺序都是无关的。

    Go语言是支持闭包的，这里只是简单地讲一下在Go语言中闭包是如何实现的。 下面我来将之前的JavaScript的闭包例子用Go来实现。

    3. import (
    4.     "fmt"
    5. )
    7. func a() func() int {
    8.     i := 0
    9.     b := func() int {
    10.         i++
    11.         fmt.Println(i)
    12.         return i
    13.     }
    14.     return b
    15. }
    17. func main() {
    18.     c := a()
    19.     c()
    20.     c()
    21.     c()
    23.     a() //不会输出i
    24. }

    输出结果：

    1.     1
    2.     2
    3.     3

    可以发现，输出和之前的JavaScript的代码是一致的。具体的原因和上面的也是一样的，这说明Go语言是支持闭包的。

    闭包复制的是原对象指针，这就很容易解释延迟引用现象。

    1. package main
    3. import "fmt"
    5. func test() func() {
    6.     x := 100
    7.     fmt.Printf("x (%p) = %d\n", &x, x)
    9.     return func() {
    10.         fmt.Printf("x (%p) = %d\n", &x, x)
    11.     }
    13. func main() {
    14.     f := test()
    16. }

    输出:

    1.     FuncVal { func_address, closure_var_pointer ... }

    外部引用函数参数局部变量

    1. package main
    3. import "fmt"
    5. // 外部引用函数参数局部变量
    6. func add(base int) func(int) int {
    7.     return func(i int) int {
    8.         base += i
    9.         return base
    10.     }
    11. }
    13. func main() {
    14.     tmp1 := add(10)
    15.     fmt.Println(tmp1(1), tmp1(2))
    16.     // 此时tmp1和tmp2不是一个实体了
    17.     tmp2 := add(100)
    18.     fmt.Println(tmp2(1), tmp2(2))
    19. }

    返回2个闭包

    1. package main
    3. import "fmt"
    5. // 返回2个函数类型的返回值
    6. func test01(base int) (func(int) int, func(int) int) {
    7.     // 定义2个函数，并返回
    8.     // 相加
    9.     add := func(i int) int {
    10.         base += i
    11.         return base
    12.     }
    13.     // 相减
    14.     sub := func(i int) int {
    15.         base -= i
    16.         return base
    17.     }
    18.     // 返回
    19. }
    21. func main() {
    22.     f1, f2 := test01(10)
    23.     // base一直是没有消
    24.     fmt.Println(f1(1), f2(2))
    25.     // 此时base是9
    26.     fmt.Println(f1(3), f2(4))
    27. }

    递归，就是在运行的过程中调用自己。 一个函数调用自己，就叫做递归函数。

    构成递归需具备的条件：

    数字阶乘

    一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。1808年，基斯顿·卡曼引进这个表示法。

    1. package main
    3. import "fmt"
    5. func factorial(i int) int {
    6.     if i <= 1 {
    7.         return 1
    8.     }
    9.     return i * factorial(i-1)
    10. }
    12. func main() {
    13.     var i int = 7
    14.     fmt.Printf("Factorial of %d is %d\n", i, factorial(i))
    15. }

    输出结果：

    1.     Factorial of 7 is 5040

    这个数列从第3项开始，每一项都等于前两项之和。

    1. package main
    3. import "fmt"
    5. func fibonaci(i int) int {
    6.     if i == 0 {
    7.         return 0
    8.     }
    9.     if i == 1 {
    10.         return 1
    11.     }
    12.     return fibonaci(i-1) + fibonaci(i-2)
    13. }
    15. func main() {
    16.     var i int
    17.     for i = 0; i < 10; i++ {
    18.         fmt.Printf("%d\n", fibonaci(i))
    19. }