一、函数
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,值为<nil>,地址为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)
}
