首页 > 编程笔记

Go语言匿名函数（入门必读）

Go 语言支持匿名函数，即在需要使用函数时再定义函数，匿名函数没有函数名，只有函数体，函数可以作为一种类型被赋值给函数类型的变量。匿名函数也往往以变量的方式被传递。

匿名函数由一个不带函数名的函数声明和函数体组成，定义匿名函数的语法格式如下：

func(参数列表)(返回参数列表){
    函数体
}

匿名函数的定义就是没有名字的普通函数定义。

1) 在定义时调用匿名函数。匿名函数可以在声明后调用，例如：

func(data int) {
    fmt.Println("hello", data)
}(100)

第 3 行“}”后的 (100)，表示对匿名函数进行调用，传递参数为 100。

2) 将匿名函数赋值给变量。匿名函数可以被赋值，例如：

//将匿名函数体保存到f()中
f := func(data int) {
    fmt.Println("hello", data)
}
//使用f()调用
f(100)

匿名函数本身就是一种值，可以方便地保存在各种容器中，实现回调函数和操作的封装。
1) 匿名函数用作回调函数。例如实现对切片的遍历操作，遍历中访问每个元素的操作使用匿名函数来实现，用户传入不同的匿名函数体，可以实现对元素不同的遍历操作。

package main
import (
    "fmt"
)
//遍历切片的每个元素, 通过给定函数进行元素访问
func visit(list []int, f func(int)) {
    for _, v := range list {
        f(v)
    }
}
func main() {
    //使用匿名函数打印切片内容
    visit([]int{1, 2, 3, 4}, func(v int) {
        fmt.Println(v)
    })
}

在以上代码中：

第 6 行，使用 visit() 函数将整个遍历过程进行封装，当要获取遍历期间的切片值时，只需要给 visit() 传入一个回调参数即可。
第 13 行，准备一个整型切片 []int{1,2,3,4}，传入 visit() 函数作为遍历的数据。
第 14、15 行，定义了一个匿名函数，作用是将遍历的每个值打印出来。

2) 使用匿名函数实现操作封装。例如将匿名函数作为 map 的键值，通过命令行参数动态调用匿名函数。

package main
import (
    "flag"
    "fmt"
)
var skillParam = flag.String("skill", "", "skill to perform")
func main() {
    flag.Parse()
    var skill = map[string]func(){
        "fire": func() {
            fmt.Println("chicken fire")
        },
        "run": func() {
            fmt.Println("soldier run")
        },
        "fly": func() {
            fmt.Println("angel fly")
        },
    }
    if f, ok := skill[*skillParam]; ok {
        f()
    } else {
        fmt.Println("skill not found")
    }
}

在以上代码中：

第 6 行，定义命令行参数 skill，从命令行输入 --skill，可以将=后的字符串传入 skillParam 指针变量。
第 8 行，解析命令行参数，解析完成后，skillParam 指针变量将指向命令行传入的值。
第 9 行，定义一个从字符串映射到 func() 的 map，然后填充这个 map。
第 10~18 行，初始化 map 的键值对，值为匿名函数。
第 20 行，skillParam 是一个 *string 类型的指针变量，使用 *skillParam 获取命令行传过来的值，并在 map 中查找对应命令行参数指定的字符串的函数。
第 23 行，如果在 map 定义中存在这个参数就调用，否则打印“skill not found”。

匿名函数可以看作函数字面量，所有直接使用函数类型变量的地方都可以由匿名函数代替。匿名函数可以直接赋值给函数变量，可以当作实参，也可以作为返回值，还可以直接被调用，例如：

package main
import (
    "fmt"
)
//匿名函数被直接赋值函数变量
var sum = func(a, b int) int {
    return a + b
}
func doinput(f func(int, int) int, a, b int) int {
    return f(a, b)
}
//匿名函数作为返回值
func wrap(op string) func(int, int) int {
    switch op {
    case "add":
        return func(a, b int) int {
            return a + b
        }
    case "sub":
        return func(a, b int) int {
            return a + b
        }
    default:
        return nil
    }
}
func main() {
    //匿名函数直接被调用
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()
    sum(1, 2)
    //匿名函数作为实参
    doinput(func(x, y int) int {
        return x + y
    }, 1, 2)
    opFunc := wrap("add")
    re := opFunc(2, 3)
    fmt.Printf("%d\n", re)
}

Go语言匿名函数（入门必读）

推荐阅读