目录

• 函数指针 vs 函数式编程
• 闭包
• 斐波那契数列与函数接口

函数指针 vs 函数式编程

• 函数是go语言中的一等公民，参数 变量 返回值都可以是函数
• go语言并不是正统的函数式编程，go语言的函数式编程主要体现在 "闭包" 上
• 高阶函数，比如 参数函数

注：正统的函数式编程：

1. 不可变性：不能有状态，只有常量和函数
2. 函数只能有一个参数

闭包

在一个函数内部可以定义另一个函数（函数嵌套定义），有了嵌套函数这种结构，便会产生闭包问题．Go不能在函数内部显式嵌套定义函数，但是可以定义一个匿名函数。

• 示例源码 — 累加器

package main

import "fmt"

//返回值是匿名函数：该匿名函数就是一个闭包
//对于闭包，v是局部变量，sum是自由变量，是闭包所处的环境
func adder() func(value int) int {
        //sum 为自由变量
    sum := 0
    return func(v int) int {
        sum += v
        return sum
    }
}
func main() {
    adder := adder()
    for i :=0;i<10;i++{
        fmt.Printf("0 + 1+ ...+ %d = %d \n",i,adder(i))
    }
}

• 输出（sum自动实现累加）

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

为函数实现接口

• 为闭包创建一个类型，为其实现　io.Reader　接口

package main

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


//斐波那契数列定义
func Fibonacci() returnFunc {
    a ,b := 0, 1
    return func() int {
        a , b = b , a + b
        return a
    }
}


type returnFunc func() int

func (g returnFunc) Read(
    p []byte) (n int, err error){
    next := g()
    if next > 100000 {
        return 0, io.EOF
    }
    s := fmt.Sprintf("%d \n", next)
    //strings.NewReader 作为returnFunc的代理函数
    return strings.NewReader(s).Read(p)
}

//打印斐波那契数列
func PrintFibonacci(reader io.Reader)  {
    scanner := bufio.NewScanner(reader)

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

func main() {
    f := Fibonacci()
    PrintFibonacci(f)
}