golang函数式编程

golang 中函数是一等公民，对于函数式编程这个思维方式我还很不习惯，在看go-zero的源码过程中，显得很是吃力，go-zero中mapreduce中使用了这个编程思想，为了习惯这种思维方式，我得从基本的函数式编程开始。

这种思维方式有什么好处？

1.解耦：将操作逻辑与调用逻辑分离，使得代码更加清晰和易于维护。例如，如果决定改变add的实现，只需要修改add函数的实现，而无需修改callback函数，也不需要修改调用它的地方。

2.代码复用与模块化：通过定义一个通用的callback函数，可以将具体的操作逻辑作为参数传递，这样，callback函数可以复用于执行任何符合Func类型定义的函数。

3.灵活性：通过传递不同的函数作为参数，可以让callback执行不同的操作。使得callback具有很高的灵活性，能够根据不同的需求执行不同的任务。

4.抽象与封装：通过定义Func类型，实际上实在抽象和封装一类具有相同签名的函数。方便管理和使用这类函数。

5.测试：通过定义Func类型，可以方便地进行单元测试。例如，可以定义一个mock函数，用于模拟add和sub函数的行为

package main

import "fmt"

func main() {
	c := callback(1, 2, add)
	fmt.Println("add:", c)
	c = callback(1, 2, sub)
	fmt.Println("sub:", c)

    add := func(a, b int) int {
		return a + b
	}
	sub := func(a, b int) int {
		return a - b
	}
	
	addFunc := generateCalculateFunc(add)
	fmt.Println("add:", addFunc(1, 2))
	subFunc := generateCalculateFunc(sub)
	fmt.Println("sub:", subFunc(1, 2))
}

func add(a, b int) int {
	return a + b
}

func sub(a, b int) int {
	return a - b
}

type Func func(a, b int) int


func callback(a, b int, fn Func) int {
	return fn(a, b)
}

type CalculateFunc func(a, b int) int

func generateCalculateFunc(fn CalculateFunc) CalculateFunc {
	return fn
}

闭包

在 Go 语言中，当一个函数返回了一个闭包，这个闭包会保持对其父函数中的局部变量的引用。在这段代码中，闭包 `func() int` 保持了对 `fibonacci` 函数中的局部变量 `a` 和 `b` 的引用。

这意味着，只要这个闭包还在被使用，`a` 和 `b` 就不会被销毁，它们会一直存在，直到闭包不再被使用。当闭包不再被任何代码引用时，它以及它引用的所有变量（包括 `a` 和 `b`）就会被 Go 语言的垃圾收集器（GC）回收。

所以，`a` 和 `b` 何时被销毁，取决于闭包何时不再被使用。如果你的代码一直在使用这个闭包，那么 `a` 和 `b` 就会一直存在。如果你的代码停止使用这个闭包，那么在下一次垃圾收集时，`a` 和 `b` 就会被销毁。

当变量被重新赋值，a,b被销毁，f=fibonacci()就是重新赋值。执行f=nil时，实际上是取消了f对闭包的引用，这个闭包，以及闭包中的变量才会被垃圾回收掉，否则，一直不会被垃圾回收。

这种写法好像会有风险，如果，无限次使用，内存岂不是一直增长？

package main

import "fmt"

func main() {
	f := fibonacci()
	fmt.Println(f()) //1
	fmt.Println(f()) //1
	fmt.Println(f()) //2
	fmt.Println(f()) //3
	fmt.Println(f()) //5
	fmt.Println(f()) //8
    f = nil
	f= fibonacci()
	fmt.Println(f()) //1
    f=nil
}

func fibonacci() func() int {
	a := 0
	b := 1
	return func() int {
		a, b = b, a+b
		return a
	}
}