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 4
test6 3
test6 2
test6 1
test6 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 0
1 -
---funcXXX 1
21 -
---funcXXX 21
321 -

例子二:

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"))
}