您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 使用技巧 >> iOS 7 技巧

Swift 錯誤處理完整解析:從 nil、guard 到自訂 ErrorType 與 do-catch

編輯:iOS 7 技巧

錯誤處理是每個專案都躲不掉的課題。Swift 的機制從 Objective-C 演變而來,但在 1.0 之後(特別是 Swift 2)出現了根本性的轉向:它主張「先想辦法避免錯誤」,而不是習慣性地捕捉每一個錯誤。

本文以一個魔法世界為例(男巫、女巫、蝙蝠與蟾蜍),示範從「用 nil 表示失敗」到「自訂錯誤型別 + do-catch」的完整升級路徑。

準備:幾個基礎型別

protocol MagicalTutorialObject {
    var avatar: String { get }
}

enum MagicWords: String {
    case Abracadbra = "abracadabra"
    case Alakazam   = "alakazam"
    case HocusPocus = "hocus pocus"
    case PrestoChango = "presto chango"
}

struct Spell: MagicalTutorialObject {
    var magicWords: MagicWords = .Abracadbra
    var avatar = "*"
}

為什麼要認真做錯誤處理?

良好的錯誤處理有三個好處:使用者看到合理的提示而非閃退;維護者能從 log 判斷出錯原因與嚴重程度;程式能以預期的方式終止,避免資料處於半完成狀態。

但反過來說,並不是所有錯誤都該被處理。如果能從設計上避免,就該避免;實在無法避免,才進入錯誤處理流程。

第一層:用 Optional 直接消滅某些錯誤

Swift 的可空型別天生適合表達「這裡可能沒有值」。若你判斷某種失敗不需要額外處理(例如 just 讓流程安靜地不執行),回傳 nil 是最簡潔的選擇。

可失敗的建構式

Swift 2 之前的做法是工廠方法:

static func createWithMagicWords(words: String) -> Spell? {
    if let incantation = MagicWords(rawValue: words) {
        var spell = Spell()
        spell.magicWords = incantation
        return spell
    } else {
        return nil
    }
}

Swift 提供了語法層級的支援,可以寫得更自然:

init?(words: String) {
    if let incantation = MagicWords(rawValue: words) {
        self.magicWords = incantation
    } else {
        return nil
    }
}

let first  = Spell(words: "abracadabra")   // 成功
let second = Spell(words: "ascendio")      // nil,這不是有效咒語

用 guard 提早退出

init?(words: String) {
    guard let incantation = MagicWords(rawValue: words) else {
        return nil
    }
    self.magicWords = incantation
}

guard 的價值在於:失敗的處理被放在函式最上方,而「一切正常」的黃金路徑縮排最少,讀起來最順。

第二層:當失敗有多種可能時,改用自訂錯誤

如果失敗的原因不止一種,nil 就無法傳達資訊了。這時才值得定義錯誤型別:

enum ChangoSpellError: ErrorType {
    case HatMissingOrNotMagical
    case NoFamiliar
    case FamiliarAlreadyAToad
    case SpellFailed(reason: String)
    case SpellNotKnownToWitch
}

兩個重點:必須採用 ErrorType 協定,編譯器才認得它是錯誤;帶關聯值的 SpellFailed(reason:) 可以攜帶具體原因,讓呼叫端做出更細緻的反應。

第三層:用 guard + throws 拆解「厄運金字塔」

原本的實作長這樣,六層以上的嵌套幾乎寫成對角線:

func turnFamiliarIntoToad() -> Toad {
    if let hat = hat {
        if hat.isMagical {
            if let familiar = familiar {
                if let toad = familiar as? Toad {
                    return toad
                } else {
                    if hasSpellOfType(.PrestoChango) {
                        if let name = familiar.name {
                            return Toad(name: name)
                        }
                    }
                }
            }
        }
    }
    return Toad(name: "New Toad")   // 出錯時憑空生一隻,顯然不對
}

改用 guard 與 throws 之後:

func turnFamiliarIntoToad() throws -> Toad {
    // 沒有戴魔法帽就不能施法
    guard let hat = hat where hat.isMagical else {
        throw ChangoSpellError.HatMissingOrNotMagical
    }
    // 沒有精靈
    guard let familiar = familiar else {
        throw ChangoSpellError.NoFamiliar
    }
    // 已經是蟾蜍了,何必再變
    if familiar is Toad {
        throw ChangoSpellError.FamiliarAlreadyAToad
    }
    // 魔法書裡沒這個咒
    guard hasSpellOfType(.PrestoChango) else {
        throw ChangoSpellError.SpellNotKnownToWitch
    }
    // 精靈沒有名字
    guard let name = familiar.name else {
        let reason = "Familiar doesn't have a name."
        throw ChangoSpellError.SpellFailed(reason: reason)
    }
    return Toad(name: name)
}

注意 as? 改成 is:當你只需要判斷型別而不使用轉換結果時,is 更精簡。另外別忘了在 MagicalBeing 協定上同步加上 throws。

第四層:用 do-catch 接住錯誤

func exampleOne() {
    let salem = Cat(name: "Salem Saberhagen")
    salem.speak()

    let witchOne = Witch(name: "Sabrina", familiar: salem)
    do {
        try witchOne.turnFamiliarIntoToad()
    } catch let error as ChangoSpellError {
        handleSpellError(error)
    } catch {
        print("Something went wrong, are you feeling OK?")
    }
}

func handleSpellError(error: ChangoSpellError) {
    let prefix = "Spell Failed."
    switch error {
    case .HatMissingOrNotMagical:
        print("\(prefix) Did you forget your hat, or does it need its batteries charged?")
    case .FamiliarAlreadyAToad:
        print("\(prefix) Why are you trying to change a Toad into a Toad?")
    default:
        print(prefix)
    }
}

這裡示範了 catch 的兩種用法:用模式比對攔下特定錯誤,以及用一個通用的 catch 兜底。

try 的三種形態

  • try:標準用法,搭配 do-catch 立即處理。
  • try?:主動忽略錯誤,失敗時結果為 nil。適合「不需要知道為何失敗」的場合。
  • try!:強制成功,等同強制解包。只有在你能確定錯誤絕不會發生時才用(例如讀取確定存在的內建檔案),濫用就是閃退的來源。
func exampleTwo() {
    let toad = Toad(name: "Mr. Toad")
    let hat = Hat()
    let witchTwo = Witch(name: "Elphaba", familiar: toad, hat: hat)

    let newToad = try? witchTwo.turnFamiliarIntoToad()
    if newToad != nil {
        print("Successfully changed familiar into toad.")
    } else {
        print("Spell failed.")
    }
}

throws 與 rethrows

函式可能拋錯就必須標記 throws,這讓錯誤傳遞在程式碼上「顯性可見」,也提醒呼叫端必須處理。

rethrows 則用於「錯誤其實是參數帶進來的」這種情況:

func doSomethingMagical(magicalOperation: () throws -> MagicalResult) rethrows -> MagicalResult {
    return try magicalOperation()
}

它只會拋出 magicalOperation 所拋出的錯誤,不會自己產生新的錯誤。

defer:無論成敗都要收尾

func speak() {
    defer { print("*cackles*") }
    defer { print("*screeches*") }
    print("Hello my pretties.")
}

輸出順序會是 Hello my pretties. → *screeches* → *cackles*。也就是說,多個 defer 的執行順序與書寫順序相反,且無論函式是正常返回還是拋出錯誤都會執行。這讓它非常適合釋放鎖、關閉檔案、還原全域狀態這類收尾工作。

幾條實務準則

  • 錯誤型別的命名要清楚,讓人看名字就知道發生了什麼。
  • 只有一種失敗狀態時,用 Optional 就好,不要為了「看起來嚴謹」而過度設計。
  • 有多種失敗狀態時,才引入自訂錯誤。
  • 不要讓錯誤沿著呼叫堆疊傳太遠,越晚處理,上下文資訊流失越多。

相較於其他語言,Swift 的 do-catch 沒有額外的執行期負擔,編譯後與普通語句無異,因此可以安心使用。至於未來,社群討論最多的方向是「無型別傳遞」,也就是讓 throws 能標明具體的錯誤型別,這在 Swift 2.x 的文件中已被列為後續任務。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved