匿名函数、闭包

匿名函数没有函数名

   

   

一个简单的匿名函数

package main

   

import "fmt"

   

func main() {

    SayHello := func() {

        fmt.Println("Hello world!")

    }

    SayHello()

}

   

   

或者直接func定义后在函数体后加上括号，表示定义的同时执行

package main

   

import "fmt"

   

func main() {

    func() {

        fmt.Println("Hello world!")

    }()

}

   

请注意以下两者的区别

package main

   

import "fmt"

   

func main() {

    a := func(a, b int) int {

        return a + b

    }

    // 函数未被调用，a中存放的是函数体，a==匿名函数，且可被多次调用

   

    b := func(a, b int) int {

        return a + b

    }(1, 2)

    // 匿名函数被调用了，b中的值是匿名函数最终的返回值

   

    fmt.Printf("a:%T\nb:%T", a, b)

}

   

   

   

   

   

闭包就是引用了函数外的变量，一个例子：

package main

   

import "fmt"

   

func calc(base int) (func(int) int, func(int) int) {

    add := func(i int) int {

        base += i

        return base

    }

    sub := func(i int) int {

        base -= i

        return base

    }

    return add, sub

}

func main() {

    a, b := calc(100)

    resulta := a(100)

    resultb := b(100)

    fmt.Println(resulta, resultb)

}

   

输出结果：200 100

因为calc函数中的base数值会被保存起来。所以resultb的结果是200

   

   

闭包小结：

一个外层函数中，有内层函数，且该内层函数会操作外层函数的局部变量，并且该外层函数的返回值就是这个内层函数。

这个内层函数和外层函数总体称之为闭包结构。

且局部变量的生命周期会发生改变，并不会随着外层函数的结束而销毁，而是内外层函数全部结束时才会随之销毁。

闭包很消耗内存，每一次复制都会开辟新的空间。