我们写代码时业务逻辑的实现，依赖于编程语言的流程控制结构。今天来介绍一下 Rust 中的流程控制结构。

if语句

if 语句是最基本的控制结构了，Rust 的 if 语句如下面代码所示：

fn main() {
    let number = 3;
    
    if number > 5 {
        println!("number > 5");
    } else if number > 3 {
        println!("number > 3");
    } else {
        println!("number <= 3");
    }
}

和 C/C++/Java 这些语言大致相同，但差异在于，if 语句的条件不使用括号包裹。由于 Rust 是强类型语言，所以 if 语句的条件也必须是 bool 类型。

除了上面这种基本形式之外，if 语句还有下面新奇的用法：

fn main() {
    let my_total = 150;
    
    // 满100减30
    let my_payment = if my_total >= 100 {
        my_total - 30
    } else {
        my_total
    }; // 注意这里必须加上分号
    
    println!("{}", my_payment); // 120
}

Rust 没有提供三元表达式，所以我们要使用 if 语句来完成，在 if 分支和 else 分支内部，直接放置一个表达式，表示返回值。需要注意的是，分支内的表达式不能加分号，类型也必须一致。

match语句

大部分编程语言都提供了 switch 这样的语句结构，来提供对指定变量的分支匹配，Rust 提供了相似的 match 功能，比传统的 switch 要强大的多：

fn main() {
    let number = 3;
    
    match number {
        0 => println!("match 0"),
        1 | 3 => println!("match 1 or 3"),
        5..=7 => println!("match [5, 7]"),
        n @ 9 => println!("match {}", n),
        _ => println!("default"),
    }
}

从上面代码可以看出，match 语句的匹配格式有很多种，可以匹配指定值，可以匹配多个值中的一个，也可以匹配某个范围内的值，还可以在匹配时定义变量，最后，default 分支使用下划线 _ 表示。

需要注意的是，5..=7 这个表达式表示的是 5 到 7 的闭区间，也就是说包含 7 这个值。

除了上述代码之外，match 语句还能返回结果值，用于为变量赋值，我们只需确保每个匹配的分支都返回一个表达式即可：

fn main() {
    let is_real = true;
    
    let result = match is_real {
        true => "real",
        false => "not real",
    }; // 注意加分号
    
    println!("{}", result);
}

循环结构

Rust 也使用 for 来定义循环结构，但稍微有些不同：

fn main() {
    // 循环表达式 不包含最后一个值
    for n in 0..10 {
        if n % 5 == 0 {
            println!("-----");
        }
        println!("{}", n);
    }
}

运行上面代码，打印结果如下：

-----
0
1
2
3
4
-----
5
6
7
8
9

如果在范围表达式的后面追加一个 = 号，和上面 match 匹配分支中的一样，表示包含最后的边界，即这个范围是闭区间：

fn main() {
    // 加个等号 包含最后一个值
    for n in 0..=10 {
        if n % 5 == 0 {
            println!("-----");
        }
        println!("{}", n);
    }
}

再次运行代码，打印结果如下：

-----
0
1
2
3
4
-----
5
6
7
8
9
-----
10

除了 for 循环之外，Rust 还提供了 loop 循环，不过在使用 loop 时，需要我们主动地根据条件退出当前循环：

fn main() {
    let mut count = 0;

    loop {
        if count >= 10 {
            break;
        }
        
        println!("{}", count);
        
        // Rust没有提供自增自减表达式
        count += 1;
    }
}

和 match 相似，loop 结构也可以返回一个最终结果。只要在 break 时附带一个结果，我们就能获取到，并将其赋给一个变量：

fn main() {
    let mut number = 1;
    
    // 求同时能被5、13、15整除的数
    let result = loop {
        let matched = number % 5 == 0 
                && number % 13 == 0 
                && number % 15 == 0;
        
        if matched {
            // 退出循环时返回最终结果
            break number;
        }
        
        number += 1;
    }; // 同样 注意加分号
    
    println!("{}", result); // 195
}

当然，我们还可以使用 while 结构，提前根据条件决定，是否要继续执行循环，这种方式相信大家都不会陌生：

fn main() {
    let mut count = 0;

    while count < 10 {
        println!("{}", count);
        
        count += 1;
    }
}

总的来说，Rust 在流程控制方面，还是有不少灵活用法的，我们可以多试一试，体会体会。

关于流程控制，就先介绍到这里了。