Go笔记(3) | 青训营笔记

这是我参与「第五届青训营 」伴学笔记创作活动的第 3 天

函数

函数的声明

func 函数名(参数,参数 ...) 函数调用后的返回值{
    函数体
    return:返回结果
}

func main() {
    printinfo()
    myprint("hello")
    c := add(1, 2)
    myprintnum(c)
    myprintnum(add(1, 2))
    x, y := swap("a", "b")
    x, _ := swap("a", "b")
    fmt.Println(x, y)
}
​
// 无参无返回值函数
func printinfo() {
    fmt.Println("printinfo")
}
​
// 有一个参数的函数
func myprint(msg string) {
    fmt.Println(msg)
}
​
func myprintnum(num int) {
    fmt.Println(num)
}
​
// 有两个参数一个返回值的函数
func add(a, b int) int {
    c := a + b
    return c
}
​
// 有多个返回值的函数
func swap(x, y string) (string, string) {
    return y, x
​
}

形式参数 实际参数

可变参数

func main() {
    fmt.Println(getNums("haha",1, 2, 3, 4, 5))
}
​
// ...可变参数f
func getNums(msg string,nums ...int) int {
    sum := 0
    for i := 0; i < len(nums); i++ {
        sum += nums[i]
    }
    fmt.Println(sum)
    return sum
}

参数传递

值传递 引用传递

arr2的数据是从arr1复制过来的,所以是不同的空间

修改arr2,并不会影响arr

值传递,传递的是数据的副本,修改数据,对于原始数据没有影响

值类型的数据,默认都是值传递,基础类型,array,struct

 func update(arr2 [4]int) {
    arr2[0] = 9
    fmt.Println(arr2)//[9 2 3 4]
}
func main() {
    //值传递
    //arr2的数据是从arr1复制过来的,所以是不同的空间
    //修改arr2,并不会影响arr
    //值传递,传递的是数据的副本,修改数据,对于原始数据没有影响
    //值类型的数据,默认都是值传递,基础类型,array,struct
    //定义一个数组 [个数]类型
    arr := [4]int{1, 2, 3, 4}
    fmt.Println("默认的数据", arr) //默认的数据 [1 2 3 4]
    //传递,拷贝arr
    update(arr)
    fmt.Println("调用后的传递的数据", arr) //调用后的传递的数据 [1 2 3 4]
​
    //引用传递
    //切片,可以扩容的数组,不需要写大小,一个可读，另一个可读写
    s1 := []int{1, 2, 3, 4}
    fmt.Println("默认的数据", s1) //默认的数据 [1 2 3 4]
    update2(s1)
    fmt.Println("调用后的传递的数据", s1) //调用后的传递的数据 [6 2 3 4]
​
}
​
func update(arr2 [4]int) {
    fmt.Println("传递的数据", arr2) //传递的数据 [1 2 3 4]
    arr2[0] = 9
    fmt.Println("修改后的数据", arr2) //修改后的数据 [9 2 3 4]
}
​
func update2(s2 []int) {
    fmt.Println("传递的数据", s2) //传递的数据 [1 2 3 4]
    s2[0] = 6
    fmt.Println("修改后的数据", s2) //修改后的数据 [6 2 3 4]
}
​

函数变量的作用域

func main() {
    var temp int = 100
    if b := 1; b < 10 {
        fmt.Println(b)//1
        fmt.Println(temp)//100
    }
}

递归函数

func main() {
    sum := getNum(5)
    fmt.Println(sum)
}
// 10 + 5
// 6 + 4
// 3 + 3
// 1 + 2
// 1
func getNum(n int) int {
    if n == 1 {
        return 1
    }
    return getNum(n-1) + n
}

defer延迟函数

defer最后执行 栈

func main() {
    a := 10
    fmt.Println("a=", 10)
    defer f(a)  //参数已经传递进去了 最后执行
    a++
    fmt.Println(a)
}
//运行结果
//a= 10
//11          
//函数里的a 10
func f(s int) {
    fmt.Println("函数里的a", s)
}