流程控制

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 的運算符不贅述, 為了減少嵌套和使得代碼更加美觀的操作不是必須的

總結

以上是生活随笔為你收集整理的rust学习笔记(4)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。