愚者的小屋
0%

go函数

发表于 更新于 分类于 ，

Go函数

函数

函数声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package main

import "fmt"

func foo1(a string, b int) int {
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    c := 100
    return c
}

//返回多个返回值，匿名的
func foo2(a string, b int) (int, int) {
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)

    return 666, 777
}

//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
    fmt.Println("---- foo3 ----")
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)
    
    //r1 r2 属于foo3的形参，  初始化默认的值是0
    //r1 r2 作用域空间 是foo3 整个函数体的{}空间
    fmt.Println("r1 = ", r1)
    fmt.Println("r2 = ", r2)
    
    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000

    return
}

func foo4(a string, b int) (r1, r2 int) {
    fmt.Println("---- foo4 ----")
    fmt.Println("a = ", a)
    fmt.Println("b = ", b)
    
    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000

    return
}

func main() {
    c := foo1("abc", 555)
    fmt.Println("c = ", c)

    ret1, ret2 := foo2("haha", 999)
    fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)

    ret1, ret2 = foo3("foo3", 333)
    fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)

    ret1, ret2 = foo4("foo4", 444)
    fmt.Println("ret1 = ", ret1, " ret2 = ", ret2)
}

运行结果：
image

注意事项

  • 首字母大写为公有，小写为私有（同一个包）。（函数，变量，常量同理）
  • 参数为值传递，是拷贝的副本，可以使用指针
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    func swap(a *int, b *int) {
        tmp := *a
        *a = *b
        *b = tmp
        return
    }

    func main() {
        a, b := 1, 2
        swap(&a, &b)
        fmt.Printf("a = %d, b = %d\n", a, b)
    }

    defer 延迟执行

    Go语言的 defer 语句会将其后面跟随的语句进行延迟处理，在 defer 归属的函数即将返回时，将延迟处理的语句按 defer 的逆序执行 (栈)
    1
    2
    3
    4
    5
    6
    7
    8
    func main() {
        //写入defer关键字
        defer fmt.Println("main end1")
        defer fmt.Println("main end2")
        
        fmt.Println("main::hello go 1")
        fmt.Println("main::hello go 2")
    }
    运行结果：
    image

return 为函数时：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

func deferFunc() int {
    fmt.Println("defer function called...")
    return 0
}

func returnFunc() int {
    fmt.Println("return function called...")
    return 0
}

func returnAndDefer() int {
    defer deferFunc()

    return returnFunc()
}

func main() {
    returnAndDefer()
}

运行结果：
image

匿名函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

func main() {

    // 无参，例如 func(){}() 调用
    func () {
        fmt.Println("匿名函数。。。")
    }()

    // 有参有返回值
    sum := func (a int, b int) int {
        return a + b
    }(1,2)

    fmt.Println("sum = ", sum)
}