Rust流程控制——循环(loop,while,for)

loop循环

Rust 提供了 loop 关键字来实现一个无限循环。

可以使用 break 语句在任何时候退出一个循环，另外可用 continue 跳过循环体的剩余部分并开始下一轮循环。

循环返回值

loop为无限循环，使用break退出，退出时有返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fn main(){
    let mut counter = 0;
    let result = loop{
        counter += 1;
        if counter >= 10{
            //从 loop 循环中返回
            break counter*2
        }
    };
    println!("{}",result);
}

//输出 20

嵌套循环中断

嵌套循环和标签,利用标签决定跳出哪个循环,注意标签是’name:loop。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fn main(){
    'outer:loop{
        println!("outer loop");
        'inner:loop{
            println!("break outer loop");
            //break or break 'inner
            // 这会中断外层循环
            break 'outer;
        };
    };
}

//输出 
//outer loop
//break outer loop

continue跳出循环体剩余部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fn main(){
    let mut counter = 0;
    loop{
        counter += 1;
        if counter >5{
            continue;
        }
        println!("no continue");
    };
}

//输出
//no continue
//no continue
//no continue
//no continue
//no continue

while循环

while 关键字可以用作当型循环（当条件满足时循环）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
fn main(){
    let mut counter = 0;
    //当counter小于5时循环
    while counter < 5 {
        if counter %2 == 0{
            println!("偶数");
        }else{
            println!("奇数");
        }
        counter +=1 ;
    }
}

//输出
//偶数
//奇数
//偶数
//奇数
//偶数

for循环

区间

for in 结构可以遍历一个 Iterator（迭代器）。创建迭代器的一个最简单的方法是使 用区间标记 a..b。这会生成从 a（包含此值） 到 b（不含此值）的，步长为 1 的 一系列值。

区间0..5不包含5，0..=5包含5。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
fn main(){
    for counter in 0 ..5{
        if counter %2 == 0{
            println!("偶数");
        }else{
            println!("奇数");
        }
    }
	//或者
    for counter in 0 ..=4{
        if counter %2 == 0{
            println!("偶数");
        }else{
            println!("奇数");
        }
    }
}

//输出
//偶数
//奇数
//偶数
//奇数
//偶数

迭代器

1.iter - 在每次迭代中借用集合中的一个元素。这样集合本身不会被改变，循环之后仍 可以使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn main(){
    let names = vec!["Curry","James","Durant"];
    for name in names.iter(){
        match name {
            &"Curry" => {
                println!("Best shooter")
            }
            _ =>{
                println!("Good player");
            }
        }
    }
}

//输出
//Best shooter
//Good player
//Good player

2.into_iter - 会消耗集合。在每次迭代中，集合中的数据本身会被提供。一旦集合被消耗了，之后就无法再使用了，因为它已经在循环中被 “移除”（move）了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
fn main(){
    let names = vec!["Curry","James","Durant"];

    for name in names.into_iter(){
        match name {
            "Curry" => {
                println!("Best shooter")
            }
            _ =>{
                println!("Good player");
            }
        }
    }
}

//输出
//Best shooter
//Good player
//Good player

3.iter_mut - 可变地（mutably）借用集合中的每个元素，从而允许集合被就地修改。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fn main(){
    let mut names = vec!["Curry","James","Durant"];

    for name in names.iter_mut(){
        *name = match name {
            &mut "Curry" => {
                "Best shooter"
            }
            _ =>{
                "Good player"
            }
        }
    }
    println!("{:?}",names);
}

//输出
//["Best shooter", "Good player", "Good player"]