Rust 循环

循环是编程中常用的控制流结构，用于重复执行一段代码。本章节将详细介绍 Rust 中的循环结构。

loop 循环

loop 是 Rust 中最基本的循环结构，它会无限重复执行代码块，直到遇到 break 语句：

fn main() {
    let mut counter = 0;
    
    loop {
        counter += 1;
        println!("Counter: {}", counter);
        
        if counter >= 5 {
            break;
        }
    }
}

loop 循环返回值

loop 循环可以返回值，通过 break 语句指定返回值：

fn main() {
    let mut counter = 0;
    
    let result = loop {
        counter += 1;
        
        if counter >= 5 {
            break counter * 2;
        }
    };
    
    println!("Result: {}", result);
}

嵌套 loop 循环

可以在 loop 循环中嵌套其他循环：

fn main() {
    let mut outer_counter = 0;
    
    loop {
        outer_counter += 1;
        println!("Outer counter: {}", outer_counter);
        
        let mut inner_counter = 0;
        loop {
            inner_counter += 1;
            println!("Inner counter: {}", inner_counter);
            
            if inner_counter >= 3 {
                break;
            }
        }
        
        if outer_counter >= 2 {
            break;
        }
    }
}

while 循环

while 循环在条件为真时执行代码块：

fn main() {
    let mut counter = 0;
    
    while counter < 5 {
        println!("Counter: {}", counter);
        counter += 1;
    }
}

while 循环的条件

while 循环的条件可以是任何返回布尔值的表达式：

fn main() {
    let mut number = 1;
    
    while number <= 10 {
        println!("Number: {}", number);
        number *= 2;
    }
}

for 循环

for 循环用于遍历集合或范围：

遍历数组

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    
    for number in numbers {
        println!("Number: {}", number);
    }
}

遍历范围

fn main() {
    // 左闭右开区间 [0, 5)
    for i in 0..5 {
        println!("i: {}", i);
    }
    
    // 左闭右闭区间 [0, 5]
    for i in 0..=5 {
        println!("i: {}", i);
    }
}

遍历迭代器

fn main() {
    // 反向遍历
    for i in (0..5).rev() {
        println!("i: {}", i);
    }
    
    // 步长遍历
    for i in (0..10).step_by(2) {
        println!("i: {}", i);
    }
}

遍历集合

fn main() {
    let fruits = vec!["apple", "banana", "cherry"];
    
    for fruit in fruits {
        println!("Fruit: {}", fruit);
    }
    
    // 遍历 HashMap
    use std::collections::HashMap;
    
    let mut scores = HashMap::new();
    scores.insert("Alice", 100);
    scores.insert("Bob", 85);
    scores.insert("Charlie", 90);
    
    for (name, score) in &scores {
        println!("{}: {}", name, score);
    }
}

循环控制

break 语句

break 语句用于退出当前循环：

fn main() {
    for i in 0..10 {
        if i == 5 {
            break;
        }
        println!("i: {}", i);
    }
}

continue 语句

continue 语句用于跳过当前循环迭代，继续下一次迭代：

fn main() {
    for i in 0..10 {
        if i % 2 == 0 {
            continue;
        }
        println!("i: {}", i);
    }
}

循环标签

对于嵌套循环，可以使用标签来指定要 break 或 continue 的循环：

fn main() {
    'outer: loop {
        println!("Outer loop");
        
        'inner: loop {
            println!("Inner loop");
            break 'outer; // 直接退出外层循环
        }
    }
}

循环的性能考虑

• for 循环是 Rust 中最常用的循环结构，它的性能通常是最好的
• while 循环适用于条件复杂的情况
• loop 循环适用于需要无限循环的情况

总结

• loop：无限循环，直到遇到 break
• while：条件为真时循环
• for：遍历集合或范围
• break：退出循环
• continue：跳过当前迭代
• 循环标签：用于嵌套循环的控制

通过本章节的学习，你应该已经掌握了 Rust 中的循环结构，可以在你的程序中使用这些结构来重复执行代码。