编程笔记 Golang基础 020 流程控制

流程控制在编程中扮演着至关重要的角色，它允许程序员根据特定条件、循环和逻辑结构来组织和控制程序的执行流程。

主要包含以下几种结构：

一、条件语句（If-else）

// 基本的if语句
if condition {
    // 条件为真时执行这里的语句
}

// if-else 结构
if condition {
    // 当条件为真时执行这里的语句
} else {
    // 当条件为假时执行这里的语句
}

// if-else-if 结构（多重条件）
if condition1 {
    // 当condition1为真时执行这里的语句
} else if condition2 {
    // 当condition1为假且condition2为真时执行这里的语句
} else {
    // 所有条件都为假时执行这里的语句
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

示例：

age := 25
if age >= 18 {
    fmt.Println("成年人")
} else {
    fmt.Println("未成年人")
}
1
2
3
4
5
6

二、Switch语句

在Go中，switch可以不需要break语句，因为每个case之后都会自动终止。并且它可以不带表达式直接判断多个条件。

switch expression {
case value1:
    // 表达式等于value1时执行这里的语句
case value2:
    // 表达式等于value2时执行这里的语句
default: 
    // 如果没有匹配项，则执行default后面的语句
}
1
2
3
4
5
6
7
8

或者使用类型判断和多值匹配：

switch variable := someValue; variable.(type) {
case type1:
    // 变量是type1类型时执行这里的语句
case type2:
    // 变量是type2类型时执行这里的语句
default:
    // 不匹配任何已知类型时执行这里的语句
}
1
2
3
4
5
6
7
8

示例：

score := 90
switch score {
case 90, 100:
    fmt.Println("优秀")
case 70, 80, 89:
    fmt.Println("良好")
default:
    fmt.Println("合格或不及格")
}

// 类型判断示例
whatAmI := interface{}(3)
switch t := whatAmI.(type) {
case int:
    fmt.Printf("Type is %T, value is %v\n", t, t)
case string:
    fmt.Printf("Type is %T, value is %q\n", t, t)
default:
    fmt.Println("未知类型")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

三、循环语句：For循环

Go仅支持一种for循环结构，但非常灵活，可以用于迭代、计数循环和其他所有类型的循环操作。

// for 初始化; 条件; 更新 {}
for initExpression ; conditionExpression ; postIterationExpression {
    // 循环体内的代码
}

// 省略其中部分表达式的简化形式
for condition { // 只有条件判断
    // ...
}

// range关键字遍历数组、切片、字符串、map和通道
for key, value := range myMap {
    fmt.Println("Key:", key, "Value:", value)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

示例：

// 计数循环
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// 遍历数组
array := [5]int{1, 2, 3, 4, 5}
for _, v := range array {
    fmt.Println(v)
}

// 遍历字符串
s := "hello"
for index, char := range s {
    fmt.Printf("索引: %d 字符: %c\n", index, char)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

四、跳转语句

• break：用来退出当前循环。
• continue：跳过当前循环体剩余的语句，进入下一次循环迭代。
• goto：跳转到标签位置，不过在Go中不推荐过度使用goto。

示例：

// break 示例
for i := 0; i < 10; i++ {
    if i == 5 {
        break // 当i等于5时跳出循环
    }
    fmt.Println(i)
}

// continue 示例
for i := 0; i < 10; i++ {
    if i%2 == 0 { // 若i是偶数
        continue // 跳过此次循环，直接进入下一个循环
    }
    fmt.Println(i) // 输出奇数
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过这些流程控制结构，Go程序员能够有效地组织程序逻辑，根据条件和循环机制控制代码执行流程。

五、示例

package main

import "fmt"

func main() {
    // if-else 语句
    age := 18
    if age >= 18 {
        fmt.Println("成年人，可以开车")
    } else {
        fmt.Println("未成年人，不能开车")

        // goto 示例（不推荐过度使用）
        start:
            fmt.Println("请年满18岁后再来尝试。")
            goto start // 直接跳回标签位置继续执行
    }

    // switch 语句
    score := 85
    switch score {
    case 90, 100:
        fmt.Println("优秀")
    case 80, 89:
        fmt.Println("良好")
    default:
        fmt.Println("合格或不及格")
    }

    // for 循环，包括初始化、条件判断和后置表达式
    for i := 0; i < 5; i++ {
        fmt.Printf("第 %d 次循环\n", i)

        // break 示例，在i等于3时跳出循环
        if i == 3 {
            break
        }
    }

    // for-range 遍历数组
    numbers := [5]int{1, 2, 3, 4, 5}
    for index, value := range numbers {
        fmt.Printf("索引: %d, 值: %d\n", index, value)

        // continue 示例，跳过偶数的输出
        if value%2 == 0 {
            continue
        }
    }

    // 初始化 map，并用 for-range 进行遍历
    grades := map[string]int{"Alice": 90, "Bob": 85, "Charlie": 95}
    for name, grade := range grades {
        fmt.Printf("%s 的成绩是：%d\n", name, grade)

        // 删除 Bob 的成绩信息
        if name == "Bob" {
            delete(grades, name)
        }
    }

    // 在循环外部添加一个标签，用于配合 goto 和 break 使用
outerLoop:
    for j := 0; j < 5; j++ {
        fmt.Println("外层循环第", j, "次")

        // 内层循环
        for k := 0; k < 3; k++ {
            fmt.Println("\t内层循环第", k, "次")

            // 当内层循环计数为2时，中断内层循环并继续执行外层循环下一次
            if k == 2 {
                fmt.Println("\t\t提前结束内层循环")
                break outerLoop
            }
        }
    }
}
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

这个示例涵盖了Go语言中的所有流程控制关键字，包括if-else、goto、switch、for（含for-range）、break和continue。注意，虽然goto在示例中被展示，但在实际编程实践中并不推荐频繁使用它以保持代码的清晰性和可维护性。

小结

流程控制在编程中扮演着至关重要的角色，它允许程序员根据特定条件、循环和逻辑结构来组织和控制程序的执行流程。以下是流程控制的重要性：

1. 逻辑表达能力：
   流程控制使得代码能够反映复杂的逻辑关系，如基于条件决定执行路径（if-else、switch）、重复执行某个操作直到满足特定条件（for、while等循环）以及跳转到指定位置继续执行（goto，虽然在某些语言中不推荐使用）。

2. 决策制定：
   程序运行过程中会遇到许多需要判断的情况，通过if-else语句、switch语句等可以实现灵活的决策制定，从而执行不同的操作或分支。

3. 数据处理：
   循环结构是处理大量数据时必不可少的工具，例如遍历数组、列表、集合、映射或文件中的数据。通过循环，可以对每一项数据进行相同或不同操作，实现过滤、计算、排序等功能。

4. 资源管理：
   在处理文件、网络连接、数据库连接等资源时，流程控制能确保资源被正确打开、使用和关闭。例如，在循环外部初始化资源，在循环内部使用，并在循环结束后释放资源。

5. 算法实现：
   大多数复杂算法都离不开流程控制的支持，如分治法、贪心法、动态规划等都需要利用循环、条件判断等来实现递归、迭代等基本操作。

6. 模块化与重用性：
   通过合理使用流程控制，可以使代码更加模块化，便于维护和重用。函数和方法内部的流程控制可以帮助封装复杂的功能，简化调用者接口。

总之，良好的流程控制是编写高质量、可读性强、易于维护的软件的基础，它为程序提供了丰富多样的执行路径选择，让程序可以根据输入、状态变化以及其他因素做出灵活响应。