【Go语言学习笔记】函数做参数和闭包

函数做参数

在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
}`

匿名函数

匿名函数是指不需要定义函数名的一种函数实现方式，它并不是一个新概念，最早可以回溯到1958年的Lisp语言。

在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)
}

//一般函数，函数结束了就释放局部变量
func test01() int {
    var x int //没有初始化，值为0
    x++
    return x * x //函数调用完毕，x自动释放
}
func main() {
    //返回值为一个匿名函数，返回一个函数类型，通过f来调用返回的匿名函数，f来调用闭包函数
    //它不关心这些捕获了的变量和常量是否已经超出了作用域,所以只有闭包还在使用它，这些变量就还会存在。
    test()
    f := squares()
    fmt.Println(f()) //1
    fmt.Println(test01())//1
    fmt.Println(test01())//1
    fmt.Println(test01())//1
    fmt.Println(test01())//1
}`

将返回值改成匿名函数

// 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中。

其实本质来说，就跟宏替换一样，把闭包里面的函数体直接替换到外函数就成了这样：

func test(){
    var res int //这个变量原来会由系统生成，记录返回值
    var x int 
    x++
    res =  x * x
    fmt.Println(res) 
    x++
    res =  x * x
    fmt.Println(res) 
    x++
    res =  x * x
    fmt.Println(res) 
    x++
    res =  x * x
    fmt.Println(res) 
    //在这里x才释放
}