7 Go一等公民：函数、闭包及函数式编程

一、函数

1.函数定义

Go语言的函数定义非常灵活强大，其有以下特征：

• 支持任意多个任意类型的参数
• 参数类型后置
• 支持不定长度的参数
• 不支持初始化参数值
• 支持多个返回值
• 返回值可选预设命名，如有命名必须所有返回值都设置，且类型后置

格式：

func FunctionName(optionalParameters) optionalReturnTypes {
    //body
}

func FunctionName(optionalParameters) optionalReturnValues {
    //body
}

示例：

函数参数

//空参数
func BaseFuncParams01() {
        //body
}

//单个参数
func BaseFuncParams02(a string) {
    //body
}

//多个不同类型参数
func BaseFuncParams03(a int, b string, c bool) {
        //body
}

//多个同类型和不同类型参数
func BaseFuncParams04(a, b int, c string) {
        //body
}

//不定长度的参数，类型为切片容器
func BaseFuncParams05(a int, b ...string) {
    fmt.Printf("这是带参函数，参数a的类型是%T\n", a)

    for index, value := range b {
        fmt.Printf("这是不定长度带参函数，参数%d的类型是%T\n", index, value)
    }
}

函数返回值

//一个返回值
func BaseFuncReturn01() int {
    r := 1
    return r
}

//预定义返回值名字
func BaseFuncReturn02() (r int) {
    r = 2
    return
}

//多个返回值
func BaseFuncReturn03() (int, string, string) {
    a := 1
    b := "bbb"
    c := "ccc"
    return a, b, c
}

//多个返回值+预定义返回值名字,如有错误返回，error总是最后一个返回参数
func BaseFuncReturn04() (a, b int, c string, err error) {
    a = 1
    b = 2
    c = "cccc"
    err = errors.New("this is error!")
    return
}

2.一等公民

在Go语言中，函数可以自定义类型，并与其他基本类型一样，可以在函数或方法中传递，可以作为切片、映射等容器的元素，由此可见，函数在Go中的应用非常强大灵活。

函数类型声明

type FuncType func(int) int 
var myFunc FuncType
fmt.Printf("myFunc: 类型为%T,值为%v,地址为%p", myFunc, myFunc, myFunc)

//myFunc: 类型为FuncType,值为,地址为0x0

函数作为入参

func BaseFunc01(f1 func(int) int) {
    //body
}

函数作为返回值

func BaseFunc01() (func(string) string) {
    //body
}

二、函数式编程

函数式编程是种编程方式，它将运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。

正统函数式编程特点如下
1.不可变性：不能有状态，只有常量和函数
2.函数只能有一个参数
Go并非正统的函数式编程语言，但其对函数式编程的支持基于闭包或高阶函数的实现。

1.匿名函数

一种不需要定义函数名的函数实现，通常用于代码结构中的一次性功能封装、函数入参、函数返回值、闭包实现等

以下为匿名函数的几种常用场景：
（有些知识点会在本系列其他专题详细解析）

//典型场景一：延时执行一段代码
func BasenonymousAFunc01() {
    defer func() {
        fmt.Println("这段代码延迟执行！！！！")
    }()

    fmt.Println("这段代码先执行！！！")
}

//典型应用场景二：并发执行一段代码
func BasenonymousAFunc02() {
    fmt.Println("这是主协程输出1！！！")
    go func() {
        fmt.Println("这是匿名函数1执行的协程！！！")
    }()

    go func() {
        time.Sleep(2 * time.Second)
        fmt.Println("这是匿名函数2执行的协程！！！")
    }()

    time.Sleep(time.Second)

    fmt.Println("这是主协程输出2！！！")

}

//典型场景三：带有参数和返回值的匿名函数
func BasenonymousAFunc03() {
    f := func(a int, b string) bool {
        var rs bool = false
        return rs
    }
    r := f(1, "fun")
    fmt.Println("执行匿名函数：", r)
}

2.闭包

所谓闭包就是一个函数“捕获”了一个和它在同一作用域的其他常量或变量。这个定义听着挺绕口，通俗地讲，闭包就是一个外壳函数，内部定义一个内核函数并返回，同时外壳函数管理一个或多个状态变量，内核函数中对该外部的状态变量的修改，只对调用该外壳函数的调用者有效，即调用外壳函数后其内部状态变量都自行管理，从调用者看来，每次执行内核函数，闭包内部状态都是独立的。

//定义一个闭包
func DoWork(name string) func(int) int {
    //设置一个保存进度的状态
    var prop int = 0

    f := func(hours int) int {
        prop += hours
        fmt.Printf("%s工作了%d小时\n", name, hours)
        return prop
    }

    return f

}

func main(){
    //使用闭包
    f1 := DoWork("fun")
    f2 := DoWork("joker")

    p1 := f1(22)
    p2 := f2(8)

    p1 = f1(7)
    p2 = f2(12)

    fmt.Printf("fun总共工作了%d小时\n", p1)
    fmt.Printf("joker总共工作了%d小时\n", p2)

}

3.高阶函数

所谓高阶函数就是将一个或多个其他函数作为自身函数的入参，并在函数体内调用它们。

以下做一个高阶函数的演示：

//自定义一个函数类型
type F func(int) int

//实现高阶函数
func HigherFunction(v int, f F) int {
    return f(v)
}

//调用高阶函数
func main() {
    //声明函数1
    var f1 F
    f1 = func(i int) int {
        return i * 2
    }
    rs1 := HigherFunction(2, f1)
    fmt.Println("执行高阶函数1结果:", rs1)
    
    //声明函数2
    var f2 F
    f2 = func(i int) int {
        return i * 20
    }
    rs2 := HigherFunction(2, f2)
    fmt.Println("执行高阶函数2结果:", rs2)

}