控制流

fn main() {
    let score = 85;
 
    if score >= 90 {
        println!("优秀");
    } else if score >= 60 {
        println!("及格");
    } else {
        println!("不及格");
    }
}

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

fn main() {
    let condition = true;
    let x = if condition { 5 } else { 6 };
    println!("x = {}", x); // 5
}

注意：if 和 else 分支的类型必须一致。

fn main() {
    let mut count = 0;
    loop {
        count += 1;
        if count >= 5 {
            break count; // break 可返回值
        }
    };
    println!("count = {}", count);
}

loop 是唯一可以用 break 返回值的循环结构。

fn main() {
    let mut n = 3;
    while n > 0 {
        println!("倒计时: {}", n);
        n -= 1;
    }
    println!("发射！");
}

最常用的循环方式：

fn main() {
    // 1..5 是半开区间 [1, 5)
    for i in 1..5 {
        println!("{}", i); // 1, 2, 3, 4
    }
 
    // 1..=5 是闭区间 [1, 5]
    for i in 1..=5 {
        println!("{}", i); // 1, 2, 3, 4, 5
    }
}

fn main() {
    let arr = [10, 20, 30, 40, 50];
 
    // 遍历元素
    for element in arr.iter() {
        println!("{}", element);
    }
 
    // 遍历索引和元素
    for (index, value) in arr.iter().enumerate() {
        println!("arr[{}] = {}", index, value);
    }
}

跳出当前循环：

fn main() {
    let mut count = 0;
    loop {
        count += 1;
        if count == 3 {
            break;
        }
    }
    println!("count = {}", count); // 3
}

跳过当前迭代，继续下一次：

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

多层循环嵌套时，用标签指定 break 或 continue 的目标：

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if i == 2 && j == 2 {
                break 'outer; // 跳出外层循环
            }
            println!("i={}, j={}", i, j);
        }
    }
    // 输出: (1,1) (1,2) (1,3) (2,1)
}

match 是 Rust 最强大的控制流工具：

fn main() {
    let number = 3;
 
    match number {
        1 => println!("一"),
        2 | 3 => println!("二或三"),   // 多模式匹配
        4..=7 => println!("四到七"),   // 范围匹配
        _ => println!("其他"),         // 通配符
    }
}

fn main() {
    let grade = 'A';
    let score = match grade {
        'A' => 95,
        'B' => 85,
        'C' => 75,
        _ => 60,
    };
    println!("分数: {}", score);
}

当只关心一个模式时，if let 比 match 更简洁：

fn main() {
    let option = Some(5);
 
    // match 写法
    match option {
        Some(x) => println!("值是 {}", x),
        None => (),
    }
 
    // if let 简洁写法
    if let Some(x) = option {
        println!("值是 {}", x);
    }
}

也可以加 else：

fn main() {
    let option: Option<i32> = None;
 
    if let Some(x) = option {
        println!("值是 {}", x);
    } else {
        println!("没有值");
    }
}

fn main() {
    let mut stack = vec![1, 2, 3];
 
    while let Some(top) = stack.pop() {
        println!("{}", top); // 3, 2, 1
    }
}

use std::io;
 
fn main() {
    println!("===== 猜数字游戏 =====");
 
    let secret_number = 42; // 实际应用中应使用 rand 生成
 
    loop {
        println!("请输入你的猜测（1-100）：");
 
        let mut guess = String::new();
        io::stdin()
            .read_line(&mut guess)
            .expect("读取失败");
 
        let guess: i32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("请输入有效数字！");
                continue;
            }
        };
 
        match guess {
            g if g < secret_number => println!("太小了！"),
            g if g > secret_number => println!("太大了！"),
            _ => {
                println!("猜对了！");
                break;
            }
        }
    }
}

• if 是表达式，可以返回值
• loop 无限循环，break 可返回值
• while 条件循环
• for 是首选的遍历方式
• 循环标签控制多层循环
• match 强大模式匹配，必须穷举所有分支
• if let 简洁匹配单个模式