CodeGym /課程 /Kotlin SELF /try/catch 作為表達式

try/catch 作為表達式

Kotlin SELF
等級 40, 課堂 1
開放

1. 為什麼要把 try/catch 變成表達式

當你剛接觸例外時,try/catch 看起來就像「安全護欄」:把危險的程式碼包起來——看起來就不會掛掉(如果運氣好)。但當程式稍微複雜一點,典型的痛點就來了:這裡要解析數字、那裡要做除法、第三個地方要檢查前置條件;而你到處都想拿到一個值(或清楚的替代方案),而不是「一堆 var 和旗標」。

Kotlin 支援更乾淨的寫法:try 是表達式,也就是它可以從 try 或 catch 回傳值。這被視為慣用寫法(idiomatic)。

想像你正在做一個 CLI 應用程式(我們的實作專案 v1),讀取使用者輸入的指令。使用者可能把支出金額輸入成 120,也可能輸入成 一百二十(很浪漫,但電腦不太懂)。通常有兩條路:要嘛寫一坨變數配上 if 的「義大利麵程式碼」,要嘛把「嘗試解析」變成表達式,得到乾淨的結果。

2. try/catch 作為表達式:語法與型別

Kotlin 的表達式不是高等數學

在動到 try 之前,先再抓住一個重點:在 Kotlin 裡,很多結構都能回傳值。你已經在 if 與 when 看過這件事,可以這樣寫:

val label = if (x > 0) "positive" else "non-positive"

try/catch 的運作方式很像:它同樣可以回傳一個值。而且,回傳值由 try 區塊或對應 catch 區塊中最後被執行的表達式決定。

這帶來一種寫法風格:在結構內直接「算出來 → 回傳」,不需要中間變數。程式碼看起來就像在講故事,而不是在寫會議紀錄。

基本語法:val x = try { ... } catch { ... }

你會反覆使用的一段關鍵片段:在 Kotlin 中,try 可以被指派給 val。這很正常也很常見:也就是「把 try-catch 當作表達式使用」。

最簡單的例子——「解析成數字,否則回傳 0」:

fun parseOrZero(text: String): Int =
    try {
        text.toInt()
    } catch (e: NumberFormatException) {
        0
    }

fun main() {
    println(parseOrZero("42"))     // 42
    println(parseOrZero("四十"))  // 0
}

請注意一個小但重要的細節:try 和 catch 都以相同型別的值結尾(Int)。因此整個 try/catch 的型別也是 Int。

如果你讓 try 回傳 Int,但 catch 卻回傳 String,編譯器會很快提醒你:它不是通靈者,不想猜「你到底要的是什麼」。有時共同型別可能被推斷成 Any,但通常這是在暗示「你做了怪怪的事」,而讀你程式碼的人之後會很痛苦。

迷你表格:try 表達式的值從哪裡來

try 裡發生了什麼 try/catch 表達式會回傳什麼
沒有發生錯誤 try 區塊的最後一個表達式
發生錯誤且被捕捉 對應 catch 區塊的最後一個表達式

當 try 就是整個函式的核心:return try { ... } catch { ... }

有時某個函式簡單到真的可以用單一的 try/catch 描述。這時你可以完全不需要中間變數,甚至不需要 val。

長這樣:

fun safeDivide(a: Int, b: Int): Int =
    try {
        a / b
    } catch (e: ArithmeticException) {
        0
    }

fun main() {
    println(safeDivide(10, 2)) // 5
    println(safeDivide(10, 0)) // 0
}

概念很簡單:「如果不能除,就回傳備用值」。當然,選擇「0」是函式契約(contract)的一部分。有些情境這樣很合理,有些情境則很危險(因為 0 可能看起來像正確結果)。重點是,這個語法能把決策寫得短、清楚、好讀。

3. 實作:在 CLI 解析指令

更乾淨地解析指令參數

現在把它連回我們的主控台應用程式(實作專案 v1)。假設有一個指令:

add <amount> <category>

使用者輸入一行文字,我們把它切成多段,然後需要穩健地取出數字。沒錯,你知道 toIntOrNull(),但今天我們練的是把 try/catch 當作表達式,因為有時不只 toInt() 會拋錯,索引存取也可能拋錯,還可能有其他問題。

先做一個小工具:「嘗試取出 token,並把它解析成 Int」:

fun parseAmountToken(tokens: List<String>, index: Int): Int? =
    try {
        tokens[index].toInt()
    } catch (e: Exception) {
        null
    }

fun main() {
    val tokens = listOf("add", "120", "food")

    println(parseAmountToken(tokens, 1)) // 120
    println(parseAmountToken(tokens, 9)) // null
    println(parseAmountToken(listOf("add", "一百"), 1)) // null
}

這裡我們回傳 Int?:成功就給數字,失敗就回傳 null。這是一個「溫和」的契約:呼叫端自己決定接下來要做什麼(提示使用者、要求重新輸入等等)。之前我們也討論過,null 很適合表示「拿不到值」,尤其當失敗原因不重要時。

但有個重要點:捕捉 Exception 通常不是好主意。這裡先這樣寫只是為了示範「同一段地方可能因為不同原因失敗」。後面會再討論如何寫得更精確、更安全。

「讀取 → 嘗試處理 → 組出回應」

在我們的專案中,我們一直努力把輸入/CLI 與「領域邏輯」與儲存分開。這裡我們關心一件很實用的事:使用者指令幾乎總是以字串進來,而字串幾乎總是很會「自由發揮」。

做一個小函式:它嘗試處理 remove <index> 指令,並回傳要給使用者看的文字。我們刻意不碰檔案/資料庫(那是後面的課程內容),先示範風格即可。

fun handleRemoveCommand(line: String): String {
    val tokens = line.trim().split(" ").filter { it.isNotBlank() }

    val index = try {
        tokens[1].toInt()
    } catch (e: Exception) {
        return "Usage: remove <index>"
    }

    return "Pretend we removed item #$index"
}

fun main() {
    println(handleRemoveCommand("remove 3"))   // Pretend we removed item #3
    println(handleRemoveCommand("remove x"))   // Usage: remove <index>
    println(handleRemoveCommand("remove"))     // Usage: remove <index>
}

技術上來說,這裡依然捕捉得太廣(Exception)。但從程式碼閱讀的架構角度,這個例子很有幫助:try 只是用來表達「嘗試取得值;不行就快速退出並給出清楚訊息」。

更好的(也更誠實的)做法,是把兩種情況分開:「沒有 token」與「不是數字」。但今天的重點,是看見 try 作為表達式,以及它如何作為早期退出邏輯的一部分。

4. 細節與風格:如何不把可讀性搞壞

多個 catch:順序很重要

開始寫「成熟」的 catch 之後,很快就會發現:錯誤可能有好幾種,而且你會想用不同方式處理。Kotlin 允許撰寫多個 catch 區塊,第一個符合的就會「勝出」。因此順序很重要:更具體的例外要放前面、更一般的要放後面。

概念層級的例子(不綁定任何商業邏輯):

fun parseAndValidatePositive(text: String): Int? =
    try {
        val n = text.toInt()
        require(n > 0) { "must be > 0" }
        n
    } catch (e: NumberFormatException) {
        null
    } catch (e: IllegalArgumentException) {
        null
    }

fun main() {
    println(parseAndValidatePositive("10"))  // 10
    println(parseAndValidatePositive("x"))   // null
    println(parseAndValidatePositive("-5"))  // null
}

這裡你看到兩種不同的問題來源:toInt() 可能拋出 NumberFormatException,而 require(...) 可能拋出 IllegalArgumentException。我們在程式碼中明確表達了這點。這比「只寫一個巨大的 catch(e: Exception),裡面靠魔法處理」更好讀。

讓 try 變小:「危險區段」要短

「帶例外處理的不可讀程式碼」最常見的原因之一,就是把半個函式都包進巨大的 try。這樣就會搞不清楚:到底哪裡可能拋錯?我們到底想處理什麼?會不會不小心捕捉到某些重要的錯誤,而其實不該捕捉?

好的風格是讓 try 盡可能精準:只包住真的可能拋例外、且你真的打算處理的那一小段程式碼。

我們來比較兩種風格。

不好的風格(try 太寬):

fun formatExpenseLine(amountText: String, category: String): String =
    try {
        val amount = amountText.toInt()
        val normalizedCategory = category.trim().lowercase()
        "Expense(amount=$amount, category=$normalizedCategory)"
    } catch (e: NumberFormatException) {
        "Bad input"
    }

這裡 try 裡面同時做了解析、字串正規化、與格式化。如果哪裡出事(字串很會出奇招),你只捕捉了 NumberFormatException,但讀程式碼的人會以為「這整段都很危險」。

更乾淨的風格(窄 try + 清楚組裝結果):

fun formatExpenseLine(amountText: String, category: String): String {
    val amount = try {
        amountText.toInt()
    } catch (e: NumberFormatException) {
        return "Bad amount: '$amountText'"
    }

    val normalizedCategory = category.trim().lowercase()
    return "Expense(amount=$amount, category=$normalizedCategory)"
}

是的,程式碼多了兩三行。但現在可以清楚看到風險點在哪裡、預期的是哪種錯誤,以及為什麼這裡適合做早期 return。

finally:它不是「另一種回傳值的方式」

新手對 finally 常有一種「神奇」想法:覺得可以在 finally 修正結果或「保證回傳正確值」。很遺憾(或值得慶幸),不行,也不需要。

finally 是一個無論如何都會執行的區塊:不管有沒有錯誤。它是用來做「清理」(cleanup)的。並且它不會改變 try-catch 作為表達式的結果。

用一個小例子示範:

fun divideWithLog(a: Int): Int {
    try {
        return 44 / a
    } catch (e: ArithmeticException) {
        return -1
    } finally {
        println("cleanup: log something") // cleanup: log something
    }
}

fun main() {
    println(divideWithLog(0)) // cleanup: log something
                             // -1
}

即使你在 try 或 catch 裡用了 return,finally 依然會執行。這在你需要保證關閉資源、把旗標復原、寫入 log 時特別有用。

也要記得一個形式規則:try 不能「單獨存在」;它至少要搭配 catch 或 finally。也就是說,只有 try { ... } 而沒有任何後續,是無法編譯的。

Kotlin 2.x 細節:catch/finally 中的 smart cast 變得更誠實

這是一個小但很實用的點,特別是在 Kotlin 2.x(而我們課程用 Kotlin 2.3)。以前編譯器在 try/catch 周圍,有時會對 smart cast 過度樂觀;而在 Kotlin 2.0+ 改善了處理,讓型別資訊能更正確地「穿越」 catch 與 finally。

對新手的實際意義很簡單:如果你有一個 nullable 型別的變數,並且在 try 中改動了它,那在 catch 裡編譯器會更謹慎,並更常要求你使用 ?.(這是好事,因為它能避免你產生錯誤的自信)。

這一講不會刻意把例子複雜化到 nullable 邏輯;但如果你看到編譯器「突然」在 catch 要你加 safe-call——那不是刁難,而是紀律。

5. 使用 try/catch 作為表達式時的常見錯誤

錯誤 №1:把 try 做得很大,「以防萬一」。
當 try 包進半個函式時,程式碼就回答不了最核心的問題:「我們到底在保護什麼?」結果你不只捕捉了預期的錯誤(例如數字格式),還可能吞掉一些本該暴露的偶發問題。解法很簡單:try 只包住最小的風險區段。

錯誤 №2:能抓具體型別卻去抓 Exception。
catch(e: Exception)聽起來像「我抓到全部,我很厲害」。但實務上常常意味著「我不小心把 bug 藏起來了」。如果你預期的是特定問題(例如 toInt() 的 NumberFormatException),就抓那個。當有多個 catch 時,也要從更具體排到更一般。

錯誤 №3:試圖用 finally 來決定結果。
finally 不是用來「替換」回傳值的。它負責的是「無論如何都要做的事」,而且它不會改變 try/catch 作為表達式的結果。若你需要選擇回傳值——就在 try/catch 裡選;finally 留給清理。

錯誤 №4:為了不崩潰就回傳「預設值」,不去想語意。
catch { 0 } 很漂亮,但有時是無聲的災難:程式繼續跑,但用的是錯的資料。預設值必須是契約的一部分,而且真的要有意義。若沒有意義——更好的選擇是回傳 null、給使用者清楚訊息,或終止流程。

錯誤 №5:在同一個 try 裡混在一起做錯誤處理與商業邏輯。
如果你在 try 裡一邊解析輸入、一邊修改應用程式狀態、一邊印出報表,那一旦拋出例外,你就得到「做了一半」的動作。對主控台應用程式特別糟:使用者看到「有東西發生了」,卻不知道發生到哪一步。更好的方式是先取得值(用 try 作為表達式),確認輸入有效後再執行動作。

1
任務
Kotlin SELF, 等級 40, 課堂 1
上鎖
收銀員輸入
收銀員輸入
1
任務
Kotlin SELF, 等級 40, 課堂 1
上鎖
分配戰利品
分配戰利品
1
任務
Kotlin SELF, 等級 40, 課堂 1
上鎖
入場通行證
入場通行證
1
任務
Kotlin SELF, 等級 40, 課堂 1
上鎖
鸚鵡指令
鸚鵡指令
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION