1.if表達式

if 表達式允許根據條件執行不同的代碼分支, 以下代碼是一個典型的使用if表達式的例子:

fn main() {
    let number = 3;
    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

所有的 if 表達式都以 if 關鍵字開頭，其后跟一個條件。在這個例子中，條件檢查變量 number 的值是否小于 5。在條件為 true 時希望執行的代碼塊位于緊跟條件之后的大括號中。

也可以包含一個可選的 else 表達式來提供一個在條件為 false 時應當執行的代碼塊，如果不提供 else 表達式并且條件為 false 時，程序會直接忽略 if 代碼塊并繼續執行下面的代碼。

嘗試運行該代碼, 會得到以下結果:

嘗試改變 number 的值使條件為 false 時看看會發生什么：

let number = 7;

再次運行程序并查看輸出：

另外值得注意的是代碼中的條件 必須 是 bool 值。如果條件不是 bool 值，我們將得到一個錯誤。

嘗試修改代碼:

fn main() {
    let number = 3;
    if number {
        println!("number was three");
    }
}

這里 if 條件的值是 3，Rust 拋出了一個錯誤：

這個錯誤表明 Rust 期望一個 bool 卻得到了一個整數。不像 Ruby 或 JavaScript 這樣的語言，Rust 并不會嘗試自動地將非布爾值轉換為布爾值。必須總是顯式地使用布爾值作為 if 的條件。例如，如果想要 if 代碼塊只在一個數字不等于 0 時執行，可以把 if 表達式修改成下面這樣：

fn main() {
    let number = 3;
    if number != 0 {
        println!("number was something other than zero");
    }
}

運行代碼會打印出 number was something other than zero。

2.使用else if處理多重條件

可以將 else if 表達式與 if 和 else 組合來實現多重條件。看以下代碼:

fn main() {
    let number = 6;
    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

這個程序有四個可能的執行路徑。運行后應該能看到如下輸出：

當執行這個程序時，它按順序檢查每個 if 表達式并執行第一個條件為 true 的代碼塊。注意即使 6 可以被 2 整除，也不會輸出 number is divisible by 2，更不會輸出 else 塊中的 number is not divisible by 4, 3, or 2。原因是 Rust 只會執行第一個條件為 true 的代碼塊，并且一旦它找到一個以后，甚至都不會檢查剩下的條件了。

使用過多的 else if 表達式會使代碼顯得雜亂無章，所以如果有多于一個 else if 表達式，最好重構代碼。

3.在let語句中使用if

因為 if 是一個表達式，我們可以在 let 語句的右側使用它, 例如:

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("The value of number is: {number}");
}

number 變量將會綁定到表示 if 表達式結果的值上, 運行一下查看結果:

記住，代碼塊的值是其最后一個表達式的值，而數字本身就是一個表達式。在這個例子中，整個 if 表達式的值取決于哪個代碼塊被執行。這意味著 if 的每個分支的可能的返回值都必須是相同類型；

if 分支和 else 分支的結果都是 i32 整型。如果它們的類型不匹配會發生什么?,嘗試修改代碼:

fn main() {
    let condition = true;
    let number = if condition { 5 } else { "six" };
    println!("The value of number is: {number}");
}

當編譯這段代碼時，會得到一個錯誤。if 和 else 分支的值類型是不相容的，同時 Rust 也準確地指出在程序中的何處發現的這個問題,如圖:

if 代碼塊中的表達式返回一個整數，而 else 代碼塊中的表達式返回一個字符串。這不可行，因為變量必須只有一個類型。Rust 需要在編譯時就確切的知道 number 變量的類型，這樣它就可以在編譯時驗證在每處使用的 number 變量的類型是有效的。如果number的類型僅在運行時確定，則 Rust 無法做到這一點；且編譯器必須跟蹤每一個變量的多種假設類型，那么它就會變得更加復雜，對代碼的保證也會減少。

4.使用循環重復執行

多次執行同一段代碼是很常用的，Rust 為此提供了多種 循環（loops）。一個循環執行循環體中的代碼直到結尾并緊接著回到開頭繼續執行。

Rust 有三種循環：loop、while 和 for。

loop 關鍵字告訴 Rust 一遍又一遍地執行一段代碼直到你明確要求停止。

fn main() {
    loop {
        println!("again!");
    }
}

當運行這個程序時，我們會看到連續的反復打印 again!，直到我們手動停止程序。大部分終端都支持一個快捷鍵，ctrl-c，來終止一個陷入無限循環的程序。Rust跟其它高級語言一樣,葉提供了break關鍵字停止循環,使用continue關鍵字告訴程序跳過這個循環迭代中的任何剩余代碼，并轉到下一個迭代。

loop 的一個用例是重試可能會失敗的操作，比如檢查線程是否完成了任務。然而你可能會需要將操作的結果傳遞給其它的代碼。如果將返回值加入你用來停止循環的 break 表達式，它會被停止的循環返回, 看看下面的代碼:

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("The result is {result}");
}

在循環之前，我們聲明了一個名為 counter 的變量并初始化為 0。接著聲明了一個名為 result 來存放循環的返回值。在循環的每一次迭代中，我們將 counter 變量加 1，接著檢查計數是否等于 10。當相等時，使用 break 關鍵字返回值 counter * 2。循環之后，我們通過分號結束賦值給 result 的語句。最后打印出 result 的值，也就是 20。

如果存在嵌套循環，break 和 continue 應用于此時最內層的循環。你可以選擇在一個循環上指定一個 循環標簽（loop label），然后將標簽與 break 或 continue 一起使用，使這些關鍵字應用于已標記的循環而不是最內層的循環。看以下代碼:

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;
        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }
        count += 1;
    }
    println!("End count = {count}");
}

外層循環有一個標簽 counting_up，它將從 0 數到 2。沒有標簽的內部循環從 10 向下數到 9。第一個沒有指定標簽的 break 將只退出內層循環。break 'counting_up; 語句將退出外層循環。運行結果如下:

5.while循環

在程序中計算循環的條件也很常見。當條件為 true，執行循環。當條件不再為 true，調用 break 停止循環。這個循環類型可以通過組合 loop、if、else 和 break 來實現。然而，這個模式太常用了，Rust 為此內置了一個語言結構，它被稱為 while 循環。看以下代碼:

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;
    while index < 5 {
        println!("the value is: {}", a[index]);
        index += 1;
    }
}

這里，代碼對數組中的元素進行計數。它從索引 0 開始，并接著循環直到遇到數組的最后一個索引（這時，index < 5 不再為真）。運行這段代碼會打印出數組中的每一個元素,如圖:

數組中的所有五個元素都如期被打印出來。盡管 index 在某一時刻會到達值 5，不過循環在其嘗試從數組獲取第六個值（會越界）之前就停止了。

但這個過程很容易出錯；如果索引長度或測試條件不正確會導致程序 panic。例如，如果將 a 數組的定義改為包含 4 個元素而忘記了更新條件 while index < 4，則代碼會 panic。這也使程序更慢，因為編譯器增加了運行時代碼來對每次循環進行條件檢查，以確定在循環的每次迭代中索引是否在數組的邊界內。

作為更簡潔的替代方案，可以使用 for 循環來對一個集合的每個元素執行一些代碼。改造后的代碼如下:

fn main() {
    let a = [10, 20, 30, 40, 50];
    for element in a {
        println!("the value is: {element}");
    }
}

當運行這段代碼時，將看到與while循環中一樣的輸出。更為重要的是，我們增強了代碼安全性，并消除了可能由于超出數組的結尾或遍歷長度不夠而缺少一些元素而導致的 bug。

for 循環的安全性和簡潔性使得它成為 Rust 中使用最多的循環結構。下面是一個使用 for 循環來倒計時的例子，它還使用了一個方法，rev，用來反轉 range：

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

執行結果如圖:

是不是感覺有點點帥氣了?