Rust流程控制（下）：深入解析Rust的循环机制

引言

在任何编程语言中，循环都是实现重复性任务的核心结构。它们允许我们高效地执行代码块，无论是遍历数据集合、处理用户输入，还是在满足特定条件前持续运行某个进程。在Rust中，循环不仅是控制程序流程的工具，更是其所有权和借用系统哲学的一部分，旨在确保内存安全和高性能。

与许多语言不同，Rust提供了多种循环结构，每种都有其特定的适用场景和优势。loop、while和for这三种循环类型，虽然目标相似，但在实现细节、性能表现以及与Rust编译器（特别是借用检查器）的交互上有着显著的区别。理解这些差异，并学会在合适的场景选择最恰当的循环，是编写高效、安全且符合Rust语言习惯（idiomatic）代码的关键一步。

本篇文章将深入探讨Rust的三种循环机制。我们将从最基础的无限循环loop开始，了解它如何与break和continue关键字协同工作，甚至从循环中返回值。接着，我们将分析条件循环while，它在循环执行前检查条件，适用于那些循环次数不确定的场景。最后，我们将重点介绍Rust中最常用也最强大的for循环，它通过迭代器（Iterator）模式，提供了一种安全、高效且极具表达力的方式来遍历集合。

通过本文的学习，你不仅将掌握Rust循环的语法，还将深入理解其背后的设计哲学，学会如何利用这些工具编写出既健壮又高效的Rust代码。

1. 无限循环：loop

loop关键字在Rust中用于创建一个无限循环。一旦进入loop块，代码将无休止地执行，直到遇到明确的停止指令。这种看似简单的结构，在特定场景下却异常强大，例如实现事件监听、状态机或者需要手动控制中断条件的后台任务。

1.1 loop的基本语法与使用

loop的语法非常直观：

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    loop {
        println!("Again!");
    }
}

如果运行这段代码，你会在终端看到"Again!"被无休止地打印出来，直到你手动终止程序（例如使用Ctrl+C）。

1.2 使用break和continue控制循环

无限循环的威力在于我们可以精确地控制其行为。Rust提供了两个关键字来管理loop循环的流程：

  • break: 立即终止循环，并跳出循环体。
  • continue: 跳过当前迭代的剩余部分，直接进入下一次迭代。

让我们看一个结合break的例子，实现一个简单的计数器：

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let mut count = 0;
    println!("Starting the loop...");

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

        if count >= 5 {
            println!("Count reached 5. Exiting loop.");
            break; // 当count大于等于5时，跳出循环
        }
    }

    println!("Loop finished. Final count is: {}", count);
}

代码分析:

  1. 我们初始化一个可变变量count为0。
  2. 进入loop循环，每次迭代count加1。
  3. 在if语句中，我们检查count的值。一旦它达到5，就打印一条消息并执行break。
  4. break会立即终止loop，程序将继续执行循环体之后的代码。

输出结果:

Starting the loop...
Current count is: 1
Current count is: 2
Current count is: 3
Current count is: 4
Current count is: 5
Count reached 5. Exiting loop.
Loop finished. Final count is: 5

现在，让我们看看continue的用法。假设我们只想打印奇数：

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let mut number = 0;

    loop {
        number += 1;

        if number > 10 {
            break; // 循环终止条件
        }

        if number % 2 == 0 {
            continue; // 如果是偶数，跳过本次迭代的println!
        }

        println!("The odd number is: {}", number);
    }
}

代码分析:

  1. 当number是偶数时（number % 2 == 0为true），continue被执行。
  2. 程序会立即跳到loop的开头，开始下一次迭代，而不会执行println!。
  3. 因此，只有当number是奇数时，println!才会被执行。

输出结果:

The odd number is: 1
The odd number is: 3
The odd number is: 5
The odd number is: 7
The odd number is: 9

1.3 从循环中返回值

Rust的loop有一个非常独特且强大的特性：它可以返回值。这使得loop可以像一个表达式一样被使用，其结果可以被赋值给一个变量。这在需要反复尝试某个操作直到成功并返回结果的场景中非常有用。

为了从loop中返回值，你需要将值放在break关键字之后。

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // 循环终止，并返回 counter * 2 的值
        }
    };

    println!("The result from the loop is: {}", result);
}

代码分析:

  1. 我们将整个loop表达式的求值结果赋值给变量result。
  2. 在循环内部，当counter达到10时，break语句不仅会终止循环，还会将counter * 2（即20）作为整个loop表达式的值返回。
  3. 这个返回值被赋给result。

输出结果:

The result from the loop is: 20

这个特性让loop在函数式编程风格中也占有一席之地，使得代码表达更加简洁和清晰。

1.4 循环标签（Loop Labels）

当存在嵌套循环时，break和continue默认只作用于最内层的循环。如果你想从内层循环中控制外层循环，就需要使用循环标签。

循环标签以单引号开头（例如'outer），紧跟在循环关键字之前。

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let mut count = 0;
    'outer: loop { // 1. 定义一个名为 'outer 的标签
        println!("Entered the outer loop. Count: {}", count);

        'inner: loop {
            println!("Entered the inner loop.");
            if count >= 2 {
                // 这只会跳出内层循环
                break;
            } else {
                // 这会跳出外层循环
                break 'outer; 
            }
        }
        
        count += 1;
        println!("This line in outer loop will not be reached in the first iteration.");
    }
    println!("Exited the outer loop.");
}

代码分析:

  1. 我们为外层循环定义了标签'outer。
  2. 在第一次进入内层循环时，count为0，else分支被执行。
  3. break 'outer;明确指定了要中断的是带有'outer标签的循环。因此，程序直接跳出了外层循环。
  4. 外层循环体中count += 1;以及之后的println!都不会被执行。

输出结果:

Entered the outer loop. Count: 0
Entered the inner loop.
Exited the outer loop.

循环标签为处理复杂嵌套逻辑提供了精确的控制能力，是Rust循环机制中一个不可或缺的高级特性。

2. 条件循环：while

while循环是在满足特定条件时重复执行代码块的经典结构。它的核心思想是“当条件为真时，继续循环”。这使得while非常适合处理那些循环次数在开始时无法确定，但有一个明确终止条件的场景。

2.1 while循环的语法与执行流程

while循环的语法结构如下：

while condition {
    // 当 condition 为 true 时执行的代码
}

其执行流程非常清晰：

  1. 条件检查：在每次迭代开始之前，对condition进行求值。
  2. 执行循环体：如果condition为true，则执行循环体内的代码。
  3. 重复：执行完循环体后，返回步骤1，再次检查条件。
  4. 终止：如果condition为false，循环终止，程序继续执行while循环之后的代码。

让我们看一个经典的倒计时例子：

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }

    println!("LIFTOFF!!!");
}

代码分析:

  1. 初始化number为3。
  2. 第一次迭代: number != 0 (3 != 0) 为true，打印"3!"，number变为2。
  3. 第二次迭代: number != 0 (2 != 0) 为true，打印"2!"，number变为1。
  4. 第三次迭代: number != 0 (1 != 0) 为true，打印"1!"，number变为0。
  5. 第四次检查: number != 0 (0 != 0) 为false，循环终止。
  6. 程序执行println!("LIFTOFF!!!");。

输出结果:

3!
2!
1!
LIFTOFF!!!

2.2 while与loop的比较

while循环本质上可以看作是loop、if和break的语法糖。上面的while循环例子，可以用loop等价地实现：

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let mut number = 3;

    loop {
        if number == 0 {
            break;
        }
        println!("{}!", number);
        number -= 1;
    }

    println!("LIFTOFF!!!");
}

虽然两者在功能上可以等价转换，但在代码可读性和意图表达上有所不同：

  • while: 当循环有一个明确的、需要在每次迭代前检查的条件时，使用while能更清晰地表达意图。代码的读者一眼就能看到循环的持续条件。
  • loop: 当循环的终止条件比较复杂，可能在循环体的多个地方、基于多个不同条件中断时，使用loop配合break会更加灵活。

2.3 while循环的适用场景

while循环在以下场景中特别有用：

  • 等待用户输入: 循环直到用户输入特定指令（如"quit"）。
  • 处理数据流: 从文件或网络读取数据，直到流结束。
  • 游戏循环: 在游戏主循环中，只要游戏没有结束（例如玩家没有退出或输掉），就持续更新游戏状态、渲染画面。
  • 算法实现: 许多算法，如二分查找，其终止条件（找到目标或搜索范围为空）非常适合用while来表达。

例如，一个简单的猜数字游戏：

// 伪代码，仅为演示场景
fn guess_the_number() {
    let secret_number = generate_random_number();
    let mut guess = String::new();
    let mut guessed_correctly = false;

    while !guessed_correctly {
        println!("Please input your guess.");
        read_user_input(&mut guess);
        let guess_num: u32 = guess.trim().parse().expect("Please type a number!");

        if guess_num < secret_number {
            println!("Too small!");
        } else if guess_num > secret_number {
            println!("Too big!");
        } else {
            println!("You win!");
            guessed_correctly = true; // 设置条件为false，终止循环
        }
    }
}

在这个例子中，循环的持续依赖于guessed_correctly这个布尔标志，while完美地契合了这种逻辑。

3. 迭代循环：for

for循环是Rust中最常用、最强大也最符合语言习惯的循环结构。它被设计用来遍历一个迭代器（Iterator）。几乎所有可以被看作一个序列或集合的类型，在Rust中都可以提供一个迭代器，这使得for循环的应用范围极其广泛。

3.1 for循环与迭代器模式

for循环的语法如下：

for item in collection {
    // 对每个 item 执行的代码
}

这里的collection是任何实现了IntoIterator trait的类型。当你写下这行代码时，Rust会自动调用collection的.into_iter()方法，将其转换成一个迭代器。然后，for循环会在每次迭代时，从这个迭代器中取出下一个元素，将其赋值给item，并执行循环体，直到迭代器耗尽。

这种设计有几个巨大的优势：

  1. 安全性: for循环与Rust的所有权系统紧密集成。在遍历集合时，所有权和借用的规则依然适用，从根本上杜绝了许多常见的并发和内存错误，如迭代器失效（iterator invalidation）。
  2. 简洁性: 代码更加简洁明了，直接表达了“对集合中的每一个元素做某事”的意图，而无需手动管理索引和边界检查。
  3. 高效性: Rust的迭代器是“零成本抽象”的典范。在编译时，基于迭代器的for循环通常会被优化成与手动编写的C风格循环同样高效的机器码。

3.2 遍历集合

让我们看看for循环在遍历不同类型集合时的应用。

3.2.1 遍历数组（Array）或切片（Slice）
// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a { // a.into_iter() 被隐式调用
        println!("the value is: {}", element);
    }
}

代码分析:

  • for循环会依次取出数组a中的每个元素，并将其值（因为i32是Copy类型）绑定到element变量上。
  • 循环自动处理了数组的边界，我们无需担心索引越界的问题。

输出结果:

the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50
3.2.2 遍历向量（Vector）

for循环遍历Vector时，根据你如何调用迭代器，可以获得元素的所有权、不可变借用或可变借用。

  • vector.into_iter(): 移动vector的所有权，并在迭代中获得每个元素的所有权。vector在循环后将不可用。
  • vector.iter(): 迭代vector的不可变借用，获得每个元素的不可变引用&T。
  • vector.iter_mut(): 迭代vector的可变借用，获得每个元素的可变引用&mut T，允许在循环中修改元素。
// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    // 1. iter() - 不可变借用
    let names = vec!["Bob", "Frank", "Ferris"];
    println!("---"Using iter()"---");
    for name in names.iter() {
        match name {
            &"Ferris" => println!("There is a rustacean among us!"),
            _ => println!("Hello {}", name),
        }
    }
    println!("names vector is still available: {:?}", names);


    // 2. iter_mut() - 可变借用
    let mut numbers = vec![1, 2, 3];
    println!("\n---"Using iter_mut()"---");
    for num in numbers.iter_mut() {
        *num *= 2; // 使用解引用操作符 * 来修改值
    }
    println!("numbers vector after modification: {:?}", numbers);


    // 3. into_iter() - 获取所有权
    let values = vec![10, 20, 30];
    println!("\n---"Using into_iter()"---");
    for value in values.into_iter() {
        println!("Got value: {}", value);
    }
    // 下一行代码将无法编译，因为 values 的所有权已经被移动
    // println!("values vector is no longer available: {:?}", values);
}

3.3 使用范围（Ranges）

for循环与范围（Range）类型结合使用，是执行固定次数循环的最地道方式。范围是标准库提供的一个实现了Iterator trait的结构体。

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    // 范围 1..4 包含 1, 2, 3 (不包含 4)
    println!("---"Using 1..4"---");
    for number in 1..4 {
        println!("{}!", number);
    }

    // 使用 .rev() 来反转迭代器
    println!("\n---"Using (1..4).rev()"---");
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

代码分析:

  • 1..4创建了一个从1开始到4结束（不含4）的范围。
  • .rev()是迭代器的一个适配器（adaptor），它会消耗掉原来的迭代器，并返回一个新的反向迭代的迭代器。
  • 这种方式比使用while循环和手动减计数器更安全、更简洁。编译器可以更好地优化它，并且不会因为错误的边界条件而产生bug。

3.4 for vs while：安全性和性能

让我们回顾一下之前的while倒计时例子：

let mut number = 3;
while number != 0 {
    // ...
    number -= 1;
}

如果我们要用for循环遍历一个数组，使用while循环的“传统”方式可能是这样的：

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    // -- 不推荐的写法 --
    while index < 5 {
        println!("the value is: {}", a[index]);
        index += 1;
    }
}

这种写法存在几个问题：

  1. 容易出错: 如果数组长度改变，你需要手动更新循环条件（index < 5）。如果index的初始值或增量逻辑写错，很容易导致索引越界，从而引发panic。
  2. 性能开销: 每次通过a[index]访问元素时，编译器为了保证内存安全，默认会插入一个边界检查（bound check），以确保index在0到a.len() - 1之间。这会带来微小的运行时开销。

相比之下，for循环版本：

// File: src/main.rs
// Rust Version: 1.73.0

fn main() {
    let a = [10, 20, 30, 40, 50];

    // -- 推荐的写法 --
    for element in a {
        println!("the value is: {}", element);
    }
}

这个版本不仅更简洁、更安全，而且通常更快。因为for循环是基于迭代器工作的，编译器在编译时就能确定循环的次数和范围，从而可以优化掉运行时的边界检查。

结论: 在遍历一个已知长度的集合或执行固定次数的迭代时，始终优先选择for循环。它更安全、更具表现力，并且能获得更好的性能。

4. 总结与最佳实践

我们已经详细探讨了Rust中的三种循环结构：loop、while和for。每一种都有其独特的设计和适用场景。为了编写出高质量的Rust代码，选择正确的循环工具至关重要。

以下是本次学习的要点总结和可供遵循的最佳实践：

循环类型 核心特性 适用场景 优点 缺点/注意事项
loop 无限循环，可与break、continue结合 1. 需要手动控制复杂退出条件的循环。
2. 实现事件循环或状态机。
3. 反复尝试操作直到成功。		 1. 表达无限循环意图最清晰。
2. 可从循环中返回值。		 必须确保有可靠的break路径，否则会造成死循环。
while 条件循环，循环前检查条件 1. 循环次数不确定，但有明确的布尔终止条件。
2. 等待某个状态发生改变。		 1. 直观地表达“当…时循环”的逻辑。 相比for，在遍历集合时更容易出错且可能稍慢。
for 迭代循环，遍历迭代器 1. 遍历任何集合（数组、向量、哈希图等）。
2. 执行固定次数的循环（使用范围）。		 1. 最安全：杜绝索引越界。
2. 最高效：通常无边界检查开销。
3. 最简洁：代码意图清晰。		 无明显缺点，是Rust中最受推崇的循环方式。

最佳实践清单：

  1. 优先使用for循环：当你需要遍历一个集合，或者执行一个已知次数的循环时，for循环几乎总是最佳选择。它融合了安全性、性能和可读性。

  2. 当循环条件不依赖于计数或集合时，选择while：如果你的循环逻辑是“只要某个条件成立就继续”，那么while循环能最直接地反映你的意图。

  3. 谨慎使用loop：loop是功能最原始也最灵活的循环。只在for和while都无法优雅地表达你的逻辑时才使用它。它在需要从循环中返回值或处理复杂的、多点退出的循环逻辑时非常有用。

  4. 利用迭代器：深入学习并利用Rust强大的迭代器API。像.iter()、.iter_mut()、.into_iter()、.rev()、.enumerate()等方法可以与for循环完美结合，写出极其强大而简洁的代码。

  5. 使用循环标签处理嵌套循环：当需要在内层循环中控制外层循环时，不要忘记使用循环标签（如'outer: loop）来精确控制break或continue的行为。

通过遵循这些原则，你将能够更好地利用Rust的循环控制结构，编写出既安全、高效，又充满表达力的代码，从而在Rust编程之路上更进一步。

# rust # 开发语言 # 后端
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

AI 浪潮终章奏凯！GitCode & 文心大模型 & 智源研究院 AI 应用开发大赛圆满落幕

avatar AtomGit开源社区

1.8B 体积、33 种语言互译｜腾讯混元 HY-MT1.5-1.8B 多语言机器翻译模型上线

在跨语言交流日益频繁的今天，阅读外语菜单、处理多语言邮件、与不同语言背景的人沟通，已经成为很多人日常工作与生活的一部分。过去，这类需求往往依赖联网翻译工具，而如今，—— 一部设备即可支持的相互翻译。当 AI 不再只是“逐字直译”，而是开始理解语境、风格与语言之间的细微差异，机器翻译就真正具备了今天为大家介绍一款高质量、多语言、支持端侧部署的机器翻译模型 ——，现已上线 AtomGit AI 社区，

avatar AtomGit开源社区
cover

LET：面向真实场景与长时序任务的人形机器人数据集

avatar AtomGit开源社区