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)
}