Rust 的流程控制機制是程式邏輯的核心，它決定了程式碼的執行順序。本文將深入探討 Rust 中的 For、While、Loop 和 Match 等關鍵字，並提供實際程式碼範例，幫助讀者理解如何在 Rust 中有效控制程式流程。For 迴圈是 Rust 中迭代集合的主要方式，可以直接迭代集合元素或使用索引迭代，同時需要注意集合的生命週期。While 迴圈則適用於根據特定條件重複執行程式碼塊，例如計時器或使用者輸入驗證。Loop 迴圈搭配 Break 關鍵字，常應用於需要持續執行的伺服器程式設計。Match 模式匹配提供更靈活的條件判斷方式，可以根據值的型別和值進行匹配，簡化複雜的條件判斷邏輯。
使用 is_finite() 方法進行防禦性程式設計
為了防止程式碼出現 NaN（Not a Number）或無限大的值，可以使用 is_finite() 方法進行檢查。以下程式碼示範瞭如何使用此方法：
fn main() {
let x: f32 = 1.0 / 0.0;
assert!(x.is_finite());
}
如果 x 的值不是有限的，則此程式碼將觸發一個斷言錯誤。
Mechanical Engineers 使用 j 而不是 i
在機械工程領域，複數通常使用 j 而不是 i 作為虛部單位。
流程控制和迴圈
在 Rust 中，程式的執行順序通常從上往下，但有時我們需要改變這個順序。Rust 提供了多種流程控制機制來實作這一點。本文將介紹 Rust 中的基本流程控制元素。
迴圈：For 迴圈
For 迴圈是 Rust 中迭代的核心。它可以用來迭代集合中的元素，包括可能無窮多的集合。基本的 For 迴圈語法如下：
for 元素 in 集合 {
//...
}
這種迴圈會將集合中的每個元素依次指定給 元素，使得你可以在迴圈體中使用它。
注意事項
當 For 迴圈結束後，集合就不再可用，即使它仍然在作用域中。這是因為 Rust 會在迴圈結束後立即結束集合的生命週期，以避免不必要的記憶體佔用。如果你需要在迴圈後繼續使用集合，應該使用參照。
安裝第三方函式庫
如果你需要使用第三方函式庫，可以使用 cargo add 命令來新增依賴項。首先，需要安裝 cargo-edit 套件：
$ cargo install cargo-edit
然後，你就可以使用 cargo add 命令來新增依賴項：
$ cargo add num
這將會新增 num 函式庫到你的 Cargo.toml 檔案中。
使用參照
如果你需要在 For 迴圈後繼續使用集合，應該使用參照。這可以避免 Rust 在迴圈結束後立即結束集合的生命週期。
Mermaid 圖表：For 迴圈流程
flowchart TD
A[開始] --> B[初始化集合]
B --> C[開始 For 迴圈]
C --> D[取得集合中的元素]
D --> E[執行迴圈體]
E --> F[是否結束迴圈]
F -->|是| G[結束]
F -->|否| D
圖表翻譯：
此圖表展示了 For 迴圈的流程。首先，初始化一個集合，然後開始 For 迴圈。在迴圈體中，取得集合中的元素，並執行迴圈體。當迴圈結束後，程式就會結束。
內容解密：
For 迴圈是 Rust 中的一種基本流程控制結構。它可以用來迭代集合中的元素，並執行迴圈體。在 For 迴圈中，集合中的每個元素都會被指定給一個變數，使得你可以在迴圈體中使用它。但是，當 For 迴圈結束後，集合就不再可用了。因此，如果你需要在迴圈後繼續使用集合，應該使用參照。
程式碼範例：
fn main() {
let vec = vec![1, 2, 3];
for elem in vec {
println!("{}", elem);
}
}
此程式碼範例展示瞭如何使用 For 迴圈來迭代一個向量中的元素，並列印預出每個元素的值。
使用Rust的for迴圈進行迭代
Rust的for迴圈是一種強大的工具，允許您輕鬆地迭代集合中的元素。以下是如何使用它：
基本語法
for item in &collection {
//...
}
在這個例子中，&collection是您想要迭代的集合，item是每次迭代的元素。
修改元素
如果您需要修改每個元素，您可以使用可變參照：
for item in &mut collection {
//...
}
匿名迴圈
當您不需要使用區域性變數時，可以使用底線（_）：
for _ in 0..10 {
//...
}
這種模式可以與_exclusive range syntax_（n..m）和_inclusive range syntax_（n..=m）結合使用，以表明您想要執行固定次數的迴圈。
避免管理索引變數
在許多程式語言中，常見的做法是透過遞增索引變數來迭代元素。Rust也提供了這種模式：
let collection = [1, 2, 3, 4, 5];
for i in 0..collection.len() {
let item = collection[i];
//...
}
但是，這種方法有兩個問題：效能和安全性。索引值會導致執行時檢查界限，而直接迭代集合可以讓編譯器在編譯時證明無效存取是不可行的。
簡寫等價
以下是for迴圈的簡寫等價：
for item in collection // 等價於 IntoIterator::into_iter(collection)
for item in &collection // 等價於 collection.iter()
for item in &mut collection // 等價於 collection.iter_mut()
流程控制
Rust的for迴圈也可以用於流程控制。以下是continue關鍵字的範例：
for n in 0..10 {
//...
continue;
//...
}
continue關鍵字可以用於跳過當前迭代的剩餘部分。
內容解密：
在上面的範例中，我們使用了for迴圈來迭代集合中的元素。for迴圈的基本語法是for item in &collection {... }，其中&collection是您想要迭代的集合，item是每次迭代的元素。
如果您需要修改每個元素，您可以使用可變參照：for item in &mut collection {... }。
匿名迴圈可以使用底線（_）來實作：for _ in 0..10 {... }。
避免管理索引變數是Rust的一個最佳實踐，因為它可以提高效能和安全性。
圖表翻譯：
flowchart TD
A[開始] --> B[迭代集合]
B --> C[修改元素]
C --> D[匿名迴圈]
D --> E[避免管理索引變數]
E --> F[流程控制]
F --> G[結束]
在這個圖表中，我們展示了Rust的for迴圈的不同用途，包括迭代集合、修改元素、匿名迴圈、避免管理索引變數和流程控制。
使用While迴圈進行迴圈運算
在程式設計中，迴圈是一種重要的控制結構，能夠讓程式重複執行某段程式碼。其中，While迴圈是一種常見的迴圈結構，能夠根據條件不斷執行程式碼。
While迴圈的基本結構
While迴圈的基本結構如下：
while 條件 {
// 程式碼
}
其中，條件是一個布林表示式，能夠傳回true或false。如果條件為true，則執行程式碼；如果條件為false，則離開迴圈。
While迴圈的應用
While迴圈可以用於許多場景，例如：
- 迴圈遍歷資料結構：While迴圈可以用於迴圈遍歷陣列、連結串列等資料結構。
- 實作計時器：While迴圈可以用於實作計時器，例如計算程式執行時間。
- 測試條件：While迴圈可以用於測試條件，例如檢查使用者輸入是否合法。
範例：使用While迴圈計算1秒內執行次數
以下是使用While迴圈計算1秒內執行次數的範例：
use std::time::{Duration, Instant};
fn main() {
let mut count = 0;
let time_limit = Duration::new(1, 0);
let start = Instant::now();
while (Instant::now() - start) < time_limit {
count += 1;
}
println!("{}", count);
}
在這個範例中，我們使用While迴圈計算1秒內執行次數。我們首先初始化一個計數器count，然後設定一個時間限制time_limit為1秒。接著，我們使用While迴圈不斷執行計數器自增操作，直到時間限制被達到。最後，我們列印預出計數器的值，即1秒內執行次數。
內容解密：
let mut count = 0;：初始化一個計數器count，初始值為0。let time_limit = Duration::new(1, 0);：設定一個時間限制time_limit為1秒。let start = Instant::now();：記錄當前時間作為起始時間。while (Instant::now() - start) < time_limit {：使用While迴圈不斷執行計數器自增操作，直到時間限制被達到。count += 1;：計數器自增操作。println!("{}", count);：列印預出計數器的值，即1秒內執行次數。
圖表翻譯：
graph LR
A[初始化計數器] --> B[設定時間限制]
B --> C[記錄起始時間]
C --> D[While迴圈]
D --> E[計數器自增]
E --> F[檢查時間限制]
F -->|達到時間限制| G[列印計數器值]
F -->|未達到時間限制| D
在這個圖表中，我們展示了While迴圈的流程。首先，我們初始化一個計數器，然後設定一個時間限制。接著，我們記錄當前時間作為起始時間。然後，我們使用While迴圈不斷執行計數器自增操作，直到時間限制被達到。最後，我們列印預出計數器的值，即1秒內執行次數。
Rust 的迴圈控制
Rust 提供了多種迴圈控制結構，包括 while、loop 和 break。在本文中，我們將探討如何使用這些結構來控制程式的流程。
避免無窮迴圈
大多數 Rust 程式設計師會避免使用以下的無窮迴圈：
while true {
println!("Are we there yet?");
}
相反，他們更喜歡使用 loop 關鍵字來實作無窮迴圈。
Loop：基礎迴圈結構
Rust 的 loop 關鍵字提供了一種更為靈活的迴圈控制方式。loop 會不斷地執行一個程式碼區塊，直到遇到 break 關鍵字或程式被終止。
loop {
//...
}
loop 常被用於實作長時間執行的伺服器，例如：
loop {
let (requester, request) = accept_request();
let result = process_request(request);
send_response(requester, result);
}
Break：終止迴圈
break 關鍵字可以用來終止一個迴圈。在 Rust 中，break 的行為與其他語言相似：
for (x, y) in (0..).zip(0..) {
if x + y > 100 {
break;
}
//...
}
從巢狀迴圈中跳出
您可以使用迴圈標籤 (loop label) 來從巢狀迴圈中跳出。迴圈標籤是一個以撇號 (') 開頭的識別符，例如：
'outer: for x in 0.. {
for y in 0.. {
//...
}
}
內容解密：
在上面的程式碼中，我們使用 loop 關鍵字來實作無窮迴圈，並使用 break 關鍵字來終止迴圈。同時，我們也使用了迴圈標籤 ('outer) 來從巢狀迴圈中跳出。
圖表翻譯：
flowchart TD
A[開始] --> B[迴圈開始]
B --> C[執行程式碼]
C --> D[檢查條件]
D -->|是| E[終止迴圈]
D -->|否| B
E --> F[結束]
在這個圖表中，我們展示了迴圈的流程：從開始到執行程式碼，然後檢查條件，如果條件滿足則終止迴圈，否則繼續執行程式碼。
條件控制流程與表示式
Rust 作為一種現代的程式語言，提供了多種控制流程的方式，包括 if、if else、else 等，用於根據條件執行不同的程式碼塊。另外，Rust 還是一種根據表示式的語言，這意味著幾乎所有的陳述式都會傳回一個值。
條件控制流程
if 陳述式是最基本的條件控制流程，它根據給定的條件決定是否執行某個程式碼塊。例如：
let x = 5;
if x > 10 {
println!("x 大於 10");
} else {
println!("x 小於或等於 10");
}
在這個例子中，如果 x 大於 10，則會列印 “x 大於 10”，否則會列印 “x 小於或等於 10”。
if else 陳述式
當需要根據多個條件執行不同的程式碼塊時，可以使用 if else 陳述式。例如：
let x = 5;
if x > 10 {
println!("x 大於 10");
} else if x == 5 {
println!("x 等於 5");
} else {
println!("x 小於 5");
}
在這個例子中，如果 x 大於 10，則會列印 “x 大於 10”；如果 x 等於 5，則會列印 “x 等於 5”；否則會列印 “x 小於 5”。
Rust 的布林值
Rust 的布林值只有兩個：true 和 false。與其他語言不同，Rust 不允許使用數字或字串等其他型別的值作為布林值。
根據表示式的語言
Rust 是一種根據表示式的語言，這意味著幾乎所有的陳述式都會傳回一個值。例如：
fn is_even(n: i32) -> bool {
n % 2 == 0
}
在這個例子中，is_even 函式傳回一個布林值，表示輸入的數字是否為偶數。
使用 if 作為表示式
Rust 還允許使用 if 作為表示式。例如：
let n = 123456;
let description = if is_even(n) {
"even"
} else {
"odd"
};
println!("{} is {}", n, description);
在這個例子中，if 陳述式作為一個表示式，傳回一個字串值，該值根據 n 的奇偶性而定。
使用 match 作為表示式
Rust 還允許使用 match 作為表示式。例如：
let n = 654321;
let description = match is_even(n) {
true => "even",
false => "odd",
};
println!("{} is {}", n, description);
在這個例子中，match 陳述式作為一個表示式，傳回一個字串值，該值根據 n 的奇偶性而定。
圖表翻譯：
graph LR
A[輸入數字] --> B{判斷奇偶}
B -->|偶數| C[傳回 "even"]
B -->|奇數| D[傳回 "odd"]
C --> E[列印結果]
D --> E
在這個圖表中，我們可以看到輸入數字後，會根據其奇偶性傳回不同的字串值，並最終列印預出結果。
Rust 的控制流和模式匹配
Rust 的控制流是程式的骨架，它決定了程式的執行順序和邏輯。控制流包括條件判斷、迴圈和函式呼叫等。在 Rust 中，控制流可以使用 if、else、loop、while 和 match 等關鍵字來實作。
條件判斷
Rust 的條件判斷使用 if 和 else 關鍵字。例如：
let x = 5;
if x > 10 {
println!("x is greater than 10");
} else {
println!("x is less than or equal to 10");
}
迴圈
Rust 的迴圈可以使用 loop、while 和 for 關鍵字。例如：
let mut i = 0;
loop {
println!("i is {}", i);
i += 1;
if i >= 10 {
break;
}
}
模式匹配
Rust 的模式匹配使用 match 關鍵字。模式匹配可以根據值的型別和值進行匹配。例如：
let x = 5;
match x {
0 => println!("x is 0"),
1..=5 => println!("x is between 1 and 5"),
_ => println!("x is greater than 5"),
}
在上面的例子中，match 會根據 x 的值進行匹配。如果 x 等於 0，則會執行第一個分支。如果 x 在 1 到 5 之間，則會執行第二個分支。否則，會執行第三個分支。
匹配型別
Rust 的模式匹配可以匹配多種型別的值，包括：
- 數值：可以使用
=運運算元進行匹配。 - 範圍：可以使用
..=運運算元進行匹配。 - 列表：可以使用
|運運算元進行匹配。 - 下劃線 (
_)：可以匹配任何值。
傳回值
Rust 的 match 會傳回一個值，如果沒有指定傳回值，則會傳回 ()（單位型別）。
非表示式
Rust 中的非表示式包括：
- 以
;結尾的表示式。 - 使用
=運運算元繫結名稱到值的宣告。 - 使用
fn、struct和enum關鍵字建立的型別宣告。
這些非表示式不會傳回任何值。
單位型別
Rust 的單位型別 (()) 是一個特殊的型別，它不包含任何值。它通常用於表示一個函式或方法沒有傳回值。
瞭解Rust中的match關鍵字
在Rust程式設計語言中，match關鍵字是一個非常重要的控制結構。它允許你根據不同的值或模式來執行不同的程式碼。下面是一個簡單的範例，展示瞭如何使用match來匹配一個值：
fn main() {
let needle = 42;
let haystack = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862];
for item in &haystack {
let result = match item {
42 | 132 => "hit!",
_ => "miss",
};
if result == "hit!" {
println!("{}: {}", item, result);
}
}
}
在這個範例中，match關鍵字被用來匹配item的值。如果item的值是42或132，則result將被指定為"hit!"，否則將被指定為"miss"。
match關鍵字的工作原理
match關鍵字的工作原理是根據提供的值或模式來執行不同的程式碼。它可以被用來匹配多種不同的值或模式，包括：
- 具體值：如上面的範例中，匹配42和132這兩個具體值。
- 範圍：可以使用
..=或..來匹配一個範圍的值。 - 列表：可以使用
,來分隔多個值。 - 模式：可以使用模式來匹配複雜的結構，如元組或列舉。
從程式碼效能與可維護性角度來看，Rust 的流程控制機制展現了其獨特的設計哲學。本文深入探討了 for 迴圈、while 迴圈、loop 關鍵字以及 match 模式匹配，並分析了它們在不同場景下的應用與優劣。Rust 強調安全性與效能，for 迴圈藉由迭代器模式有效避免了索引錯誤並提升了執行效率；while 迴圈則提供了更通用的條件迴圈控制；而 loop 與 break 的組合則適用於需要精細控制迴圈終止條件的場景。match 模式匹配則以其簡潔優雅的語法和窮盡匹配的特性，大幅提升了程式碼的可讀性和安全性，減少了傳統 if-else 鏈式判斷可能帶來的錯誤。然而，match 的模式設計需要仔細考量，避免過於複雜的模式降低程式碼可維護性。展望未來，隨著 Rust 語言的持續發展，預計其流程控制機制將會更加完善，並與非同步程式設計、錯誤處理等特性更緊密地結合，為開發者提供更強大且安全的程式碼編寫體驗。對於追求高效能且注重程式碼品質的開發者而言，Rust 的流程控制機制值得深入學習和應用。玄貓認為，Rust 的嚴謹性與表達力使其在系統程式設計、嵌入式開發等領域具有顯著優勢，並將在未來持續影響程式設計正規化。
