Rust从入门到实战系列二百七十六：流程控制

if/else

1. 🌟
   // 填 空
   fn main() {
   let n = 5;
   if n < 0 {
   println!(“{} is negative”, n);
   } __ n > 0 {
   println!(“{} is positive”, n);
   } __ {
   println!(“{} is zero”, n);
   }
   }
2. 🌟🌟 if/else 可以用作表达式来进行赋值
   // 修 复 错 误
   fn main() {
   let n = 5;
   let big_n =
   if n < 10 && n > -10 {
   println!(" 数 字 太 小 ， 先 增 加 10 倍 再 说");
   10 * n
   } else {
   println!(“数 字 太 大 ， 我 们 得 让 它 减 半”);
   n / 2.0 ;
   }
   println!(“{} -> {}”, n, big_n);
   }
   for
3. 🌟 for in 可以用于迭代一个迭代器，例如序列 a…b .
   fn main() {
   for n in 1…=100 { // 修 改 此 行 ， 让 代 码 工 作
   if n == 100 {
   panic!(“NEVER LET THIS RUN”)
   }
   }
   }
4. 🌟🌟
   // 修 复 错 误 ， 不 要 新 增 或 删 除 代 码 行
   fn main() {
   let names = [String::from(“liming”),String::from(“hanmeimei”)];
   for name in names {
   // do something with name…
   }
   println!(“{:?}”, names);
   let numbers = [1, 2, 3];
   // numbers中 的 元 素 实 现 了 Copy， 因 此 无 需 转 移 所 有 权
   for n in numbers {
   // do something with name…
   }
   println!(“{:?}”, numbers);
   }
5. 🌟
   fn main() {
   let a = [4,3,2,1];
   // 通 过 索 引 和 值 的 方 式 迭 代 数 组 a
   for (i,v) in a.__ {
   println!(“第{}个 元 素 是{}”,i+1,v);
   }
   }
   while
6. 🌟🌟 当条件为 true 时， while 将一直循环
   // 填 空 ， 让 最 后 一 行 的 println! 工 作 !
   fn main() {
   // 一 个 计 数 值
   let mut n = 1;
   // 当 条 件 为 真 时 ， 不 停 的 循 环
   while n __ 10 {
   if n % 15 == 0 {
   println!(“fizzbuzz”);
   } else if n % 3 == 0 {
   println!(“fizz”);
   } else if n % 5 == 0 {
   println!(“buzz”);
   } else {
   println!(“{}”, n);
   }
   __;
   }
   println!(“n 的 值 是 {}, 循 环 结 束”,n);
   }
   continue and break
7. 🌟 使用 break 可以跳出循环
   // 填 空 ， 不 要 修 改 其 它 代 码
   fn main() {
   let mut n = 0;
   for i in 0…=100 {
   if n == 66 {
   __
   }
   n += 1;
   }
   assert_eq!(n, 66);
   }
8. 🌟🌟 continue 会结束当次循环并立即开始下一次循环
   // 填 空 ， 不 要 修 改 其 它 代 码
   fn main() {
   let mut n = 0;
   for i in 0…=100 {
   if n != 66 {
   n+=1;
   __;
   }
   __
   }
   assert_eq!(n, 66);
   }
   loop
9. 🌟🌟 loop 一般都需要配合 break 或 continue 一起使用。
   // 填 空 ， 不 要 修 改 其 它 代 码
   fn main() {
   let mut count = 0u32;
   println!(“Let’s count until infinity!”);
   // 无 限 循 环
   loop {
   count += 1;
   if count == 3 {
   println!(“three”);
   // 跳 过 当 此 循 环 的 剩 余 代 码
   __;
   }
   println!(“{}”, count);
   if count == 5 {
   println!(“OK, that’s enough”);
   __;
   }
   }
   assert_eq!(count, 5);
   }
10. 🌟🌟 loop 是一个表达式，因此我们可以配合 break 来返回一个值
    // 填 空
    fn main() {
    let mut counter = 0;
    let result = loop {
    counter += 1;
    if counter == 10 {
    __;
    }
    };
    assert_eq!(result, 20);
    }
11. 🌟🌟🌟 当有多层循环时，你可以使用 continue 或 break 来控制外层的循环。要实现这一点，外
    部的循环必须拥有一个标签 'label , 然后在 break 或 continue 时指定该标签
    // 填 空
    fn main() {
    let mut count = 0;
    'outer: loop {
    'inner1: loop {
    if count >= 20 {
    // 这 只 会 跳 出 inner1 循 环
    break 'inner1; // 这 里 使 用 break 也 是 一 样 的
    }
    count += 2;
    }
    count += 5;
    'inner2: loop {
    if count >= 30 {
    break 'outer;
    }
    continue 'outer;
    }
    }
    assert!(count == __)
    }