1. 介紹
如果你曾經想過:「為什麼我第十次在寫同一段字串轉換?」那你其實已經差不多準備好理解 extensions 了。 Extension 函式是一種方式,讓你可以在不修改既有型別程式碼的前提下,替它加上方便的「看起來像方法」的操作。 這在型別是外部來源時(標準函式庫、第三方函式庫)特別有用,因為你實際上不可能(也不應該)去改它。
務必記住一個核心概念:extensions 不會新增真正的類別成員,它們只是讓你用方法語法去呼叫一般函式。
想像型別是一台辦公室裡的咖啡機。咖啡機是別人的,不能拆機改裝。但你可以在旁邊牆上貼一張「快速沖泡指南」,並告訴同事:「照這樣喝」。 咖啡機本身沒有改變,但使用起來更順手了。extension 就是那張指南,只是編譯器會假裝它像是被「內建」在咖啡機裡一樣。
為了不要停留在抽象層面,我們會以一個 CLI(主控台)風格的小程式為出發點:假設我們正在逐步做一個支出記錄。 我們會有像 add、list、total 這類命令,並且希望能乾淨而一致地處理使用者輸入。
2. Extension 函式的語法
在這一節我們會平穩地釐清 Kotlin 的 extension 函式長什麼樣,以及編譯器為什麼允許這種語法。 主要目標是:不要再把 fun String.xxx() 當成什麼超自然的東西。 這不是「把語言弄壞」,而是一種非常克制的語法糖:它會被轉換成一般函式呼叫,只是用更好讀的方式寫出來。
extension 函式的語法如下:
fun ReceiverType.functionName(params...): ReturnType {
...
}
其中 ReceiverType 是我們要「擴充」的型別。我們不改類別本身,但能得到這樣的呼叫形式: obj.functionName()。
最簡單的例子:把命令字串正規化——去掉前後空白、轉成小寫。
fun String.normalizeCommand(): String {
return trim().lowercase()
}
fun main() {
val raw = " AdD "
println(raw.normalizeCommand()) // add
}
這裡的 normalizeCommand() 是一般函式;但因為寫成 fun String.normalizeCommand() 所以就可以像字串的方法那樣呼叫它。
從技術面(簡化來說)編譯器大概會把: raw.normalizeCommand() 轉成 normalizeCommand(raw)。 也就是說,這只是「把物件當作第一個參數傳進去」的更舒服寫法。
3. Receiver:extension 函式裡的 this 是誰
「receiver」這個詞聽起來像要架設網路伺服器,但其實很簡單。 Receiver就是呼叫 extension 函式的那個物件。 在函式本體裡,這個物件可以用 this 存取,就跟一般類別方法內的 this 一樣。 因此 extension 函式會「感覺」像方法:在裡面你可以直接寫 length、 trim()、 lowercase() 而不需要額外的限定。
Kotlin 文件強調:擴充「永遠是在 receiver 上被呼叫」,而且 receiver type 必須和被擴充的類別/介面型別相符。
看看一個例子:在 extension 函式裡我們顯式使用 this(雖然通常不需要):
fun String.isBlankAfterTrim(): Boolean {
val prepared = this.trim()
return prepared.isEmpty()
}
fun main() {
println(" ".isBlankAfterTrim()) // true
println(" hi ".isBlankAfterTrim()) // false
}
沒錯,這裡的 this 就是原始字串。它不是「特別的 this」、不是新物件、也不是拷貝;它就是同一個 receiver。
這帶出一個很實用的結論:extension 函式非常適合用來做「對物件的小操作」——你可以替它取個好名字,避免把邏輯散落在各處。
4. 在 CLI 中使用 extension:把 main 的雜訊拿掉
接下來會出現 extensions 最討喜的一個效果:它們讓腳本式(CLI)的程式碼更短、更好懂。 主控台程式常常有很多「樣板包裝」:讀一行、正規化、切成片段、檢查命令是否存在。 如果這些都直接堆在 main 裡,它很快就會變成托爾斯泰的長篇小說(我們想讀小說,不想拿來編譯)。
我們替字串做兩個小擴充:
- 命令正規化(trim() + lowercase()),
- 用空白把字串拆成「單字」,但不要空片段。
fun String.normalizeCommand(): String = trim().lowercase()
fun String.splitWords(): List<String> =
trim().split(Regex("\\s+"))
fun main() {
val input = " ADD coffee 250 "
val words = input.normalizeCommand().splitWords()
println(words) // [add, coffee, 250]
}
注意:邏輯變得可以由左到右閱讀。我們幾乎是在描述一條 pipeline:「正規化 → 切成單字」。 這就是 Kotlin 裡大家喜歡 extensions 的原因之一:程式碼讀起來像故事。Kotlin 也確實偏愛這種敘事感。
還有一點:Kotlin 標準庫本身就有大量 extension 函式(例如集合相關的),這也算是語言哲學的一部分——很多實用 API 就是透過擴充實作出來的。
5. 可見性:extension 函式能看到什麼
這裡有一段通常會打破新手期待的內容:「既然它像方法,那我就能拿到 private 欄位吧!」 不行。而且這其實是好事,否則我們很容易破壞外部類別的封裝。 extension 函式不是類別的一部分,所以它遵循一般可見性規則:只能看到「從外部」看得到的東西。
Kotlin 文件把它講得很直接:宣告在 receiver 類別外部的 extension,無法存取該類別的 private/protected 成員。
範例:不能讀取 receiver 的 private 欄位
class User(private val password: String) {
fun passwordLength(): Int = password.length
}
fun User.isSecure(): Boolean {
// password is not accessible here because it is private:
// return password.length >= 8
return passwordLength() >= 8
}
fun main() {
val u = User("supersecret")
println(u.isSecure()) // true
}
在這裡 extension 函式只能使用公開 API(passwordLength()),而不能直接去碰 password。這才是正確做法。
細節:檔案層級的 private 在同一個檔案內可見
另一個有用的細節:如果 extension 宣告在檔案的 top-level,它可以存取同一個檔案內的 private 函式/變數。 這不是「繞過私有」,而是一般規則:檔案層級的 private 表示「只在此檔案內可見」。
在我們的 CLI 情境下這很方便:你可以把正則或小工具藏成 private,再讓 extension 使用它們來提供漂亮的 API。
private val spaces = Regex("\\s+")
fun String.splitWords(): List<String> =
trim().split(spaces)
fun main() {
println("a b c".splitWords()) // [a, b, c]
}
這是一種很乾淨的方式:不把「服務性細節」暴露給外部,同時仍然能寫出整潔的擴充。
6. Kotlin 如何選擇 extension 函式
下面整理幾條在真實程式碼中最常決定 extensions 行為的規則:該放哪裡、如何用 import 引入、名稱衝突時誰會「贏」,以及為什麼 extensions 不會像 override 那樣提供多型。
extensions 放哪裡,以及如何用 import 引入
開始寫 extensions 之後,會出現一種新的混亂:「我有個檔案叫 Utils.kt,裡面塞了 400 個對所有東西的擴充」。 幾乎成了傳統。但我們會嘗試提前避免它。
概念很簡單:extensions 最好依語意放在一起,放到獨立的檔案/套件中,並在需要的地方引入。 Kotlin 對此支援得很自然:你把 extension 宣告在 top-level,然後像一般函式一樣 import 它。
迷你示意(概念圖):
// File: cli/TextExtensions.kt
package app.cli
fun String.normalizeCommand(): String = trim().lowercase()
// File: cli/Main.kt
package app.cli
import app.cli.normalizeCommand
fun main() {
println(" ADD ".normalizeCommand()) // add
}
沒錯,import extension 的方式就跟一般函式一樣。這再次提醒我們:extension 不是「真正的類別方法」,它只是用更方便的語法呼叫函式。
Extension vs member function:同名時誰會贏
現在來到一個重要分岔:extension 函式以方法形式呼叫,但 Kotlin 也有真正的方法(member functions)。 如果類別已經有同名方法,會發生什麼?
Kotlin 的規則很明確:名稱與簽名都相同時,member function 優先,extension 會輸。
class Example {
fun printType() {
println("Member")
}
}
fun Example.printType() {
println("Extension")
}
fun main() {
Example().printType() // Member
}
為什麼要這樣?因為不然 extensions 可能會在你不知情的情況下「攔截」類別行為,尤其是來自函式庫的類別。 Kotlin 選擇了可預測性:真正的方法永遠比「貼在咖啡機旁的貼紙」重要。
不過有個好消息:只要簽名不同,extension 可以多載(overload)。
class Example {
fun printType() {
println("Member")
}
}
fun Example.printType(index: Int) {
println("Extension #$index")
}
fun main() {
Example().printType() // Member
Example().printType(2) // Extension #2
}
對我們的 CLI 來說,這表示:當你擴充標準庫型別(String、List、Map)時,幾乎不會「破壞」它們的 API——你要嘛新增新名稱,要嘛謹慎地用不同簽名做多載(但別走火入魔)。
靜態選擇:為什麼這不是多型
這是今天的核心「陷阱」。我們知道在 OOP 中,override 會在執行期依物件的實際型別選擇。 新手很容易把同樣期待套到 extensions 上。但 Kotlin 的做法不同: extension 函式是以靜態方式解析,也就是在編譯期依變數型別決定,而不是依實際物件。
open class Animal
class Dog : Animal()
fun Animal.kind(): String = "animal"
fun Dog.kind(): String = "dog"
fun printKind(a: Animal) {
println(a.kind())
}
fun main() {
val a: Animal = Dog()
val d: Dog = Dog()
printKind(a) // animal
println(d.kind()) // dog
}
為什麼 printKind(a) 會印出 "animal"? 因為參數 a 的型別是 Animal。 即使裡面實際放的是 Dog,extension 仍然是依變數型別選擇,而不是依「內容」。
記憶法很簡單:extension 函式不會成為虛擬方法表的一部分(不參與 override 機制)。 它是外部的語法糖,所以不會啟動多型。
因此在實務上代表:不要試圖用 extensions 來「多型化」處理型別階層。 這應該交給一般方法與 override(或對 sealed 階層做 when,但那是另一個故事,今天不展開)。
Extension 函式不取代 override:用「formatter」示範
我們做一個例子,直接對比差異:override 依實際物件選擇;extension 依變數型別選擇。
假設我們有一個支出模型:
data class Expense(
val title: String,
val cents: Int
)
我們希望在主控台漂亮列印支出。先做兩個 formatter(用一般方法與 override),再加一個 extension 做對照。
open class ExpenseFormatter {
open fun format(e: Expense): String = "${e.title}: ${e.cents} cents"
}
class PrettyExpenseFormatter : ExpenseFormatter() {
override fun format(e: Expense): String = "• ${e.title} — ${e.cents}¢"
}
fun main() {
val f: ExpenseFormatter = PrettyExpenseFormatter()
val e = Expense("Coffee", 250)
println(f.format(e)) // • Coffee — 250¢
}
這一段如預期運作:format() 被覆寫,呼叫時會選到 PrettyExpenseFormatter 的實作。
接著在 ExpenseFormatter 上加一個 extension(純示範,實際專案通常沒必要這麼做):
fun ExpenseFormatter.formatHeader(): String = "=== Expenses ==="
fun main() {
val f: ExpenseFormatter = PrettyExpenseFormatter()
println(f.formatHeader()) // === Expenses ===
}
這能運作,但要理解:formatHeader() 無法像一般方法那樣透過繼承被「覆寫」,因為它不是類別的方法。 它就是外部函式,只是用方法語法呼叫。
結論:如果你需要依型別替換行為——用 override。 如果你想從外部加上一個方便的操作——用 extension。
迷你對照表:方法 vs extension
有時把兩個概念並排放著就很有幫助,讓大腦停止混淆。 兩者都有 receiver,呼叫長得也像,但在選擇規則與存取權限上完全不同。
| 特性 | 一般類別方法(member function) | Extension 函式 |
|---|---|---|
| 宣告位置 | 類別內部 | 外部(通常 top-level) |
| 呼叫方式 | |
|
| 實作選擇 | 可透過 override 動態選擇 | 靜態:依變數型別 |
| 存取 receiver 的 private 成員 | 可以(它就是類別的一部分) | 不行(若 extension 宣告在類別外) |
| 同名衝突時 | 它才是事實來源 | 同簽名時會輸給 member |
這張表不用背。只要記住兩個「錨點」: extension 是靜態解析;而且若宣告在外部,就看不到 receiver 的 private 成員。
7. 使用 extension 函式時的常見錯誤
錯誤 1:期待像 override 一樣有多型。
很常見的陷阱:寫了 fun Dog.kind(),並以為透過 Animal 呼叫仍會得到 "dog"。 但 extension 是依變數的 declared type(靜態)決定,而不是依實際物件。
錯誤 2:嘗試存取 receiver 類別的 private/protected 成員。
若 extension 宣告在類別外部,它不會變成「自己人」:private 成員仍然是 private。 若你真的需要存取,通常代表類別應該提供公開方法/屬性(或你用錯地方解題了)。
錯誤 3:把 extensions 變成 Utils.kt 的垃圾桶。
當擴充變多後,很容易想把它們「先丟到某個地方」。 一個月後就變成考古現場:「normalize() 到底宣告在哪?為什麼有三個?」 更好的方式是依語意就近放置,並在真正使用的地方 import。
錯誤 4:給 extensions 取太通用的名字。
像 process()、handle()、doStuff() 這種名字,不管是方法還是 extension 都很糟。 但 extension 還有額外問題:它讀起來像「型別內建的能力」。 如果字串突然多了一個 process(),未來的讀者就得去翻它到底做什麼。 好的名稱應該描述結果:normalizeCommand()、splitWords()、toMoneyLabel()。
錯誤 5:忘記 member 方法的優先權。
有時開發者寫了同名 extension,期待改變類別行為,結果疑惑:「為什麼沒有被呼叫?」 若類別已經有同簽名的 member 方法,它會勝出。
GO TO FULL VERSION