函数定义

函数定义和使用

/*
 func 函数名(函数参数)(返回值){
    代码体
    return 值
}
*/
​
//函数的定义 
func add(a int,b int) int {
    sum:= a+b
    return sum
}
​
//函数的优点
//1,多次使用，降低代码冗余，提高代码编写速度
//2,方便修改和完善
func main(){
    
    a := 10
    b :=20
    sum := add(a,b)
    fmt.Println(sum)
}

函数的参数和返回值

//函数定义时，函数的参数成为形式参数 没有具体的值简称形参
//主要目的是在函数调用时告诉函数的格式，个数，类型
func max(a int,b int) int {
​
    if a>b {
        //return 表示函数的结束 在一个函数中可以出现多个return
        //当一个return被执行时，表示函数停止
        return a
    }else {
        return b
    }
}
​
//执行
func main() {
​
    a := 10
    b := 20
    //调用函数
    //在函数调用时 函数的参数称为实际参数 简称为实参 实参有具体的值
    result := max(a, b)
    fmt.Println(result)
}
​

函数的不定参

//定义不定参数  参数名 + ... + 参数类型
func sum (arr ...int) int{
    sum := 0
    //通过下标获取 元素的值 
    // arr[index]  集合[下标]
    //通过len(arr) 获取集合元素的个数
    for i:=0;i<len(arr);i++{
        sum += arr[i]
    }
    fmt.Printf("%T
", arr) //整型切片
    rereturn sum
}
​
//函数调用
 reselut :=sum(1,2,3,4,5)
​

len

#program mark:
    1，可获取字符长度
    2，可获取集合个数

函数的嵌套调用

//不定参函数嵌套调用
func demon(arr ...int) int {
    //函数调用
    //不定参作为函数参数时，需要使用...
    max := demon1(arr...)
    return max
}
​
func demon1(arr ...int) int {
    max := arr[0]
    //循环遍历
    for i := 0; i < len(arr); i++ {
        //满足条件 记录最大值
        if arr[i] > max {
            max = arr[i]
        }
    }
    return max
}
//调用
reseult :=demon(9,2,3,4,10,2)

函数的返回值

//多个函数的返回值
func test2() (a int, b int, c int) {
    a = 10
    b = 20
    c = 30
    return a, b, c
}
​
//多个函数返回值
func test2() (int,int,int) {
    a = 10
    b = 20
    c = 30
    return a, b, c
}
​
//匿名变量接收
var m, n int
m, n, _ = test2()
fmt.Println(m,n)
​

 

函数类型

1,函数名本身是一个地址常量 (不可修改)
2,函数在内存中的代码区位置
​
//定义函数类型变量
var f  func() 
//将函数赋值给函数类型变量
f = test
fmt.Println(f)
​
//调用函数
func test() {
    fmt.Println("hello world")
}
​
///MARK: 函数定义类型别名
type FUNCTYPE func(int, string) (int, bool)
​
//定义函数类型变量
var f =  FUNCTYPE
//在通过函数类型变量调用函数时 如果函数有参数 需要传递参数
f = test2
f(1, "")
​
//调用函数
func test2(a int, b string) (int, bool) {
    fmt.Println("调用test2函数")
    return 0, false
}
​
///MARK: 自动推导类型创建 函数变量
f := test2
f(1,"")

函数的作用域

//局部变量</br> //在函数内部定义的变量成为局部变量</br> //作用域：从变量定义到函数结束</br>

匿名函数

//定义并调用匿名函数
reslut := func(a int,b int)int{
    return a+b
}(10,20)
​
//(a:10,b:20)调用匿名函数
fmt.Println(reslut) 
​
//方法2 
f:=func(a int,b int)int{
    return a+b
}
​
sum:=f(10,20)
fmt.Println(sum)

递归函数

#pargram mark  
//如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。
//递归函数一定有出口 return 
​
案例:
    func test9(n int)  {
    if n == 0 {
        return
    }
    //sum *=n //5*4*3*2*1
    test9(n-1)
    sum *=n //1*2*3*4*5
}
​
func main() {
    test9(6)
    fmt.Println(sum)
}
​
注意:
    递归函数的执行流程