型別系統導論
前言
你剛寫完一段程式，按下執行。螢幕閃出紅色錯誤：TypeError: Cannot read properties of undefined。你皺眉頭嘟囔：「怎麼又來？」
其實這個錯誤背後是「型別系統」在幫你把關。為什麼有的語言報錯在執行前，有的在執行後？為什麼有的語言 1 + "1" 等於 "11"，有的直接噴錯？這一切都和型別系統有關。
本章我們從最基礎的「什麼是型別」開始，用生活比喻解釋靜態/動態、強/弱型別，再動手實作一個迷你型別檢查器，最後比較 TypeScript、Rust、Python 的型別哲學。
這篇文章會帶你學什麼？
學完這章後，你將獲得：
- 四象限思維：快速判斷任何語言的型別設計
- 底層理解：知道為什麼
1 + "1"在不同語言結果不同 - 實戰能力：看懂並設計基本的型別註解
- 選型判斷：根據場景選擇適合的型別嚴格度
- 動手經驗：實作一個迷你型別檢查器，理解編譯器如何做型別推斷
| 章节 | 內容 | 核心概念 |
|---|---|---|
| 第 1 章 | 四象限 | 靜態/動態 × 強/弱型別 |
| 第 2 章 | 靜態 vs 動態 | 檢查時機與型別註解 |
| 第 3 章 | 強型別 vs 弱型別 | 隱式轉換與型別安全 |
| 第 4 章 | 型別推斷與推導 | 讓編譯器幫你寫型別 |
| 第 5 章 | 聯型與泛型 | 型別系統的進階武器 |
| 第 6 章 | 總結 | 選擇合適的型別系統 |
0. 全景圖：型別系統概述
1. 型別系統的作用
程式是對資料進行操作的過程。但不同類型的資料，能做的操作是不一樣的：
| 生活例子 | 類比程式 | 為什麼不能亂做？ |
|---|---|---|
你可以把兩個數字加起來：2 + 3 = 5 | 數字型別加法 number + number | 這是數學加法 |
你可以把兩個字串拼起來："hello" + " world" | 字串連接 string + string | 這是字串串接 |
| 但你不能把「地址」除以「電話號碼」 | 複合型別不支援除法 | 語義上毫無意義 |
| 也不能對「人名」做開根號 | 字串不支援數學運算 | 會得到無意義的結果 |
型別系統就是計算機的資料分類和操作規則系統。它定義了：
- 有哪些型別：整數、浮點數、字串、布林、陣列、物件……
- 每種型別能做什麼操作：數字可以加減乘除，字串可以拼接取長度……
- 不同型別之間如何互動：能不能相加？能不能賦值？需不需要轉換？
生活比喻：圖書館分類
型別系統就像圖書館的分類系統：
- 分類標籤（型別）：文學書、科技書、歷史書、繪本……
- 放置區域（記憶體配置）：不同類型的書放在不同書架區
- 借閱規則（操作規則）：參考書只能館內閱讀，普通書可以外借
- 館際互換（型別轉換）：有些書可以跨館調閱（隱式轉換），有些必須手動申請（顯式轉換）
沒有分類的圖書館，找一本書要翻遍所有書架；沒有型別的程式，出了問題要逐行排查。型別系統就是為了讓混亂變得有序。
2. 靜態型別與動態型別
型別檢查發生在什麼時候？這是靜態和動態的核心差異。
| 維度 | 靜態型別（Static Typing） | 動態型別（Dynamic Typing） |
|---|---|---|
| 檢查時機 | 編譯時（Compile-time） | 執行時（Runtime） |
| 發現錯誤 | 程式執行之前 | 程式執行之後 |
| 型別宣告 | 通常需要（現代語言有推斷） | 不需要 |
| 代表語言 | Java、C++、Rust、TypeScript | Python、JavaScript、Ruby、PHP |
| 生活比喻 | 機場安檢：進去之前就檢查，不給帶違禁品 | 百貨公司隨逛：進去之後才可能被攔 |
靜態型別：把關在執行前
TypeScript 範例（注意這裡有個錯誤，把 num2 寫成了字串 "2"）：
function addNumbers(a: number, b: number): number {
return a + b;
}
// ✅ 正確
addNumbers(1, 2); // 3
// ❌ 錯誤！編譯器直接報錯，程式根本跑不起來
// Argument of type 'string' is not assignable to parameter of type 'number'
addNumbers(1, "2");靜態型別的威力：在你按下「執行」之前，型別檢查器就像一個嚴格的保安，攔下了所有不符合型別規定的程式碼。好的靜態型別系統甚至能幫你避免邏輯錯誤（Rust 的所有權系統甚至能避免記憶體泄漏和資料競爭）。
動態型別：出錯才攔截
JavaScript 範例（同樣的錯誤）：
function addNumbers(a, b) {
return a + b;
}
// ✅ 看起來正常
addNumbers(1, 2); // 3
// ❌ 「正常執行」但結果不對！
addNumbers(1, "2"); // "12" —— 字串串接，不是加法動態型別的靈活性代價是：錯誤只有在執行到那段程式碼時才會浮出來。如果你的測試沒覆蓋到那個分支，Bug 就會跑到生產環境。
那種比較好
| 場景 | 推薦型別 | 理由 |
|---|---|---|
| 快速原型、小工具、個人專案 | 動態型別（Python/JS） | 寫得快，心智負擔低 |
| 團隊協作、程式碼量大、長期維護 | 靜態型別（TS/Rust/Java） | 重構安全，錯誤提早發現 |
| 程式碼可能被別人維護 | 靜態型別 | 型別就是最好的文件 |
| 效能要求極高 | 靜態型別（C++/Rust） | 編譯器可以做更多最佳化 |
3. 強型別與弱型別
另一個維度是：型別轉換有多「自動」？
| 維度 | 強型別（Strong Typing） | 弱型別（Weak Typing） |
|---|---|---|
| 隱式轉換 | 幾乎不做自動轉換 | 積極做自動轉換 |
| 型別安全 | 高：不隨便混合不相容型別 | 低：為了「能跑」不惜結果奇怪 |
| 代表語言 | Python、Rust、Haskell | JavaScript、PHP、C |
| 生活比喻 | 嚴格的分類商店：蔬菜區和五金區不混賣 | 夜市攤販：什麼都可以搭在一起賣 |
JavaScript 的隱式轉換（弱型別經典）
// 這些結果合理嗎？
console.log(1 + "2"); // "12" → 數字被轉成字串
console.log("5" - 1); // 4 → 字串被轉成數字
console.log(true + false); // 1 → 布林被轉成數字
console.log([] + {}); // "[object Object]" → 瘋狂轉換
console.log(NaN === NaN); // false → NaN 不等於自己為什麼 JavaScript 這麼「自由」？因為 Brendan Eich 只用了 10 天設計這門語言，設計理念是「盡量讓程式碼跑起來，不要隨便報錯」。這個理念在 1995 年（當時 JS 只用來做表單驗證）或許合理，但在今天（Node.js 跑後端、單頁應用幾十萬行程式碼）就成了災難。這也是為什麼 TypeScript 會誕生：給弱型別的 JS 加上強型別的保護。
Python 的強型別保護
# Python 說：不行就是不行，不要自己亂猜
print(1 + "2")
# TypeError: unsupported operand type(s) for +: 'int' and 'str'
# 你必須手動做型別轉換（顯式轉換）
print(str(1) + "2") # "12" —— 字串串接
print(1 + int("2")) # 3 —— 數字加法強型別的好處是：不會在你沒察覺的時候偷偷做轉換，導致結果和你預期的不一樣。 與其得到一個錯得很離譜的結果，不如直接報錯，讓你趕快修正。
C 的「中間地帶」
#include <stdio.h>
int main() {
int x = 65; // ASCII 碼 65 = 'A'
char c = x; // int → char 隱式轉換（寬容）
printf("%c\n", c); // 印出 A
double d = 3.14;
int y = d; // double → int 隱式轉換（小數被截斷！）
printf("%d\n", y); // 印出 3，不是 3.14
return 0;
}C 在基本型別之間做了許多隱式轉換，是公認的「弱型別」。好處是寫起來方便，壞處是如果你不知道這些轉換規則，很容易踩到精確度丟失或溢位的坑。
4. 型別推斷與型別註解
很多初學者以為「靜態型別 = 每一行都要寫型別」，其實現代靜態型別語言幾乎都有型別推斷（Type Inference），編譯器會根據右側的值自動推斷左側變數的型別：
// 你不需要寫 const message: string = "Hello"
// TypeScript 會自動推斷 message 是 string
const message = "Hello, TypeScript!";
// 但函式參數和返回值通常建議寫上型別註解
// 讓編譯器和讀你的程式碼的人都知道你的意圖
function greet(name: string): string {
return `Hello, ${name}!`;
}
// Rust 推斷能力更強，大部分時候不用寫型別
fn main() {
let number = 42; // 推斷為 i32（整數）
let pi = 3.14; // 推斷為 f64（浮點數）
let name = "Rust"; // 推斷為 &str（字串切片）
}原則：什麼時候寫型別註解？
- 函式的參數和返回值一定要寫 — 這是介面契約
- 複雜資料結構建議寫 — 物件、陣列的巢狀結構寫清楚比較好維護
- 簡單的區域變數可以不寫 — 讓編譯器推斷，保持程式碼簡潔
5. 聯型與泛型
學完基礎型別後，我們來看兩個進階但超好用的武器：聯型（Union Types） 讓一個變數可以是多種型別之一，泛型（Generics） 讓型別可以「參數化」。
聯型：「可能是 A 也可能是 B」
// 一個使用者的狀態：可能是未登入（null）或已登入（物件）
type User = {
id: number;
name: string;
} | null;
// 請求結果：成功時帶資料，失敗時帶錯誤
type Result<T> =
| { success: true; data: T }
| { success: false; error: string };泛型：「型別參數，型別化的函式」
// 沒有泛型的話，你得寫無數個版本……
function identityString(x: string): string { return x; }
function identityNumber(x: number): number { return x; }
// 有了泛型，一個函式搞定所有型別
function identity<T>(x: T): T { return x; }
identity<string>("hello"); // T = string
identity<number>(42); // T = number
identity({ name: "Alice" }); // 推斷 T = { name: string }應用：泛型佇列
// Rust 的泛型實作：Queue 可裝任何型別的元素
struct Queue<T> {
items: Vec<T>,
}
impl<T> Queue<T> {
fn new() -> Self { Queue { items: Vec::new() } }
fn enqueue(&mut self, item: T) { self.items.push(item); }
fn dequeue(&mut self) -> Option<T> {
if self.items.is_empty() { None } else { Some(self.items.remove(0)) }
}
}6. 總結：選擇合適的型別系統
把本章的四個維度整合起來，你就能判斷任何一門語言的型別風格：
| 語言 | 靜態/動態 | 強/弱型別 | 適合什麼 |
|---|---|---|---|
| Rust | 靜態 | 超強 | 系統軟體、效能敏感場景、追求零成本抽象 |
| TypeScript | 靜態 | 強（底層 JS 弱） | 前端、Node.js、需要漸進式加強型別 |
| Java | 靜態 | 強（但有很多轉換） | 企業級後端、Android、大型團隊 |
| Go | 靜態 | 強 | 雲原生基礎設施、微服務、Docker/K8s 生態 |
| Python | 動態 | 強 | AI / 資料科學 / 腳本 / 快速原型 |
| JavaScript | 動態 | 弱 | 簡單互動、腳本（但建議寫 TypeScript） |
| PHP | 動態 | 弱 | 早期 Web（現代 PHP 已加強型別） |
選型指南
沒有最好的型別系統，只有最適合場景的選擇。 但有三個經驗法則：
- 個人專案 + 快速迭代：選動態強型別（Python），爽就完事了
- 團隊 + 長期維護 + 程式碼量大：選靜態強型別（TS/Rust/Java），節省的除錯時間遠大於你寫型別的時間
- 效能優先 + 底層控制：選 Rust/C++，型別系統幫你守住底線並釋放最大效能
延伸閱讀
- 《型別程式設計入門》 — 用 TypeScript 講解型別系統的方方面面
- The Rust Performance Book — Rust 中的型別如何影響最佳化
- TypeScript Handbook — 官方文件講解高級型別技巧
- Haskell 趣學指南 — 透過 Haskell 感受強大的 Hindley-Milner 型別推斷
下一步學習：回到全棧開發導論，你會發現：理解了型別系統，再去看任何一門語言的文件，你都能快速掌握它的設計哲學，而不是死記語法。