八、2.函数的参数、返回值和递归

1.参数

package main

import "fmt"
//函数的参数传递，同类型形参可以省略类型
func add(a, b int) int {
    return a + b
}
func sum(a, b int) int {
    c := 0
    for a <= b {
        c += a
        a++
    }
    return c
}
func addN(c, d int, args ...int) int {
    fmt.Println(c, d, args)
    fmt.Printf("%T\n", args)
    return c
}
//可变参数
//可变参数只有一个 类型必须一致 以切片的方式传递
func addM(args ...int) int {
    s := 0
    for _, v := range args {
        s += v
    }
    return s
}

//args...  因为要调用其他函数 要传参 而addM 的args 是一个int 如果sacl的args 是一个int切片，传参会失败，那么我们需要对这个切片做解包然后传递 ...表示解包把切片中的元素分解成单一元素传递
func sacl(c string, args ...int) int {
    switch c {
    case "add":
        return addM(args...)
    }
    return -1
}
//切片删除元素函数
func del(nums02 []int, num int) []int {
    nums02 = append(nums02[:num], nums02[num+1:]...)
    return nums02
}
func main() {
    fmt.Println(add(1, 5))
    fmt.Println(sum(1, 6))
    fmt.Println(addN(1, 2, 3, 5, 6))
    fmt.Println(addM(1, 10, 11))

    fmt.Println(sacl("add", 1, 2, 3))
    //切片删除
    nums01 := []int{1, 2, 3, 4, 5, 6, 7, 8, 10}
    //删除索引为4的元素
    //...表示把切片的元素解包 然后添加到 前面的切片中 :4 表示0至4 并不包括4 那么从5开始解包元素并添加  就表示把索引位4的元素剔除了
    nums01 = append(nums01[:4], nums01[5:]...)
    fmt.Println(nums01)
    num03 := []int{1, 2, 3}
    fmt.Println(del(num03, 2))
}

2.返回值

package main

import "fmt"
func sum(a []int) int {
    for _, v := range a {
        return v
    }
    return -1
}

//多返回值
//有多少个返回值 就需要多个变量来接，如果不需要 可以用_丢弃
func testreturn(a, b int) (int, int, int, int) {
    return a + b, a - b, a * b, a / b
}
//返回值命名
//会返回当前变量的值
//不推荐 因为变量过多 会引起混乱
func test(a, b int) (sum, sub, mul, div int) {
    sum = a + b
    sub = a - b
    mul = a * b
    div = a / b
    return
}
func main() {
    //go规定在函数的执行逻辑中必须有返回值 每个分支都必须有
    //return:在多个return的时候，碰到return就返回 return之后的代码就不执行了
    //例如上面函数sum  正常来说切片使用循环遍历 是可以得到很多的，结果只有1 那么就是到return 就结束
    s := []int{1, 2, 3, 4}
    fmt.Println(sum(s))
    q, w, e, _ := testreturn(1, 2)
    fmt.Println(q, w, e)
    fmt.Println(test(1, 2))
}

3.递归

递归是指函数直接或间接调用自己，递归常用于解决分治问题，将大问题分解为相同的小问
题进行解决，需要关注终止条件

package main

import "fmt"
//递归
func addN(a int) int {
    if a == 1 {
        return 1
    }
    fmt.Println(a)
    return a + addN(a-1)
}
func factorial(n int) int {
    if n == 0 {
        return 1
    }
    fmt.Println(n)
    return n * factorial(n-1)
}
func tower(a, b, c string, layer int) {
    if layer == 1 {
        fmt.Println(a, "->", c)
        return
    }
    //a n-1 借助c 移动到b
    tower(a, c, b, layer-1)
    fmt.Println(a, "->", c)
    //b n-1 借助a 移动到c
    tower(b, a, c, layer-1)
}
func main() {
    // fmt.Println(addN(3))
    fmt.Println(factorial(35))
    tower("a", "b", "c", 5)
}