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)
}