作用域

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 使用最多的if语句类型只有if而没有else分支
if simplestms; expression {
    ... ...
}

// 在这种类型的if语句中，有两个代码块：一个隐式的代码块和一个显示的代码块
// 上面代码等价于
{ // 隐式的代码块
    simplestms
    if expression { // 显式代码块
        ... ...
    }
}

 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

package main

import "fmt"

func main() {
    // 这里需要注意变量声明的先后顺序
    if a := 1; false {
        fmt.Println(11)
    } else if b := 2; false {
        fmt.Println(22)
    } else if c := 3; false {
        fmt.Println(33)
    } else {
        fmt.Println(a, b, c)
    }

    // 上面代码 等价于如下代码 因此不同位置定义的变量作用域不同
    {
        aa := 1
        if false {
            fmt.Println(11)
        } else {
             bb := 2
            if false {
                fmt.Println(22)
            } else {
                 cc := 3
                if false {
                    fmt.Println(33)
                } else {
                    fmt.Println(aa, bb, cc)
                }
            }
        }
    }

    // Output:
    // 1 2 3
    // 1 2 3
}

 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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

package main

import (
    "fmt"
    "math/rand"
)

// Ga 全局变量
var (
    Ga int = 99
)

// v 全局常量
const (
    v int = 199
)

func main()  {
    // 覆盖外部声明变量Ga
    Ga := "string"
    fmt.Println("main函数中:", Ga)  // main函数中: string

    b := GetGa()
    fmt.Println("main函数中：", b(), b(), b(), b())

    printGVariable()

    fmt.Println(v)

    // 注意这里屏蔽了全局常量v
    v := 1
    {
        v := 2
        fmt.Println(v)
        {
            v := 3
            fmt.Println(v)
        }
    }

    fmt.Println(v)

    // Output:
    // main函数中: string
    // GetGa if中： 55
    // GetGa 循环中： 2
    // GetGa函数中: 99
    // main函数中： 100 101 102 103
    // 103
    // 199
    // 2
    // 3
    // 1
}

// GetGa 返回值为函数 func() int
func GetGa() func() int {
    rand1 := rand.Intn(10)  // 返回随机数 [0,10] 之间
    // 局部变量 Ga
    if Ga := 55; Ga + rand1 < 60 {
        fmt.Println("GetGa if中：", Ga)
    }

    // 局部变量 Ga
    for Ga := 2; ;  {
        fmt.Println("GetGa 循环中：", Ga)
        break
    }

    // 全局变量 Ga
    fmt.Println("GetGa函数中:", Ga)

    // 关于闭包的情况参看函数章节 
    return func() int {
        // 此处Ga的作用域认定上下文是99
        Ga += 1 // 全局变量Ga
        return Ga
    }
}

func printGVariable() {
    // 全局变量Ga
    fmt.Println(Ga)
}