Golang闭包函数

Golang Golang闭包函数 评论

闭包函数

闭包函数概述 闭包函数：返回函数的函数 闭包的好处：【内层函数的状态】被保存在闭包中 不使用闭包，就要开
辟多个全局变量来保存函数以外的数据 如果说这个函数被多方调用，大家都需要各保存各的数据，那么此时就需要开辟多个全局变量 具体使用哪个全局变量，还要在函数内做判断——增大了重复的代码量，令代码看起来比较垃圾

案例：

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package main

import "fmt"

/*
李逵和武松的Study方法的逻辑是几乎一模一样的
然而为了分别保存二人的学习进度，需要开辟两个全局变量，函数内部需要使用两条分支结构才能完成业务逻辑；
如果是108将都来学习...
此时代码的可复用性很差！
*/
var likuiProgress int //0
var wusongProgress int //0
func Study(name string,hours int) {
	fmt.Printf("%s学习了%d小时\n",name,hours)
	if name=="李逵"{
		likuiProgress += hours
	}else if name=="武松"{
		wusongProgress += hours
	}
}
func main081() {
	Study("李逵", 5)
	fmt.Printf("李逵的学习进度是%d/10000\n",likuiProgress)

	Study("武松", 15)
	fmt.Printf("李逵的学习进度是%d/10000\n",wusongProgress)
}


/*
使用闭包函数优化Study
每个人有不同的学习进度，将这个进度保存在【各自的闭包】中
*/
/*
闭包函数：返回函数的函数
闭包函数的好处：使用同一份内层函数代码，创建出任意多个不同的函数对象，这些对象各自的状态都被保存在函数闭包（外层函数）中，各行其道互不干扰
*/
func GetStudyFunc(name string) func(hours int) (progress int) {

	//用于保存内层函数的状态
	var progress int

	//定义内层函数
	studyFunc := func(hours int) int {
		fmt.Printf("%s学习了%d小时\n",name,hours)

		//更新内层函数在闭包中的状态
		progress += hours
		return progress
	}
	fmt.Printf("study的类型是%T\n", studyFunc)

	//返回内层函数
	return studyFunc
}

func main() {

	//调用闭包函数，得到三个【代码相同的不同函数对象】
	studyFunc1 := GetStudyFunc("李逵")
	studyFunc2 := GetStudyFunc("武松")
	studyFunc3 := GetStudyFunc("鲁智深")

	//交替执行这些内层函数，其状态的更新会被其函数闭包所保存
	lkProgress := studyFunc1(5)
	lzsProgress := studyFunc3(17)
	wsProgress := studyFunc2(15)
	lkProgress = studyFunc1(3)
	lzsProgress = studyFunc3(12)
	lkProgress = studyFunc1(2)
	wsProgress = studyFunc2(13)

	//输出结果，三个函数的各自的状态没有互相影响
	fmt.Printf("李逵的学习进度是%d/10000\n",lkProgress)
	fmt.Printf("武松的学习进度是%d/10000\n",wsProgress)
	fmt.Printf("鲁智深的学习进度是%d/10000\n",lzsProgress)
}

YanChen

Personal profile