十、Rust 循环语句

现实的世界很无奈，因为它是线性的，流水线形式的。

过完今天，还有明天，过完明天，还有后天。

具体到每一天，无外乎是

  1. 睡醒 -> 早餐 -> 上班/上学 -> 午餐 -> 上班/上学 -> 回家 -> 晚饭 -> 睡觉

虽然站在每天的角度考虑，生活真的是顺风顺水，流水作业。但如果站在上帝的视角，白天生活无外乎是

  1. 吃饭 -> 工作 -> 吃饭 -> 工作 -> 吃饭 -> 工作

好像陷入了一种死循环的状态。

如果我们把时间缩短到每个小时，那么白天的生活几乎就是

  1. 9:30  上班
  2. 10:30 上班
  3. 11:30 上班
  4. 12:00 下班
  5. 13:30 上班
  6. 14:30 上班
  7. 15:30 上班
  8. 16:30 上班
  9. 17:30 上班
  10. 18:30 下班

如果你撇开时间不看，那白天都在上班上班上班….这样循环下去。

即使加入了时间，看起来除了 12:00 和 18:30 是下班外，每个小时都在循环工作的赶脚。

循环其实就是一种重复，在满足指定的条件下，重复的做某些事情。就好比如只要时间没到 18:30，那么我们一直在重复的上班。

编程语言是模拟现实生活的，如果你有哪块搞不清楚，那么只要从现实生活中找例子即可。

编程语言也有循环这种概念，也可以在满足指定的条件下，重复的执行一部分代码，我们把这种重复执行的代码称之为 转换语句

10.1 Rust 中的循环

循环语句允许我们多次执行语句或语句组。

循环语句就是在指定条件为真的情况下重复的执行代码。

这个重复的过程，我们使用一张图来描绘就会像下面这样子

loop statement

有时候不得不感慨中文的博大精深，就一个重复执行的动作，我们有很多种描述方法

  1. 太阳每天都东升西落。在人的生命周期中，永远看不到结束的时候，这是一种死循环。
  2. 只要还趴下住院，你就一直要重复的工作…。这是一种有条件的循环，只要条件为真就要重复执行。
  3. 做错了事，总是被罚站 30 分钟。1分钟…2分钟…30 分钟。这种循环有初始化，有临界条件，还会自动递增时间。

对应着上面三种重复，Rust 语言中也有三种表示 循环 的语句：

  • loop 语句。一种重复执行且永远不会结束的循环。
  • while 语句。一种在某些条件为真的情况下就会永远执行下去的循环。
  • for 语句。一种有确定次数的循环。

三种语句都能实现循环功能，只不过侧重点不一样。

从上面的描述中，根据循环是否可能结束，我们把循环分为两大类

  1. 能确定次数的循环，比如 for 循环。
  2. 满足条件就是永动机的循环。比如 while 循环。
  3. 死循环。比如 loop 循环。

10.2 for 循环语句

for 语句是一种能确定循环次数的循环。

for 语句用于执行代码块指定的次数。

可能和其它语言有所不同，Rust 中的 for 循环只有 for..in 这种格式，常用于迭代一组固定的值，例如数组、向量等。

10.2.1 for 循环语句的语法格式

  1. for temp_variable in lower_bound..upper_bound {
  2.    // action 要重复执行的代码
  3. }

  • lower_bound..upper_bound 用于指定循环区间，是一个左闭又开的区间，比如 1..3 则只有 1 和 2 不包含 3

  • temp_variable 是循环迭代的每一个元素。

  • temp_variable 变量的作用域仅限于 for…in 语句，超出则会报错

10.2.2 范例: 基本的 for…in 循环

下面的代码，使用 for…in 循环，重复输出 1 到 11 之间的数字（不包括 11 ）

  1. fn main(){
  2.    for x in 1..11{
  3.       println!("x is {}",x);
  4.    }
  5. }

编译运行以上 Rust 代码，输出结果如下

  1. x is 1
  2. x is 2
  3. x is 3
  4. x is 4
  5. x is 5
  6. x is 6
  7. x is 7
  8. x is 8
  9. x is 9
  10. x is 10

10.3 while 循环

while 语句是一种只要条件为真就一直会重复执行下去的循环。

while 循环会在每次重复执行前先判断条件是否满足，满足则执行，不满足则退出。

10.3.1 while 语句的语法格式

  1. while ( condition ) {
  2.     // action 要重复执行的代码
  3. }

condition 是一个表达式，返回的结果会转换为 布尔类型。只要 condition 返回真，那么循环就会一直执行。

10.3.2 范例： 基本的 while 循环

下面的代码，使用 while 循环重写下上面的代码，重复输出 1 到 11 之间的数字（不包括 11 ）

  1. fn main(){
  2.    let mut x = 1;
  3.    while x < 11{
  4.       println!("inside loop x value is {}",x);
  5.       x+=1;
  6.    }
  7.    println!("outside loop x value is {}",x);
  8. }

编译运行以上 Rust 代码，输出结果如下

  1. inside loop x value is 1
  2. inside loop x value is 2
  3. inside loop x value is 3
  4. inside loop x value is 4
  5. inside loop x value is 5
  6. inside loop x value is 6
  7. inside loop x value is 7
  8. inside loop x value is 8
  9. inside loop x value is 9
  10. inside loop x value is 10
  11. outside loop x value is 11

看到最后的 outside loop x value is 11 没，因为当 x 递增到 11 就不再满足条件 x < 11 了。

10.4 loop 循环

loop 语句代表着一种死循环。它没有循环条件，也没有循环次数，它就是一个永动机。

10.4.1 loop 语句的语法格式

  1. loop {
  2.     // action 要重复执行的代码
  3. }

10.4.2 范例：loop 循环的基本使用

下面的语句，我们使用 loop 输出 1 到无限大的数字。

实际上是不可能的

  1. fn main(){
  2.    let mut x = 0;
  3.    loop {
  4.       x+=1;
  5.       println!("x={}",x);
  6.    }
  7. }

编译运行以上 Rust 代码，输出结果如下

  1. x=1
  2. x=2
  3. x=3
  5. ...
  6. ...
  8. x=61^Cx=612514
  9. x=612515
  10. x=612516

这是一个死循环，如果不出意外是不会停下来的。需要我们手动退出程序，这时候你可以按下 CTRL + C 组合建退出程序。

注意: 任何程序，如果进入死循环，你可以按下 CTRL + C 组合键退出程序。

10.5 循环控制语句 break

好啦好啦，我们已经学会了三大循环语句了，大家用起来感觉如何？？？

在日常的编程中，不知道大家有没有这样的请求，如果 action 语句块中也能退出循环就好了。

哈哈，为了响应这个请求，语言的开发者们早点就想到了这一块了，于是有了 break 语句。

也就是说 break 语句的出现，就是为了在 action 语句块中可以退出循环语句。

10.5.1 break 语句的语法

break 语句的语法格式如下

  1. break;

很简洁，不拖泥带水的。

10.5.2 范例

小试牛刀一下，我们使用 break 语句改造下我们的 loop 循环，在 x 大于 11 就退出循环。

也就是使用 loop 循环实现 while 循环

  1. fn main(){
  2.    let mut x = 0;
  3.    loop {
  4.       x+=1;
  5.       if x > 10 {
  6.         break;
  7.       }
  8.       println!("x={}",x);
  9.    }
  10. }

编译运行以上 Rust 代码，输出结果如下

  1. x=1
  2. x=2
  3. x=3
  4. x=4
  5. x=5
  6. x=6
  7. x=7
  8. x=8
  9. x=9
  10. x=10

10.6 循环控制语句 continue

break 语句让我们尝到了甜头，有时候我们就会突发奇想，有没有另一个关键字，不像 break 语句那样直接退出整个循环，而仅仅是退出当前循环。也就是剩下的语句不执行了，开始下一个迭代。

创造了那些语言的前辈们，自然也会有这个想法，于是造出了 continue 语句。

continue 语句，简单的说，就是停止执行剩下的语句，直接进入下一个循环。

10.6.1 continue 语句的语法格式

continue 语句的语法格式如下

  1. continue;

10.6.2 范例

下面的代码，我们使用 for 循环输出 1 到 11 之间的数字，但是跳过数字 5

  1. fn main(){
  2.     for x in 1..11{
  3.         if 5 == x {
  4.             continue;
  5.         }
  6.         println!("x is {}",x);
  7.     }
  8. }

编译运行以上 Rust 代码，输出结果如下

  1. x is 1
  2. x is 2
  3. x is 3
  4. x is 4
  5. x is 6
  6. x is 7
  7. x is 8
  8. x is 9
  9. x is 10