匿名函数

顾名思义，就是没有名字的函数，很多语言都有，如：java, js, php, 其中js最钟情匿名函数。匿名函数最大的用途就是用来模拟块级作用域，避免数据污染。

下来，我们来看看golang的匿名函数：

  • 不带参数 ```go package main

import ( “fmt” ) func main() { f:=func(){ fmt.Println(“hello world”) } f()//hello world fmt.Printf(“%T\n”, f) //打印 func() }

  2. - 带参数
  3. ```go
  4. // 带参数
  5. package main
  7. import (
  8.    "fmt"
  9. )
  10. func main() {
  11.    f:=func(args string){
  12.       fmt.Println(args)
  13.    }
  14.    f("hello world") // hello world
  15. }
  • 带返回值 ```go package main

import “fmt”

func main() { f:=func()string{ return “hello world” } a:=f() fmt.Println(a) //hello world }

  2. - 多个匿名函数
  3. ```go
  4. package main
  6. import "fmt"
  8. func main() {
  9.    f1,f2:=F(1,2)
  10.    fmt.Println(f1(4))//6
  11.    fmt.Println(f2())//6
  12. }
  13. func F(x, y int)(func(int)int,func()int) {
  14.    f1 := func(z int) int {
  15.       return (x + y) * z / 2
  16.    }
  18.    f2 := func() int {
  19.       return 2 * (x + y)
  20.    }
  21.    return f1,f2
  22. }

闭包

闭包说白了就是函数的嵌套，内层的嵌套可以使用外层函数的所有变量，即使外层函数已经执行完毕。

  1. package main
  3. import "fmt"
  5. func main() {
  6.    a := Fun()
  7.    d := Fun()
  8.    b:=a("hello ")
  9.    c:=a("hello ")
  10.    e:=d("hello ")
  11.    f:=d("hello ")
  12.    fmt.Println(b)//worldhello
  13.    fmt.Println(c)//worldhello hello
  14.    fmt.Println(e)//worldhello
  15.    fmt.Println(f)//worldhello hello
  16. }
  17. func Fun() func(string) string {
  18.    a := "world"
  19.    return func(args string) string {
  20.       a += args
  21.       return  a
  22.    }
  23. }

两次调用F(), 维护的不是同一个a变量

参考：
GO 匿名函数和闭包