GO高阶函数：匿名函数、回调函数和闭包

基本概念

高阶函数包括回调函数和闭包，二者区别如下：

• 回调函数：接受一个或多个函数作为输入
• 闭包：返回一个函数

匿名函数

go的高阶函数和python的有点不一样，go函数不能嵌套命名函数，所以go的高阶函数只能用匿名函数来实现。
Go中所有匿名函数都是闭包。匿名函数顾名思义即没有函数名的函数，一般用于模拟块级作用域，避免数据污染。例如：

package main

import (
   "fmt"
)

func main() {
   f:=func(){
      fmt.Println("hello world")
   }
   f()//hello world
   fmt.Printf("%T\n", f) //打印 func()
}

匿名函数不需要先定义再使用，可以直接使用：

package main

import (  
    "fmt"
)

func main() {
	func(arg string) {
		fmt.Println("this is a", arg)
	}("test")
	// "this is a test"
}

上面定义了一个形参为arg的匿名函数，并向函数中输入字符串"test"

回调函数

概念

函数的参数包含其他函数。回调函数可以使外函数的功能不那么单一。

使用场景

比较典型的应用是sort包中的SliceSTable()这个排序函数：

func SliceStable(slice interface{}, less func(i, j int) bool)

通过定义SliceStable函数中的less函数可以对数组数据按照不同的方式来排序。

package main

import (
	"fmt"
	"sort"
)

func main() {
	s := []int{6，1，9，0，3}
    // 定义排序函数
	less := func(i, j int) bool {
		return s1[i] > s1[j]   // 降序排序
        // return s1[i] < s1[j]  // 升序排列
	}
    //
	sort.SliceStable(s1, less)
	fmt.Println(s1)
}

闭包(Closure)

闭包就是返回函数的函数，将函数作为函数的返回值。
使用方式是先实现闭包对象（闭包生成对象是函数），再通过这个函数做其他的功能。

demo1
生成一个counter计数器

package main

import "fmt"

func main() {
    a := counter()
    b:=a(1)
    c:=a(1)
    fmt.Println(b)  // 1
    fmt.Println(c)  // 2
}
func counter() func(int) int {
    a := 0
    return func(add int) int {
        a += add
        return  a
    }
}

demo2：
例如我现在有100个用户，每个用户都需要生成对应的xlsx文件、json文件、txt文件用于保存相关的信息，可以先创建闭包来实现三个函数，这三个函数可以生成.xlsx, .json, .txt的文件后缀，然后再通过这三个函数创建这100个用户的对应文件。

func MakeFile(suffix string) func(string) string {
    return func(clientName string) string {
        if !strings.HasSuffix(name, suffix) {
            return clientName + suffix
        }
        return clientName
    }
}

makeXlsx := MakeFile(".xlsx")
makeJson := MakeFile(".json")
makeTxt := MakeFile(".txt")

makeXlsx("clientA")
makeJson("clientA")
......

闭包应用场景：

• 一般用于多个函数中有大量重复代码的情况
• 或者用于工厂模式，需要根据不同的需求来实现不同的函数