本文共 3037 字，大约阅读时间需要 10 分钟。

函数–Go语言学习笔记

函数的定义

func funcName(形参1 type1,形参2 type2) (返回值1 type1,返回值2 type2){

//函数体
return value1,value2//go语言支持多返回值
}

如果形参1和形参2的类型一样可以合并为（形参1，形参2，返回值类型）

函数的参数

形式参数：也叫形参。函数定义的时候，用于接受外部传入的数据的变量。函数中，某些变量的数值无法确定，需要由外部传入数据。

实际参数：也叫实参。函数调用时，给形参赋值的实际的数据。

函数的调用：

1.函数名：声明的函数名和调用的函数名要统一。

2.实参必须严格匹配形参：顺序，个数，类型，一一对应。

可变参

概念：一个函数的参数的类型确定，但是个数不确定。就可以使用可变参数。

语法：参数名…参数的类型

对于函数，可变参数相当于一个切片。

调用函数的时候，可以传入0-多个参数。

Println(),Printf(),Print()

append()

注意事项：

A：如果一个函数的参数时可变参数，同时还有其他的参数可变参数要放在参数列表的最后面。

B：一个函数的参数列表最多只能有一个可变参数。

func getSum(nums..int){
   sum:=0for i:=0;i<len(nums);i++{
   sum+=nums[i]}fmt.Println("总和是："，sum)}

参数传递

A：值传递：传递的是数据的副本。修改数据，对于原始数据没有影响。值类型的数据，默认都是值传递：基础类型，arry,struct

B:引用传递：传递的是数据的地址。导致多个变量指向同一块内存。引用类型的数据，默认都是引用传递：slice,map,chan.

函数带一个返回值

func getSum()int{
   //返回值为 int    sum:=0    for i:=1;i<=10;i++{
           sum+=i    }    return sum}

func getSum2()(sum int){
   //定义函数时，指明返回的数据是哪一个    for i:=1;i<=100;i++    {
           sum+=i    }    return}

带多个返回值

func rectangle(len,wid float64)(peri float64,area float64){
   //已指明返回的数据    peri=(len+wid)*2    area=len*wid    return}

空白标识符–专门用来舍弃数据

re,_:=retangle(2,3)fmt.Println(re)//10

注意点：

1.一个函数定义了返回值，必须使用return语句将结果返回给调用处。return后的数据必须和函数定义的一致：个数，类型，顺序

2.可以使用_,来舍弃多余的返回值

3.如果一个函数定义了有函数返回值，那么函数中有分支，循环，那么要保证，无论执行哪个分支，都要有return语句执行

4.如果一个函数没有定义返回值，那么函数中可以使用

return,专门用来结束函数的执行。

全局变量–所有函数都可以使用，而且共享这一份数据

函数的类型

func(参数列表的数据类型)(返回值列表的数据类型)

匿名函数

定义一个匿名函数《直接进行调用。通常只能使用一次，也可以使用匿名函数赋值给某个函数变量，那么就可以多次使用了。

匿名函数：

Go语言是支持函数式编程：

1.将匿名哈桑农户作为另一个函数的参数，回调函数

2.将匿名函数作为另一个函数的返回值，可以形参闭包结构。

func main(){
       func (){
           fmt.Println("我是一个匿名函数")    }()//直接调用    fun3:=func(){
           fmt.Println("我也是一个匿名函数")    }//没有()所以没有进行调用    fun3()}//我是一个匿名函数//我也是一个匿名函数

带参数的匿名函数

func(a,b int){
       fmt.Println(a,b)}(1,2)//实参

定义带返回值的匿名函数

func main(){
       res1:=func(a,b int)int{
       return a+b   }(10,20)//匿名函数调用了，jiangzhixing-结果给res1    fmt.Println(res1)}//30

高阶函数

函数fun1作为函数fun2的参数，其中fun1叫做回调函数，fun2叫做高阶函数。

func main(){
       res1:=add(1,2)    fmt.Println(res1)//3        res2:=oper(10,20,add)    fmt.Println(res2)//30        res3:=oper(5,2,sub)    fmt.Println(res3)//3        res5:=oper(100,8,func(a,b int)int{
           if b==0{
               fmt.Println("除数不能为0")            return 0        }        return a/b    })    fmt.Println(res5)//12}//加法func add(a.b int)int{
       return a+b}//减法func sub(a,b int)int{
       return a-b}func oper(a,b int,func(int,int)iint)int{
       fmt.Println(a,b,fun)//打印三个参数    res:=fun(a,b)    return res}//参数有匿名函数，根据调用oper时的实参确定调用哪个回调函数，//即可选择加法还是减法运算

闭包

一个外层函数中，有内层函数，该内层函数中，会操作外层函数的局部变量(外层函数中的参数，或者外层函数中直接定义的变量)，并且该外层函数的返回值就是这个内层函数，这个内层函数和外层函数的局部变量，统称为闭包结构。

func main(){
       res1:=incerement()//res1=fun    v1:=res1()    fmt.Println(v1)//1    v2:=res1()    fmt.Println(v2)//2 注意：结果为2.是因为函数fun    //一直没有结束，一直等待调用，其作为返回值不代表自身结束，    //所以i的值一直保存并随着incerement的调用而不断更新}func incerement()func()int{
   //外层函数    //1.定义一个局部变量    i:=0    //2.定义一个匿名函数，给变量自增并返回    fun:=func()int{
   //内层函数        i++        return i    }    //3.返回该匿名函数    return fun}