Go的函数式编程

---

前言

这里主要分享一下Go的函数式编程

---

一、闭包

我目前的理解是函数的内部变量，而且函数运行之后不被销毁的，比如adder(1)一次返回 sum+1， 而第二次adder(1)返回的就是第一次return的结果加上1

func Adder() func(value int) int {
	sum := 0
	return func(value int) int {
		sum += value
		return sum
	}
}

比如sum在Adder的作用，可以看到adder1的sum跟adder2的sum是不同的值，而且sum

func TestAdder(t *testing.T)  {
	adder1 := Adder()
	for i := 0; i < 10; i++ {
		fmt.Println("adder1 add ", i, " is ", adder1(i))
	}

	adder2 := Adder()
	for i := 0; i < 5; i++ {
		fmt.Println("adder2 add ", i, " is ", adder2(i))
	}
}

二、函数传给另外一个函数

之前树的中序遍历

func (node *BST)InorderTraversePrint()  {
	if node == nil {
		return
	}
	node.Left.InorderTraversePrint()
	fmt.Println(node.Value)
	node.Right.InorderTraversePrint()
}

使用函数作为传递之后

func (node *BST) InorderTraverseFunc(f func(node *BST))  {
	if node == nil {
		return
	}
	node.Left.InorderTraverseFunc(f)
	f(node)
	node.Right.InorderTraverseFunc(f)
}

这样我们就可以在不影响中序遍历的逻辑情况下引入新的逻辑
- 比如统计节点数

func TestBST_InorderTraverseFunc(t *testing.T) {
	bst := BST{Value: 3}
	bst.Left = &BST{Value: 1}
	bst.Right = &BST{Value: 5}
	bst.Left.Right = &BST{Value: 2}
	bst.Right.Left = &BST{Value: 4}

	totalNode := 0
	bst.InorderTraverseFunc(func(node *BST) {
		fmt.Println(node.Value)
		totalNode++
	})
	fmt.Println("total node is", totalNode)
}

---

三、函数接口

使用函数接口这样我们可以实现一些方法，比如Read再传给Writer使用

//函数
func Fibonacci()  func() int{
	a, b := 0, 1
	return func() int {
		a, b = b, a+b
		return a
	}
}

//定义函数接口
type intGen func() int

//实现函数方法
func (f intGen) Read(p []byte) (n int, err error) {
	next := f()

	if next > 10000 {
		return 0, io.EOF
	}

	sum := fmt.Sprintf("%d\n", next)

	return strings.NewReader(sum).Read(p)
}

//给fmt.Println使用
func TestIntGen_Read2(t *testing.T) {
	var fib intGen = Fibonacci()
	scanner := bufio.NewScanner(fib)
	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}

总结

讨论了Go的函数式编程的一些使用，以后用到继续补充