函数式编程

函数与闭包

函数是一等公民：参数、变量、返回值都可以是函数，函数也可以实现接口。在C++中就只有函数指针。
“正统”的函数式编程：不能有状态，只能有函数和常量；每个函数只能有一个参数。
go语言没有Lambda表达式，但是支持匿名函数。

一个持有外部自由变量的函数就是闭包。
要搞清楚闭包的关键，就是要分析出返回的函数它使用(引用)到哪些变量，因为函数和它引用到的变量共同构成闭包。

func adder() func(int) int {
	sum := 0 //自由变量
	return func(v int) int {
		sum += v  //这个闭包中引用sum自由变量
		return sum
	}
}
func main() {
	a := adder()
	for i := 0; i < 10; i++ {
		fmt.Println(a(i))
	}
}

//python中的闭包
def adder():
	sum = 0

	def f(value):
		nonlocal sum
		sum += value
		return sum
	return f

//C++中的闭包
auto adder(){
	auto sum = 0;
	return [=] (int value) mutable{
		sum += vaule;
		return sum;
	};
}

斐波那契数列

函数作为返回值，为函数实现接口。

package main

import (
	"bufio"
	"fmt"
	"io"
	"strings"
)

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

type intGen func() int //只要是类型，就能实现接口

//函数也能实现接口
func (g intGen) Read(p []byte) (n int, err error) {
	next := g()
	if next > 1000 {
		return 0, io.EOF
	}
	s := fmt.Sprintf("%d\n", next) //将next转为字符串
	return strings.NewReader(s).Read(p)
}

func printFileContents(reader io.Reader) {
	scanner := bufio.NewScanner(reader)

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}
func main() {
	f := fibonacci()
	printFileContents(f)

}

使用函数来遍历二叉树

函数作为参数

func (node *TreeNode) Traverse() {
	node.TraverseFunc(func(node *TreeNode) {
		node.Print()
	})
}

func (node *TreeNode) TraverseFunc(f func(*TreeNode)) {
	if node == nil {
		return
	}
	node.Left.TraverseFunc(f)
	f(node)
	node.Right.TraverseFunc(f)
}
root.Traverse()

nodeCount := 0
	root.TraverseFunc(func(node *tree.TreeNode) {
		nodeCount++
	})