Go函数式编程

Go函数式编程

• 函数是一等公民：参数，变量，返回值都可以是函数

• 高阶函数：可以将一个函数作为另外一个函数的参数。

  ​

  f1()
  f2(f1)
  f1函数作为f2函数的参数
  f2函数，叫做高阶函数，接收了另外一个函数作为参数的函数
  f1函数，叫做回调函数，作为另外一个函数的参数
  

  package main
  
  import "fmt"
  
  // 回调函数
  func main() {
  	// 函数调用
  	r1 := add(1, 2)
  	fmt.Println(r1)
  	// 高阶函数调用
  	r2 := oper(1, 2, add)
  	fmt.Println(r2)
  	r3 := oper(1, 2, sub)
  	fmt.Println(r3)
  	// 匿名函数
  	fun1 := func(a, b int) int {
  		return a * b
  	}
  	r4 := oper(1, 2, fun1) // 调用匿名函数 *
  	fmt.Println(r4)
  	// 能够直接传递匿名函数
  	r5 := oper(1, 2, func(a int, b int) int {
  		if b == 0 {
  			fmt.Println("除数不能为0")
  			return 0
  		}
  		return a / b
  	})
  	fmt.Println(r5)
  }
  
  // 运算 (运算的数字，运算操作)
  // 高阶函数，参数是接收另外一个函数
  func oper(a, b int, fun func(int, int) int) int {
  	fmt.Println(a, b, fun)
  	r := fun(a, b)
  	return r
  }
  
  func add(a, b int) int {
  	return a + b
  }
  func sub(a, b int) int {
  	return a - b
  }
  

Go语言中函数的本质也是一种数据类型

闭包

一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量

并且该外层函数的返回值就是这个内层函数。

这个内层函数和外层函数的局部变量，统称为闭包结构。

局部变量的生命周期就会发生改变，正常的局部变量会随着函数的调

用而创建，随着函数的结束而销毁

但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用

func incre() func() int { //外层函数
	//定义一个局部变量
	i := 0
	//在外层函数的内部定义一个匿名函数，给变量自增并返回
	fun := func() int {
		i++
		return i
	}
	return fun
}

e.g.用闭包实现斐波那契数

package main

import "fmt"

// 闭包实现斐波那契数
func main() {
	f := fbnq()
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println(f())
	fmt.Println("----------------")
	f1 := fbnq() //再次调用，a,b从0，1开始
	fmt.Println(f1())
	fmt.Println(f1())
	fmt.Println(f()) //这里的并没有随着第二次创建就被销毁归，而是在内层函数继续调用着
	fmt.Println(f1())
	fmt.Println(f1())
	fmt.Println(f1())
}

func fbnq() func() int {
	a, b := 0, 1
	return func() int {
		a, b = b, a+b
		return a
	}
}