循环

> 掌握 loop、while 和 for 三种循环结构，以及 break/continue 的用法。

while 循环

while 语法

概念名称： while 在条件为真时重复执行。

语法结构：
┌──────────────────────────────────────┐
│  while 条件 {                         │
│        ↑                              │
│        布尔表达式                      │
│                                       │
│      循环体                            │
│  }                                    │
│                                       │
│  while count < 5 { ... }              │
└──────────────────────────────────────┘

最简示例

fn main() {
    let mut count = 0;
    while count < 3 {
        println!("count = {}", count);
        count += 1;
    }
}

▶ Run

详细示例

fn main() {
    let mut count = 0;

    // 当条件为真时重复执行
    while count < 5 {
        println!("count = {}", count);
        count += 1;
    }

    println!("循环结束，count = {}", count);
}

▶ Run

输出：

count = 0
count = 1
count = 2
count = 3
count = 4
循环结束，count = 5

while let（模式匹配循环）

fn main() {
    // 场景 1：弹出栈直到空
    let mut stack = vec![1, 2, 3, 4, 5];

    while let Some(top) = stack.pop() {
        println!("弹出：{}", top);
    }
    // 输出：5, 4, 3, 2, 1

    // 场景 2：迭代器
    let mut iter = vec![1, 2, 3].into_iter();

    while let Some(value) = iter.next() {
        println!("值：{}", value);
    }
}

▶ Run

无限循环 + break

fn main() {
    let mut count = 0;

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

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

▶ Run

---

for 循环（最常用）

for 语法

概念名称： for 用于遍历集合或范围。

语法结构：
┌──────────────────────────────────────┐
│  for 元素 in 集合/范围 {              │
│      ↑        ↑                       │
│      模式绑定  迭代器                  │
│                                       │
│      循环体                            │
│  }                                    │
│                                       │
│  for i in 0..5 { ... }    → 0,1,2,3,4 │
│  for i in 0..=5 { ... }   → 0,1,2,3,4,5│
│  for item in &vec { ... } → 遍历引用  │
└──────────────────────────────────────┘

最简示例

fn main() {
    for i in 0..3 {
        println!("i = {}", i);
    }
}

▶ Run

遍历集合

fn main() {
    let numbers = [1, 2, 3, 4, 5];

    // 遍历数组（推荐方式）
    for number in numbers.iter() {
        println!("{}", number);
    }

    // 简写（自动解引用）
    for &number in &numbers {
        println!("{}", number);
    }

    // 可变遍历
    let mut mutable_numbers = [1, 2, 3];
    for num in &mut mutable_numbers {
        *num *= 2;
    }
    println!("{:?}", mutable_numbers);  // [2, 4, 6]
}

▶ Run

范围（Range）

fn main() {
    // 不包含结束值：1, 2, 3
    for i in 1..4 {
        print!("{} ", i);
    }
    println!();

    // 包含结束值：1, 2, 3, 4
    for i in 1..=4 {
        print!("{} ", i);
    }
    println!();

    // 倒序：3, 2, 1
    for i in (1..4).rev() {
        print!("{} ", i);
    }
    println!();

    // 步长（需要使用 step_by）
    for i in (1..=10).step_by(2) {
        print!("{} ", i);  // 1 3 5 7 9
    }
    println!();
}

▶ Run

enumerate - 带索引遍历

fn main() {
    let names = ["Alice", "Bob", "Charlie"];

    // 方法 1：手动跟踪索引（不推荐）
    let mut index = 0;
    for name in &names {
        println!("{}: {}", index, name);
        index += 1;
    }

    // 方法 2：使用 enumerate（推荐）
    for (index, name) in names.iter().enumerate() {
        println!("{}: {}", index, name);
    }
}

▶ Run

输出：

0: Alice
1: Bob
2: Charlie

zip - 同时遍历两个集合

fn main() {
    let names = ["Alice", "Bob", "Charlie"];
    let ages = [25, 30, 35];

    // 同时遍历两个数组
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("{} 是 {} 岁", name, age);
    }

    // 长度不同时，以短的为准
    let short = [1, 2];
    let long = [1, 2, 3, 4, 5];
    for (a, b) in short.iter().zip(long.iter()) {
        println!("{} - {}", a, b);  // 只输出 2 对
    }
}

▶ Run

---

loop 循环

loop 语法

概念名称： loop 无限循环，直到 break 退出。

语法结构：
┌──────────────────────────────────────┐
│  loop {                               │
│                                       │
│      循环体                            │
│                                       │
│      break;       → 无值退出          │
│      break 值;    → 返回值退出        │
│  }                                    │
│                                       │
│  let result = loop {                  │
│      break 42;   → result = 42       │
│  };                                   │
└──────────────────────────────────────┘

最简示例

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

▶ Run

详细示例

fn main() {
    let mut counter = 0;

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

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

▶ Run

loop 可以返回值

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

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

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

▶ Run

循环标签（嵌套循环控制）

fn main() {
    // 默认 break 只跳出最内层循环
    'outer: for i in 1..=3 {
        'inner: for j in 1..=3 {
            if i == 2 && j == 2 {
                break 'outer;  // 直接跳出外层循环
            }
            println!("i = {}, j = {}", i, j);
        }
    }
    println!("循环结束");
}

▶ Run

输出：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 2, j = 1
循环结束

---

continue

fn main() {
    // 跳过偶数，只打印奇数
    for i in 1..=10 {
        if i % 2 == 0 {
            continue;  // 跳过本次迭代
        }
        println!("{}", i);
    }
}

▶ Run

输出：

1
3
5
7
9

continue 在嵌套循环中

fn main() {
    for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                continue;  // 只跳过内层循环的当前迭代
            }
            println!("i = {}, j = {}", i, j);
        }
    }
}

▶ Run

输出：

i = 1, j = 1
i = 1, j = 3
i = 2, j = 1
i = 2, j = 3
i = 3, j = 1
i = 3, j = 3

小结

• loop 无限循环，用 break 退出，可以携带返回值
• while 条件循环，条件为 false 时退出
• for 遍历迭代器，是 Rust 中最常用的循环
• break 中断循环，continue 跳过本次迭代

练习题

详见：练习题