Go(4 [函数])

Go函数,

写法:声明函数:func 函数名(参数列表)[(返回值列表)]{}

特点:

1. 不支持重载，一个包不能有两个名字一样的函数

2. 函数是一等公民,函数也是一种类型,一个函数可以赋值给变量

3. 匿名函数

4. 多返回值

函数传递方式:

1. 值类型

2. 引用类型

3. map、 slice、 chan、指针、 interface默认以引用的方式传递
   

无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷呗，一般来说，地址拷呗更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。

测试一:函数赋值

func add (a int,b int) int  {   return  a + b}func main()  {   c:=add   fmt.Printf("%P %T %p %T \n",c,add,c,add)   sum :=add(30,40)   fmt.Println(sum)   ccc :=c(30,40)   fmt.Println(ccc)}

一:自定义函数:

type add_func func(int ,int)int//自定义一个函数类型,也可以传递func operator(op add_func,a ,b int) int {    //值传递给自定义函数   return op(a,b)}func main(){sum :=operator(c,100,200)fmt.Println(sum)}

测试二:返回值写法

func test2(a,b int)(c int)  {   c = a +b   //不必写c,默认会把c返回   return}

func test3(a,b int)(sum int,avg int)  {   sum  = a +b   avg = (a +b)/2   return}func main(){e,q:=test3(6,7)fmt.Println(d,e,q)}

二:可变参数:     (这里又有...用法)

func add(arg…int) int {}0个或多个参数func add(a int, arg…int) int {}1个或多个参数func add(a int, b int, arg…int) int {}2个或多个参数

其中arg是一个slice，我们可以通过arg[index]依次访问所有参数通过len(arg)来判断传递参数的个数

测试三:多个值传递

func test4(arg...int) int {   var sum int   fmt.Println("test4---arg",arg)   for i:=0;i<len(arg);i++{      sum = sum + arg[i]   }   return sum}func testArg()  {   fmt.Println(test4(1))   fmt.Println(test4())   fmt.Println(test4(1,3,4,5,6,2121,21,12,))}func main(){testArg()}

三:关键字defer

1. 当函数返回时,执行defer语句,因此,可以用来做资源清理 例如:

   1. 关闭文件句柄

   2. 锁资源释放

   3. 数据库连接释放

2. 多个defer语句,按先进后出的方式执行,

3. defer语句中的变量,在defer声明时就决定了

示例1:

func test5()  {   i:=0   defer fmt.Println("test5",i)   i++   return}>>>test5 0

示例二:

func test6()  {   for i:=0;i<5;i++{      defer fmt.Println("test6",i)   }}>>test6 4test6 3test6 2test6 1test6 0

四:函数递归

func test7(a int) int  {   if a == 1{      return 1   }   return test7(a-1) * a}n:=test7(5)fmt.Println(n)

五:斐波那契

func test8( a int) int  {   if a <= 1{      return 1   }   return test8(a -1) + test8(a - 2)}for i:=0;i<20;i++{   n:=test8(i)   fmt.Printf("%d ",n)}

六:闭包：

func test9() func(int) int  {   var x int   fmt.Println("---XXX",x)    //返回一个匿名函数   return func(a int) int {      //x就是闭包里面的全局变量      //因为全局变量生命周期长      //调用的结果存在x里面,所以下次调用的时候,是在之前结果基础上在相加、      //观察哪个是外部变量, 这个外部变量就是成员变量！，值一直会在, 这里x就是外部变量      fmt.Println("---funcXXX",x)      x+=a      return x   }}func main(){var f = test9()fmt.Println(f(1),"-")fmt.Println(f(20),"-")fmt.Println(f(300),"-")}》》---XXX 0---funcXXX 01 ----funcXXX 121 ----funcXXX 21321 -

例子二:

func test10(suffix string) func(string) string {   //suffix 可以当成 成员变量, 一直存在   f:= func(name string) string {      if !strings.HasSuffix(name,suffix){         return name + suffix      }      return name   }   return f}func main(){func1 :=test10(".bmp")func2 :=test10(".jgp")fmt.Println(func1("zcq"))fmt.Println(func2("rch"))}