title: "Swift 中枚舉高級用法及實(shí)踐"
date: 2015-11-20
tags: [APPVENTURE]
categories: [Swift 進(jìn)階]
permalink: advanced-practical-enum-examples

原文鏈接=http://appventure.me/2015/10/17/advanced-practical-enum-examples/
作者=Benedikt Terhechte
原文日期=2015-10-17
譯者=pmst+小鍋
校對=shanks
定稿=shanks

譯者注：作為一個走心且有逼格的翻譯組，我們對本篇文章中的代碼都進(jìn)行了驗(yàn)證，并且寫了將代碼分為上下兩篇做成了 playground，代碼中有詳盡的注釋。可以到這個github地址上進(jìn)行下載，這個代碼由翻譯組的另一位小伙伴 ppt 提供。
本文是一篇詳細(xì)且具有實(shí)戰(zhàn)意義的教程，涵蓋幾乎所有枚舉(Enum)知識點(diǎn)，為你解答Swift中枚舉的應(yīng)用場合以及使用方法。

和switch語句類似，Swift中的枚舉乍看之下更像是C語言中枚舉的進(jìn)階版本，即允許你定義一種類型，用于表示普通事情中某種用例。不過深入挖掘之后，憑借Swift背后特別的設(shè)計(jì)理念，相比較C語言枚舉來說其在實(shí)際場景中的應(yīng)用更為廣泛。特別是作為強(qiáng)大的工具，Swift中的枚舉能夠清晰表達(dá)代碼的意圖。

本文中，我們將首先了解基礎(chǔ)語法和使用枚舉的可能性，接著通過實(shí)戰(zhàn)教你如何以及何時使用枚舉。最后我們還會大致了解下Swift標(biāo)準(zhǔn)庫中枚舉是如何被使用的。

正式開始學(xué)習(xí)之前，先給出枚舉的定義。之后我們將回過頭再來討論它。

枚舉聲明的類型是囊括可能狀態(tài)的有限集，且可以具有附加值。通過內(nèi)嵌(nesting),方法(method),關(guān)聯(lián)值(associated values)和模式匹配(pattern matching),枚舉可以分層次地定義任何有組織的數(shù)據(jù)。
深入理解(Diving In)

簡要概述如何定義和使用枚舉。

定義基本的枚舉類型(Defining Basic Enums)

試想我們正在開發(fā)一款游戲，玩家能夠朝四個方向移動。所以嘍，玩家的運(yùn)動軌跡受到了限制。顯然，我們能夠使用枚舉來表述這一情況:

    case Left
    case Right
    case Top
    case Bottom
}```
緊接著，你可以使用多種模式匹配結(jié)構(gòu)獲取到Movement的枚舉值，或者按照特定情況執(zhí)行操作:

let aMovement = Movement.Left

// switch 分情況處理
switch aMovement{
case .Left: print("left")
default:()
}

// 明確的case情況
if case .Left = aMovement{
print("left")
}

if aMovement == .Left { print("left") }```
案例中，我們無須明確指出enum的實(shí)際名稱(即case Move.Left:print("Left"))。因?yàn)轭愋蜋z查器能夠自動為此進(jìn)行類型推算。這對于那些UIKit以及AppKit中錯綜復(fù)雜的枚舉是灰常有用的。

枚舉值(Enum Values)

當(dāng)然，你可能想要為enum中每個case分配一個值。這相當(dāng)有用，比如枚舉自身實(shí)際與某事或某物掛鉤時，往往這些東西又需要使用不同類型來表述。在C語言中，你只能為枚舉case分配整型值，而Swift則提供了更多的靈活性。

// 映射到整型
enum Movement: Int {
    case Left = 0
    case Right = 1
    case Top = 2
    case Bottom = 3
}

// 同樣你可以與字符串一一對應(yīng)

enum House: String {
    case Baratheon = "Ours is the Fury"
    case Greyjoy = "We Do Not Sow"
    case Martell = "Unbowed, Unbent, Unbroken"
    case Stark = "Winter is Coming"
    case Tully = "Family, Duty, Honor"
    case Tyrell = "Growing Strong"
}

// 或者float double都可以(同時注意枚舉中的花式unicode)

enum Constants: Double {
    case π = 3.14159
    case e = 2.71828
    case φ = 1.61803398874
    case λ = 1.30357
}```
對于String和Int類型來說，你甚至可以忽略為枚舉中的case賦值，Swift編譯器也能正常工作。

// Mercury = 1, Venus = 2, ... Neptune = 8
enum Planet: Int {
case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

// North = "North", ... West = "West"
// 譯者注: 這個是swift2.0新增語法
enum CompassPoint: String {
case North, South, East, West
}```
Swift枚舉中支持以下四種關(guān)聯(lián)值類型:
整型(Integer)
浮點(diǎn)數(shù)(Float Point)
字符串(String)
布爾類型(Boolean)
因此你無法1為枚舉分配諸如CGPoint類型的值。

倘若你想要讀取枚舉的值，可以通過rawValue屬性來實(shí)現(xiàn):

let bestHouse = House.Stark
print(bestHouse.rawValue)
// prints "Winter is coming"
不過某種情形下，你可能想要通過一個已有的raw value來創(chuàng)建一個enum case。這種情況下，枚舉提供了一個指定構(gòu)造方法:

enum Movement: Int {
case Left = 0
case Right = 1
case Top = 2
case Bottom = 3
}
// 創(chuàng)建一個movement.Right 用例,其raw value值為1
let rightMovement = Movement(rawValue: 1)
倘若使用rawValue構(gòu)造器，切記它是一個可失敗構(gòu)造器(failable initializer)。換言之，構(gòu)造方法返回值為可選類型值,因?yàn)橛袝r候傳入的值可能與任意一個case都不匹配。比如Movement(rawValue:42)。

如果你想要以底層 C 二進(jìn)制編碼形式呈現(xiàn)某物或某事，使得更具可讀性，這是一個非常有用的功能。例如，可以看一下BSD kqeue library中的VNode Flags標(biāo)志位的編碼方式:

enum VNodeFlags : UInt32 {
case Delete = 0x00000001
case Write = 0x00000002
case Extended = 0x00000004
case Attrib = 0x00000008
case Link = 0x00000010
case Rename = 0x00000020
case Revoke = 0x00000040
case None = 0x00000080
}
如此便可以使你的Delete或Write用例聲明一目了然，稍后一旦需要，只需將raw value傳入 C 函數(shù)中即可。

嵌套枚舉(Nesting Enums)

如果你有特定子類型的需求，可以對enum進(jìn)行嵌套。這樣就允許你為實(shí)際的enum中包含其他明確信息的enum。以RPG游戲中的每個角色為例，每個角色能夠擁有武器，因此所有角色都可以獲取同一個武器集合。而游戲中的其他實(shí)例則無法獲取這些武器(比如食人魔,它們僅使用棍棒)。

enum Character {
enum Weapon {
case Bow
case Sword
case Lance
case Dagger
}
enum Helmet {
case Wooden
case Iron
case Diamond
}
case Thief
case Warrior
case Knight
}
現(xiàn)在，你可以通過層級結(jié)構(gòu)來描述角色允許訪問的項(xiàng)目條。

let character = Character.Thief
let weapon = Character.Weapon.Bow
let helmet = Character.Helmet.Iron
包含枚舉(Containing Enums)

同樣地，你也能夠在structs或classes中內(nèi)嵌枚舉。接著上面的例子:

struct Character {
enum CharacterType {
case Thief
case Warrior
case Knight
}
enum Weapon {
case Bow
case Sword
case Lance
case Dagger
}
let type: CharacterType
let weapon: Weapon
}

let warrior = Character(type: .Warrior, weapon: .Sword)
同樣地，這也將有助于我們將相關(guān)的信息集中在一個位置。

關(guān)聯(lián)值(Associated Value)

關(guān)聯(lián)值是將額外信息附加到enum case中的一種極好的方式。打個比方，你正在開發(fā)一款交易引擎，可能存在買和賣兩種不同的交易類型。除此之外每手交易還要制定明確的股票名稱和交易數(shù)量:

簡單例程(Simple Example)

enum Trade {
case Buy
case Sell
}
func trade(tradeType: Trade, stock: String, amount: Int) {}
然而股票的價值和數(shù)量顯然從屬于交易，讓他們作為獨(dú)立的參數(shù)顯得模棱兩可。你可能已經(jīng)想到要往struct中內(nèi)嵌一個枚舉了，不過關(guān)聯(lián)值提供了一種更清爽的解決方案：

enum Trade {
case Buy(stock: String, amount: Int)
case Sell(stock: String, amount: Int)
}
func trade(type: Trade) {}
模式匹配(Pattern Mathching)

如果你想要訪問這些值，模式匹配再次救場:

let trade = Trade.Buy(stock: "APPL", amount: 500)
if case let Trade.Buy(stock, amount) = trade {
print("buy (amount) of (stock)")
}
標(biāo)簽(Labels)

關(guān)聯(lián)值不需要附加標(biāo)簽的聲明:

enum Trade {
case Buy(String, Int)
case Sell(String, Int)
}
倘若你添加了，那么，每當(dāng)創(chuàng)建枚舉用例時，你都需要將這些標(biāo)簽標(biāo)示出來。

(元組參數(shù))Tuple as Arguments

更重要的是,Swift內(nèi)部相關(guān)信息其實(shí)是一個元組,所以你可以像下面這樣做:

let tp = (stock: "TSLA", amount: 100)
let trade = Trade.Sell(tp)

if case let Trade.Sell(stock, amount) = trade {
print("buy (amount) of (stock)")
}
// Prints: "buy 100 of TSLA"
語法允許您將元組當(dāng)作一個簡單的數(shù)據(jù)結(jié)構(gòu),稍后元組將自動轉(zhuǎn)換到高級類型，就比如enum case。想象一個應(yīng)用程序可以讓用戶來配置電腦:

typealias Config = (RAM: Int, CPU: String, GPU: String)

// Each of these takes a config and returns an updated config
func selectRAM(_ config: Config) -> Config {return (RAM: 32, CPU: config.CPU, GPU: config.GPU)}
func selectCPU(_ config: Config) -> Config {return (RAM: config.RAM, CPU: "3.2GHZ", GPU: config.GPU)}
func selectGPU(_ config: Config) -> Config {return (RAM: config.RAM, CPU: "3.2GHZ", GPU: "NVidia")}

enum Desktop {
case Cube(Config)
case Tower(Config)
case Rack(Config)
}

let aTower = Desktop.Tower(selectGPU(selectCPU(selectRAM((0, "", "") as Config))))
配置的每個步驟均通過遞交元組到enum中進(jìn)行內(nèi)容更新。倘若我們從函數(shù)式編程2中獲得啟發(fā)，這將變得更好。

infix operator <^> { associativity left }

func <^>(a: Config, f: (Config) -> Config) -> Config {
return f(a)
}
最后，我們可以將不同配置步驟串聯(lián)起來。這在配置步驟繁多的情況下相當(dāng)有用。

let config = (0, "", "") <^> selectRAM <^> selectCPU <^> selectGPU
let aCube = Desktop.Cube(config)
使用案例(Use Case Example)

關(guān)聯(lián)值可以以多種方式使用。常言道：一碼勝千言, 下面就上幾段簡單的示例代碼，這幾段代碼沒有特定的順序。

// 擁有不同值的用例
enum UserAction {
case OpenURL(url: NSURL)
case SwitchProcess(processId: UInt32)
case Restart(time: NSDate?, intoCommandLine: Bool)
}

// 假設(shè)你在實(shí)現(xiàn)一個功能強(qiáng)大的編輯器，這個編輯器允許多重選擇，
// 正如 Sublime Text : https://www.youtube.com/watch?v=i2SVJa2EGIw
enum Selection {
case None
case Single(Range<Int>)
case Multiple([Range<Int>])
}

// 或者映射不同的標(biāo)識碼
enum Barcode {
case UPCA(numberSystem: Int, manufacturer: Int, product: Int, check: Int)
case QRCode(productCode: String)
}

// 又或者假設(shè)你在封裝一個 C 語言庫，正如 Kqeue BSD/Darwin 通知系統(tǒng):
// https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2
enum KqueueEvent {
case UserEvent(identifier: UInt, fflags: [UInt32], data: Int)
case ReadFD(fd: UInt, data: Int)
case WriteFD(fd: UInt, data: Int)
case VnodeFD(fd: UInt, fflags: [UInt32], data: Int)
case ErrorEvent(code: UInt, message: String)
}

// 最后, 一個 RPG 游戲中的所有可穿戴裝備可以使用一個枚舉來進(jìn)行映射，
// 可以為一個裝備增加重量和持久兩個屬性
// 現(xiàn)在可以僅用一行代碼來增加一個"鉆石"屬性，如此一來我們便可以增加幾件新的鑲嵌鉆石的可穿戴裝備
enum Wearable {
enum Weight: Int {
case Light = 1
case Mid = 4
case Heavy = 10
}
enum Armor: Int {
case Light = 2
case Strong = 8
case Heavy = 20
}
case Helmet(weight: Weight, armor: Armor)
case Breastplate(weight: Weight, armor: Armor)
case Shield(weight: Weight, armor: Armor)
}
let woodenHelmet = Wearable.Helmet(weight: .Light, armor: .Light)
方法和屬性(Methods and properties)

你也可以在enum中像這樣定義方法:

enum Wearable {
enum Weight: Int {
case Light = 1
}
enum Armor: Int {
case Light = 2
}
case Helmet(weight: Weight, armor: Armor)
func attributes() -> (weight: Int, armor: Int) {
switch self {
case .Helmet(let w, let a): return (weight: w.rawValue * 2, armor: w.rawValue * 4)
}
}
}
let woodenHelmetProps = Wearable.Helmet(weight: .Light, armor: .Light).attributes()
print (woodenHelmetProps)
// prints "(2, 4)"
枚舉中的方法為每一個enum case而“生”。所以倘若想要在特定情況執(zhí)行特定代碼的話，你需要分支處理或采用switch語句來明確正確的代碼路徑。

enum Device {
case iPad, iPhone, AppleTV, AppleWatch
func introduced() -> String {
switch self {
case AppleTV: return "(self) was introduced 2006"
case iPhone: return "(self) was introduced 2007"
case iPad: return "(self) was introduced 2010"
case AppleWatch: return "(self) was introduced 2014"
}
}
}
print (Device.iPhone.introduced())
// prints: "iPhone was introduced 2007"
屬性(Properties)

盡管增加一個存儲屬性到枚舉中不被允許，但你依然能夠創(chuàng)建計(jì)算屬性。當(dāng)然，計(jì)算屬性的內(nèi)容都是建立在枚舉值下或者枚舉關(guān)聯(lián)值得到的。

enum Device {
case iPad, iPhone
var year: Int {
switch self {
case iPhone: return 2007
case iPad: return 2010
}
}
}
靜態(tài)方法(Static Methods)

你也能夠?yàn)槊杜e創(chuàng)建一些靜態(tài)方法(static methods)。換言之通過一個非枚舉類型來創(chuàng)建一個枚舉。在這個示例中,我們需要考慮用戶有時將蘋果設(shè)備叫錯的情況(比如AppleWatch叫成iWatch)，需要返回一個合適的名稱。

enum Device {
case AppleWatch
static func fromSlang(term: String) -> Device? {
if term == "iWatch" {
return .AppleWatch
}
return nil
}
}
print (Device.fromSlang("iWatch"))
可變方法(Mutating Methods)

方法可以聲明為mutating。這樣就允許改變隱藏參數(shù)self的case值了3。

enum TriStateSwitch {
case Off, Low, High
mutating func next() {
switch self {
case Off:
self = Low
case Low:
self = High
case High:
self = Off
}
}
}
var ovenLight = TriStateSwitch.Low
ovenLight.next()
// ovenLight 現(xiàn)在等于.On
ovenLight.next()
// ovenLight 現(xiàn)在等于.Off
小結(jié)(To Recap)

至此，我們已經(jīng)大致了解了Swift中枚舉語法的基本用例。在開始邁向進(jìn)階之路之前，讓我們重新審視文章開篇給出的定義，看看現(xiàn)在是否變得更清晰了。

枚舉聲明的類型是囊括可能狀態(tài)的有限集，且可以具有附加值。通過內(nèi)嵌(nesting),方法(method),關(guān)聯(lián)值(associated values)和模式匹配(pattern matching),枚舉可以分層次地定義任何有組織的數(shù)據(jù)。
現(xiàn)在我們已經(jīng)對這個定義更加清晰了。確實(shí)，如果我們添加關(guān)聯(lián)值和嵌套，enum就看起來就像一個封閉的、簡化的struct。相比較struct，前者優(yōu)勢體現(xiàn)在能夠?yàn)榉诸惻c層次結(jié)構(gòu)編碼。

// Struct Example
struct Point { let x: Int, let y: Int }
struct Rect { let x: Int, let y: Int, let width: Int, let height: Int }

// Enum Example
enum GeometricEntity {
case Point(x: Int, y: Int)
case Rect(x: Int, y: Int, width: Int, height: Int)
}
方法和靜態(tài)方法的添加允許我們?yōu)閑num附加功能，這意味著無須依靠額外函數(shù)就能實(shí)現(xiàn)4。

// C-Like example
enum Trade {
case Buy
case Sell
}
func order(trade: Trade)

// Swift Enum example
enum Trade {
case Buy
case Sell
func order()
}
枚舉進(jìn)階(Advanced Enum Usage）

協(xié)議(Protocols)

我已經(jīng)提及了structs和enums之間的相似性。除了附加方法的能力之外，Swift也允許你在枚舉中使用協(xié)議(Protocols)和協(xié)議擴(kuò)展(Protocol Extension)。

Swift協(xié)議定義一個接口或類型以供其他數(shù)據(jù)結(jié)構(gòu)來遵循。enum當(dāng)然也不例外。我們先從Swift標(biāo)準(zhǔn)庫中的一個例子開始.

CustomStringConvertible是一個以打印為目的的自定義格式化輸出的類型。

protocol CustomStringConvertible {
var description: String { get }
}
該協(xié)議只有一個要求，即一個只讀(getter)類型的字符串(String類型)。我們可以很容易為enum實(shí)現(xiàn)這個協(xié)議。

enum Trade: CustomStringConvertible {
case Buy, Sell
var description: String {
switch self {
case Buy: return "We're buying something"
case Sell: return "We're selling something"
}
}
}

let action = Trade.Buy
print("this action is (action)")
// prints: this action is We're buying something
一些協(xié)議的實(shí)現(xiàn)可能需要根據(jù)內(nèi)部狀態(tài)來相應(yīng)處理要求。例如定義一個管理銀行賬號的協(xié)議。

protocol AccountCompatible {
var remainingFunds: Int { get }
mutating func addFunds(amount: Int) throws
mutating func removeFunds(amount: Int) throws
}
你也許會簡單地拿struct實(shí)現(xiàn)這個協(xié)議，但是考慮應(yīng)用的上下文，enum是一個更明智的處理方法。不過你無法添加一個存儲屬性到enum中，就像var remainingFuns:Int。那么你會如何構(gòu)造呢？答案灰常簡單，你可以使用關(guān)聯(lián)值完美解決:

enum Account {
case Empty
case Funds(remaining: Int)

enum Error: ErrorType {
case Overdraft(amount: Int)
}

var remainingFunds: Int {
switch self {
case Empty: return 0
case Funds(let remaining): return remaining
}
}
}
為了保持代碼清爽，我們可以在enum的協(xié)議擴(kuò)展(protocl extension)中定義必須的協(xié)議函數(shù):

extension Account: AccountCompatible {

mutating func addFunds(amount: Int) throws {
var newAmount = amount
if case let .Funds(remaining) = self {
newAmount += remaining
}
if newAmount < 0 {
throw Error.Overdraft(amount: -newAmount)
} else if newAmount == 0 {
self = .Empty
} else {
self = .Funds(remaining: newAmount)
}
}

mutating func removeFunds(amount: Int) throws {
try self.addFunds(amount * -1)
}

}
var account = Account.Funds(remaining: 20)
print("add: ", try? account.addFunds(10))
print ("remove 1: ", try? account.removeFunds(15))
print ("remove 2: ", try? account.removeFunds(55))
// prints:
// : add: Optional(())
// : remove 1: Optional(())
// : remove 2: nil
正如你所看見的，我們通過將值存儲到enum cases中實(shí)現(xiàn)了協(xié)議所有要求項(xiàng)。如此做法還有一個妙不可言的地方:現(xiàn)在整個代碼基礎(chǔ)上你只需要一個模式匹配就能測試空賬號輸入的情況。你不需要關(guān)心剩余資金是否等于零。

同時，我們也在賬號(Accout)中內(nèi)嵌了一個遵循ErrorType協(xié)議的枚舉，這樣我們就可以使用Swift2.0語法來進(jìn)行錯誤處理了。這里給出更詳細(xì)的使用案例教程。

擴(kuò)展(Extensions)

正如剛才所見，枚舉也可以進(jìn)行擴(kuò)展。最明顯的用例就是將枚舉的case和method分離，這樣閱讀你的代碼能夠簡單快速地消化掉enum內(nèi)容，緊接著轉(zhuǎn)移到方法定義:

enum Entities {
case Soldier(x: Int, y: Int)
case Tank(x: Int, y: Int)
case Player(x: Int, y: Int)
}
現(xiàn)在，我們?yōu)閑num擴(kuò)展方法:

extension Entities {
mutating func move(dist: CGVector) {}
mutating func attack() {}
}
你同樣可以通過寫一個擴(kuò)展來遵循一個特定的協(xié)議:

extension Entities: CustomStringConvertible {
var description: String {
switch self {
case let .Soldier(x, y): return "(x), (y)"
case let .Tank(x, y): return "(x), (y)"
case let .Player(x, y): return "(x), (y)"
}
}
}
枚舉泛型(Generic Enums)

枚舉也支持泛型參數(shù)定義。你可以使用它們以適應(yīng)枚舉中的關(guān)聯(lián)值。就拿直接來自Swift標(biāo)準(zhǔn)庫中的簡單例子來說，即Optional類型。你主要可能通過以下幾種方式使用它:可選鏈(optional chaining(?))、if-let可選綁定、guard let、或switch，但是從語法角度來說你也可以這么使用Optional:

let aValue = Optional<Int>.Some(5)
let noValue = Optional<Int>.None
if noValue == Optional.None { print("No value") }
這是Optional最直接的用例，并未使用任何語法糖，但是不可否認(rèn)Swift中語法糖的加入使得你的工作更簡單。如果你觀察上面的實(shí)例代碼，你恐怕已經(jīng)猜到Optional內(nèi)部實(shí)現(xiàn)是這樣的5:

// Simplified implementation of Swift's Optional
enum MyOptional<T> {
case Some(T)
case None
}
這里有啥特別呢？注意枚舉的關(guān)聯(lián)值采用泛型參數(shù)T作為自身類型，這樣可選類型構(gòu)造任何你想要的返回值。

枚舉可以擁有多個泛型參數(shù)。就拿熟知的Either類為例，它并非是Swift標(biāo)準(zhǔn)庫中的一部分，而是實(shí)現(xiàn)于眾多開源庫以及
其他函數(shù)式編程語言，比如Haskell或F#。設(shè)計(jì)想法是這樣的:相比較僅僅返回一個值或沒有值(née Optional)，你更期望返回一個成功值或者一些反饋信息(比如錯誤值)。

// The well-known either type is, of course, an enum that allows you to return either
// value one (say, a successful value) or value two (say an error) from a function
enum Either<T1, T2> {
case Left(T1)
case Right(T2)
}
最后，Swift中所有在class和struct中奏效的類型約束，在enum中同樣適用。

// Totally nonsensical example. A bag that is either full (has an array with contents)
// or empty.
enum Bag<T: SequenceType where T.Generator.Element==Equatable> {
case Empty
case Full(contents: T)
}
遞歸 / 間接(Indirect)類型

間接類型是 Swift 2.0 新增的一個類型。 它們允許將枚舉中一個 case 的關(guān)聯(lián)值再次定義為枚舉。舉個例子，假設(shè)我們想定義一個文件系統(tǒng)，用來表示文件以及包含文件的目錄。如果將文件和目錄定義為枚舉的 case，則目錄 case 的關(guān)聯(lián)值應(yīng)該再包含一個文件的數(shù)組作為它的關(guān)聯(lián)值。因?yàn)檫@是一個遞歸的操作，編譯器需要對此進(jìn)行一個特殊的準(zhǔn)備。Swift 文檔中是這么寫的：

枚舉和 case 可以被標(biāo)記為間接的(indrect)，這意味它們的關(guān)聯(lián)值是被間接保存的，這允許我們定義遞歸的數(shù)據(jù)結(jié)構(gòu)。
所以，如果我們要定義 FileNode 的枚舉，它應(yīng)該會是這樣的：

enum FileNode {
case File(name: String)
indirect case Folder(name: String, files: [FileNode])
}
此處的 indrect 關(guān)鍵字告訴編譯器間接地處理這個枚舉的 case。也可以對整個枚舉類型使用這個關(guān)鍵字。作為例子，我們來定義一個二叉樹:

indirect enum Tree<Element: Comparable> {
case Empty
case Node(Tree<Element>,Element,Tree<Element>)
}
這是一個很強(qiáng)大的特性，可以讓我們用非常簡潔的方式來定義一個有著復(fù)雜關(guān)聯(lián)的數(shù)據(jù)結(jié)構(gòu)。

使用自定義類型作為枚舉的值

如果我們忽略關(guān)聯(lián)值，則枚舉的值就只能是整型，浮點(diǎn)型，字符串和布爾類型。如果想要支持別的類型，則可以通過實(shí)現(xiàn) StringLiteralConvertible 協(xié)議來完成，這可以讓我們通過對字符串的序列化和反序列化來使枚舉支持自定義類型。

作為一個例子，假設(shè)我們要定義一個枚舉來保存不同的 iOS 設(shè)備的屏幕尺寸：

enum Devices: CGSize {
case iPhone3GS = CGSize(width: 320, height: 480)
case iPhone5 = CGSize(width: 320, height: 568)
case iPhone6 = CGSize(width: 375, height: 667)
case iPhone6Plus = CGSize(width: 414, height: 736)
}
然而，這段代碼不能通過編譯。因?yàn)?CGPoint 并不是一個常量，不能用來定義枚舉的值。我們需要為想要支持的自定義類型增加一個擴(kuò)展，讓其實(shí)現(xiàn) StringLiteralConvertible 協(xié)議。這個協(xié)議要求我們實(shí)現(xiàn)三個構(gòu)造方法，這三個方法都需要使用一個String類型的參數(shù)，并且我們需要將這個字符串轉(zhuǎn)換成我們需要的類型(此處是CGSize)。

extension CGSize: StringLiteralConvertible {
public init(stringLiteral value: String) {
let size = CGSizeFromString(value)
self.init(width: size.width, height: size.height)
}

public init(extendedGraphemeClusterLiteral value: String) {
let size = CGSizeFromString(value)
self.init(width: size.width, height: size.height)
}

public init(unicodeScalarLiteral value: String) {
let size = CGSizeFromString(value)
self.init(width: size.width, height: size.height)
}

}
現(xiàn)在就可以來實(shí)現(xiàn)我們需要的枚舉了，不過這里有一個缺點(diǎn)：初始化的值必須寫成字符串形式，因?yàn)檫@就是我們定義的枚舉需要接受的類型(記住，我們實(shí)現(xiàn)了 StringLiteralConvertible，因此String可以轉(zhuǎn)化成CGSize類型)

enum Devices: CGSize {
case iPhone3GS = "{320, 480}"
case iPhone5 = "{320, 568}"
case iPhone6 = "{375, 667}"
case iPhone6Plus = "{414, 736}"
}
終于，我們可以使用 CGPoint 類型的枚舉了。需要注意的是，當(dāng)要獲取真實(shí)的 CGPoint 的值的時候，我們需要訪問枚舉的是 rawValue 屬性。

let a = Devices.iPhone5
let b = a.rawValue
print("the phone size string is (a), width is (b.width), height is (b.height)")
// prints : the phone size string is iPhone5, width is 320.0, height is 568.0
使用字符串序列化的形式，會讓使用自定義類型的枚舉比較困難，然而在某些特定的情況下，這也會給我們增加不少便利(比較使用NSColor / UIColor的時候)。不僅如此，我們完全可以對自己定義的類型使用這個方法。

對枚舉的關(guān)聯(lián)值進(jìn)行比較

在通常情況下，枚舉是很容易進(jìn)行相等性判斷的。一個簡單的 enum T { case a, b } 實(shí)現(xiàn)默認(rèn)支持相等性判斷 T.a == T.b, T.b != T.a

然而，一旦我們?yōu)槊杜e增加了關(guān)聯(lián)值，Swift 就沒有辦法正確地為兩個枚舉進(jìn)行相等性判斷，需要我們自己實(shí)現(xiàn) == 運(yùn)行符。這并不是很困難：

enum Trade {
case Buy(stock: String, amount: Int)
case Sell(stock: String, amount: Int)
}
func ==(lhs: Trade, rhs: Trade) -> Bool {
switch (lhs, rhs) {
case let (.Buy(stock1, amount1), .Buy(stock2, amount2))
where stock1 == stock2 && amount1 == amount2:
return true
case let (.Sell(stock1, amount1), .Sell(stock2, amount2))
where stock1 == stock2 && amount1 == amount2:
return true
default: return false
}
}
正如我們所見，我們通過 switch 語句對兩個枚舉的 case 進(jìn)行判斷，并且只有當(dāng)它們的 case 是匹配的時候(比如 Buy 和 Buy)才對它們的真實(shí)關(guān)聯(lián)值進(jìn)行判斷。

自定義構(gòu)造方法

在 靜態(tài)方法 一節(jié)當(dāng)中我們已經(jīng)提到它們可以作為從不同數(shù)據(jù)構(gòu)造枚舉的方便形式。在之前的例子里也展示過，對出版社經(jīng)常誤用的蘋果設(shè)備名返回正確的名字：

enum Device {
case AppleWatch
static func fromSlang(term: String) -> Device? {
if term == "iWatch" {
return .AppleWatch
}
return nil
}
}
我們也可以使用自定義構(gòu)造方法來替換靜態(tài)方法。枚舉與結(jié)構(gòu)體和類的構(gòu)造方法最大的不同在于，枚舉的構(gòu)造方法需要將隱式的 self 屬性設(shè)置為正確的 case。

enum Device {
case AppleWatch
init?(term: String) {
if term == "iWatch" {
self = .AppleWatch
}
return nil
}
}
在這個例子中，我們使用了可失敗(failable)的構(gòu)造方法。但是，普通的構(gòu)造方法也可以工作得很好：

enum NumberCategory {
case Small
case Medium
case Big
case Huge
init(number n: Int) {
if n < 10000 { self = .Small }
else if n < 1000000 { self = .Medium }
else if n < 100000000 { self = .Big }
else { self = .Huge }
}
}
let aNumber = NumberCategory(number: 100)
print(aNumber)
// prints: "Small"
對枚舉的 case 進(jìn)行迭代

一個特別經(jīng)常被問到的問題就是如何對枚舉中的 case 進(jìn)行迭代。可惜的是，枚舉并沒有遵守SequenceType協(xié)議，因此沒有一個官方的做法來對其進(jìn)行迭代。取決于枚舉的類型，對其進(jìn)行迭代可能也簡單，也有可能很困難。在StackOverflow上有一個很好的討論貼。貼子里面討論到的不同情況太多了，如果只在這里摘取一些會有片面性，而如果將全部情況都列出來，則會太多。

對 Objective-C 的支持

基于整型的枚舉，如 enum Bit: Int { case Zero = 0; case One = 1 } 可以通過 @objc 標(biāo)識來將其橋接到 Objective-C 當(dāng)中。然而，一旦使用整型之外的類型(如 String)或者開始使用關(guān)聯(lián)值，我們就無法在 Objective-C 當(dāng)中使用這些枚舉了。

有一個名為_ObjectiveCBridgeable的隱藏協(xié)議，可以讓規(guī)范我們以定義合適的方法，如此一來，Swift 便可以正確地將枚舉轉(zhuǎn)成 Objective-C 類型，但我猜這個協(xié)議被隱藏起來一定是有原因的。然而，從理論上來講，這個協(xié)議還是允許我們將枚舉(包括其實(shí)枚舉值)正確地橋接到 Objective-C 當(dāng)中。

但是，我們并不一定非要使用上面提到的這個方法。為枚舉添加兩個方法，使用 @objc 定義一個替代類型，如此一來我們便可以自由地將枚舉進(jìn)行轉(zhuǎn)換了，并且這種方式不需要遵守私有協(xié)議：

enum Trade {
case Buy(stock: String, amount: Int)
case Sell(stock: String, amount: Int)
}

// 這個類型也可以定義在 Objective-C 的代碼中
@objc class OTrade: NSObject {
var type: Int
var stock: String
var amount: Int
init(type: Int, stock: String, amount: Int) {
self.type = type
self.stock = stock
self.amount = amount
}
}

extension Trade {

func toObjc() -> OTrade {
switch self {
case let .Buy(stock, amount):
    return OTrade(type: 0, stock: stock, amount: amount)
case let .Sell(stock, amount):
    return OTrade(type: 1, stock: stock, amount: amount)
}
}

static func fromObjc(source: OTrade) -> Trade? {
switch (source.type) {
case 0: return Trade.Buy(stock: source.stock, amount: source.amount)
case 1: return Trade.Sell(stock: source.stock, amount: source.amount)
default: return nil
}
}

}
這個方法有一個的缺點(diǎn)，我們需要將枚舉映射為 Objective-C 中的 NSObject 基礎(chǔ)類型(我們也可以直接使用 NSDictionary)，但是，當(dāng)我們碰到一些確實(shí)需要在 Objective-C 當(dāng)中獲取有關(guān)聯(lián)值的枚舉時，這是一個可以使用的方法。

枚舉底層

Erica Sadun 寫過一篇很流弊的關(guān)于枚舉底層的博客，涉及到枚舉底層的方方面面。在生產(chǎn)代碼中絕不應(yīng)該使用到這些東西，但是學(xué)習(xí)一下還是相當(dāng)有趣的。在這里，我準(zhǔn)備只提到那篇博客中一條，如果想了解更多，請移步到原文：

枚舉通常都是一個字節(jié)長度。[...]如果你真的很傻很天真，你當(dāng)然可以定義一個有成百上千個 case 的枚舉，在這種情況下，取決于最少所需要的比特?cái)?shù)，枚舉可能占據(jù)兩個字節(jié)或者更多。
Swift 標(biāo)準(zhǔn)庫中的枚舉

在我們準(zhǔn)備繼續(xù)探索枚舉在項(xiàng)目中的不同用例之前，先看一下在 Swift 標(biāo)準(zhǔn)庫當(dāng)中是如何使用枚舉可能會更誘人，所以現(xiàn)在讓我們先來看看。

Bit 這個枚舉有兩個值，One 和 Zero。它被作為 CollectionOfOne<T> 中的 Index 類型。

FloatingPointClassification 這個枚舉定義了一系列 IEEE 754 可能的類別，比如 NegativeInfinity, PositiveZero 或 SignalingNaN。

Mirror.AncestorRepresentation 和 Mirror.DisplayStyle 這兩個枚舉被用在 Swift 反射 API 的上下文當(dāng)中。

Optional 這個就不用多說了

Process 這個枚舉包含了當(dāng)前進(jìn)程的命令行參數(shù)(Process.argc, Process.arguments)。這是一個相當(dāng)有趣的枚舉類型，因?yàn)樵?Swift 1.0 當(dāng)中，它是被作為一個結(jié)構(gòu)體來實(shí)現(xiàn)的。

實(shí)踐用例

我們已經(jīng)在前面幾個小節(jié)當(dāng)中看過了許多有用的枚舉類型。包括 Optional，Either, FileNode 還有二叉樹。然而，還存在很多場合，使用枚舉要勝過使用結(jié)構(gòu)體和類。一般來講，如果問題可以被分解為有限的不同類別，則使用枚舉應(yīng)該就是正確的選擇。即使只有兩種 case，這也是一個使用枚舉的完美場景，正如 Optional 和 Either 類型所展示的。

以下列舉了一些枚舉類型在實(shí)戰(zhàn)中的使用示例，可以用來點(diǎn)燃你的創(chuàng)造力。

錯誤處理

說到枚舉的實(shí)踐使用，當(dāng)然少不了在 Swift 2.0 當(dāng)中新推出的錯誤處理。標(biāo)記為可拋出的函數(shù)可以拋出任何遵守了 ErrorType 空協(xié)議的類型。正如 Swift 官方文檔中所寫的：

Swift 的枚舉特別適用于構(gòu)建一組相關(guān)的錯誤狀態(tài)，可以通過關(guān)聯(lián)值來為其增加額外的附加信息。
作為一個示例，我們來看下流行的JSON解析框架 Argo。當(dāng) JSON 解析失敗的時候，它有可能是以下兩種主要原因：

JSON 數(shù)據(jù)缺少某些最終模型所需要的鍵(比如你的模型有一個 username 的屬性，但是 JSON 中缺少了)
存在類型不匹配，比如說 username 需要的是 String 類型，而 JSON 中包含的是 NSNull6。
除此之外，Argo 還為不包含在上述兩個類別中的錯誤提供了自定義錯誤。它們的 ErrorType 枚舉是類似這樣的：

enum DecodeError: ErrorType {
case TypeMismatch(expected: String, actual: String)
case MissingKey(String)
case Custom(String)
}
所有的 case 都有一個關(guān)聯(lián)值用來包含關(guān)于錯誤的附加信息。

一個更加通用的用于完整 HTTP / REST API 錯誤處理的ErrorType應(yīng)該是類似這樣的：

enum APIError : ErrorType {
// Can't connect to the server (maybe offline?)
case ConnectionError(error: NSError)
// The server responded with a non 200 status code
case ServerError(statusCode: Int, error: NSError)
// We got no data (0 bytes) back from the server
case NoDataError
// The server response can't be converted from JSON to a Dictionary
case JSONSerializationError(error: ErrorType)
// The Argo decoding Failed
case JSONMappingError(converstionError: DecodeError)
}
這個 ErrorType 實(shí)現(xiàn)了完整的 REST 程序棧解析有可能出現(xiàn)的錯誤，包含了所有在解析結(jié)構(gòu)體與類時會出現(xiàn)的錯誤。

如果你看得夠仔細(xì)，會發(fā)現(xiàn)在JSONMappingError中，我們將Argo中的DecodeError封裝到了我們的APIError類型當(dāng)中，因?yàn)槲覀儠?Argo 來作實(shí)際的 JSON 解析。

更多關(guān)于ErrorType以及此種枚舉類型的示例可以參看官方文檔。

觀察者模式

在 Swift 當(dāng)中，有許多方法來構(gòu)建觀察模式。如果使用 @objc 兼容標(biāo)記，則我們可以使用 NSNotificationCenter 或者 KVO。即使不用這個標(biāo)記，didSet語法也可以很容易地實(shí)現(xiàn)簡單的觀察模式。在這里可以使用枚舉，它可以使被觀察者的變化更加清晰明了。設(shè)想我們要對一個集合進(jìn)行觀察。如果我們稍微思考一下就會發(fā)現(xiàn)這只有幾種可能的情況：一個或多個項(xiàng)被插入，一個或多個項(xiàng)被刪除，一個或多個項(xiàng)被更新。這聽起來就是枚舉可以完成的工作：

enum Change {
case Insertion(items: [Item])
case Deletion(items: [Item])
case Update(items: [Item])
}
之后，觀察對象就可以使用一個很簡潔的方式來獲取已經(jīng)發(fā)生的事情的詳細(xì)信息。這也可以通過為其增加 oldValue 和 newValue 的簡單方法來擴(kuò)展它的功能。

狀態(tài)碼

如果我們正在使用一個外部系統(tǒng)，而這個系統(tǒng)使用了狀態(tài)碼(或者錯誤碼)來傳遞錯誤信息，類似 HTTP 狀態(tài)碼，這種情況下枚舉就是一種很明顯并且很好的方式來對信息進(jìn)行封裝7 。

enum HttpError: String {
case Code400 = "Bad Request"
case Code401 = "Unauthorized"
case Code402 = "Payment Required"
case Code403 = "Forbidden"
case Code404 = "Not Found"
}
結(jié)果類型映射(Map Result Types)

枚舉也經(jīng)常被用于將 JSON 解析后的結(jié)果映射成 Swift 的原生類型。這里有一個簡短的例子：

enum JSON {
case JSONString(Swift.String)
case JSONNumber(Double)
case JSONObject([String : JSONValue])
case JSONArray([JSONValue])
case JSONBool(Bool)
case JSONNull
}
類似地，如果我們解析了其它的東西，也可以使用這種方式將解析結(jié)果轉(zhuǎn)化我們 Swift 的類型。

UIKit 標(biāo)識

枚舉可以用來將字符串類型的重用標(biāo)識或者 storyboard 標(biāo)識映射為類型系統(tǒng)可以進(jìn)行檢查的類型。假設(shè)我們有一個擁有很多原型 Cell 的 UITableView：

enum CellType: String {
case ButtonValueCell = "ButtonValueCell"
case UnitEditCell = "UnitEditCell"
case LabelCell = "LabelCell"
case ResultLabelCell = "ResultLabelCell"
}
單位

單位以及單位轉(zhuǎn)換是另一個使用枚舉的絕佳場合。可以將單位及其對應(yīng)的轉(zhuǎn)換率映射起來，然后添加方法來對單位進(jìn)行自動的轉(zhuǎn)換。以下是一個相當(dāng)簡單的示例：

enum Liquid: Float {
case ml = 1.0
case l = 1000.0
func convert(amount amount: Float, to: Liquid) -> Float {
if self.rawValue < to.rawValue {
return (self.rawValue / to.rawValue) * amount
} else {
return (self.rawValue * to.rawValue) * amount
}
}
}
// Convert liters to milliliters
print (Liquid.l.convert(amount: 5, to: Liquid.ml))
另一個示例是貨幣的轉(zhuǎn)換。以及數(shù)學(xué)符號(比如角度與弧度)也可以從中受益。

游戲

游戲也是枚舉中的另一個相當(dāng)好的用例，屏幕上的大多數(shù)實(shí)體都屬于一個特定種族的類型(敵人，障礙，紋理，...)。相對于本地的 iOS 或者 Mac 應(yīng)用，游戲更像是一個白板。即開發(fā)游戲我們可以使用全新的對象以及全新的關(guān)聯(lián)創(chuàng)造一個全新的世界，而 iOS 或者 OSX 需要使用預(yù)定義的 UIButtons，UITableViews，UITableViewCells 或者 NSStackView.

不僅如此，由于枚舉可以遵守協(xié)議，我們可以利用協(xié)議擴(kuò)展和基于協(xié)議的編程為不同為游戲定義的枚舉增加功能。這里是一個用來展示這種層級的的簡短示例：

enum FlyingBeast { case Dragon, Hippogriff, Gargoyle }
enum Horde { case Ork, Troll }
enum Player { case Mage, Warrior, Barbarian }
enum NPC { case Vendor, Blacksmith }
enum Element { case Tree, Fence, Stone }

protocol Hurtable {}
protocol Killable {}
protocol Flying {}
protocol Attacking {}
protocol Obstacle {}

extension FlyingBeast: Hurtable, Killable, Flying, Attacking {}
extension Horde: Hurtable, Killable, Attacking {}
extension Player: Hurtable, Obstacle {}
extension NPC: Hurtable {}
extension Element: Obstacle {}
字符串類型化

在一個稍微大一點(diǎn)的 Xcode 項(xiàng)目中，我們很快就會有一大堆通過字符串來訪問的資源。在前面的小節(jié)中，我們已經(jīng)提過重用標(biāo)識和 storyboard 的標(biāo)識，但是除了這兩樣，還存在很多資源：圖像，Segues，Nibs，字體以及其它資源。通常情況下，這些資源都可以分成不同的集合。如果是這樣的話，一個類型化的字符串會是一個讓編譯器幫我們進(jìn)行類型檢查的好方法。

enum DetailViewImages: String {
case Background = "bg1.png"
case Sidebar = "sbg.png"
case ActionButton1 = "btn1_1.png"
case ActionButton2 = "btn2_1.png"
}
對于 iOS 開發(fā)者，R.swift這個第三方庫可以為以上提到的情況自動生成結(jié)構(gòu)體。但是有些時候你可能需要有更多的控制(或者你可能是一個Mac開發(fā)者8)。

API 端點(diǎn)

Rest API 是枚舉的絕佳用例。它們都是分組的，它們都是有限的 API 集合，并且它們也可能會有附加的查詢或者命名的參數(shù)，而這可以使用關(guān)聯(lián)值來實(shí)現(xiàn)。

這里有個 Instagram API 的簡化版：

enum Instagram {
enum Media {
case Popular
case Shortcode(id: String)
case Search(lat: Float, min_timestamp: Int, lng: Float, max_timestamp: Int, distance: Int)
}
enum Users {
case User(id: String)
case Feed
case Recent(id: String)
}
}
Ash Furrow的Moya框架就是基本這個思想，使用枚舉對 rest 端點(diǎn)進(jìn)行映射。

鏈表

Airspeed Velocity有一篇極好的文章說明了如何使用枚舉來實(shí)現(xiàn)一個鏈表。那篇文章中的大多數(shù)代碼都超出了枚舉的知識，并涉及到了大量其它有趣的主題9，但是，鏈表最基本的定義是類似這樣的(我對其進(jìn)行了一些簡化)：

enum List {
case End
indirect case Node(Int, next: List)
}
每一個節(jié)點(diǎn)(Node) case 都指向了下一個 case， 通過使用枚舉而非其它類型，我們可以避免使用一個可選的 next 類型以用來表示鏈表的結(jié)束。

Airspeed Velocity 還寫過一篇超贊的博客，關(guān)于如何使用 Swift 的間接枚舉類型來實(shí)現(xiàn)紅黑樹，所以如果你已經(jīng)閱讀過關(guān)于鏈表的博客，你可能想繼續(xù)閱讀這篇關(guān)于紅黑樹的博客。

設(shè)置字典(Setting Dictionaries)

這是 Erica Sadun 提出的非常非常機(jī)智的解決方案。簡單來講，就是任何我們需要用一個屬性的字典來對一個項(xiàng)進(jìn)行設(shè)置的時候，都應(yīng)該使用一系列有關(guān)聯(lián)值的枚舉來替代。使用這方法，類型檢查系統(tǒng)可以確保配置的值都是正確的類型。

關(guān)于更多的細(xì)節(jié)，以及合適的例子，可以閱讀下她的文章。

局限

與之前類似，我將會用一系列枚舉的局限性來結(jié)束本篇文章。

提取關(guān)聯(lián)值

David Owens寫過一篇文章，他覺得當(dāng)前的關(guān)聯(lián)值提取方式是很笨重的。我墻裂推薦你去看一下他的原文，在這里我對它的要旨進(jìn)行下說明：為了從一個枚舉中獲取關(guān)聯(lián)值，我們必須使用模式匹配。然而，關(guān)聯(lián)值就是關(guān)聯(lián)在特定枚舉 case 的高效元組。而元組是可以使用更簡單的方式來獲取它內(nèi)部值，即 .keyword 或者 .0。

// Enums
enum Ex { case Mode(ab: Int, cd: Int) }
if case Ex.Mode(let ab, let cd) = Ex.Mode(ab: 4, cd: 5) {
print(ab)
}
// vs tuples:
let tp = (ab: 4, cd: 5)
print(tp.ab)
如果你也同樣覺得我們應(yīng)該使用相同的方法來對枚舉進(jìn)行解構(gòu)(deconstruct)，這里有個 rdar: rdar://22704262 (譯者注：一開始我不明白 rdar 是啥意思，后來我 google 了下，如果你也有興趣，也可以自己去搜索一下)

相等性

擁有關(guān)聯(lián)值的枚舉沒有遵守 equatable 協(xié)議。這是一個遺憾，因?yàn)樗鼮楹芏嗍虑樵黾恿瞬槐匾膹?fù)雜和麻煩。深層的原因可能是因?yàn)殛P(guān)聯(lián)值的底層使用是使用了元組，而元組并沒有遵守 equatable 協(xié)議。然而，對于限定的 case 子集，如果這些關(guān)聯(lián)值的類型都遵守了 equatable 類型，我認(rèn)為編譯器應(yīng)該默認(rèn)為其生成 equatable 擴(kuò)展。

// Int 和 String 是可判等的, 所以 Mode 應(yīng)該也是可判等的
enum Ex { case Mode(ab: Int, cd: String) }

// Swift 應(yīng)該能夠自動生成這個函數(shù)
func == (lhs: Ex.Mode, rhs: Ex.Mode) -> Bool {
switch (lhs, rhs) {
case (.Mode(let a, let b), .Mode(let c, let d)):
return a == c && b == d
default:
return false
}
}
元組(Tuples)

最大的問題就是對元組的支持。我喜歡使用元組，它們可以使很多事情變得更簡單，但是他們目前還處于無文檔狀態(tài)并且在很多場合都無法使用。在枚舉當(dāng)中，我們無法使用元組作為枚舉的值：

enum Devices: (intro: Int, name: String) {
case iPhone = (intro: 2007, name: "iPhone")
case AppleTV = (intro: 2006, name: "Apple TV")
case AppleWatch = (intro: 2014, name: "Apple Watch")
}
這似乎看起來并不是一個最好的示例，但是我們一旦開始使用枚舉，就會經(jīng)常陷入到需要用到類似上面這個示例的情形中。

迭代枚舉的所有case

這個我們已經(jīng)在前面討論過了。目前還沒有一個很好的方法來獲得枚舉中的所有 case 的集合以使我們可以對其進(jìn)行迭代。

默認(rèn)關(guān)聯(lián)值

另一個會碰到的事是枚舉的關(guān)聯(lián)值總是類型，但是我們卻無法為這些類型指定默認(rèn)值。假設(shè)有這樣一種情況:

enum Characters {
case Mage(health: Int = 70, magic: Int = 100, strength: Int = 30)
case Warrior(health: Int = 100, magic: Int = 0, strength: Int = 100)
case Neophyte(health: Int = 50, magic: Int = 20, strength: Int = 80)
}
我們依然可以使用不同的值創(chuàng)建新的 case，但是角色的默認(rèn)設(shè)置依然會被映射。

變化

10/26/2015

增加局限性示例(相等性 & 獲取關(guān)聯(lián)值)
增加 Erica Sadun 的關(guān)聯(lián)枚舉示例
10/22/2015

合并來自 #6 @mabidakun的PR
增加枚舉底層的鏈接
將帳號示例拆分為兩個更容易理解的片段。
10/21/2015

合并來自 #4 @blixt和#2 @kandelvijayavolare和#3 @sriniram以及#5 @SixFiveSoftware的PR
為帳號示例添加調(diào)用代碼
增加 ErrorType 示例
解釋

1、可以使用一些小技術(shù)來達(dá)到這個目的，具體的請參照下面的文章內(nèi)容

2、為了演示的緣故，這個示例的實(shí)現(xiàn)經(jīng)過的簡化。在真實(shí)的開發(fā)中，應(yīng)該使用可選類型以及反向順序的參數(shù)。可以參考一下現(xiàn)在十分流行的函數(shù)式編程庫，如 Swiftz 和 Dollar

3、這個示例直接采用了Swift 官方文檔的示例

4、經(jīng)常使得他們定義的位置很難被發(fā)現(xiàn)

5、這是一個簡化版的，當(dāng)然，Swift 為我們加了很多的語法糖

6、如果你在應(yīng)用中使用過 JSON，應(yīng)該也曾經(jīng)碰到過這個問題

7、順便一提，不能直接使用數(shù)字做為枚舉 case 的名稱，因此直接使用 400 是不行的

8、雖然如此，不過支持 Mac 版的 R.swift 好像就快推出了

9、這句話可以解釋為: 打開鏈接，并開始閱讀文章