golang学习笔记——函数式编程

函数式编程

package main

import "fmt"

func adder() func(int) int {
	sum := 0
	return func(v int) int {
		sum += v
		return sum
	}
}

type adderFunc func() int

func adder2() adderFunc {
	// a, b := 1, 1
	return func() int {
		// fmt.Println(a)
		// a, b = b, a+b
		// return a
		return 0

	}
}

func main() {
	a := adder()
	i := 0
unlimitloop:
	for {
		fmt.Printf("0 + .... + %d = %d\n", i, a(i))
		i++
		if i > 10 {
			// goto unlimitloop
			// continue unlimitloop
			break unlimitloop
		}
	}

	i = 0
	b := adder2()
	for {
		fmt.Printf("0 + .... + %d = %d\n", i, b())
		i++
		if i > 10 {
			break
		}
	}
}

• 函数是一等公民：参数，变量，返回值都可以是函数
• 高阶函数
• 函数->闭包
• 正统的函数式编程——不可变性：不能有状态，只有常量和函数
• 正统的函数式编程——函数只能有一个参数

函数式编程例1、2——斐波那契数列&函数式接口

package main

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

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

type intGen func() int

func (ig intGen) Read(p []byte) (n int, err error) {
	next := ig()
	if next > 10000 {
		return 0, io.EOF
	}
	s := fmt.Sprintf("fabonacci => %d\n", next)
	return strings.NewReader(s).Read(p)
}

func printFibonacci(reader io.Reader) {
	scanner := bufio.NewScanner(reader)
	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}

func main() {
	//fabonacci
	f := fabonacci()
	// for i := 1; i <= 10; i++ {
	// 	fmt.Printf("fabonacci(%d) => %d\n", i, f())
	// }

	//realize io.Reader
	printFibonacci(f)
}

函数式编程例3——使用函数来遍历二叉树

package main

import (
	"fmt"
)

//TreeNode
type TreeNode struct {
	Val         int
	Left, Right *TreeNode
}

//method of myself
func printerTree(node *TreeNode) {
	var f func(*TreeNode)
	f = func(node *TreeNode) {
		if node == nil {
			return
		}
		fmt.Println(node.Val)
		f(node.Left)
		f(node.Right)
	}
	f(node)
}

//method of course
func (node *TreeNode) traserveFunc(f func(*TreeNode)) {
	if node == nil {
		return
	}
	f(node)
	node.Left.traserveFunc(f)
	node.Right.traserveFunc(f)
}

func (node *TreeNode) traverse() {
	node.traserveFunc(func(treenode *TreeNode) {
		fmt.Println(treenode.Val)
	})
	fmt.Println()
}

func main() {
	//TreeNode example
	example1_head := new(TreeNode)
	example1_head_left := new(TreeNode)
	example1_head_right := new(TreeNode)
	example1_head_right_left := new(TreeNode)
	example1_head_right_right := new(TreeNode)
	example1_head.Val = 3
	example1_head.Left = example1_head_left
	example1_head.Right = example1_head_right
	example1_head_left.Val = 9
	example1_head_right.Val = 20
	example1_head_right.Left = example1_head_right_left
	example1_head_right.Right = example1_head_right_right
	example1_head_right_left.Val = 15
	example1_head_right_right.Val = 7
	/*
			3
		   / \
		  9  20
			 / \
			15  7
	*/

	//遍历二叉树————函数式
	printerTree(example1_head)
	//课程写法
	example1_head.traverse()
	//计数
	var count int
	example1_head.traserveFunc(func(node *TreeNode) {
		count++
	})
	fmt.Printf("node count : %d\n", count)
}

• 更为自然，不需要修饰如何访问自有变量
• 没有lambda表达式，但是有匿名函数