package main import (
"fmt"
"strconv"
) type funcType func(int, int) int // 自定义函数类型
type Callback func(int, int) int
type Callback2 func(string) func main() {
// 匿名函数经常被用于回调函数或闭包等 // 1. 定义匿名函数时直接调用
//anonymousFunc1() // 2. 先声明匿名函数，再调用匿名函数
//anonymousFunc2() // 3. 匿名函数可以作为返回值被多次调用
//f11 := anonymousFunc3()
//fmt.Println(f11(11, 22))
//fmt.Println(f11(300, 500)) // 4. 这是一个简单的回调例子，调用函数test时，调用真正的实现函数add
//fmt.Println(test(10, 20, add)) // 5. 这是一个将字符串转为Int的例子，在转换失败的情况下执行回调函数，输出错误信息
fmt.Println(stringToInt("15", errLog))
fmt.Println(stringToInt("15ab", errLog)) // 6. 闭包案例
//f := adder()
//fmt.Println(f())
//fmt.Println(f())
//fmt.Println(f())
//f2 := adder()
//fmt.Println(f2())
//fmt.Println(f2())
} // 方式一，定义匿名函数时直接调用
func anonymousFunc1() {
fmt.Println("anonymouseFunc1执行了")
a := func(data int) int {
fmt.Println("匿名函数执行了", data)
return data + 1
}(100)
fmt.Println(a)
} // 方式二：先声明匿名函数，再调用匿名函数
func anonymousFunc2() {
fmt.Println("anonymousFunc2执行了")
f := func(str string) string {
fmt.Println("匿名函数2执行了")
return str + " world"
}
ret := f("hello")
fmt.Println(ret)
} // 方式三：匿名函数可以作为返回值被多次调用
func anonymousFunc3() funcType {
return func(x, y int) int {
res := x + y
return res
}
} // 方式四：这是一个简单的回调例子，调用函数test时，调用真正的实现函数add
// 回调函数就是一个通过函数指针调用的函数。
// 如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
// 回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应
func test(x, y int, callback Callback) int {
return callback(x, y)
}
func add(x, y int) int {
return x + y
} // 方式五：这是一个将字符串转为Int的例子，在转换失败的情况下执行回调函数，输出错误信息
func stringToInt(str string, callback Callback2) int64 {
if value, err := strconv.ParseInt(str, 0, 0); err != nil {
callback(err.Error())
return 0
} else {
return value
}
}
func errLog(msg string) { // 记录日志消息的具体实现
fmt.Println(msg)
} // 方式六：作为闭包
// 闭包：闭是封闭（函数内部函数），包是包含（该内部函数对外部作用域而非全局作用域的变量的引用）。
// 闭包指的是：函数内部函数对外部作用域而非全局作用域的引用。
func adder() func() int {
sum := 0
fmt.Println("this line exec")
return func() int {
sum++
return sum
}
}