Go语言基础篇--7.Go语言之【回调函数+闭包】

1.回调函数

函数的类型定义：

定义两个函数func1()和func2()，如果讲func1函数作为func2函数的参数传给func2，那么此时func2函数可算作是高阶函数，func1函数则为回调函数。示例：

func main() {
	res := operate(1, 5, add)//这里要注意，要写add而不是add(),add()表示的是函数的执行结果
	fmt.Println(res)
}

func add(a, b int) int {
	return a + b
}
func operate(a, b int, funcName func(int, int) int) int {
	fmt.Println(a, b, funcName)
	res := funcName(a, b)
	return res
}
/*分析：
func operate(a, b int, funcName func(int, int) int) int
对于operate函数，先传入两个整形数据，接着传入一个函数，
这个函数类型是func(int, int) int，表示输入两个int数据，
返回一个int数据，operate括号外面的int表示operate函数
最终返回一个int类型数据
*/
           

2.闭包

概念：在一个外层函数当中有内层函数，并且在内层函数中会操作外层函数中的局部变量（自定义或传入的参数），并且外层函数会把内层函数作为返回值。此时，内层函数和该局部变量的结构统称为闭包结构。

func main() {
	close := closureTest()
	fmt.Printf("%T\n", close)
	fmt.Println(close())
	fmt.Println(close())
	fmt.Println(close())
}
/*分析：
close被定义为一个函数，其类型与closureTest函数的返回值类型相同，实际上就是内层函数。
运行该行代码时close := closureTest()，i被初始化为0；接下来每执行一次close()那么i的值就会加1
这是因为一个内层函数对外层函数的局部变量进行操作，
且外层函数会把内层函数作为返回值，
此时该局部变量的生命周期会发生改变，
不会随着外层函数的结束而结束，
因为内层函数还要继续使用
*/
func closureTest() func() int { //外层函数
	//局部变量
	i := 0
	fun := func() int { //内层函数
		i++
		return i
	}
	return fun //返回该内层函数（实际上是个匿名函数）
}
/*result*/
//func() int
//1
//2
//3

           

func main() {
	close := closureTest()
	fmt.Printf("%T\n", close)
	fmt.Println(close())
	fmt.Println(close())
	fmt.Println(close())
	fmt.Println(close())
	
	close0 := closureTest()
	fmt.Println(close0())
	fmt.Println(close0())
	fmt.Println(close())
}
/*result*/
//1
//2
//3
//4
//1
//2
//5
           

再次将close定义为closureTest函数，此时会重新开辟一块i的内存空间，此时close0()访问的是新的i的内存地址，而后续调用的close()还会继续访问之前的旧的i的内存地址。