====== 控制流 ======

===== 条件判断：if / else if / else =====

<code rust>
fn main() {
    let score = 85;

    if score >= 90 {
        println!("优秀");
    } else if score >= 60 {
        println!("及格");
    } else {
        println!("不及格");
    }
}
</code>

==== if 是表达式 ====

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

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

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

===== 循环 =====

==== loop：无限循环 ====

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

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

==== while：条件循环 ====

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

==== for：区间遍历 ====

最常用的循环方式：

<code rust>
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
    }
}
</code>

==== for 遍历集合 ====

<code rust>
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);
    }
}
</code>

===== 循环控制关键字 =====

==== break ====

跳出当前循环：

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

==== continue ====

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

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

==== 循环标签 ====

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

<code rust>
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)
}
</code>

===== match：模式匹配 =====

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

<code rust>
fn main() {
    let number = 3;

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

==== match 表达式返回值 ====

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

===== if let 简洁匹配 =====

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

<code rust>
fn main() {
    let option = Some(5);

    // match 写法
    match option {
        Some(x) => println!("值是 {}", x),
        None => (),
    }

    // if let 简洁写法
    if let Some(x) = option {
        println!("值是 {}", x);
    }
}
</code>

也可以加 ''else''：

<code rust>
fn main() {
    let option: Option<i32> = None;

    if let Some(x) = option {
        println!("值是 {}", x);
    } else {
        println!("没有值");
    }
}
</code>

===== while let 循环匹配 =====

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

    while let Some(top) = stack.pop() {
        println!("{}", top); // 3, 2, 1
    }
}
</code>

===== 本章实践：猜数字游戏 =====

<code rust>
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;
            }
        }
    }
}
</code>

===== 本章小结 =====

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