循环

loops.md
commit 549270d4e66cc77b1f02cea13aaad9c90f150524

Rust 目前提供 3 种方法来进行一些迭代操作。他们是loop，while和for。每种方法都有自己的用途。

loop

无限loop是 Rust 提供的最简单的循环。使用loop关键字，Rust 提供了一个直到一些终止语句被执行的循环方法。Rust 的无限loop看起来像这样：

  1. loop {
  2.     println!("Loop forever!");
  3. }

while

Rust 也有一个while循环。它看起来像：

  1. let mut x = 5; // mut x: i32
  2. let mut done = false; // mut done: bool
  4. while !done {
  5.     x += x - 3;
  7.     println!("{}", x);
  9.     if x % 5 == 0 {
  10.         done = true;
  11.     }
  12. }

while循环是当你不确定应该循环多少次时正确的选择。

如果你需要一个无限循环，你可能想要这么写：

  1. while true {

然而，loop远比它适合处理这个情况：

  1. loop {

Rust 的控制流分析会区别对待这个与while true，因为我们知道它会一直循环。现阶段理解这些细节意味着什么并不是非常重要，基本上，你给编译器越多的信息，越能确保安全和生成更好的代码，所以当你打算无限循环的时候应该总是倾向于使用loop。

for

for用来循环一个特定的次数。然而，Rust的for循环与其它系统语言有些许不同。Rust的for循环看起来并不像这个“C语言样式”的for循环：

  1. for (x = 0; x < 10; x++) {
  2.     printf( "%d\n", x );
  3. }

相反，它看起来像这个样子：

  1. for x in 0..10 {
  2.     println!("{}", x); // x: i32
  3. }

更抽象的形式：

  1. for var in expression {
  2.     code
  3. }

这个表达式是一个迭代器.迭代器返回一系列的元素。每次迭代循环中的一个元素。然后它的值与var绑定，它在循环体中有效。每当循环体执行完后，我们从迭代器中取出下一个值，然后我们再重复一遍。当迭代器中不再有值时，for循环结束。

在我们的例子中，0..10表达式取一个开始和结束的位置，然后给出一个含有这之间值得迭代器。当然它不包括上限值，所以我们的循环会打印0到9，而不是到10。

Rust 没有使用“C语言风格”的for循环是有意为之的。即使对于有经验的 C 语言开发者来说，要手动控制要循环的每个元素也都是复杂并且易于出错的。

Enumerate 方法

当你需要记录你已经循环了多少次了的时候，你可以使用.enumerate()函数。

对于范围（On ranges）：

  1. for (index, value) in (5..10).enumerate() {
  2.     println!("index = {} and value = {}", index, value);
  3. }

输出：

  1. index = 0 and value = 5
  2. index = 1 and value = 6
  3. index = 2 and value = 7
  4. index = 3 and value = 8
  5. index = 4 and value = 9

别忘了在范围外面加上括号。

对于迭代器（On iterators）:

  1. let lines = "hello\nworld".lines();
  3. for (linenumber, line) in lines.enumerate() {
  4.     println!("{}: {}", linenumber, line);
  5. }

输出：

  1. 0: hello
  2. 1: world

提早结束迭代（Ending iteration early）

让我们再看一眼之前的while循环：

  1. let mut x = 5;
  2. let mut done = false;
  4. while !done {
  5.     x += x - 3;
  7.     println!("{}", x);
  9.     if x % 5 == 0 {
  10.         done = true;
  11.     }
  12. }

我们必须使用一个mut布尔型变量绑定，done,来确定何时我们应该推出循环。Rust 有两个关键字帮助我们来修改迭代：break和continue。

这样，我们可以用break来写一个更好的循环：

  1. let mut x = 5;
  3. loop {
  4.     x += x - 3;
  6.     println!("{}", x);
  8.     if x % 5 == 0 { break; }
  9. }

现在我们用loop来无限循环，然后用break来提前退出循环。

continue比较类似，不过不是退出循环，它直接进行下一次迭代。下面的例子只会打印奇数：

  1. for x in 0..10 {
  2.     if x % 2 == 0 { continue; }
  4.     println!("{}", x);
  5. }

break和continue在while循环和for循环中都有效。

循环标签（Loop labels）

你也许会遇到这样的情形，当你有嵌套的循环而希望指定你的哪一个break或continue该起作用。就像大多数语言，默认break或continue将会作用于最内层的循环。当你想要一个break或continue作用于一个外层循环，你可以使用标签来指定你的break或continue语句作用的循环。如下代码只会在x和y都为奇数时打印他们：

  1. 'outer: for x in 0..10 {
  2.     'inner: for y in 0..10 {
  3.         if x % 2 == 0 { continue 'outer; } // Continues the loop over `x`.
  4.         if y % 2 == 0 { continue 'inner; } // Continues the loop over `y`.
  5.         println!("x: {}, y: {}", x, y);
  6.     }
  7. }