Go基础系列：函数(2)——回调函数和闭包

回调函数和闭包

当函数具有如下两种特性的时候，就能够称之为高阶函数(high order functions)：

1. 函数能够做为另外一个函数的参数(典型用法是回调函数)
   
2. 函数能够返回另外一个函数，即让另外一个函数做为这个函数的返回值(典型用法是闭包)

通常来讲，附带的还具有一个特性：函数能够做为一个值赋值给变量。

f := func(){...}
f()

因为Go中函数不能嵌套命名函数，因此函数返回函数的时候，只能返回匿名函数。

先简单介绍下高阶函数，而后介绍闭包。

高阶函数示例

例如，将函数做为另外一个函数的参数：

package main

import "fmt"

func added(msg string, a func(a, b int) int) {
    fmt.Println(msg, ":", a(33, 44))
}

func main() {
    // 函数内部不能嵌套命名函数
    // 因此main()中只能定义匿名函数
    f := func(a, b int) int {
        return a + b
    }
    added("a+b", f)
}

如下示例是函数返回另外一个函数：

package main

import "fmt"

func added() func(a, b int) int {
    f := func(a, b int) int {
        return a + b
    }
    return f
}

func main() {
    m := added()
    fmt.Println(m(33, 44))
}

回调函数(sort.SliceStable)

将函数B做为另外一个函数A的参数，可使得函数A的通用性更强，能够随意定义函数B，只要知足规则，函数A均可以去处理，这比较适合于回调函数。

在Go的sort包中有一个很强大的Slice排序工具SliceStable()，它就是将排序函数做为参数的：

func SliceStable(slice interface{}, less func(i, j int) bool)

这个函数是什么意思呢？给定一个名为slice的Slice结构，使用名为less的函数去对这个slice排序。这个less函数的结构为less func(i, j int) bool，其中i和j指定排序依据。Go中已经内置好了排序的算法，咱们无需本身去定义排序算法，Go会自动从Slice中每次取两个i和j索引对应的元素，而后去回调排序函数less。因此咱们只须要传递升序仍是降序、根据什么排序就能够。

例如：

package main

import (
    "fmt"
    "sort"
)

func main() {
    s1 := []int{112, 22, 52, 32, 12}
    // 定义排序函数
    less := func(i, j int) bool {
        // 降序排序
        return s1[i] > s1[j]
        // 升序排序：s1[i] < s1[j]
    }
    //
    sort.SliceStable(s1, less)
    fmt.Println(s1)
}

这里的排序函数就是回调函数。每取一次i和j对应的元素，就调用一次less函数。

能够将排序函数直接写在SliceStable()的参数位置：

sort.SliceStable(s1, func(i, j int) bool {
    return s1[i] > s1[j]
})

还能够更强大更灵活。例如，按照字符大小顺序来比较，而不是按照数值大小比较：

package main

import (
    "fmt"
    "sort"
    "strconv"
)

func main() {
    s1 := []int{112, 220, 52, 32, 42}
    sort.SliceStable(s1, func(i, j int) bool {
        // 将i和j对应的元素值转换成字符串
        bi := strconv.FormatInt(int64(s1[i]), 10)
        bj := strconv.FormatInt(int64(s1[j]), 10)
        // 按字符顺序降序排序
        return bi > bj
    })
    fmt.Println(s1)
}

按照字符串长度来比较：

package main

import (
    "fmt"
    "sort"
)

func main() {
    s1 := []string{"hello","malong","gaoxiao"}
    sort.SliceStable(s1, func(i, j int) bool {
        // 按字节大小顺序降序排序
        return len(s1[i]) > len(s1[j])
    })
    fmt.Println(s1)
}

更严格地说是按字节数比较，由于len()操做字符串时获取的是字节数而非字符数。若是要按照字符数比较，则使用以下代码：

package main

import (
    "fmt"
    "sort"
)

func main() {
    s1 := []string{"hello","世界","gaoxiao"}
    sort.SliceStable(s1, func(i, j int) bool {
        // 按字节大小顺序降序排序
        return len([]rune(s1[i])) > len([]rune(s1[j]))
    })
    fmt.Println(s1)
}

闭包

函数A返回函数B，最典型的用法就是闭包(closure)。

关于闭包详细的定义，见个人另外一篇文章，无比详细一文搞懂：词法做用域、动态做用域、回调函数、闭包

简单地说，闭包就是"一个函数+一个做用域环境"组成的特殊函数。这个函数能够访问不是它本身内部的变量，也就是这个变量在其它做用域内，且这个变量是未赋值的，而是等待咱们去赋值的。

例如：

package main

import "fmt"

func f(x int) func(int) int{
    g := func(y int) int{
        return x+y
    }
    // 返回闭包
    return g
}

func main() {
    // 将函数的返回结果"闭包"赋值给变量a
    a := f(3)
    // 调用存储在变量中的闭包函数
    res := a(5)
    fmt.Println(res)

    // 能够直接调用闭包
    // 由于闭包没有赋值给变量，因此它称为匿名闭包
    fmt.Println(f(3)(5))
}

上面的f()返回的g之因此称为闭包函数，是由于它是一个函数，且引用了不在它本身范围内的变量x，这个变量x是g所在做用域环境内的变量，由于x是未知、未赋值的自由变量。

若是x在传递给g以前是已经赋值的，那么闭包函数就不该该称为闭包，由于这样的闭包已经失去意义了。

下面这个g也是闭包函数，但这个闭包函数是自定义的，而不是经过函数返回函数获得的。

package main

import "fmt"

func main() {
    // 自由变量x
    var x int
    // 闭包函数g
    g := func(i int) int {
        return x + i
    }
    x = 5
    // 调用闭包函数
    fmt.Println(g(5))
    x = 10
    // 调用闭包函数
    fmt.Println(g(3))
}

之因此这里的g也是闭包函数，是由于g中访问了不属于本身的变量x，而这个变量在闭包函数定义时是未绑定值的，也就是自由变量。

闭包的做用很明显，在第一个闭包例子中，f(3)退出后，它返回的闭包函数g()仍然记住了本来属于f()中的x=3。这样就可让不少闭包函数共享同一个自由变量x的值。

例如，下面的a(3)、a(5)、a(8)都共享来自f()的x=3。

a := f(3)
a(3)
a(5)
a(8)

再往外层函数看，f(3)能够将自由变量x绑定为x=3，天然也能够绑定为x=5、x=8等等。

因此，何时使用闭包？通常来讲，能够将过程分红两部分或更多部分都进行工厂化的时候，就适合闭包(实际上，有些地方直接将闭包称呼为工厂函数)。第一个部分是能够给自由变量批量绑定不一样的值，第二部分是多个闭包函数能够共享第一步绑定后的自由变量。