第一章：基礎

第一章第 1 集：安裝 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 的編譯器，負責把程式碼轉成電腦能執行的東西

第一章第 2 集：第一個程式

本集目標

用 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! 用來印東西到螢幕上

第一章第 3 集：變數與輸出

本集目標

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

正文

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

什麼是變數？

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

來看看怎麼用：

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

跑起來會印出：

5

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

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

文字變數

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

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

跑起來會印出：

Hello, Rust!

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

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

let 不一定要馬上賦值

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

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

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

重點整理

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

第一章第 4 集：註解

本集目標

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

正文

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

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

單行註解

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

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); 就不會被執行了，但你隨時可以把 // 拿掉讓它復活。

小提醒

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

重點整理

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

第一章第 5 集：算術運算子

本集目標

學會在 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 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3
10 % 3 = 1

等等，10 / 3 怎麼是 3？

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

% 是什麼？

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

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

多個 {} 的用法

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

println!("{} + {} = {}", a, b, a + b);

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

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

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

重點整理

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

第一章第 6 集：運算子優先順序

本集目標

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

第一章第 7 集：比較運算子

本集目標

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

正文

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

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

== 等於

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

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

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

!= 不等於

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

印出 true。5 不等於 3 嗎？對。

< 小於

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

印出 true。3 小於 5。

> 大於

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

印出 true。10 大於 7。

<= 小於等於

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

印出 true。5 小於或等於 5 嗎？等於的話也算，所以是 true。

>= 大於等於

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

印出 false。8 大於或等於 10 嗎？不是。

一覽表

重點整理

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

第一章第 8 集：if

本集目標

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

正文

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

這就是 if 的用途。

基本用法

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

跑起來會印出：

大於 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 條件不需要加小括號

第一章第 9 集：作用域

本集目標

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

正文

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

什麼是作用域？

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

來看這個例子：

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

跑起來會印出 10。到這裡都沒問題。

出了大括號會怎樣？

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

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

你會得到一個編譯錯誤：

error[E0425]: cannot find value `y` in this scope

Rust 在跟你說：「我找不到 y 這個東西。」

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

為什麼要有作用域？

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

不只是獨立的大括號

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

重點整理

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

第一章第 10 集：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 是二選一：一定會走其中一邊，不會兩邊都走或都不走

第一章第 11 集：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");
    }
}

跑起來會印出：

B

它是怎麼判斷的？

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 是選擇性的，用來處理「以上條件都不成立」的情況

第一章第 12 集：邏輯運算子

本集目標

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

正文

上幾集我們學了 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
• 用邏輯運算子組合多個條件，寫出更精確的判斷

第一章第 13 集：let mut

本集目標

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

正文

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

先看看會怎樣

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

你覺得會印出 10 嗎？不會。你會得到一個編譯錯誤：

error[E0384]: cannot assign twice to immutable variable `x`

Rust 在跟你說：「x 是不可變的，你不能再給它新的值。」

等等，為什麼不行？

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

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

要改的話，加 mut

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

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

跑起來會印出：

x 原本是 5
x 現在是 10

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

小整理

let x = 5;       // 不可變，之後不能改
let mut x = 5;   // 可變，之後可以改

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

重點整理

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

第一章第 14 集：複合賦值運算子

本集目標

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

正文

上一集學了 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 宣告

第一章第 15 集：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() 這些是什麼意思？以後會慢慢教，現在先照抄就好。

為什麼先不解釋？

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

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

重要的事

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

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

重點整理

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

第一章第 16 集：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

關鍵在這行

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("請輸入數字")

第一章第 17 集：綜合練習

本集目標

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

正文

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

目標

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

完整程式碼

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，就能做出有互動性的程式
• 程式設計的魅力：把小塊知識拼在一起，就能做出有用的東西
• 除了學新語法，多練習組合應用也很重要

第一章第 18 集：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;
    }
}

跑起來：

5
4
3
2
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 就是無限迴圈，記得一定要有出口

第一章第 19 集：while

本集目標

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

正文

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

用 while 改寫倒數計時

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

跑起來：

5
4
3
2
1
發射！

結果一模一樣！

跟 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 適合在迴圈中間才能決定要不要停的情況

第一章第 20 集：for + range

本集目標

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

正文

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

for + 範圍

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

跑起來：

0
1
2
3
4

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
1
2
3
4
5

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 裡面都可以使用

第一章第 21 集：巢狀迴圈

本集目標

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

正文

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

什麼是巢狀迴圈？

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

九九乘法表

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

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

跑起來：

1 x 1 = 1   1 x 2 = 2   1 x 3 = 3   ... 1 x 9 = 9
2 x 1 = 2   2 x 2 = 4   2 x 3 = 6   ... 2 x 9 = 18
...
9 x 1 = 9   9 x 2 = 18   9 x 3 = 27   ... 9 x 9 = 81

它是怎麼運作的？

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);
        }
    }
}

跑起來：

i=1, j=1
i=2, j=1
i=3, j=1

每次 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!("結束！");
}

跑起來：

i=1, j=1
結束！

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

重點整理

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

第一章第 22 集：continue

本集目標

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

正文

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

只印奇數

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

跑起來：

1
3
5
7
9

它是怎麼運作的？

迴圈 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);
    }
}

1
2
3
4
6
7
8
9
10

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);
        }
    }
}

跑起來：

i=1, j=1
i=2, j=1
i=3, j=1

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

重點整理

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

第一章第 23 集：型別（基礎）

本集目標

認識 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);
}

x = 5
negative = -10
y = 3.14
z = true

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

那之前為什麼不用標？

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

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; 手動指定型別

第一章第 24 集：型別（數字詳解）

本集目標

認識 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 就夠了
• 浮點數有 f32 和 f64，日常用 f64（Rust 預設）
• 數字後綴（如 5i32、3.14f64）可以直接指定型別
• 浮點數除法保留小數，但有精確度問題（0.1 + 0.2 ≠ 0.3）
• 不同型別的數字不能直接混著算，Rust 不會自動轉型

第一章第 25 集：char

本集目標

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

正文

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

char 是什麼？

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

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

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

A
你
🦀

單引號 vs 雙引號

這很重要：

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

let c = 'A';        // char，一個字元
let s = "Hello";    // 字串，五個字元

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

// 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);
}

R 美 の 😊

每一個都是合法的 char。

型別標註

如果你想明確標註型別：

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

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

重點整理

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

第一章第 26 集：跳脫字元

本集目標

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

正文

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

\n —— 換行

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

第一行
第二行

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

\t —— Tab

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

名字  分數
小明  85
小華  92

\t 會插入一個 tab 空間。

\\ —— 反斜線本身

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

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

檔案路徑：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);
}

A
B   C\

\' —— 單引號

在 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 裡都能使用

第一章第 27 集：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。

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

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 有時候是數字、有時候是字串——它需要一個確定的型別。

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

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

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

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

這有什麼好處？

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

重點整理

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

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

第二章：函數、陣列與切片

第二章第 1 集：const

本集目標

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

正文

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

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

來看語法：

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

跑起來會印出：

最高分是：100

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

差別一：const 一定要標型別

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

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

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

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

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

差別三：const 不能用 mut

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

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

差別四：const 可以放在函數外面

const MAX_PLAYERS: i32 = 10;

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

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

什麼時候用 const？

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

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

重點整理

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

第二章第 2 集：shadowing

本集目標

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

正文

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

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

結果：

x = 6

第二行的 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);
}

結果：

x = 6

Shadowing vs mut：最大的差別

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

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

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

結果：

x = hello

這完全合法！因為第二個 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);
}

結果：

input + 1 = 43

如果沒有 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
}

結果：

區塊內 x = 2
區塊外 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 的變數，出了大括號就消失，原本的變數會「回來」

第二章第 3 集：底線變數

本集目標

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

正文

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

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

編譯的時候會看到：

warning: unused variable: `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 還能用，_ 不能用

第二章第 4 集：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 用 () 把不同型別的值打包在一起
• 用 t.0、t.1、t.2 取值（索引從 0 開始）
• () 是空的 tuple，叫做 unit type
• 單元素 tuple 要加逗號：(5,) 不是 (5)

第二章第 5 集：{:?} Debug 格式

本集目標

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

正文

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

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

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

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

編譯器會跟你說：

error: `(i32, i32, i32)` doesn't implement `std::fmt::Display`

翻譯成白話：「這個型別沒有實作 Display，我不知道要怎麼用『好看的方式』印出來。」

解決方法：用 {:?}

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

結果：

(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);
}

結果會自動換行、縮排，看起來更清楚：

(
    (1, 2),
    (3, 4),
    (5, 6),
)

小技巧：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! 是快速偵錯的好幫手，會印出檔名和行數

第二章第 6 集：簡單函數

本集目標

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

正文

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

定義一個函數

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

fn main() {
    greet();
}

結果：

你好！歡迎來到 Rust 的世界！

拆解一下語法：

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

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

函數可以呼叫好幾次

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

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

結果：

哈囉！
哈囉！
哈囉！

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

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

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

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

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

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

函數命名慣例

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

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

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

重點整理

• 用 fn 名字() { ... } 定義函數
• 在 main 裡用 名字(); 呼叫
• 函數定義放在 main 上面或下面都可以
• 命名慣例是 snake_case（全小寫加底線）

第二章第 7 集：函數參數

本集目標

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

正文

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

加上參數

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

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

結果：

3 + 4 = 7
10 + 20 = 30

語法拆解：

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

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

參數一定要標型別

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

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

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

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

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

多個參數、不同型別

參數可以有不同的型別：

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

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

結果：

5 是正數嗎？true
-3 是正數嗎？false

一個參數也行

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

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

結果：

5 的兩倍是 10
100 的兩倍是 200

重點整理

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

第二章第 8 集：函數回傳值

本集目標

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

正文

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

基本語法

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

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

結果：

3 + 4 = 7

重點來了：

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

不加分號 = 回傳值

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

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

加了分號會怎樣？

如果你不小心加了分號：

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

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

沒寫回傳值的函數

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

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

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

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

只是 -> () 通常省略不寫。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);
}

結果：

結果：7
再加 10：17

用 Tuple 回傳多個值

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

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

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

結果：

第一個：2，第二個：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);
}

結果：

最小：3，最大：7

重點整理

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

第二章第 9 集：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));
}

結果：

abs(5) = 5
abs(-3) = 3
abs(0) = 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
    }
}

兩種都對！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));
}

結果：

3.3333333333333335
錯誤：不能除以零！
0.0

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

不要到處用 return

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

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

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

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

重點整理

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

第二章第 10 集：遞迴

本集目標

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

正文

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

答案是可以的，而且這個技巧叫做遞迴（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: i32) -> i32 {
    if n <= 1 {
        1
    } else {
        n * factorial(n - 1)
    }
}

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

結果：

5! = 120
3! = 6
1! = 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: i32) {
    if n <= 0 {
        println!("發射！🚀");
        return;
    }
    println!("{}...", n);
    countdown(n - 1);
}

fn main() {
    countdown(5);
}