Go语言学习之路（八）函数

一、函数定义
1.Go语言函数没有声明，直接定义即可

2.函数定义
   func 函数名(形参表){

   }

3.不定参数表(args…数据类型)
   方法一：
   func Test1(args...int){
   for i:=0; i < len(args); i++{
   fmt.Print(args[i])
   }
   }
   方法二：
   func Test(args ...int) {
       for i, data := range args {
           fmt.Print(i, " ")
           fmt.Println(data)
       }
   }
   如果不适用i变量，则可以使用匿名变量：
       func Test(args ...int) {
           for _, data := range args {
               //fmt.Print(i, " ")
               fmt.Println(data)
           }
       }


注意：不定参数一定要放在函数形参表的最后
不定参数根据需要决定传不传参，其他参数必须传参

4.函数嵌套调用
   不定参数嵌套
   全部传递参数：
       func Test3(args...int){
       for _, data := range args{
       fmt.Println(data)
       }
       }

       funcTest4(args...int){
       Test3(args...)
       }
   传递部分参数;
       func Test5(args...int){
       for _,data:=range args{
       fmt.Println(data)
       }
       }

       func Test6(args...int){
       Test5(args[2:]...)
       }
       表示传递了2(包括2)以后的数据

       funcTest5(args...int){
       for_,data:=range args{
       fmt.Println(data)
       }
       }

       funcTest7(args...int){
       Test5(args[:2]...)
       }
       表示传递了2(不包括2)之前的数据

       相当于传递了[a:b]即a(包括a)到 b(不包括b）的数据

       不定参数可以不传值，打印为空
二、函数返回值
1.函数返回值写法
   第一种:
       func AddOne(numOne int, numTwo int) int {
       Sum := numOne + numTwo
       return Sum
       }
   第二种:
       func AddTwo(numOne int,numTwo int) (Sum int) {
       Sum = numOne + numTwo
       return Sum
       }
   第三种:
       func AddThree(numOne int,numTwo int) (Sum int) {
       Sum = numOne + numTwo
       return
       }

2.返回多个值
   第一种：
       func TestOne() (a int,b int,c int) {
       a = 1
       b = 2
       c = 3

       return a, b, c
       }

       var Rone int
       //var Rtwo int
       var Rthree int

       ROne,_,RThree=TestOne()

       fmt.Println(ROne,RThree)

   第二种：
       func TestOne() (a int,b int,c int) {
       a = 1
       b = 2
       c = 3

       return
       }

       var Rone int
       //var Rtwo int
       var Rthree int

       ROne,_,RThree=TestOne()

       fmt.Println(ROne,RThree)

       匿名变量可以使用多个·，但是使用时不能·出现_,_,_=TestOne()，这样go会认为应该直接使用TestOne(),所以会报错
   第三种：
       func test()(max,minint){}
三、函数类型
type 类型名函数名形参表

type FUNCTYPE func(a int,b int) int

func Add(a int,b int)(sum int){
Sum = a + b
return
}

func main(){
Var Result FUNCTYPE
Result = Add
fmt.Println(Result(1,2))
}

四、函数作用域
1、全局变量
定义在函数体内的变量

var a int

func main(){
a=9
Test()
fmt.Println(a)
}

func Test(){
a=5
a+=1
//fmt.Println(a)
}

结果为6

修改了全局变量

2、局部变量
var a int

func main(){
a := 9
Test()
fmt.Println(a)
}

func Test(){
a=5
a+=1
//fmt.Println(a)
}

结果为9

全局变量与局部变量名称一致时
局部变量优先级高于全局变量

func main(){
a := 9
Test()
fmt.Println(a)
}

func Test(){
a:=5
a+=1
//fmt.Println(a)
}

结果为9

局部变量 Test函数结束后栈释放

五、匿名函数
所谓匿名函数就是没有名字能够直接在函数体内进行调用的函数
一、匿名函数使用

法一：

Go语言学习之路（八）函数

法二：

Go语言学习之路（八）函数

法三：直接调用匿名函数
var num int=9

func(){
num+=1
}()

fmt.Println(num)

匿名函数返回值
   x,y:=func(i,j int)(max,min int){
   if i<j {
   max=j
   min=i
   }elseifi>j{
   max=j
   min=i
   }else{
   fmt.Println("相等")
   }

   return
   }(10,20)

   fmt.Println("max:",x)
   fmt.Println("min:",y)

匿名函数传参：
   法一：
   f:=func(a int,b int){
   sum:=a+b
   fmt.Println(sum)
   }

   f(10,20)
   法二：
   func(a int,b int){
   sum:=a+b
   fmt.Println(sum)
   }(10,20)

六、闭包
函数闭包就是以匿名函数作为函数返回值

func main(){

f:=Test()

fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
}

func Test() func() int {
var a int=0
return func() int {
a++
return a
}
}

七、递归函数
递归函数就是不断调用自身的函数，下面举例求20的阶乘

Var i int64=1
Var n int64=1

func main(){
Count()
fmt.Println(n)
}

func Count(){
n*=i
i++

if 20>=i{
Count()
}
}

Go语言学习之路（八）函数

相关推荐