控制流

控制流是程序的基础，它决定了代码的执行顺序。本章将介绍 Rust 中的条件判断、循环和初步的模式匹配。

if 表达式

基本用法

fn main() {
    let number = 7;

    if number < 5 {
        println!("条件为真");
    } else {
        println!("条件为假");
    }
}

注意：条件必须是 bool 类型，Rust 不会自动转换：

fn main() {
    let number = 3;

    // 错误！number 不是 bool 类型
    // if number {
    //     println!("数字是 3");
    // }

    // 正确
    if number != 0 {
        println!("数字不是零");
    }
}

多分支

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("能被 4 整除");
    } else if number % 3 == 0 {
        println!("能被 3 整除");
    } else if number % 2 == 0 {
        println!("能被 2 整除");
    } else {
        println!("不能被 4、3、2 整除");
    }
}

if 是表达式

在 Rust 中，if 是表达式，可以返回值：

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("number 的值是: {}", number);
}

注意：两个分支的返回类型必须相同：

fn main() {
    let condition = true;

    // 错误！类型不匹配
    // let number = if condition { 5 } else { "six" };
}

循环

Rust 有三种循环：loop、while 和 for。

loop 无限循环

fn main() {
    let mut counter = 0;

    loop {
        counter += 1;
        println!("count: {}", counter);

        if counter == 5 {
            break;  // 退出循环
        }
    }
}

loop 返回值

loop 可以通过 break 返回值：

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;  // 返回 20
        }
    };

    println!("结果是: {}", result);
}

循环标签

处理嵌套循环时，可以使用标签来指定 break 或 continue 作用于哪个循环：

fn main() {
    let mut count = 0;

    'outer: loop {
        println!("count = {}", count);
        let mut remaining = 10;

        loop {
            println!("remaining = {}", remaining);
            if remaining == 9 {
                break;  // 退出内层循环
            }
            if count == 2 {
                break 'outer;  // 退出外层循环
            }
            remaining -= 1;
        }

        count += 1;
    }

    println!("最终 count = {}", count);
}

while 条件循环

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }

    println!("发射！");
}

for 遍历循环

for 是最常用的循环，用于遍历集合：

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("值是: {}", element);
    }
}

使用 Range

fn main() {
    // 1 到 3（不包含 4）
    for number in 1..4 {
        println!("{}!", number);
    }

    // 1 到 4（包含 4）
    for number in 1..=4 {
        println!("{}!", number);
    }

    // 反向
    for number in (1..4).rev() {
        println!("{}!", number);
    }
}

获取索引

fn main() {
    let a = ['a', 'b', 'c'];

    for (index, value) in a.iter().enumerate() {
        println!("{}: {}", index, value);
    }
}

continue 跳过当前迭代

fn main() {
    for number in 1..=10 {
        if number % 2 == 0 {
            continue;  // 跳过偶数
        }
        println!("{}", number);
    }
}

match 模式匹配

match 是 Rust 强大的控制流运算符，类似其他语言的 switch，但功能更强大。

基本用法

fn main() {
    let number = 3;

    match number {
        1 => println!("一"),
        2 => println!("二"),
        3 => println!("三"),
        _ => println!("其他"),  // _ 是通配符
    }
}

match 是表达式

fn main() {
    let number = 2;

    let result = match number {
        1 => "一",
        2 => "二",
        3 => "三",
        _ => "其他",
    };

    println!("result = {}", result);
}

匹配多个值

fn main() {
    let number = 5;

    match number {
        1 | 2 => println!("一或二"),
        3..=5 => println!("三到五"),
        _ => println!("其他"),
    }
}

匹配必须穷尽

Rust 要求 match 必须覆盖所有可能的情况：

fn main() {
    let number: u8 = 5;

    // 错误！没有覆盖所有情况
    // match number {
    //     1 => println!("一"),
    //     2 => println!("二"),
    // }

    // 使用 _ 通配符覆盖其余情况
    match number {
        1 => println!("一"),
        2 => println!("二"),
        _ => println!("其他"),
    }
}

绑定值

fn main() {
    let number = 5;

    match number {
        n @ 1..=5 => println!("1-5 之间: {}", n),
        n @ 6..=10 => println!("6-10 之间: {}", n),
        n => println!("其他: {}", n),
    }
}

if let 简洁匹配

当只关心一种匹配情况时，if let 比 match 更简洁：

fn main() {
    let some_value = Some(3);

    // 使用 match
    match some_value {
        Some(3) => println!("是三！"),
        _ => (),
    }

    // 使用 if let，更简洁
    if let Some(3) = some_value {
        println!("是三！");
    }
}

配合 else：

fn main() {
    let some_value = Some(5);

    if let Some(3) = some_value {
        println!("是三！");
    } else {
        println!("不是三");
    }
}

while let 条件循环

fn main() {
    let mut stack = vec![1, 2, 3];

    while let Some(top) = stack.pop() {
        println!("{}", top);
    }
}

小练习

练习 1：判断正负零

编写一个函数，判断数字是正数、负数还是零：

fn check_number(n: i32) {
    // 使用 if/else if/else
}

fn main() {
    check_number(5);   // 输出: 正数
    check_number(-3);  // 输出: 负数
    check_number(0);   // 输出: 零
}

练习 2：猜数字框架

使用 loop 实现一个猜数字游戏的框架（暂时用固定值模拟输入）：

fn main() {
    let secret = 42;
    let mut guesses = [50, 30, 42];  // 模拟用户输入
    let mut index = 0;

    loop {
        // 获取猜测
        // 比较并给出提示
        // 猜对则退出
    }
}

练习 3：九九乘法表

使用嵌套 for 循环打印九九乘法表：

1x1=1
1x2=2  2x2=4
1x3=3  2x3=6  3x3=9
...

练习 4：星期转换

使用 match 将数字 1-7 转换为星期几：

fn day_of_week(day: u8) -> &'static str {
    // 使用 match
}

fn main() {
    println!("{}", day_of_week(1));  // 星期一
    println!("{}", day_of_week(7));  // 星期日
    println!("{}", day_of_week(8));  // 无效
}

官方文档

• The Rust Book - 控制流
• The Rust Book - match 控制流
• Rust By Example - 流程控制

下一步

掌握了控制流后，下一章我们将学习 Rust 最核心的概念——所有权系统。