《Go程序设计语言》学习笔记之函数变量和匿名函数
《Go程序设计语言》学习笔记之函数变量和匿名函数
一. 环境
Centos8.5, go1.17.5 linux/amd64
二. 函数变量
1. 概念
像其它的值一样，函数变量也有类型，而且它们可以赋给变量或者传递或者从其它函数中返回。函数变量可以像其它函数一样调用。
函数本身不可比较，所以不可以互相进行比较，或者作为键值出现在 map 中。
函数变量使得函数不仅将数据进行参数化，还将函数的行为当作参数进行传递。
2. 声明
第 14 行，声明了一个函数变量 f，在第 18 行，对函数变量 f 进行了重新赋值。注意，此时前提是函数 negative 与 函数变量 f 的类型或签名一致，或者更进一步说他们的形参列表和返回列表是相同的。第 16 行、第 20 行，通过打印函数变量 f 的类型，可以证实。
第 22 行，声明了一个函数变量 f2。如果此时，将函数 negative 赋值给它，则会提示 "IncompatibleAssign"，即不合适的赋值。
9 func square(n int) int { return n * n }
10 func negative(n int) int { return -n }
11 func product(m, n int) int { return m * n }
12
13 func main() {
14 f := square
15 fmt.Printf("%d\n", f(3))
16 fmt.Printf("%T\n", f)
17
18 f = negative
19 fmt.Printf("%d\n", f(3))
20 fmt.Printf("%T\n", f)
21
22 f2 := product
23 fmt.Printf("%d\n", f2(5, 4))
24 fmt.Printf("%T\n", f2)
25
运行结果如下
3. 零值
函数类型的零值是 nil(空值)，调用一个空的函数变量将导致宕机。
从第 15 行打印结果，可证实函数变量 f 是个空值。第 17 行进行调用，结果就挂了。所以，声明一个空值的函数变量后，记得进行初始化下。
13 func main() {
14 var f func(int) int
15 fmt.Printf("%T\n", f)
16 fmt.Printf("%t\n", nil == f)
17 f(3)
18 }
运行结果如下
4. 比较
函数变量可以和空值直接比较，但是函数变量之间不可比较。
1) 与空值直接比较
13 func main() {
14 var f func(int) int
15 fmt.Printf("%t\n", nil == f)
16
17 if nil != f {
18 f(3)
19 } else {
20 fmt.Printf("f is nil\n")
21 }
22 }
运行结果如下
2) 函数变量之间比较
编译会报错，提示："函数变量 f 只能与 nil 比较"
13 func main() {
14 f := square
15 f2 := negative
16
17 fmt.Printf("%T\n", f == f2)
18 }
编译报错
invalid operation: f == f2 (func can only be compared to nil)
三. 匿名函数
1. 概念
命名函数只能在包级别的作用域进行声明，但我们能够使用函数字面量在任何表达式内指定函数变量。函数字面量就像函数声明，但在 func 关键字后面没有函数的名称。它是一个表达式，它的值称作匿名函数。
2. 特点
1) 函数字面量在我们需要使用的时候才定义
内置包 strings 中有几个这样的例子如 strings.Map()等，这里以 strings.IndexFunc() 为例，它返回在字符串中第一个符合匿名函数的码点值的索引。
n := strings.IndexFunc("Hello, 世界", func(c rune) bool { return unicode.Is(unicode.Han, c) })
2) 以这种方式定义的函数能够获取到整个词法环境，因此里层的函数可以使用外层函数中的变量。
这里在书中的例子基础上增加了点内容，用于对比。
函数 Increase() 返回了一个匿名函数。而在匿名函数中，递增了 x 。每次调用函数 Increase() ，即执行 f()，f 是有状态的，它保存了 x 的当前的最新值，这通过打印 x 值可知。里层的匿名函数能够获取和更新外层函数 Increase() 函数的局部变量。当然，也可以改变包的全局变量 y 。
个人感觉，使用匿名函数的时候，匿名函数外层函数中的变量对于匿名函数来讲，就像它的全局变量一样。这样，就不用声明那么多包级别的全局变量了，感觉还挺方便。
8 var y int = 10
9
10 func Increase() func() int {
11 var x int
12 return func() int {
13 x++
14 y++
15 fmt.Printf("x: %d, y: %d\n", x, y)
16
17 return x * x
18 }
19 }
20
21 func main() {
22 f := Increase()
23 fmt.Printf("%d\n", f())
24 fmt.Printf("----------\n")
25 fmt.Printf("%d\n", f())
26 fmt.Printf("----------\n")
27 fmt.Printf("%d\n", f())
28 fmt.Printf("----------\n")
29 fmt.Printf("%d\n", f())
30 fmt.Printf("----------\n")
31 }
运行结果如下
3. 注意
捕获迭代变量
为了观察现象，笔者在书中的例子上修改了下。将 tempDirs 直接修改为了一个 slice ，并明指明出了文件名。在每次遍历 tempDirs 时，中间停顿了3秒(当然，也可以修改更大的)。这样在这个间隙时，就可以去指定目录下观察是否创建了相应目录，是否将该目录删除了。
4 import (
5 "os"
6 "time"
7 )
8
9 func main() {
10 tempDirs := []string{"./aa/aaa", "./bb/bbb", "./cc/ccc"}
11
12 var rmdirs []func()
13
14 for _, d := range tempDirs {
15 dir := d
16 os.MkdirAll(dir, 0755)
17 time.Sleep(3 * time.Second)
18 rmdirs = append(rmdirs, func() { os.RemoveAll(dir) })
19
20 }
21
22 for _, rmdir := range rmdirs {
23 rmdir()
24 }
25
26 }
~
运行结果如下
没有打印结果。但是可以在另一个命令行窗口，可以看到 aa目录下有创建和删除aaa目录，另外对 bb、cc目录也是一样地进行观察，结果均符合预期。
第15 行代码，每次循环时，将遍历到的元素 d 赋值给了一个局部变量 dir，后面对局部变量 dir 进行操作。试试，如果直接对遍历到的元素 d 进行操作呢？感觉那样代码会更简洁。
调整代码如下：
9 func main() {
10 tempDirs := []string{"./aa/aaa", "./bb/bbb", "./cc/ccc"}
11
12 var rmdirs []func()
13
14 for _, d := range tempDirs {
15 //dir := d
16 //os.MkdirAll(dir, 0755)
17 os.MkdirAll(d, 0755)
18 time.Sleep(3 * time.Second)
19 //rmdirs = append(rmdirs, func() { os.RemoveAll(dir) })
20 rmdirs = append(rmdirs, func() { os.RemoveAll(d) })
21
22 }
23
24 for _, rmdir := range rmdirs {
25 rmdir()
26 }
27
28 }
运行结果如下
没有打印结果。但是在另一个命令行窗口，可以观察到 aa 目录下仍有 目录 aaa，bb 目录下仍有目录 bbb，只有 cc 目录下的目录删除了，是空的。
此时，程序并没有按照预期进行。
d 是在for循环引入的一个块作用域内进行声明的。在 for 循环中创建的所有函数变量共享相同的变量 -- 一个可访问的储存位置，而不是固定的值。变量 d 在每次迭代中都在不断更新。当在最后删除创建的目录时，实际上删除的都是最后一次创建的目录。也就是说 rmdirs 中的每个元素要删除的目录都是一样的，均是最后一次创建的目录。
即使使用下标也是会存在这样的问题。
