Go函数式编程篇

函数式编程并非Go语言所特有

函数与闭包

Go语言闭包应用：

1）不需要修饰如何访问自由变量

2）没有Lambda表达式，但是有匿名函数  （其实二者做的事情差不多，一样）

Go语言对函数式编程主要是体现在闭包上面。

函数式编程 vs 函数指针：

函数是一等公民：参数，变量，返回值都可以是函数（c++里只有函数指针，Java里函数只是一个名字）

高阶函数：函数的参数可以是一个函数

函数-->闭包

函数闭包：

其他语言中对闭包的支持

Python中的闭包：python原生支持闭包、使用_closure_来查看闭包内容
def adder():
      sum = 0
      def  f(value):
            nonlocal sum
            sum += value
            return sum 
      return f

C++中的闭包：过去stl或者boost带有类似库；C++11及以后：支持闭包   以下是C++14下编译通过的
auto adder(){
　　auto sum = 0;
   return [-] (int value) mutable {
　　　　sum += value;
　　　　return sum;
　　}
} 

Java中的闭包：1.8以后：使用Function接口和Lambda表达式来创建函数对象  函数本身不能作为参数和返回值的
1.8以前 匿名类或Lambda表达式均支持闭包
Function<Integer,Integer> adder() {
　　final Holder<Integer> sum = new Holder<>(0);
   return (Integer value) -> {
　　　　sum.value += value;
　　　　return sum.value;
　　}
}

 

 

“正统”函数式编程

1）不可变性：不能有状态，只有常量和函数 2）函数只能有一个参数  但是学习的这篇视频不作这个严格规定

示例fib

目录

adder.go

package main

import "fmt"
//闭包
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 main() {
    // 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)
    }
}

 

输出：

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

Process finished with exit code 0

 

fib.go

package fib

// 1, 1, 2, 3, 5, 8, 13, ...
func Fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

　　

main.go

package main

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

    "learngo/functional/fib"
)

type intGen func() int

func (g intGen) Read(
    p []byte) (n int, err error) {
    next := g() //取下一个元素
    if next > 10000 {//达到10000以上结束
        return 0, io.EOF
    }
    s := fmt.Sprintf("%d\n", next)//转换成字符串

    // TODO: incorrect if p is too small!
    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)
}

　　

 输出：

1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765

Process finished with exit code 0

 示例遍历二叉树

使用函数遍历二叉树

tree详情见之前的https://www.cnblogs.com/ycx95/p/9361122.html