#《Go 语音圣经(中文版)》

#匿名函数

拥有函数名的函数只能在包级语法块中被声明,通过函数字面量(function literal),我们可绕过这一限制,在任何表达式中表示一个函数值。

函数值字面量是一种表达式,它的值被称为匿名函数(anonymous function)。

函数字面量允许我们在使用函数时,再定义它。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import "fmt"

/*
@Time : 2021/6/2 13:36
@Author : onns
@File : ch5/5.2.go
*/

func squares() func() int {
var x int
return func() int {
x += 2
return x * x
}
}

func main() {
f := squares()
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
}
1
2
3
4
5
[13:36:09] onns@Onns ~/Onns/code/go/go-bible/ch5 $ go run 5.2.go 
4
16
36
64

squares的例子证明,函数值不仅仅是一串代码,还记录了状态。在squares中定义的匿名内部函数可以访问和更新squares中的局部变量,这意味着匿名函数和squares中,存在变量引用。这就是函数值属于引用类型和函数值不可比较的原因。Go使用闭包(closures)技术实现函数值,Go程序员也把函数值叫做闭包。

当匿名函数需要被递归调用时,必须首先声明一个变量,再将匿名函数赋值给这个变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package main

import (
"fmt"
"sort"
)

/*
@Time : 2021/6/2 13:46
@Author : onns
@File : ch5/5.3.go
*/

// prereqs记录了每个课程的前置课程
var prereqs = map[string][]string{
"algorithms": {"data structures"},
"calculus": {"linear algebra"},
"compilers": {"data structures", "formal languages", "computer organization"},
"data structures": {"discrete math"},
"databases": {"data structures"},
"discrete math": {"intro to programming"},
"formal languages": {"discrete math"},
"networks": {"operating systems"},
"operating systems": {"data structures", "computer organization"},
"programming languages": {"data structures", "computer organization"},
}

func topoSort(m map[string][]string) []string {
var order []string
seen := make(map[string]bool)
var learn func(items []string)
learn = func(items []string) {
for _, item := range items {
if !seen[item] {
seen[item] = true
learn(m[item])
order = append(order, item)
}
}
}
var keys []string
for key := range m {
keys = append(keys, key)
}
sort.Strings(keys)
learn(keys)
return order
}
func main() {
for i, course := range topoSort(prereqs) {
fmt.Printf("%d:\t%s\n", i+1, course)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
[14:45:42] onns@Onns ~/Onns/code/go/go-bible/ch5 $ go run 5.3.go
1: intro to programming
2: discrete math
3: data structures
4: algorithms
5: linear algebra
6: calculus
7: formal languages
8: computer organization
9: compilers
10: databases
11: operating systems
12: networks
13: programming languages
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package main

import (
"fmt"
"strconv"
)

/*
@Time : 2021/6/2 16:17
@Author : onns
@File : ch5/itertest/main.go
*/

func createdir(s int, _ int) {
fmt.Println("Create " + strconv.Itoa((s)))
}

func removedir(s int) {
fmt.Println("Remove " + strconv.Itoa((s)))
}

func main() {
tempList := []int{1, 2, 3, 4, 5, 6, 7}
var rmdirs []func()
for _, d := range tempList {
dir := d
createdir(dir, 0755)
rmdirs = append(rmdirs, func() {
removedir(dir)
})
}
for _, rmdir := range rmdirs {
rmdir()
}

for _, dir := range tempList {
createdir(dir, 0755)
rmdirs = append(rmdirs, func() {
removedir(dir)
})
}
for _, rmdir := range rmdirs {
rmdir()
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
[16:27:50] onns@Onns ~/Onns/code/go/go-bible/ch5/itertest $ ./itertest
Create 1
Create 2
Create 3
Create 4
Create 5
Create 6
Create 7
Remove 1
Remove 2
Remove 3
Remove 4
Remove 5
Remove 6
Remove 7
Create 1
Create 2
Create 3
Create 4
Create 5
Create 6
Create 7
Remove 1
Remove 2
Remove 3
Remove 4
Remove 5
Remove 6
Remove 7
Remove 7
Remove 7
Remove 7
Remove 7
Remove 7
Remove 7
Remove 7

问题的原因在于循环变量的作用域。在上面的程序中,for循环语句引入了新的词法块,循环变量dir在这个词法块中被声明。在该循环中生成的所有函数值都共享相同的循环变量。需要注意,**函数值中记录的是循环变量的内存地址,而不是循环变量某一时刻的值。**以dir为例,后续的迭代会不断更新dir的值,当删除操作执行时,for循环已完成,dir中存储的值等于最后一次迭代的值。这意味着,每次对os.RemoveAll的调用删除的都是相同的目录。[1]

通常,为了解决这个问题,我们会引入一个与循环变量同名的局部变量,作为循环变量的副本。比如下面的变量dir,虽然这看起来很奇怪,但却很有用。

1
2
3
4
for _, dir := range tempDirs() {
dir := dir // declares inner dir, initialized to outer dir
// ...
}

  1. 好奇为什么会出现这样的情况? ↩︎