自從Swift 1開始就提供了錯誤處理技術支持;這種技術是受來自于Objective-C的啟發而開發出的。Swift 2在這方面的改進使得處理您的應用程序中的意外狀態和條件更加簡單直接。

就像其他普通的編程語言一樣，Swift中的錯誤處理技術也存在不同類型，具體情況則要取決于遇到的錯誤類型和您的應用程序的總體結構。

本教程將帶您通過具體的例子來介紹如何最有效地處理常見的錯誤情況。你還會看到如何升級早期版本Swift編寫的項目中的錯誤處理模塊。文章***，將集中介紹未來版本的Swift可能提供的錯誤處理技術!

【注意】本教程假定您已熟悉使用Swift 2語法，特別是枚舉(enumberations)和可選值(optionals)。如果你需要復習一下這些概念，建議您閱讀Greg Heo的文章“What’s New in Swift 2”。

接下來，就讓我們開始踏上Swift 2錯誤處理技術的學習征程，你一定會體會到不一樣的樂趣的!

簡介

本教程提供了兩個初學者案例供大家學習使用，它們的下載地址分別是：https://cdn4.raywenderlich.com/wp-content/uploads/2016/04/Avoiding-Errors-with-nil-Starter.playground-1.zip和 https://cdn4.raywenderlich.com/wp-content/uploads/2016/04/Avoiding-Errors-with-Custom-Handling-Starter.playground-1.zip。

為了跟蹤本文中的實例代碼，請下載這兩個示例工程。

首先，請使用Xcode打開***個初學者案例Errors with nil。通讀工程中的代碼，你會看到有幾個類、結構和枚舉定義。

請注意代碼的以下部分：

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 = "*" 
 
} 

這是一個魔法的基本構建塊。默認情況下，它的初始化咒語值為“Abracadbra”。

現在，您已經熟悉了我們要介紹的例子中的一些基本術語，那么接下來您要開始施行一些“魔法”了。

為什么要關注錯誤處理

錯誤處理是一種以優雅方式失敗的藝術。

——出自《Swift Apprentice》一書的第12章(“錯誤處理”)

好的錯誤處理方法有助于增強最終用戶和軟件維護人員的體驗，使其更容易地查明問題、 問題原因及其可能產生的嚴重后果。代碼中錯誤處理得越具體，問題就越容易診斷。錯誤處理也可以讓系統用適當的方式拋出錯誤，從而不至于挫敗或擾亂用戶。

但并不是需要處理一切錯誤。如果程序員不處理，語言功能本身也可能會使您完全避免某些類別的錯誤。作為一般規則，如果你能避免錯誤的可能性，那么請遵循這樣的設計思路。如果你不能避免潛在的錯誤條件，那么顯式處理錯誤是你***的選擇。

使用nil避免Swift錯誤

由于Swift提供了優雅的可選項(Optionals)處理能力;所以，在你期望值出現但未提供值的地方您完全可以避免錯誤條件。作為一個聰明的程序員，你可以操縱此功能：通過一個錯誤條件判斷故意返回nil。這種方法最適合用于當你到達一個錯誤狀態但你不必采取任何措施的情形;也就是說，你選擇不采取措施而不是采取緊急措施。

兩個典型的使用nil避免Swift錯誤的例子是可失敗構造器和guard語句。

可失敗構造器(failable initializer)

可失敗構造器能夠防止一個對象的創建——除非已提供了足夠的信息。在Swift 2以前(以及在其他語言中)，這一功能通常是通過工廠方法模式實現的。

Swift使用這種模式的一個示例在createWithMagicWords方法中就會看到：

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

上述初始化器試圖使用提供的咒語創建一個魔法(spell);但如果言語不是咒語(magic words)，改以返回nil。

你可以在本教程***部的代碼中觀察魔法的創建來查看這種方法的使用：

你會注意到： first使用咒語“abracadabra”成功創建一個魔法，而咒語“ascendio”并不會產生這種效果，并返回second的值為nil。

工廠方法是一種老式的編程風格。其實，在Swift中有更好的方式來實現同樣的事情。為此，你只需使用一個可失敗構造器而不是工廠方法來更新spell擴展即可。

于是，你可以刪除createWithMagicWords(_:)方法并把它替換為以下內容：

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

在這里，你簡化了代碼——并沒有顯式創建和返回spell對象。

給first和second賦值的語句行現在會拋出編譯時錯誤：

let first = Spell.createWithMagicWords("abracadabra") 
 
let second = Spell.createWithMagicWords("ascendio") 

你需要更改這些語句——使用新的初始化器。為此，你只需要使用以下內容替換上面的代碼行即可：

let first = Spell(words: "abracadabra") 
 
let second = Spell(words: "ascendio") 

此后，所有錯誤應修復完畢，再編譯示例工程應沒有什么錯誤。這樣修改以后，您的代碼整潔多了——但是其實你可以做得比這更好!

Guard語句

guard是一種斷言某事是否為真實的快速方法。然后，如果檢查失敗，您可以執行事先設計的代碼塊。

Guard是Swift 2引入的，通常用于通過調用堆棧以冒泡法處理錯誤，最終錯誤將得到處理。Guard語句允許提前退出一個函數或方法;這使得程序員更清楚對于剩下的要運行的處理邏輯需要存在哪些條件。

為了進一步精簡魔法的可失敗構造器，我們再來使用guard方法修改一下上面代碼：

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

這樣修改后，就沒有必要再在一個單獨的行上使用一個單獨的else子句;而且，失敗的情況也更加明顯，因為它現在位于初始化程序的頂部。

請注意，***和第二個魔法常量的值沒有改變，但代碼卻變得更為精簡了。

使用定制處理器避免錯誤

上面通過精簡魔法的可失敗構造器并通過巧妙地使用nil已經可以避免一些錯誤。接下來，讓我們來處理一些更復雜的錯誤。

為了學習接下來的錯誤處理技術，請打開工程Avoiding-Errors-with-Custom-Handling-Starter.playground-1。

請注意下面代碼中的特征：

struct Spell: MagicalTutorialObject { 
 
var magicWords: MagicWords = .Abracadbra 
 
var avatar = "*" 
 
init?(words: String) { 
 
guard let incantation = MagicWords(rawValue: words) else { 
 
return nil 
 
} 
 
self.magicWords = incantation 
 
} 
 
init?(magicWords: MagicWords) { 
 
self.magicWords = magicWords 
 
} 
 
} 

這里定義的是Spell的構造器，我們對之作了簡要修改以匹配您在本教程的***部分所完成的工作。此外，請注意這里還使用了MagicalTutorialObject協議和另外一個為了方便使用而引入的可失敗構造器。

protocol Familiar: MagicalTutorialObject { 
 
var noise: String { get } 
 
var name: String? { get set } 
 
init() 
 
init(name: String?) 
 
} 

這里的Familiar協議將適用于各類寵物(如蝙蝠和蟾蜍，為女巫所豢養和驅使)，在本文第二個示例工程中一直這樣使用。

接下來看女巫(Witch)的定義：

struct Witch: MagicalBeing { 
 
var avatar = "*" 
 
var name: String? 
 
var familiar: Familiar? 
 
var spells: [Spell] = [] 
 
var hat: Hat? 
 
init(name: String?, familiar: Familiar?) { 
 
self.name = name 
 
self.familiar = familiar 
 
if let s = Spell(magicWords: .PrestoChango) { 
 
self.spells = [s] 
 
} 
 
} 
 
init(name: String?, familiar: Familiar?, hat: Hat?) { 
 
self.init(name: name, familiar: familiar) 
 
self.hat = hat 
 
} 
 
func turnFamiliarIntoToad() -> Toad { 
 
if let hat = hat { 
 
if hat.isMagical { // When have you ever seen a Witch perform a spell without her magical hat on ? :] 
 
if let familiar = familiar { // Check if witch has a familiar 
 
if let toad = familiar as? Toad { // Check if familiar is already a toad - no magic required 
 
return toad 
 
} else { 
 
if hasSpellOfType(.PrestoChango) { 
 
if let name = familiar.name { 
 
return Toad(name: name) 
 
} 
 
} 
 
} 
 
} 
 
} 
 
} 
 
return Toad(name: "New Toad") // This is an entirely new Toad. 
 
} 
 
func hasSpellOfType(type: MagicWords) -> Bool { // Check if witch currently has appropriate spell in their spellbook 
 
return spells.contains { $0.magicWords == type } 
 
} 
 
} 

現在，讓我們簡單作一下總結：

初始化女巫：使用name和familiar參數，或者再添加一個hat參數。

一個女巫知道有限數量的魔法;這些存儲魔法在spells中，spells是一個魔法對象的數組。

每一個巫婆似乎都有一個嗜好，即在turnFamiliarIntoToad()方法中通過使用PrestoChango咒語把她的寵物變成一只癩蛤蟆。

請注意上面方法turnFamiliarIntoToad()中的縮進字符的數量。此外，你還應當注意：該方法中如果有任何差錯，將返回一只全新的蟾蜍。這似乎令人費解(而且有些錯誤!)。在下一節中，通過自定義錯誤處理技術您會完全明白這段代碼的。

使用重構技術

在上面的turnFamiliarIntoToad()方法中使用了多級嵌套語句來控制程序流程，而閱讀這樣的嵌套代碼相當費勁。

如你前面看到的，Guard語句和多個可選綁定的使用有助于清除上面金字塔式復雜代碼。然而，利用do-catch機制，通過從錯誤狀態處理中解耦控制流能夠徹底消除這一問題。

do-catch機制通常出現在以下關鍵字前后：

throws

do

catch

try

defer

ErrorType

若要查看這些關鍵字的實際使用，你要拋出多個自定義錯誤。首先，你要定義你希望處理的語句，你可以通過一個枚舉來列出一切可能出錯的內容。

然后，將下面的代碼添加到你的示例工程(一個與游樂場內容有關的程序)的女巫(Witch)定義的上方：

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

請注意與ChangoSpellError有關的兩點：

它符合ErrorType協議，這是在Swift語言中定義錯誤時的必要條件。

在SpellFailed情形下，可以針對魔法失敗通過一個關聯值指定一個自定義原因。

接下來，把throws關鍵字添加到方法簽名中，以指示調用此方法時可能會發生錯誤：

func turnFamiliarIntoToad() throws -> Toad { 

然后，在MagicalBeing協議上也作一下更新：

protocol MagicalBeing: MagicalTutorialObject { 
 
var name: String? { get set } 
 
var spells: [Spell] { get set } 
 
func turnFamiliarIntoToad() throws -> Toad 
 
} 

既然你已經列出所有錯誤狀態，接下來你可以重構turnFamiliarIntoToad()方法。

處理帽子相關錯誤

首先，修改下面的語句以確保女巫戴著她最重要的帽子，把語句：

if let hat = hat { 

修改為：

guard let hat = hat else { 
 
throw ChangoSpellError.HatMissingOrNotMagical 
 
} 

【注意】不要忘記刪除方法底部的}符號;否則工程將會出現編譯錯誤!

下一行包含一個布爾值檢查，也是與帽子相關的：

if hat.isMagical { 

您可以選擇添加一個單獨的guard語句來執行這項檢查;但是，把一組檢查統一放在一行代碼中更為清楚。因此，你可以更改***個的guard語句，像下面這樣：

guard let hat = hat where hat.isMagical else { 
 
throw ChangoSpellError.HatMissingOrNotMagical 
 
} 

現在，經這樣一修改，也一并消除了if hat.isMagical {檢查部分。

在下一節中，你會繼續解除那種成金字塔形可怕的條件語句。

處理Familiar有關錯誤

【譯者注】在本文中，我把“familiar”翻譯為“寵物”，即前面為女巫所豢養和驅駛的各種小動物。

接下來，讓我們修改檢測是否女巫是否含有familiar的語句，即把語句：

if let familiar = familiar { 

修改為從另一個guard語句中拋出一個錯誤：

guard let familiar = familiar else { 
 
throw ChangoSpellError.NoFamiliar 
 
} 

目前，我們先忽略發生的任何錯誤，因為你接下來的代碼更改會使它們消失。

處理Toad相關錯誤

在下一行中，如果巫婆想要對毫無戒心的兩棲類施加turnFamiliarIntoToad()咒語的話，你需要返回現有的蟾蜍，但使用一種明確的錯誤會更好地告知她犯的錯誤。為此，把以下內容：

if let toad = familiar as? Toad { 
 
return toad 
 
} 

修改成如下語句：

if familiar is Toad { 
 
throw ChangoSpellError.FamiliarAlreadyAToad 
 
} 

注意到，這里把as?修改為is，從而可以更簡潔地檢查與協議的一致性，而不一定需要使用結果。關鍵字is還可以用于更普遍形式的類型比較。如果你有興趣更多地學習is和as，建議你閱讀蘋果官網中《Swift編程語言》的類型轉換部分(https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TypeCasting.html)。

使用上面技術，我們就可以把else子句里面的內容放到else子句外面，從而刪除掉else。

處理魔法相關錯誤

***，對hasSpellOfType(type:)方法的調用可以確保女巫在她的魔法書中存在適當的魔法。為此，我們把下面的代碼：

if hasSpellOfType(.PrestoChango) { 
 
if let toad = f as? Toad { 
 
return toad 
 
} 
 
} 

更改為如下代碼：

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) 

現在，您可以刪除***一行代碼，這是沒有問題的，即刪除下面一行：

return Toad(name: "New Toad") 

現在，你擁有了以下簡練的方法。其中，我提供了幾點補充，以進一步解釋代碼的作用：

func turnFamiliarIntoToad() throws -> Toad { 
 
// When have you ever seen a Witch perform a spell without her magical hat on ? :] 
 
guard let hat = hat where hat.isMagical else { 
 
throw ChangoSpellError.HatMissingOrNotMagical 
 
} 
 
// Check if witch has a familiar 
 
guard let familiar = familiar else { 
 
throw ChangoSpellError.NoFamiliar 
 
} 
 
// Check if familiar is already a toad - if so, why are you casting the spell? 
 
if familiar is Toad { 
 
throw ChangoSpellError.FamiliarAlreadyAToad 
 
} 
 
guard hasSpellOfType(.PrestoChango) else { 
 
throw ChangoSpellError.SpellNotKnownToWitch 
 
} 
 
// Check if the familiar has a name 
 
guard let name = familiar.name else { 
 
let reason = "Familiar doesn’t have a name." 
 
throw ChangoSpellError.SpellFailed(reason: reason) 
 
} 
 
// It all checks out! Return a toad with the same name as the witch's familiar 
 
return Toad(name: name) 
 
} 

以前，從turnFamiliarIntoToad()方法中返回一個可選項僅表明了“施加這個魔法時出現了某種錯誤”。但，像這樣使用自定義的錯誤，你可以更清楚地表示錯誤狀態，從而對其做出相應的反應。

其他適合定制錯誤的地方

現在，既然建立了方法可以拋出自定義Swift錯誤，你就需要進一步處理這些錯誤。這樣做的標準機制稱為do-catch語句，這類似于在其他如Java語言中使用的try-catch機制。

現在，請將下面的代碼添加到你的工程文件的***：

func exampleOne() { 
 
print("") // Add an empty line in the debug area 
 
// 1 
 
let salem = Cat(name: "Salem Saberhagen") 
 
salem.speak() 
 
// 2 
 
let witchOne = Witch(name: "Sabrina", familiar: salem) 
 
do { 
 
// 3 
 
try witchOne.turnFamiliarIntoToad() 
 
} 
 
// 4 
 
catch let error as ChangoSpellError { 
 
handleSpellError(error) 
 
} 
 
// 5 
 
catch { 
 
print("Something went wrong, are you feeling OK?") 
 
} 
 
} 

以下是該函數所實現的任務：

1. 創建這個女巫的寵物，它是一只叫Salem的貓。

2. 創建女巫，名字叫Sabrina。

3. 嘗試把這只貓變成一只癩蛤蟆。

4. 捕獲一個ChangoSpellError錯誤，并適當地處理錯誤。

5. ***，捕捉所有其他錯誤并打印出一條友好的信息。

添加上述內容后，你會看到一個編譯器錯誤。現在，我們著手解決這個問題。

handleSpellError()方法尚未定義，因此，把下列代碼添加到前面exampleOne()函數定義的上面：

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) 
 
} 
 
} 

***，把以下內容添加到文件的底部并運行工程代碼：

exampleOne() 

你會看到調試控制臺輸出顯示有關內容：

捕獲錯誤

下面給出在上面的代碼片段中使用的每一個Swift 2錯誤處理技術的簡短概括。

catch子句

你可以在Swift中使用模式匹配來處理特定錯誤或把幾種錯誤類型放在一起處理。

上面的代碼中向你演示了捕獲錯誤的幾種用法：一個是捕獲特定的ChangoSpell錯誤，一個是一起處理剩余錯誤的情況。

try子句

你可以使用try子句并結合do-catch子句來清楚表明哪些行或代碼段可能拋出錯誤。

你可以通過幾種不同的方式來使用try命令，上面使用過的是下面之一：

try——清楚和直接的do-catch語句中的標準用法，這是上面代碼中使用的方式。

try?——本質上是通過忽視錯誤的方式來處理錯誤;如果拋出一個錯誤，語句的結果將為nil。

try!——該子句強調一種期望結果：理論上，一個語句能夠拋出一個錯誤;但實際上，這種錯誤條件永遠不會發生。try!子句可用于像加載文件這樣的編程代碼中，這種情況下你有把握確保某些所需的媒體存在。應小心使用這個子句。

現在，讓我們具體地了解try?子句的用法。你可以把下列代碼剪切并粘貼到你上面文件的底部：

func exampleTwo() { 
 
print("") // Add an empty line in the debug area 
 
let toad = Toad(name: "Mr. Toad") 
 
toad.speak() 
 
let hat = Hat() 
 
let witchTwo = Witch(name: "Elphaba", familiar: toad, hat: hat) 
 
let newToad = try? witchTwo.turnFamiliarIntoToad() 
 
if newToad != nil { // Same logic as: if let _ = newToad 
 
print("Successfully changed familiar into toad.") 
 
} 
 
else { 
 
print("Spell failed.") 
 
} 
 
} 

請注意上面代碼中exampleOne的不同之處。在這里，你不必關心特定錯誤的輸出問題，但仍然要捕捉發生錯誤的事實。這里并沒有創建蟾蜍寵物;所以，newToad的值為nil。

傳播錯誤

throws

如果一個函數或方法拋出錯誤，在Swift中需要使用throws關鍵字。拋出的錯誤會沿調用堆棧向上自動傳播，但人們普遍認為讓錯誤從其發生源地傳播太遠是一個不好的做法。在整個代碼庫中增加錯誤可能性的重大傳播可能會躲過恰當的錯誤處理機會;為此，借助于throws關鍵字可以確保傳播能夠在代碼中記錄在案，并且對編程人員也很容易了解這一點。

rethrows

目前為止，你所看到的所有示例都使用了throws，但怎么使用rethrows呢?

rethrows告訴編譯器僅當函數參數拋出錯誤時這個函數才拋出錯誤。下面是一個最直接的例子(無需將它添加到前面的文件中)：

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

在這里，doSomethingMagical(_:)方法僅當提供給函數的magicalOperation參數拋出錯誤時才拋出錯誤。如果成功了，它返回一個MagicalResult值。

操縱錯誤處理行為

defer

雖然自動傳播在大多數情況下工作良好，但也有些情況下，當錯誤在調用堆棧中向上傳播時你可能要進一步控制你的應用程序的行為。

Defer語句提供了一種機制，每當退出當前范圍允許程序執行“清理”工作，如方法或函數返回時。它用于管理需要清理的資源——無論動作是否成功。因此，在錯誤處理上下文中尤為有用。

【譯者注】建議你結合C++/Java等語言中的finally子句加以理解。

為了了解defer的使用，請將下面的方法添加到Witch結構的***：

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

然后，將下面的代碼添加到前面文件的底部：

func exampleThree() { 
 
print("") // Add an empty line in the debug area 
 
let witchThree = Witch(name: "Hermione", familiar: nil, hat: nil) 
 
witchThree.speak() 
 
} 
 
exampleThree() 

在調試控制臺中，您應該看到女巫在說完所有話后發出咯咯的笑聲。

有趣的是，defer語句是以其編程時順序的相反的順序執行的。

現在，我們把另一個defer添加到speak()語句，以便女巫可以咯咯地發笑。然后，女巫在說完所有話后發出咯咯的笑聲：

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

你注意到調試控制臺中的輸出順序了嗎?這正是defer語句的能力!

與錯誤有關的更有趣的事情

本文中提供的上述Swift語句使其與很多其他受歡迎的語言保持了一致，從而把Swift從Objective-C基于NSError基礎的錯誤處理方法中分離出來。而大多數情況下的Objective-C錯誤都是直譯式的，編譯器中的靜態分析器能夠很好地幫助你確定你需要哪些錯誤及何時需要捕獲錯誤。

雖然do-catch相關支持語句在其他語言中也有很大的開銷;但是，在Swift語言中，它們基本上像任何其他語句一樣處理。這將確保它們的有效性和高效率。

但是，不要因為你可以創建自定義錯誤并拋出錯誤并隨意地使用。這方面，建議你針對你開發的工程先制定一些準則：何時需要拋出和捕獲錯誤。對此，我提出下列建議：

確保錯誤類型在您的整個代碼庫中被清楚地命名。

當單個錯誤狀態時盡量使用可選值(Optionals)。

當存在超過一個錯誤狀態時使用自定義錯誤處理技術。

不允許錯誤從其源地傳播得太遠。

未來的Swift錯誤處理

在各種Swift論壇中經常討論幾種高級錯誤處理想法。其中，談論最多的概念之一是非類型化傳播的問題。

“......我們相信我們可以擴展我們當前的模型以支持非類型化傳播的普遍錯誤。這項工作怎樣才能做得很好——特別是在不完全犧牲代碼大小和性能的情況下，將引發大量深度研究。可以預測，在Swift 2.0中實現這一方法是沒有問題的。”(來自《Swift 2.x Error Handling》)

不論你是否在享用Swift 3中的主流錯誤處理思想，是否對于今天存在的東西滿意，令人高興的是，隨著語言技術的繼續發展，整潔的錯誤處理技術正在各地積極討論中并不斷改進。

小結

您可以下載本教程已完成的游樂場示例工程進一步研究討論，地址是https://cdn2.raywenderlich.com/wp-content/uploads/2016/04/Magical-Error-Handling-in-Swift.zip。

如果你渴望看到有關Swift 3的新進展，我推薦你參閱《Swift Language Proposals》(https://github.com/apple/swift/tree/master/docs/proposals)。

希望到目前為止，你已經真正沉迷于Swift中的錯誤處理技術。