本文主要讲解Go语言中的函数式编程概念和使用，分享给大家，具体如下：
主要知识点：
- Go语言对函数式编程的支持主要体现在闭包上面
- 闭包就是能够读取其他函数内部变量的函数。只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
- 学习闭包的基本使用
- 标准的闭包具有不可变性：不能有状态，只能有常量和函数，而且函数只能有一个参数，但是一般可以不用严格遵守
- 使用闭包 实现 斐波那契数列
- 学习理解函数实现接口
- 使用函数遍历二叉树
具体代码示例如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
package mainimport ( "fmt" "io" "strings" "bufio")//普通闭包func adder() func(int) int { sum := 0 return func(v int) int { sum += v return sum }}//无状态 无变量的闭包type iAdder func(int) (int, iAdder)func adder2(base int) iAdder { return func(v int) (int, iAdder) { return base + v, adder2(base + v) }}//使用闭包实现 斐波那契数列func Fibonacci() func() int { 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 > 10000 { return 0, io.EOF } s := fmt.Sprintf("%d\n", next) // TODO: incorrect if p is too small! return strings.NewReader(s).Read(p)}//通过 Reader读取文件func printFileContents(reader io.Reader) { scanner := bufio.NewScanner(reader) for scanner.Scan() { fmt.Println(scanner.Text()) }}func main() { //普通闭包调用 a := adder() for i := 0; i < 10; i++ { var s int =a(i) fmt.Printf("0 +...+ %d = %d\n",i, s) } //状态 无变量的闭包 调用 b := adder2(0) for i := 0; i < 10; i++ { var s int s, b = b(i) fmt.Printf("0 +...+ %d = %d\n",i, s) } //调用 斐波那契数列 生成 fib:=Fibonacci() fmt.Println(fib(),fib(),fib(),fib(),fib(),fib(),fib(),fib()) var f intGen = Fibonacci() printFileContents(f)} |
以下代码演示函数遍历二叉树：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
package mainimport "fmt"type Node struct { Value int Left, Right *Node}func (node Node) Print() { fmt.Print(node.Value, " ")}func (node *Node) SetValue(value int) { if node == nil { fmt.Println("Setting Value to nil " + "node. Ignored.") return } node.Value = value}func CreateNode(value int) *Node { return &Node{Value: value}}//为 TraverseFunc 方法提供 实现func (node *Node) Traverse() { node.TraverseFunc(func(n *Node) { n.Print() }) fmt.Println()}//为 Node 结构增加一个方法 TraverseFunc ，//此方法 传入一个方法参数，在遍历是执行func (node *Node) TraverseFunc(f func(*Node)) { if node == nil { return } node.Left.TraverseFunc(f) f(node) node.Right.TraverseFunc(f)}func main() { var root Node root = Node{Value: 3} root.Left = &Node{} root.Right = &Node{5, nil, nil} root.Right.Left = new(Node) root.Left.Right = CreateNode(2) root.Right.Left.SetValue(4) root.Traverse() // 进行了 打印封装 //以下通过匿名函数，实现了 自定义实现 nodeCount := 0 root.TraverseFunc(func(node *Node) { nodeCount++ }) fmt.Println("Node count:", nodeCount) //Node count: 5} |
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://my.oschina.net/ruoli/blog/1815740
