golang匿名函数使用

介绍

== 函数是编程语言中不可缺少的部分，在golang这门语言中函数是一等公民。也是使用好golang的必备技能。==

(一)使用匿名函数实现阶加

(1.1) 一下是个返回函数类型的方法

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

(1.2)在上面代码代码添加iAdder结构体，写adder2方法返回一个iAdder函数

type iAdder func(int) (int, iAdder)

func adder2(base int) iAdder {
	return func(v int) (int, iAdder) {
		return base + v, adder2(base + v)
	}
}

下面是main

func main() {

	//0 + 1 + ... + 0 = 0
	//0 + 1 + ... + 1 = 1
	//0 + 1 + ... + 2 = 3
	//0 + 1 + ... + 3 = 6
	//0 + 1 + ... + 4 = 10
	//0 + 1 + ... + 5 = 15
	//0 + 1 + ... + 6 = 21
	//0 + 1 + ... + 7 = 28
	//0 + 1 + ... + 8 = 36
	//0 + 1 + ... + 9 = 45
	// a := adder() is trivial and also works.
	a := adder2(0)
	for i := 0; i < 10; i++ {
		var s int
		s, a = a(i)
		fmt.Printf("0 + 1 + ... + %d = %d\n",
			i, s)
	}
}

这样实现了数的阶加

(二)使用匿名函数实现斐波拉阶数

这里使用匿名函数实现斐波拉阶数
实例代码

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

让我做一个小改动 添加一个type intGen func() int 结构 实现 func (r *Reader) Read(b []byte) (n int, err error) 这样intGen 就实现了io包下的 Reader接口，看代码

type intGen func() int

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

	// TODO: incorrect if p is too small!
	//func NewReader(s string) *Reader
	return strings.NewReader(s).Read(p)
}

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

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}

func main() {
	var f intGen = fib.Fibonacci()
	printFileContents(f)
}

(三)使用匿名函数中性排列

package tree

import "fmt"

type Node struct {
	Value       int
	Left, Right *Node
}

func (node Node) Print() {
	fmt.Print(node.Value, " ")
}

type myTreeNode struct {
	node *tree.Node
}

func (myNode *myTreeNode) postOrder() {
	if myNode == nil || myNode.node == nil {
		return
	}

	left := myTreeNode{myNode.node.Left}
	right := myTreeNode{myNode.node.Right}

	left.postOrder()
	right.postOrder()
	myNode.node.Print()
}

上面是正常写法，下面加匿名写法

package tree

import "fmt"

func (node *Node) Traverse() {
	node.TraverseFunc(func(n *Node) {
		n.Print()
	})
	fmt.Println()
}

func (node *Node) TraverseFunc(f func(*Node)) {
	if node == nil {
		return
	}

	node.Left.TraverseFunc(f)
	f(node)
	node.Right.TraverseFunc(f)
}

main 中代码

root = tree.Node{Value: 3}
	root.Left = &tree.Node{}
	root.Right = &tree.Node{5, nil, nil}
	root.Right.Left = new(tree.Node)
	root.Left.Right = tree.CreateNode(2)
	root.Right.Left.SetValue(4)

	root.Traverse()
	//当然你可以自己添加一个函数功能
	nodeCount := 0
	root.TraverseFunc(func(node *tree.Node) {
		nodeCount++
	})
	fmt.Println("Node count:", nodeCount)