rust学习笔记(4)

流程控制

if

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

if 语句也可以作为变量计算的代码块

    let big_n =
        if n < 10 && n > -10 {
            println!(", and is a small number, increase ten-fold");

            // 这个表达式返回一个 `i32` 类型。
            10 * n
        } else {
            println!(", and is a big number, half the number");

            // 这个表达式也必须返回一个 `i32` 类型。
            n / 2
            // 试一试 ^ 试着加上一个分号来结束这条表达式。
        };
    //   ^ 不要忘记在这里加上一个分号！所有的 `let` 绑定都需要它。

loop

    // 无限循环
    loop {
        count += 1;

        if count == 3 {
            println!("three");

            // 跳过这次迭代的剩下内容
            continue;
        }

        println!("{}", count);

        if count == 5 {
            println!("OK, that's enough");

            // 退出循环
            break;
        }
    }

默认是无线循环, 需要手动break

嵌套loop

loop可以嵌套, 在嵌套的时候可以给每个loop打上对应的标签

标签可以用来识别是哪个loop, 这可以帮助 break 和 continue

#![allow(unreachable_code)]

fn main() {
    'outer: loop {
        println!("Entered the outer loop");

        'inner: loop {
            println!("Entered the inner loop");

            // 这只是中断内部的循环
            //break;

            // 这会中断外层循环
            break 'outer;
        }

        println!("This point will never be reached");
    }

    println!("Exited the outer loop");
}

break返回值

在loop中可以使用break返回值

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    assert_eq!(result, 20);
}

while

一个带上条件的循环, 写作为 while n < 101 {

for

    // `n` 将在每次迭代中分别取 1, 2, ..., 100
    for n in 1..101 {

不包含101

for n in 1..=100 {

包含100

迭代器

可以和迭代器进行操作

使用iter和iter_mut函数, 采用借用的方式

fn main() {
    let names = vec!["Bob", "Frank", "Ferris"];

    for name in names.iter() {
        match name {
            &"Ferris" => println!("There is a rustacean among us!"),
            _ => println!("Hello {}", name),
        }
    }
}

• into_iter 函数会消耗元素, 这不是借用, 用了之后就丢失了

match

匹配变量的情况选择对应的分支

这个代码可以用来作为处理异常的情况

    let num = 13;
    print!("{} 是", num);
    match num % 2 {
        0 => {
            println!("偶数")
        }
        1 => println!("奇数"),
        _ => println!("未知"),
    }

使用 | 作为或者操作符

使用 _ 用来处理其他情况

可以使用范围操作符

变量赋值

    let binary = match boolean {
        // match 分支必须覆盖所有可能的值
        false => 0,
        true => 1,
        // 试一试 ^ 将其中一条分支注释掉
    };

可以用来快速赋值

解构

    let triple = (0, -2, 3);
    // 试一试 ^ 将不同的值赋给 `triple`

    println!("Tell me about {:?}", triple);
    // match 可以解构一个元组
    match triple {
        // 解构出第二个和第三个元素
        (0, y, z) => println!("First is `0`, `y` is {:?}, and `z` is {:?}", y, z),
        (1, ..)  => println!("First is `1` and the rest doesn't matter"),
        // `..` 可用来忽略元组的其余部分
        _      => println!("It doesn't matter what they are"),
        // `_` 表示不将值绑定到变量
    }

因为元组被解构之后可以作为匹配的条件

enum

可以用来操作枚举类, 比如处理异常

枚举类内部是可以携带值的

引用

    match reference {
        // 如果用 `&val` 这个模式去匹配 `reference`，就相当于做这样的比较：
        // `&i32`（译注：即 `reference` 的类型）
        // `&val`（译注：即用于匹配的模式）
        // ^ 我们看到，如果去掉匹配的 `&`，`i32` 应当赋给 `val`。
        // 译注：因此可用 `val` 表示被 `reference` 引用的值 4。
        &val => println!("Got a value via destructuring: {:?}", val),
    }

guard

fn main() {
    let pair = (2, -2);
    // 试一试 ^ 将不同的值赋给 `pair`

    println!("Tell me about {:?}", pair);
    match pair {
        (x, y) if x == y => println!("These are twins"),
        // ^ `if` 条件部分是一个卫语句
        (x, y) if x + y == 0 => println!("Antimatter, kaboom!"),
        (x, _) if x % 2 == 1 => println!("The first one is odd"),
        _ => println!("No correlation..."),
    }
}

可以使用 if 语句帮助进行条件选择

other

有一些类似 if let 和 while let 的运算符不赘述, 为了减少嵌套和使得代码更加美观的操作不是必须的