golang中匿名函数的应用-回调函数-闭包

100

101

102

103

104

105

106

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