Rust 教學：`if let` 與 `while let` 的使用與實務應用

簡介

在 Rust 中，列舉（enum） 搭配**模式匹配（pattern matching）**是處理多樣資料型別的核心工具。傳統的 match 表達式功能完整，但在只需要關注單一變體時，寫起來會顯得冗長。這時，if let 與 while let 兩個語法糖就派上用場，讓程式碼更簡潔、可讀性更高。

本篇文章將深入說明 if let 與 while let 的語法、背後的原理，以及在日常開發中如何正確、有效地使用它們。文章適合 初學者 了解概念，也提供 中級開發者 在實務專案中避免常見陷阱的最佳實踐。

核心概念

1. 為什麼需要 `if let` / `while let`

match 必須列舉所有可能的變體，或使用 _ 佔位符。當我們只關心單一變體，而其他變體的處理僅是「不做任何事」時，match 會變得冗長：

match option {
    Some(v) => println!("Got {}", v),
    _ => {}
}

if let 正是為了簡化這類情況而設計，只匹配一個模式，其他情況自動忽略。while let 則是把同樣的概念延伸到迴圈，讓程式在條件成立時持續執行。

2. `if let` 的語法與運作

基本語法：

if let <Pattern> = <Expression> {
    // 匹配成功的程式區塊
} else {
    // 可選的 else 區塊
}

<Pattern>：要匹配的模式（例如 Some(x)、Ok(v)、MyEnum::Variant {..}）。
<Expression>：產生值的表達式，通常是 Option、Result 或自訂的列舉。
只有在模式匹配成功時，才會執行大括號內的程式碼。

範例 1：從 `Option` 取值

let maybe_name = Some("Alice");

// 只在有值時印出名字
if let Some(name) = maybe_name {
    println!("Hello, {}!", name);
} else {
    println!("No name found.");
}

重點：maybe_name 的所有權仍屬於外部，if let 只會借用（若模式使用 &）或搬走（若模式使用 Some(name)）對應的值。

範例 2：處理 `Result` 的錯誤資訊

fn parse_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    s.parse()
}

let input = "42a";

if let Err(e) = parse_number(input) {
    eprintln!("解析失敗：{}", e);
}

此例只在錯誤時執行錯誤處理，成功的情況自動忽略。

範例 3：自訂列舉的部分匹配

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

let msg = Message::Move { x: 10, y: 20 };

if let Message::Move { x, .. } = msg {
    println!("移動到 x = {}", x);   // 只關心 x，y 用 .. 忽略
}

.. 表示「其餘欄位不關心」，讓模式更簡潔。

3. `while let` 的語法與運作

while let 把 if let 的概念放入迴圈，只要模式匹配成功就持續執行，一旦失敗即跳出迴圈。

基本語法：

while let <Pattern> = <Expression> {
    // 每次匹配成功的程式區塊
}

範例 4：從迭代器中取出元素

let mut numbers = vec![1, 2, 3].into_iter();

while let Some(num) = numbers.next() {
    println!("取出 {}", num);
}

只要 next() 回傳 Some，迴圈就會繼續；回傳 None 時自動結束。

範例 5：使用 `Option` 逐步消耗

let mut opt = Some(0);

while let Some(v) = opt {
    println!("目前值 {}", v);
    if v >= 3 {
        opt = None; // 終止迴圈
    } else {
        opt = Some(v + 1);
    }
}

這個範例展示了 在迴圈內改變條件 的技巧。

範例 6：從 `Result` 流式處理

let mut lines = std::io::BufReader::new(std::io::stdin()).lines();

while let Some(Ok(line)) = lines.next() {
    if line == "quit" {
        break;
    }
    println!("你輸入了：{}", line);
}

只要讀到的行是 Ok，就持續處理；遇到 Err 或 EOF（None）則自動停止。

4. `if let` / `while let` 與 `match` 的比較

需求	建議使用	範例
必須處理所有變體（包括錯誤）	`match`	`match result { Ok(v) => ..., Err(e) => ... }`
只關心單一變體，其他直接忽略	`if let` / `while let`	`if let Some(v) = opt { ... }`
需要在匹配失敗時執行其他程式碼	`if let … else`	`if let Err(e) = res { … } else { … }`
需要在條件成立時持續執行	`while let`	`while let Some(v) = iter.next() { … }`

常見陷阱與最佳實踐

忘記處理所有權
- if let Some(v) = opt 會搬走 opt 內的值，之後 opt 變成 None。若仍需要使用原始 opt，請改用 if let Some(ref v) = opt（借用）或 if let Some(v) = &opt（模式匹配借用）。
過度使用 if let 造成可讀性下降
- 雖然 if let 簡潔，但若同一段程式需要同時處理多個變體，還是應該使用 match，避免多層嵌套的 if let。
while let 可能產生無限迴圈
- 確保在迴圈內有 明確的終止條件（例如更新迭代器、改變 Option 的值），否則會因為模式永遠匹配而卡住。
使用 .. 忽略欄位時要小心
- .. 只會忽略 未被綁定 的欄位，若欄位有 Copy 或 Clone 限制，仍可能觸發不必要的搬移或複製。
在 while let 中使用 break/continue 時的可讀性
- 若迴圈內有多個分支需要提前結束，建議將條件抽離成函式或使用 match 包裝，以提升程式的結構清晰度。

最佳實踐

只在需要「單一」匹配且其他情況不需要額外處理時使用 if let。
在迭代器或流式資料處理時，首選 while let，因為它天然配合 Option/Result 的 next()/read_line() 介面。
保持一致的錯誤處理風格：若專案中大量使用 Result，建議在公共入口點使用 match，而在局部僅需忽略成功結果時使用 if let Err(e) = …。
使用 ref 或 & 來避免不必要的所有權搬移，尤其在大型結構或 String、Vec 等資料上。

實際應用場景

1. 解析指令列參數

在 CLI 程式中，常會使用 std::env::args() 產生的迭代器。配合 while let 可以簡潔地遍歷所有參數：

let mut args = std::env::args().skip(1); // 跳過程式名稱

while let Some(arg) = args.next() {
    match arg.as_str() {
        "--help" => {
            print_help();
            return;
        }
        "--verbose" => {
            set_verbose(true);
        }
        _ => {
            eprintln!("未知參數: {}", arg);
        }
    }
}

2. 網路資料的逐行讀取

在處理 TCP 流或檔案時，常以 BufRead::lines() 取得 Iterator<Item = Result<String, io::Error>>。while let 能直接過濾成功的行：

use std::io::{self, BufRead};

let stdin = io::stdin();
let mut lines = stdin.lock().lines();

while let Some(Ok(line)) = lines.next() {
    if line.trim() == "exit" {
        break;
    }
    process_line(&line);
}

3. GUI 事件迴圈（簡化版）

在簡易的事件驅動模型中，事件列可能是 Option<Event>，每次取出後處理：

enum Event {
    Click(i32, i32),
    KeyPress(char),
    Quit,
}

let mut event_queue: Vec<Event> = vec![
    Event::Click(10, 20),
    Event::KeyPress('a'),
    Event::Quit,
];

while let Some(event) = event_queue.pop() {
    match event {
        Event::Click(x, y) => println!("點擊座標 ({}, {})", x, y),
        Event::KeyPress(c) => println!("按下鍵位 '{}'", c),
        Event::Quit => {
            println!("結束程式");
            break;
        }
    }
}

while let Some(event) = … 讓事件迴圈的結構與「只要有事件就處理」的語意高度對應。

總結

if let 與 while let 是 模式匹配 的語法糖，專為「只關心單一變體」的情況設計，讓程式碼更簡潔、可讀。
if let 適用於 條件式 判斷；while let 則把相同概念帶入迴圈，常見於迭代器、流式 I/O、事件驅動等場景。
正確掌握 所有權與借用 的差異，避免不必要的搬移或所有權喪失。
在實務開發中，根據需求選擇 match、if let、while let，保持程式碼的可讀性與一致性。

透過本篇的概念說明與實作範例，你應該已能在自己的 Rust 專案中自信地使用 if let 與 while let，寫出更乾淨、更符合 Rust 思維的程式碼。祝你寫程式愉快，持續探索 Rust 的強大特性！

Rust 教學：if let 與 while let 的使用與實務應用

簡介

核心概念

1. 為什麼需要 if let / while let

2. if let 的語法與運作

範例 1：從 Option 取值

範例 2：處理 Result 的錯誤資訊