普通函数调用流程（调用流程：先调用后返回，先进后出）
func func2(c int) {
fmt.Println("c=", c)
}
func func1(b int) {
func2(b - 1)
fmt.Println("b=", b)
}
func func0(a int) {
func1(a - 1)
fmt.Println("a=", a)
}
func main() {
func0(3)
}
结果为c= 1 b= 2 a= 3
函数递归
func func2(c int) {
if c == 0 {
fmt.Println("c=", c)
return //函数终止调用
}
func2(c - 1) //调用函数本身，直到满足条件
fmt.Println("c=", c)
}
func main() {
func2(3)
}
回调函数（函数有一个参数是函数类型，这个函数就是回调函数）
多态---多种形态，调用同一个接口，不同的表现，可以实现不同表现
先有想法，后面在实现功能
type newtype func(int, int) int
func add(a, b int) int {
return a + b
}
func minus(a, b int) int {
return a - b
}
func calc(a, b int, test newtype) (result int) {
//fmt.Println("calc")
result = test(a, b)
return
}
func main() {
num := calc(3, 5, add)
fmt.Printf("num=%d", num)
num = calc(3, 5, minus)
fmt.Printf("num=%d", num)
}
匿名函数基本语法
//带参数无返回值
func main() {
func(q, w int) {
fmt.Printf("q=%d,w=%d", q, w)
}(10, 20)
}
//有参有返回值
func main() {
max, min := func(i, j int) (max, min int) {
if i > j {
max = i
min = j
} else {
max = j
min = i
}
return
}(10, 20)
fmt.Printf("max=%d,min=%d", max, min)
闭包以引用方式捕获外部变量
func main() {
a := 10
str := "mike"
func() {
a = 888
str = "aaa"
fmt.Printf("内部 a=%d,str=%s", a, str)
}()
fmt.Printf("外部 a=%d,str=%s", a, str)
} //返回结果都是匿名函数里的值
func test02() func() int {
var x int
return func() int {
x++
return x * x
}
}
//函数的返回值时一个匿名函数，返回一个函数类型
func main() {
f := test02() //返回值是一个匿名函数，通过f来调用返回的匿名函数，f来调闭包
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
} //将函数作为第一级对象
