Rust流程控制实战：从基础到高级技巧-优快云博客

Rust流程控制实战：从基础到高级技巧

rust-by-practice Learning Rust By Practice, narrowing the gap between beginner and skilled-dev through challenging examples, exercises and projects. 项目地址: https://gitcode.com/gh_mirrors/ru/rust-by-practice

本文将基于Rust实践项目中的流程控制示例，深入讲解Rust中各种流程控制结构的使用方法和最佳实践。无论你是Rust初学者还是有一定经验的开发者，都能从中获得有价值的知识。

条件判断：if表达式

Rust中的if表达式与其他语言类似，但有一个重要特点：它实际上是一个表达式，可以返回值。

fn main() {
    let n = 5;

    if n < 0 {
        println!("{} is negative", n);
    } else if n > 0 {
        println!("{} is positive", n);
    } else {
        println!("{} is zero", n);
    }
}

这个基础示例展示了if-else if-else的典型结构。注意Rust的条件不需要括号，但代码块必须用花括号包裹。

更有趣的是if表达式可以返回值：

fn main() {
    let n = 5;

    let big_n = if n < 10 && n > -10 {
        println!(", and is a small number, increase ten-fold");
        10 * n  // 返回值
    } else {
        println!(", and is a big number, halve the number");
        n / 2   // 返回值
    };

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

这里if和else分支都返回了值，赋给了big_n变量。注意两个分支返回的类型必须相同。

循环结构

for循环

Rust的for循环主要用于迭代集合：

fn main() {
    for n in 1..100 {  // 范围1到99
        if n == 100 {
            panic!("NEVER LET THIS RUN")
        }
    }
}

这个例子展示了范围迭代。注意1..100是左闭右开区间，所以n永远不会等于100。

处理数组时需要注意所有权问题：

fn main() {
    let names = [String::from("liming"), String::from("hanmeimei")];
    for name in &names {  // 借用而非移动
        // 使用name...
    }
    println!("{:?}", names);  // 仍然可用

    let numbers = [1, 2, 3];
    for n in numbers {  // Copy类型可以直接移动
        // 使用n...
    }
    println!("{:?}", numbers);  // 仍然可用
}

对于需要索引的情况，可以使用enumerate：

fn main() {
    let a = [4, 3, 2, 1];
    for (i, v) in a.iter().enumerate() {
        println!("The {}th element is {}", i + 1, v);
    }
}

while循环

while循环在条件为真时持续执行：

fn main() {
    let mut n = 1;
    while n < 10 {
        // 经典的fizzbuzz问题
        if n % 15 == 0 {
            println!("fizzbuzz");
        } else if n % 3 == 0 {
            println!("fizz");
        } else if n % 5 == 0 {
            println!("buzz");
        } else {
            println!("{}", n);
        }
        n += 1;
    }
}

loop循环

loop是无限循环，需要显式break退出：

fn main() {
    let mut count = 0u32;
    loop {
        count += 1;
        if count == 3 {
            println!("three");
            continue;  // 跳过本次迭代剩余部分
        }
        println!("{}", count);
        if count == 5 {
            println!("OK, that's enough");
            break;  // 退出循环
        }
    }
}

loop的一个强大特性是可以返回值：

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;  // 返回20
        }
    };
    assert_eq!(result, 20);
}

循环标签与嵌套控制

对于复杂的嵌套循环，Rust提供了标签系统：

fn main() {
    let mut count = 0;
    'outer: loop {
        'inner1: loop {
            if count >= 20 {
                break 'inner1;  // 只退出inner1
            }
            count += 2;
        }
        count += 5;
        'inner2: loop {
            if count >= 30 {
                break 'outer;  // 退出outer循环
            }
            continue 'outer;  // 继续outer循环
        }
    }
    assert!(count == 30);
}

标签语法允许精确控制多层嵌套循环的流程，这在复杂算法中非常有用。