go 匿名函数和闭包

匿名函数

1. 函数也是一种类型，因此可以定义作为一个函数类型的变量

package main

import "fmt"

// 函数作为参数

func add(a, b int) int {
    return a + b
}

func testfunc(a, b int, fun func(int, int) int) int {
    sum := fun(a, b)
    return sum
}

func main() {
    sum := testfunc(2, 3, add)
    fmt.Println(sum)
}

2. 匿名函数即没有名字的函数

注意defer 和匿名函数的使用

package main

import "fmt"

func add(a, b int) int {
    return a + b

}

// 函数名也可以赋值给变量
func test1() {
    ff := add
    fmt.Printf("ff的类型是%T\n", ff)
    sum := ff(4, 5)
    fmt.Printf("sum is %d \n", sum)
}

/*
ff的类型是func(int, int) int
sum is 9
*/

// 匿名函数
func test2() {
    f1 := func(a, b int) int {
        return a + b
    }
    fmt.Printf("f1的类型是%T\n", f1)
    sum := f1(4, 5)
    fmt.Printf("sum is %d \n", sum)
}

/*
f1的类型是func(int, int) int
sum is 9
*/

// defer
func test3() int {
    i := 10
    defer fmt.Printf("defer i is %d\n", i)
    i = 100
    fmt.Printf("i is %d\n", i)
    return i
}

/*
i is 100
defer i is 10
return i is 100
*/

// defer 和匿名函数
func test4 () int {
    i:= 10
    defer func() {
        fmt.Printf("defer i is %d \n", i)
    }()

    i= 100
    fmt.Printf("i is %d\n", i)

    return i
}

/*
i is 100
defer i is 100
return i is 100
*/
-.


func main() {
    // test1()

    // test2()

    // i := test3()
    // fmt.Printf("return i is %d", i)

    i := test4()
    fmt.Printf("return i is %d", i)
}

闭包

一个函数和与其相关的引用环境组合组成的实体

个人认为go中的闭包和python中的闭包概念一样 都是 一个外层函数 嵌套 一个内层函数 内层函数包含对外层函数变量的引用 外层 函数返回值为内层函数的函数名

闭包 举例

package main

import (
    "fmt"
    "strings"
    "time"
)

func test1() func(int) int {
    index := 10
    return func(d int) int {
        index += d
        return index
    }

}

func test2(base int) func(int) int {
    return func(a int) int {
        base += a
        return base
    }
}

func test3(suffix string) func(name string) string {
    return func(name string) string {
        if !strings.HasSuffix(name, suffix) {
            // return name+suffix
            return fmt.Sprintf("%s%s", name, suffix)
        }
        return name
    }
}

func test4(a int) (func(int) int, func(int) int) {

    add := func(b int) int {
        a += b
        return a
    }

    sub := func(c int) int {
        a -= c
        return a
    }

    return add, sub
}


func test5(){
    for i:=0; i<=5;i++{
        go func(){
            fmt.Println()
        }()
    }
    time.Sleep(time.Second)
}


func test6(){
    for i:=0; i<=5;i++{
        go func(a int){
            fmt.Println(a)
        }(i)
    }
    time.Sleep(time.Second)
}

func main() {
    // f := test1()
    // fmt.Printf("f(1) return is %d\n", f(1))  // 11
    // fmt.Printf("f(2) return is %d\n", f(2))  //13
    // fu := test1()
    // fmt.Printf("fu(1) return is %d\n", fu(5))  // 15
    // fmt.Printf("fu(2) return is %d\n", fu(6))  //21

    // f := test2(5)
    // fmt.Printf("f(1) return is %d\n", f(1)) // 6
    // fmt.Printf("f(2) return is %d\n", f(2)) //8
    // fu := test2(10)
    // fmt.Printf("fu(1) return is %d\n", fu(5)) // 15
    // fmt.Printf("fu(2) return is %d\n", fu(6)) //21

    // f3 := test3(".jpg")
    // fmt.Printf("f3('ctz') return is %s\n", f3("ctz")) // f3('ctz') return is ctz.jpg
    // fmt.Printf("f3('yunnan.jpg') return is %s\n", f3("yunnan.jpg")) //f3('yunnan.jpg') return is yunnan.jpg


    // add, sub := test4(10)

    // fmt.Println(add(5), sub(6)) //15 9
    // fmt.Println(add(3), sub(4)) // 12 8

    test5()


}