一、什么是控制结构?
控制结构(Control Structures)是编程语言中用于控制程序执行路径和执行顺序的语法结构。
默认情况下,程序按照代码在源文件中的排列顺序逐条执行。但实际业务逻辑通常包含条件判断、重复操作以及流程跳转,仅依靠顺序执行无法表达复杂逻辑。
例如:
- 用户登录时,需要判断账号和密码是否正确。
- 处理订单时,需要根据订单状态执行不同操作。
- 遍历集合时,需要重复执行某段逻辑。
- 遇到异常情况时,需要提前结束当前操作。
这些行为都依赖控制结构。
从程序执行方式来看,控制结构通常分为三类:
- 顺序结构(Sequence):按照语句排列顺序依次执行。
- 选择结构(Selection):根据条件决定执行哪一条路径。
- 循环结构(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)
选择结构根据条件表达式的结果,决定程序执行哪一条分支路径。
常见形式包括:
ifif...elseif...else if...elseswitch- 模式匹配(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)
循环结构用于重复执行一段代码。
当某个操作需要执行多次时,不需要重复编写相同代码,而是通过循环结构控制重复执行的次数和结束条件。
常见循环结构包括:
whiledo...whileforforeach/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)。
- 流式数据处理。
- 大数据集逐步读取。
- 生成器与管道式处理。
- 减少中间集合的创建。
五、循环控制语句
循环结构通常还需要配合控制语句,改变循环的正常执行过程。
常见的循环控制语句包括:
breakcontinuereturngoto(部分语言支持)
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)