返回专栏
· 19 分钟阅读

控制结构(Control Structures)


一、什么是控制结构?

控制结构(Control Structures)是编程语言中用于控制程序执行路径和执行顺序的语法结构。

默认情况下,程序按照代码在源文件中的排列顺序逐条执行。但实际业务逻辑通常包含条件判断、重复操作以及流程跳转,仅依靠顺序执行无法表达复杂逻辑。

例如:

  • 用户登录时,需要判断账号和密码是否正确。
  • 处理订单时,需要根据订单状态执行不同操作。
  • 遍历集合时,需要重复执行某段逻辑。
  • 遇到异常情况时,需要提前结束当前操作。

这些行为都依赖控制结构。

从程序执行方式来看,控制结构通常分为三类:

  1. 顺序结构(Sequence):按照语句排列顺序依次执行。
  2. 选择结构(Selection):根据条件决定执行哪一条路径。
  3. 循环结构(Iteration):在满足条件时重复执行一段代码。

此外,函数调用、异常处理、跳转语句等机制也会影响程序的控制流。

二、顺序结构(Sequence)

顺序结构是最基本的控制结构,程序按照语句在代码中的先后顺序执行。

flowchart TB
    A["开始"] --> B["执行语句 A"]
    B --> C["执行语句 B"]
    C --> D["执行语句 C"]
    D --> E["结束"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

例如:

a = 10
b = 20
result = a + b
print(result)

程序依次完成变量赋值、计算和输出。

2.1 顺序结构的特点

  • 执行顺序由语句排列位置决定。
  • 默认情况下,每条语句执行完成后才继续执行下一条语句。
  • 不需要额外的条件判断。
  • 是分支结构和循环结构的基础。

需要注意,顺序结构描述的是程序的逻辑执行顺序,并不意味着所有程序语句在物理层面都必须严格串行执行。

编译器和处理器可能通过指令重排、流水线、乱序执行等方式优化实际执行过程,但在语言规定的可观察行为范围内,仍然需要保证程序语义正确。

三、选择结构(Selection)

选择结构根据条件表达式的结果,决定程序执行哪一条分支路径。

常见形式包括:

  • if
  • if...else
  • if...else if...else
  • switch
  • 模式匹配(Pattern Matching)
  • 条件表达式(Conditional Expression)

3.1 if 语句

if 是最基本的条件选择结构。

age = 20

if age >= 18:
    print("成年人")

执行过程:

flowchart TD
    A["开始"] --> B["判断 age >= 18"]
    B --> C{"条件是否成立"}
    C -->|"是"| D["输出成年人"]
    C -->|"否"| E["跳过条件语句"]
    D --> F["继续执行"]
    E --> F

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

当条件表达式为真时,执行对应代码块;为假时,跳过代码块。

不同语言对条件表达式的要求存在差异:

语言 条件表达式要求
C 可以使用标量表达式,零为假,非零为真
C++ 条件表达式需要能够转换为 bool
Java 必须是 boolean 类型
JavaScript 可以使用任意值,按 Truthy / Falsy 规则判断
Python 可以使用任意对象,按照 Truth Value Testing 判断
Go 必须是 bool 类型

例如,JavaScript 中:

if ("hello") {
    console.log("条件成立");
}

字符串 "hello" 会被转换为真值。

但在 Java 中,不能直接将字符串作为 if 的条件:

String value = "hello";

// 编译错误:条件必须是 boolean
if (value) {
    System.out.println("条件成立");
}

这是跨语言开发中容易忽略的差异。

3.2 if...else 语句

当条件成立和不成立时需要执行不同逻辑,可以使用 if...else。

score = 75

if score >= 60:
    print("及格")
else:
    print("不及格")

执行过程:

flowchart TD
    A["开始"] --> B["判断 score >= 60"]
    B --> C{"是否及格"}
    C -->|"是"| D["输出及格"]
    C -->|"否"| E["输出不及格"]
    D --> F["继续执行"]
    E --> F

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

if...else 的两个分支具有互斥关系:一次条件判断只会选择其中一个分支执行。

3.3 if...else if...else 语句

当需要判断多个条件时,可以使用多分支结构。

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

执行过程:

flowchart TD
    A["开始"] --> B{"score >= 90"}
    B -->|"是"| C["优秀"]
    B -->|"否"| D{"score >= 80"}
    D -->|"是"| E["良好"]
    D -->|"否"| F{"score >= 60"}
    F -->|"是"| G["及格"]
    F -->|"否"| H["不及格"]
    C --> I["继续执行"]
    E --> I
    G --> I
    H --> I

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

多分支结构具有一个重要特征:按照代码顺序依次判断,匹配第一个成立的条件后,就执行对应分支,并跳过后续分支。

因此,条件排列顺序会影响程序结果。

例如:

score = 95

if score >= 60:
    print("及格")
elif score >= 90:
    print("优秀")

输出结果是:

及格

因为 score >= 60 已经成立,后面的条件不会继续判断。

正确做法是将更具体、更严格的条件放在前面:

if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

3.4 switch 语句

switch 是一种多分支选择结构,通常根据一个表达式的值匹配不同分支。

例如 Java:

int status = 2;

switch (status) {
    case 1:
        System.out.println("待处理");
        break;
    case 2:
        System.out.println("处理中");
        break;
    case 3:
        System.out.println("已完成");
        break;
    default:
        System.out.println("未知状态");
}

传统 switch 的执行特点:

  • 根据表达式的值寻找匹配的 case。
  • 匹配后执行对应分支。
  • 在支持贯穿行为的语法中,如果没有遇到 break 等终止语句,可能继续执行后续分支。
  • default 用于处理没有匹配项的情况。

这里需要重点理解 break。

在传统 C、C++、Java 的 switch 中,break 通常用于退出整个 switch 结构,而不是仅仅结束当前 case。

如果遗漏 break,就可能出现分支贯穿(Fall-through)。

int value = 1;

switch (value) {
    case 1:
        System.out.println("A");
    case 2:
        System.out.println("B");
    default:
        System.out.println("C");
}

输出:

A
B
C

这是因为匹配 case 1 后,程序继续向下执行,没有自动跳出 switch。

现代语言对 switch 做了不同改进:

语言 主要特点
C 主要支持整数类型及枚举等符合要求的控制表达式
C++ 支持整数类型、枚举类型等符合要求的控制表达式
Java 支持整数、枚举、字符串等类型,现代版本还提供增强型 switch
JavaScript 使用严格相等比较匹配 case
Go 不需要显式 break,默认不会贯穿后续分支
Rust match 是更核心的模式匹配结构,分支必须覆盖所有可能情况

例如 Go:

status := 2

switch status {
case 1:
    fmt.Println("待处理")
case 2:
    fmt.Println("处理中")
case 3:
    fmt.Println("已完成")
default:
    fmt.Println("未知状态")
}

Go 的 switch 默认在匹配分支执行结束后退出,不需要像传统 Java switch 一样显式添加 break。

3.5 模式匹配(Pattern Matching)

模式匹配是一种比传统 switch 更灵活的选择机制。

它不仅可以判断值是否相等,还可以根据数据结构、类型、字段和值的组合进行匹配。

例如 Rust:

enum Status {
    Pending,
    Processing,
    Completed,
}

let status = Status::Processing;

match status {
    Status::Pending => println!("待处理"),
    Status::Processing => println!("处理中"),
    Status::Completed => println!("已完成"),
}

模式匹配的核心能力包括:

  • 值匹配:匹配具体常量或值。
  • 类型匹配:根据数据类型选择分支。
  • 结构匹配:匹配元组、结构体、枚举等数据结构。
  • 解构:从匹配的数据结构中提取内部字段。
  • 守卫条件:在模式匹配基础上增加额外判断。

模式匹配与传统条件判断的主要区别在于:它可以同时完成条件选择和数据结构解构,减少复杂的嵌套判断。

四、循环结构(Iteration)

循环结构用于重复执行一段代码。

当某个操作需要执行多次时,不需要重复编写相同代码,而是通过循环结构控制重复执行的次数和结束条件。

常见循环结构包括:

  • while
  • do...while
  • for
  • foreach / for...in
  • 迭代器(Iterator)

4.1 while 循环

while 循环在每次执行循环体之前判断条件。

只要条件成立,就继续执行循环体;条件不成立时,退出循环。

count = 1

while count <= 5:
    print(count)
    count += 1

执行过程:

flowchart TD
    A["初始化 count = 1"] --> B{"count <= 5"}
    B -->|"是"| C["执行循环体"]
    C --> D["count += 1"]
    D --> B
    B -->|"否"| E["退出循环"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

while 的关键特点:

  • 先判断条件,再执行循环体。
  • 条件一开始就不成立时,循环体一次也不会执行。
  • 适合循环次数不确定、主要依赖条件控制的场景。

4.2 do...while 循环

do...while 与 while 的主要区别是:先执行循环体,再判断条件。

int count = 1;

do {
    System.out.println(count);
    count++;
} while (count <= 5);

执行过程:

flowchart TD
    A["开始"] --> B["执行循环体"]
    B --> C["更新循环变量"]
    C --> D{"判断循环条件"}
    D -->|"是"| B
    D -->|"否"| E["退出循环"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

因此,do...while 至少执行一次循环体。

适用场景:

  • 用户输入校验。
  • 菜单交互。
  • 需要先执行一次操作,再决定是否继续的逻辑。

需要注意,Python、Go 等语言没有原生的 do...while 语法,但可以通过其他循环结构实现相同逻辑。

4.3 for 循环

for 循环通常用于执行次数明确,或者具有明确迭代规则的场景。

以 C 语言为例:

for (int i = 0; i < 5; i++) {
    printf("%d\n", i);
}

传统 for 结构包含三个部分:

for (初始化表达式; 条件表达式; 更新表达式) {
    // 循环体
}

三个部分的作用:

部分 作用 执行时机
初始化表达式 初始化循环变量 整个循环开始时执行一次
条件表达式 判断是否继续循环 每次执行循环体之前
更新表达式 更新循环变量 每次循环体执行完成后

执行顺序:

flowchart TD
    A["初始化表达式"] --> B{"判断条件表达式"}
    B -->|"成立"| C["执行循环体"]
    C --> D["执行更新表达式"]
    D --> B
    B -->|"不成立"| E["退出循环"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,for 的三个表达式并不一定都必须存在。

例如:

for (;;) {
    // 无限循环
}

由于没有终止条件,该循环会持续执行,除非通过 break、return 或其他控制机制离开。

4.4 foreach 与 for...in

遍历集合是编程中非常常见的操作。

许多语言提供了专门的集合遍历语法,例如:

Python:

names = ["Alice", "Bob", "Charlie"]

for name in names:
    print(name)

Java:

String[] names = {"Alice", "Bob", "Charlie"};

for (String name : names) {
    System.out.println(name);
}

JavaScript:

const names = ["Alice", "Bob", "Charlie"];

for (const name of names) {
    console.log(name);
}

这些语法可以避免手动管理索引,使代码更加简洁。

但需要注意,不同语言的遍历语义并不完全相同。

语言 遍历语法 主要行为
Python for...in 遍历可迭代对象中的元素
Java 增强型 for 遍历数组或实现 Iterable 的对象
JavaScript for...of 遍历可迭代对象的值
JavaScript for...in 遍历对象可枚举的属性键
Go for...range 遍历数组、切片、字符串、映射、通道等
Rust for...in 通过迭代器遍历元素

特别需要注意 JavaScript:

const names = ["Alice", "Bob", "Charlie"];

for (const index in names) {
    console.log(index);
}

for (const name of names) {
    console.log(name);
}

for...in 输出的是属性键,数组中通常表现为索引字符串;for...of 输出的是元素值。

两者不能随意替换。

4.5 迭代器(Iterator)

迭代器是一种用于逐个访问集合元素的抽象机制。

它将集合的数据存储方式与元素遍历方式分离,使不同数据结构可以提供统一的遍历接口。

迭代器通常包含以下核心操作:

  • 获取下一个元素。
  • 判断是否还有元素。
  • 返回当前元素。
  • 维护遍历过程中的状态。

在不同语言中,迭代器接口有所差异:

语言 相关机制
Java Iterator、Iterable
Python Iterator、Iterable、__next__()
JavaScript Iterator、Symbol.iterator
C++ Iterator、Range-based for
Rust Iterator Trait
Go 常通过 range 或自定义遍历接口实现

以 Python 为例:

numbers = [10, 20, 30]

iterator = iter(numbers)

print(next(iterator))
print(next(iterator))
print(next(iterator))

输出:

10
20
30

iter() 获取迭代器,next() 请求下一个元素。

当迭代器没有更多元素时,Python 会抛出 StopIteration,而 for...in 会自动处理这一结束信号。

迭代器的价值不仅在于遍历集合,还可以支持:

  • 惰性计算(Lazy Evaluation)。
  • 流式数据处理。
  • 大数据集逐步读取。
  • 生成器与管道式处理。
  • 减少中间集合的创建。

五、循环控制语句

循环结构通常还需要配合控制语句,改变循环的正常执行过程。

常见的循环控制语句包括:

  • break
  • continue
  • return
  • goto(部分语言支持)

5.1 break:终止循环

break 用于立即结束当前循环结构,跳转到循环之后的代码继续执行。

for i in range(10):
    if i == 5:
        break

    print(i)

输出:

0
1
2
3
4

当 i == 5 时,执行 break,整个循环结束。

需要注意,break 通常只终止当前最内层循环,而不是自动终止所有嵌套循环。

for i in range(3):
    for j in range(3):
        if j == 1:
            break

        print(i, j)

内层循环结束后,外层循环仍然会继续执行。

5.2 continue:跳过当前迭代

continue 用于结束当前这一次循环迭代,并进入下一次循环判断或迭代。

for i in range(5):
    if i == 2:
        continue

    print(i)

输出:

0
1
3
4

当 i == 2 时,跳过本次循环剩余代码,但循环本身并没有结束。

break 和 continue 的区别:

语句 作用 后续行为
break 终止当前循环 跳出循环
continue 跳过当前迭代 进入下一次迭代

5.3 return:结束函数执行

return 用于从当前函数返回调用者。

它不仅可以终止循环,还可以结束函数内部的所有后续执行。

def find_number(numbers, target):
    for number in numbers:
        if number == target:
            return True

    return False

result = find_number([1, 3, 5, 7], 5)
print(result)