Go函数篇--匿名函数和闭包

匿名函数和闭包

一、匿名函数

  • 区别于普通的具名函数，匿名函数无需声明函数名，带函数体即可
  • 匿名函数的优势就在于，不用申明一个函数，即可使用函数内的变量
  • 当匿名函数引用了外部作用域中的变量时就成了闭包函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import (
    "fmt"
    "math"
)

func main() {
    getSqrt := func(a float64) float64 {
        return math.Sqrt(a)
    }
    fmt.Println(getSqrt(4))
}

二、闭包

什么是闭包？

  • 闭包是由函数及其相关引用环境组合而成的实体
  • 当匿名函数引用了外部作用域中的变量时就成了闭包函数
  • 个人感觉，从模块和作用域的角度看，闭包和类有点类似，包含变量和方法，方法可以引用类里面的变量；
  • 闭包的目的就是减少全局变量的使用，但是不够明确，一般不推荐用
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
package main

import (
    "fmt"
)

func a() func() int {
    i := 0
    fmt.Printf("i(%p)=%d\n",&i, i )
    b := func() int {
	    fmt.Printf("i(%p)=%d\n",&i, i )
        i++
        fmt.Println(i)
        return i
    }
    return b
}

func main() {
    c := a()
    c() // 1
    c() // 2
    c() // 3
    
    a() //不会输出i
    a()() // 输出1
}

闭包复制的是原对象的指针

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

import "fmt"

func test() func() {
    x := 100
    fmt.Printf("x (%p) = %d\n", &x, x)

    return func() {
        fmt.Printf("x (%p) = %d\n", &x, x)
    }
}

func main() {
    f := test()
    f()
}

// 输出
x (0xc42007c008) = 100
x (0xc42007c008) = 100

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func add(base int) func(int) int {
	return func(i int) int {
		base += i
		return base
	}
}
func main() {
	t1 := add(10)
	fmt.Println(t1(1), t1(2)) // 11 13

	t2 := add(100)
	fmt.Println(t2(1), t2(2)) // 101 103
}

Q: 闭包函数是函数式编程语言的核心？

三、迭代中的变量

由于循环变量的作用域的规则限制，在循环里创建的所有函数变量共享相同的变量 （一个可访问的存储位置，而不是固定的值）；所有函数取到的值是最后一次循环的值

3.1.Example

现在想创建三个临时目录，然后用完之后将这三个临时目录都删除。

按下面这么写实际上只会删除最后一个目录 tmp3 ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "os"

func main() {
	var rmDirs []func()
	tempDirs := []string {"tmp1", "tmp2", "tmp3"}
	for _, dir := range tempDirs{
		os.MkdirAll(dir, 0755)
		rmDirs = append(rmDirs, func(){
			 os.RemoveAll(dir)
		})
	}

	for _, rmdir := range rmDirs {
		rmdir()
	}
}
1
2
3
4
5
tree
.
├── main.go
├── tmp1
└── tmp2

需要设置一个中间变量，才能实现效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "os"

func main() {
	var rmDirs []func()
	tempDirs := []string {"tmp1", "tmp2", "tmp3"}
	for _, d := range tempDirs{
		dir := d // Add
		os.MkdirAll(dir, 0755)
		rmDirs = append(rmDirs, func(){
			 os.RemoveAll(dir)
		})
	}

	for _, rmdir := range rmDirs {
		rmdir()
	}
}
1
2
3
tree
.
└── main.go