13.1 函数

package main

import "fmt"

func test(a int) { //todo:这里把形参不命名成a，会更便于区分理解
   a = a + 1
   fmt.Println("test a=", a)
}
func sum(a int, b int) int {
   fmt.Println("我要求和啦")
   return a + b
}
func multiply(a, b int) int { //todo:可以(a,b int)这样些，表明a,b同为int类型
   return a * b
}

func myFunc(f func(int, int) int, num1 int, num2 int) int {
   return f(num1, num2)
}

type funcType func(int, int) int

func yourFunc(f funcType, num1 int, num2 int) int {
   return f(num1, num2)
}

//todo:返回值列表的另一种表示方法
func sun(p int, q int) (sum int, sub int) { //由于返回值多于一个，故需要括号
   sum = p + q //不再需要 :=  因为返回值列表中相当于已经申明了变量
   sub = p - q
   return //不能缺这个关键词
}

type myfunc func(a int, b int) (int, int)
func (m *myfunc) test() {
   fmt.Println("这是方法下函数")
}
func hanshu(a int, b int) (int, int) {
   return a + b, a - b
}
func hanshu2(a int, b int) int {
   return a + b
}
//上面的 hanshu、hanshu2是函数名，相当于变量，上面那么写后，就是完成
//了函数变量的申明，但没赋值，里面的参数也申明了，也没赋值；既然函数名
//作为变量，下面主函数中的代码里就把它像变量一样使用

func main() {
   //todo:函数的开辟空间和函数内变量的作用域
   a := 10
   test(a)              //test a= 11    //todo：调用test这一步，由于函数被调用时会开辟一个新的栈空间，因此并不会更改上一行的a
   fmt.Println("a=", a) //a= 10 //todo:可见，函数在一个独立的栈空间，函数里的变量作用域只在函数里

   sum(a, a) //我要求和啦 //todo:此处调用了有返回值的函数sum，但并未接收返回值，这是可以的

   //todo:函数作为一种数据类型
   c := multiply //todo:multiply是一个类型为函数的变量，这样赋值后，c也就是一个函数类型的变量
   fmt.Printf("c的类型是%T,add的类型是%T", c, multiply)
   //c的类型是func(int, int) int,add的类型是func(int, int) int
   res := c(1, 2)           //todo:等价于 multiply(1,2)
   fmt.Println("res=", res) //res= 2

   res1 := myFunc(sum, 3, 4)  //我要求和啦
   fmt.Println("res1=", res1) //res1= 7

   res2 := myFunc(multiply, 3, 4)
   fmt.Println("res2=", res2) //res2= 12

   res11 := yourFunc(sum, 3, 4) //我要求和啦
   fmt.Println("res11=", res11) //res11= 7

   res22 := yourFunc(multiply, 3, 4)
   fmt.Println("res22=", res22) //res22= 12

   cc := hanshu
   d := myfunc(cc) //todo:类型转换，这里的转换必须是c的类型与myfunc是一致的
   //e := myfunc(hanshu2) 比如这里就会因为类型不一致而不能转换类型
   d.test() //这是方法下函数
}