在Rust中，除了while、for实现循环控制，增加了一个新的循环方式loop，这才是名符其实的循环语句。类似C/C++、Java、JavaScript、C#语言一样，使用关键字continue和break控制执行流程。Continue语句表示本次循环内，后面的语句不再执行，直接进入下一轮循环。break语句表示跳出循环，不再继续，而loop关键表示一个无限死循环。loop与while true的区别在于前者是表达式，而后者是语句，这是二者区别的核心。

其实loop就是一个while(true)的语法糖，既然死循环都出来了，又想起来为啥不支持 :?三元运算符？

1. loop

loop 关键字，在Rust中，使用loop表示一个无限死循环。示例如下：

//loop死循环
use std::time::Duration;
use std::thread::sleep;
fn loop_test1(){ 
    println!("***** loop_test1 start *****");

    let mut count = 0u32;
    loop{
        count +=1;
        println!("print count={}",count);    
        sleep(Duration::from_millis(100)); //睡眠 100 ms
        // if count>10{
        //     break; //如果没有break则一直死循环。
        // }
    }
    println!("***** loop_test1 end *****\n");
}

fn main() {

    loop_test1();
}

这个死循环有一个非常明确的使用场景，就是在嵌入式系统中的主函数，直接看到loop就可以认为是主函数了，或者是某个任务的主体，这个设计还是很好的，至少在可读性上又增加了一层。

break语句和continue语句还可以在多重循环中选择跳出到哪一层的循环。

//loop循环 + 跳出标签所指的那层循环。
fn loop_test2()
{
    let mut count1 = 0u32;
    let mut count2 = 0u32;
    'loop1:loop{
        count1 +=1;

        'loop2:loop{
            count2+=1;
            if count2 == 2 {
                println!("count2=={},continue 'loop2!",count2);  
                continue 'loop2;
            }
            
            if count2 >= 4 {
                count2 = 0;
                break ;
            }
            
            if count1 == 5{
                println!("count1=={},break: out of 'loop1!",count1);
                break 'loop1;
            }
            
            println!("print count1={} -- count2={}",count1,count2);
        }
    }
}

loop的break返回值
loop是表达式而while/for是语句，这是loop与while/for循环不一样的地方。
在loop内部break的后面可以跟一个表达式，这个表达式就是最终的loop表达式的值。如果一个loop永远不返回，那么它的类型就是“发散类型”。

当使用 loop循环时，通过形如 break EXPR 或 break 'label EXPR 来返回，其中 EXPR 是一个表达式，它的结果被从 loop循环中返回。 例如：

#![allow(unused)]
fn main() {
    let (mut a, mut b) = (1, 1);
    let result = loop {
        if b > 10 {
            break b;
        }
        let c = a + b;
        a = b;
        b = c;
    };
    // 斐波那契数列中第一个大于10的值：
    assert_eq!(result, 13);
}

2. while

while 关键字，while语句是带条件判断的循环语句。其语法是while关键字后跟条件判断语句，最后是结果语句块。如果条件满足，则持续循环执行结果语句块。示例如下：

//while语句是带条件判断的循环语句,同样可有continue和break来控制循环流程。。
fn while_test1(){ 
    let mut while_count = 0;
    while while_count < 10 {
        while_count+=1;
        println!("print while_count={}",while_count);

        if while_count == 3 {
            println!("continue: while while_count= {}",while_count);
            continue;
        }

        if while_count == 5 {
            println!("reak: out of while while_count = {}",while_count);
            break;
        }
    }
}

//while实现死/无限循环：
use std::time::Duration;
use std::thread::sleep;
fn while_test2(){ 
    let mut while_count = 0;
    #[warn(while_true)]{
        while true {
            while_count+=1;
            println!("print while_count={}",while_count);
            sleep(Duration::from_millis(500)); //睡眠 500 ms

            // if while_count == 10 {
            //     break; //如果没有break则一直循环。
            // }
        } 
    }
}

会警告提示用关键字“loop”：

warning: denote infinite loops with `loop { ... }`
   --> src/main.rs:108:9
    |
108 |         while true {
    |         ^^^^^^^^^^ help: use `loop`

注意：loop和while true的死/无限循环区别：

//loop和while true无限循环区别。
fn loop_while_infinitecycle_test3(){ 
    let x;
    loop { x = 1; break; }
    println!("{}", x);//没问题。

    let x;
    while true { x = 1; break; }
    println!("{}", x);//报错，提示x不确定被赋初值，却被使用。
}

原因在于对编译器来说loop是一定会进入循环体去执行，但是while是需要先判断条件为真才进入循环体执行。

while let谓词模式循环
while let循环在语义上类似于 while循环，但它用 let关键字后紧跟着一个模式、一个 =、一个检验对象(scrutinee)表达式和一个块表达式，来替代原来的条件表达式。 如果检验对象表达式的值与模式匹配，则执行循环体块，然后控制流再返回到模式匹配语句。如果不匹配，则 while表达式执行完成。

#![allow(unused)]
fn main() {
    let mut x = vec![1, 2, 3];

    while let Some(y) = x.pop() {
        println!("y = {}", y);
    }

    while let _ = 5 {
        println!("不可反驳模式总是会匹配成功");
        break;
    }
}

可以使用操作符 | 指定多个模式。 这与匹配(match)表达式中的 | 具有相同的语义：

#![allow(unused)]
fn main() {
    let mut vals = vec![2, 3, 1, 2, 2];
    while let Some(v @ 1) | Some(v @ 2) = vals.pop() {
        // 打印 2, 2, 然后 1
        println!("{}", v);
    }
}

3. for循环

Rust中的for关键字类似其他语言中的for-each循环，但不是C/C++的三段式for循环语句。for循环的主要用处是利用迭代器对包含同样类型的多个元素的容器执行遍历。for循环内部也可以使用continue和break控制执行流程。举例如下：

//for 循环。continue和break控制执行流程
fn for_test1(){ 
    let mut for_count: i32 ;
    for n in 1..10{
        for_count = n;
        
        if for_count == 3 {
            continue;
        }
        if for_count == 6 {
            break;
        }
        println!("print for_count={}",for_count);
    }
}

//for 循环。for + match 的用法
fn for_test2(){     
    /* 数值匹配 */
    for n in 0..=20{
        if n == 16 {
            println!("continue: for n= {}",n);
            continue;
        }
        match n {
            0 => println!("match 0 n={}",n),
            0|2|4|6|8 => println!("match n is even number:{}",n),
            1|3|5|7|9 => println!("match n is odd number:{}",n),
            10..=15 => println!("match n is '10'<=n<='19' : {}",n),
            _ => println!("useless number {}",n),
        }
    }

    /* 字符串匹配 */
    let for_name = vec!["s1","s2","s3"];
    for name in for_name.iter(){
        match name{
            &"s1" => println!("match \"s1\" name ={}",name),
            &"s2" => println!("match \"s2\"  name ={}",name),
            _ => println!("current name={}, isn't = \"s1\" or \"s2\"!",name),
        }
    }
}

for + while 循环混用:

fn for_test3(){ 
    println!("******************** for_test3 start ********************");

    'outer: for x in 1..5 {
        let mut i = 0;
        while i < x {
            i += 1;
            if i == 3 {
                println!("###break: 'outer. for: x={}, while:i={}",x,i);
                break 'outer;
            }
            println!("for: x={}, while:i={}",x,i);
        }
    }
}

for+iter(), iter()函数获取数组中所有元素的值:

fn my_fn()->u32{
    let arr:[i32;4]=[10,20,30,40];
    println!("array is {:?}",arr);
    println!("array size is :{}",arr.len());
    
    for val in arr.iter(){
      println!("value is :{}",val);
    }
    return 0;
}

//for 引用传递
fn my_fn(arr:&mut [i32;3])
{
    let n=arr.len();
   for i in 0..n {
      arr[i]=0;
   }
}

fn main() {
    let mut arr:[i32;3]=[1,2,3];
    println!("arr: {:?}", arr);
    my_fn(&mut arr);
    println!("arr after uptade: {:?}", arr);
}

注意：
for i in 0...10 { }中的i是直接使用，是不用单独声明的，例如：
let mut i:u32 = 0;警告未使用的变量：warning: unused variable: i

for i in 1..10 { //这个for循环的i不是上面声明的变量i.
    println!("i={ }",i);
}

4. 基于rust循环控制实现的相关算法

1. 计算考拉兹序列的长度。
   （若n为偶数）: n→n/2.（若n为奇数): n→n*3+1.
   从13开始，可以迭代生成如下的序列：13→40→20→10→5→16→8→4→2→1，代码示例如下：

fn collatz_length(mut n: i32) -> u32 {
    let mut len = 1;
    while n > 1 {
        println!("len={}:{}",len,n);
        n = if n % 2 == 0 { n  / 2 } else { 3 * n + 1 };
        len += 1;
    }
        println!("len={}:{}",len,n);
    return len;
}

2. 求斐波那契数列
   斐波那契函数的变化规律：F1=1,F2=1,F(n)=F(n-1)+F(n-2) (n>=3)。

fn fib(mut n: u32) -> u32 {
    let mut fn1:u32 = 1;
    let mut fn2:u32 = 1;
    let mut fn_value:u32 = 0;
    
    while n > 2{
        println!("fn_value={},fn1={},fn2={}",fn_value,fn1,fn2);
        /* fn_value = fn-1 + fn-2 */
        fn_value=fn1+fn2;
        
        fn2=fn1;
        fn1=fn_value;
        n-=1;
    }
    println!("fn1={},fn2={}",fn1,fn2);
    return fn_value;
}

3. 猴子吃桃问题
   一只猴子第一天摘了n个桃，当即吃了一半又多吃了一个，第二天又吃了一半再多吃一个，直到第十天早上想吃时只剩下1个，问第一天摘了多少桃？

fn peach() -> u32 {
    let mut peach_num:u32 = 1;//in day 10(no eat), only remained 1 peach.
    for i in 1..10{
        println!("day={},peach_num={}",i,peach_num);
        peach_num=2*(peach_num+1);
    }
    println!("day={},peach_num={}",10,peach_num);
    return peach_num;
}

4. 实现冒泡排序

fn my_fn( mem:&mut Vec<i32>)
{
    for i in 0..mem.len() {
        for x in 0..mem.len()-1{
            if mem[x] > mem[x+1]{
                mem.swap(x,x+1);
            }
        }
    }
}

fn main() {
    let mut mem1 =vec![1,6,5,3,9,4,8,2,7,0];
    println!("mem1: {:?}", mem1);
    my_fn(&mut mem1);
    println!("mem1 after update: {:?}", mem1);
}

建议
在实际使用中，对于数组的遍历，建议用for，在线程的主函数体中使用loop，在其它情况下条件循环使用while，形成模式以后使代码可读性更强。