go语言中的定义函数类型,匿名函数,自执行函数

定义一个函数类型

type add func(int, int) int

定义函数类型

package main
import ("fmt")


// 定义一个函数类型
type addType func(int, int) int

func add(a int, b int) int {
	return a + b
}
func main()  {
	// 定义一个变量a,这个变量a的类型是一个函数
	var a addType
	// 将函数的add赋给a
	a = add
	// 调用这个函数
	fmt.Println(a(1, 2))
} 

// 输出 3

自定义类型

package main
import ("fmt")
// 自定义一个类型
type myInt int
func main()  {
	// 定义一个变量a,这个变量a的类型是一个函数
	var a int = 10
	// 使用这个自定义的类型
	var b myInt = 20
	var c = a + b
	fmt.Println(c)
} 

输出的话，会进行报错的哈。
因为：不同类型之间不能直接进行运算。
虽然 myInt 的底层类型是 int，但在 Go 的类型系统中。
myInt 和 int 被视为两个完全独立、不同的类型,所以不能进行运算。
type myInt int 只是创建了一个以 int [为底层类型]的[新类型]，它不会继承 int 的方法，也不会和 int 自动兼容。

解决办法：显式类型转换。转化为相同的类型，然后再进行相加

package main
import ("fmt")
// 自定义一个类型
type myInt int
func main()  {
	// 定义一个变量a,这个变量a的类型是一个函数
	var a int = 10
	// 使用这个自定义的类型
	var b myInt = 20
	// 转化为相同的类型
	var c = a + int(b)
	fmt.Println(c)
} 

将函数作为参数进行传递

package main
import ("fmt")

// 自定义一个类型
type addType func(int, int) int

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

// 等价于：func addFn(a, b int, callFn func(int, int) int) int {}
func addFn(a, b int, callFn addType) int {
	return addMethods(a, b)
}

func main()  {
	var a = 1
	var b = 2
	// 把函数当做参数进行传递了哈
	fmt.Println(addFn(a, b, addMethods))

} 

输出3

匿名函数

匿名函数就是么有函数名称的函数，匿名函数的写法形式如下：
func(参数列表) (返回值列表) {函数体}
为啥会出现匿名函数？因为：普通函数不能够放到另外一个函数下。
如果我非要在一个函数中写另外一个函数怎么办呢？
1，写成匿名函数

普通函数不能够放到另外一个函数下

package main
import ("fmt")

func main()  {
	// 普通函数say不能够放到另外一个函数main下,否则会报错的哈
	fun say(){
		fmt.Println("hello world")
	}
} 

写成匿名函数在赋值给一个变量

package main
import ("fmt")

func main()  {
	//写成匿名函数在赋值给一个变量
	var funSay = func (){
		fmt.Println("hello world")
	}
	funSay()
} 

匿名函数自执行

package main
import ("fmt")

func main()  {
	// 匿名函数自执行
// 等价于： var funSay = func (){ } funSay();现在直接把括号放在了变量后面，进行调用。
	func (){
		fmt.Println("hello world")
	}()
}