Go语言学习：函数

函数定义

go语言中通过关键字 func 来定义函数
func 函数名（参数）返回指{
函数体
}

无参无返回值

func f1(){
	fmt.Println("hello go")
}

有参无返回值

func f2(x int){
	fmt.Println("hello go")
}

多个同类型参数可以省略上一个或者多个

func f3( x, y int,z bool){
	fmt.Println(x,y,z)
}

单个参数也可以省略 但是不推荐使用

func f4( int){
	fmt.Println("我这个参数怎么接")
}

无参有返回值

func f5() (z int) {
	x := 10
	y := 2
	z = x * y
	return
}

同样也可以省略

func f6() int {
	x := 10
	y := 2
	return x * y
}

go 支持多个参数返回 多个参数返回必须要加括号

func f7() ( x,y int) {
	x = 10
	y = 2
	return x,y
}

有参有返回值

func f8(x, y int) (z int) {
	z = x * y
	return
}

可变参数

可变参数可以接收多个同类型的参数
接收的数据结构是一个切片

func main() {
	f5(10, 20,30,40)
}
func f9(x... int) {
	fmt.Println(x)
}
//输出
//[10 20 30 40]

可变参数必须是在参数的最后一个

func f5(x, y string ,z... int) {
	fmt.Println(x,y,z) 
}

匿名函数

匿名函数 不需要有方法名字
匿名函数是立即使用的
一般用于函数内部，因为函数内部没有办法声明一个有名字的函数

	num := func(x, y int) int {
		
		return x * y
		
	}
	num(10,20)

匿名函数后面直接加括号是 立即调用此函数
一般用于 只执行一次的函数

	 func(x, y int) int {
		
		return x * y
		
	}(10, 20)
	

进阶 函数作为参数传递

func main() {

	fmt.Println(calc(10,50,add))
}

func add(x, y int) (z int) {
	z = x + y
	return
}
func calc(x,y int ,op func(int ,int ) int )int{
	return  op(x,y)
}

进阶 函数作为返回值

func main() {
	p := radd("+")
	fmt.Println(p(10,20))
}
func radd (str string) (op func(int ,int ) int){
	if str == "+"{
		return add
	}else{
		return nil
	}
}

进阶 闭包

闭包是一个函数, 这个函数包含了他外部作用域的一个变量
闭包 = 函数+外部变量的引用

func adder(  x int ) func(int) int {

	return func(y int) int {
		x += y
		return x
	}
}
func main() {
 	ret  := adder(200)
 	ret2 := ret(200)
 	
	fmt.Println(ret2)
}

adder是一个函数
adder 里的匿名函数引用了其外部的X变量
这就是闭包

func main() {
	var f = add_count()
	fmt.Println(f(10))
	fmt.Println(f(20))
	fmt.Println(f(30))
	fmt.Println(f(40))
}

func add_count() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
//输出10 , 30 , 60 , 100

var f = add_count() 其中 f 等于于 add_count里面匿名方法

当第一次调用时 x=0（声明不赋值时默认值）
走匿名方法 给x赋值 返回 x 此时 x=10
当第二次调用时 x=10 （10+20 ） 返回30
一次后推
因为每次调用的方法 实际上时 add_count的匿名函数！
所以X的值并不会消亡 跟着匿名函数的的操作发生着改变