流程控制

if/else

  1. 🌟
2. // 填空
3. fn main() {
4. let n = 5;

6. if n < 0 {
7. println!("{} is negative", n);
8. } __ n > 0 {
9. println!("{} is positive", n);
10. } __ {
11. println!("{} is zero", n);
12. }
13. }
  1. 🌟🌟 if/else 可以用作表达式来进行赋值
2. // 修复错误
3. fn main() {
4. let n = 5;

6. let big_n =
7. if n < 10 && n > -10 {
8. println!(" 数字太小，先增加 10 倍再说");

10. 10 * n
11. } else {
12. println!("数字太大，我们得让它减半");

14. n / 2.0 ;
15. }

17. println!("{} -> {}", n, big_n);
18. }

for

  1. 🌟 for in 可以用于迭代一个迭代器，例如序列 a..b.
2. fn main() {
3. for n in 1..=100 { // 修改此行，让代码工作
4. if n == 100 {
5. panic!("NEVER LET THIS RUN")
6. }
7. }
8. }
  1. 🌟🌟
2. // 修复错误，不要新增或删除代码行
3. fn main() {
4. let names = [String::from("liming"),String::from("hanmeimei")];
5. for name in names {
6. // do something with name...
7. }

9. println!("{:?}", names);

11. let numbers = [1, 2, 3];
12. // numbers中的元素实现了 Copy，因此无需转移所有权
13. for n in numbers {
14. // do something with name...
15. }

17. println!("{:?}", numbers);
18. }
  1. 🌟
1. fn main() {
2. let a = [4,3,2,1];

4. // 通过索引和值的方式迭代数组 `a`
5. for (i,v) in a.__ {
6. println!("第{}个元素是{}",i+1,v);
7. }
8. }

while

  1. 🌟🌟 当条件为 true 时，while 将一直循环
2. // 填空，让最后一行的  println! 工作 !
3. fn main() {
4. // 一个计数值
5. let mut n = 1;

7. // 当条件为真时，不停的循环
8. while n __ 10 {
9. if n % 15 == 0 {
10. println!("fizzbuzz");
11. } else if n % 3 == 0 {
12. println!("fizz");
13. } else if n % 5 == 0 {
14. println!("buzz");
15. } else {
16. println!("{}", n);
17. }

19. __;
20. }

22. println!("n 的值是 {}, 循环结束",n);
23. }

continue and break

  1. 🌟 使用 break 可以跳出循环
2. // 填空，不要修改其它代码
3. fn main() {
4. let mut n = 0;
5. for i in 0..=100 {
6. if n == 66 {
7. __
8. }
9. n += 1;
10. }

12. assert_eq!(n, 66);
13. }
  1. 🌟🌟 continue 会结束当次循环并立即开始下一次循环
2. // 填空，不要修改其它代码
3. fn main() {
4. let mut n = 0;
5. for i in 0..=100 {
6. if n != 66 {
7. n+=1;
8. __;
9. }

11. __
12. }

14. assert_eq!(n, 66);
15. }

loop

  1. 🌟🌟 loop 一般都需要配合 break 或 continue 一起使用。
2. // 填空，不要修改其它代码
3. fn main() {
4. let mut count = 0u32;

6. println!("Let's count until infinity!");

8. // 无限循环
9. loop {
10. count += 1;

12. if count == 3 {
13. println!("three");

15. // 跳过当前循环的剩余代码
16. __;
17. }

19. println!("{}", count);

21. if count == 5 {
22. println!("OK, that's enough");

24. __;
25. }
26. }

28. assert_eq!(count, 5);
29. }
  1. 🌟🌟 loop 是一个表达式，因此我们可以配合 break 来返回一个值
2. // 填空
3. fn main() {
4. let mut counter = 0;

6. let result = loop {
7. counter += 1;

9. if counter == 10 {
10. __;
11. }
12. };

14. assert_eq!(result, 20);
15. }
  1. 🌟🌟🌟 当有多层循环时，你可以使用 continue 或 break 来控制外层的循环。要实现这一点，外部的循环必须拥有一个标签 'label, 然后在 break 或 continue 时指定该标签
2. // 填空
3. fn main() {
4. let mut count = 0;
5. 'outer: loop {
6. 'inner1: loop {
7. if count >= 20 {
8. // 这只会跳出 inner1 循环
9. break 'inner1; // 这里使用 `break` 也是一样的
10. }
11. count += 2;
12. }

14. count += 5;

16. 'inner2: loop {
17. if count >= 30 {
18. break 'outer;
19. }

21. continue 'outer;
22. }
23. }

25. assert!(count == __)
26. }

你可以在这里找到答案(在 solutions 路径下)