Go 函数的骚操作

参考：
李文周的博客

定义函数类型

我们可以使用type关键字来定义一个函数类型，具体格式如下

type calculation func(int, int) int

类似于int、float、string。就好像新定义了一个关键字
例子：

func add(a,b int) int{
	return a+b
}

func sub(a,b int) int{
	return a-b
}

func main(){
	type calculation  func(int,int) int

	var a calculation//var a int
	a = add
	sum:= a(10,20)
	println(sum)

	s := sub
	num := s(20,10)
	println(num)
}

函数类型变量
写递归算法时常用到

var  digui func()
digui = func() {
	println("把啦啦啦能量！")
}
digui()

var add func(int,int)int
add = func(i1, i2 int) int {
	return i1+i2
}
println(add(10,20))

匿名函数
函数当然还可以作为返回值，但是在Go语言中函数内部不能再像之前那样定义函数了，只能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下：

func(参数)(返回值){
    函数体
}

实例一：

匿名函数作为返回值

func xxx() func(){
	return func() {
		println("lalalala")
	}
}
func main(){
	a := xxx()
	a()
}

实例二

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数

func main(){
	add := func (a,b int) int  {
		return a+b
	}
	num:=add(10,20)
	println(num)

	func (a,b int) int{
		return a+b
	}(10,20)//可以直接在后面加括号立即执行
}

闭包

闭包指的是一个函数和与其相关的引用环境组合而成的实体

闭包 = 匿名函数+外层变量的引用

实例一：

变量f是一个函数并且它引用了其外部作用域中的name变量，此时f就是一个闭包。 在f的生命周期内，变量x也一直有效

。

func sayhello2 ( name string) func(){//这是个闭包
	//name:=string
	return func ()  {
		println("hello",name)
	}
}
func sayhello() func(){//它不是一个闭包，它没有引用外部变量
	return func ()  {
		println("Hello")
	}
}
func main(){
	f := sayhello2("悟空")//f此时就是个闭包
	f()//相当于执行了函数内的匿名函数
}

进阶实例：
文件后缀名检测

import "strings"
func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
		//HasSuffix是判断name变量是否以suffix为后缀。如果是返回True。
			return name + suffix
		}
		return name
	}
}
func main(){
	file := makeSuffixFunc(".txt")
	s:= file("悟空")
	println(s)//悟空.txt
	s2:=file("沙师弟")
	println(s2)//沙师弟.txt
}

进阶实例2：

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}