函数--Go语言学习笔记

Posted 2021-05-18 旧时星空

函数–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:=0
for 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
}