從零開始學 Rust

你好！這篇教學的主要目的是讓完全沒寫過程式的初學者理解 Rust 這個程式語言中的各種概念。雖然網路上已經有很多 Rust 的教學了，但以前的教學似乎都是寫給已經會至少另一個程式語言的學習者，因此我希望這份教學能填補這樣的空白。Rust 這個語言有著很鮮明的特色，Rust 的功能強大，用 Rust 寫的程式執行效率也高，並且使用 Rust 的時候，還更容易在寫程式初期提早發現錯誤。大家都聽過的 C++ 雖然同樣也是功能強大且執行效率高，但在安全性上頭卻做了不少犧牲。因為 Rust 如上所述的特性，Rust 也在這個以 AI 寫程式的時代扮演著舉足輕重的地位。

這份教學的思路也因此比較符合目前 AI 時代的開發流程，教學中並不會提供各種「作業」，認為你一定要能寫出特定規格的算法。取而代之的是，這份教學會讓你有辦法讀懂 Rust 的程式大概在做什麼，也希望能讓你理解一個真正軟體的架構是怎麼被設計出來的。甚至我會說，如果你懶得使用電腦的話，單單閱讀本教學而不實際執行程式來學習 Rust 也是一個可行的方式。

儘管如此，我還是建議學習者一章一章閱讀本教學，如果你有靜態語言的基礎，你或許可以跳過第一章，但我更推薦的方法還是簡單花幾分鐘掃過第一章之後再往後繼續閱讀。如果是初學者就更不用說了。當然，要是你不怕漏掉什麼內容的話，你也可以直接跳到有興趣的部分看，或者是使用搜尋功能提前閱讀教學後面才給的解釋，這些都是可行的做法。啊對了，文中有章附錄一，雖然叫作附錄但也建議讀者能全部觀看。

未來我可能會再提供一份文件當作補充教材，讓讀者在遇到無法解決的問題或想實作一些作業的時候使用，但目前我還沒有撰寫那份文件。因此，讀者有可能會想要自創一些問題，或者直接問 AI 有沒有適合你程度的題目，這也都只是依你學習的方法和目標而定。

最後提一下一件事，不然怕沒人知道：你可以直接在教學裡面跑程式。文內程式原始碼的右上角有幾個按鈕，按了就知道會發生什麼事了。大概先這樣吧……

本教學除大綱與校對外，大部分由 AI 完成：

• 模型：Claude 4.5 / 4.6 / 4.7
• 馬具：OpenClaw / Claude Code

基礎

安裝 Rust

本集目標

把 Rust 裝到你的電腦上，確認它可以用。

正文

哈囉！歡迎來到 Rust 教學系列！

今天是第一集，我們什麼程式都還不寫，先把工具裝好就好。就像你要煮菜，總得先有鍋子對吧？

安裝 rustup

Rust 有一個官方的安裝工具叫 rustup，它會幫你把所有需要的東西一次裝好。

打開你的瀏覽器，去這個網址：

https://rustup.rs

• Windows 使用者：下載 rustup-init.exe，雙擊執行，然後一路按 Enter 選預設就好
• Mac / Linux 使用者：打開終端機（Terminal），貼上這行指令：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

它會問你要不要用預設設定，直接按 Enter 就好。

確認安裝成功

裝完之後，重新打開一個終端機（這很重要，舊的終端機可能還抓不到），然後輸入：

rustc --version

如果你看到類似這樣的東西：

rustc 1.XX.X (xxxxxxx 20XX-XX-XX)

恭喜你！Rust 已經裝好了！

rustc 就是 Rust 的編譯器，它負責把你寫的程式碼變成電腦能執行的東西。至於什麼是編譯器，之後我們慢慢聊，現在你只要知道「裝好了、能用了」就夠了。

重點整理

• 用 rustup 安裝 Rust，它會幫你把所有需要的工具一次裝好
• 安裝完要重新開終端機，再用 rustc --version 確認安裝成功
• rustc 是 Rust 的編譯器，負責把程式碼轉成電腦能執行的東西

第一個程式

本集目標

用 Cargo 建立專案，跑出你人生中第一個 Rust 程式。

正文

上一集我們裝好了 Rust，今天就來寫第一個程式吧！

用 Cargo 建立專案

Rust 有一個超好用的工具叫 Cargo，它是 Rust 的專案管理工具。你可以把它想成一個管家，幫你整理程式碼、編譯、執行，全部包辦。

打開終端機，輸入：

cargo new hello

這會幫你建立一個叫 hello 的資料夾，裡面已經幫你準備好了基本的檔案結構。

用 VS Code 打開

接著用 VS Code（或你喜歡的編輯器）打開這個 hello 資料夾。你會看到兩個重要的東西：

1. Cargo.toml — 這是專案的設定檔，記錄你的專案叫什麼名字、用什麼版本之類的。現在不用管它，知道有這個檔案就好。

2. src/main.rs — 這就是你的程式碼！打開來看看：

fn main() {
    println!("Hello, world!");
}

這就是 Rust 自動幫你生成的第一個程式。fn main() 是程式的入口點，所有程式都從這裡開始跑。println! 是印東西到螢幕上的指令。我們在第一章裡面暫時都只會在 fn main() 後面接的大括號裡面寫程式。

什麼是編譯？

在跑程式之前，先來了解一個重要概念。

我們寫的 .rs 檔案是給人看的程式碼，電腦其實看不懂。所以需要一個翻譯的過程，把我們寫的程式碼變成電腦能直接執行的檔案——這個翻譯的過程就叫做編譯（compile）。

負責做這件事的工具叫做編譯器（compiler），Rust 的編譯器就是上一集安裝的 rustc。

好消息是，你不需要自己去呼叫 rustc，等一下用的 cargo run 會自動幫你編譯再執行，一步搞定。

執行看看

回到終端機，先進入 hello 資料夾：

cd hello

然後輸入：

cargo run

你應該會看到螢幕上印出：

Hello, world!

太棒了！你的第一個 Rust 程式成功跑起來了！

改一下再跑

現在回到 VS Code，把 println! 裡面的文字改成：

fn main() {
    println!("Hello, Rust!");
}

存檔，再回到終端機跑一次 cargo run：

Hello, Rust!

看到了嗎？你改了什麼，它就印什麼。程式設計就是這麼回事——你告訴電腦要做什麼，它就照做。

重點整理

• Cargo 是 Rust 的專案管理工具，用 cargo new 建立新專案
• 專案裡 Cargo.toml 是設定檔，src/main.rs 是主程式碼
• 編譯是把人看得懂的程式碼翻譯成電腦能跑的檔案
• 用 cargo run 一鍵完成編譯和執行
• fn main() 是程式的入口點，println! 用來印東西到螢幕上

變數與輸出

本集目標

學會用 let 建立變數，再用 println! 把它印出來。

正文

上一集我們成功跑出了 “Hello, Rust!”，但那個文字是寫死在程式裡的。如果我們想要更靈活一點呢？這時候就需要變數了。

什麼是變數？

變數就像一個盒子，你可以把東西放進去，之後再拿出來用。

來看看怎麼用：

fn main() {
    let x = 5;
    println!("{}", x);
}

這裡 let x = 5; 就是在說：「我要建立一個叫 x 的變數，然後把 5 放進去。」

然後 println!("{}", x); 裡面的 {} 就是一個佔位符，意思是「這個位置，請幫我填入 x 的值」。

文字變數

變數不只能放數字，也能放文字：

fn main() {
    let name = "Rust";
    println!("Hello, {}!", name);
}

看到了嗎？{} 的位置被 name 的值 "Rust" 取代了。

你也可以試著把 "Rust" 改成你自己的名字，看看會印出什麼！

let 不一定要馬上賦值

let 宣告變數的時候，不一定要馬上給值。你可以先宣告，之後再賦值：

fn main() {
    let x;
    x = 5;
    println!("{}", x);
}

這樣完全合法，但一定要賦值剛好一次，沒有賦值就使用會發生編譯錯誤。

重點整理

• let 用來建立變數
• "雙引號" 包起來的是文字
• println!("{}", 變數) 可以把變數的值印出來
• {} 是佔位符，會被後面的值取代
• let 宣告不一定要馬上賦值，但一定要賦值一次

註解

本集目標

學會在程式碼裡寫筆記（註解），讓自己和別人看得懂你在幹嘛。

正文

寫程式的時候，有時候你會想在旁邊做個筆記，提醒自己「這段在幹嘛」。這就是註解的用途。

註解不會被電腦執行，它純粹是寫給人看的。

單行註解

用 // 開頭，後面的內容整行都是註解：

fn main() {
    // 這是一個註解，電腦會忽略這行
    let x = 5; // 也可以寫在程式碼後面
    println!("{}", x);
}

跑起來還是只會印出 5，那兩行註解完全不會影響程式。

多行註解

如果你要寫很長的筆記，可以用 /* */ 把它包起來：

fn main() {
    /* 
        這是多行註解
        可以寫好幾行
        電腦通通會忽略
    */
    let x = 10;
    println!("{}", x);
}

什麼時候要寫註解？

• 當這段程式碼的邏輯不太明顯的時候
• 當你怕自己過幾天回來看會忘記的時候
• 當你想暫時讓某行程式碼不要執行（把它「註解掉」）

fn main() {
    let x = 5;
    // println!("{}", x); // 暫時不印，但不想刪掉
    println!("程式結束");
}

這樣 println!("{}", x); 就不會被執行了，但你隨時可以把 // 拿掉讓它復活。

小提醒

不用每一行都寫註解喔！好的程式碼本身就應該夠清楚。註解是用在「不明顯」的地方，不是每行都要解釋。

重點整理

• // 是單行註解，/* */ 是多行註解
• 註解是寫給人看的，電腦完全忽略
• 可以用註解暫時「關掉」某行程式碼，不用刪掉它
• 好的程式碼本身就該夠清楚，註解用在不明顯的地方就好

算術運算子

本集目標

學會在 Rust 裡做加減乘除和取餘數。

正文

今天來學數學！別怕，就是加減乘除而已。

基本四則運算

先建立兩個變數：

fn main() {
    let a = 10;
    let b = 3;

    println!("{} + {} = {}", a, b, a + b);
    println!("{} - {} = {}", a, b, a - b);
    println!("{} * {} = {}", a, b, a * b);
    println!("{} / {} = {}", a, b, a / b);
    println!("{} % {} = {}", a, b, a % b);
}

等等，10 / 3 怎麼是 3？

好問題！因為 a 和 b 都是整數，所以 Rust 做的是整數除法，小數點後面直接砍掉。10 除以 3 等於 3.333…，砍掉小數就是 3。

% 是什麼？

% 叫做取餘數（模數運算）。10 除以 3 等於 3 餘 1，所以 10 % 3 就是 1。

你可以想成：「10 裡面有幾個 3？有 3 個，然後剩下 1。」那個剩下的就是餘數。

多個 {} 的用法

你有注意到嗎？我們在 println! 裡面放了三個 {}：

fn main() {
    let a = 10;
    let b = 3;
    println!("{} + {} = {}", a, b, a + b);
}

Rust 會按照順序把值填進去：

• 第一個 {} → a 的值（10）
• 第二個 {} → b 的值（3）
• 第三個 {} → a + b 的值（13）

幾個 {} 就對應後面幾個值，順序要對上。

重點整理

• 五個算術運算子：+（加）、-（減）、*（乘）、/（除）、%（取餘數）
• 整數除法會直接捨去小數部分（10 / 3 是 3 不是 3.333）
• % 取餘數：10 % 3 就是 10 除以 3 剩下的 1
• println! 裡可以放多個 {}，按順序對應後面的值

運算子優先順序

本集目標

了解 Rust 的運算順序——先乘除後加減，以及怎麼用括號改變順序。

正文

上一集我們學了加減乘除，但如果把它們混在一起呢？電腦會先算哪個？

先乘除，後加減

fn main() {
    println!("{}", 2 + 3 * 4);
}

你覺得答案是多少？

如果你覺得是 20（先算 2 + 3 = 5，再乘 4），那就錯了！

答案是 14。因為 Rust 跟數學一樣，先乘除，後加減。所以它先算 3 * 4 = 12，再算 2 + 12 = 14。

用括號改變順序

如果你真的想先算加法呢？加括號就對了：

fn main() {
    println!("{}", (2 + 3) * 4);
}

這次答案就是 20 了。括號裡面的會先算，2 + 3 = 5，然後 5 * 4 = 20。

小訣竅

不確定順序的時候，加括號就對了。括號不只是改順序，有時也讓程式碼更好讀。就算順序本來就對，加個括號讓意圖更明確也沒什麼不好。

fn main() {
    // 這兩行結果一樣，但第二行更清楚
    println!("{}", 2 + 3 * 4);
    println!("{}", 2 + (3 * 4));
}

重點整理

• Rust 的運算優先順序跟數學一樣：先乘除後加減
• 用括號 () 可以強制改變運算順序
• 不確定順序時加括號，既安全又讓程式碼更好讀

比較運算子

本集目標

學會用比較運算子來比大小、判斷相不相等。

正文

到目前為止我們都在做數學運算，但程式設計裡還有另一種很重要的運算——比較。

比較的結果不是數字，而是 true（對）或 false（錯）。

== 等於

fn main() {
    println!("{}", 5 == 5);
}

5 等於 5 嗎？對，所以是 true。

注意喔，是兩個等號 ==，不是一個。一個等號 = 是拿來給變數賦值的（let x = 5），兩個等號 == 才是拿來比較的。

!= 不等於

fn main() {
    println!("{}", 5 != 3);
}

5 不等於 3 嗎？對。

< 小於

fn main() {
    println!("{}", 3 < 5);
}

3 小於 5。

> 大於

fn main() {
    println!("{}", 10 > 7);
}

10 大於 7。

<= 小於等於

fn main() {
    println!("{}", 5 <= 5);
}

5 小於或等於 5 嗎？等於的話也算。

>= 大於等於

fn main() {
    println!("{}", 8 >= 10);
}

8 大於或等於 10 嗎？不是。

一覽表

重點整理

• 六個比較運算子：==、!=、<、>、<=、>=
• 比較的結果是 true（對）或 false（錯）
• ==（兩個等號）是比較，=（一個等號）是賦值，別搞混

if

本集目標

用 if 讓程式根據條件決定要不要做某件事。

正文

到目前為止，我們的程式都是從頭到尾一行一行執行的。但真正的程式需要會「判斷」——如果怎樣，就做什麼事。

這就是 if 的用途。

基本用法

fn main() {
    let x = 7;
    if x > 3 {
        println!("大於 3");
    }
}

邏輯很簡單：x 是 7，7 大於 3 嗎？對，所以就執行大括號 {} 裡面的程式碼。

條件不成立的話呢？

把 x 改成 1 試試看：

fn main() {
    let x = 1;
    if x > 3 {
        println!("大於 3");
    }
}

跑起來……什麼都沒有。因為 1 不大於 3，條件是 false，所以大括號裡的程式碼就被跳過了。

重點整理

• if 後面接條件，條件為 true 就執行大括號裡的程式碼
• 條件為 false 就整段跳過不執行
• Rust 的 if 條件不需要加小括號

作用域

本集目標

了解大括號 {} 創造的「範圍」，以及為什麼變數出了大括號就不能用了。

正文

這集來聊一個很重要的概念——作用域（scope）。

什麼是作用域？

你可以把大括號 {} 想成一個房間。在房間裡面建立的東西，出了房間就看不到了。

來看這個例子：

fn main() {
    {
        let y = 10;
        println!("{}", y);
    }
}

到這裡都沒問題。

出了大括號會怎樣？

現在試著在大括號外面用 y：

fn main() {
    {
        let y = 10;
        println!("{}", y);
    }
    println!("{}", y); // 這行會出錯！
}

你會得到一個編譯錯誤，Rust 在跟你說：「我找不到 y 這個東西。」

為什麼？因為 y 是在那對大括號裡面建立的，一出了大括號，y 就不見了。就像你在一個房間裡放了一張椅子，關上門之後，走廊上是看不到那張椅子的。

為什麼要有作用域？

這其實是一件好事。它讓你的變數不會在不該出現的地方亂跑。想像一下如果每個變數在程式的任何地方都能用，那程式一大起來就會超級混亂。作用域幫你把東西整理得有條有理。

不只是獨立的大括號

上一集教的 if 也有大括號對吧？其實 if 的大括號也是一個作用域，外面看不到裡面的變數。之後我們會學到迴圈、函數等等，只要看到 {}，裡面就是一個作用域。這是 Rust 裡面一個很統一的規則。

重點整理

• 每對大括號 {} 都會建立一個作用域（scope）
• 在作用域裡建立的變數，出了 {} 就消失、不能再用
• if 和其他帶有 {} 的語法都會形成作用域

else

本集目標

用 else 讓程式在條件不成立時，做另一件事。

正文

上次學 if 的時候，如果條件不成立，程式就什麼都不做。但很多時候我們想說：「如果這樣就做 A，否則就做 B。」這就是 else 的用途。

基本用法

fn main() {
    let x = 2;
    if x > 5 {
        println!("大");
    } else {
        println!("小");
    }
}

x 是 2，2 大於 5 嗎？不是，所以跳過 if 的大括號，執行 else 的大括號，印出「小」。

換個值試試

把 x 改成 8：

fn main() {
    let x = 8;
    if x > 5 {
        println!("大");
    } else {
        println!("小");
    }
}

這次印出「大」，因為 8 大於 5，條件成立，走 if 那邊。

白話文

你可以把 if...else 想成：

如果條件成立，就做這個；否則，就做那個。

一定會走其中一邊，不會兩邊都走，也不會兩邊都不走。

重點整理

• else 接在 if 後面，處理條件不成立時要做的事
• if...else 是二選一：一定會走其中一邊，不會兩邊都走或都不走

else if

本集目標

用 else if 處理多個條件分支——不只二選一，還能三選一、四選一。

正文

上一集學的 if...else 只能處理「二選一」。但如果有更多情況呢？比如成績分等第：A、B、C、F……這時候就需要 else if。

範例：成績等第

fn main() {
    let score = 85;

    if score >= 90 {
        println!("A");
    } else if score >= 80 {
        println!("B");
    } else if score >= 70 {
        println!("C");
    } else {
        println!("F");
    }
}

它是怎麼判斷的？

Rust 會從上到下，一個一個條件去看：

1. score >= 90？85 >= 90？不是，跳過。
2. score >= 80？85 >= 80？是！印 “B”，然後結束。
3. 後面的都不看了。

這很重要：一旦某個條件成立，後面的都會被跳過。

試試其他分數

• score = 95 → 印 “A”
• score = 73 → 印 “C”
• score = 50 → 印 “F”（前面全部不成立，走到 else）

結構

if 條件1 {
    ...
} else if 條件2 {
    ...
} else if 條件3 {
    ...
} else {
    ...（以上都不成立時）
}

你可以放任意多個 else if，最後的 else 是選擇性的（但通常建議加上去，以防漏掉什麼情況）。

重點整理

• else if 可以處理多個條件分支，不只二選一
• Rust 從上到下檢查條件，第一個成立的就執行，後面全部跳過
• 最後的 else 是選擇性的，用來處理「以上條件都不成立」的情況

邏輯運算子

本集目標

學會用 &&（而且）、||（或者）、!（不是）來組合多個條件。

正文

上幾集我們學了 if，但條件都很簡單——只有一個。現實中常常需要同時考慮好幾個條件，比如「年滿 18 歲而且是學生」。這就需要邏輯運算子。

&& —— 而且（AND）

兩個條件都要成立，結果才是 true：

fn main() {
    let age = 24;
    let is_student = true;

    if age >= 18 && is_student {
        println!("是個成年學生");
    }
}

因為 24 >= 18 是 true，is_student 也是 true，兩個都成立，所以整體是 true。

如果把 age 改成 15，15 >= 18 是 false，不管 is_student 是不是 true，整體就是 false，就不會印了。

|| —— 或者（OR）

只要其中一個條件成立，結果就是 true：

fn main() {
    let is_weekend = false;
    let is_holiday = true;

    if is_weekend || is_holiday {
        println!("今天放假！");
    }
}

雖然 is_weekend 是 false，但 is_holiday 是 true，只要有一個是 true 就夠了。

! —— 不是（NOT）

把 true 變成 false，把 false 變成 true：

fn main() {
    let raining = false;

    if !raining {
        println!("出門走走吧！");
    }
}

raining 是 false，加上 ! 之後就變成 true，所以條件成立。

你可以讀成：「如果沒有在下雨，就出門走走。」

重點整理

• &&（而且）：兩邊都為 true 才是 true
• ||（或者）：只要一邊為 true 就是 true
• !（不是）：把 true 變 false，false 變 true
• 用邏輯運算子組合多個條件，寫出更精確的判斷

let mut

本集目標

了解 Rust 的變數預設不可變，要用 mut 才能改值。

正文

今天來聊 Rust 一個很有特色的設計——變數預設不可變。

先看看會怎樣

fn main() {
    let x = 5;
    x = 10;
    println!("{}", x);
}

你覺得會印出 10 嗎？不會。你會得到一個編譯錯誤。Rust 在跟你說：「x 是不可變的，你不能再給它新的值。」

等等，為什麼不行？

在很多程式語言裡，變數就是可以隨便改的。但 Rust 的態度是：如果你不打算改它，就別讓它可以被改。

為什麼？因為如果你知道一個值不會變，你在讀程式的時候就不用擔心它被偷改了。這在大型程式裡很重要。

要改的話，加 mut

如果你確實需要改變值，加上 mut（mutable 的縮寫，意思是「可變的」）：

fn main() {
    let mut x = 5;
    println!("x 原本是 {}", x);
    x = 10;
    println!("x 現在是 {}", x);
}

這次就沒問題了！因為你用 let mut 告訴 Rust：「這個變數我之後會改。」

小整理

fn main() {
    let x = 5;     // 不可變，之後不能改
    let mut x = 5; // 可變，之後可以改
}

Rust 不是不讓你改變數，它只是要你明確說出來。這是 Rust 的一個設計哲學：有意識地做出選擇。

重點整理

• Rust 的變數預設是不可變的，不能重新賦值
• 要讓變數可以改值，宣告時加上 mut：let mut x = 5;
• 修改可變變數的值：直接用 x = 新值;（不需要再寫 let）
• 這是 Rust 的設計哲學：要你明確選擇，而不是默默允許修改

複合賦值運算子

本集目標

學會用 +=、-= 等簡寫方式來更新變數的值。

正文

上一集學了 let mut 讓變數可以改值。今天來學一個偷懶的寫法。

x = x + 5 是什麼意思？

先來看一個很重要的觀念。假設你有一個變數 x 是 10，你想讓它加 5：

fn main() {
    let mut x = 10;
    x = x + 5;
    println!("{}", x); // 15
}

這裡 x 同時出現在 = 的左邊和右邊。這不是數學上的「x 等於 x + 5」（那在數學上根本不成立對吧？），而是程式語言的意思：先算右邊的 x + 5（也就是 10 + 5 = 15），然後把結果存回左邊的 x。所以 x 的值就從 10 變成了 15。

+= 簡寫

上面那行其實有個更簡短的寫法：

fn main() {
    let mut x = 10;
    x += 5;
    println!("{}", x); // 15
}

x += 5 的意思就是 x = x + 5，只是比較簡潔。

其他複合賦值運算子

減法、乘法、除法、取餘數都有對應的簡寫：

fn main() {
    let mut a = 20;
    
    a -= 3;
    println!("20 - 3 = {}", a); // 17
    
    a *= 2;
    println!("17 * 2 = {}", a); // 34
    
    a /= 4;
    println!("34 / 4 = {}", a); // 8（整數除法）
    
    a %= 3;
    println!("8 % 3 = {}", a);  // 2
}

一覽表

小提醒

要用這些運算子，變數一定要是 let mut 宣告的，因為你正在改變它的值。

重點整理

• 複合賦值運算子：+=、-=、*=、/=、%=
• x += 5 就是 x = x + 5 的簡寫——先算右邊，再存回左邊
• 使用前提：變數必須用 let mut 宣告

stdin

本集目標

讓程式讀取使用者的鍵盤輸入——先照抄，不用完全理解每一行。

正文

到目前為止，我們程式裡的值都是寫死的。但如果想讓使用者自己輸入呢？比如讓使用者輸入名字，然後程式跟他打招呼？

先照抄這段程式碼

fn main() {
    println!("請輸入你的名字：");

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("讀取失敗");

    println!("你好，{}！", input.trim());
}

跑起來的效果：

請輸入你的名字：
Andy
你好，Andy！

這段在幹嘛？

我知道這段看起來有點嚇人，但別擔心，我們先把它當成一個黑盒子——你只要知道它能讀取使用者輸入就好。

大概的意思是：

1. let mut input = String::new(); → 建立一個空的文字變數，準備接收輸入
2. std::io::stdin().read_line(&mut input).expect("讀取失敗"); → 從鍵盤讀一行文字，存到 input 裡
3. input.trim() → 把多餘的空白和換行符號去掉

至於 String::new()、&mut、.expect() 這些是什麼意思？以後會慢慢教，現在先照抄就好。

為什麼先不解釋？

因為要解釋這段程式碼，需要先理解好幾個還沒學的觀念。與其硬塞一堆看不懂的解釋，不如先學會用，之後自然就懂了。

就像小時候你學騎腳踏車，不用先學力學和陀螺效應——先騎就對了。

重要的事

每次要讀使用者輸入，就把這三行拿去用：

fn main() {
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("讀取失敗");
    let name = input.trim(); // 去掉尾巴的換行
}

重點整理

• 讀取使用者輸入的三行固定寫法：String::new() → stdin().read_line() → .trim()
• 這段先當成黑盒子照抄即可，背後的觀念之後會慢慢學
• .trim() 用來去掉輸入尾巴的換行符號

parse

本集目標

學會把使用者輸入的文字轉換成數字。

正文

和上一集一樣，這集的語法先照抄就好，不用完全理解每一行在做什麼。之後學到更多概念會回來解釋。

上一集我們學了怎麼讀取使用者的輸入，但讀進來的東西是文字。如果使用者輸入了 42，對 Rust 來說那是一串文字，不是數字 42。

你不能拿文字去做加減乘除，所以我們需要把它「轉換」成數字。

文字轉數字

fn main() {
    println!("請輸入一個數字：");

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("讀取失敗");

    let num = input.trim().parse::<i32>().expect("請輸入數字");

    println!("你輸入的數字是 {}", num);
}

跑起來：

請輸入一個數字：
42
你輸入的數字是 42

關鍵在這行

fn main() {
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("讀取失敗");
    let num = input.trim().parse::<i32>().expect("請輸入數字");
}

拆開來看：

1. input.trim() → 去掉頭尾的空白和換行
2. .parse::<i32>() → 把文字解析成整數（i32 就是一種整數型別）
3. .expect("請輸入數字") → 如果轉換失敗（比如使用者輸入了 “abc”），就印這個錯誤訊息然後結束程式

完整的互動範例

fn main() {
    println!("請輸入一個數字：");

    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("讀取失敗");

    let num = input.trim().parse::<i32>().expect("請輸入數字");

    println!("{} 乘以 2 等於 {}", num, num * 2);
}

請輸入一個數字：
7
7 乘以 2 等於 14

現在你可以讀取數字並拿來運算了！

重點整理

• 使用者輸入的東西是文字，要用 .parse::<i32>() 轉成整數才能做運算
• .expect("錯誤訊息") 在轉換失敗時會印出訊息並結束程式
• 完整流程：input.trim().parse::<i32>().expect("請輸入數字")

綜合練習

本集目標

把前面學的東西組合起來，做一個「輸入分數 → 判斷等第」的小程式。

正文

恭喜你撐到現在！今天我們要把前面學的東西全部串起來，做一個真正有用的小程式。

目標

讓使用者輸入分數，程式自動判斷等第並印出來。

完整程式碼

fn main() {
    println!("請輸入你的分數：");

    // 讀取使用者輸入
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("讀取失敗");

    // 把文字轉成數字
    let score = input.trim().parse::<i32>().expect("請輸入數字");

    // 判斷等第
    if score >= 90 {
        println!("你的成績是 A");
    } else if score >= 80 {
        println!("你的成績是 B");
    } else if score >= 70 {
        println!("你的成績是 C");
    } else {
        println!("你的成績是 F");
    }
}

跑跑看

請輸入你的分數：
85
你的成績是 B

請輸入你的分數：
92
你的成績是 A

請輸入你的分數：
45
你的成績是 F

回顧一下用了哪些技巧

1. println! → 印提示訊息（第 2 集）
2. let mut + String::new() → 準備接收輸入（第 15 集）
3. stdin().read_line() → 讀取鍵盤輸入（第 15 集）
4. .trim().parse::<i32>() → 文字轉數字（第 16 集）
5. if / else if / else → 條件判斷（第 8、10、11 集）

看到了嗎？把各種功能組合起來就能做出一個有互動性的小程式。這就是程式設計的魅力——把小塊的知識拼在一起，就能做出有用的東西。

挑戰

如果你想多練習，試試看：

• 加一個 D 等第（60 ~ 69 分）
• 如果分數超過 100 或小於 0，印出「分數不正確」

重點整理

• 結合前面學的 stdin、parse、if 和 else if，就能做出有互動性的程式
• 程式設計的魅力：把小塊知識拼在一起，就能做出有用的東西
• 除了學新語法，多練習組合應用也很重要

loop + break

本集目標

用 loop 做出一個無限迴圈，再用 break 在適當的時機跳出來。

正文

到目前為止，我們的程式都是跑一次就結束。但如果有些事情需要重複做呢？比如倒數計時：5、4、3、2、1、發射！

這就需要迴圈。

loop —— 無限迴圈

loop 就是一直跑、一直跑，永遠不停：

fn main() {
    loop {
        println!("停不下來啊啊啊");
    }
}

如果你真的跑了這段程式，它會一直印一直印……你得用 Ctrl + C 強制停止它。

所以我們需要一個「出口」。

break —— 跳出迴圈

fn main() {
    let mut count = 5;
    loop {
        if count == 0 {
            println!("發射！");
            break;
        }
        println!("{}", count);
        count -= 1;
    }
}

它是怎麼運作的？

1. count 從 5 開始
2. 進入 loop，先檢查 count == 0 嗎？不是，印出 5，然後 count -= 1，count 變成 4
3. 再回到 loop 的開頭，檢查 count == 0 嗎？不是，印出 4，count 變成 3
4. ……一直重複……
5. 當 count 變成 0，if count == 0 成立，印出「發射！」，然後 break 跳出迴圈
6. 程式結束

重點整理

• loop 會無限重複執行大括號裡的程式碼
• break 用來跳出迴圈，讓程式繼續往下跑
• 沒有 break 的 loop 就是無限迴圈，記得要有出口

while

本集目標

用 while 迴圈改寫倒數計時，對比 loop + break 的寫法。

正文

上一集我們用 loop + break 做了倒數計時。今天來學另一種迴圈——while，它讓同樣的邏輯寫起來更乾淨。

用 while 改寫倒數計時

fn main() {
    let mut count = 5;
    while count > 0 {
        println!("{}", count);
        count -= 1;
    }
    println!("發射！");
}

結果一模一樣！

跟 loop + break 比一下

上一集的寫法：

fn main() {
    let mut count = 5;
    loop {
        if count == 0 {
            println!("發射！");
            break;
        }
        println!("{}", count);
        count -= 1;
    }
}

while 的寫法：

fn main() {
    let mut count = 5;
    while count > 0 {
        println!("{}", count);
        count -= 1;
    }
    println!("發射！");
}

有看出差別嗎？while 把「條件判斷」和「迴圈」合在一起了。不需要自己寫 if 和 break，只要告訴 while：「一旦這個條件成立，就繼續跑。」

while 的白話文

當條件成立的時候，就一直做大括號裡的事。

while count > 0 → 只要 count 大於 0，就繼續跑。count 一旦變成 0，條件不成立了，就自動停下來。

什麼時候用 loop，什麼時候用 while？

• while：你在迴圈開始前就知道要不要繼續（先檢查條件，再決定要不要跑）
• loop + break：你需要在迴圈中間某個地方才能決定要不要停下來

兩種都可以達成目的，只是 while 在很多情況下寫起來更簡潔。

重點整理

• while 迴圈：只要條件成立就一直跑，條件不成立就自動停
• 比 loop + break 更簡潔，適合在迴圈開始前就知道要不要繼續的情況
• loop + break 適合在迴圈中間才能決定要不要停的情況

for + range

本集目標

用 for 迴圈搭配範圍（range）來重複執行，不用自己處理計數器。

正文

前兩集我們學了 loop 和 while，都需要自己手動管理計數器（count -= 1 之類的）。今天來學一個更簡單的寫法——for 迴圈。

for + 範圍

fn main() {
    for i in 0..5 {
        println!("{}", i);
    }
}

0..5 是什麼？

0..5 叫做範圍（range），意思是「從 0 開始，到 5 之前」。注意，不包含 5！

所以 0..5 就是 0、1、2、3、4 這五個數字。

你可以把 for i in 0..5 讀成：「讓 i 依序從 0 跑到 4，每次做大括號裡的事。」

注意這裡的 i 不需要寫 let——for 會自動幫你宣告它。而且 i 在 for 後面的大括號 {} 裡面都可以使用。

要包含結尾呢？用 0..=5

fn main() {
    for i in 0..=5 {
        println!("{}", i);
    }
}

0..=5 多了一個 =，表示「包含 5」。

比較一下

while 和 for 也能用 break

之前在 loop 裡面學過 break，其實 while 和 for 也能用。要注意的是，break 只會跳出迴圈，不會跳出 if 之類的控制結構。所以下面這段程式碼裡，break 是跳出 for 迴圈，不是跳出 if：

fn main() {
    for i in 0..10 {
        if i == 5 {
            println!("找到 5 了，不找了！");
            break;
        }
        println!("{}", i);
    }
}

跑起來只會印 0~4，遇到 5 就 break 跳出迴圈了。

重點整理

• for i in 0..5 讓 i 從 0 跑到 4（不含尾），0..=5 則包含 5
• 相比 while，for 不用手動遞增計數器和檢查條件，更簡潔也更不容易出錯
• break 在 loop、while、for 裡面都可以使用

巢狀迴圈

本集目標

把迴圈放進迴圈裡——用巢狀迴圈印出九九乘法表。

正文

上一集學了 for 迴圈，今天來玩個進階的——把一個迴圈放進另一個迴圈裡面。

什麼是巢狀迴圈？

「巢狀」就是「一層包一層」的意思，像俄羅斯套娃一樣。外面的迴圈跑一次，裡面的迴圈就會完整跑完一輪。

九九乘法表

來挑戰一下，用巢狀迴圈印出九九乘法表：

fn main() {
    for i in 1..=9 {
        for j in 1..=9 {
            print!("{} x {} = {}   ", i, j, i * j);
        }
        println!(); // 換行
    }
}

它是怎麼運作的？

1. 外面的迴圈 i 從 1 跑到 9
2. 當 i = 1 時，裡面的迴圈 j 從 1 跑到 9 → 印出 1×1, 1×2, … 1×9
3. 裡面的迴圈跑完後，println!() 換行
4. 外面的迴圈走到 i = 2，裡面的迴圈又從 1 跑到 9 → 印出 2×1, 2×2, … 2×9
5. 以此類推……

print! vs println!

這裡用了一個新東西：print!。它跟 println! 很像，差別在於 print! 印完不會換行，而 println! 印完會換行。

視覺化

外迴圈跑一次 = 一行：

i=1 → [j=1, j=2, j=3, ... j=9] → 換行
i=2 → [j=1, j=2, j=3, ... j=9] → 換行
...
i=9 → [j=1, j=2, j=3, ... j=9] → 換行

break 只跳出最內層

在巢狀迴圈裡用 break，它只會跳出最裡面那一層迴圈，外面那層還會繼續跑：

fn main() {
    for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                break; // 只跳出內層迴圈
            }
            println!("i={}, j={}", i, j);
        }
    }
}

每次 j 到 2 就 break 了，但外層的 i 還是繼續跑 1、2、3。

loop label：跳出指定層

如果你想直接跳出外面那層呢？可以用 loop label：

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                break 'outer; // 跳出外層迴圈
            }
            println!("i={}, j={}", i, j);
        }
    }
    println!("結束！");
}

'outer: 是一個標籤（label），放在迴圈前面。break 'outer 就是說「跳出標記為 'outer 的那個迴圈」。注意標籤名稱前面要加 '（單引號）。

重點整理

• 巢狀迴圈就是迴圈裡面再放迴圈，外層跑一次、內層就完整跑一輪
• print! 和 println! 的差別：print! 印完不換行
• break 在巢狀迴圈裡只會跳出最內層的迴圈
• 用 loop label（'outer: + break 'outer）可以跳出指定的外層迴圈

continue

本集目標

用 continue 跳過迴圈中的某些輪次。

正文

之前學了 break 可以跳出迴圈。今天來學 continue——它不是跳出迴圈，而是跳過這一次，直接進入下一次迴圈。

只印奇數

fn main() {
    for i in 0..10 {
        if i % 2 == 0 {
            continue;
        }
        println!("{}", i);
    }
}

它是怎麼運作的？

迴圈 i 從 0 跑到 9：

• i = 0 → 0 % 2 == 0 嗎？是（偶數），continue！跳過，不印
• i = 1 → 1 % 2 == 0 嗎？不是（奇數），繼續往下跑，印出 1
• i = 2 → 偶數，continue，跳過
• i = 3 → 奇數，印出 3
• ……以此類推

break vs continue

• break：整個迴圈結束，不再跑了
• continue：這一次跳過，但迴圈繼續跑下一次

和 break 一樣，continue 也是只作用在迴圈上，不會跳過 if 之類的控制結構。上面的程式碼裡，continue 是跳過 for 迴圈的這一次，不是跳過 if。

另一個例子

跳過 5 不印：

fn main() {
    for i in 1..=10 {
        if i == 5 {
            continue;
        }
        println!("{}", i);
    }
}

5 被跳過了，其他都正常印出來。

continue + loop label

上一集學過 break 'outer 可以跳出指定層迴圈，continue 也可以搭配 label：

fn main() {
    'outer: for i in 1..=3 {
        for j in 1..=3 {
            if j == 2 {
                continue 'outer; // 跳過外層迴圈的這一次
            }
            println!("i={}, j={}", i, j);
        }
    }
}

每次 j 到 2，就 continue 'outer 直接跳到外層的下一輪，所以 j=2 和 j=3 都不會印。

重點整理

• continue 跳過這一次，直接進入下一次迴圈
• break 是「整個迴圈不跑了」，continue 是「這次跳過，跑下一次」
• 搭配 if 可以有選擇性地跳過特定情況
• continue 'outer 可以搭配 loop label 跳過外層迴圈的一輪

型別（基礎）

本集目標

認識 Rust 的基本型別。

正文

到現在為止，我們寫 let x = 5; 的時候都沒有特別說 x 是什麼「型別」。今天來正式認識一下型別是什麼。

什麼是型別？

型別就是在告訴 Rust：「這個變數裡面放的是什麼東西。」

是整數？小數？文字？還是 true/false？不同的型別代表不同的資料。

手動標註型別

你可以在變數名稱後面加上 : 型別 來指定：

fn main() {
    let x: i32 = 5;
    let negative: i32 = -10;
    let y: f64 = 3.14;
    let z: bool = true;

    println!("x = {}", x);
    println!("negative = {}", negative);
    println!("y = {}", y);
    println!("z = {}", z);
}

• i32 → 整數（integer，32 位元）
• f64 → 浮點數（float，64 位元），就是帶小數點的數字
• bool → 布林值，只有 true 和 false

那之前為什麼不用標？

因為 Rust 很聰明！它會看你給的值，自動推斷型別：

fn main() {
    let x = 5;    // Rust 自動判斷：這是 i32
    let y = 3.14; // Rust 自動判斷：這是 f64
    let z = true; // Rust 自動判斷：這是 bool
}

這叫做型別推斷（type inference）。大部分的時候 Rust 都能自己搞定，你不用特別標。

重點整理

• 三個基本型別：i32（整數）、f64（浮點數）、bool（布林值）
• Rust 有型別推斷，大部分時候不用手動標註型別
• 需要時可以用 let x: i32 = 5; 手動指定型別

型別（數字詳解）

本集目標

認識 Rust 所有的數字型別，以及數字後綴的用法。

正文

上一集我們簡單認識了 i32 和 f64。今天來把 Rust 所有的數字型別都看一遍。

整數型別

Rust 的整數型別分成有號（可以是負數）和無號（只能是正數和零）：

• i = integer（整數），u = unsigned（無號）
• 數字代表用幾個位元來存——位元越多，能存的數字越大
• isize 和 usize 的大小取決於你的系統是 32 位元還是 64 位元（現在幾乎都是 64 位元）

日常用 i32 就夠了。 不確定的時候，用 i32。

浮點數型別

浮點數就是帶小數點的數字，只有兩種：

日常用 f64 就夠了。 Rust 預設的浮點數就是 f64。

浮點數運算

第 5 集教算術運算的時候，我們都用整數。浮點數一樣可以用 + - * / %，但有一個重要的差別——浮點數除法會保留小數：

fn main() {
    let a = 10.0;
    let b = 3.0;
    println!("{}", a / b); // 3.3333333333333335
    println!("{}", a % b); // 1.0
}

還記得第 5 集 10 / 3 的結果是 3（整數除法直接截斷）嗎？浮點數不會截斷，10.0 / 3.0 會得到 3.3333...。

不過浮點數有一個經典的坑——精確度問題：

fn main() {
    println!("{}", 0.1 + 0.2); // 0.30000000000000004
}

0.1 + 0.2 不是 0.3！這不是 Rust 的 bug，而是所有程式語言都有的浮點數精確度限制。電腦用二進位存小數，有些十進位小數沒辦法精確表示。知道有這件事就好，不用太擔心。

Rust 怎麼推斷數字型別？

當你寫 let x = 5;，Rust 預設把它當成 i32。 當你寫 let y = 3.14;，Rust 預設把它當成 f64。

但 Rust 不只看數字本身，它也會根據你怎麼使用這個變數來推斷型別。有時候根據上下文，Rust 會推斷出 i32 以外的整數型別。這個之後遇到的時候會更清楚。

不過基本上來說，整數預設就是 i32、浮點數預設就是 f64。

數字後綴（literal suffix）

如果你想要指定型別，除了 let x: i64 = 5; 之外，還有一個更簡潔的寫法——直接在數字後面加型別名稱：

fn main() {
    let a = 5i32;      // i32
    let b = 5u8;       // u8
    let c = 3.14f64;   // f64
    let d = 2.0f32;    // f32
    let e = 100000i64; // i64

    println!("{} {} {} {} {}", a, b, c, d, e);
}

5i32 意思就是「5 這個數字，型別是 i32」。數字和型別之間不用空格，直接接在一起。

小提醒

不同型別的數字不能直接混著算：

fn main() {
    let a: i32 = 5;
    let b: i64 = 10;
    println!("{}", a + b); // ❌ 編譯錯誤！i32 和 i64 不能直接相加
}

這是 Rust 的安全設計，Rust 不會自動幫你轉換型別。

重點整理

• 整數分有號（i8-i128）和無號（u8-u128），日常用 i32 就夠了
• isize 和 usize 的大小取決於系統（64 位元上是 64 位元）
• 浮點數有 f32 和 f64，日常用 f64（Rust 預設）
• 數字後綴（如 5i32、3.14f64）可以直接指定型別
• 浮點數除法保留小數，但有精確度問題（0.1 + 0.2 ≠ 0.3）
• 不同型別的數字不能直接混著算，Rust 不會自動轉型

char

本集目標

認識 char 型別——用來存放「一個字元」的型別。

正文

之前我們用過字串（string，用雙引號 " 包起來的文字），今天來認識一個更小的單位——字元（char）。

char 是什麼？

char 就是一個字元。注意，是「一個」，不是一串。

fn main() {
    let c = 'A';
    let c2 = '你';
    let c3 = '🦀';

    println!("{}", c);
    println!("{}", c2);
    println!("{}", c3);
}

單引號 vs 雙引號

這很重要：

• 單引號 ' → char，只能放一個字元
• 雙引號 " → 字串，可以放很多字元

fn main() {
    let c = 'A';     // char，一個字元
    let s = "Hello"; // 字串，五個字元
}

如果你用單引號放超過一個字元，Rust 會報錯：

fn main() {
    let c = 'AB'; // ❌ 錯誤！char 只能放一個字元
}

Unicode

Rust 的 char 支援 Unicode，所以不只是英文字母，中文、日文、甚至 emoji 都可以：

fn main() {
    let letter = 'R';
    let chinese = '美';
    let japanese = 'の';
    let emoji = '😊';

    println!("{} {} {} {}", letter, chinese, japanese, emoji);
}

每一個都是合法的 char。

型別標註

如果你想明確標註型別：

fn main() {
    let c: char = 'Z';
    println!("{}", c);
}

不過通常不用特別標，Rust 看到單引號就知道是 char。

重點整理

• char 是「一個字元」的型別，用單引號包起來：'A'、'你'、'🦀'
• 支援 Unicode，中文、日文、emoji 都是合法的 char
• 單引號 ' = char（一個字元），雙引號 " = 字串（一串字元），別搞混

跳脫字元

本集目標

學會用反斜線 \ 在字串裡插入換行、tab 等特殊字元。

正文

有時候你想在字串裡面放一些「特殊」的東西，比如換行、tab、或者雙引號本身。這時候就需要跳脫字元（escape character）。

\n —— 換行

fn main() {
    println!("第一行\n第二行");
}

\n 就是告訴 Rust：「這裡換一行。」它不會真的印出 \n 這兩個字，而是產生一個換行的效果。

\t —— Tab

fn main() {
    println!("名字\t分數");
    println!("小明\t85");
    println!("小華\t92");
}

\t 會插入一個 tab 空間。

\\ —— 反斜線本身

如果你想印出反斜線 \ 本身呢？因為 \ 已經被拿來當跳脫字元的開頭了，所以要用兩個反斜線：

fn main() {
    println!("檔案路徑：C:\\Users\\Andy");
}

\“ —— 雙引號

字串是用 " 包起來的，那如果字串裡面要有 " 呢？

fn main() {
    println!("他說：\"你好！\"");
}

\" 告訴 Rust：「這個雙引號是字串內容，不是字串的結尾。」

在 char 裡使用

跳脫字元在 char 裡面也能用：

fn main() {
    let newline: char = '\n';
    let tab: char = '\t';
    let backslash: char = '\\';

    print!("A{}B{}C{}", newline, tab, backslash);
}

\’ —— 單引號

在 char 裡面，如果你想表示單引號本身，就要跳脫：

fn main() {
    let quote: char = '\'';
    println!("{}", quote);
}

因為 char 是用 ' 包起來的，所以裡面要放 ' 就得用 \'。

不需要跳脫的情況

在字串（""）裡面，單引號不需要跳脫，可以直接用：

fn main() {
    println!("It's a test"); // ' 在字串裡不用跳脫
}

同樣地，在 char（''）裡面，雙引號也不需要跳脫：

fn main() {
    let c: char = '"'; // " 在 char 裡不用跳脫
    println!("{}", c);
}

簡單來說：包在外面的那個符號才需要跳脫，另一個不用。

一覽表

重點整理

• 跳脫字元用 \ 開頭，代表特殊字元：\n（換行）、\t（tab）、\\（反斜線）
• \" 在字串裡表示雙引號本身，\' 在 char 裡表示單引號本身
• 跳脫字元在字串和 char 裡都能使用
• 規則：包在外面的那個符號才需要跳脫，另一個不用

if 當表達式

本集目標

學會把 if 當成一個「表達式」，直接用它來給變數賦值。

正文

這是第一章的最後一集！今天要介紹 Rust 一個很酷的特性——if 不只是判斷用的，它還可以回傳值。

先看一般的寫法

假設你要根據條件給變數不同的值，你可能會這樣寫：

fn main() {
    let condition = true;
    let x;

    if condition {
        x = 1;
    } else {
        x = 2;
    }

    println!("{}", x);
}

這樣沒問題，但 Rust 有一個更簡潔的寫法。

if 當表達式

fn main() {
    let condition = true;
    let x = if condition { 1 } else { 2 };

    println!("{}", x);
}

跑起來印出 1。

看到了嗎？if condition { 1 } else { 2 } 整個放在 let x = 的右邊，直接把結果賦值給 x。

如果 condition 是 true，x 就是 1；如果是 false，x 就是 2。

注意：大括號裡面不加分號

fn main() {
    let condition = true;
    let x = if condition { 1 } else { 2 };
    //                      ^          ^
    //                   沒有分號     沒有分號
}

這些值（1 和 2）後面沒有分號。在 Rust 裡，不加分號的值就是「回傳值」。這是 Rust 的表達式語法，之後學函數的時候會更詳細地講。

兩邊型別要一致！

fn main() {
    let condition = true;
    let x = if condition { 1 } else { "hello" }; // ❌ 錯誤！
}

這會報錯，因為 1 是整數，"hello" 是字串。Rust 不允許 x 有時候是數字、有時候是字串——它需要一個確定的型別。

兩邊的大括號裡，值的型別必須相同：

fn main() {
    let condition = true;

    // ✅ 兩邊都是整數
    let x = if condition { 1 } else { 2 };

    // ✅ 兩邊都是字串
    let msg = if condition { "好" } else { "壞" };

    // ❌ 一邊整數一邊字串
    let x = if condition { 1 } else { "hello" };
}

這有什麼好處？

1. x 不需要是 mut
2. 程式碼更簡潔
3. Rust 的設計哲學：很多東西都可以是「表達式」，都能回傳值

重點整理

• if 在 Rust 裡是表達式，可以直接回傳值：let x = if condition { 1 } else { 2 };
• 大括號裡作為回傳值的部分不加分號
• if 和 else 兩邊的型別必須一致

恭喜你完成了第一章！🎉 你已經學會了 Rust 的基本語法，包括變數、運算、條件判斷、迴圈、型別等等。下一章我們會開始學更多 Rust 的特色功能！

函數、陣列與切片

const

本集目標

用 const 宣告一個永遠不會變的常數，並了解它和 let 的差別。

正文

第一章我們學了 let 來宣告變數，今天來認識它的好朋友——const。

const 就是「常數」，意思是：這個值從頭到尾都不會變，而且在編譯的時候就已經決定好了。

來看語法：

fn main() {
    const MAX_SCORE: i32 = 100;
    println!("最高分是：{}", MAX_SCORE);
}

看起來跟 let 很像對吧？但有幾個重要的差別：

差別一：const 一定要標型別

fn main() {
    const MAX_SCORE: i32 = 100; // ✅ 一定要寫 : i32
    let max_score = 100;        // ✅ let 可以省略，編譯器會自己推
}

用 const 的時候，你不能偷懶不寫型別，編譯器會跟你抱怨。

差別二：命名慣例是全大寫加底線

fn main() {
    const MAX_SCORE: i32 = 100;       // ✅ 全大寫，用底線分隔
    const PI_VALUE: f64 = 3.14159;    // ✅ 這樣
    const maxScore: i32 = 100;        // ⚠️ 可以編譯，但編譯器會警告你
}

這是 Rust 社群的慣例：常數用 SCREAMING_SNAKE_CASE（全大寫蛇形命名）。不遵守的話程式還是能跑，但編譯器會碎碎念。

差別三：const 不能用 mut

#![allow(unused)]

fn main() {
    const mut MAX: i32 = 100; // ❌ 不存在這種東西
    let mut x = 5;            // ✅ 這個可以
}

常數就是常數，不能變就是不能變，沒有「可變的常數」這種矛盾的東西。

差別四：const 可以放在 fn 外面

const MAX_PLAYERS: i32 = 10;

fn main() {
    println!("最多 {} 位玩家", MAX_PLAYERS);
}

let 只能放在 fn 裡面，但 const 可以放在最外層，讓整個程式都能用到。

什麼時候用 const？

當你有一個值是固定不變的，而且你在寫程式的時候就知道它是多少，就用 const。比如：

const TAX_RATE: f64 = 0.05;
const MAX_RETRY: i32 = 3;

fn main() {}

重點整理

• const 宣告編譯期常數，值永遠不會變
• 一定要標型別（不能省略）
• 命名慣例是全大寫加底線，像 MAX_SCORE
• 不能加 mut
• 可以放在函數外面，讓整個程式都能用

shadowing

本集目標

用 let 重新宣告同名變數（shadowing），以及它和 mut 的關鍵差別。

正文

Rust 有一個很有趣的功能叫做 shadowing（遮蔽）。簡單說就是：你可以用 let 再次宣告一個同名的變數，新的會「蓋掉」舊的。

fn main() {
    let x = 5;
    let x = x + 1;
    println!("x = {}", x);
}

第二行的 let x = x + 1; 其實是在說：「我要建立一個全新的 x，它的值是舊的 x 加 1。」舊的 x 就被蓋掉了，從此以後 x 就是 6。

你甚至可以連續 shadow 好幾次：

fn main() {
    let x = 1;
    let x = x + 1; // x = 2
    let x = x * 3; // x = 6
    println!("x = {}", x);
}

shadowing vs mut：最大的差別

「等等，這跟 mut 有什麼不一樣？不都是改值嗎？」

最大的差別是：shadowing 可以換型別，mut 不行。

fn main() {
    // shadowing：可以從數字變成字串
    let x = 5;
    let x = "hello";
    println!("x = {}", x);
}

這完全合法！因為第二個 let x 是一個全新的變數，只是剛好同名而已。

但如果用 mut 試試看：

fn main() {
    let mut x = 5;
    x = "hello"; // ❌ 編譯錯誤！不能把字串塞進 i32
}

mut 只是讓你改「值」，型別還是鎖死的。但 shadowing 是建立一個全新的變數，所以型別可以完全不同。

實際用途

shadowing 最常見的用途是「轉換型別但保留名字」：

fn main() {
    let input = "42"; // 這是字串
    let input = input.trim().parse::<i32>().expect("請輸入數字"); // 轉成數字，還是叫 input
    println!("input + 1 = {}", input + 1);
}

如果沒有 shadowing，你就得取兩個不同的名字，像 input_str 和 input_num，有點囉嗦。

shadowing 和作用域

還記得第一章第 9 集學的作用域嗎？Shadowing 在大括號 {} 裡面也能用，而且出了大括號，遮蔽就會結束，舊的變數會「回來」：

fn main() {
    let x = 1;
    {
        let x = 2; // 在這個區塊這行之後，x 被遮蔽為 2
        println!("區塊內 x = {}", x); // 2
    }
    println!("區塊外 x = {}", x);     // 1
}

大括號裡的 let x = 2 建立了一個新的 x，遮蔽了外面的 x。但這個遮蔽只在大括號裡面有效——一出大括號，新的 x 就消失了，原本的 x（值為 1）又可以使用了。

這跟 mut 完全不同。如果用 mut 在區塊裡改值，出了區塊值就真的變了：

fn main() {
    let mut x = 1;
    {
        x = 2; // 直接改值，不是 shadowing
    }
    println!("x = {}", x); // 2
}

所以再強調一次：shadowing 是建立新變數，mut 是改舊變數的值。在作用域裡這個差別特別明顯。

重點整理

• 用 let 重新宣告同名變數叫做 shadowing
• 新的變數會蓋掉舊的
• 和 mut 最大的差別：shadowing 可以換型別
• 實際上每次 let 都是建立一個全新的變數，只是名字一樣
• 在大括號裡 shadow 的變數，出了大括號就消失，原本的變數會「回來」

底線變數

本集目標

用底線 _ 開頭的變數名來告訴編譯器「我知道這個沒用到，別唸我」。

正文

Rust 的編譯器很貼心（有時候有點煩），如果你宣告了一個變數但沒有使用它，它會給你一個警告：

fn main() {
    let x = 5;
    // 沒有用到 x
}

程式還是能跑，但那個黃色的警告看了就不舒服。怎麼消除呢？

方法一：加底線前綴

在變數名前面加一個底線 _：

fn main() {
    let _x = 5;
    // 沒有用到 _x，但編譯器不會警告了
}

這樣編譯器就懂了：「喔，你是故意不用的，好吧。」

注意，_x 還是一個正常的變數，你想用的話還是可以用：

fn main() {
    let _x = 5;
    println!("{}", _x);  // 還是可以用
}

方法二：單獨的底線 _

如果你連名字都不想取，就直接用一個底線：

fn main() {
    let _ = 42;
}

這代表「我完全不在乎這個值」。沒有名字，你之後也沒辦法用它。

_x vs _ 的差別

• _x：有名字，值會被保留，之後還能用
• _：沒名字，值馬上就丟掉了

大部分情況下用哪個都行。

重點整理

• 變數沒用到時，Rust 編譯器會警告你
• 在變數名前面加 _（像 _x）可以消除警告
• 單獨的 _ 代表「我完全不在乎這個值」
• _x 還能用，_ 不能用

tuple

本集目標

用 tuple 把多個不同型別的值組合成一個，並學會怎麼取出裡面的值。

正文

到目前為止，我們一個變數只能存一個值。但如果我想把「一個整數、一個小數、一個布林值」綁在一起呢？這就是 tuple（元組）的用途。

建立 tuple

fn main() {
    let t = (1, 3.14, true);
    println!("{}", t.0); // 1
    println!("{}", t.1); // 3.14
    println!("{}", t.2); // true
}

用小括號 () 把值包起來，用逗號隔開，就是一個 tuple 了。

要取裡面的值，用點加索引：t.0、t.1、t.2。注意索引從 0 開始喔！

unit type — 空的 tuple

Rust 有一個特殊的 tuple，裡面什麼都沒有：

fn main() {
    let _u: () = ();
}

這個 () 叫做 unit type（單元型別）。它是「只有一個值的型別」。它的值也是寫成 ()。

標型別

如果你想明確寫出 tuple 的型別：

fn main() {
    let t: (i32, f64, bool) = (1, 3.14, true);
    println!("{} {} {}", t.0, t.1, t.2);
}

每個位置的型別都要對應上。

單元素 tuple — 別忘了逗號！

如果你想建立一個只有一個元素的 tuple，要記得加逗號：

fn main() {
    let not_a_tuple = (5);     // 這只是數字 5，加了括號而已
    let a_tuple = (5,);        // 這才是 tuple！注意逗號

    println!("{}", a_tuple.0); // 5
}

(5) 只是一個被括號包住的數字，不是 tuple。(5,) 才是。那個逗號很重要！

型別也是一樣的寫法：

fn main() {
    let t: (i32,) = (5,);
    println!("{}", t.0);
}

(i32) 只是 i32 加了括號，(i32,) 才是單元素 tuple 的型別。

修改 tuple 裡面的值

如果 tuple 用 let mut 宣告，就可以修改裡面的值：

fn main() {
    let mut t = (1, 2, 3, 4);
    println!("修改前：{}", t.1); // 2
    t.1 = 99;
    println!("修改後：{}", t.1); // 99
}

跟其他 mut 變數一樣——沒有 mut 就不能改。

重點整理

• tuple 用 () 把不同型別的值打包在一起
• 用 t.0、t.1、t.2……取值（索引從 0 開始）
• () 是 unit type，代表「沒有有意義的值」
• 單元素 tuple 要加逗號：(5,) 才是 tuple，(5) 只是數字
• let mut 的 tuple 可以用 t.0 = 新值 修改裡面的值

{:?} Debug 格式

本集目標

用 {:?} 印出 tuple 等「沒辦法用 {} 印」的東西。

正文

到目前為止，我們都用 {} 來印東西：

fn main() {
    let x = 42;
    println!("{}", x); // ✅ 42
}

數字、bool 這些基本型別用 {} 都沒問題。但如果你試著用 {} 印一個 tuple：

fn main() {
    let t = (1, 2, 3);
    println!("{}", t); // ❌ 編譯錯誤！
}

編譯器會吐出一堆錯誤訊息，簡單來說：「這個型別沒有實作 Display，我不知道要怎麼用『好看的方式』印出來。」

解決方法：用 {:?}

fn main() {
    let t = (1, 2, 3);
    println!("{:?}", t); // ✅ (1, 2, 3)
}

{:?} 叫做 Debug 格式。它不是給使用者看的「漂亮格式」，而是給開發者看的「偵錯格式」。

Display {} vs Debug {:?}

對數字、bool 這些簡單型別來說，{} 和 {:?} 印出來的結果一樣。那 {:?} 的重點在哪？

它能印出 {} 印不了的東西——像 tuple。 tuple 只有 Debug 格式，沒有 Display 格式。

美化版：

如果資料很複雜（比如 tuple 套 tuple），可以用 {:#?} 印出「美化過的 Debug 格式」：

fn main() {
    let data = ((1, 2), (3, 4), (5, 6));
    println!("{:#?}", data);
}

小技巧：dbg! 巨集

Rust 還有一個很方便的偵錯工具 dbg!：

fn main() {
    let x = 5;
    dbg!(x);
    dbg!(x + 1);
}

它會印出檔名、行數和值，超方便：

[src/main.rs:3] x = 5
[src/main.rs:4] x + 1 = 6

重點整理

• {} 是 Display 格式，給使用者看的，但不是所有型別都支援
• {:?} 是 Debug 格式，給開發者看的，tuple 等複合型別都能用
• {:#?} 是美化版的 Debug 格式，複雜資料用這個更清楚
• dbg! 是快速偵錯的好幫手，會印出檔名和行數

簡單函數

本集目標

用 fn 定義自己的函數，並在 main 裡呼叫它。

正文

到目前為止，我們幾乎所有的程式碼都寫在 main 裡面。但如果程式越來越大，全部擠在一起就很亂。這時候我們可以把一段程式碼「包裝」成一個函數（function），想用的時候呼叫它就好。

定義一個函數

fn greet() {
    println!("你好！歡迎來到 Rust 的世界！");
}

fn main() {
    greet();
}

拆解一下語法：

• fn → 告訴 Rust「我要定義一個函數」
• greet → 函數的名字
• () → 參數列表（目前是空的，下一集會學）
• { ... } → 函數要做的事

然後在 main 裡面寫 greet(); 就是呼叫它。

函數可以呼叫好幾次

fn greet() {
    println!("哈囉！");
}

fn main() {
    greet();
    greet();
    greet();
}

這就是函數的好處——寫一次，用很多次。

函數之間可以互相呼叫

不只是 main裡面可以呼叫函數——函數之間也可以互相呼叫。main 只是程式的進入點（程式開始執行的地方），但裡面呼叫的函數也能再呼叫其他函數：

fn say_name() {
    println!("我是 Rust！");
}

fn greet() {
    say_name();
}

fn main() {
    greet(); // main 呼叫 greet，greet 再呼叫 say_name
}

函數定義的位置：上面或下面都行

在某些語言裡，函數必須在使用之前先定義。但 Rust 不用！

fn main() {
    greet();  // ✅ 先呼叫
}

fn greet() {  // 後定義
    println!("你好！");
}

這樣也完全沒問題。Rust 編譯器會先掃過整個檔案，所以不管你把函數放在 main 上面還是下面，都找得到。

函數命名慣例

Rust 的函數名用蛇形命名法（snake_case）：全小寫，單字之間用底線 _ 隔開。

fn say_hello() { // ✅ 蛇形命名
    println!("Hello!");
}

fn sayHello() {  // ⚠️ 可以跑，但編譯器會警告
    println!("Hello!");
}

fn main() {}

重點整理

• 用 fn 名字() { ... } 定義函數
• 用 名字(); 呼叫函數
• main 是程式的進入點，但函數之間也可以互相呼叫
• 函數定義放在 main 上面或下面都可以
• 命名慣例是 snake_case（全小寫加底線）

函數參數

本集目標

幫函數加上參數，讓它能接收外部傳進來的資料。

正文

上一集的 greet 函數每次都只能印一樣的東西，有點無聊。如果我們想讓函數更靈活——比如「你告訴我兩個數字，我幫你加起來」——就需要參數（parameter）。

加上參數

fn add(a: i32, b: i32) {
    println!("{} + {} = {}", a, b, a + b);
}

fn main() {
    add(3, 4);
    add(10, 20);
}

語法拆解：

• a: i32 → 第一個參數叫 a，型別是 i32
• b: i32 → 第二個參數叫 b，型別也是 i32
• 參數之間用逗號隔開

呼叫的時候，add(3, 4) 就是把 3 傳給 a、4 傳給 b。

參數一定要標型別

在 Rust 裡，函數的參數一定要標型別，不能偷懶：

fn add_v1(a, b) {           // ❌ 編譯錯誤！沒標型別
    println!("{}", a + b);
}

fn add_v2(a: i32, b: i32) { // ✅ 一定要標
    println!("{}", a + b);
}

fn main() {}

「可是 let x = 5; 不是可以不標嗎？」

沒錯，let 可以讓編譯器自己推斷。但函數參數不行——因為函數是你的「對外介面」，Rust 希望介面要清清楚楚的，不要搞得模模糊糊。

多個參數、不同型別

參數可以有不同的型別：

fn describe(x: i32, is_positive: bool) {
    println!("{} 是正數嗎？{}", x, is_positive);
}

fn main() {
    describe(5, true);
    describe(-3, false);
}

一個參數也行

fn double(x: i32) {
    println!("{} 的兩倍是 {}", x, x * 2);
}

fn main() {
    double(5);
    double(100);
}

重點整理

• 函數參數寫在小括號裡：fn 名字(參數: 型別)
• 多個參數用逗號隔開
• 參數一定要標型別，這是 Rust 的硬性規定
• 呼叫時傳入對應的值就好

函數回傳值

本集目標

讓函數回傳一個值，並學會 Rust 獨特的「不加分號就是回傳值」的寫法。

正文

上一集的函數只是把結果印出來。但很多時候我們想要的是：「你算完之後把答案交回來，我自己決定要怎麼用。」

基本語法

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let result = add(3, 4);
    println!("3 + 4 = {}", result);
}

重點來了：

1. -> i32 寫在參數後面，告訴 Rust「這個函數會回傳一個 i32」
2. 函數最後一行 a + b 沒有加分號 → 這就是回傳值

不加分號 = 回傳值

這是 Rust 最獨特的設計之一。函數最後一行如果不加分號，它的值就會自動被當成回傳值：

fn double(x: i32) -> i32 {
    x * 2 // ✅ 沒有分號，這就是回傳值
}

fn main() {}

加了分號會怎樣？

如果你不小心加了分號：

fn double(x: i32) -> i32 {
    x * 2; // ❌ 加了分號
}

fn main() {}

編譯器會報錯。為什麼？因為加了分號之後，x * 2 的計算結果會被丟掉，而函數最後沒有留下任何值。在這種狀況下，實際回傳的是 ()（unit type，還記得第 4 集嗎？）。但你答應了要回傳 i32，型別不符，編譯器就會抱怨。

沒寫回傳值的函數

回頭看本章第 6 集的 greet 函數，它沒有寫 -> 回傳值：

fn greet() {
    println!("你好！");
}

fn main() {}

在 Rust 裡，所有函數都有回傳值。沒寫 -> 的話，就等同於寫 -> ()：

fn greet() -> () {
    println!("你好！");
}

fn main() {}

只是 -> () 通常省略不寫。println!("你好！"); 最後有分號，計算結果被丟掉，函數回傳 ()——剛好符合宣告。

接住回傳值

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let result = add(3, 4);
    println!("結果：{}", result);

    // 也可以直接用在表達式裡
    println!("再加 10：{}", add(3, 4) + 10);
}

用 tuple 回傳多個值

函數只能回傳「一個」值，但如果你想回傳多個呢？把它們裝在 tuple 裡就好：

fn swap(a: i32, b: i32) -> (i32, i32) {
    (b, a)
}

fn main() {
    let result = swap(1, 2);
    println!("第一個：{}，第二個：{}", result.0, result.1);
}

-> (i32, i32) 代表回傳一個包含兩個 i32 的 tuple。呼叫之後用 .0、.1 取出裡面的值。

再來一個實用的例子：

fn min_max(a: i32, b: i32) -> (i32, i32) {
    if a < b {
        (a, b)
    } else {
        (b, a)
    }
}

fn main() {
    let result = min_max(7, 3);
    println!("最小：{}，最大：{}", result.0, result.1);
}

重點整理

• 用 -> 型別 宣告函數的回傳型別
• 函數最後一行不加分號，就是回傳值（這是 Rust 的慣用寫法）
• 加了分號就變成普通語句，回傳的會是 ()
• 沒寫回傳值的函數，其實回傳的是 ()
• 想回傳多個值？用 tuple 包起來：-> (i32, i32)，用 .0、.1 取值

early return

本集目標

用 return 關鍵字在函數中途就把值回傳出去，不用等到最後一行。

正文

上一集我們學到：函數最後一行不加分號就是回傳值。但有時候你想在函數中間就回傳——遇到某個條件就提前結束。這時候就要用 return 關鍵字。

基本範例：絕對值

fn abs(x: i32) -> i32 {
    if x >= 0 {
        return x; // 如果 x 是正數或零，直接回傳
    }
    -x            // 走到這裡代表 x 是負數，回傳 -x
}

fn main() {
    println!("abs(5) = {}", abs(5));
    println!("abs(-3) = {}", abs(-3));
    println!("abs(0) = {}", abs(0));
}

注意看：

• return x; → 用 return 關鍵字，要加分號
• 最後一行 -x → 不加分號，這是「自然回傳」

return vs 不加分號

兩種回傳方式的比較：

// 方式一：用 return（通常用在「提前離開」）
fn abs_v1(x: i32) -> i32 {
    if x >= 0 {
        return x;
    }
    -x
}

// 方式二：純粹用表達式（整個 if-else 就是回傳值）
fn abs_v2(x: i32) -> i32 {
    if x >= 0 {
        x
    } else {
        -x
    }
}

fn main() {}

兩種都對！Rust 社群的慣例是：

• 能用表達式寫的，就用表達式（方式二）
• 有「我想要提前離開」的意思時才用 return（方式一）

實用場景：提前擋掉不合法的輸入

fn divide(a: f64, b: f64) -> f64 {
    if b == 0.0 {
        println!("錯誤：不能除以零！");
        return 0.0; // 提前離開
    }

    // 這邊可能又做了很多其他事情......

    a / b
}

fn main() {
    println!("{}", divide(10.0, 3.0));
    println!("{}", divide(10.0, 0.0));
}

這種「先檢查、不對就提前走人」的寫法叫做 guard clause（守衛子句），在實務中非常常見。

不要到處用 return

雖然每個回傳值都寫 return 也能跑，但在 Rust 裡這不是好習慣：

// 不太 Rust 的寫法
fn add_v1(a: i32, b: i32) -> i32 {
    return a + b; // 可以跑，但沒必要
}

// Rust 慣用寫法
fn add_v2(a: i32, b: i32) -> i32 {
    a + b         // 最後一行直接當回傳值
}

fn main() {}

return 留給「提前離開」的場景就好。

重點整理

• return 值; 可以在函數中途提前回傳（記得加分號）
• 最後一行不加分號的自然回傳是 Rust 的慣用寫法
• return 最常用在 guard clause：先檢查條件，不對就提前走人
• 不要每個回傳值都寫 return，只在需要提前離開時才用

遞迴

本集目標

讓函數呼叫自己來解決問題，這個技巧叫做「遞迴」。

正文

你有沒有想過：函數可以在自己裡面呼叫自己嗎？

答案是可以的，而且這個技巧叫做遞迴（recursion）。聽起來很玄，但其實概念很簡單。

經典範例：階乘

「5 的階乘」寫成 5!，意思是 5 × 4 × 3 × 2 × 1 = 120。

用遞迴的思路想：

• 5! = 5 × 4!
• 4! = 4 × 3!
• 3! = 3 × 2!
• 2! = 2 × 1!
• 1! = 1（到這裡停下來）

看到了嗎？每一步都是「自己乘以比自己小一號的階乘」，最後到 1 就停。

fn factorial(n: u32) -> u32 {
    if n <= 1 {
        1
    } else {
        n * factorial(n - 1)
    }
}

fn main() {
    println!("5! = {}", factorial(5));
    println!("3! = {}", factorial(3));
    println!("1! = {}", factorial(1));
}

遞迴的兩個關鍵

每個遞迴函數都需要兩樣東西：

1. base case（基底情況）：什麼時候停下來

if n <= 1 {
    1 // 停！不再呼叫自己
}

2. recursive case（遞迴情況）：怎麼把問題縮小

n * factorial(n - 1) // 把問題縮小：n 變成 n - 1

如果忘記寫 base case，函數就會無限呼叫自己，最後程式就炸了。

追蹤執行過程

讓我們追蹤 factorial(5) 的執行過程：

factorial(5)
= 5 * factorial(4)
= 5 * (4 * factorial(3))
= 5 * (4 * (3 * factorial(2)))
= 5 * (4 * (3 * (2 * factorial(1))))
= 5 * (4 * (3 * (2 * 1)))
= 5 * (4 * (3 * 2))
= 5 * (4 * 6)
= 5 * 24
= 120

就像俄羅斯套娃一樣，一層一層展開，到底之後再一層一層收回來。

另一個例子：倒數

fn countdown(n: u32) {
    if n <= 0 {
        println!("發射！🚀");
        return;
    }
    println!("{}...", n);
    countdown(n - 1);
}

fn main() {
    countdown(5);
}

遞迴 vs 迴圈

其實上面的例子都可以用迴圈寫。那什麼時候用遞迴？什麼時候用迴圈？

• 簡單的重複 → 迴圈比較直覺
• 問題本身就是遞迴結構 → 遞迴比較自然

現在先知道遞迴怎麼寫就好，之後遇到適合的場景自然會用到。

重點整理

• 遞迴就是函數呼叫自己
• 一定要有 base case（停止條件），不然會無限迴圈
• 每次呼叫都要讓問題變小，往 base case 靠近

陣列基礎

本集目標

用陣列（array）把多個相同型別的值排成一列，並學會怎麼存取和建立。

正文

之前學了 tuple 可以把不同型別的值打包在一起。今天來認識另一個好朋友——陣列（array）。陣列是「把一堆相同型別的值排成一列」。

建立陣列

fn main() {
    let arr = [1, 2, 3, 4, 5];
    println!("{:?}", arr);
}

這裡用了 {:?}（Debug 格式）來印陣列——還記得本章第 5 集嗎？陣列和 tuple 一樣，只有 Debug 格式，不能用 {}。

用中括號 [] 包起來，逗號隔開。注意：陣列裡的值必須是同一個型別。

fn main() {
    let arr = [1, "hello", 3.14]; // ❌ 不行！型別不同
}

想混不同型別？用上幾集學的 tuple。

用索引取值

fn main() {
    let arr = [1, 2, 3, 4, 5];
    println!("第一個：{}", arr[0]);
    println!("第三個：{}", arr[2]);
    println!("最後一個：{}", arr[4]);
}

重點：索引從 0 開始！所以 5 個元素的索引是 0、1、2、3、4。

越界會 panic

如果你存取一個不存在的索引：

#![allow(unconditional_panic)]

fn main() {
    let arr = [1, 2, 3, 4, 5];
    println!("{}", arr[10]);  // 💥 index out of bounds!
}

程式會直接崩潰（panic），印出錯誤。Rust 不會讓你偷偷讀到不該讀的記憶體。比起默默給你一個垃圾值，直接崩潰反而更安全——至少你馬上知道哪裡出錯了。

陣列的型別

陣列的型別寫法是 [元素型別; 長度]：

fn main() {
    let arr: [i32; 5] = [1, 2, 3, 4, 5];
    println!("{:?}", arr);
}

[i32; 5] 代表「一個放 5 個 i32 的陣列」。注意，長度也是型別的一部分——[i32; 3] 和 [i32; 5] 是不同的型別！

大部分時候 Rust 可以自動推斷，不用手動標。但知道怎麼寫型別在之後會很有用。

快速建立：重複語法

如果你想建立一個「5 個 0」的陣列：

fn main() {
    let zeros = [0; 5];
    println!("{:?}", zeros);
}

[0; 5] 的意思是「值 0，重複 5 次」。分號前面是值，後面是個數。

再來幾個例子：

fn main() {
    let ones = [1; 10];    // 10 個 1
    let flags = [true; 3]; // 3 個 true
    println!("{:?}", ones);
    println!("{:?}", flags);
}

重點整理

• 陣列用 [值1, 值2, ...] 建立，所有元素必須同型別
• 索引從 0 開始，用 arr[0] 取值
• 存取超出範圍的索引會 panic（程式崩潰）
• 陣列型別寫法是 [型別; 長度]，如 [i32; 5]（長度也是型別的一部分）
• [值; 個數] 可以快速建立重複的陣列，如 [0; 5]
• 用 {:?} 印整個陣列

陣列走訪

本集目標

用 for 迴圈走過陣列裡的每一個元素。

正文

上一集我們學了怎麼用 arr[0]、arr[1] 一個一個取值。但如果陣列有 100 個元素，總不能寫 100 行吧？這時候就要用 for 迴圈來走訪（iterate）整個陣列。

基本語法

fn main() {
    let arr = [1, 2, 3, 4, 5];

    for x in arr {
        println!("{}", x);
    }
}

for x in arr 的意思是：「把 arr 裡的元素一個一個拿出來，每次放進 x，然後執行大括號裡的程式碼。」

幫元素做運算

fn main() {
    let scores = [80, 95, 72, 88, 100];

    for score in scores {
        if score >= 90 {
            println!("{} 分 → 優秀！", score);
        } else {
            println!("{} 分 → 加油！", score);
        }
    }
}

加總所有元素

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let mut total = 0;

    for x in arr {
        total += x;
    }

    println!("總和：{}", total);
}

先用 let mut total = 0; 建立一個可變的累加器，每次迴圈把值加上去。

for in range vs for in 陣列

第一章學的 for i in 0..5 是走訪一個數字範圍。這集的 for x in arr 是走訪一個陣列。語法一樣，只是 in 後面放的東西不同：

fn main() {
    let arr = [10, 20, 30];

    // 走訪數字範圍：i 依序是 0, 1, 2
    for i in 0..3 {
        println!("索引 {}：{}", i, arr[i]);
    }

    // 走訪陣列：x 依序是 10, 20, 30
    for x in arr {
        println!("值：{}", x);
    }
}

走訪陣列時用 for x in arr 比用索引更簡潔、更安全、也更快速——不用擔心索引越界。需要同時拿到索引和值的時候，之後會學到更好的方式。

重點整理

• for x in arr { ... } 走訪陣列的每個元素
• 可以在迴圈裡對每個元素做運算、判斷、累加
• for x in arr（走訪陣列）和 for i in 0..n（走訪範圍）語法一樣，差在 in 後面的東西
• 走訪陣列時用 for x in arr 比用索引更簡潔、更安全、也更快速

切片 &[T]

本集目標

用切片（slice）取出陣列的一部分，像透過窗戶看裡面的東西。

正文

有時候你不需要整個陣列，只想看其中一段。比如一個有 5 個元素的陣列，你只想看第 2 到第 4 個。這時候就可以用切片（slice）。

基本語法

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let slice = &arr[1..4];
    println!("{:?}", slice);
}

和陣列、tuple 一樣，切片也只能用 {:?} 來印，不能用 {}。

&arr[1..4] 的意思是：「從索引 1 開始，到索引 4 之前為止。」

• 索引 1 → 2（包含）
• 索引 2 → 3（包含）
• 索引 3 → 4（包含）
• 索引 4 → 5（不包含）

所以結果是 [2, 3, 4]。

範圍的寫法

fn main() {
    let arr = [1, 2, 3, 4, 5];

    let a = &arr[0..3];  // [1, 2, 3]         從 0 到 3（不含 3）
    let b = &arr[0..=2]; // [1, 2, 3]         從 0 到 2（包含 2）
    let c = &arr[2..];   // [3, 4, 5]         從 2 到最後
    let d = &arr[..3];   // [1, 2, 3]         從頭到 3（不含 3）
    let e = &arr[..];    // [1, 2, 3, 4, 5]   整個陣列

    println!("{:?}", a);
    println!("{:?}", b);
    println!("{:?}", c);
    println!("{:?}", d);
    println!("{:?}", e);
}

• 1..4 → 從 1 到 4（不含 4）
• 1..=3 → 從 1 到 3（包含 3），還記得第一章第 20 集的 ..= 嗎？一樣的用法
• 2.. → 從 2 到結尾
• ..3 → 從開頭到 3（不含 3）
• .. → 整個

切片是「視窗」，不是「複製」

這裡有個重要的觀念：切片不是把資料複製一份出來，而是「指向原本陣列的某一段」。就像透過窗戶看房間裡的東西——東西還是在房間裡，你只是從窗戶看進去。

fn main() {
    let arr = [10, 20, 30, 40, 50];
    let slice = &arr[1..4];
    
    println!("陣列：{:?}", arr);
    println!("切片：{:?}", slice);
}

那個 & 是什麼？

你可能注意到切片前面有個 &。這個符號代表「借用」（borrow），是 Rust 最重要的概念之一。但現在不用深入理解——先記住「切片要加 &」就好，之後我們會詳細解釋。

現在你只需要知道：寫切片的時候前面要加 &。

切片的型別

還記得陣列的型別是 [i32; 5]（型別包含長度）嗎？切片的型別是 &[i32]——沒有長度：

fn main() {
    let arr: [i32; 5] = [1, 2, 3, 4, 5];
    let slice: &[i32] = &arr[1..4];
    println!("{:?}", slice);
}

&[i32] 代表「一段 i32 的切片」，不管長度是多少。這是切片和陣列最大的不同——陣列的長度是型別的一部分（[i32; 3] 和 [i32; 5] 是不同型別），但切片不管長度，&[i32] 可以指向任意長度的連續區段。

走訪切片

切片也可以用 for 走訪：

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let slice = &arr[1..4];

    for x in slice {
        println!("{}", x);
    }
}

複合型別

學完切片之後，讓我們整理一下：到目前為止，我們學過兩類型別。

基本型別（primitive types）： i32、f64、bool、char 等等，每個值就是一個單獨的東西。

複合型別（compound types）： 把其他型別組合在一起的型別。我們已經學了三種：

• tuple：(i32, f64, bool) — 可以裝不同型別
• 陣列：[i32; 5] — 同一種型別，固定長度
• 切片：&[i32] — 同一種型別，不限長度

複合型別裡面的型別不一定要是基本型別，也能是一層複合型別套另一層複合型別：

fn main() {
    // 陣列裡面裝 tuple
    let pairs: [(i32, bool); 3] = [(1, true), (2, false), (3, true)];
    println!("{:?}", pairs);

    // tuple 裡面裝陣列
    let t: ([i32; 3], [i32; 3]) = ([1, 2, 3], [4, 5, 6]);
    println!("{:?}", t);

    // 陣列裡面裝陣列
    let grid: [[i32; 2]; 3] = [[1, 2], [3, 4], [5, 6]];
    println!("{:?}", grid);

    // 切片也是複合型別
    let arr: [i32; 5] = [10, 20, 30, 40, 50];
    let slice: &[i32] = &arr[1..4];
    println!("{:?}", slice);

    // tuple 裡面裝切片
    let pair: (&[i32], &[i32]) = (&arr[..2], &arr[3..]);
    println!("{:?}", pair);
}

重點整理

• 切片用 &arr[start..end] 或 &arr[start..=end] 取出陣列的一部分
• start..end 是「包含 start、不包含 end」
• start..=end 是「包含 start 也包含 end」
• 切片是陣列的「視窗」，不是複製
• 切片型別是 &[i32]（不含長度），陣列型別是 [i32; 5]（含長度）
• 前面的 & 代表借用，之後會詳細解釋
• 切片也可以用 for 走訪
• tuple、陣列、切片都是複合型別——它們裡面可以裝其他型別，包含複合型別

函數 + 切片參數

本集目標

用切片 &[i32] 當函數參數，這樣不管陣列多長都能傳進去。

正文

上一集學了切片，這集來看一個超實用的應用：把切片當作函數的參數。

先看問題

假設你想寫一個函數來計算陣列的總和。如果用陣列當參數：

fn sum(nums: [i32; 5]) -> i32 {
    let mut total = 0;
    for x in nums {
        total += x;
    }
    total
}

fn main() {
    let a = [1, 2, 3, 4, 5];
    println!("{}", sum(a)); // ✅ 可以

    let b = [1, 2, 3];
    println!("{}", sum(b)); // ❌ 不行！b 有 3 個元素，但函數要 5 個
}

問題出在 [i32; 5]——你把長度寫死成 5 了。3 個元素的陣列就傳不進去。

解決方案：用切片

fn sum(nums: &[i32]) -> i32 {
    let mut total = 0;
    for x in nums {
        total += x;
    }
    total
}

fn main() {
    let a = [1, 2, 3, 4, 5];
    let b = [10, 20, 30];
    let c = [7];

    println!("a 的總和：{}", sum(&a));  // 15
    println!("b 的總和：{}", sum(&b));  // 60
    println!("c 的總和：{}", sum(&c));  // 7
}

把參數型別從 [i32; 5] 改成 &[i32]，就能接受任何長度的陣列了！

呼叫的時候要加 &：sum(&a) 表示「把 a 的切片傳進去」。

也可以傳切片的一部分

因為參數是 &[i32]，你不只能傳整個陣列，也能傳一段切片：

fn sum(nums: &[i32]) -> i32 {
    let mut total = 0;
    for x in nums {
        total += x;
    }
    total
}

fn main() {
    let arr = [1, 2, 3, 4, 5];

    println!("全部：{}", sum(&arr));        // 15
    println!("前三個：{}", sum(&arr[..3]));  // 6
    println!("後三個：{}", sum(&arr[2..]));  // 12
}

這就是切片的威力——一個函數，各種用法。

為什麼切片比固定長度陣列好？

在實務中，幾乎所有接受陣列的函數都用切片當參數。

重點整理

• 函數參數用 &[i32] 而不是 [i32; 5]，就能接受任意長度
• 呼叫時傳 &arr 或 &arr[1..4] 都行
• 切片參數讓函數更靈活、更通用
• 這是 Rust 實務中最常見的寫法

字串切片 &str

本集目標

認識 &str 這個型別，原來我們一直在用的字串就是切片！

正文

前幾集我們學了陣列的切片 &[i32]。今天來認識另一種切片——字串切片。其實我們之前寫的 "hello" 就是字串切片。

字串的真面目

fn main() {
    let s = "hello";
    println!("{}", s);
}

這段程式碼你已經看了無數次了。但 s 的型別是什麼？

答案是：&str（字串切片）。

fn main() {
    let s: &str = "hello"; // 明確標出型別
    println!("{}", s);
}

&str 唸作「string slice」或「str ref」。它就像陣列切片 &[i32] 一樣，是「指向一段資料的視窗」。

和陣列切片的對比

概念完全一樣！只是一個是數字的切片，一個是文字的切片。

字串切片也可以取子字串

fn main() {
    let s = "hello world";
    let hello = &s[0..5];
    let world = &s[6..11];
    println!("{}", hello); // hello
    println!("{}", world); // world
}

&s[0..5] 就是取 s 的前 5 個 bytes（注意是 bytes，不是字元）。

和陣列切片一樣，也可以用 ..= 來包含結尾：

fn main() {
    let s = "hello world";
    let hello = &s[0..=4]; // 包含索引 4，等同於 &s[0..5]
    println!("{}", hello); // hello
}

⚠️ 中文字串切片要小心！

英文字母一個字佔 1 個 byte，但中文字通常佔 3 個 bytes。如果你切的位置剛好在一個中文字的「中間」，程式會直接崩潰：

fn main() {
    let s = "你好";
    let first = &s[0..3]; // ✅ "你"（剛好 3 個 bytes）
    println!("{}", first);
}

但如果你試著切 &s[0..1]：

fn main() {
    let s = "你好";
    let oops = &s[0..1];  // ❌ 程式崩潰！
    println!("{}", oops);
}

因為「你」佔了 3 個 bytes（索引 0、1、2），你切到索引 1 是這個字的「中間」，Rust 不允許這樣做。

簡單來說：對英文字串做切片很安全，但對中文字串做切片時，要確保切的位置剛好在字元的邊界上。如果不確定，先不要對中文字串用 &s[start..end]。

函數參數用 &str

現在你知道字串是 &str 了，就可以把它當函數參數：

fn greet(name: &str) {
    println!("嗨，{}！", name);
}

fn main() {
    greet("Andy");
    greet("小明");
}

"Andy" 本身就是 &str 型別，所以直接傳進去就行。

重點整理

• "hello" 的型別是 &str，就是字串切片
• &str 和陣列切片 &[i32] 的概念一樣——都是「指向一段資料的視窗」
• 函數參數寫 &str 就能接受字串
• 也可以用 &s[start..end] 取子字串，但要小心：索引是 byte 位置，不是字元位置，切在中文等多 byte 字元的中間會 panic

恭喜你完成了第二章！🎉 這一章我們學到了更多組織程式的方法——函數、陣列、切片，還有各種讓程式碼更清晰的技巧。下一章我們將開始自訂型別，用 struct 和 enum 來描述你自己的資料！

Struct、Enum 與 Pattern Matching

struct（named fields）

本集目標

學會用 struct 把多個相關的值組合在一起，形成一個自訂型別。

概念說明

到目前為止，我們用過的型別都是 Rust 內建的：i32、f64、bool、char，還有 tuple、陣列和切片。但實際寫程式的時候，你會需要自己定義新的型別。

struct 就是 Rust 讓你定義新型別的方式之一。定義一個 struct，就是在告訴 Rust：「我要一個新的型別，它裡面包含這些欄位。」

比如說，一個「點」有 x 座標和 y 座標。我們可以用 tuple (i32, i32) 來表示，但 tuple 只能用 .0、.1 取值，看不出哪個是 x、哪個是 y。用 struct 就能幫每個欄位取名字。

定義 struct 的語法是：

struct Point {
    x: i32,
    y: i32,
}

fn main() {}

struct 定義一般放在 fn main() 外面，這樣其他函數也能用到。放在上面或下面都可以（和函數一樣，不受定義順序限制）。

建立一個 struct 的值時，要用 型別名 { 欄位名: 值 } 的寫法。取值的時候用 .欄位名。如果要修改 struct 的欄位，變數必須加 mut。

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 3, y: 7 };
    println!("x 座標是 {}", p.x);
    println!("y 座標是 {}", p.y);

    // Point 是一個型別，就像 i32 一樣，可以用在型別標注上
    let p2: Point = Point { x: 100, y: 200 };
    println!("p2 的座標是 ({}, {})", p2.x, p2.y);

    // 也可以用 mut 讓 struct 的值可以修改
    let mut q = Point { x: 0, y: 0 };
    q.x = 10;
    q.y = 20;
    println!("q 的座標是 ({}, {})", q.x, q.y);
}

補充：trailing comma（結尾逗號）

注意 struct 定義裡，最後一個欄位後面也有逗號：

struct Point {
    x: i32,
    y: i32, // ← 這個逗號可加可不加
}

fn main() {}

Rust 允許在 struct 定義、struct 建立、函數呼叫等地方的最後一個項目後面加逗號。這叫做 trailing comma（結尾逗號）。加了不會錯，而且好處是之後新增欄位時，不用回去幫上一行補逗號，git diff 也比較乾淨。

Rust 社群慣例是加上 trailing comma。

重點整理

• struct 讓你定義一個有名字欄位的自訂型別
• struct 定義一般放在 fn main() 外面，上面或下面都可以（和函數一樣）
• 建立 struct 值的語法：Point { x: 1, y: 2 }
• 用 .欄位名 取得欄位的值，例如 p.x
• 如果要修改 struct 的欄位，變數必須加 mut
• 最後一個欄位後面的逗號（trailing comma）可加可不加，慣例是加

tuple struct 與 unit struct

本集目標

學會用 tuple struct 定義沒有欄位名的 struct，以及完全沒有欄位的 unit struct。

概念說明

上一集學的 struct 每個欄位都有名字。但有時候，欄位的意義已經很明顯了，不需要特別取名。這時候可以用 tuple struct——它長得像 tuple 和 struct 的混合體。

struct Point(i32, i32);

fn main() {}

建立值的時候用 Point(3, 7)——注意，這裡的 Point 既是型別的名字，也是建立值時使用的名字。取值用 .0、.1，就像 tuple 一樣。

上一集的 named-field struct 也是同樣的道理：Point 既是型別名，也是建立值時寫 Point { x: 1, y: 2 } 用的名字。

另外還有一種更極端的情況：struct 完全沒有欄位，叫做 unit struct。它通常用來當作一個「標記」，表示某種身份或角色，但本身不帶任何資料。

struct Marker;

fn main() {}

範例程式碼

// tuple struct：欄位沒有名字，用位置存取
struct Point(i32, i32);

// 另一個 tuple struct 的例子
struct Color(i32, i32, i32);

// unit struct：完全沒有欄位
struct Marker;

fn main() {
    let p: Point = Point(3, 7);
    println!("x = {}, y = {}", p.0, p.1);

    let red: Color = Color(255, 0, 0);
    println!("R={}, G={}, B={}", red.0, red.1, red.2);

    // unit struct 建立時不需要括號或大括號
    let _m: Marker = Marker;
    println!("Marker 被建立了！（它不帶任何資料）");
}

重點整理

• tuple struct：struct Point(i32, i32);，用 .0、.1 取值
• unit struct：struct Marker;，沒有任何欄位
• tuple struct 適合欄位意義明顯、不需要命名的情況
• unit struct 適合當標記用，本身不攜帶資料
• 即使兩個 tuple struct 的欄位型別完全一樣，它們也是不同的型別（例如 Point(i32, i32) 和 Size(i32, i32) 不能互換）

enum（C-style）

本集目標

學會用 enum 定義一組固定的選項，讓變數只能是其中一個值。

概念說明

上一集我們學了 struct——用來定義「把多個值組合在一起」的新型別。這一集要學另一種定義新型別的方式：enum。

有時候我們想表達「這個東西只能是幾個選項之一」。比如說，一個交通燈只能是紅、黃、綠其中一種。

enum（enumeration，列舉）就是用來定義這種「多選一」的型別。和 struct 一樣，定義一個 enum 就是在告訴 Rust：「我要一個新的型別，它的值只能是這幾個選項之一。」最簡單的 enum 長這樣：

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {}

每一個選項叫做一個 variant（變體）。建立 enum 值的時候，要用 型別名::變體名 的寫法：

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let c = Color::Red;
}

注意中間是兩個冒號 ::，這在 Rust 裡叫做「路徑運算子」，表示「Color 底下的 Red」。

這種最基本的 enum——每個 variant 都不帶任何額外資料——有時候稱為 C-style enum，因為 C 語言的 enum 就是這樣。

範例程式碼

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn main() {
    let dir = Direction::Up;

    // 目前我們還不會用 enum 做太多事
    // 下一集會學 match，就能根據 enum 的值做不同的事情
    // 這邊先展示怎麼建立不同的 enum 值

    let _d1 = Direction::Down;
    let _d2 = Direction::Left;
    let _d3 = Direction::Right;

    println!("方向已經設定好了！");
    println!("（下一集學 match 之後，就能根據方向做不同的事）");
}

重點整理

• enum 和 struct 一樣，都是定義新型別的方式
• struct：把多個值組合在一起；enum：從多個選項中選一個
• 用 :: 來指定是哪一個 variant，例如 Direction::Up
• C-style enum 的每個 variant 都不帶額外資料
• 和 struct 一樣，enum 定義一般放在 fn main() 外面，上面或下面都可以
• 目前還無法直接印出 enum 的值（下一集學 match 就可以了）

match C-style enum

本集目標

學會用 match 來根據 enum 的值執行不同的程式碼，並理解「窮舉」的概念。

概念說明

上一集我們定義了 enum，但沒辦法根據它的值做不同的事。現在來學 match——Rust 最強大的模式匹配（pattern matching）工具。

match 的基本語法是：

match 變數 {
    模式1 => 做某件事,
    模式2 => 做另一件事,
    模式3 => 做第三件事,
}

每一行叫做一個「分支」（arm）。Rust 會從上到下檢查，找到第一個符合的模式就執行對應的程式碼。

最重要的規則：match 必須窮舉所有可能的值。 如果你的 enum 有三個 variant，你就必須處理全部三個。少寫一個，編譯器就會報錯。這是 Rust 幫你抓 bug 的方式——確保你不會忘記處理某種情況。

和 struct 還有 enum 一樣，match 的最後一個分支後面也可以加 trailing comma（結尾逗號）。Rust 社群慣例是加上的。

範例程式碼

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let c = Color::Green;

    match c {
        Color::Red => println!("紅色"),
        Color::Green => println!("綠色"),
        Color::Blue => println!("藍色"),
    }

    // 再來一個例子
    let light = Color::Red;

    match light {
        Color::Red => println!("停下來！"),
        Color::Green => println!("可以走了！"),
        Color::Blue => println!("這個交通燈有點奇怪..."),
    }
}

重點整理

• match 會根據值比對不同的模式，執行對應的分支
• 每個分支用 => 分隔模式和要執行的程式碼
• match 必須窮舉所有 variant——少一個就編譯失敗
• 分支從上到下比對，第一個符合的就會執行
• match 是 Rust 處理 enum 最基本的方式

match 當表達式

本集目標

學會把 match 當作表達式使用，讓它回傳一個值。

概念說明

還記得第一章學過 if 可以當表達式嗎？

fn main() {
    let condition = true;
    let x = if condition { 1 } else { 2 };
}

match 也可以！你可以把整個 match 放在 let 的右邊，讓每個分支回傳一個值：

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let c = Color::Red;
    let msg = match c {
        Color::Red => "紅色",
        Color::Green => "綠色",
        Color::Blue => "藍色",
    };
}

注意最後面有一個分號 ;，因為整個 let msg = match ... { ... }; 是一個 let 陳述式。

每個分支回傳的值的型別必須一致。如果第一個分支回傳 &str，其他分支也都要回傳 &str。

範例程式碼

enum Season {
    Spring,
    Summer,
    Autumn,
    Winter,
}

fn main() {
    let s = Season::Autumn;

    // match 當表達式，回傳 &str
    let name = match s {
        Season::Spring => "春天",
        Season::Summer => "夏天",
        Season::Autumn => "秋天",
        Season::Winter => "冬天",
    };
    println!("現在是{}", name);

    // match 當表達式，回傳 i32
    let temp = match s {
        Season::Spring => 22,
        Season::Summer => 35,
        Season::Autumn => 18,
        Season::Winter => 8,
    };
    println!("大約 {} 度", temp);
}

重點整理

• match 可以當表達式，整個 match 會回傳一個值
• 用法：let x = match ... { ... };（最後別忘了分號）
• 所有分支的回傳值型別必須一致
• 這和 if 表達式的概念相同——Rust 裡很多東西都可以是表達式

block 表達式

本集目標

學會用大括號 {} 建立 block 表達式，在裡面執行多行程式碼後回傳一個值。

概念說明

在 Rust 裡，一對大括號 {} 不只是作用域，它本身也是一個表達式，可以回傳值。規則很簡單：block 裡面最後一行如果不加分號，那一行的值就是整個 block 的回傳值。

fn main() {
    let x = {
        let y = 5;
        y + 1 // 沒有分號 → 這就是 block 的回傳值
    };
    // x 現在是 6
}

這個概念在 match 裡特別有用。之前的 match 分支都只有一行，但如果你想在某個分支裡做多件事，就可以用 block：

enum Color {
    Red,
    Green,
    Blue,
}

fn describe_color() -> &'static str {
    let c = Color::Red;
    match c {
        Color::Red => {
            println!("是紅色！");
            "red"
        }
        // ...
        _ => "",
    }
}

fn main() {}

block 裡可以宣告變數、做計算，最後一行不加分號就是回傳值。

注意：如果 match 的分支用了 block {}，後面的逗號可以省略。因為 } 本身就是明確的結束標記，Rust 不需要逗號來分隔。但如果分支只有一行（沒有用 block），後面的逗號就不能省。

enum Season {
    Spring,
    Summer,
    Autumn,
    Winter,
}

fn describe_season() -> &'static str {
    let s = Season::Summer;
    match s {
        Season::Summer => {
            println!("好熱啊！");
            "炎熱的夏天"
        }                             // ← 沒有逗號，OK
        Season::Autumn => "涼爽的秋天", // ← 一行的分支，要逗號
        // ...
        _ => "",
    }
}

fn main() {}

範例程式碼

enum Season {
    Spring,
    Summer,
    Autumn,
    Winter,
}

fn main() {
    // block 表達式的基本用法
    let result = {
        let a = 10;
        let b = 20;
        a + b // 最後一行不加分號 → 回傳值
    };
    println!("result = {}", result);

    // 在 match 分支裡使用 block
    let s = Season::Summer;

    let description = match s {
        Season::Spring => {
            let temp = 22;
            println!("春暖花開");
            if temp > 20 {
                "溫暖的春天"
            } else {
                "還有點涼的春天"
            }
        }
        Season::Summer => {
            println!("好熱啊！");
            "炎熱的夏天"
        }
        Season::Autumn => "涼爽的秋天",
        Season::Winter => "寒冷的冬天",
    };
    println!("{}", description);
}

重點整理

• {} block 本身是一個表達式，最後一行不加分號就是回傳值
• let x = { ... }; 可以在 block 裡做多行計算後把結果賦值給 x
• match 分支可以用 => { ... } 來執行多行程式碼，而且 block 後面不用加逗號
• block 裡宣告的變數只在 block 內有效（作用域）
• block 表達式在 Rust 裡非常常見，是很重要的基礎概念

enum 攜帶 tuple variant

本集目標

學會讓 enum 的 variant 攜帶額外的資料，像 tuple 一樣。

概念說明

之前學的 C-style enum，每個 variant 就只是一個名字，不帶任何資料。但很多時候，不同的選項需要攜帶不同的資料。

比如說，「形狀」可以是圓形或長方形。圓形需要一個半徑，長方形需要寬和高——它們需要的資料不一樣。在 Rust 裡，你可以讓每個 variant 攜帶資料：

enum Shape {
    Circle(f64),         // 攜帶一個 f64（半徑）
    Rectangle(i32, i32), // 攜帶兩個 i32（寬、高）
}

fn main() {}

這種寫法像是在 variant 名字後面加上 tuple 的欄位，所以叫做 tuple variant。

建立值的方式就像呼叫函數一樣，把資料放在括號裡：

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}

fn main() {
    let s = Shape::Circle(3.14);
    let r = Shape::Rectangle(10, 20);
}

注意：現在我們知道怎麼建立帶資料的 enum 了，但要「取出」裡面的資料，需要用 match——這個我們第 9 集會學。

範例程式碼

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}

enum Message {
    Quit,           // 不帶資料（就像 C-style）
    Echo(i32),      // 帶一個 i32
    Move(i32, i32), // 帶兩個 i32
}

fn main() {
    let s1 = Shape::Circle(5.0);
    let s2 = Shape::Rectangle(10, 20);

    let m1 = Message::Quit;
    let m2 = Message::Echo(42);
    let m3 = Message::Move(3, 7);

    // 目前先建立值就好
    // 第 9 集會學怎麼用 match 取出裡面的資料
    println!("形狀和訊息都建立好了！");

    // 同一個 enum 裡，不同 variant 可以帶不同數量、不同型別的資料
    // 甚至有些 variant 不帶資料也完全沒問題（像 Message::Quit）
}

重點整理

• enum variant 可以攜帶資料：Circle(f64) 表示 Circle 帶一個 f64
• 建立帶資料的 variant：Shape::Circle(5.0)
• 同一個 enum 裡，不同 variant 可以帶不同的資料
• 有些 variant 可以不帶資料，有些帶一個，有些帶多個——很靈活
• 要取出 variant 裡的資料，需要用 match（第 9 集會學）

enum 攜帶 struct variant

本集目標

學會讓 enum 的 variant 用類似 struct 的方式攜帶有名字的欄位。

概念說明

上一集學了 tuple variant，欄位沒有名字，用位置來區分。但如果一個 variant 攜帶的資料比較多，沒有名字就很容易搞混。

Rust 允許你用類似 named-field struct 的寫法，讓 variant 的每個欄位都有名字：

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
}

fn main() {}

建立值的時候就像建立 struct 一樣：

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
}

fn main() {
    let s = Shape::Circle { radius: 5.0 };
    let r = Shape::Rectangle { width: 10, height: 20 };
}

同一個 enum 裡，有些 variant 可以用 tuple 形式，有些可以用 struct 形式，甚至有些不帶資料，完全可以混搭。

範例程式碼

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
    Dot,  // 不帶資料的 variant 也可以混在一起
}

fn main() {
    let s1 = Shape::Circle { radius: 5.0 };
    let s2 = Shape::Rectangle { width: 10, height: 20 };
    let s3 = Shape::Dot;

    // 目前還不能直接取出裡面的欄位
    // 第 10 集會學怎麼用 match 取出 struct variant 的資料
    println!("三種形狀都建立好了！");

    // 一個更生活化的例子
    let event = Event::Click { x: 100, y: 200 };
    println!("事件已建立！");
}

enum Event {
    Click { x: i32, y: i32 },
    KeyPress(char), // tuple 形式也可以混搭
    Quit,           // 不帶資料也行
}

重點整理

• variant 可以用 struct 形式攜帶有名字的欄位：Circle { radius: f64 }
• 建立值：Shape::Circle { radius: 5.0 }
• 同一個 enum 可以混搭：有的用 tuple 形式、有的用 struct 形式、有的不帶資料
• struct 形式的好處是欄位有名字，程式碼更容易讀懂
• 取出欄位資料需要用 match（第 10 集會學）

match 解構 tuple variant

本集目標

學會用 match 解構 enum tuple variant，取出裡面攜帶的資料。

概念說明

第 7 集我們學了怎麼建立帶資料的 enum variant，但一直沒辦法取出裡面的資料。現在終於可以了！

在 match 的模式裡，你可以用變數名來「接住」variant 裡的資料：

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}
fn main() {
    let s = Shape::Circle(42.0); 
    match s {
        Shape::Circle(r) => println!("半徑是 {}", r),
        Shape::Rectangle(w, h) => println!("寬 {}，高 {}", w, h),
    }
}

Shape::Circle(r) 裡的 r 不是固定的名字——你可以取任何名字。它的意思是「如果 s 是 Circle，就把裡面的那個 f64 值取出來，叫做 r」。

這個動作叫做解構（destructuring）——把一個複合的東西拆開，取出裡面的各個部分。match 不只是比對「是哪個 variant」，還能同時把裡面的資料解構出來給你用。

範例程式碼

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}

fn main() {
    let s = Shape::Circle(5.0);

    match s {
        Shape::Circle(r) => {
            println!("這是一個圓形");
            println!("半徑是 {}", r);
            let area = r * r * 3.14159;
            println!("面積大約是 {}", area);
        }
        Shape::Rectangle(w, h) => {
            println!("這是一個長方形");
            println!("寬 {}，高 {}", w, h);
            let area = w * h;
            println!("面積是 {}", area);
        }
    }

    // 再一個例子
    let action = Action::Move(3, -2);

    match action {
        Action::Stop => println!("停止不動"),
        Action::Move(dx, dy) => {
            println!("往 x 方向移動 {}，往 y 方向移動 {}", dx, dy);
        }
    }
}

enum Action {
    Stop,
    Move(i32, i32),
}

重點整理

• 解構（destructuring）：把複合的東西拆開，取出裡面的各個部分
• 在 match 模式裡，可以在括號中使用變數名解構 tuple variant
• Shape::Circle(r) → 把 Circle 裡的值取出來叫做 r
• Shape::Rectangle(w, h) → 把 Rectangle 裡的兩個值分別叫做 w 和 h
• 變數名可以自己取
• match 依然要窮舉所有 variant

match 解構 struct variant

本集目標

學會用 match 解構 enum struct variant，取出裡面的有名字欄位。

概念說明

第 9 集學了怎麼解構 tuple variant（用位置），現在來學著解構 struct variant（用欄位名）。

語法是在模式裡用 欄位名: 變數名 的寫法：

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
}
fn main() {
    let s = Shape::Circle { radius: 42.0 }; 
    match s {
        Shape::Circle { radius: r } => println!("半徑 {}", r),
        Shape::Rectangle { width: w, height: h } => println!("{}x{}", w, h),
    }
}

radius: r 的意思是「把 radius 這個欄位的值取出來，叫做 r」。冒號左邊是欄位名，右邊是你自己取的變數名。

這和建立 struct variant 的語法很像，只是方向相反：建立是「把值放進去」，match 是「把值拿出來」。

範例程式碼

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
}

fn main() {
    let s = Shape::Rectangle { width: 10, height: 5 };

    match s {
        Shape::Circle { radius: r } => {
            println!("這是圓形，半徑 = {}", r);
            let area = r * r * 3.14159;
            println!("面積大約 {}", area);
        }
        Shape::Rectangle { width: w, height: h } => {
            println!("這是長方形");
            println!("寬 = {}，高 = {}", w, h);
            let area = w * h;
            println!("面積 = {}", area);
            let perimeter = 2 * (w + h);
            println!("周長 = {}", perimeter);
        }
    }
}

一般的 struct 也能用同樣的方式

不只 enum 的 struct variant，一般的 named-field struct 也能用同樣的方式解構：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 3, y: 0 };

    match p {
        Point { x: 0, y: 0 } => println!("原點"),
        Point { x: a, y: 0 } => println!("在 x 軸上，x = {}", a),
        Point { x: 0, y: b } => println!("在 y 軸上，y = {}", b),
        Point { x: a, y: b } => println!("在 ({}, {})", a, b),
    }
}

語法完全一樣——型別名 { 欄位名: 變數名 }。

注意上面的模式混用了固定的值和變數：Point { x: 0, y: b } 裡面 x: 0 是固定值（只在 x 等於 0 的時候才符合），y: b 是變數（把 y 的值取出來叫 b）。這個技巧在 match 裡很常用。match 會從上到下依序比對每個模式。一旦比對成功，就執行右手邊的程式碼，執行完後直接離開整個 match——不會繼續往下比對。

重點整理

• 在 match 裡用 欄位名: 變數名 來解構 struct variant
• Shape::Circle { radius: r } → 把 radius 欄位取出來叫做 r
• 冒號左邊是欄位名（必須和定義一樣），右邊是你自己取的變數名
• 一般的 named-field struct 也能用同樣的方式在 match 裡解構
• 模式裡可以混用固定值和變數：Point { x: 0, y: b } 表示「x 必須是 0，y 取出來叫 b」
• match 從上到下比對，一旦成功就執行該分支的程式碼然後離開 match
• 所有欄位都要寫出來（目前是這樣，之後會學怎麼忽略）

field shorthand

本集目標

學會用 field shorthand 簡化 struct 的建立和模式匹配。

概念說明

上一集在 match 裡寫了 radius: r，意思是把 radius 欄位取出來叫做 r。但如果你想讓變數名就叫做 radius 呢？按照之前的寫法要寫 radius: radius——欄位名和變數名重複了，有點囉嗦。

Rust 提供了一個簡寫：如果變數名和欄位名一樣，可以只寫一次：

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
}

fn main() {
    let radius = 42.0;
    // 完整寫法
    Shape::Circle { radius: radius };
    // 簡寫（field shorthand）
    Shape::Circle { radius };
}

這個簡寫不只在 match 裡可以用，建立 struct 的時候也可以用：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let x = 3;
    let y = 7;
    // 完整寫法
    let p = Point { x: x, y: y };
    // 簡寫
    let p = Point { x, y };
}

只要變數名和欄位名一樣，就能省略 : 變數名 的部分。

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
}

fn main() {
    // 建立 struct 時使用 field shorthand
    let x = 5;
    let y = 10;
    let p = Point { x, y }; // 等同於 Point { x: x, y: y }
    println!("點的座標：({}, {})", p.x, p.y);

    // 建立 enum struct variant 時也可以用
    let radius = 3.5;
    let s = Shape::Circle { radius }; // 等同於 Shape::Circle { radius: radius }

    // match 裡也可以用 field shorthand
    match s {
        Shape::Circle { radius } => {
            println!("圓形，半徑 = {}", radius);
        }
        Shape::Rectangle { width, height } => {
            println!("長方形 {}x{}", width, height);
        }
    }
}

重點整理

• 當變數名和欄位名相同時，可以只寫一次：Point { x, y } 等同於 Point { x: x, y: y }
• 這個簡寫叫做 field shorthand
• 建立 struct / enum variant 時可以用
• match 模式裡也可以用
• 這是一個很常見的寫法，實際寫 Rust 時常常用簡寫

tuple pattern

本集目標

學會在 match 裡解構一般的 tuple 與 tuple struct。

概念說明

第 9 集學了怎麼在 match 裡解構 enum variant。其實不只 enum，我們也能用 match 解構一般的 tuple！

fn main() {
    let point = (3, 7);

    match point {
        (0, 0) => println!("原點"),
        (x, 0) => println!("在 x 軸上，x = {}", x),
        (0, y) => println!("在 y 軸上，y = {}", y),
        (x, y) => println!("在 ({}, {})", x, y),
    }
}

match 會從上到下比對：

• (0, 0) → 兩個值都是 0 才會符合
• (x, 0) → 第二個值是 0，第一個值隨便（取出來叫 x）
• (0, y) → 第一個值是 0，第二個值隨便
• (x, y) → 什麼都會符合（最後一個分支當「預設」）

跟第 10 集學的一樣，模式裡可以混用「固定的值」和「變數」。固定的值用來比對，變數用來接住資料。

範例程式碼

fn main() {
    let point = (2, 0);

    match point {
        (0, 0) => println!("原點"),
        (x, 0) => println!("在 x 軸上，x = {}", x),
        (0, y) => println!("在 y 軸上，y = {}", y),
        (x, y) => println!("一般的點 ({}, {})", x, y),
    }

    // 用 match 搭配 tuple 做簡單的分類
    let score = (85, 90);

    match score {
        (100, 100) => println!("雙滿分！"),
        (a, b) => {
            println!("國文 {}，數學 {}", a, b);
            let total = a + b;
            println!("總分 {}", total);
        }
    }
}

tuple struct 也能用同樣的方式

還記得第 2 集學的 tuple struct 嗎？它的模式匹配方式和一般 tuple 一模一樣：

struct Point(i32, i32);

fn main() {
    let p = Point(3, 0);

    match p {
        Point(0, 0) => println!("原點"),
        Point(x, 0) => println!("在 x 軸上，x = {}", x),
        Point(0, y) => println!("在 y 軸上，y = {}", y),
        Point(x, y) => println!("在 ({}, {})", x, y),
    }
}

唯一的差別是模式前面要加上型別名稱 Point(...)，而普通 tuple 直接寫 (...)。

重點整理

• 一般的 tuple 也可以拿來 match
• tuple struct 也能用同樣的方式進行模式匹配，只是前面要加型別名稱：Point(x, y)

slice pattern

本集目標

學會用 slice pattern 解構陣列和切片。

概念說明

對陣列進行模式匹配

上一集我們學了如何解構 tuple，其實我們也可以對陣列和切片進行模式匹配！就是用 [a, b, c] 這種 slice pattern 來比對陣列的每個元素：

fn main() {
    let rgb = [255, 128, 0];

    match rgb {
        [255, 0, 0] => println!("純紅色"),
        [0, 255, 0] => println!("純綠色"),
        [0, 0, 255] => println!("純藍色"),
        [r, g, b] => println!("自訂顏色：R={}, G={}, B={}", r, g, b),
    }
}

跟前面幾集很像，你可以在模式裡混用「固定的值」和「變數」。固定的值用來比對，變數用來接住資料。

切片也能用

不只固定長度的陣列，切片（&[T]）也能用 slice pattern。差別在於切片的長度在編譯期是未知的，所以你可以用不同長度的模式來匹配：

fn describe(numbers: &[i32]) {
    match numbers {
        [] => println!("空的"),
        [x] => println!("只有一個元素：{}", x),
        [x, y] => println!("兩個元素：{} 和 {}", x, y),
        [x, y, z] => println!("三個元素：{}, {}, {}", x, y, z),
        _ => println!("超過三個元素"),
    }
}

fn main() {}

固定長度的陣列永遠是固定的長度，像[i32; 3] 的分支永遠不會匹配到 [] 或 [x]。切片才需要考慮不同長度的情況。

範例程式碼

fn describe(data: &[i32]) {
    match data {
        [] => println!("空的切片"),
        [only] => println!("只有一個元素：{}", only),
        [first, second] => println!("兩個元素：{} 和 {}", first, second),
        _ => println!("有很多元素，第一個是 {}", data[0]),
    }
}

fn main() {
    // 固定長度陣列的 slice pattern
    let rgb = [255, 128, 0];

    match rgb {
        [255, 0, 0] => println!("純紅色"),
        [0, 255, 0] => println!("純綠色"),
        [0, 0, 255] => println!("純藍色"),
        [r, g, b] => println!("自訂顏色：R={}, G={}, B={}", r, g, b),
    }

    println!("---");

    // 切片的 slice pattern——可以匹配不同長度
    describe(&[]);
    describe(&[42]);
    describe(&[1, 2]);
    describe(&[10, 20, 30, 40, 50]);
}

重點整理

• 遇到陣列的時候，可以在 match 時用 [a, b, c] 這種 slice pattern，跟 tuple pattern 類似
• 切片 &[T] 長度不固定，可以用不同長度的模式來匹配（[]、[x]、[x, y]……）

巢狀 pattern matching

本集目標

學會在 match 裡面再解構更深層的結構——巢狀的模式比對。

概念說明

到目前為止，我們的 match 都只解構一層。但如果資料結構是巢狀的呢？比如一個 tuple 裡面包著 enum，或是一個 enum 裡面包著另一個 struct？

Rust 的 pattern matching 可以一次解構好幾層，就像剝洋蔥一樣，一層一層往裡面拿。

比如說，你有一個 tuple (i32, Shape)，你可以在 match 裡同時解構 tuple 和裡面的 Shape：

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}

fn main() {
    let data = (666, Shape::Circle(42.0));
    match data {
        (id, Shape::Circle(r)) => println!("#{} 是圓形，半徑 {}", id, r),
        (id, Shape::Rectangle(w, h)) => println!("#{} 是長方形 {}x{}", id, w, h),
    }
}

一個模式裡，外層解構 tuple 取出 id 和 Shape，內層再解構 Shape 取出裡面的資料。全部在一行完成！

範例程式碼

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    // 範例一：tuple 裡面包 enum
    let data = (1, Shape::Circle(5.0));

    match data {
        (id, Shape::Circle(r)) => {
            println!("形狀 #{} 是圓形，半徑 {}", id, r);
        }
        (id, Shape::Rectangle(w, h)) => {
            println!("形狀 #{} 是長方形 {}x{}", id, w, h);
        }
    }

    // 範例二：tuple 裡面包 struct
    let item = ("原點", Point { x: 0, y: 0 });

    match item {
        (name, Point { x, y }) => {
            println!("{}：座標 ({}, {})", name, x, y);
        }
    }
}

重點整理

• Rust 的 pattern matching 可以解構多層巢狀結構
• 可以在一個模式裡同時解構 tuple + enum、tuple + struct 等
• 巢狀解構讓你不需要寫多個 match，一次就能把所有資料取出來
• 寫法就是把模式一層一層嵌進去，和資料的結構對應

_ wildcard

本集目標

學會用 _ 來忽略不關心的值，以及在 match 裡建立預設分支。

概念說明

有時候在 match 裡，我們只關心某幾種情況，其他的都想「忽略」。Rust 提供了 _（底線）作為 wildcard（萬用字元），它可以匹配任何值，但不會把值綁定到變數上。

最常見的用法有兩種：

1. 預設分支：_ => ...

放在 match 的最後面，表示「其他所有情況都走這裡」：

fn main() {
    let score = 95;
    match score {
        100 => println!("滿分！"),
        _ => println!("不是滿分"),
    }
}

2. 忽略某個位置的值

在 tuple 或 enum 的模式裡，用 _ 佔住不需要的位置：

fn main() {
    let point = (5, 5);
    match point {
        (0, _) => println!("在 y 軸上"), // 不關心第二個值
        (_, 0) => println!("在 x 軸上"), // 不關心第一個值
        (_, _) => println!("其他位置"),
    }
}

範例程式碼

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn main() {
    // _ 作為預設分支
    let dir = Direction::Left;

    match dir {
        Direction::Up => println!("往上"),
        _ => println!("不是往上（可能是下、左、右）"),
    }

    // _ 忽略 tuple 裡的某個值
    let record = ("Alice", 95, 'A');

    match record {
        (name, _, _) => println!("名字是 {}", name),
    }

    // 混合使用
    let data = (1, Direction::Up);

    match data {
        (_, Direction::Up) => println!("方向是上（不管編號是多少）"),
        (id, _) => println!("編號 {}（方向不是上）", id),
    }

    // 在 i32 上使用 _ 作為預設
    let score = 87;

    match score {
        100 => println!("滿分！"),
        0 => println!("零分..."),
        _ => println!("得了 {} 分", score),
    }
}

重點整理

• _ 是 wildcard，匹配任何值但不綁定變數
• _ => ... 放在 match 最後面當「預設分支」，處理所有未列出的情況
• 在模式裡用 _ 忽略不需要的欄位
• 有了 _，match 就不用每個 variant 都寫出來了

.. 忽略多個值

本集目標

學會用 .. 一次忽略 struct 或 tuple 中多個不關心的值。

概念說明

上一集學了用 _ 忽略一個值。但如果一個 struct 有很多欄位，而你只關心其中一兩個呢？每個不要的都寫 _ 太麻煩了。

Rust 提供了 ..（兩個點），意思是「剩下的我都不要了」。

在 match struct 時使用

struct Player {
    id: i32,
    hp: i32,
    mp: i32,
    level: i32,
}

fn main() {
    let p = Player { id: 1, hp: 0, mp: 50, level: 10 };

    match p {
        Player { hp: 0, .. } => println!("這個玩家倒下了！"),
        Player { level, .. } => println!("等級 {}", level),
    }
}

Player { hp: 0, .. } 表示「hp 是 0，其他欄位我不管」。不用每個不要的欄位都寫 _。

enum 的 struct variant 也能這樣匹配，用法完全一樣。

在 match tuple 時使用

fn main() {
    let scores = (90, 85, 78, 92, 88);

    match scores {
        (first, ..) => println!("第一科：{}", first),
    }

    match scores {
        (.., last) => println!("最後一科：{}", last),
    }

    match scores {
        (first, .., last) => println!("第一科 {}，最後一科 {}", first, last),
    }
}

(first, ..) 只取第一個，(.., last) 只取最後一個，(first, .., last) 取頭和尾。

tuple struct 和 enum 的 tuple variant 也能用類似的方式匹配，例如 MyStruct(first, ..) 或 MyEnum::Variant(first, ..)。

在陣列和切片裡使用

第 13 集學過 slice pattern，.. 在陣列和切片裡也一樣好用：

fn main() {
let data: &[i32] = &[10, 20, 30, 40, 50];

match data {
    [first, .., last] => println!("頭 = {}，尾 = {}", first, last),
    [only] => println!("只有一個：{}", only),
    [] => println!("空的"),
}
}

注意：.. 只能出現一次

.. 在一層的模式裡只能出現一次，因為如果出現兩次，Rust 會不知道中間的值怎麼分配。

範例程式碼

struct Player {
    id: i32,
    hp: i32,
    mp: i32,
    level: i32,
}

fn main() {
    // struct 上使用 ..
    let p1 = Player { id: 1, hp: 100, mp: 50, level: 10 };

    match p1 {
        Player { hp, .. } => println!("HP = {}", hp),
    }

    let p2 = Player { id: 2, hp: 0, mp: 30, level: 5 };

    match p2 {
        Player { hp: 0, .. } => println!("這個玩家已經倒下了！"),
        Player { level, .. } => println!("等級 {}", level),
    }

    // tuple 上使用 ..
    let scores = (90, 85, 78, 92, 88);

    match scores {
        (first, ..) => println!("第一科：{}", first),
    }

    match scores {
        (.., last) => println!("最後一科：{}", last),
    }

    match scores {
        (first, .., last) => println!("第一科 {}，最後一科 {}", first, last),
    }

    // 切片上使用 ..
    let data: &[i32] = &[10, 20, 30, 40, 50];

    match data {
        [first, .., last] => println!("頭 = {}，尾 = {}", first, last),
        [only] => println!("只有一個：{}", only),
        [] => println!("空的"),
    }
}

重點整理

• .. 用來一次忽略多個欄位或值
• match struct 時：Player { hp, .. } 只取 hp，其他全部忽略；enum 的 struct variant 也一樣
• match tuple 時：(first, ..) 只取第一個，(.., last) 只取最後一個；tuple struct 和 enum 的 tuple variant 用類似寫法
• 陣列和切片裡：[first, ..] 取第一個，[first, .., last] 取頭和尾
• .. 在一層模式裡只能出現一次

range pattern

本集目標

學會在 match 裡用範圍來比對數值。

概念說明

之前學 match 的時候，我們都是一個一個值去比對。但如果想比對「1 到 5 之間的任何數字」呢？總不能寫五個分支吧。

Rust 提供了 range pattern，讓你在 match 裡用範圍來比對：

fn main() {
    let score = 12;
    match score {
        1..=5 => println!("低分"),
        _ => {}
    }
}

1..=5 代表 1、2、3、4、5（包含頭尾）。這個 ..= 和第一章學的 for i in 0..=5 是差不多的意思。

除了 ..=（包含結尾），也可以用 ..（不包含結尾）：

fn main() {
    let score = 65;
    match score {
        0..50 => println!("不及格"),  // 0 到 49
        50..=100 => println!("及格"), // 50 到 100（包含）
        _ => {}
    }
}

注意：兩種 .. 不要搞混！

上一集的 .. 和這一集的 .. 長得一模一樣，但意義完全不同：

• 上一集：Point { x, .. } → 忽略剩餘欄位，.. 代表「其他我不管了」
• 這一集：0..50 → 數值範圍，.. 代表「從某個數到某個數」

Rust 編譯器會根據前後文判斷是哪一種，不會搞混。但初學時要注意分辨。

單邊範圍

range pattern 也支援只寫一邊：

fn main() {
    let temperature = 25;
    match temperature {
        ..0 => println!("零下"),        // 小於 0
        0..=30 => println!("普通"),     // 0 到 30
        31.. => println!("很熱"),       // 31 以上
    }
}

char 也能用

range pattern 不只能用在數字，也能用在 char：

fn main() {
    let c = '哼';
    match c {
        'a'..='z' => println!("小寫英文字母"),
        'A'..='Z' => println!("大寫英文字母"),
        '0'..='9' => println!("數字"),
        _ => println!("其他字元"),
    }
}

範例程式碼

fn main() {
    // 用 range pattern 判斷分數等級
    let score = 78;

    match score {
        90..=100 => println!("A"),
        80..90 => println!("B"),
        70..80 => println!("C"),
        60..70 => println!("D"),
        0..60 => println!("F"),
        _ => println!("分數超出範圍"),
    }

    // 單邊範圍
    let temperature = -5;

    match temperature {
        ..0 => println!("零下，很冷！"),
        0..=35 => println!("還可以"),
        36.. => println!("太熱了！"),
    }

    // char 的 range pattern
    let c = 'G';

    match c {
        'a'..='z' => println!("'{}' 是小寫字母", c),
        'A'..='Z' => println!("'{}' 是大寫字母", c),
        '0'..='9' => println!("'{}' 是數字", c),
        _ => println!("'{}' 是其他字元", c),
    }
}

重點整理

• .. 和 ..= 除了能用在 for 迴圈上，還能用來當作 pattern
• 1..=5 → 包含頭尾（1, 2, 3, 4, 5）
• 0..50 → 包含頭、不包含尾（0 到 49）
• ..0 → 小於 0；31.. → 31 以上（單邊範圍）
• char 也能用 range pattern：'a'..='z'
• 這裡的 .. 是「數值範圍」，和上一集忽略欄位的 .. 是不同的東西，不要搞混

多個值 |

本集目標

學會在 match 的同一個分支裡比對多個可能的值。

概念說明

有時候你想讓好幾個值都執行同樣的程式碼。比如說，星期六和星期天都是假日，不需要分開寫兩個分支。

Rust 用 |（直線符號）來表示「或」：

fn main() {
    let day = 1;
    match day {
        6 | 7 => println!("假日"),
        _ => println!("工作日"),
    }
}

6 | 7 的意思是「6 或 7」。你可以用 | 串接任意多個值：

fn main() {
    let n = 3;
    match n {
        1 | 2 | 3 => println!("前三名"),
        _ => println!("其他"),
    }
}

也可以搭配 enum 使用：

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let color = Color::Red;
    match color {
        Color::Red | Color::Blue => println!("冷暖色"),
        Color::Green => println!("綠色"),
    }
}

範例程式碼

enum Season {
    Spring,
    Summer,
    Autumn,
    Winter,
}

fn main() {
    // 數字的多值比對
    let month = 7;

    match month {
        3 | 4 | 5 => println!("春天"),
        6 | 7 | 8 => println!("夏天"),
        9 | 10 | 11 => println!("秋天"),
        12 | 1 | 2 => println!("冬天"),
        _ => println!("無效月份"),
    }

    // enum 的多值比對
    let s = Season::Autumn;

    let is_hot = match s {
        Season::Summer => true,
        Season::Spring | Season::Autumn | Season::Winter => false,
    };
    println!("天氣熱嗎？{}", is_hot);

    // 搭配 range pattern 和 |
    let ch = '5';

    match ch {
        'a'..='z' | 'A'..='Z' => println!("字母"),
        '0'..='9' => println!("數字"),
        ' ' | '\t' | '\n' => println!("空白字元"),
        _ => println!("其他"),
    }
}

重點整理

• | 在 match 裡表示「或」，讓同一個分支比對多個值
• 語法：模式1 | 模式2 | 模式3 => ...
• 可以搭配 enum variant 使用
• 也可以搭配 range pattern 使用：'a'..='z' | 'A'..='Z'
• 當多個值要做相同處理時，用 | 比寫多個分支更簡潔

@ 綁定

本集目標

學會用 @ 在比對範圍的同時，把符合的值綁定到一個變數上。

概念說明

上一集學了 range pattern：1..=5 可以比對 1 到 5 之間的值。但有個問題——比對成功後，你沒辦法知道「到底是 1、2、3、4 還是 5」，因為你只知道它在這個範圍裡。

@（at 符號）可以解決這個問題。它讓你在比對的同時，把實際的值存到一個變數裡：

fn main() {
    let age = 50;
    match age {
        n @ 0..=12 => println!("{}歲，是小孩", n),
        n @ 13..=19 => println!("{}歲，是青少年", n),
        n => println!("{}歲，是大人", n),
    }
}

n @ 0..=12 的意思是「如果值在 0 到 12 之間，就把這個值叫做 n」。這樣你就能同時做範圍檢查和取值了。

範例程式碼

fn main() {
    let age = 15;

    match age {
        n @ 0..=6 => println!("{}歲，學齡前", n),
        n @ 7..=12 => println!("{}歲，國小", n),
        n @ 13..=15 => println!("{}歲，國中", n),
        n @ 16..=18 => println!("{}歲，高中", n),
        n => println!("{}歲，已成年", n),
    }

    // 搭配 char 使用
    let ch = 'k';

    match ch {
        c @ 'a'..='m' => println!("'{}' 在字母表前半段", c),
        c @ 'n'..='z' => println!("'{}' 在字母表後半段", c),
        c => println!("'{}' 不是小寫字母", c),
    }

    // 更實用的例子：HTTP 狀態碼
    let status = 404;

    match status {
        code @ 200..=299 => println!("成功！狀態碼：{}", code),
        code @ 300..=399 => println!("重新導向，狀態碼：{}", code),
        code @ 400..=499 => println!("用戶端錯誤，狀態碼：{}", code),
        code @ 500..=599 => println!("伺服器錯誤，狀態碼：{}", code),
        code => println!("未知狀態碼：{}", code),
    }
}

@ 不只能搭配 range

@ 可以搭配任何模式，不只是 range。比如搭配 |（多個值）：

fn main() {
    let day = 6;

    match day {
        d @ (1 | 3 | 5 | 7) => println!("第 {} 天，是休息日", d),
        d @ (2 | 4 | 6) => println!("第 {} 天，是工作日", d),
        d => println!("第 {} 天，不是合法的日子", d),
    }
}

d @ (1 | 3 | 5 | 7) 的意思是「如果值是 1、3、5 或 7，就把它叫做 d」。注意 | 的部分要用括號包起來。

重點整理

• n @ 1..=5 在比對範圍的同時，把值綁定到變數 n
• 語法：變數名 @ 模式
• @ 可以搭配任何模式，不只是 range：d @ (1 | 3 | 5 | 7) 也行
• 如果不用 @，你只知道值符合模式，但不知道具體是多少
• @ 的概念是「把符合這個模式的值，用這個名字存起來」

match guard

本集目標

學會在 match 分支加上額外的條件判斷（guard）。

概念說明

有時候光靠模式匹配還不夠，你還需要加上一些額外的條件。比如說，你想用 match 判斷一個數是奇數還是偶數——這沒辦法用 range pattern 或固定值表達，因為它需要做運算（% 2）。

Rust 的 match guard 讓你在模式後面加上 if 條件：

fn main() {
    let n = 137;
    match n {
        x if x % 2 == 0 => println!("{} 是偶數", x),
        x => println!("{} 是奇數", x),
    }
}

x if x % 2 == 0 的意思是「先把值綁定到 x，然後額外檢查 x % 2 == 0 是否成立」。只有模式匹配而且 guard 條件為 true 的時候，這個分支才會被執行。

注意：guard 不算在「窮舉」的判斷裡。就算你寫了所有可能的 guard，Rust 可能還是會要求你加 _ 預設分支。

範例程式碼

fn main() {
    let n = 8;

    match n {
        x if x % 2 == 0 => println!("{} 是偶數", x),
        x => println!("{} 是奇數", x),
    }

    // 搭配 tuple 使用
    let point = (3, 7);

    match point {
        (x, y) if x == y => println!("在對角線上：({}, {})", x, y),
        (x, y) if x > 0 && y > 0 => println!("({}, {}) 在第一象限", x, y),
        (x, y) => println!("其他的點 ({}, {})", x, y),
    }
}

重點整理

• match guard：在模式後面加 if 條件 做額外判斷
• 語法：模式 if 條件 => ...
• 只有模式匹配且條件為 true 時，分支才會執行
• guard 可以使用模式裡綁定的變數（如 x if x > 0）
• guard 條件不算窮舉，通常最後還是要加 _ 預設分支

let 解構 tuple

本集目標

學會用 let 直接把 tuple 的值拆開，分別賦值給不同的變數。

概念說明

之前我們學了在 match 裡解構 tuple，像是 (x, y) => ...。但其實不用 match，用 let 就可以直接解構！

fn main() {
    let (x, y) = (1, 2);
}

這一行做了兩件事：

1. 建立一個 tuple (1, 2)
2. 把第一個值取出來叫 x，第二個值取出來叫 y

之前在第二章學 tuple 時，都是用 t.0、t.1 來取值。現在學了解構，你可以一行就把所有值拆開，每個值都有一個好讀的名字。

之前學的 _ 和 .. 也可以在 let 解構裡使用。

mut 在綁定上

之前在第一章學了 let mut x = 5;。其實 mut 不是型別的一部分——它是綁定（binding）的修飾。

既然 let 解構就是在做 binding，自然也可以對個別變數加 mut：

#![allow(unused)]

fn main() {
    let (mut a, b) = (1, 2);
    a += 10; // OK，a 是可變的
    b += 10; // 錯誤，b 是不可變的
}

同一個 pattern 裡，可以有些變數加 mut，有些不加——各自獨立。

這個規則不只適用於 let，任何綁定變數的地方都能加 mut：

• match 分支：Some(mut x) => { x += 1; }
• for 迴圈：for mut x in [1, 2, 3] { ... }
• 函數參數：fn foo(mut x: i32) { x += 1; }

之後學到的綁定變數也一樣。都是同一件事——mut 修飾的是 binding，不是型別。

範例程式碼

fn main() {
    // 基本的 let 解構
    let (x, y) = (10, 20);
    println!("x = {}, y = {}", x, y);

    // 三個值的 tuple 也可以
    let (name, score, grade) = ("小明", 95, 'A');
    println!("{} 得了 {} 分，等級 {}", name, score, grade);

    // 搭配 _ 忽略不需要的值
    let (_, second, _) = (1, 2, 3);
    println!("只要第二個：{}", second);

    // 搭配 .. 忽略多個值
    let (first, ..) = (100, 200, 300, 400);
    println!("只要第一個：{}", first);

    // 個別加 mut
    let (mut a, b) = (1, 2);
    a += 10;
    println!("a = {}, b = {}", a, b);

    // 函數回傳 tuple，直接解構
    let (min, max) = min_max(7, 3);
    println!("最小 {}，最大 {}", min, max);
}

fn min_max(a: i32, b: i32) -> (i32, i32) {
    if a < b {
        (a, b)
    } else {
        (b, a)
    }
}

重點整理

• let (x, y) = (1, 2); 可以直接把 tuple 拆開
• 解構 tuple 比用 .0、.1 更好讀
• 可以搭配 _ 忽略單個值，搭配 .. 忽略多個值
• mut 是 binding 的修飾，不是型別的一部分——任何綁定變數的地方都能加 mut
• 函數回傳 tuple 時，可以用 let 解構直接取出每個值

let 解構 struct

本集目標

學會用 let 直接把 struct 的欄位拆開，分別賦值給變數。

概念說明

上一集學了 let 解構 tuple，現在來解構 struct。概念完全一樣——用 let 把 struct 的欄位一次拆開：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 6, y: 7 };
    let Point { x, y } = p;
}

這一行會把 p.x 的值放進變數 x，p.y 的值放進變數 y。這裡用的是 field shorthand（第 13 集學的），所以 x 既是欄位名也是變數名。

如果你想要的變數名和欄位名不同，可以用 欄位名: 變數名 的寫法：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 6, y: 7 };
    let Point { x: px, y: py } = p;
    // 現在變數叫 px 和 py
}

之前學的 .. 也可以用，只取你需要的欄位：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 6, y: 7 };
    let Point { x, .. } = p;
    // 只取 x，忽略其他欄位
}

tuple struct 也可以解構，用法跟 tuple pattern 幾乎一樣，只是前面要加上型別名稱：

struct Pair(i32, i32);

fn main() {
    let p = Pair(1, 2);
    let Pair(a, b) = p;
}

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

struct Rectangle {
    x: i32,
    y: i32,
    width: i32,
    height: i32,
}

fn main() {
    let p = Point { x: 5, y: 10 };

    // let 解構 struct（用 field shorthand）
    let Point { x, y } = p;
    println!("x = {}, y = {}", x, y);

    // 用不同的變數名
    let p2 = Point { x: 3, y: 7 };
    let Point { x: px, y: py } = p2;
    println!("px = {}, py = {}", px, py);

    // 搭配 .. 只取部分欄位
    let rect = Rectangle { x: 0, y: 0, width: 100, height: 50 };
    let Rectangle { width, height, .. } = rect;
    println!("寬 {}，高 {}", width, height);
    let area = width * height;
    println!("面積 = {}", area);
}

重點整理

• let Point { x, y } = p; 把 struct 的欄位拆成個別變數
• .. 可以忽略不需要的欄位
• tuple struct 也能解構：let Pair(a, b) = p;
• let 解構在取出 struct 資料時非常方便

for 迴圈解構

本集目標

學會在 for 迴圈的變數位置直接解構 tuple 或 struct。

概念說明

我們已經學過 let 可以解構 tuple 和 struct。其實 for 迴圈的變數位置也可以——同樣的解構語法直接寫上去就行。

走訪一個裝著 tuple 的陣列：

fn main() {
    let pairs = [(1, "one"), (2, "two"), (3, "three")];

    for (num, name) in pairs {
        println!("{} = {}", num, name);
    }
}

(num, name) 就是模式，陣列裡的每個元素都是 tuple，迴圈會把它拆開分別給 num 和 name。

走訪 struct 也一樣：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let points = [
        Point { x: 0, y: 0 },
        Point { x: 1, y: 2 },
        Point { x: 3, y: 4 },
    ];

    for Point { x, y } in points {
        println!("({}, {})", x, y);
    }
}

把這想成是 let 解構和 for 迴圈的結合：每次迴圈拿出一個元素時，就用 let 解構的語法把它拆開。

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    // 走訪 tuple 陣列並解構
    let scores = [("Alice", 85), ("Bob", 92), ("Carol", 78)];
    for (name, score) in scores {
        println!("{}: {}", name, score);
    }

    // 走訪 struct 陣列並解構
    let points = [
        Point { x: 0, y: 0 },
        Point { x: 3, y: 4 },
        Point { x: -1, y: 2 },
    ];
    for Point { x, y } in points {
        println!("({}, {})", x, y);
    }

    // 用 .. 忽略不要的欄位
    let more_points = [
        Point { x: 1, y: 10 },
        Point { x: 2, y: 20 },
    ];
    for Point { x, .. } in more_points {
        println!("x = {}", x);
    }
}

重點整理

• for 迴圈的變數位置可以直接寫解構模式
• 走訪 tuple 的陣列：for (a, b) in pairs
• 走訪 struct 的陣列：for Point { x, y } in points

函數參數解構

本集目標

學會在函數的參數位置直接解構 tuple 或 struct。

概念說明

我們已經學了在 let、match 和 for 裡解構。其實函數的參數也可以解構！

假設你有一個函數，接收一個 tuple (i32, i32) 代表座標。與其在函數內再拆開，不如直接在參數位置就拆好：

fn print_point((x, y): (i32, i32)) {
    println!("({}, {})", x, y);
}

fn main() {}

注意語法：(x, y) 是模式（pattern），: (i32, i32) 是型別標註。模式和型別之間用 : 分隔。

呼叫的時候和平常一樣，傳一個 tuple 進去：

fn print_point((x, y): (i32, i32)) {
    println!("({}, {})", x, y);
}
fn main() {
    print_point((3, 7));
}

struct 也可以在參數位置解構：

struct Point {
    x: i32,
    y: i32,
}

fn print_point_struct(Point { x, y }: Point) {
    println!("({}, {})", x, y);
}

fn main() {}

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

// 函數參數解構 tuple
fn add_coordinates((x1, y1): (i32, i32), (x2, y2): (i32, i32)) -> (i32, i32) {
    (x1 + x2, y1 + y2)
}

// 函數參數解構 struct
// 當然這邊你也能選擇用 match
fn describe_point(Point { x, y }: Point) {
    if x == 0 && y == 0 {
        println!("原點");
    } else if x == 0 {
        println!("在 y 軸上，y = {}", y);
    } else if y == 0 {
        println!("在 x 軸上，x = {}", x);
    } else {
        println!("一般的點 ({}, {})", x, y);
    }
}

fn main() {
    // 傳 tuple 給函數
    let a = (1, 2);
    let b = (3, 4);
    let result = add_coordinates(a, b);
    println!("({}, {}) + ({}, {}) = ({}, {})", a.0, a.1, b.0, b.1, result.0, result.1);

    // 傳 struct 給函數
    let p = Point { x: 0, y: 5 };
    describe_point(p);

    let origin = Point { x: 0, y: 0 };
    describe_point(origin);
}

為什麼 tuple 和 struct 能用 let 解構？

你可能會好奇：為什麼 tuple 和 struct 就可以在 let、for 和函數參數裡直接解構？

struct Point {
    x: i32,
    y: i32,
}

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: i32, height: i32 },
}

fn main() {
    let p = Point { x: 6, y: 7 };
    let s = Shape::Circle { radius: 6.7 };
    let (x, y) = (1, 2);    // OK
    let Point { x, y } = p; // OK
    let Shape::Circle { radius: f64 } = s; // 不行！
}

答案是：tuple 和 struct 的解構不會失敗。一個 (i32, i32) 一定有兩個值，一個 Point 一定有 x 和 y——沒有其他可能。

但 enum 不一樣。一個 Shape 可能是 Circle 或 Rectangle。如果你寫 let Shape::Circle { radius: f64 } = s;，但 s 其實是 Rectangle 呢？這就失敗了。Rust 不允許 let 裡出現可能失敗的模式。

比對時一定會成功的模式被叫做 irrefutable pattern（不可反駁的模式），可能失敗的叫做 refutable pattern（可反駁的模式）。let、for 和函數參數只接受 irrefutable pattern。

想處理可能失敗的模式？下一集會教 if let。

重點整理

• 函數參數也可以直接用模式解構：fn foo((x, y): (i32, i32))
• tuple 和 struct 都可以在參數位置解構
• 呼叫時和平常一樣傳值，解構是函數內部的事
• let、for 和函數參數只接受不會失敗的模式（irrefutable pattern），所以 tuple 和 struct 可以，enum 會有問題

if let

本集目標

學會用 if let 來簡化「只關心一種模式」的 match。

概念說明

有時候你只關心 enum 的某一個 variant，其他的都不在意。用 match 寫的話，必須處理所有情況，就算你只想處理一個：

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let c = Color::Blue;
    match c {
        Color::Red => println!("是紅色！"),
        _ => {}  // 其他情況什麼都不做
    }
}

那個 _ => {} 看起來很多餘。Rust 提供了 if let 語法來簡化這種情況：

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let c = Color::Blue;
    if let Color::Red = c {
        println!("是紅色！");
    }
}

if let 模式 = 值 的意思是「如果這個值符合這個模式，就執行大括號裡的程式碼」。

你也可以加上 else 處理不符合的情況：

enum Color {
    Red,
    Green,
    Blue,
}

fn main() {
    let c = Color::Blue;
    if let Color::Red = c {
        println!("是紅色！");
    } else {
        println!("不是紅色");
    }
}

注意：if let 裡的 = 是一個等號，不是兩個。這不是在做比較，而是在做「模式比對」。

範例程式碼

enum Color {
    Red,
    Green,
    Blue,
}

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}

fn main() {
    let c = Color::Red;

    // 用 if let 檢查是不是 Red
    if let Color::Red = c {
        println!("是紅色！");
    }

    // 搭配 else
    let c2 = Color::Blue;

    if let Color::Red = c2 {
        println!("是紅色！");
    } else {
        println!("不是紅色");
    }

    // if let 也可以取出 variant 裡的資料
    let s = Shape::Circle(5.0);

    if let Shape::Circle(r) = s {
        println!("是圓形！半徑 = {}", r);
        let area = r * r * 3.14159;
        println!("面積大約 {}", area);
    }

    // 如果不是 Circle 就不會執行
    let s2 = Shape::Rectangle(10, 20);

    if let Shape::Circle(r) = s2 {
        println!("這行不會被執行，因為 s2 是 Rectangle");
        println!("半徑 {}", r);
    } else {
        println!("不是圓形");
    }
}

if let guard

if let 也可以用在 match 的 guard 位置（第 20 集學的 match guard）。語法是 模式 if let 模式2 = 表達式 =>：

enum Wrapper {
    Value(i32),
    Empty,
}

fn lookup(key: i32) -> Wrapper {
    if key > 0 { Wrapper::Value(key * 10) } else { Wrapper::Empty }
}

fn main() {
    let items = [1, -2, 3];

    for item in items {
        match item {
            x if let Wrapper::Value(v) = lookup(x) => {
                println!("{} 查到了：{}", x, v);
            }
            x => println!("{} 查不到", x),
        }
    }
}

x if let Wrapper::Value(v) = lookup(x) 的意思是：先把值綁定到 x，然後用 lookup(x) 的結果再做一次模式比對——只有結果是 Wrapper::Value(v) 的時候這個分支才成立。

這個例子其實用一般的 if let 也寫得出來。但當程式邏輯更複雜——例如外層的 match 已經在比對其他模式，而你又需要在某個分支裡對另一個值做模式比對——if let guard 有時可以讓程式碼更好讀，不用在 match 的分支裡面再套一層 if let。

重點整理

• if let 模式 = 值 { ... } 是 match 只有一個分支時的簡寫
• 只在值符合模式時執行大括號裡的程式碼
• 可以加 else 處理不符合的情況
• 可以在模式裡取出資料，像 if let Shape::Circle(r) = s
• 比起寫 match + _ => {}，if let 更簡潔
• if let 也能用在 match guard：模式 if let 模式2 = 表達式 => ...

while let

本集目標

學會用 while let 在迴圈中持續做模式比對，直到模式不再符合為止。

概念說明

上一集學了 if let——「如果符合模式就執行一次」。while let 則是「只要符合模式就一直執行」，是 if let 的迴圈版本。

語法：

while let 模式 = 值 {
    // 迴圈本體
}

每次迴圈開始前，Rust 會檢查「值是否符合模式」。符合就繼續跑，不符合就停下來。

為了示範 while let，我們用一個自訂 enum 來模擬「可能有值、可能結束」的情況：

enum Step {
    Value(i32),
    Done,
}

fn main() {}

範例程式碼

enum Step {
    Value(i32),
    Done,
}

fn get_step(index: i32) -> Step {
    if index < 5 {
        Step::Value(index * 10)
    } else {
        Step::Done
    }
}

fn main() {
    let mut i = 0;

    // while let：只要 get_step 回傳 Value，就繼續
    while let Step::Value(v) = get_step(i) {
        println!("第 {} 步，值 = {}", i, v);
        i += 1;
    }
    println!("結束了！總共跑了 {} 步", i);

    println!();

    // 另一個例子：倒數計時
    let mut count = 5;

    // 利用自訂 enum 模擬倒數
    while let Countdown::Tick(n) = get_countdown(count) {
        println!("倒數 {}...", n);
        count -= 1;
    }
    println!("發射！🚀");
}

enum Countdown {
    Tick(i32),
    Launch,
}

fn get_countdown(n: i32) -> Countdown {
    if n > 0 {
        Countdown::Tick(n)
    } else {
        Countdown::Launch
    }
}

重點整理

• while let 模式 = 值 { ... } 是 if let 的迴圈版本
• 只要值符合模式，就持續執行迴圈
• 值不符合模式時，迴圈自動結束

let else

本集目標

學會用 let...else 在 pattern 不匹配時提前離開，寫出更扁平的程式碼。

概念說明

if let 的反面

上一集學了 while let，再上一集學了 if let——「如果匹配成功就做某件事」。但有時候你想要的是反過來：「如果匹配失敗就提前離開，成功的話繼續往下走。」

假設我們有這個 enum：

enum Color {
    Red,
    Green,
    Blue,
    Custom(i32, i32, i32),
}

fn main() {}

用 if let 寫的話：

enum Color {
    Red,
    Green,
    Blue,
    Custom(i32, i32, i32),
}

fn describe(color: Color) {
    if let Color::Custom(r, g, b) = color {
        println!("自訂顏色：{} {} {}", r, g, b);
    } else {
        println!("不是自訂顏色，結束");
        return;
    }
    // 這裡想用 r, g, b⋯⋯但它們已經不在作用域了！
}

fn main() {}

r、g、b 只活在 if let 的 {} 裡面，後面的程式碼用不到。

let…else 語法

let...else 讓綁定的變數活在後面的程式碼裡，而不是只活在 {} 裡面：

enum Color {
    Red,
    Green,
    Blue,
    Custom(i32, i32, i32),
}

fn describe(color: Color) {
    let Color::Custom(r, g, b) = color else {
        println!("不是自訂顏色，結束");
        return;
    };
    // r, g, b 在這裡可以直接用！
    println!("紅：{}，綠：{}，藍：{}", r, g, b);
}

fn main() {}

意思是：

1. 嘗試用 pattern 匹配 color
2. 如果成功，r、g、b 被綁定，程式繼續往下
3. 如果失敗，執行 else 裡面的程式碼

else 裡面必須離開

else 區塊不能只是「做點事然後繼續」——它必須讓程式離開當前的流程。合法的寫法包括：

• return —— 離開函數
• break —— 離開迴圈
• continue —— 跳到迴圈下一輪

為什麼？因為如果 pattern 不匹配，變數就沒有被綁定。如果 else 之後程式繼續往下跑，那些變數就是未定義的——Rust 不允許這種事。

和 if let 的比較

• if let：匹配成功才進入 {} 區塊，綁定的變數只活在裡面
• let...else：匹配失敗就離開，綁定的變數活在後面所有的程式碼裡

let...else 讓程式碼更扁平——不用多縮排一層。

範例程式碼

enum Shape {
    Circle(f64),
    Rectangle(i32, i32),
}

fn print_circle_info(shape: Shape) {
    let Shape::Circle(radius) = shape else {
        println!("不是圓形，跳過");
        return;
    };
    // radius 在這裡可以直接用
    println!("圓形，半徑 = {}", radius);
}

fn main() {
    print_circle_info(Shape::Circle(3.14));
    print_circle_info(Shape::Rectangle(10, 20));

    // 在迴圈裡搭配 continue
    let shapes = [
        Shape::Rectangle(3, 4),
        Shape::Circle(1.0),
        Shape::Rectangle(5, 6),
        Shape::Circle(2.5),
    ];

    println!("\n只印圓形：");
    for shape in shapes {
        let Shape::Circle(r) = shape else {
            continue;  // 不是圓形，跳過這一輪
        };
        println!("半徑：{}", r);
    }
}

重點整理

• let pattern = expr else { return/break/continue }; 在匹配失敗時提前離開
• else 裡面必須離開當前流程（return / break / continue）
• 匹配成功的話，綁定的變數在後續程式碼還能使用
• 比 if let 更適合「失敗就離開，成功繼續」的場景——程式碼更扁平

associated function

本集目標

學會用 impl 為 struct 或 enum 定義 associated function（關聯函數），以及用 :: 呼叫。

概念說明

到目前為止，我們的函數都是「獨立的」——定義在最外層，和任何型別沒有關係。但很多時候，某些函數和特定的型別密切相關。比如說，「建立一個新的 Point」這件事，和 Point 這個型別有直接關係。

Rust 用 impl 區塊讓你把函數「附加」到型別上：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

fn main() {}

這樣定義的函數叫做 associated function（關聯函數），因為它和 Point 這個型別「關聯」在一起。呼叫的時候用 ::：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

fn main() {
    let p = Point::new(3, 7);
}

Point::new 看起來是不是有點眼熟？之前用 enum 的時候也是用 :: 啊！像 Color::Red。概念是一樣的——:: 可以表示「某個型別底下的東西」。

associated function 最常見的用途就是 new——作為「建構函數」來建立型別的值。

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    // associated function：建立一個新的 Point
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    // 也可以定義其他 associated function
    fn origin() -> Point {
        Point { x: 0, y: 0 }
    }
}

// enum 也可以有 impl！
enum Color {
    Red,
    Green,
    Blue,
}

impl Color {
    fn from_number(n: i32) -> Color {
        match n {
            0 => Color::Red,
            1 => Color::Green,
            _ => Color::Blue,
        }
    }
}

fn main() {
    // 用 :: 呼叫 associated function
    let p1 = Point::new(3, 7);
    println!("p1 = ({}, {})", p1.x, p1.y);

    let p2 = Point::origin();
    println!("p2 = ({}, {})", p2.x, p2.y);

    // enum 的 associated function
    let c = Color::from_number(1);
    match c {
        Color::Red => println!("紅"),
        Color::Green => println!("綠"),
        Color::Blue => println!("藍"),
    }
}

重點整理

• impl 型別名 { ... } 為型別定義 associated function
• associated function 用 型別名::函數名() 呼叫
• 最常見的用途是 new 函數，作為建構函數
• struct 和 enum 都可以有 impl 區塊

method

本集目標

學會用 self 定義 method（方法），讓函數可以用 . 在值上面呼叫。

概念說明

上一集學了 associated function，它是用 :: 呼叫的，和「型別」相關。但有時候我們想對一個已經存在的值做操作，比如「算出這個 Point 的 x + y」。

這就是 method（方法）——參數列表的第一個位置放 self，代表「呼叫這個方法的那個值本身」：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn sum(self) -> i32 {
        self.x + self.y
    }
}

fn main() {}

呼叫的時候用 .（點）而不是 ::：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    fn sum(self) -> i32 {
        self.x + self.y
    }
}
fn main() {
    let p = Point::new(3, 7);
    let s = p.sum(); // 用 . 呼叫 method
}

注意：呼叫 p.sum() 的時候，不需要再手動傳入 self。. 前面的 p 會自動變成方法裡的 self。所以雖然定義時寫了 fn sum(self)，呼叫時只要寫 p.sum() 而不是 p.sum(p)。

method 可以有其他參數

method 除了 self 之外，還可以有一個或更多其他的參數——就跟一般函數一樣：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {}

呼叫時，self 由 . 前面的值自動帶入，你只需要傳其他的參數：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let p1 = Point::new(1, 2);
    let p2 = Point::new(3, 4);
    let p3 = p1.add(p2); // p1 是 self，p2 是 other
}

associated function vs method 的差別：

• associated function：沒有 self，用 :: 呼叫 → Point::new(3, 7)
• method：第一個參數是 self，用 . 呼叫 → p.sum()

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    // associated function（沒有 self）
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }

    // method（第一個參數是 self）
    fn sum(self) -> i32 {
        self.x + self.y
    }

    // method 可以有 self 之外的參數
    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }

    // 另一個 method
    fn is_origin(self) -> bool {
        self.x == 0 && self.y == 0
    }
}

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

impl Direction {
    // enum 也可以有 method
    fn is_horizontal(self) -> bool {
        match self {
            Direction::Left => true,
            Direction::Right => true,
            Direction::Up => false,
            Direction::Down => false,
        }
    }
}

fn main() {
    let p = Point::new(3, 7); // :: 呼叫 associated function
    let s = p.sum();          // . 呼叫 method
    println!("3 + 7 = {}", s);

    // method 帶其他參數
    let a = Point::new(1, 2);
    let b = Point::new(10, 20);
    let c = a.add(b); // a 是 self，b 是 other
    println!("相加後：({}, {})", c.x, c.y);

    let origin = Point::new(0, 0);
    println!("是原點嗎？{}", origin.is_origin());

    // enum 的 method
    let dir = Direction::Left;
    let horizontal = dir.is_horizontal();
    println!("是水平方向嗎？{}", horizontal);
}

重點整理

• method 的第一個參數是 self，代表值本身
• method 用 . 呼叫：p.sum()，. 前面的值自動成為 self，不需要手動傳入
• method 除了 self 還可以有其他參數：fn add(self, other: Point) -> Point，呼叫時括號內只寫 self 以外的參數
• struct 和 enum 都可以有 method

大寫 Self

本集目標

學會用大寫 Self 作為「目前正在 impl 的型別」的別名，讓程式碼更簡潔。

概念說明

上一集我們在 impl 裡面寫了這樣的程式碼：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Point {
        Point { x, y }
    }
}

fn main() {}

注意到 Point 這個名字出現了三次：impl Point、-> Point、Point { x, y }。如果型別名很長（例如 Rectangle），一直重複寫就很囉嗦。

Rust 提供了大寫 Self（注意 S 是大寫的！），它在 impl 區塊裡面代表「目前正在 impl 的型別」。所以上面的程式碼可以改成：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }
}

fn main() {}

Self 就是 Point 的別名。這樣寫有兩個好處：

1. 更簡潔，尤其是型別名很長的時候
2. 如果之後改了型別名，impl 裡面不用每個地方都改

注意區分：

• 小寫 self：代表「這個值本身」（method 的第一個參數）
• 大寫 Self：代表「目前的型別」

範例程式碼

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    // 用 Self 代替 Point
    fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }

    fn origin() -> Self {
        Self { x: 0, y: 0 }
    }

    // method 裡也可以用 Self
    fn flip(self) -> Self {
        Self { x: self.y, y: self.x }
    }

    fn sum(self) -> i32 {
        self.x + self.y
    }
}

// enum 也可以用 Self
enum Light {
    Red,
    Yellow,
    Green,
}

impl Light {
    fn next(self) -> Self {
        match self {
            Self::Red => Self::Green,
            Self::Green => Self::Yellow,
            Self::Yellow => Self::Red,
        }
    }

    fn is_stop(self) -> bool {
        match self {
            Self::Red => true,
            Self::Yellow => true,
            Self::Green => false,
        }
    }
}

fn main() {
    // struct 使用 Self
    let p = Point::new(3, 7);
    println!("原始：({}, {})", p.x, p.y);

    let p2 = Point::new(3, 7);
    let flipped = p2.flip();
    println!("翻轉：({}, {})", flipped.x, flipped.y);

    let p3 = Point::origin();
    println!("原點：({}, {})", p3.x, p3.y);

    // enum 使用 Self
    let light = Light::Red;
    let stop = light.is_stop();
    println!("需要停嗎？{}", stop);

    let light2 = Light::Red;
    let next_light = light2.next();
    let stop2 = next_light.is_stop();
    println!("下一個燈需要停嗎？{}", stop2);
}

重點整理

• 大寫 Self 在 impl 區塊裡代表「目前的型別」
• Self 可以用在回傳型別 -> Self、建構值 Self { ... }、以及 enum variant Self::Red
• 小寫 self = 值本身，大寫 Self = 型別本身
• struct 和 enum 的 impl 裡都可以用 Self
• 使用 Self 讓程式碼更簡潔，也更容易維護

恭喜你完成了第三章！🎉 這一章你學會了 struct、enum、pattern matching（match、if let、while let、let else）、解構、associated function 和 method。你現在已經能用 Rust 的型別系統來組織資料和行為了。下一章我們要進入 Rust 最核心也最獨特的概念——所有權（ownership）！

所有權與借用

所有權（鑰匙圈比喻）

本集目標

用生活化的鑰匙圈比喻，理解 Rust 最核心的概念——所有權。

概念說明

這集我們不寫程式，先來聊一個 Rust 最重要的概念：所有權（ownership）。

鑰匙圈比喻

想像你有一個鑰匙圈。鑰匙圈上可能掛著一些小裝飾（很輕、隨身帶著），也可能掛著一把鑰匙，這把鑰匙可以打開一個保險箱。規則很簡單：

每個鑰匙圈只能在一個人手上。

這就是 Rust 的所有權規則。你手上拿著鑰匙圈，上面的裝飾和鑰匙都是你的。

移轉（move）= 交出去就沒了

如果有人跟你說：「把你的鑰匙圈給我。」你把整個鑰匙圈交給對方之後，你手上就什麼都沒了。你不能再用那把鑰匙去開保險箱，因為鑰匙已經不在你手上了。

在 Rust 裡面，這叫做 move（移轉）。當你把一個值交給別人（例如賦值給另一個變數），原本的變數就不能再用了。

為什麼不能複製鑰匙？

你可能會想：「那我去複製一把鑰匙不就好了？」

問題在這裡：如果兩個人各拿一把鑰匙，都可以打開同一個保險箱，那就可能出事了——

• A 正在整理保險箱裡的東西
• B 同時也打開保險箱，把東西拿走了
• A 回頭一看：「咦？我的東西呢？」

這就是所謂的「資料競爭（data race）」。Rust 的所有權規則就是為了從根本上防止這種問題。

clone = 買一個新的保險箱

那如果我真的需要兩份一樣的資料怎麼辦？

答案是：不要複製鑰匙，而是買一個新的保險箱，把裡面的東西複製一份放進去，然後配一把新的鑰匙。

這樣兩個人各有自己的保險箱、自己的鑰匙，互不干擾。

在 Rust 裡面，這叫做 clone（克隆）。它會完整複製一份資料，產生一個全新的、獨立的副本。

為什麼 Rust 要這麼嚴格？

大部分的程式語言不管這些，讓你隨便複製、隨便共用，然後等出了 bug 再說。Rust 不一樣——它在你寫程式的時候就幫你把關，確保不會有兩個人同時亂動同一份資料。

這就是 Rust 的核心哲學：在編譯時期就防止錯誤，而不是等到程式跑起來才出事。

重點整理

• 每個值都有一個「擁有者」，就像每個鑰匙圈只能在一個人手上
• move（移轉）：把鑰匙圈交給別人，你就沒有了
• 不能簡單地複製鑰匙去開同一個保險箱，這可能會造成資料競爭
• clone（克隆）：買新的保險箱 + 複製內容物 + 配新鑰匙，兩份完全獨立
• Rust 在編譯時就強制執行所有權規則，防止資料競爭

trait 簡介

本集目標

學會定義 trait 和為型別實作 trait，並認識 #[derive] 這個自動產生實作的捷徑。

概念說明

什麼是 trait？

在進入所有權的主題之前，我們先來學一個重要的工具：trait。它和上一集的鑰匙圈比喻沒有直接關係，但之後講 Clone、Copy 等概念的時候會用到，所以先學起來。

在第三章，我們學會了用 impl 幫 struct 和 enum 加上 method。但如果我們想要規定「某些型別都必須有某個功能」呢？

比如說，我想規定：「某些型別都必須能打招呼。」這就是 trait 的用途——它定義了一組「能力」或「行為」，然後不同的型別可以各自實作這些行為。

trait 就像一張「規格表」，上面寫著：「你要符合這個規格，就必須提供這些功能。」

定義 trait

用 trait 關鍵字來定義：

trait Greet {
    fn greet(self);
}

fn main() {}

這段程式碼的意思是：「凡是實作了 Greet 這個 trait 的型別，都必須有一個 greet method。」

為型別實作 trait

trait Greet {
    fn greet(self);
}

struct Cat;

impl Greet for Cat {
    fn greet(self) {
        println!("喵～");
    }
}

fn main() {}

之前我們寫 impl Cat { ... } 是直接幫 Cat 加 method。現在寫 impl Greet for Cat { ... } 是說「Cat 符合 Greet 這個規格」，然後在裡面提供 Greet 要求的 method。

derive：自動產生實作的捷徑

有些 trait 的實作方式很固定，Rust 編譯器可以幫你自動產生。這時候就用 #[derive(...)]：

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {}

還記得第二章我們用 {:?} 印出 tuple 和陣列嗎？其實 {:?} 就是在使用 Debug 這個 trait。tuple 和陣列內建就有 Debug，但我們自己定義的 struct 和 enum 沒有——所以要加 #[derive(Debug)]，讓 Rust 自動幫我們產生 Debug 的實作。

範例程式碼

// 定義一個 trait：所有實作者都必須能「打招呼」
trait Greet {
    fn greet(self);
}

// 定義兩種動物
struct Cat;
struct Dog;

// 幫 Cat 實作 Greet
impl Greet for Cat {
    fn greet(self) {
        println!("我是一隻貓咪喵～");
    }
}

// 幫 Dog 實作 Greet
impl Greet for Dog {
    fn greet(self) {
        println!("我是一隻狗狗汪！");
    }
}

// 用 derive 讓 Rust 自動產生 Debug 實作
#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let cat = Cat;
    let dog = Dog;

    // 呼叫 trait method
    cat.greet();
    dog.greet();

    // 用 {:?} 印出 struct（因為有 #[derive(Debug)]）
    let p = Point { x: 3, y: 7 };
    println!("{:?}", p);
}

重點整理

• trait 是一組行為的規格定義，像是一張「能力清單」
• 用 impl TraitName for TypeName 來幫型別實作 trait（例如 impl Greet for Cat）
• #[derive(Debug)] 讓 Rust 自動幫你的 struct/enum 實作 Debug trait
• 加了 #[derive(Debug)] 之後，就可以用 {:?} 來印出自訂的 struct/enum

move 與 Clone

本集目標

理解 Rust 的 move 語意——賦值和傳入函數都會轉移所有權——以及用 Clone 來複製資料。

概念說明

move：交出去就沒了

上一集我們學了 trait，現在來看所有權在程式碼裡的樣子。

在 Rust 裡，當你把一個 struct 的值賦給另一個變數，原本的變數就不能再用了。這就是第 1 集講的「把鑰匙圈交出去」：

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1; // p1 的所有權移轉給 p2
    // 從這裡開始，p1 不能再用了！
}

這個行為叫做 move（移轉）。Rust 編譯器會在編譯時就檢查這件事，如果你在 move 之後還嘗試使用原本的變數，編譯器會直接報錯。

傳進函數也是 move

不只是賦值，把值傳進函數也會發生 move：

struct Point {
    x: i32,
    y: i32,
}

fn print_point(p: Point) {
    println!("({}, {})", p.x, p.y);
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    print_point(p1); // p1 被 move 進函數了
    // p1 不能再用了！
}

因為函數的參數就像一個新的變數，值被「交」給了它。

Clone：完整複製一份

如果你需要保留原本的值，又想要一份副本，就用 Clone。

首先，你的型別要加上 #[derive(Clone)]（當然也可以順便加 Debug）：

#[derive(Debug, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {}

然後用 .clone() 來複製：

#[derive(Debug, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1.clone();  // 複製一份，p1 還在
    println!("{:?}", p1); // OK！p1 還能用
    println!("{:?}", p2); // p2 是獨立的副本
}

回想第 1 集的比喻：clone 就是「複製一份完整的鑰匙圈和保險箱」。兩個變數各自擁有自己的資料，互不干擾。

整數不會 move？

你可能會注意到，整數的行為不太一樣：

fn main() {
    let a = 42;
    let b = a;
    println!("{}", a); // 這居然可以！
}

為什麼整數不會 move？這個問題我們下一集再來解答。

範例程式碼

#[derive(Debug, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn print_point(p: Point) {
    println!("函數收到的點：({}, {})", p.x, p.y);
}

fn main() {
    let p1 = Point { x: 10, y: 20 };

    // 用 clone 複製一份，這樣 p1 不會被 move 走
    let p2 = p1.clone();
    println!("p1 = {:?}", p1);
    println!("p2 = {:?}", p2);

    // 傳進函數也是 move，所以先 clone
    print_point(p1.clone());
    println!("p1 還在：{:?}", p1);

    // 如果不 clone，直接傳進去，p1 就被 move 走了
    print_point(p1);
    // 下面這行如果取消註解，編譯器會報錯：
    // println!("p1 不見了：{:?}", p1);
}

重點整理

• let p2 = p1; 會 move，之後 p1 不能再用
• 把值傳進函數也是 move
• #[derive(Clone)] + .clone() 可以複製一份獨立的副本
• clone 之後，原本的變數還可以繼續使用
• 整數（i32 等）不會 move——下一集會解釋為什麼

Copy

本集目標

理解 Copy trait——為什麼整數、浮點數、布林值、字元在賦值時不會 move。

概念說明

上一集的問題

上一集我們發現，struct 的值在賦值或傳入函數時會被 move，但整數不會：

fn main() {
    let a = 42;
    let b = a;
    println!("{}", a); // 完全沒問題！
}

為什麼？答案就是 Copy trait。

什麼是 Copy？

Copy 是一個特殊的 trait。如果一個型別實作了 Copy，那麼在賦值或傳入函數時，Rust 會自動複製一份，而不是 move。

你可以把 Copy 想像成：「這個東西太小了、太簡單了，複製一份根本不費力，所以 Rust 直接幫你複製，不用特別寫 .clone()。」

哪些型別自動有 Copy？

以下這些型別天生就有 Copy：

• 整數：i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize
• 浮點數：f32, f64
• 布林值：bool
• 字元：char
• ……還有其他更多型別

另外，tuple 和陣列如果裡面每個元素都是 Copy 的，那它們整體也是 Copy 的：

fn main() {
    let t = (1, true, 'a');  // (i32, bool, char) → 全部 Copy → tuple 也是 Copy
    let t2 = t;
    println!("{:?}", t);     // OK！

    let arr = [1, 2, 3];     // [i32; 3] → i32 是 Copy → 陣列也是 Copy
    let arr2 = arr;
    println!("{:?}", arr);   // OK！
}

這就是為什麼你在前面幾章寫的程式碼裡，整數、tuple、陣列可以隨便賦值給多個變數、傳進多個函數，完全不會有問題。

除了 Copy 之外，當 tuple 的每個型別都有實作 Clone 時，tuple 也會自動實作 Clone。事實上 tuple 對很多其他 trait 也有同樣的行為——只要所有元素都有實作某個 trait，tuple 整體就會有。這點以後不再贅述。

自己的型別也可以加 Copy

如果你的型別裡面所有值都是 Copy 的型別，那你的型別也可以加上 #[derive(Copy, Clone)]：

#[derive(Debug, Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {}

注意：#[derive(Copy)] 一定要同時加 Clone——如果只寫 #[derive(Copy)] 而不寫 Clone，編譯器會報錯。

為什麼？因為 Rust 規定：任何可以 copy 的東西，也必須可以 clone。Copy 是「自動複製」，Clone 是「手動複製」。如果一個東西連手動複製都不行，那自動複製當然更不行。所以 Copy 要求你先有 Clone。

加上之後，Point 的行為就跟整數一樣了——賦值不會 move：

#[derive(Debug, Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1; // 自動複製，p1 還在！
    println!("{:?}", p1); // OK
}

copy 和 clone 的差別

簡單來說：copy 是自動的複製，clone 是手動的複製。

範例程式碼

#[derive(Debug, Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

fn print_point(p: Point) {
    println!("函數收到：({}, {})", p.x, p.y);
}

fn double(n: i32) -> i32 {
    n * 2
}

fn main() {
    // 整數自動 Copy
    let a = 42;
    let b = a;
    println!("a = {}, b = {}", a, b); // 兩個都能用

    // bool 也是 Copy
    let flag = true;
    let flag2 = flag;
    println!("flag = {}, flag2 = {}", flag, flag2);

    // 整數傳進函數不會 move
    let x = 10;
    let result = double(x);
    println!("x = {}, result = {}", x, result);

    // 自訂的 struct 加上 Copy 後也不會 move
    let p1 = Point { x: 3, y: 7 };
    let p2 = p1;     // 自動複製
    print_point(p1); // p1 還能用
    println!("p1 = {:?}", p1); // 還是能用！
    println!("p2 = {:?}", p2);
}

不要隨便幫自己的型別加 Copy

看完這一集，你可能會想：「那我以後每個 struct 都加 #[derive(Copy, Clone)] 不就好了？」

請不要這樣做。 原因是：一旦加了 Copy，使用你這個型別的程式碼就會依賴「賦值時自動複製」的行為。如果有一天你需要修改這個 struct，加了一個不是 Copy 的欄位，你就必須拿掉 Copy。

問題來了：拿掉 Copy 之後，原本寫 let p2 = p1; 的地方全部會從「自動複製」變成「move」，p1 就不能再用了。所有用到這個型別的程式碼都可能因此壞掉，而且壞的地方可能很多、很分散。

所以好的習慣是：只有你確定這個型別永遠都會很小、很簡單，而且不會再加非 Copy 的欄位時，才加 Copy。 像 Point { x: i32, y: i32 } 這種就很適合。如果不確定，只加 Clone 就好——需要複製的時候手動寫 .clone()，未來要改也不會影響其他程式碼。

重點整理

• Copy 是一個 trait，讓型別在賦值和傳入函數時自動複製，而不是 move
• i32、f64、bool、char 等基本型別天生就有 Copy
• tuple 和陣列如果所有元素都是 Copy，整體也是 Copy
• tuple 對很多 trait（Copy、Clone 等）都有同樣的行為：所有元素都有實作 → tuple 就有實作
• 自訂 struct 可以加 #[derive(Copy, Clone)]，但所有欄位都必須是 Copy 的型別
• Copy 一定要搭配 Clone 一起 derive
• Copy = 自動複製，Clone = 手動複製（.clone()）
• 不要隨便加 Copy——未來拿掉會讓所有依賴自動複製的程式碼壞掉。不確定就只加 Clone

借用 &

本集目標

學會用 & 借用值，不需要 move 也不需要 clone，就能讓別人讀取你的資料。

概念說明

move 和 clone 都有代價

前面我們學了兩種方式來處理所有權：

• move：交出去就沒了，原本的變數不能再用
• clone：複製一份，但如果資料很大，複製就很浪費

有沒有辦法不交出去、不複製，只是借別人看一下？

有！這就是借用（borrowing），用 & 符號。

& 就是「借」

struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 1, y: 2 };
    let r: &Point = &p; // r 借用了 p，p 還是擁有者
}

&p 的意思是：「我不要拿走 p 的所有權，我只是借來看看。」p 還在，你隨時可以繼續用 p。

函數參數用 & 就不會 move

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn print_point(p: &Point) {
    println!("({}, {})", p.x, p.y);
}

fn main() {
    let p1 = Point { x: 10, y: 20 };
    print_point(&p1); // 傳 &p1，只是借，不是 move
    println!("{:?}", p1); // p1 還在！
}

注意兩個地方：

1. 函數參數的型別寫 &Point（前面加 &）
2. 呼叫時傳 &p1（也加 &）

這樣函數只是「借」了 p1 來看，用完就還回去，p1 的所有權完全沒有改變。

之前的 & 原來是借用！

還記得之前學的 &[i32]（切片）和 &str（字串切片）嗎？當時我們說「先照抄」，現在謎底揭曉了——那些 & 就是借用！

• &[i32] 是借用一段陣列的資料，不擁有它
• &str 是借用一段文字的資料，不擁有它

所以像這樣的函數：

fn sum(nums: &[i32]) -> i32 {
    let mut total = 0;
    for x in nums {
        total += x;
    }
    total
}

fn main() {}

用 for x in nums 就能走訪切片裡的每個元素，跟之前走訪陣列的方式一樣。函數只是借用了陣列的一段切片，不會把整個陣列 move 走。

* 解參考

& 是「借」，反過來 * 就是「順著借用找到原本的值」，叫做解參考（dereference）：

fn main() {
    let x = 42;
    let r = &x;
    println!("{}", *r); // 42，和 x 一樣
}

不過大部分情況下你不需要手動寫 *——Rust 在用 . 存取欄位、呼叫 method、或 println! 的時候都會自動幫你解參考。所以目前知道有這個東西就好，下一集會用到它。

&T 都是 Copy

上一集學了 Copy——有些型別賦值的時候會自動複製，不會 move。不管 T 是什麼，&T 都是 Copy 的。畢竟參考只是借用，複製一個參考不會影響原本的資料，只是多了一個人在看而已：

fn main() {
    let s = String::from("hello");
    let r1 = &s;
    let r2 = r1; // 複製參考，不是 move
    println!("{} {}", r1, r2); // r1 和 r2 都能用
}

注意：String 本身不是 Copy（賦值會 move），但 &String 是 Copy。

借用是唯讀的

用 & 借用的時候，你只能讀，不能改。如果你想借來改，那是下一集的內容。

範例程式碼

#[derive(Debug, Clone)]
struct Point {
    x: i32,
    y: i32,
}

// 用借用，不會 move
fn print_point(p: &Point) {
    println!("({}, {})", p.x, p.y);
}

// 切片參數就是借用
fn sum(nums: &[i32]) -> i32 {
    let mut total = 0;
    for x in nums {
        total += x;
    }
    total
}

fn main() {
    let p1 = Point { x: 10, y: 20 };

    // 借用：傳 &p1，p1 不會被 move
    print_point(&p1);
    print_point(&p1); // 可以借很多次！
    println!("p1 還在：{:?}", p1);

    // 陣列切片也是借用
    let numbers = [1, 2, 3, 4, 5];
    let total = sum(&numbers);
    println!("總和 = {}", total);
    println!("numbers 還在：{:?}", numbers);

    // &str 也是借用
    let greeting: &str = "你好";
    println!("{}", greeting);
    println!("{}", greeting); // 可以用很多次
}

重點整理

• & 是借用，不轉移所有權，原本的變數還能繼續用
• 函數參數寫 &Type，呼叫時傳 &value
• 借用可以多次進行，不像 move 只能一次
• &T 都是 Copy——複製一個參考不影響原本的資料
• 借用是唯讀的，不能修改借來的資料
• &[i32] 和 &str 就是借用——之前「先照抄」的 &，現在解謎了

可變借用 &mut

本集目標

學會用 &mut 借用值並修改它，不需要 move 就能改變別人的資料。

概念說明

上一集的限制

上一集我們學了 & 借用，但借用是唯讀的——你只能看，不能改。如果我們想借別人的東西來修改呢？

&mut 就是「借來改」

fn main() {
    let mut x = 10;
    let r: &mut i32 = &mut x; // 可變借用
    *r = 20;                  // 透過 r 修改 x 的值
}

幾個重點：

1. 原本的變數必須是 let mut（因為你要改它）
2. 借用時寫 &mut x
3. 要透過借用去修改值，要寫 *r（上一集學的解參考——順著借用找到原本的值）

函數參數用 &mut

更常見的用法是在函數裡：

fn add_ten(n: &mut i32) {
    *n += 10;
}

fn main() {
    let mut x = 5;
    add_ten(&mut x);
    println!("{}", x); // 15
}

函數拿到的是 &mut i32——一個可變借用。透過 *n 可以修改原本的值。呼叫時傳 &mut x。

struct 的可變借用

對 struct 也一樣：

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn move_right(p: &mut Point) {
    p.x += 1; // struct 的欄位不需要寫 *，Rust 會自動處理
}

fn main() {}

注意：修改 struct 的欄位時，不需要寫 (*p).x += 1，直接寫 p.x += 1 就好——上一集提過 Rust 會自動解參考。

範例程式碼

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

// 透過可變借用修改整數
fn add_ten(n: &mut i32) {
    *n += 10;
}

// 透過可變借用修改 struct 的欄位
fn move_right(p: &mut Point) {
    p.x += 1;
}

fn move_up(p: &mut Point) {
    p.y += 1;
}

fn main() {
    // 修改整數
    let mut score = 80;
    println!("修改前：{}", score);
    add_ten(&mut score);
    println!("修改後：{}", score);

    // 修改 struct
    let mut pos = Point { x: 0, y: 0 };
    println!("起始位置：{:?}", pos);

    move_right(&mut pos);
    move_right(&mut pos);
    move_up(&mut pos);
    println!("移動後：{:?}", pos);

    // 直接用 &mut 修改
    let mut val = 100;
    let r = &mut val;
    *r += 50;
    println!("val = {}", val);
}

重點整理

• &mut 是可變借用，借來之後可以修改原本的值
• 原本的變數必須是 let mut
• 函數參數寫 &mut Type，呼叫時傳 &mut value
• 修改 struct 欄位可以直接寫 r.field（自動解參考）
• 下一集會學到可變借用的重要限制規則

借用規則

本集目標

理解 Rust 的借用規則：同時只能有一個 &mut 或多個 &，以及懸垂參考的問題。

概念說明

為什麼需要規則？

上一集我們學了 &mut 可變借用。但如果 Rust 允許你同時有多個可變借用，會怎樣？

想像你有一串鑰匙圈。借給很多人看（&）沒問題——大家都只是看，不會改變鑰匙圈上有什麼。但如果同時借給兩個人修改（&mut）——A 在加一把新鑰匙，B 同時在拆掉那把——結果就不可預測了。

這也是資料競爭（data race），會導致各種奇怪的 bug。所以 Rust 制定了嚴格的借用規則。

規則一：同時只能有一個 &mut

在同一個時間點，一個值最多只能有一個可變借用：

#![allow(unused_variables)]

fn main() {
    let mut x = 10;
    let r1 = &mut x;
    let r2 = &mut x; // 編譯錯誤！已經有一個 &mut 了
    *r1 += 1;
}

規則二：& 和 &mut 不能同時存在

如果有人在讀（&），就不能有人在改（&mut）；反過來也是：

#![allow(unused_variables)]

fn main() {
    let mut x = 10;
    let r1 = &x;     // 唯讀借用
    let r2 = &mut x; // 編譯錯誤！已經有 & 了，不能再 &mut
    println!("{}", r1);
}

規則三：多個 & 可以同時存在

多個人同時讀，沒有任何問題：

fn main() {
    let x = 10;
    let r1 = &x;
    let r2 = &x;
    let r3 = &x;
    println!("{} {} {}", r1, r2, r3); // 完全OK
}

懸垂參考（dangling reference）

還有一個重要的規則：參考不能活得比它的原值還久。一旦值離開了作用域被丟棄，任何指向它的參考就會變成懸垂參考——指向一個已經不存在的地方。Rust 在編譯時就會阻止這種事情發生。

最常見的情況是參考從內層作用域「逃」到外面：

fn main() {
    let r;
    {
        let x = 42;
        r = &x; // x 只活在這個大括號裡
    } // x 在這裡被丟棄了
    println!("{}", r); // 編譯錯誤！r 指向的 x 已經不存在了
}

x 在大括號結束時就被丟棄了，但 r 還試圖在外面使用它——Rust 不允許。

另一個常見的情況是函數試圖回傳區域變數的參考：

fn bad() -> &i32 {
    let x = 42;
    &x // x 在函數結束時就被丟棄了，參考會指向一個已經不存在的值
}

fn main() {}

道理是一樣的：x 在函數結束後就消失了，回傳的參考會指向一個不存在的值。

至於 Rust 是怎麼追蹤「參考還有沒有效」的，那就是之後會學到的生命週期（lifetime）概念了。這裡先記住：參考不能活得比它指向的值還久。

範例程式碼

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    // 多個不可變借用：OK
    let p = Point { x: 1, y: 2 };
    let r1 = &p;
    let r2 = &p;
    println!("r1 = {:?}, r2 = {:?}", r1, r2);

    // 一個可變借用：OK
    let mut p2 = Point { x: 10, y: 20 };
    {
        let r3 = &mut p2;
        r3.x += 5;
        println!("修改後：{:?}", r3);
    } // r3 離開作用域，可變借用結束

    // 可變借用結束了，現在可以用 & 借用
    let r4 = &p2;
    println!("唯讀借用：{:?}", r4);

    // 示範：同時多個唯讀借用
    let nums = [10, 20, 30, 40, 50];
    let slice1 = &nums[0..3];
    let slice2 = &nums[2..5];
    println!("slice1 = {:?}", slice1);
    println!("slice2 = {:?}", slice2);
}

重點整理

• 允許無限制地借用同樣會造成資料競爭，所以 Rust 制定了借用規則
• 同一時間只能有一個 &mut，不能同時有兩個可變借用
• & 和 &mut 不能同時存在——要嘛大家都只讀，要嘛只有一個人在改
• 多個 & 可以同時存在，多人同時讀沒問題
• 懸垂參考：參考不能活得比它指向的值還久——不管是值離開了作用域，還是函數回傳區域變數的參考都不行
• Rust 靠這些規則在編譯時就防止資料競爭，之後會學到生命週期來更精確地追蹤參考的有效期

self vs &self vs &mut self

本集目標

學會在 method 中選擇 self、&self、&mut self，以及函數參數的 T / &T / &mut T 怎麼選。

概念說明

回顧：第三章的 self

在第三章，我們學了 impl 和 method，當時所有的 method 都用 self 傳值：

struct Cat;

impl Cat {
    fn meow(self) {
        println!("喵～");
    }
}

fn main() {}

但 self 傳值會消耗這個值——呼叫完之後，原本的變數就不能再用了（因為被 move 了）。

現在我們學了借用，就可以用更聰明的方式了！

三種 self

怎麼選？

• 只是要讀取資料 → 用 &self（最常用！）
• 要修改自己的欄位 → 用 &mut self
• 要轉移所有權（呼叫後原本的變數不能再用） → 用 self

大部分的 method 都用 &self，因為你通常只是想「看看這個東西的狀態」，不需要消耗它。

實際例子：Clone

一個很好的例子是 Clone trait。它定義的簡化版長這樣：

trait Clone {
    fn clone(&self) -> Self;
}

fn main() {}

clone 接收 &self——只是借用自己，不消耗——然後回傳一個新的 Self（大寫 Self，第三章最後一集教過，代表實作這個 trait 的型別）。這解釋為什麼你可以對同一個變數連續呼叫好幾次 .clone()——因為 clone 只是借用，不會 move 原本的值。

如果 clone 的簽名是 fn clone(self) -> Self，那每次 clone 都會消耗原本的值，那就違反 clone 的本意了。

函數參數也一樣

不只是 method 的 self，一般函數參數也是同樣的邏輯：

選擇的原則一樣：

• 只讀 → &T
• 要改 → &mut T
• 要消耗 → T

範例程式碼

#[derive(Debug)]
struct Counter {
    id: i32,
    count: i32,
}

impl Counter {
    // associated function：建立新的 Counter
    fn new(id: i32) -> Self {
        Counter { id, count: 0 }
    }

    // &self：只讀
    fn get_count(&self) -> i32 {
        self.count
    }

    // &self：只讀，印出資訊
    fn display(&self) {
        println!("計數器 {}：目前計數 = {}", self.id, self.count);
    }

    // &mut self：可變借用，修改 count
    fn increment(&mut self) {
        self.count += 1;
    }

    // self：取得所有權，回傳最終結果
    fn finish(self) -> i32 {
        println!("計數器 {} 結束！最終計數 = {}", self.id, self.count);
        self.count
    }
}

// 一般函數也一樣的邏輯
fn print_counter(c: &Counter) {
    println!("（函數版）計數器 {}：{}", c.id, c.count);
}

fn reset_counter(c: &mut Counter) {
    c.count = 0;
}

fn main() {
    let mut c = Counter::new(1);

    // &self：只讀
    c.display();
    println!("目前：{}", c.get_count());

    // &mut self：修改
    c.increment();
    c.increment();
    c.increment();
    c.display();

    // 一般函數的 &T 和 &mut T
    print_counter(&c);
    reset_counter(&mut c);
    c.display();
    c.increment();
    c.increment();

    // self：取得所有權
    let final_count = c.finish();
    println!("回傳的最終計數：{}", final_count);
    // c 的所有權已經被 finish 拿走了，下面這行會編譯錯誤：
    // c.display();
}

呼叫時不用手動加 & 或 &mut

你可能注意到了——呼叫的時候我們只寫 c.display()、c.increment()，不用寫 (&c).display() 或 (&mut c).increment()。Rust 會根據 method 的 self 參數自動幫你加上 & 或 &mut。你當然也能寫 (&c).display() 或 (&mut c).increment()，但沒有必要。

重點整理

• &self：唯讀借用，最常用，呼叫後還能繼續用
• &mut self：可變借用，可以修改欄位，呼叫後還能繼續用
• self：消耗所有權，呼叫後變數就不能再用了
• 選擇原則：只讀 → &self，要改 → &mut self，要消耗 → self
• Clone 裡方法的定義是 fn clone(&self) -> Self——借用自己產生一份新的，所以 clone 不會消耗原本的值
• 一般函數參數也一樣：只讀 → &T，要改 → &mut T，要消耗 → T
• 呼叫 method 時直接寫 c.method()

stack 與 heap

本集目標

理解 stack 和 heap 的差別，並揭秘第 1 集鑰匙圈比喻的真正含義。

概念說明

記憶體的兩個區域

程式執行的時候，資料會被放在記憶體裡。記憶體有兩個主要的區域：

堆疊（stack）：

• 快速
• 大小在編譯時就確定了
• 函數的區域變數、整數、浮點數、布林值、char 都放在這裡
• 函數結束時，這些變數就自動被清掉了

堆積（heap）：

• 比較慢，但更靈活
• 大小可以在程式執行時才決定（例如一段文字，你不知道使用者會輸入多長）
• 需要手動管理（在其他語言裡），或靠所有權系統自動管理（在 Rust 裡）

鑰匙圈比喻揭秘！

還記得第 1 集的鑰匙圈比喻嗎？現在來揭秘它真正的意思：

• 鑰匙圈上的裝飾 = stack 上的資料（小而固定，跟著鑰匙圈走）
• 保險箱 = heap 上的資料（大而靈活，存在別的地方）
• 鑰匙 = 指標（pointer），記錄了保險箱在記憶體中的位置

所以當我們說「move 是把鑰匙圈交出去」：

• 如果鑰匙圈上只有裝飾（stack 資料），交出去很便宜，甚至可以直接複製一份（這就是 Copy！）
• 如果鑰匙圈上有鑰匙（指標），交出去的是指標，保險箱（heap 資料）不會複製

為什麼整數是 Copy？

現在你應該懂了：整數（i32 等）就像鑰匙圈上的小裝飾，完全在 stack 上，小小的、複製起來零成本。所以 Rust 讓它們自動 Copy。

而像之後會學到的 String 那樣的型別，它的資料在 heap 上。如果隨便複製，就等於複製了整個保險箱裡的東西，代價很大。所以 Rust 需要用 move，要複製就得明確呼叫 .clone()。

範例程式碼

#[derive(Debug, Copy, Clone)]
struct StackData {
    x: i32,
    y: i32,
    active: bool,
}

fn main() {
    // 這些都在 stack 上
    let a = 42;    // i32，4 bytes，stack
    let b = 3.14;  // f64，8 bytes，stack
    let c = true;  // bool，1 byte，stack
    let ch = '🦀'; // char，4 bytes，stack
    println!("整數：{}，浮點：{}，布林：{}，字元：{}", a, b, c, ch);

    // struct 裡面全是 stack 資料，所以整個 struct 也在 stack 上
    let data = StackData { x: 10, y: 20, active: true };
    let data2 = data; // Copy！data 還能用
    println!("data = {:?}", data);
    println!("data2 = {:?}", data2);

    // 陣列也在 stack 上（大小固定）
    let arr = [1, 2, 3, 4, 5];
    println!("陣列：{:?}", arr);

    // tuple 也在 stack 上
    let t = (42, true, 'A');
    println!("tuple：{:?}", t);

    // 之後會學 String 和 Vec，它們的資料在 heap 上
    // 到時候 move 和借用的重要性就更明顯了！
}

重點整理

• stack（堆疊）：快速、大小固定。整數、浮點、布林、char、小 struct 都在這裡
• heap（堆積）：靈活、大小可變。大型或動態大小的資料放在這裡
• 鑰匙圈比喻揭秘：裝飾 = stack 資料、保險箱 = heap 資料、鑰匙 = 指標
• 整數是 Copy，因為它們完全在 stack 上，複製幾乎沒有成本
• heap 資料預設 move（只轉移鑰匙），要完整複製就用 clone（複製整個保險箱的內容）

String

本集目標

認識 Rust 的 String 型別——一個擁有資料、可以修改的字串。

概念說明

之前的字串都是借來的

從第一章開始，我們一直在用 &str 這個型別：

fn main() {
    let greeting: &str = "你好";
}

"你好" 這個字串是直接寫在程式碼裡的，它的資料被編譯進程式本身。&str 是一個借用——你只是在看這段文字，但你不擁有它，也不能修改它。

String：你擁有的字串

String 是一個你可以擁有、可以修改的字串型別。它的資料存在 heap 上。

用 String::from() 來建立：

fn main() {
    let s = String::from("你好");
}

String::from 是一個 associated function（跟第三章學的一樣，用 :: 呼叫），它會把 &str 的內容複製一份到 heap 上，建立一個你擁有的 String。

push_str：在後面加上文字

String 可以修改！用 push_str 來接上更多文字：

fn main() {
    let mut s = String::from("你好");
    s.push_str("，世界！");
    println!("{}", s); // 你好，世界！
}

注意變數要宣告成 let mut，因為我們要修改它。

format!：組合多個值成字串

format! 跟 println! 的用法一模一樣，只是它不會印出來，而是回傳一個 String：

fn main() {
    let name = "小明";
    let age = 20;
    let msg = format!("我叫{}，今年{}歲", name, age);
    println!("{}", msg);
}

String 也適用所有權規則

因為 String 的資料在 heap 上，所以它不是 Copy。賦值和傳入函數都會 move：

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // move！s1 不能再用了
}

這跟之前學的一樣——想保留 s1 就用 .clone() 或 & 借用。

範例程式碼

fn main() {
    // 建立 String
    let mut greeting = String::from("你好");
    println!("{}", greeting);

    // push_str：接上更多文字
    greeting.push_str("，世界");
    greeting.push_str("！");
    println!("{}", greeting);

    // format!：組合多個值
    let name = "小花";
    let score = 95;
    let report = format!("{}同學的成績是{}分", name, score);
    println!("{}", report);

    // String 會 move（不是 Copy）
    let s1 = String::from("Rust");
    // let s2 = s1; // 如果這樣寫，s1 就被 move 走了，不能再用
    let s2 = s1.clone(); // 用 clone 複製一份，s1 還在
    println!("s1 = {}", s1);
    println!("s2 = {}", s2);

    // 傳進函數：用借用就不會 move
    let s3 = String::from("哈囉");
    print_string(&s3);
    println!("s3 還在：{}", s3);

    // Debug 格式也能用
    let s4 = String::from("debug 測試");
    println!("{:?}", s4);
}

fn print_string(s: &String) {
    println!("函數收到：{}", s);
}

重點整理

• String 是擁有資料的字串型別，資料存在 heap 上
• String::from("...") 建立新的 String
• push_str 在字串後面接上更多文字（需要 let mut）
• format! 跟 println! 語法一樣，但回傳 String 而不是印出來
• String 不是 Copy，賦值和傳入函數會 move
• 要保留原本的 String，用 .clone() 或 & 借用

String vs &str

本集目標

搞清楚 String 和 &str 的差別，以及函數參數該用哪一個。

概念說明

兩種字串，到底差在哪？

&String 會自動轉成 &str

當你有一個 String，想把它的參考傳給接受 &str 的函數時，Rust 會自動幫你轉換：

fn greet(name: &str) {
    println!("你好，{}！", name);
}

fn main() {
    let s = String::from("小明");
    greet(&s); // &String 自動轉成 &str，完全OK！
}

為什麼可以這樣？之後會學到。現在只要知道：傳 &String 的地方如果參數型別是 &str，Rust 會自動處理。

函數參數偏好 &str

如果你的函數只需要「讀」一段文字，不需要擁有它，參數型別就寫 &str：

fn count_chars(s: &str) -> i32 {
    let mut count = 0;
    for _c in s.chars() {
        count += 1;
    }
    count
}

fn main() {}

這裡用到的 .chars() 是一個 method——String 和 &str 都有實作。它會把字串拆成一個一個字元讓你走訪。

這樣做的好處是：

1. 傳 &str（字串字面值）可以用
2. 傳 &String 也可以用（自動轉換）
3. 不會 move 任何東西

這就是為什麼 Rust 社群普遍建議：函數參數用 &str 而不是 &String。

什麼時候用 String？

• 你需要擁有這段文字（存在 struct 裡、回傳給呼叫者）
• 你需要修改這段文字（push_str 等）

範例程式碼

// 參數用 &str：既能接 &str，也能接 &String
fn greet(name: &str) {
    println!("你好，{}！", name);
}

fn char_count(s: &str) -> i32 {
    let mut count = 0;
    for _c in s.chars() {
        count += 1;
    }
    count
}

fn main() {
    // &str：字串字面值
    let literal = "世界";
    greet(literal);

    // String：擁有的字串
    let owned = String::from("小花");
    greet(&owned); // &String 自動轉 &str

    // 兩種都能傳給接受 &str 的函數
    println!("「{}」有 {} 個字元", literal, char_count(literal));
    println!("「{}」有 {} 個字元", owned, char_count(&owned));

    // String 可以修改，&str 不行
    let mut s = String::from("Rust");
    s.push_str(" 好好玩");
    println!("{}", s);

    // String 會 move
    let s1 = String::from("hello");
    let s2 = s1; // move
    // println!("{}", s1); // 編譯錯誤！
    println!("{}", s2);

    // &str 不會 move（它本身就是借用）
    let greeting: &str = "哈囉";
    let greeting2 = greeting; // 這是 Copy！（&str 是 Copy 的）
    println!("{}", greeting);  // OK
    println!("{}", greeting2); // OK
}

重點整理

• String 擁有資料（heap 上），可以修改，會 move
• &str 是借用，不擁有資料，不能修改，不會 move
• &String 會自動轉成 &str
• 函數參數偏好用 &str——接受範圍更廣（&str 和 &String 都能傳）
• 需要擁有或修改字串時才用 String

Vec 基礎

本集目標

學會使用 Vec——一個可以動態增長的陣列。

概念說明

陣列的限制

我們在第二章學了陣列 [i32; 5]，但陣列的大小是固定的——宣告時就決定了，之後不能加東西也不能減東西。

如果我們需要一個大小可以變化的集合呢？比如：使用者一筆一筆輸入資料，或者程式在執行過程中不斷累積結果。

這就需要 Vec。Vec 就像一個可以伸縮的陣列，資料存在 heap 上。

建立 Vec

最簡單的方式是用 vec! 巨集：

fn main() {
    let nums = vec![1, 2, 3, 4, 5];
}

這樣就建立了一個包含 5 個 i32 的 Vec。Rust 會根據你放的值自動推斷型別。

你也可以建立空的 Vec，然後一個一個加：

fn main() {   
    let mut nums = Vec::new();
    nums.push(10);
    nums.push(20);
}

Rust 會在你第一次 push 的時候推斷出型別。

索引和走訪

Vec 的索引跟陣列一樣，用 [i]：

fn main() {
    let nums = vec![10, 20, 30];
    println!("{}", nums[0]); // 10
    println!("{}", nums[2]); // 30
}

走訪也跟陣列一樣，用 for：

fn main() {
    let nums = vec![10, 20, 30];
    for n in &nums {
        println!("{}", n);
    }
}

注意：走訪的時候用 &nums（借用），這樣 nums 不會被 move 走。下一集會詳細說明。

push：加入新元素

fn main() {
    let mut fruits = Vec::new();
    fruits.push("蘋果");
    fruits.push("香蕉");
    fruits.push("櫻桃");
    println!("{:?}", fruits);
}

push 會把新元素加到最後面。注意 Vec 必須是 let mut 才能 push。

len：取得長度

fn main() {
    let nums = vec![1, 2, 3];
    println!("長度：{}", nums.len());
}

範例程式碼

fn main() {
    // 用 vec! 建立
    let scores = vec![85, 92, 78, 95, 88];
    println!("成績：{:?}", scores);
    println!("第一筆：{}", scores[0]);
    println!("共 {} 筆", scores.len());

    // 空的 Vec，用 push 加入
    let mut names = Vec::new();
    names.push("小明");
    names.push("小花");
    names.push("阿旺");
    println!("名單：{:?}", names);

    // 走訪
    println!("逐一列出：");
    for name in &names {
        println!("  - {}", name);
    }

    // 用 for 走訪並加總
    let nums = vec![10, 20, 30, 40, 50];
    let mut total = 0;
    for x in &nums {
        total += x;
    }
    println!("總和 = {}", total);

    // Vec 可以一直 push
    let mut growing = Vec::new();
    for i in 0..5 {
        growing.push(i * 10);
    }
    println!("動態建立：{:?}", growing);
}

重點整理

• Vec 是可以動態增長的陣列，資料存在 heap 上
• vec![1, 2, 3] 建立有初始值的 Vec，Rust 自動推斷型別
• Vec::new() 建立空的 Vec
• push 在最後面加入元素（需要 let mut）
• 索引用 v[0]、v[1] 等，長度用 v.len()（method，回傳元素個數）
• 走訪用 for x in &v（借用，不 move）
• Vec 和陣列的操作方式很像，但 Vec 大小可以變化

Vec 與所有權

本集目標

理解 Vec 的所有權行為，以及它和 String/&str 的對稱關係。

概念說明

Vec 和 String 是一對

在前面幾集，我們學了 String 和 &str 的關係：

Vec 也有完全一樣的對應：

String 擁有一段文字，&str 借用一段文字。Vec 擁有一組元素，&[T] 借用一組元素。概念完全對稱。

Vec 會 move

Vec 的資料在 heap 上，所以它不是 Copy。賦值和傳入函數都會 move：

fn main() {
    let v1 = vec![1, 2, 3];
    let v2 = v1; // move！v1 不能再用了
}

跟 String 一模一樣。

函數參數用切片 &[T]

跟 String/&str 的建議一樣——如果函數只需要讀取 i32 的 Vec 的內容，用切片 &[i32]：

fn sum(nums: &[i32]) -> i32 {
    let mut total = 0;
    for x in nums {
        total += x;
    }
    total
}

fn main() {
    let v = vec![1, 2, 3, 4, 5];
    let total = sum(&v); // &Vec 自動轉成 &[i32]
    println!("v 還在：{:?}", v);
}

就像 &String 會自動轉成 &str，i32 的 &Vec 也會自動轉成 &[i32]。

for 迴圈與所有權

這是很重要的一點：for 迴圈走訪 Vec 時，可以選擇要 move 還是 borrow：

for x in v——move！

fn main() {
    let v = vec![1, 2, 3];
    for x in v {
        println!("{}", x);
    }
    // v 被 move 走了，不能再用！
}

for x in v 會消耗整個 Vec。迴圈結束後，v 就不存在了。

for x in &v——borrow！

fn main() {
    let v = vec![1, 2, 3];
    for x in &v {
        println!("{}", x);
    }
    println!("v 還在：{:?}", v); // OK！
}

for x in &v 只是借用，v 不會被消耗。

大部分情況你應該用 for x in &v，除非你確定不再需要這個 Vec。

範例程式碼

// 參數用切片：&Vec 自動轉 &[i32]
fn sum(nums: &[i32]) -> i32 {
    let mut total = 0;
    for x in nums {
        total += x;
    }
    total
}

fn print_all(nums: &[i32]) {
    let mut first = true;
    for x in nums {
        if first {
            first = false;
        } else {
            print!(", ");
        }
        print!("{}", x);
    }
    println!();
}

fn main() {
    // Vec 會 move
    let v1 = vec![10, 20, 30];
    let v2 = v1.clone(); // clone 保留 v1
    println!("v1 = {:?}", v1);
    println!("v2 = {:?}", v2);

    // 函數用切片參數（借用）
    let scores = vec![85, 92, 78, 95, 88];
    println!("總分 = {}", sum(&scores));
    print_all(&scores);
    println!("scores 還在：{:?}", scores);

    // 切片操作
    let slice = &scores[1..4]; // 借用一部分
    println!("中間三筆：{:?}", slice);
    println!("中間三筆的總分 = {}", sum(slice));

    // for x in &v：借用走訪
    println!("逐一列出（借用）：");
    for s in &scores {
        println!("  {}", s);
    }
    println!("scores 還在：{:?}", scores);

    // for x in v：move 走訪（用完就沒了）
    let temp = vec![1, 2, 3];
    println!("消耗走訪：");
    for x in temp {
        println!("  {}", x);
    }
    // temp 已經被 move 了，下面會編譯錯誤：
    // println!("{:?}", temp);

    // 對稱關係整理
    // String  ↔ &str     （擁有 ↔ 借用 文字）
    // Vec     ↔ &[T]     （擁有 ↔ 借用 一組值）
    println!("--- 對稱關係 ---");
    let s = String::from("hello");
    let s_ref: &str = &s;     // &String → &str
    println!("String: {}, &str: {}", s, s_ref);

    let v = vec![1, 2, 3];
    let v_ref: &[i32] = &v;   // &Vec → &[i32]
    println!("Vec: {:?}, slice: {:?}", v, v_ref);
}

重點整理

• Vec 和 String 的所有權行為完全對稱：都在 heap 上，都會 move，都可以 clone
• String ↔ &str 就像 Vec ↔ &[T]（擁有 ↔ 借用）
• &Vec 會自動轉成 &[T]（跟 &String 自動轉 &str 一樣）
• 函數參數偏好用切片 &[T] 而不是 &Vec
• for x in v：move，消耗整個 Vec
• for x in &v：borrow，只是借用，Vec 還在
• 大部分情況用 for x in &v，除非你確定不再需要這個 Vec

恭喜你完成了第四章！🎉 這一章你學會了 Rust 最核心的概念——所有權、move、clone、copy、borrowing，還有 String 和 Vec 這兩個最常用的非 Copy 型別。這些概念是 Rust 和其他語言最大的不同，也是 Rust 能在不需要犧牲效能的情況下保證記憶體安全的關鍵。下一章我們將進入泛型、trait bound 和生命週期——讓你的程式碼能處理任意型別，同時保持型別安全！

泛型、Trait Bound 與生命週期

泛型函數

本集目標

學會用 <T> 定義泛型函數，讓同一個函數可以處理不同型別。

概念說明

在第四章，我們學了 Vec，用它來存一堆 i32。但你有沒有注意到，我們總是寫 vec![1, 2, 3]，讓 Rust 自己推斷型別？

其實，Vec 不是一個完整的型別。它的完整寫法是 Vec<i32>、Vec<String>、Vec<bool>——角括號 <> 裡面放的是「這個 Vec 要裝什麼型別的東西」。

第四章故意沒提角括號，因為當時我們還沒學過泛型。現在，是時候揭開這個秘密了。

什麼是泛型？

假設你想寫一個函數，傳入兩個值，回傳第一個：

fn first_i32(a: i32, b: i32) -> i32 {
    a
}

fn main() {}

如果又需要處理 f64 呢？難道要再寫一個 first_f64？

泛型就是解決這個問題的。我們用一個「型別參數」T 來代替具體的型別：

fn first<T>(a: T, b: T) -> T {
    a
}

fn main() {}

這裡的 <T> 寫在函數名後面，表示「這個函數有一個型別參數叫 T」。然後參數 a 和 b 的型別都是 T，回傳值也是 T。

當你呼叫 first(10, 20) 的時候，Rust 看到 10 是 i32，就知道 T = i32。呼叫 first(3.14, 2.71) 的時候，T = f64。同一個函數定義，自動適用於不同型別。

命名慣例

型別參數通常用單個大寫字母：T（Type）、U、V。如果有語意的話也會用比較長的名字，但目前用 T 就好。

範例程式碼

// 泛型函數：回傳兩個值中的第一個
fn first<T>(a: T, _b: T) -> T {
    a
}

// 可以有多個型別參數
fn make_pair<T, U>(a: T, b: U) -> (T, U) {
    (a, b)
}

fn main() {
    // T 被推斷為 i32
    let x = first(10, 20);
    println!("{}", x);

    // T 被推斷為 &str
    let y = first("hello", "world");
    println!("{}", y);

    // 但兩個參數的型別必須一樣，因為 first 的兩個參數都是 T
    // let bad = first(1, "a"); // 編譯錯誤！1 是 i32 但 "a" 是 &str

    // T = i32, U = &str
    let pair = make_pair(42, "hello");
    println!("{:?}", pair);
}

重點整理

• Vec 的完整寫法是 Vec<T>，角括號裡放型別參數——第四章故意省略，現在正式學習
• 泛型函數用 <T> 宣告型別參數，讓同一個函數可以處理不同型別
• Rust 會根據傳入的值自動推斷 T 是什麼型別
• 可以有多個型別參數：<T, U>
• 型別參數慣例用大寫字母：T、U、V

泛型 struct

本集目標

學會定義帶型別參數的 struct，讓同一個結構可以存放不同型別的資料。

概念說明

上一集我們學了泛型函數。其實 struct 也可以有型別參數！

回想一下，Vec<i32> 和 Vec<String> 就是同一個 struct 定義，只是裡面放的型別不同。我們也可以自己定義這樣的泛型 struct。

定義泛型 Struct

struct Pair<T> {
    first: T,
    second: T,
}

fn main() {}

這裡的 <T> 寫在 struct 名稱後面，表示「Pair 有一個型別參數 T」。first 和 second 的型別都是 T，所以它們必須是同一種型別。

使用的時候：

struct Pair<T> {
    first: T,
    second: T,
}

fn main() {   
    let p = Pair { first: 1, second: 2 };       // T = i32
    let q = Pair { first: "hi", second: "yo" }; // T = &str
}

多個型別參數

如果你希望 first 和 second 可以是不同型別，就用兩個型別參數：

struct MixedPair<T, U> {
    first: T,
    second: U,
}

fn main() {}

這和上一集的 make_pair<T, U> 概念一模一樣。

範例程式碼

// 兩個欄位必須同型別
#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

// 兩個欄位可以不同型別
#[derive(Debug)]
struct MixedPair<T, U> {
    first: T,
    second: U,
}

fn main() {
    let int_pair = Pair { first: 10, second: 20 };
    println!("{:?}", int_pair);

    let str_pair = Pair { first: "hello", second: "world" };
    println!("{:?}", str_pair);

    // Pair<T> 的兩個欄位必須同型別，以下會編譯錯誤：
    // let bad = Pair { first: 42, second: "oops" };

    let mixed = MixedPair { first: 42, second: "answer" };
    println!("{:?}", mixed);
}

重點整理

• struct 可以用 <T> 宣告型別參數，讓同一個定義適用於不同型別
• Pair<T> 的兩個欄位都是 T，所以必須同型別
• 需要不同型別時，用多個型別參數：MixedPair<T, U>
• 和泛型函數一樣，Rust 會根據使用方式自動推斷型別參數

泛型 enum

本集目標

學會定義帶型別參數的 enum。

概念說明

上一集學了泛型 struct，這一集來看泛型 enum。其實概念完全一樣——在 enum 名稱後面加 <T>，讓 variant 攜帶的資料可以是任何型別。

定義泛型 Enum

假設我們想做一個「也許有值」的型別，裡面可能有東西，也可能是空的：

enum Maybe<T> {
    Something(T),
    Nothing,
}

fn main() {}

Something(T) 攜帶一個 T 型別的值，Nothing 什麼都不帶。

泛型 enum 也可以有多個型別參數。比如一個「二選一」的型別：

enum Either<L, R> {
    Left(L),
    Right(R),
}

fn main() {}

Either<L, R> 要嘛是 Left(L)，要嘛是 Right(R)——兩個型別完全獨立。

範例程式碼

// 自己定義的泛型 enum
#[derive(Debug)]
enum Maybe<T> {
    Something(T),
    Nothing,
}

// 兩個型別參數的泛型 enum
#[derive(Debug)]
enum Either<L, R> {
    Left(L),
    Right(R),
}

fn main() {
    let a: Maybe<i32> = Maybe::Something(42);
    let b: Maybe<i32> = Maybe::Nothing;

    println!("{:?}", a);
    println!("{:?}", b);

    // 用 match 取出值
    match a {
        Maybe::Something(val) => println!("裡面有：{}", val),
        Maybe::Nothing => println!("空的"),
    }

    // 兩個型別參數
    let x: Either<i32, &str> = Either::Left(100);
    let y: Either<i32, &str> = Either::Right("hello");

    println!("{:?}", x);
    println!("{:?}", y);
}

重點整理

• enum 也可以帶型別參數：enum Maybe<T> { ... }
• variant 攜帶的資料型別可以用 T 來泛化
• 可以有多個型別參數：enum Either<L, R> { Left(L), Right(R) }
• 標準庫裡有很多重要的泛型 enum，之後會陸續認識

turbofish 語法

本集目標

學會用 ::<> turbofish 語法手動指定型別參數，理解它和泛型定義的關係。

概念說明

前幾集我們學了泛型——函數、struct、enum 都可以有型別參數 <T>。大部分時候 Rust 能自動推斷 T 是什麼，但有時候編譯器推不出來，就需要我們手動告訴它。

turbofish 是什麼？

還記得第一章學 parse 的時候，我們寫過這樣的程式碼嗎？

fn main() {
    let input = "1";
    let num = input.trim().parse::<i32>().expect("請輸入數字");
}

當時我們把 ::<i32> 當黑盒子照抄。現在學了泛型，終於可以理解它了！

.parse() 是一個泛型方法，有一個型別參數 T，代表「你想把字串轉成什麼型別」。但光看 input.trim().parse() 這段程式碼，編譯器不知道你想轉成 i32 還是 f64 還是其他東西。

所以我們用 ::<i32> 手動指定 T = i32。這個 ::<> 語法就叫做 turbofish（因為 ::<> 看起來像一條魚 🐟）。

turbofish 的本質

turbofish 就是「手動填入泛型定義裡角括號的型別參數」：

• 泛型定義：fn parse<T>(...)——這裡的 <T> 是宣告
• turbofish：.parse::<i32>()——這裡的 ::<i32> 是填入

函數、方法、型別都可以用 turbofish：

// 函數的 turbofish
func::<i32>(arg);

// 型別的 turbofish
Vec::<i32>::new();

.parse() 做了什麼？

順便完整解釋一下 parse：它把字串轉換成你指定的型別。轉換可能失敗（比如 "abc" 不能轉成數字），所以需要搭配 .expect() 處理失敗的情況——這點在第一章就用過了。

範例程式碼

fn first<T>(a: T, _b: T) -> T {
    a
}

fn main() {
    // 通常 Rust 能自動推斷，不需要 turbofish
    let x = first(10, 20);
    println!("{}", x);

    // 手動用 turbofish 指定型別
    let y = first::<f64>(3.14, 2.71);
    println!("{}", y);

    // Vec 的 turbofish
    let v = Vec::<i32>::new();
    println!("{:?}", v);

    // parse 的 turbofish——呼應第一章的黑盒子
    let input = "42";
    let num = input.parse::<i32>().expect("不是數字");
    println!("{}", num);

    let pi = "3.14".parse::<f64>().expect("不是數字");
    println!("{}", pi);
}

重點整理

• turbofish ::<> 是手動指定泛型型別參數的語法
• 大部分時候 Rust 能自動推斷，不需要 turbofish
• 當編譯器推不出型別時（例如 .parse()），就需要用 turbofish 手動指定
• 第一章寫的 .parse::<i32>() 其實就是 turbofish——現在我們理解它為什麼這樣寫了
• .parse() 把字串轉成指定型別，轉換可能失敗所以搭配 .expect() 使用

placeholder type _

本集目標

學會用 _ 在型別標注中讓編譯器推斷部分型別。

概念說明

上一集學了 turbofish，可以手動指定所有型別參數。但有時候你只想指定一部分，剩下的讓 Rust 自己推斷。這時候就用 _ 作為型別層級的萬用字元。

_ 當型別佔位符

看這個例子：

fn main() {
    let v: Vec<_> = vec![1, 2, 3];
}

這裡我們告訴 Rust「這是一個 Vec」，但裡面的元素型別用 _ 表示「你自己推斷吧」。Rust 看到 1, 2, 3 是整數，就推斷 _ = i32。

turbofish 裡也可以用 _：

fn main() {
    let v = Vec::<_>::new();
}

不過這樣寫其實和直接寫 Vec::new() 讓 Rust 全部推斷沒什麼差別。_ 更常用在你需要指定外層型別、但內層型別讓 Rust 推斷的情況。

什麼時候有用？

當型別有多個參數，你只想標注一部分的時候。_ 的威力在型別越複雜時越明顯——之後學到更多標準庫型別時會自然體會到。

範例程式碼

fn main() {
    // 用 _ 讓 Rust 推斷 Vec 的元素型別
    let v: Vec<_> = vec![1, 2, 3];
    println!("{:?}", v);

    // turbofish 裡也能用 _
    let v2 = Vec::<_>::new(); // 和 Vec::new() 一樣，_ 讓 Rust 推斷
    let v2: Vec<i32> = v2;    // 之後透過使用方式確定型別
    println!("{:?}", v2);

    // 比較：完全不標型別 vs 用 _ 部分標注
    let a = vec![true, false]; // Rust 全部推斷：Vec<bool>
    let b: Vec<_> = vec![true, false]; // 告訴 Rust 是 Vec，元素型別自己推斷
    println!("{:?}", a);
    println!("{:?}", b);
}

重點整理

• _ 可以在型別標注中當佔位符，讓 Rust 推斷該位置的型別
• 適合用在「外層型別我知道，內層讓 Rust 推斷」的情況
• turbofish 和 let 標注都可以使用 _

型別別名

本集目標

學會用 type 為型別建立別名，讓複雜的泛型型別變得更好讀。

概念說明

隨著我們學了泛型，型別會越來越複雜。比如一個三維的資料結構：

Vec<Vec<Vec<i32>>>

每次都寫完整型別有點累，而且不好讀。Rust 提供了 type 關鍵字來建立型別別名：

type Grid3D = Vec<Vec<Vec<i32>>>;

fn main() {}

從此以後，Grid3D 和 Vec<Vec<Vec<i32>>> 就是同一個型別——只是換了個名字。它不會建立新型別，就只是一個簡寫。

簡單的別名

type Name = String;

fn main() {}

Name 和 String 完全等價，可以互換使用。

帶參數的型別別名

型別別名也可以帶泛型參數：

type Pair<T> = (T, T);

fn main() {}

這樣 Pair<i32> 就等於 (i32, i32)，Pair<String> 就等於 (String, String)。

注意

型別別名只是簡寫，不是新型別。Name 和 String 完全可以互換使用，編譯器視它們為同一個型別。

範例程式碼

// 簡單的型別別名
type Name = String;

// 簡化複雜的巢狀型別
type Grid3D = Vec<Vec<Vec<i32>>>;

// 帶泛型參數的別名
type Pair<T> = (T, T);

fn main() {
    // Name 就是 String
    let greeting: Name = String::from("你好");
    println!("{}", greeting);

    // 三維 Vec 用別名就很清爽
    let mut grid: Grid3D = vec![vec![vec![0; 3]; 3]; 3];
    grid[1][1][1] = 42;
    println!("grid[1][1][1] = {}", grid[1][1][1]);

    // Pair<i32> 就是 (i32, i32)
    let point: Pair<i32> = (3, 7);
    println!("{:?}", point);

    let coords: Pair<f64> = (1.5, 3.7);
    println!("{:?}", coords);
}

重點整理

• type Name = ExistingType; 建立型別別名，只是簡寫，不是新型別
• 型別別名可以帶泛型參數：type Pair<T> = (T, T);
• 常見用途：簡化複雜的巢狀型別（如 Vec<Vec<Vec<i32>>>）
• 別名和原型別完全等價，可以互換使用

泛型 impl

本集目標

學會為泛型 struct 實作方法，理解 impl<T> 語法中兩個 T 的含義。

概念說明

第二集我們定義了泛型 struct Pair<T>。這集要幫它 impl。

回想第三章，impl struct 是這樣寫的：

struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn sum(&self) -> i32 {
        self.x + self.y
    }
}

fn main() {}

那泛型 struct 呢？

impl<T> 的語法

#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

impl<T> Pair<T> {
    fn new(first: T, second: T) -> Pair<T> {
        Pair { first, second }
    }
}

fn main() {}

注意這裡有兩個 T 出現在不同位置，它們的角色不一樣：

1. impl<T> 的 <T>：宣告一個型別參數 T。告訴 Rust「接下來我要用一個叫 T 的型別參數」
2. Pair<T> 的 <T>：使用剛才宣告的 T。告訴 Rust「我要幫的是 Pair<T> 這個型別」

換句話說：impl<T> 宣告 T，然後把 T 傳給 Pair<T>——「對於任何型別 T，幫 Pair<T> 實作以下方法」。

如果你只寫 impl Pair<T> 而不加 impl<T>，Rust 會以為 T 是一個具體的型別名稱（就像 i32 或 String 一樣），然後找不到叫 T 的型別就報錯。

反過來，如果你寫 impl Pair<i32>（不需要 impl<T>），那就是只幫 Pair<i32> 這一種加方法，Pair<String> 或其他的都不會有。

方法裡使用 T

宣告了 T 之後，在整個 impl 區塊裡都可以使用它：

#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

impl<T> Pair<T> {
    fn new(first: T, second: T) -> Pair<T> {
        Pair { first, second }
    }

    fn first(&self) -> &T {
        &self.first
    }
}

fn main() {}

實作 trait 也是一樣

第四章教 trait 的時候，我們幫具體型別實作了 trait，像 impl Describe for Cat。如果你想幫一個泛型型別實作 trait，語法也是一樣——在 impl 後面加上 <T> 來宣告型別參數：

trait SomeTrait {}

struct Pair<T> {
    first: T,
    second: T,
}

impl<T> SomeTrait for Pair<T> {
    // ...
}

fn main() {}

一樣是「對於任何型別 T，幫 Pair<T> 實作這個 trait」。

範例程式碼

#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

impl<T> Pair<T> {
    // associated function
    fn new(first: T, second: T) -> Pair<T> {
        Pair { first, second }
    }

    // method：回傳 first 的借用
    fn first(&self) -> &T {
        &self.first
    }

    // method：回傳 second 的借用
    fn second(&self) -> &T {
        &self.second
    }
}

fn main() {
    let p = Pair::new(10, 20);
    println!("first = {}", p.first());
    println!("second = {}", p.second());
    println!("{:?}", p);

    let q = Pair::new("hello", "world");
    println!("first = {}", q.first());
    println!("second = {}", q.second());
}

重點整理

• 為泛型 struct 實作方法時，寫 impl<T> Pair<T> { ... }
• impl<T> 的 <T> 是宣告 T，Pair<T> 的 <T> 是使用 T
• 結論：impl<T> 宣告 T，然後把 T 傳給 Pair<T>
• 宣告之後，整個 impl 區塊裡的方法都可以使用 T
• 幫泛型型別實作 trait 語法類似：impl<T> SomeTrait for Pair<T> { ... }

Option<T>

本集目標

認識 Rust 標準庫最重要的泛型 enum——Option<T>，理解它如何取代 null 並防止 runtime 錯誤。

概念說明

null 的問題

在某些程式語言裡，任何變數都可能是 null（空值）。這導致一個經典問題：你以為變數有值，用了它，結果執行時炸掉——「null pointer exception」。null 的發明者 Tony Hoare 甚至稱它為「十億美金的錯誤」。

Rust 的解法很簡單：沒有 null。

取而代之的是一個泛型 enum：Option<T>。

Option 的定義

Option<T> 長這樣（標準庫已經幫你定義好了）：

enum Option<T> {
    Some(T),
    None,
}

fn main() {}

看起來是不是很像第 3 集我們自己寫的 Maybe<T>？沒錯！概念完全一樣：

• Some(T) 表示「有一個 T 型別的值」
• None 表示「沒有值」

強制處理 None

Option 的厲害之處在於：編譯器強制你處理「沒有值」的情況。你不能直接把 Option<i32> 當成 i32 來用，必須先檢查它到底是 Some 還是 None。

這就是用 match 的時候了：

fn main() {
    let maybe_value = Some("bruh");
    match maybe_value {
        Some(v) => println!("有值：{}", v),
        None => println!("沒有值"),
    }
}

Option 不用寫完整路徑

因為 Option、Some、None 實在太常用了，Rust 預設就把它們引入到每個檔案裡。所以你不需要寫 Option::Some(42)，直接寫 Some(42) 就好。

零成本的秘密：niche optimization

一個有趣的小知識：Option<&T> 和普通的參考 &T 佔用一樣大的記憶體！

因為參考 &T 不可能是 null，所以 Rust 在記憶體中聰明地用 null 來代表 None，不需要額外的空間。這叫做 niche optimization——利用型別中「不可能出現的值」來塞額外的資訊。

範例程式碼

// 在切片中找到第一個偶數，找不到就回傳 None
fn find_even(numbers: &[i32]) -> Option<i32> {
    for n in numbers {
        if n % 2 == 0 {
            return Some(*n);
        }
    }
    None
}

fn main() {
    let nums = vec![1, 3, 5, 8, 11];
    let result = find_even(&nums);

    // 用 match 取出 Option 的值
    match result {
        Some(n) => println!("找到偶數：{}", n),
        None => println!("沒有偶數"),
    }

    let odds = vec![1, 3, 5, 7];
    let result2 = find_even(&odds);

    match result2 {
        Some(n) => println!("找到偶數：{}", n),
        None => println!("沒有偶數"),
    }
}

重點整理

• Option<T> 是 Rust 用來表達「可能沒有值」的泛型 enum，取代了其他語言的 null
• Some(T) 表示有值，None 表示沒有值
• 編譯器強制你處理 None 的情況，執行時期不會有 null pointer exception
• Option、Some、None 太常用，Rust 預設就引入了，不需要額外路徑
• niche optimization：Option<&T> 和 &T 大小相同，零額外成本

Option 常用方法

本集目標

學會 Option 的常用方法：unwrap、expect、unwrap_or、flatten，以及用 if let 取值。

概念說明

上一集我們用 match 來處理 Option，這是最安全的方式。但每次都寫 match 有時候太囉嗦了。Rust 提供了一些方便的方法。

unwrap：暴力取值

fn main() {
    let x: Option<i32> = Some(42);
    let value = x.unwrap(); // 42
}

如果是 Some，直接拿到裡面的值。但如果是 None，程式會 panic（崩潰）！所以 unwrap 要小心用——只在你確定不會是 None 的時候才用。

expect：帶訊息的 unwrap

#![allow(unused_variables)]

fn main() {
    let x: Option<i32> = None;
    let value = x.expect("不應該是 None"); // panic，印出你的訊息
}

和 unwrap 一樣，但 panic 時會印出你自訂的訊息，方便除錯。

unwrap_or：提供預設值

fn main() {
    let x: Option<i32> = None;
    let value = x.unwrap_or(0); // 0
}

如果是 Some 就取出值，如果是 None 就用你給的預設值。不會 panic，很安全。

flatten：把巢狀 Option 壓平

有時候你會碰到 Option<Option<T>> 這種巢狀結構：

fn main() {
    let nested: Option<Option<i32>> = Some(Some(42));
    let flat: Option<i32> = nested.flatten(); // Some(42)
}

flatten 把兩層 Option 壓成一層。如果外層或內層是 None，結果就是 None。

範例程式碼

fn find_even(numbers: &[i32]) -> Option<i32> {
    for n in numbers {
        if *n % 2 == 0 {
            return Some(*n);
        }
    }
    None
}

fn main() {
    let nums = [1, 3, 5, 7];
    let has_even = [2, 4, 6];

    // unwrap_or：安全地提供預設值
    let result = find_even(&nums).unwrap_or(0);
    println!("偶數（沒找到就給 0）：{}", result);

    // expect：確定有值時使用
    let result2 = find_even(&has_even).expect("應該要有偶數");
    println!("找到偶數：{}", result2);

    // if let：第三章學過的語法
    if let Some(n) = find_even(&has_even) {
        println!("用 if let 取出：{}", n);
    }

    // flatten：壓平巢狀 Option
    let nested: Option<Option<i32>> = Some(Some(42));
    let flat = nested.flatten();
    println!("{:?}", flat);

    let nested_none: Option<Option<i32>> = Some(None);
    let flat_none = nested_none.flatten();
    println!("{:?}", flat_none);

    let outer_none: Option<Option<i32>> = None;
    let flat_outer = outer_none.flatten();
    println!("{:?}", flat_outer);
}

重點整理

• unwrap()：取出 Some 的值，None 時 panic——小心使用
• expect("訊息")：和 unwrap 一樣，但 panic 時印出自訂訊息
• unwrap_or(預設值)：None 時回傳預設值，不會 panic
• flatten()：把 Option<Option<T>> 壓成 Option<T>
• 搭配 if let Some(x) = ...（第三章學的）也很方便

Result<T, E>

本集目標

學會使用 Result<T, E> 處理可能失敗的操作，理解它和 Option 的對稱關係。

概念說明

上兩集學了 Option<T>——「可能有值，可能沒有」。但有時候，「沒有值」不夠——你還需要知道為什麼沒有。

比如解析數字，失敗時你想知道是「格式錯誤」還是「數字太大」。這就是 Result<T, E> 的用途。

Result 的定義

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn main() {}

• Ok(T) 表示成功，裡面包著成功的值
• Err(E) 表示失敗，裡面包著錯誤資訊

和 Option 一樣，Result、Ok、Err 也是 Rust 預設就引入到每個檔案裡的。

Result 和 Option 的對稱

Option 只知道「有或沒有」，Result 還知道「為什麼沒有」。

回顧第一章的黑盒子

還記得第一章的 .expect("讀取失敗") 和 .parse::<i32>().expect("請輸入數字") 嗎？

.parse() 回傳的就是 Result。expect 的行為和 Option 的 expect 一模一樣——成功就取出 Ok 的值，失敗就 panic 並印出你的訊息。

現在我們終於能完整理解第一章的那段「黑盒子」程式碼了。

常用方法

和 Option 一樣，Result 也有：

• unwrap()：成功取出值，失敗 panic
• expect("訊息")：和 unwrap 一樣，但自訂 panic 訊息
• unwrap_or(預設值)：失敗時用預設值

範例程式碼

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("除數不能是零"))
    } else {
        Ok(a / b)
    }
}

fn main() {
    // 用 match 處理 Result
    let result = divide(10, 3);
    match result {
        Ok(value) => println!("10 / 3 = {}", value),
        Err(msg) => println!("錯誤：{}", msg),
    }

    // 除以零的情況
    let bad = divide(10, 0);
    match bad {
        Ok(value) => println!("結果：{}", value),
        Err(msg) => println!("錯誤：{}", msg),
    }

    // unwrap_or：失敗時用預設值
    let safe = divide(10, 0).unwrap_or(0);
    println!("安全的結果：{}", safe);

    // 回顧第一章：parse 回傳 Result
    let input = "42";
    let num: Result<i32, _> = input.parse();
    match num {
        Ok(n) => println!("解析成功：{}", n),
        Err(e) => println!("解析失敗：{:?}", e),
    }

    // expect：確定不會失敗時使用
    let num2 = "100".parse::<i32>().expect("這不應該失敗");
    println!("{}", num2);
}

重點整理

• Result<T, E> 表示「成功（Ok）或失敗（Err）」，比 Option 多了錯誤資訊
• Ok(T) 對應成功，Err(E) 對應失敗
• Result、Ok、Err 和 Option 一樣，是 Rust 預設就引入每個檔案的
• unwrap()、expect()、unwrap_or() 的用法和 Option 完全對稱
• 第一章的 .parse().expect(...) 就是在用 Result——現在我們能理解了

? 運算子

本集目標

學會用 ? 運算子簡化錯誤傳播，避免一次又一次的 match。

概念說明

上一集學了 Result，我們用 match 來處理成功和失敗。但如果一個函數裡有好幾個可能失敗的操作呢？

fn do_stuff() -> Result<i32, String> {
    let a = match "42".parse::<i32>() {
        Ok(n) => n,
        Err(e) => return Err(format!("{:?}", e)),
    };
    let b = match "10".parse::<i32>() {
        Ok(n) => n,
        Err(e) => return Err(format!("{:?}", e)),
    };
    Ok(a + b)
}

fn main() {}

每個 parse 都要 match 一次，太囉嗦了。? 運算子就是用來解決這個問題的。

? 的本質

? 放在 Result 後面，做的事情就是：

• 如果是 Ok(v)，把 v 取出來，繼續往下跑
• 如果是 Err(e)，回傳 Err，提前離開函數

所以 ? 就是 match + early return 的簡寫。

注意：錯誤型別要一致

使用 Result 的時候，Err 裡的型別必須和函數回傳的 Err 型別一致或有某種關聯（之後會講具體是哪種關聯）。如果沒有關聯，就不能直接用 ?——你得先把錯誤轉成對的型別。

比如 .parse() 的錯誤型別是 std::num::ParseIntError，但你的函數回傳 Result<_, String>。這時候你可以用 match 自己轉換，然後再手動 return：

fn stringify_err() -> Result<i32, String> {
    let input = "1";
    let n = match input.parse::<i32>() {
        Ok(v) => Ok(v),
        Err(e) => return Err(format!("{:?}", e)),
    };
    n
}

fn main() {}

或者先包一層把錯誤轉好的輔助函數，在那個函數回傳之後就能直接用 ?——下面的範例程式碼就是這樣做的。

後面我們會教到更方便處理這種狀況的做法，不用每次都自己手動轉換錯誤型別。

? 也能用在 Option

? 不只能用在 Result 上，也能用在 Option 上——如果是 None，就直接 return None。

main 也能回傳 Result

如果 main 函數回傳 Result<(), String>，你就可以在 main 裡使用 ?。

範例程式碼

// 手動轉換錯誤型別的輔助函數
fn parse_i32(input: &str) -> Result<i32, String> {
    match input.parse::<i32>() {
        Ok(n) => Ok(n),
        Err(e) => Err(format!("解析 '{}' 失敗：{:?}", input, e)),
    }
}

// 使用 ? 簡化錯誤傳播
fn add_two_strings(a: &str, b: &str) -> Result<i32, String> {
    let x = parse_i32(a)?; // Ok 就取值，Err 就提前回傳
    let y = parse_i32(b)?;
    Ok(x + y)
}

// ? 用在 Option 上：第一個元素是正數嗎？
fn first_is_positive(numbers: &[i32]) -> Option<bool> {
    // 如果切片是空的，.first() 回傳 None，? 直接 return None
    let first = numbers.first()?;
    Some(*first > 0)
}

// main 也能回傳 Result，這樣就能用 ?
fn main() -> Result<(), String> {
    let result = add_two_strings("42", "10")?;
    println!("42 + 10 = {}", result);

    // 錯誤的情況
    let bad = add_two_strings("42", "abc");
    match bad {
        Ok(n) => println!("結果：{}", n),
        Err(e) => println!("錯誤：{}", e),
    }

    let nums = [3, 7, 2];
    match first_is_positive(&nums) {
        Some(true) => println!("第一個元素是正數"),
        Some(false) => println!("第一個元素不是正數"),
        None => println!("空的切片"),
    }

    let empty: &[i32] = &[];
    match first_is_positive(empty) {
        Some(b) => println!("結果：{}", b),
        None => println!("空的切片，沒有第一個元素"),
    }

    Ok(())
}

重點整理

• ? 是 match + early return 的簡寫
• Result 上用 ?：Ok 取值，Err 提前回傳
• Option 上用 ?：Some 取值，None 提前回傳
• 使用 ? 時，錯誤型別必須和函數回傳型別一致——不一致時要另外處理
• fn main() -> Result<(), String> 讓 main 也能使用 ?

多個方法的 trait 與預設實作

本集目標

學會在 trait 中定義多個方法，以及用預設實作讓實作者只需覆寫需要的部分。

概念說明

第四章學 trait 的時候，我們的 trait 都只有一個方法。其實 trait 可以有很多個方法，而且有些方法可以提供預設實作——也就是先寫好一個「通用版本」，實作者不喜歡再覆寫。

多個方法

trait Describe {
    fn name(&self) -> String;
    fn description(&self) -> String;
}

fn main() {}

實作的時候，所有方法都必須提供：

trait Describe {
    fn name(&self) -> String;
    fn description(&self) -> String;
}

struct Cat;

impl Describe for Cat {
    fn name(&self) -> String { ... }
    fn description(&self) -> String { ... }
}

fn main() {}

預設實作

有些方法可以先寫好一個合理的預設版本：

trait Describe {
    fn name(&self) -> String;

    fn description(&self) -> String {
        let n = self.name();
        let mut result = String::from("我是 ");
        result.push_str(&n);
        result
    }
}

fn main() {}

description 有預設實作，它呼叫了 name() 來組合字串。實作 Describe 的時候，只需要提供 name() 就好——description() 會自動使用預設版本。

當然，你也可以覆寫預設實作，提供自己的版本。

預設實作可以呼叫其他方法

注意上面的 description 預設實作裡呼叫了 self.name()。這是允許的——預設實作可以使用同一個 trait 中的其他方法。這讓你可以建立「只要提供幾個基本方法，其他方法就自動有了」的設計。

範例程式碼

trait Describe {
    // 必須實作的方法
    fn name(&self) -> String;

    // 預設實作：可以直接用，也可以覆寫
    fn description(&self) -> String {
        let n = self.name();
        let mut result = String::from("我是 ");
        result.push_str(&n);
        result
    }
}

struct Cat {
    nickname: String,
}

struct Dog {
    nickname: String,
}

// Cat 只實作 name，description 用預設的
impl Describe for Cat {
    fn name(&self) -> String {
        self.nickname.clone()
    }
}

// Dog 覆寫 description
impl Describe for Dog {
    fn name(&self) -> String {
        self.nickname.clone()
    }

    fn description(&self) -> String {
        let n = self.name();
        let mut result = String::from("汪汪！我叫 ");
        result.push_str(&n);
        result.push_str("，我是一隻狗！");
        result
    }
}

fn main() {
    let cat = Cat { nickname: String::from("小橘") };
    let dog = Dog { nickname: String::from("阿柴") };

    // Cat 用預設的 description
    println!("{}", cat.name());
    println!("{}", cat.description());

    // Dog 用自訂的 description
    println!("{}", dog.name());
    println!("{}", dog.description());
}

重點整理

• trait 可以定義多個方法
• 方法可以提供預設實作——在方法後面直接寫 { ... } 而不是 ;
• 預設實作可以呼叫同一個 trait 中的其他方法
• 實作 trait 時，有預設實作的方法可以不寫（使用預設版本），也可以覆寫

trait bound

本集目標

學會用 trait bound 限制泛型參數的能力，以及用條件式 impl 為符合條件的型別加方法。

概念說明

第一集學泛型函數的時候，我們寫了 fn first<T>(a: T, b: T) -> T。但如果你想在泛型函數裡 clone 一個值呢？

fn duplicate<T>(x: &T) -> (T, T) {
    (x.clone(), x.clone()) // 編譯錯誤！
}

fn main() {}

編譯器會報錯：「不是所有 T 都有 clone() 方法。」

這很合理——T 可以是任何型別，萬一有個型別沒有實作 Clone 呢？

trait bound：限制 T 的能力

解法是加上 trait bound，告訴 Rust「T 必須實作 Clone」：

fn duplicate<T: Clone>(x: &T) -> (T, T) {
    (x.clone(), x.clone())
}

fn main() {}

T: Clone 的意思是「T 必須實作 Clone trait」。這樣 Rust 就知道 x.clone() 一定可以呼叫。

到處都能加 trait bound

trait bound 不只能用在函數上。幾乎所有有泛型參數的地方都能加——struct、enum、impl 定義裡都可以：

struct Wrapper<T: Clone> {
    value: T,
}

fn main() {}

條件式 impl

其中最實用的是在 impl 區塊上加 trait bound。這叫做條件式 impl——只有當型別參數符合某些條件時，才提供特定的方法。

#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

impl<T: Clone> Pair<T> {
    fn to_tuple(&self) -> (T, T) {
        (self.first.clone(), self.second.clone())
    }
}

fn main() {}

這段的意思是：只有當 T 實作了 Clone 的時候，Pair<T> 才有 to_tuple 方法。

實際效果

#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

impl<T: Clone> Pair<T> {
    fn new(first: T, second: T) -> Pair<T> {
        Pair { first, second }
    }

    fn to_tuple(&self) -> (T, T) {
        (self.first.clone(), self.second.clone())
    }
}
fn main() {
    let p1 = Pair::new(1, 2); // i32 有 Clone
    let t = p1.to_tuple();    // 可以呼叫 ✓

    let p2 = Pair::new(Pair::new(1, 2), Pair::new(3, 4)); // Pair 沒有 derive Clone
    p2.to_tuple(); // 編譯錯誤！Pair<i32> 沒有實作 Clone
}

Pair<Pair<i32>> 不能呼叫 to_tuple()，因為 Pair<i32> 沒有實作 Clone（我們沒有幫它 derive Clone）。

範例程式碼

#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

// 所有 Pair<T> 都有 new
impl<T> Pair<T> {
    fn new(first: T, second: T) -> Pair<T> {
        Pair { first, second }
    }
}

// 只有 T: Clone 的 Pair<T> 才有 to_tuple
impl<T: Clone> Pair<T> {
    fn to_tuple(&self) -> (T, T) {
        (self.first.clone(), self.second.clone())
    }
}

// 泛型函數 + trait bound
fn duplicate<T: Clone>(x: &T) -> (T, T) {
    (x.clone(), x.clone())
}

fn main() {
    // i32 有 Clone，所以 Pair<i32> 有 to_tuple
    let p = Pair::new(10, 20);
    let t = p.to_tuple();
    println!("{:?}", t);

    // 泛型函數也可以用
    let pair = duplicate(&42);
    println!("{:?}", pair);

    let pair2 = duplicate(&String::from("hello"));
    println!("{:?}", pair2);

    // Pair<Pair<i32>> 不能呼叫 to_tuple
    // 因為 Pair<i32> 沒有 derive Clone
    let nested = Pair::new(Pair::new(1, 2), Pair::new(3, 4));
    println!("{:?}", nested);
    // nested.to_tuple(); // 編譯錯誤！Pair<i32> 沒有實作 Clone
}

重點整理

• trait bound T: Clone 限制 T 必須實作特定 trait
• trait bound 可以加在函數、struct、enum、impl 等各種泛型參數上
• 沒有 trait bound 的話，泛型函數/方法不能假設 T 有任何能力
• 條件式 impl：impl<T: Clone> Pair<T> { ... } 只在 T 符合條件時提供方法

use 基礎

本集目標

學會用 use 把長路徑縮短，並理解為什麼之前不用 use 就能用 Option、Vec 等型別。

概念說明

Rust 有非常多內建的函數、型別和 trait，為了組織它們，Rust 的標準庫用模組把東西分門別類。舉例來說，每個型別都有一個完整的路徑來說明它位於哪個模組裡，路徑用 :: 分隔，像是 std::string::String（String 位於 std 的 string 模組裡）、std::vec::Vec、std::fmt::Display。平常要用某個型別，就要寫出它的完整路徑。

但奇怪的是，我們前面一直在用 Vec、String、Option、Result 這些型別，從來沒寫過 std::vec::Vec 這種完整路徑也能用，為什麼？

因為 Rust 有一個叫 prelude 的機制——Rust 預設就把最常用的函數、型別和 trait 引入到每個檔案裡。Vec、String、Option、Result、Some、None、Ok、Err，還有 Clone、Copy 等常用 trait，都在 prelude 裡面，所以不用寫完整路徑。

但不是所有東西都在 prelude 裡。比如 std::fmt::Display 這個 trait，就不在 prelude 裡。如果你想用它，就要寫完整路徑——或者用 use 把它引入。

use 的語法

use std::fmt::Display;

fn main() {}

這行的意思是：「把 std::fmt::Display 引入到當前的作用域，之後直接寫 Display 就好。」

use 不會引入新功能，它只是讓長路徑變短。沒有 use，你寫 std::fmt::Display；有了 use，你只需要寫 Display。

範例程式碼

use std::mem::size_of;

fn main() {
    // 沒有 use 的話，要寫完整路徑：
    println!("i32 的大小：{} bytes", std::mem::size_of::<i32>());

    // 有了 use，直接寫 size_of 就好：
    println!("bool 的大小：{} bytes", size_of::<bool>());
    println!("f64 的大小：{} bytes", size_of::<f64>());
    println!("char 的大小：{} bytes", size_of::<char>());
}

重點整理

• use std::fmt::Display; 把長路徑縮短，之後直接寫 Display
• use 只是路徑的簡寫，不引入新功能
• Rust 的編譯器預設引入 prelude 的常用型別和 trait（Vec、String、Option、Clone 等）
• 不在 prelude 裡的東西（如 Display）需要寫完整路徑或用 use 引入

Display trait

本集目標

學會為自訂型別實作 Display trait，理解 Display 和 Debug 的差別，以及 Display 和 ToString 的關係。

概念說明

第二章我們學了 {:?} 來印出 tuple、陣列和加了 #[derive(Debug)] 的 struct。但 {:?} 是給開發者看的「debug 格式」。如果你想用 {} 來印出自訂型別，就需要實作 Display trait。

Display vs Debug

• Debug（{:?}）：給開發者看的格式，可以用 #[derive(Debug)] 自動產生
• Display（{}）：給使用者看的格式，必須手動實作，不能 derive

為什麼要分開？因為開發者需要看到所有欄位、型別資訊（debug 格式），但使用者只需要看到好讀的文字。兩者的需求不同，所以不能用同一個 trait 解決。

實作 Display

use std::fmt::Display;
use std::fmt::Formatter;
use std::fmt::Result;

struct Point {
    x: i32,
    y: i32,
}

impl Display for Point {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {}

fmt 方法接收一個 &mut Formatter，你用 write! 巨集把想要的格式寫進去。write! 的用法和 println! 幾乎一樣，只是第一個參數是 &mut Formatter。

Display 和 ToString 的關係

Rust 有一個 ToString trait，它只有一個方法：

fn to_string(&self) -> String;

重點來了——你不需要自己實作 ToString。標準庫裡有這樣一段程式碼：

impl<T: Display> ToString for T {
    fn to_string(&self) -> String {
        // 內部用 Display 的 fmt 方法來產生字串
        // ...
    }
}

這段的意思是：「對於所有實作了 Display 的型別 T，自動幫它實作 ToString。」這叫做 blanket implementation（毯子式實作）——像一條毯子，蓋住所有符合條件的型別。

所以只要實作 Display，你的型別就自動有 .to_string() 方法，不用額外做任何事。

範例程式碼

use std::fmt::Display;
use std::fmt::Formatter;

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

// 手動實作 Display
impl Display for Point {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

#[derive(Debug)]
struct Color {
    r: u8,
    g: u8,
    b: u8,
}

impl Display for Color {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "R{}G{}B{}", self.r, self.g, self.b)
    }
}

fn main() {
    let p = Point { x: 3, y: 7 };

    // Debug 格式（給開發者看）
    println!("Debug: {:?}", p);

    // Display 格式（給使用者看）
    println!("Display: {}", p);

    // 因為有 Display，自動獲得 .to_string()
    let s = p.to_string();
    println!("to_string: {}", s);

    let c = Color { r: 255, g: 128, b: 0 };
    println!("Debug: {:?}", c);
    println!("Display: {}", c);
    println!("to_string: {}", c.to_string());
}

重點整理

• Display trait 讓你的型別可以用 {} 格式印出
• Debug（{:?}）給開發者看，可以 derive；Display（{}）給使用者看，必須手動實作
• 實作方式：impl Display for MyType，在 fmt 方法裡用 write! 寫格式
• 實作 Display 會自動獲得 .to_string() 方法（blanket implementation）

多個 trait bound 與 where

本集目標

學會用 + 組合多個 trait bound，以及用 where 子句讓複雜的 bound 更好讀。

概念說明

第 13 集我們學了 T: Clone，要求 T 必須實作 Clone。但如果你想同時要求 T 實作多個 trait 呢？

多個 trait bound

用 + 把多個 trait bound 串起來：

fn show_clone<T: Clone + std::fmt::Display>(x: &T) {
    let cloned = x.clone();
    println!("原始：{}", x);
    println!("克隆：{}", cloned);
}

fn main() {}

T: Clone + Display 表示 T 必須同時實作 Clone 和 Display。

where 子句

當 trait bound 很長的時候，寫在 <> 裡面會很擠。Rust 提供 where 子句，放在函數簽名後面：

fn show_clone<T>(x: &T)
where
    T: Clone + std::fmt::Display,
{
    let cloned = x.clone();
    println!("原始：{}", x);
    println!("克隆：{}", cloned);
}

fn main() {}

兩種寫法完全等價，只是 where 比較好讀。

where 比角括號更靈活

where 子句的冒號前面不只能放 T，還能放更複雜的東西。比如一個 tuple 型別：

fn clone_pair<T, U>(pair: &(T, U)) -> (T, U)
where
    (T, U): Clone,
{
    pair.clone()
}

fn main() {}

(T, U): Clone 要求 tuple (T, U) 能被 clone。這種寫法只能出現在 where 子句裡，不能放在 <> 裡——這就是 where 更靈活的地方。

範例程式碼

use std::fmt::Display;

// 多個 trait bound：Clone + Display
// clone 一份，印出原始值，然後回傳複製品
fn clone_and_show<T: Clone + Display>(x: &T) -> T {
    println!("複製了：{}", x);
    x.clone()
}

// 用 where 子句：有時候比較好讀
fn show_pair<T, U>(a: &T, b: &U)
where
    T: Display,
    U: Display,
{
    println!("a = {}, b = {}", a, b);
}

fn main() {
    // 多個 trait bound
    let cloned = clone_and_show(&42);
    println!("拿到的複製品：{}", cloned);

    let cloned2 = clone_and_show(&String::from("hello"));
    println!("拿到的複製品：{}", cloned2);

    // where 子句
    show_pair(&10, &"world");
}

where 還能用在哪裡

where 不只能用在函數上。其他很多會用到泛型的地方也都能用 where，例如 impl 區塊：

impl<T> Pair<T>
where
    T: Clone + Display,
{
    // 方法定義
}

此外，where 也能出現在 struct、enum 和 trait 的定義上。目前知道就好了，之後需要用到的時候自然會想起來。

重點整理

• 用 + 組合多個 trait bound：T: Clone + Display
• where 子句是另一種寫 trait bound 的方式，更好讀
• where 比角括號更靈活，冒號前面可以放 tuple 等複雜型別（如 (T, U): Clone）
• where 不只能用在函數上，impl、struct、enum、trait 等能用泛型的地方都能用

impl Trait 語法

本集目標

學會用 impl Trait 作為 trait bound 的簡寫，理解它在參數和回傳值中的不同含義。

概念說明

我們前面學了 trait bound：fn foo<T: Display>(x: &T)。Rust 還提供了一種更簡潔的寫法：impl Trait。

參數位置的 impl Trait

use std::fmt::Display;

fn show(x: &impl Display) {
    println!("{}", x);
}

fn main() {}

這和 fn show<T: Display>(x: &T) 完全等價——都是說「x 的型別必須實作 Display」。只是寫法更簡潔。

每個 impl Trait 是獨立的型別

重要觀念：參數中的每個 impl Trait 代表一個獨立的型別。

use std::fmt::Display;

fn show_two(a: &impl Display, b: &impl Display) {
    println!("{} {}", a, b);
}

fn main() {}

a 和 b 可以是不同的型別——只要它們都實作了 Display。比如 a 可以是 i32，b 可以是 String。

如果你要求 a 和 b 必須是同一個型別，就要用具名的型別參數：

use std::fmt::Display;

fn show_same<T: Display>(a: &T, b: &T) {
    println!("{} {}", a, b);
}

fn main() {}

回傳位置的 impl Trait

impl Trait 也可以用在回傳值：

use std::fmt::Display;

fn greeting() -> impl Display {
    String::from("你好")
}

fn main() {}

這表示「我會回傳一個實作了 Display 的型別，但不告訴你具體是什麼型別」。呼叫者只知道回傳值可以用 Display 的方法（像 println!("{}", greeting())），不知道具體是 String 還是其他什麼。

範例程式碼

use std::fmt::Display;

// 參數位置的 impl Trait
fn show(x: &impl Display) {
    println!("顯示：{}", x);
}

// 每個 impl Trait 是獨立型別，a 和 b 可以不同型別
fn show_pair(a: &impl Display, b: &impl Display) {
    println!("{} 和 {}", a, b);
}

// 要求同一型別，用泛型
fn show_same<T: Display>(a: &T, b: &T) {
    println!("{} 和 {}", a, b);
}

// 回傳位置的 impl Trait
fn make_greeting(name: &str) -> impl Display {
    let mut s = String::from("你好，");
    s.push_str(name);
    s.push_str("！");
    s
}

fn main() {
    // 參數位置
    show(&42);
    show(&String::from("hello"));

    // 兩個參數可以不同型別
    show_pair(&42, &"hello");

    // 要求同型別
    show_same(&10, &20);
    // show_same(&10, &"hello"); // 編譯錯誤！i32 和 &str 不同型別

    // 回傳 impl Trait
    let greeting = make_greeting("世界");
    println!("{}", greeting);

    // greeting 的型別是 `impl Display`，不是 `String`
    // 所以你不能把它當 String 用：
    // greeting.push_str("!!!"); // 編譯錯誤！impl Display 沒有 push_str 方法
    // 即使我們知道裡面其實是 String，編譯器只認 Display 這個 trait
}

重點整理

• fn foo(x: &impl Display) 是 fn foo<T: Display>(x: &T) 的簡寫
• 每個 impl Trait 參數代表獨立的型別——兩個 impl Display 可以是不同型別
• 要求同型別，用具名的型別參數 <T: Display>
• 回傳位置的 -> impl Trait 隱藏具體型別，呼叫者只知道它實作了什麼 trait

多參數 trait

本集目標

學會定義帶其他型別參數的 trait，讓同一個型別可以針對不同目標型別實作同一個 trait。

概念說明

到目前為止，我們的 trait 都比較簡單——Clone、Display、Describe，沒有其他型別參數。但有時候你想定義的行為和另一個型別有關。

比如「轉換」這件事：i32 可以轉成 f64，也可以轉成 String。同一個型別，轉換的目標不同，邏輯也不同。

帶其他型別參數的 trait

trait Convert<T> {
    fn convert(self) -> T;
}

fn main() {}

Convert<T> 的意思是：「可以轉換成 T 型別」。同一個型別可以實作 Convert<f64>、Convert<String> 等不同版本。

實作多參數 Trait

trait Convert<T> {
    fn convert(self) -> T;
}

impl Convert<(i32,)> for i32 {
    fn convert(self) -> (i32,) {
        (self,)
    }
}

fn main() {}

這裡 i32 實作了 Convert<(i32,)>——把自己轉成單元素 tuple。

同一個型別可以實作多次，只要型別參數不同：

trait Convert<T> {
    fn convert(self) -> T;
}

impl Convert<String> for i32 {
    fn convert(self) -> String {
        // 用 ToString trait（i32 已經有了）
        self.to_string()
    }
}

fn main() {}

和沒有其他參數的 trait 的差別

• Clone（沒有其他參數）：一個型別只能實作一次 Clone
• Convert<T>（有其他參數）：一個型別可以實作 Convert<String>、Convert<(i32,)> 等多個版本

範例程式碼

// 定義一個帶型別參數的 trait
trait Convert<T> {
    fn convert(self) -> T;
}

// i32 轉成單元素 tuple
impl Convert<(i32,)> for i32 {
    fn convert(self) -> (i32,) {
        (self,)
    }
}

// i32 轉成 String
impl Convert<String> for i32 {
    fn convert(self) -> String {
        self.to_string()
    }
}

// bool 轉成 i32
impl Convert<i32> for bool {
    fn convert(self) -> i32 {
        if self {
            1
        } else {
            0
        }
    }
}

fn main() {
    // i32 -> (i32,)
    let x: i32 = 42;
    let tuple: (i32,) = x.convert();
    println!("{:?}", tuple);

    // i32 -> String
    let y: i32 = 100;
    let s: String = y.convert();
    println!("{}", s);

    // bool -> i32
    let b = true;
    let n: i32 = b.convert();
    println!("{}", n);
}

重點整理

• Trait 可以帶其他型別參數：trait Convert<T> { ... }
• 同一個型別可以對不同的 T 實作同一個 trait（例如 Convert<String> 和 Convert<(i32,)>）
• 這和沒有其他參數的 trait 不同——一個型別只能實作一次那些 trait
• 多參數 trait 讓「和另一個型別相關的行為」可以統一定義

From / Into

本集目標

學會使用標準庫的 From 和 Into trait 做型別轉換，理解「實作 From 就自動獲得 Into」的機制。

概念說明

上一集我們自己定義了 Convert<T> trait。其實 Rust 標準庫已經有一套更完整的轉換機制：From 和 Into。

From

From<T> 的定義（簡化版）：

trait From<T> {
    fn from(value: T) -> Self;
}

fn main() {}

它的意思是：「我可以從 T 轉換而來。」

你一定見過這個：

fn main() {
    let s = String::from("hello");
}

這就是 String 實作了 From<&str>——從 &str 轉換成 String。

Into

Into<T> 是 From 的反方向：

trait Into<T> {
    fn into(self) -> T;
}

fn main() {}

重點：你只需要實作 From，就自動獲得 Into。 不需要自己實作 Into。

這又是一個 blanket implementation——Rust 有一個規則是「如果 Y: From<X>，那 X 自動實作 Into<Y>」。

TryFrom / TryInto

有些轉換可能失敗——比如把一個很大的 i64 轉成 i32 可能會溢位。這時候用 TryFrom 和 TryInto，它們回傳 Result 而不是直接回傳值。

和 From/Into 一樣，實作 TryFrom 就自動獲得 TryInto。

範例程式碼

use std::fmt::Display;
use std::fmt::Formatter;

struct Celsius {
    value: f64,
}

struct Fahrenheit {
    value: f64,
}

impl Display for Celsius {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "{}°C", self.value)
    }
}

impl Display for Fahrenheit {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "{}°F", self.value)
    }
}

// 實作 From：從 Celsius 轉成 Fahrenheit
impl From<Celsius> for Fahrenheit {
    fn from(c: Celsius) -> Fahrenheit {
        Fahrenheit {
            value: c.value * 1.8 + 32.0,
        }
    }
}

fn main() {
    // String::from——我們一直在用的
    let s = String::from("hello");
    println!("{}", s);

    // 自訂的 From
    let boiling = Celsius { value: 100.0 };
    println!("攝氏：{}", boiling);
    let f = Fahrenheit::from(Celsius { value: 100.0 });
    println!("華氏：{}", f);

    // 自動獲得 Into（不需要另外實作）
    let body_temp = Celsius { value: 37.0 };
    let f2: Fahrenheit = body_temp.into();
    println!("體溫：{}", f2);

    // TryFrom 的例子：i32 轉 u8 可能失敗
    let big: i32 = 300;
    let result = u8::try_from(big);
    match result {
        Ok(n) => println!("轉換成功：{}", n),
        Err(e) => println!("轉換失敗：{:?}", e),
    }

    let small: i32 = 42;
    let ok = u8::try_from(small);
    match ok {
        Ok(n) => println!("轉換成功：{}", n),
        Err(e) => println!("轉換失敗：{:?}", e),
    }
}

重點整理

• From<T> 定義「從 T 轉換而來」：String::from("hello") 就是這個
• 實作 From 就自動獲得 Into——不需要另外實作
• into() 是 from() 的反方向：let f: Fahrenheit = celsius.into();
• TryFrom / TryInto 用於可能失敗的轉換，回傳 Result
• 實作 TryFrom 也會自動獲得 TryInto

Drop

本集目標

學會用 Drop trait 定義值離開作用域時的清理行為，以及手動提前釋放資源。

概念說明

到目前為止，我們知道值離開作用域就不能用了。但其實 Rust 在背後還做了一件事——值離開作用域時，Rust 會自動丟棄（drop）它，釋放它佔用的資源（包括記憶體）。大部分時候你不需要在意這件事，但有時候你想在值被丟棄的那一刻做一些額外的事情，比如印一條訊息、關閉檔案、清理暫存等。

Drop Trait

Drop trait 讓你自訂「被丟棄時要做什麼」：

struct MyType { name: String }

impl Drop for MyType {
    fn drop(&mut self) {
        println!("MyType 被丟棄了！");
    }
}

fn main() {}

Rust 會在值離開作用域時自動呼叫 drop。你不能手動呼叫 x.drop()——Rust 禁止這樣做，因為值被 drop 之後又被自動 drop 一次會出問題。

手動提前釋放

如果你想提前釋放一個值，用 drop()：

struct MyType { name: String }

impl Drop for MyType {
    fn drop(&mut self) {
        println!("MyType 被丟棄了！");
    }
}

fn main() {
    let x = MyType { name: String::from("小明") };
    drop(x); // 提前丟棄
    // x 不能再用了
}

drop 是一個函數（不是 method），它會取走值的所有權，然後讓值離開作用域，觸發 Drop。

有 Drop 的型別不能部分 move

這是一個重要的限制。如果一個 struct 實作了 Drop，你就不能從它的欄位 move 出值：

#![allow(unused_variables)]

struct Resource {
    name: String,
    id: i32,
}

impl Drop for Resource {
    fn drop(&mut self) {
        println!("釋放 {}", self.name);
    }
}

fn main() {
    let r = Resource { name: String::from("A"), id: 1 };
    let n = r.name; // 編譯錯誤！不能部分 move
}

為什麼？因為 drop 需要完整的 self。如果你把 name move 走了，drop 執行時 self.name 就不存在了——這不安全。所以 Rust 禁止有 Drop 的型別做部分 move。

範例程式碼

struct Resource {
    name: String,
}

impl Drop for Resource {
    fn drop(&mut self) {
        println!("釋放資源：{}", self.name);
    }
}

fn main() {
    let a = Resource { name: String::from("資料庫連線") };
    let b = Resource { name: String::from("檔案處理器") };

    println!("建立了兩個資源");

    // 手動提前釋放 a
    drop(a);
    println!("a 已經被提前釋放了");

    // a 不能再用了
    // println!("{}", a.name); // 編譯錯誤！

    println!("接下來 b 會在 main 結束時自動釋放");

    // 作用域示範
    {
        let c = Resource { name: String::from("暫時的資源") };
        println!("c 在這個作用域裡");
    } // c 在這裡被自動 drop

    println!("c 已經被釋放了，b 還在");
} // b 在這裡被自動 drop

重點整理

• Drop trait 讓你自訂值離開作用域時的清理行為
• Rust 在值離開作用域時自動呼叫 drop，不能手動呼叫 .drop()
• 想提前釋放，用 drop(value)
• 有 Drop 的型別不能部分 move——因為 drop 需要完整的 self

Box<T>

本集目標

學會用 Box<T> 把資料放在 heap 上，理解它在遞迴型別中的必要性。

概念說明

還記得第四章的保險箱比喻嗎？鑰匙圈上掛著鑰匙，鑰匙可以打開保險箱，保險箱裡放著真正的東西。

Box<T> 就是那個保險箱——它把資料放在 heap 上，然後在 stack 上留一把鑰匙（指標）。

為什麼需要 Box？

大部分時候，Rust 把資料直接放在 stack 上就好了。但有兩種情況需要 Box：

1. 資料太大

如果一個 struct 有很多欄位、佔很多空間，放在 stack 上可能不太好（stack 空間有限）。用 Box 把它移到 heap 上，stack 上只留一個指標。

2. 遞迴型別

這是更重要的原因。假設你想定義一個連結串列（linked list）：

enum List {
    Node(i32, List), // 編譯錯誤！
    Empty,
}

fn main() {}

Rust 需要在編譯時知道每個型別的大小。但這裡有個問題：要知道 List 的大小，你需要知道 Node 有多大。Node 包含一個 i32 和一個 List——所以你需要知道 List 有多大。但 List 裡面又有 List⋯⋯

展開來看：List 的大小 = i32 + List 的大小 = i32 + i32 + List 的大小 = ⋯⋯ 永遠算不完。編譯器在這裡直接報錯：「recursive type has infinite size（遞迴型別大小無限大）」。

解法就是用 Box：

enum List {
    Node(i32, Box<List>),
    Empty,
}

fn main() {}

Box<List> 的大小是固定的（就是一個指標的大小），問題就解決了。

Box 的使用

fn main() {
    let x = Box::new(42);
    println!("{}", x); // 可以直接用，Rust 會自動拿裡面的值
}

Box::new(value) 把值搬到 heap 上。Box 擁有裡面的值，離開作用域時會自動釋放（因為 Box 實作了 Drop）。

範例程式碼

// 用 Box 的遞迴型別：連結串列
enum List {
    Node(i32, Box<List>),
    Empty,
}

// 印出串列
fn print_list(list: &List) {
    match list {
        List::Node(value, next) => {
            print!("{} -> ", value);
            print_list(next);
        }
        List::Empty => {
            println!("end");
        }
    }
}

fn main() {
    // 基本的 Box 使用
    let x = Box::new(42);
    println!("Box 裡的值：{}", x);

    // 一步一步建立連結串列：3 -> 2 -> 1 -> end
    // 從最後面開始建立
    let list = List::Empty;                   // end
    let list = List::Node(1, Box::new(list)); // 1 -> end
    let list = List::Node(2, Box::new(list)); // 2 -> 1 -> end
    let list = List::Node(3, Box::new(list)); // 3 -> 2 -> 1 -> end

    print_list(&list);

    // Box 是唯一擁有者——鑰匙不是 Copy，所以 let b = a 是 move
    let a = Box::new(String::from("hello"));
    let b = a; // 鑰匙從 a 交給 b，a 就空了
    // println!("{}", a); // 編譯錯誤！a 已經被 move 了
    println!("{}", b);
}

重點整理

• Box<T> 把資料放在 heap 上，stack 上只留一個指標（保險箱比喻的「鑰匙」）
• 最重要的用途：遞迴型別（如連結串列）需要 Box 來打破無限大小的問題
• Box::new(value) 建立 Box，離開作用域時自動釋放
• Box 是唯一擁有者，move 語義和其他非 Copy 的 type 一樣

Rc<T>

本集目標

學會用 Rc<T> 讓多個擁有者共享同一份資料，理解參考計數的原理。

概念說明

上一集學了 Box<T>——一個保險箱只有一把鑰匙，一個擁有者。但有時候你需要多個擁有者共享同一份資料。

問題：一個值只能有一個擁有者

fn main() {
    let a = Box::new(String::from("hello"));
    let b = a; // move！a 不能再用了
}

如果你希望 a 和 b 都能用這個值，怎麼辦？

你可能會想：「那 clone 一份不就好了？」

fn main() {
    let a = Box::new(String::from("hello"));
    let b = a.clone(); // 複製了整個 String 的內容
}

這確實能讓 a 和 b 都能用。但問題是——clone 是真的把 heap 上的資料完整複製了一份。如果資料很大（比如一個很長的 Vec），每次 clone 都是一筆不小的開銷。而且 a 和 b 指向的是兩份獨立的資料，改了 a 不會影響 b。

如果你需要的是「多個人共享同一份資料」，Box 的 clone 就不是正確的工具了。

Rc：參考計數

還記得第四章的保險箱比喻嗎？Rust 預設的規則是「一個保險箱只有一把鑰匙」——這就是所有權。但 Rc<T> 打破了這個預設：它讓你配好幾把鑰匙，都能打開同一個保險箱。

Rc<T>（reference counting）用一個「計數器」來追蹤目前有幾把鑰匙：

• 建立 Rc 時，計數 = 1
• .clone() 時，計數 +1（不會複製資料，只是增加計數）
• 某個 Rc 離開作用域時，計數 -1
• 計數歸零時，資料才會被真正釋放

Rc 的 .clone() 不是深度複製

對 Rc 呼叫 .clone() 和我們之前學的 .clone() 不一樣——它不會複製裡面的資料，只是增加參考計數。所以速度很快，成本很低。

Rc 的 clone 不是用 #[derive(Clone)] 產生的，而是標準庫自己手動實作的。如果用 derive，它會深度複製裡面的資料；但 Rc 的 clone 只是增加計數器，行為完全不同。

Rc 是唯讀的

Rc<T> 只提供不可變的存取——所有擁有者都只能讀，不能改。如果需要可以改，之後會學 RefCell。

範例程式碼

use std::rc::Rc;

fn main() {
    // 建立 Rc，計數 = 1
    let a = Rc::new(String::from("共享的資料"));
    println!("建立 a，計數 = {}", Rc::strong_count(&a));

    // clone 只是增加計數，不複製資料
    let b = a.clone();
    println!("clone 給 b，計數 = {}", Rc::strong_count(&a));

    let c = a.clone();
    println!("clone 給 c，計數 = {}", Rc::strong_count(&a));

    // a, b, c 都可以讀取
    println!("a = {}", a);
    println!("b = {}", b);
    println!("c = {}", c);

    {
        let d = a.clone();
        println!("在作用域裡，計數 = {}", Rc::strong_count(&a));
    } // d 被 drop，計數 -1
    println!("離開作用域後，計數 = {}", Rc::strong_count(&a));

    // 實際用途：多個 struct 共享同一份資料
    let shared_name = Rc::new(String::from("Rust"));

    let greeting1 = shared_name.clone();
    let greeting2 = shared_name.clone();

    println!("1: {}", greeting1);
    println!("2: {}", greeting2);
}

重點整理

• Rc<T> 用參考計數讓多個擁有者共享同一份資料
• Rc::new(value) 建立時計數為 1
• .clone() 計數 +1，只增加計數，不複製內部資料——成本很低
• 某個 Rc 被 drop 時計數 -1，歸零時才釋放資料
• Rc 是唯讀的——所有擁有者只能讀，不能改
• 用 Rc::strong_count(&x) 查看目前的參考計數

Deref 與自動解參考

本集目標

理解 Deref trait 和 Rust 的自動解參考機制，以及智慧指標為什麼能直接呼叫內部型別的方法。

概念說明

對智慧指標使用 *

到目前為止，我們只對一般的參考（&T）用過 *。但其實 * 也能用在其他型別上：

fn main() {
    let b = Box::new(42);
    let val: i32 = *b; // 把值從 Box 裡拿出來
    println!("{}", val); // 42
}

*b 得到的是 Box 裡面的 i32。這之所以能成立，是因為 Box<T> 實作了一個叫 Deref 的 trait。

Deref trait 與智慧指標

Deref 告訴 Rust：「當你需要解參考我的時候，該怎麼做。」Box<T> 和 Rc<T> 都實作了 Deref。在 Rust 中，我們常常把實作了 Deref 的型別叫作智慧指標（smart pointer）。

*v 背後發生了什麼

當你對一個實作了 Deref 的型別使用 * 時，Rust 實際上會這樣展開：

*v
// 等同於
*(Deref::deref(&v))

Deref::deref 接收 &Self，回傳一個參考（例如 &T），然後外面的 * 再把這個參考解開，得到 T 本身。

以剛才的 Box<i32> 為例：

let b = Box::new(42);

*b
// 展開為 *(Deref::deref(&b))
// Deref::deref(&b) 回傳 &i32
// 再 * 一次得到 i32

所以解參考 Box<T> 最終得到的是 T。Rc<T> 也一樣，解參考 Rc<T> 得到 T。

DerefMut

DerefMut 是 Deref 的可變版本。當你對一個可變的智慧指標寫入時，Rust 會用 DerefMut 來展開：

*v = 新的值
// 等同於
*(DerefMut::deref_mut(&mut v)) = 新的值

DerefMut::deref_mut 回傳 &mut T，外面的 * 解開後就能寫入值。例如：

fn main() {
    let mut b = Box::new(0);
    *b = 42;
    println!("{}", *b); // 42
}

Box<T> 同時實作了 Deref 和 DerefMut，所以既能讀也能寫。Rc<T> 則只實作了 Deref，不允許透過 * 修改內容。

Deref coercion

Deref coercion 是 Rust 在需要的時候自動透過 Deref 轉換參考型別的機制。這不只發生在 method call，任何需要型別匹配的地方都可能觸發。

例如，一個函數接受 &i32，你可以直接傳 &Box<i32> 進去，Rust 會自動透過 Deref 把 &Box<i32> 轉成 &i32：

fn show(val: &i32) {
    println!("{}", val);
}

fn main() {
    let b = Box::new(42);
    show(&b); // deref coercion：&Box<i32> 自動轉成 &i32
}

Deref coercion 也可以連鎖。例如 &Box<Box<i32>> 會先 deref 成 &Box<i32>，再 deref 成 &i32。DerefMut 同理。

method call 的自動解參考

method call 有另一套獨立的機制。前面學過 (&a).method() 可以簡寫為 a.method()——如果 method 接收的是 &self，Rust 會自動幫你加 &。反過來，如果你有一個 &T 或智慧指標，而方法定義在 T 上，Rust 也會自動幫你加 *。

當你用 . 呼叫方法時，Rust 會嘗試加 &、加 *、或兩者組合，一層一層嘗試，直到找到有對應方法的型別。如果 a 是 &Box<i32>，而你呼叫一個定義在 i32 上、接收 &self 的方法，Rust 會做 (&**a).method()——先 *a 得到 Box<i32>，再 * 得到 i32，再 & 回去得到 &i32 來匹配 &self。

來看一些比較簡單的例子：

let boxed = Box::new(String::from("hello"));

// 你寫的：
boxed.len()

// Rust 實際上做的：
(*boxed).len()
// *boxed 得到 String，String 有 len()，找到了

如果有多層包裝，Rust 會一層一層剝開：

let double_boxed = Box::new(Box::new(String::from("hello")));

// 你寫的：
double_boxed.len()

// Rust 實際上做的：
(**double_boxed).len()
// *double_boxed 得到 Box<String>，沒有 len()
// 再 * 一次得到 String，有 len()，找到了

Rc 也一樣：

use std::rc::Rc;

fn main() {
    let rc = Rc::new(vec![1, 2, 3]);
    println!("{}", rc.len()); // 自動解參考，呼叫 Vec 的 len()
}

方法同名時的優先順序

Rust 從外往內找方法：外層智慧指標自身的方法優先於內層型別的方法。

一個常見的例子是 clone。Rc 本身有 clone 方法（增加參考計數），T 可能也有 clone 方法（深度複製資料）。直接呼叫 .clone() 會拿到 Rc 的 clone：

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("hello"));
    let b = a.clone(); // Rc 的 clone，增加參考計數，不複製 String
}

如果你想呼叫內層 String 的 clone，可以明確寫出來：

use std::rc::Rc;

fn main() {
    let a = Rc::new(String::from("hello"));
    let c = (*a).clone(); // String 的 clone，真的複製了一份 String
}

範例程式碼

use std::rc::Rc;

fn show(val: &i32) {
    println!("值：{}", val);
}

fn main() {
    // *Box<T> 得到 T（Deref）
    let b = Box::new(42);
    let val: i32 = *b;
    println!("解參考 Box：{}", val);

    // DerefMut：透過 * 寫入值
    let mut b = Box::new(0);
    *b = 42;
    println!("寫入後：{}", *b);

    // deref coercion：&Box<i32> 自動轉成 &i32
    let b = Box::new(99);
    show(&b);

    // 自動解參考：Box<String> 直接呼叫 String 的方法
    let boxed = Box::new(String::from("hello"));
    println!("Box 裡的字串長度：{}", boxed.len());
    // 等同於 (*boxed).len()

    // Rc 也一樣
    let rc = Rc::new(vec![10, 20, 30]);
    println!("Rc 裡的 Vec 長度：{}", rc.len());

    // clone 的優先順序
    let a = Rc::new(String::from("shared"));
    let b = a.clone();       // Rc 的 clone（快，只增加計數）
    let c = (*a).clone();    // String 的 clone（慢，複製整個 String）
    println!("a = {}, b = {}, c = {}", a, b, c);
    println!("Rc 計數 = {}", Rc::strong_count(&a)); // 2，不是 3
}

重點整理

• 在 Rust 中，實作了 Deref 的型別常被稱為智慧指標；*v 展開為 *(Deref::deref(&v))，所以解參考 Box<T> 得到 T
• DerefMut 是 Deref 的可變版本；*v = 值 展開為 *(DerefMut::deref_mut(&mut v)) = 值
• Deref coercion：Rust 在型別不匹配時會自動透過 Deref 轉換參考，不限於 method call（如 &Box<i32> → &i32）
• method call 的自動解參考是獨立的機制：用 . 呼叫方法時，Rust 會嘗試加 &、加 * 或兩者組合來找到對應的方法
• 方法同名時外層優先——Rc 的 clone 優先於 String 的 clone

Cell<T>

本集目標

學會用 Cell<T> 在不可變參考的情況下修改值，理解它的限制。

概念說明

第四章學了借用規則：要嘛一個 &mut，要嘛多個 &，不能同時。這很安全，但有時候你在只有 &（不可變參考）的情況下，還是想修改值。

Cell 的概念

Cell<T> 提供一種「繞過借用規則」的方式——它用 .get() 取值、.set() 設值，不需要可變參考。

use std::cell::Cell;

fn main() {
    let x = Cell::new(42);
    x.set(100);              // 不需要 mut！
    println!("{}", x.get()); // 100
}

但 Cell 有一個重要的限制：

T 必須是 Copy

Cell<T> 的 .get() 會把值複製一份出來（不是借用）。所以 T 必須實作 Copy。

你不能用 Cell<String>，因為 String 不是 Copy。只能用 Copy 的型別（i32、f64、bool 等）。

為什麼不要用 mut？

有些情況下你不方便拿到 &mut。比如一個 struct 被多處共享參考（&self），但你想修改裡面的某個計數器。Cell 就很適合這種場景。

Rc 就是用 Cell 實作的

上一集學的 Rc<T> 需要一個參考計數器——每次 clone 時計數 +1，drop 時計數 -1。但 Rc 對外只提供 &self（不可變參考），計數器卻需要被修改。怎麼辦？答案就是用 Cell！Rc 內部的計數器就是 Cell<usize>，所以即使只有 &self 也能更新計數。

範例程式碼

use std::cell::Cell;

struct Counter {
    count: Cell<i32>,
    name: String,
}

impl Counter {
    fn new(name: String) -> Counter {
        Counter {
            count: Cell::new(0),
            name,
        }
    }

    // 注意：只需要 &self，不需要 &mut self
    fn increment(&self) {
        let current = self.count.get();
        self.count.set(current + 1);
    }

    fn get_count(&self) -> i32 {
        self.count.get()
    }
}

fn main() {
    // 基本用法
    let x = Cell::new(42);
    println!("原始值：{}", x.get());

    x.set(100);
    println!("修改後：{}", x.get());

    // 在 struct 裡使用 Cell
    let counter = Counter::new(String::from("訪問次數"));

    // 只有 &counter（不可變參考），但可以修改 count
    counter.increment();
    counter.increment();
    counter.increment();

    println!("{} 的計數：{}", counter.name, counter.get_count());
}

重點整理

• Cell<T> 讓你在不需要 &mut 的情況下修改值
• .get() 複製值出來，.set() 寫入新值
• T 必須是 Copy——因為 get 是複製，不是借用
• 適合用在「只有 &self 但想修改某個欄位」的場景