分支结构

基础的多分支

与C系语言不同的是, if 的条件判断语句不需要 ()

fn main() {
    let os_name = "macOS";

    if os_name == "Windows" {
        println!("Windows");
    } else if os_name == "macOS" {
        println!("macOS");
    } else if os_name == "Linux" {
        println!("Linux");
    } else {
        println!("Unknown");
    }
}

从分支返回结果

与C系语言大不同的来了, 面向表达式编程, 可以很方便接收表达式的结果

fn main() {
    let os_name = "macOS";

    // 类似3元表达式, 但是确是使用 if else
    let is_mac = if os_name == "macOs" { "yes" } else { "no" };

    println!("is macOS:{}", is_mac);
}

循环结构

while

普通循环

fn main() {
    let mut i = 0;
    while i < 5 {
        println!("i={i}");
        i += 1;
    }
}

从表达式返回值

fn main() {
    let avg = {
        let mut i = 0;
        let mut sum = 0;
        while i < 5 {
            println!("i = {i}");
            sum += i;
            i += 1;
            // 注: 在rust中没有 ++ 这操作符号
            // 所以不能 i++ 和 ++i 操作
        }

        // 创建{}表达式, 最后一句将结果返回
        sum / i
    };

    // 看起来好像没有必要, 不使用 {} 表达式
    // 也可以直接拿到值, 这个代码为了演示可以这样操作
    println!("avg = {avg}");
}

for in

fn main() {
    // .. 操作符类似python的 range 函数
    // 1.创建一个列表
    // 2.包含开始(0),但是不包含结尾(5)
    for item in (0..5) {
        println!("item={item}");
    }
}

loop

fn main() {
    let mut i = 0;
    loop {
        // 默认就是无限循环, 只有使用 break 才会跳出循环
        i += 1;
        if i >= 5 {
            break;
        }
    }
    println!("sum");
}

表达式优先

或者叫 面向表达式编程, 这个概念书上没有提到, 但是对于习惯了语句优先的人来说, 转变这个思维很重要 像 C/Java/JavaScript 等语言, 都是基于 语句 来编程的, 而 Rust 在这一点上有些不同

fn main(){
    // 这是一个完整的赋值语句
    let x = 10;

    // 在其他语言中, 这可能是一个流程控制语句
    // 但在 Rust 中, 这是一个表达式, 是可以获取值的
    if x > 5 { 5 } else { x };
    println!("x={}", x);

    // 像这样获取值, 在其他 C-Like 的语言中肯定是不行的
    let y = if x > 5 { 5 } else { x };
    println!("y={}", y);

    // 当然也可以展开
    let x = 10;
    let s = if x < 15 {
        // 甚至可以这样操作:
        // 里面这个 if 没有加 ; 那么他会先计算出值然后给到外面
        // 的这个 if, 最后外面的 if 计算出值再赋值给 s
        if x % 2 == 0 {
            "less then 20, even"
        } else {
            "less then 20, odd"
        }
    } else {
        "big then 20"
    };
    println!("s={}", s);

    // 循环也可以这样操作, 从循环表达式中获取值
    let mut i = 0;
    let v = loop {
        if i == 5 {
            break i; // 注意要用 break 去返回循环表达式的值
        }
        i += 1;
    }; // 这样就变成了赋值语句, 所以最后必须要加;
    println!("v={}", v);

    // 如果只是循环控制流不用返回数据,可以不用加;
    // 就像这样:
    loop {
        if i == 10 {
            break;
        }
        i += 1;
    }

    // 不仅是 loop, while, for, if, match 都可以这样操作
    // 而且, 不仅是这些流程控制语句可以这样操作, 空的
    // 作用域都可以这样操作
    let value = {
        let x = 10;
        let y = 20;
        x + y
    };
    println!("value={}", value);

    // 所以在 Rust 中
    // 1. 表达式优先
    // 2. 行尾是否加 ; 是很重要的, 这决定了: 这行代码是完整的语句还是表达式
}

练习

实现相互转换摄氏与华氏温度函数

fn celsius_to_fahrenheit(celsius: i32) -> i32 {
     (celsius * 9/5) + 32
}

fn fahrenheit_to_celsius (fahrenheit: i32) -> i32 {
    (fahrenheit - 32) * 5 / 9
}

fn main() {
    let fa = celsius_to_fahrenheit(30);
    println!("fahrenheit = {fa}");

    let ce = fahrenheit_to_celsius(30);
    println!("celsius = {ce}");
}

生成第 n 个斐波那契数

fn fib(n: i32) -> i32 {
    if n < 1 {
        return n;
    }

    let mut i = 0;
    let mut a = 0;
    let mut b = 1;
    while i < n {
        let temp = a; // start from 0
        a = b;        // prev loop b value
        b += temp;    // curr loop b value
        i += 1;
    }
    a
}

fn main() {
    let x = fib(6);
    println!("x = {x}");
}