掌握 Rust 控制流：从 if 到 match，写出优雅的代码

不吃草的牛德

发布于 2026-04-23 11:38:07

910

文章被收录于专栏：RustRust

在编程中，控制流是决定程序执行路径的核心机制。Rust 作为一门注重性能和安全的语言，提供了强大而简洁的控制流工具，包括条件语句 if、循环（loop、while、for）和模式匹配 match。本文将带你深入了解 Rust 的控制流机制，通过实际案例帮助你写出更优雅、可靠的代码。

1. 条件语句：if 和 elseRust 的 if 语句用于根据条件执行不同的代码块，语法简洁且类型安全。与许多语言不同，Rust 的条件表达式必须返回布尔类型（bool），不支持隐式转换。示例：检查数字是否为正

fn main() {
    let number = 42;
    if number > 0 {
        println!("{} is positive", number);
    } else if number < 0 {
        println!("{} is negative", number);
    } else {
        println!("{} is zero", number);
    }
}

输出：

42 is positive

关键点：

条件必须是 bool 类型，例如 number > 0，不能直接写 if number（这会导致编译错误）。
大括号 {} 是必须的，即使代码块只有一行。

if 作为表达式Rust 的 if 是表达式，可以直接返回值，非常适合简洁赋值：

fn main() {
    let number = 10;
    let description = if number % 2 == 0 {
        "even"
    } else {
        "odd"
    };
    println!("{} is {}", number, description);
}

输出：

10 is even

注意：if 和 else 分支的返回值类型必须一致，否则编译器会报错。2. 循环：loop、while 和 forRust 提供了三种循环机制：loop（无限循环）、while（条件循环）和 for（迭代循环），每种都有独特用途。loop：无限循环loop 用于创建无限循环，直到显式使用 break 退出。可以返回值的循环非常适合需要重复尝试的场景。

fn main() {
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 5 {
            break count * 2; // 返回值 10
        }
    };
    println!("Result: {}", result);
}

输出：

Result: 10

技巧：使用 break 返回值让 loop 更灵活，适合实现重试逻辑。while：条件循环while 在条件为真时执行循环：

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    println!("Liftoff!");
}

输出：

3!
2!
1!
Liftoff!

适用场景：当循环次数不确定但有明确终止条件时，使用 while。for：迭代循环for 循环用于遍历迭代器，简洁且安全。Rust 的 for 常与范围（Range）或集合搭配使用。

fn main() {
    for i in 1..=5 {
        println!("Number: {}", i);
    }
}

输出：

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5

提示：1..=5 表示包含 5 的范围，1..5 则不包含 5。

迭代集合也很简单：

fn main() {
    let colors = ["red", "green", "blue"];
    for color in colors.iter() {
        println!("Color: {}", color);
    }
}

优势：for 循环利用迭代器，避免手动索引，减少越界错误。3. 模式匹配：match 和 if letRust 的 match 是一种强大的控制流工具，用于匹配值并执行对应分支。match 要求覆盖所有可能情况，确保代码健壮。示例：处理枚举假设我们有一个 Coin 枚举，表示不同面值的硬币：

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}
fn value_in_cents(coin: Coin) -> u8 {
    match coin {
        Coin::Penny => {
            println!("Lucky penny!");
            1
        }
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}
fn main() {
    let coin = Coin::Penny;
    println!("Value: {} cents", value_in_cents(coin));
}

输出：

Lucky penny!
Value: 1 cents

关键点：

match 必须穷尽所有情况，否则编译器会报错。
每个分支的返回值类型必须一致。

if let：简化匹配对于只需要匹配一种情况的场景，if let 更简洁：

fn main() {
    let some_value = Some(42);
    if let Some(value) = some_value {
        println!("Got a value: {}", value);
    } else {
        println!("No value");
    }
}

输出：

Got a value: 42

if let Some(value) = some_value

这行代码的意思是：

尝试把 some_value 解构成 Some(value)，如果成功，就进入这个分支，并且你可以使用解构出来的 value；如果 some_value 是 None，那就进入 else 分支。

如果 some_value 是 Some(x)，那么 value 就会被绑定到 x，然后执行

 { println!("Got a value: {}", value); }

如果 some_value 是 None，则执行 else 块中的

{ println!("No value"); }

适用场景：if let 适合处理 Option 或 Result 等简单匹配，减少代码嵌套。

4. 实际案例：猜数字游戏让我们通过一个简单的猜数字游戏，综合运用控制流：

use rand::Rng;
use std::io;
fn main() {
    println!("Guess the number!");
    let secret = rand::thread_rng().gen_range(1..=100);
    loop {
        println!("Please input your guess:");
        let mut guess = String::new();
        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("Please enter a number!");
                continue;
            }
        };
        match guess.cmp(&secret) {
            std::cmp::Ordering::Less => println!("Too small!"),
            std::cmp::Ordering::Greater => println!("Too big!"),
            std::cmp::Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

添加依赖：在 Cargo.toml 中添加：