Go-闭包和匿名函数讲解

回调函数及多态

package main

import "fmt"

//给匿名函数类型取别名
//注意不要在后面加{},加了是表面匿名函数定义
type FuncType func(x int, y int) int

//例如实现加法
func Add(x int, y int) int {
    val := x + y
    return val
}

//例如实现减法
func Sub(x int, y int) int {
    val := x - y
    return val
}

//例如实现乘法
func Mul(x int, y int) int {
    val := x * y
    return val
}

//例如实现除法
func Div(x int, y int) int {
    val := x / y
    return val
}

//回调函数，函数有一个参数是函数类型， 这个函数就是回调函数
//多态，多种形态，调用同一个接口，不同的表现，可以实现不同表现，例如：加减乘除
//先有想法，后面再实现功能
func callback(a, b int, fTest FuncType) int {
    fmt.Println("这个个回调函数")
    res := fTest(a, b) //这个函数还没有实现
    //result := Add(a, b) //这样不好，因为Add（）必须先定义后，才能调用，而且会写死这个callback函数功能
    return res
}

func main() {
    val := callback(1, 1, Add)
    fmt.Println("val=", val)
    val = callback(1, 1, Sub)
    fmt.Println("val=", val)
    val = callback(1, 1, Mul)
    fmt.Println("val=", val)
    val = callback(1, 1, Div)
    fmt.Println("val=", val)
}

 

闭包:

　　一个函数捕获了和它在同一作用域的其它常量和变量。

匿名函数和闭包  

package main

import "fmt"

func main() {
    a := 10
    s := "test"

    //匿名函数，没有函数名，这个是匿名函数的定义,还没有调用
    f := func() {
        fmt.Println("a=", a)
        fmt.Println("s=", s)
    }
    f()
    //给一个函数类型起别名
    type FuncType func() //函数没有参数，没有返回值
    //声明变量
    // f1 := f
    var f1 FuncType
    f1 = f
    f1()

    //需求：定义匿名函数，同时调用
    func() {
        fmt.Println("定义匿名函数，同时调用")
    }() //后面的（）代表调用此匿名函数

    //需求：带参数的匿名函数
    f2 := func(i, j int) {
        fmt.Printf("i=%d, j=%d\n", i, j)
    }
    f2(1, 2)

    func(i, j int) {
        fmt.Printf("i=%d, j=%d\n", i, j)
    }(10, 20)

    //需求：匿名函数，带参数带返回值
    x, y := func(a, b int) (max, min int) {
        if a > b {
            max = a
            min = b
        } else {
            max = b
            min = a
        }
        return
    }(2, 4)
    fmt.Printf("x=%d, y=%d", x, y)
}

 

闭包捕获外部变量的特点

package main

import "fmt"

func main() {
    //闭包以引用方式捕获外部变量
    a := 10
    str := "mike"
    func() {
        a = 666
        str = "Paul"
        fmt.Printf("内部： a=%d, str=%s\n", a, str)
    }() //（）代表直接调用
    fmt.Printf("外部：a=%d, str=%s\n", a, str)
}

 

闭包调用局部变量，与普通调用函数时局部变量的区别

package main

import "fmt"

func test() func() int {
    var x int

    return func() int {
        x++
        return x * x // 闭包，调用了局部变量x
    }
}
func main() {
    f := test()
    //闭包用到这些局部变量，局部变量生命周期不由它的作用域决定
    //只有闭包还在使用它，这些局部变量就还会存在
    fmt.Println(f()) //1
    fmt.Println(f()) //4
    fmt.Println(f()) //9
    fmt.Println(f()) //16
    fmt.Println(f()) //25
}

func test01() int {
    var x int //局部变量
    x++
    return x * x // 函数调用完毕，x自动释放
}

func main01() {
    fmt.Println(test01()) //1
    fmt.Println(test01()) //1
    fmt.Println(test01()) //1
    fmt.Println(test01()) //1
}