15. Go-闭包函数式编程

闭包函数式编程

闭包

• go 支持闭包
• 闭包是指有权访问另一个函数作用域中的变量的函数, 在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
• • 闭包的用途在于
    • 读取其他函数内部的变量
    • 创造一个私有作用域

package main

import "fmt"

func addSum() func(int) int  {
	sum := 0
	return func(n int) int {
		sum = sum + n
		fmt.Println(sum + n)
		return sum
	}
}

type iAddSum func(int) (int,iAddSum)
func addSum2(base int) iAddSum  {
	return func(i int) (int, iAddSum) {
		return base + i, addSum2(base + i)
	}
}


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

func main() {
	// 数据累加
	// a :=addSum()
	// a :=addSum2(0)
	// for i := 0; i < 10; i++ {
	// 	var s int
	// 	s,a = a(i)
	// 	fmt.Println(s)
	// }

	b := Fibonacci()

	for i := 0; i < 10; i++ {
		old,n :=b()
		fmt.Println(old, n)
	}

}

函数式

• 在 Go 语言中函数是一等公民，它作为一个变量、类型、参数、返回值，甚至可以去实现一个接口,但是 Go 语言中函数不支持重载、嵌套和默认参数。
• 函数支持的特性

package main
import "fmt"


// 作为变量
func test(){}
funcTest := test
fmt.Println


// 匿名函数
test := func(){}


// 作为类型
type iAdder func(int, int) int

func main(){
    var adder iAdder = func(a int, b int) int {
        return a + b
    }
    
    fmt.Println(adder(1,2)) // 3
}


// 不定长度参数
func test(num ...int){
    fmt.Println(num) // [1 2 3 4]
}
test(1,2,3,4)


// 多返回值
func test() (string,int,bool){
    return "Hello World", 100, true
}
v1, v2, v3 := test()
fmt.Println(v1, v2, v3) // Hello World 100 true


// 命名返回值参数
func test() (a string, b bool, c int) {
    a = "Golang"
    b = false
    c = 200
    return
}
v1, v2, v3 := test()
fmt.Println(v1, v2, v3) // Golang false 200 

• 使用函数实现接口

package main

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

// 使用 闭包实现 斐波那契数列
func fibonacci() intGen {
    a, b := 0, 1
    return  func() int {
        a, b = b, a + b
        return a
    }
}

// 定义一个类型
type intGen func() int

// 实现一个 Reader 接口
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)
    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(){
    f := fibonacci()
    
    printFileContents(f)
}