Go语言中的函数式编程实践

本文主要讲解go语言中的函数式编程概念和使用，分享给大家，具体如下：

主要知识点：

1. go语言对函数式编程的支持主要体现在闭包上面
2. 闭包就是能够读取其他函数内部变量的函数。只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
3. 学习闭包的基本使用
4. 标准的闭包具有不可变性：不能有状态，只能有常量和函数，而且函数只能有一个参数，但是一般可以不用严格遵守
5. 使用闭包 实现 斐波那契数列
6. 学习理解函数实现接口
7. 使用函数遍历二叉树

具体代码示例如下：

package main

import (
 "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)
}

以下代码演示函数遍历二叉树：

package main
import "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
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。