CodeGym /課程 /Kotlin SELF /Smart-cast 以及如何使用它

Smart-cast 以及如何使用它

Kotlin SELF
等級 41, 課堂 2
開放

1. Smart-cast:編譯器的承諾

Smart-cast 不是魔法,也不是讀心術。它是編譯器相當務實的決策:如果它確定在某個程式點上,某個值具有更窄的型別(例如 String 而不是 String?),它就允許你把它當作這個窄型別來使用,而不需要明確寫 as,也不需要 !!。

關鍵在「確定」。只要有哪怕一點點機會讓值在檢查與使用之間發生變化,編譯器就會切換到「我不信你,因為之後你會怪我」模式。

先從 smart-cast 完美運作的情境開始,看起來就像「本來就該這樣」:

fun printNameLength(name: String?) {
    if (name != null) {
        println(name.length) // ok: 在區塊內 name 會被視為 String
    }
}

這裡 name 是函式參數(本質上是本地參照),在 if 區塊範圍內,編譯器可以保證:既然能進到這裡,就代表 name 不是 null。

2. 為什麼 smart-cast 有時不會生效

如果用一句話描述問題:smart-cast 只在編譯器確信物件穩定(不會在你沒注意時被改掉)的地方才會運作。

Kotlin 會對幾種情境特別「多疑」:可變變數(var)、物件屬性(obj.prop,尤其可能有自訂 getter 的那種),以及值在 lambda 內被使用、而且可能在其他地方被改變的情況。

有時這會讓人覺得很委屈:你用眼睛看得出「不會變」,但編譯器證明不了。邏輯很簡單:編譯器不會讀你的想法,它只讀程式碼並推演風險。

var 與「萬一它被改了呢?」

var 是最常見的痛點來源,因為它字面意思就是「可以被改」。只要編譯器看到某個變數理論上可以改變,它就常常會拒絕在較長的一段程式碼上對它做 smart-cast。

來看一個接近真實的例子:假設在 CLI 應用程式裡有一個「目前輸入行」(設計不一定好,但教學專案常見)。

var currentLine: String? = null

fun printCurrentLineLength() {
    if (currentLine != null) {
        // 編譯器可能會抱怨:currentLine 是 var,它可能變成 null
        println(currentLine.length)
    }
}

為什麼 Kotlin 會抱怨?因為 currentLine 被讀了兩次:一次在條件裡,一次在 println 裡。這兩次讀取之間,理論上可能發生任何程式碼(在大型專案中——不管是事件處理器、或是某個改動全域狀態的函式)。即使你現在「沒有多執行緒」也「沒有那種事」,編譯器仍然遵守語言契約,而不是看專案當下的心情。

解法是經典技巧:把值做快照到本地 val。

var currentLine: String? = null

fun printCurrentLineLength() {
    val snapshot = currentLine
    if (snapshot != null) {
        println(snapshot.length) // ok: snapshot 是 val,在此區塊內穩定
    }
}

這是一個非常重要的習慣:當你不確定時,對 nullable 值做一次「可控的」讀取,接下來只使用本地 val。這會讓程式對編譯器更容易分析,也讓未來「兩週後的你」更容易看懂。

obj.property:它是存取呼叫,不是「變數」

非常常見的陷阱:我們先檢查 user.name != null,然後想使用 user.name.length。看起來合理,但編譯器不是這樣看。

核心觀念:user.name 是屬性,而存取屬性不必然是「單純讀欄位」。它可能是 getter 呼叫(包含自訂 getter),每次都可能回傳不同的值。因此編譯器常常不會對 user.name 做「長距離」的 smart-cast。

最小例子:

class User(var name: String?)

fun printUserNameLength(user: User) {
    if (user.name != null) {
        // 常見錯誤:smart-cast 不會套用到 user.name
        println(user.name.length)
    }
}

即使 name 只是普通的 var,邏輯仍相同:我們讀了 user.name 兩次。兩次讀取之間它可能被改掉(例如有人把 user.name = null)。

正確技巧——再次使用快照:

class User(var name: String?)

fun printUserNameLength(user: User) {
    val name = user.name
    if (name != null) {
        println(name.length) // ok
    }
}

這不是「權宜之計」,而是正常風格:「讀一次 → 檢查 → 使用」。

為什麼遇到自訂 getter 時編譯器會特別謹慎

為了更直觀理解為何編譯器不必相信屬性,想像 getter 真的很狡猾:

class FlakyUser {
    val name: String?
        get() = if (System.currentTimeMillis() % 2L == 0L) "Neo" else null
}

fun printFlakyNameLen(u: FlakyUser) {
    if (u.name != null) {
        // 連人類都無法保證第二次呼叫 u.name 不會回傳 null
        println(u.name.length)
    }
}

這裡很明顯,「先檢查再使用」失效了,因為 u.name 實際上就像一個函式。編譯器會嚴格處理,才能對「簡單」與「狡猾」兩種情況都一致地安全。

Nullable + lambda:值會「脫離控制」

下一類情境:你檢查了 x != null,接著在lambda 內使用 x。有時可以、有時不行——新手會覺得 Kotlin 在刁難人。

原因在於:lambda 是一段獨立程式碼,它可能不在你以為的地方執行。編譯器必須確信變數在 lambda 執行前不會被改變。

例子:假設我們透過接收 action 的函式來格式化輸出。

fun render(block: () -> Unit) {
    block()
}

fun printLenInsideLambda(text: String?) {
    if (text != null) {
        render {
            println(text.length) // 有時這裡會遇到 smart-cast 的限制
        }
    }
}

在實務上,Kotlin 2.x(K2 編譯器)在某些「lambda 內 smart-cast」的情境變得更好,特別是搭配 inline 函式時,因為 inline 函式的效果就像 lambda「就在此處被呼叫」,編譯器更容易證明安全性。但基本原則不變:如果編譯器無法保證 lambda 一定會在此處執行、且變數不會改變,它就會保守處理。

幾乎總是有效、也最可靠的技巧:在 lambda 之前先做快照。

fun render(block: () -> Unit) {
    block()
}

fun printLenInsideLambda(text: String?) {
    val snapshot = text
    if (snapshot != null) {
        render {
            println(snapshot.length) // ok
        }
    }
}

Smart-cast 與 try/catch:資訊可能被「重置」的時候

還有一個有時會讓人意外的點:你明明「已經知道」變數不是 null,但在 try/catch 內或某些操作之後,編譯器可能又把它當回 nullable 型別。

這裡不需要深入細節,但理解原理很有用:如果你在 try 內對同一個變數重新賦值(包含賦為 null),編譯器就必須在之後重新評估它的型別。所以「快照到 val」依然是通用保險:當你想把值當作穩定值使用時,它很管用。

3. 為了 smart-cast 改寫程式碼的技巧

快照到本地 val

這是幾乎所有「smart-cast impossible」情境的基本招式:值只讀一次,接下來就把它當作本地 val 來用。

公式很簡單:

val snapshot = maybeNull
if (snapshot != null) {
    // 把 snapshot 當作 non-null 使用
}

這個習慣一次解決兩個問題:讓程式更清楚,也避免重複讀取/重複呼叫 getter。

Guard clause:提前返回,讓後面都變成 non-null

有時要「說服」編譯器,最好的方式是讓程式更直線:如果值是 null,我們立刻退出。這叫 guard clause(守衛式檢查)。它的好處是:更少巢狀、更少 if 的「階梯」,而且編譯器通常更容易對函式剩下的部分套用 smart-cast。

比較兩種寫法。

巢狀版本:

fun printUpper(text: String?) {
    if (text != null) {
        println(text.uppercase())
    }
}

提前返回版本:

fun printUpper(text: String?) {
    if (text == null) return
    println(text.uppercase()) // text 會被視為 String
}

心理上這種風格常更好讀:先「排除壞情況」,再寫主流程,不必一直看到 ?.。

requireNotNull / checkNotNull:明確把 T? -> T

當 null 代表「這是 bug/違反契約」時,不必硬要 smart-cast 生效,而是直接表明:「如果是 null,就用清楚的訊息直接失敗」。這正是 requireNotNull 與 checkNotNull 的用途。

語意上的差別是:require* 通常用於不合法的參數/輸入;check* 用於錯誤的狀態(不變量被破壞)。在這堂課更重要的是:兩者都會回傳 non-null 的值,因此是取得 T 的方便且可讀的做法。

例如:

fun tokenLength(token: String?): Int {
    val t = requireNotNull(token) { "Token must be provided" }
    return t.length
}

這裡我們甚至不需要 smart-cast:我們明確把 String? 轉成了 String。

但也別濫用。如果 token 是使用者輸入,在正常流程中本來就可能缺少,fail-fast 可能太嚴苛:你會直接讓程式崩潰,而不是請使用者再輸入一次。前置條件適合用在 null 代表「程式設計師寫錯」或「內部契約被破壞」的地方。

4. 實作:remove 指令與搜尋結果的重複讀取

想像一個教學用 CLI 記帳追蹤器。我們有一個 repository,能依 id 找到支出。依搜尋契約,結果可能不存在——因此型別是 Expense?。

非常簡單的模型:

data class Expense(val id: Int, val title: String, val amount: Int)

fun findExpenseById(expenses: List<Expense>, id: Int): Expense? {
    return expenses.find { it.id == id }
}

接著是用「天真寫法」實作的 remove 指令處理器:

fun handleRemove(expenses: MutableList<Expense>, id: Int) {
    if (findExpenseById(expenses, id) != null) {
        // 不好:我們重複呼叫搜尋並假設結果相同
        val title = findExpenseById(expenses, id).title
        println("Removed: $title")
    }
}

這裡的問題不只在 smart-cast——更是邏輯問題:我們搜尋了兩次。兩次呼叫之間列表可能被改掉,而且這也只是多餘的工作。

正確風格:找一次 → 保存 → 之後以「搜尋結果快照」繼續操作。

fun handleRemove(expenses: MutableList<Expense>, id: Int) {
    val found = findExpenseById(expenses, id)
    if (found == null) {
        println("Nothing to remove: id=$id")
        return
    }

    expenses.remove(found)
    println("Removed: ${found.title}") // Removed: ...
}

注意:這同時是 snapshot 與 guard clause。這種程式幾乎總是更容易讓編譯器理解、更快,且對人更清楚。

5. 速查表:smart-cast 哪裡能用、哪裡不能

有時不必死背規則,只要記住一個想法:值穩定時才可能 smart-cast。不過為了方便對照,這裡給一張精簡表格。

程式碼情境 編譯器可能拒絕的原因 應該怎麼改寫
檢查了 if (x != null) 然後在後面使用 x 通常 ok,只要 x 是本地 val 或參數 不用改,這是「理想」情況
var x: T? 檢查後繼續使用 var 可能被改動,特別是被讀取兩次時 建立 val snapshot = x,之後都用 snapshot
檢查 obj.prop != null,接著使用 obj.prop.something prop 被讀取兩次,getter 可能回傳不同值 用 val p = obj.prop,後面都用 p
檢查後在 lambda 內使用 lambda 可能稍後執行或在不同脈絡下執行 在 lambda 前先做快照,或使用 ?.let { ... }
複雜流程:檢查後又對同一變數重新賦值 先前的檢查可能已經不成立 Guard clause 或在變更前先做快照

另外:Kotlin 2.x 中有些情境比以前更「容易通過」(特別是搭配 inline 函式與某些條件),但你仍然會在「讀一次 → 檢查 → 使用」的寫法中獲益最大。

6. 常見錯誤

錯誤 1:「我檢查了 user.name != null,所以 user.name.length 一定可以用。」
這是最常見的陷阱之一,因為用眼睛看覺得很直觀。但屬性存取不等於本地變數存取:它可能是 getter、重複讀取、或狀態改變。修正通常很簡單:val name = user.name,接著都用 name。

錯誤 2:「我很確定,先快速加個 !!。」
!! 不是 smart-cast 問題的解法,它只是讓你請程式在更晚、也更大聲地崩潰。如果你確定依契約這裡不可能是 null,更好的做法是用 requireNotNull/checkNotNull 搭配清楚訊息。若 null 在正常流程中可能發生,那你就應該處理它(提前 return、?:、?.let { ... }),而不是把它變成程式裡的地雷。

錯誤 3:重複計算,而不是保存結果。
當你寫 if (find(...) != null) println(find(...).title) 時,你不只是在賭 smart-cast,也在賭搜尋函式是可預期的、狀態不會變。即使現在成立,程式可讀性也變差,且在重構時更容易出 bug。正確風格:算一次 → 放進 val found → 後面都用它。

錯誤 4:「做了快照,但後面還是用原本的變數。」
有時開發者寫了 val snapshot = x,檢查 snapshot != null,但在區塊內又回去使用 x。這會把你帶回原始問題:x 仍然是 nullable 且可能可變。既然做了快照,就要一致地使用它。

錯誤 5:把 ?.let { ... } 變成在 let 裡再包 let 的套娃。
let 很好用,但如果你開始堆出三層巢狀 let 的「金字塔」,程式又會變得沉重。這種情況下,更好的方式通常是建立幾個清楚的中間 val、使用 guard clauses,或把邏輯適度拆成兩三個小函式,讓每個函式都在已經是 non-null 的值上工作。

1
任務
Kotlin SELF, 等級 41, 課堂 2
上鎖
訊息狀態
訊息狀態
1
任務
Kotlin SELF, 等級 41, 課堂 2
上鎖
參加者名牌
參加者名牌
1
任務
Kotlin SELF, 等級 41, 課堂 2
上鎖
報表標籤
報表標籤
1
任務
Kotlin SELF, 等級 41, 課堂 2
上鎖
標頭鍵
標頭鍵
留言
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION