本文是一篇詳細且具有實戰意義的教程，涵蓋幾乎所有枚舉(Enum)知識點，為你解答Swift中枚舉的應用場合以及使用方法。

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

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

枚舉的定義
枚舉聲明的類型是囊括可能狀態的有限集，且可以具有附加值。
通過內嵌(nesting),方法(method),關聯值(associated values)和模式匹配(pattern matching),枚舉可以分層次地定義任何有組織的數據。

深入理解(Diving In)
簡要概述如何定義和使用枚舉。

• 定義基本的枚舉類型(Defining Basic Enums)
  試想我們正在開發一款游戲，玩家能夠朝四個方向移動。所以嘍，玩家的運動軌跡受到了限制。顯然，我們能夠使用枚舉來表述這一情況:

enum Movement{case Leftcase Rightcase Topcase Bottom
}

• 緊接著，你可以使用多種模式匹配結構獲取到Movement的枚舉值，或者按照特定情況執行操作:

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的實際名稱(即case Move.Left:print("Left"))。因為類型檢查器能夠自動為此進行類型推算。這對于那些UIKit以及AppKit中錯綜復雜的枚舉是灰常有用的。

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

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

// 同樣你可以與字符串一一對應
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.14159case e = 2.71828case φ = 1.61803398874case λ = 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枚舉中支持以下四種關聯值類型:

整型(Integer)
浮點數(Float Point)
字符串(String)
布爾類型(Boolean)

因此你無法為枚舉分配諸如CGPoint類型的值。

倘若你想要讀取枚舉的值，可以通過rawValue屬性來實現:

let bestHouse = House.Stark
print(bestHouse.rawValue)
// prints "Winter is coming"

不過某種情形下，你可能想要通過一個已有的raw value來創建一個enum case。這種情況下，枚舉提供了一個指定構造方法:

enum Movement: Int {case Left = 0case Right = 1case Top = 2case Bottom = 3
}

// 創建一個movement.Right 用例,其raw value值為1
let rightMovement = Movement(rawValue: 1)

倘若使用rawValue構造器，切記它是一個可失敗構造器(failable initializer)。換言之，構造方法返回值為可選類型值,因為有時候傳入的值可能與任意一個case都不匹配。比如Movement(rawValue:42)。

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

enum VNodeFlags : UInt32 {case Delete = 0x00000001case Write = 0x00000002case Extended = 0x00000004case Attrib = 0x00000008case Link = 0x00000010case Rename = 0x00000020case Revoke = 0x00000040case None = 0x00000080
}

如此便可以使你的Delete或Write用例聲明一目了然，稍后一旦需要，只需將raw value傳入 C 函數中即可。

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

enum Character {enum Weapon {case Bowcase Swordcase Lancecase Dagger}enum Helmet {case Woodencase Ironcase Diamond}case Thiefcase Warriorcase Knight
}

現在，你可以通過層級結構來描述角色允許訪問的項目條。

let character = Character.Thief
let weapon = Character.Weapon.Bow
let helmet = Character.Helmet.Iron

• 包含枚舉(Containing Enums)
  同樣地，你也能夠在structs或classes中內嵌枚舉。接著上面的例子:

struct Character {enum CharacterType {case Thiefcase Warriorcase Knight}enum Weapon {case Bowcase Swordcase Lancecase Dagger}let type: CharacterTypelet weapon: Weapon
}
let warrior = Character(type: .Warrior, weapon: .Sword)

同樣地，這也將有助于我們將相關的信息集中在一個位置。

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

• 簡單例程(Simple Example)

enum Trade {case Buycase Sell
}
func trade(tradeType: Trade, stock: String, amount: Int) {}

然而股票的價值和數量顯然從屬于交易，讓他們作為獨立的參數顯得模棱兩可。你可能已經想到要往struct中內嵌一個枚舉了，不過關聯值提供了一種更清爽的解決方案：

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

• 標簽(Labels)

關聯值不需要附加標簽的聲明:

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

倘若你添加了，那么，每當創建枚舉用例時，你都需要將這些標簽標示出來。

• (元組參數)Tuple as Arguments

更重要的是,Swift內部相關信息其實是一個元組,所以你可以像下面這樣做:

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"

語法允許您將元組當作一個簡單的數據結構,稍后元組將自動轉換到高級類型，就比如enum case。想象一個應用程序可以讓用戶來配置電腦:

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中進行內容更新。倘若我們從函數式編程2中獲得啟發，這將變得更好。

infix operator <^> { associativity left }func <^>(a: Config, f: (Config) -> Config) -> Config { return f(a)
}

最后，我們可以將不同配置步驟串聯起來。這在配置步驟繁多的情況下相當有用。

let config = (0, "", "") <^> selectRAM  <^> selectCPU <^> selectGPU
let aCube = Desktop.Cube(config)

• 使用案例(Use Case Example)

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

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

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

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

// 又或者假設你在封裝一個 C 語言庫，正如 Kqeue BSD/Darwin 通知系統:
// 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 游戲中的所有可穿戴裝備可以使用一個枚舉來進行映射，
// 可以為一個裝備增加重量和持久兩個屬性
// 現在可以僅用一行代碼來增加一個"鉆石"屬性，如此一來我們便可以增加幾件新的鑲嵌鉆石的可穿戴裝備
enum Wearable {enum Weight: Int {case Light = 1case Mid = 4case Heavy = 10}enum Armor: Int {case Light = 2case Strong = 8case 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而“生”。所以倘若想要在特定情況執行特定代碼的話，你需要分支處理或采用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)

盡管增加一個存儲屬性到枚舉中不被允許，但你依然能夠創建計算屬性。當然，計算屬性的內容都是建立在枚舉值下或者枚舉關聯值得到的。

enum Device {case iPad, iPhonevar year: Int {switch self {case iPhone: return 2007case iPad: return 2010}}
}

• 靜態方法(Static Methods)

你也能夠為枚舉創建一些靜態方法(static methods)。換言之通過一個非枚舉類型來創建一個枚舉。在這個示例中,我們需要考慮用戶有時將蘋果設備叫錯的情況(比如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。這樣就允許改變隱藏參數self的case值了3。

enum TriStateSwitch {case Off, Low, Highmutating func next() {switch self {case Off:self = Lowcase Low:self = Highcase High:self = Off}}
}
var ovenLight = TriStateSwitch.Low
ovenLight.next()
// ovenLight 現在等于.On
ovenLight.next()
// ovenLight 現在等于.Off

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

枚舉聲明的類型是囊括可能狀態的有限集，且可以具有附加值。通過內嵌(nesting),方法(method),關聯值(associated values)和模式匹配(pattern matching),枚舉可以分層次地定義任何有組織的數據。

現在我們已經對這個定義更加清晰了。確實，如果我們添加關聯值和嵌套，enum就看起來就像一個封閉的、簡化的struct。相比較struct，前者優勢體現在能夠為分類與層次結構編碼。

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

方法和靜態方法的添加允許我們為enum附加功能，這意味著無須依靠額外函數就能實現4。

// C-Like example
enum Trade {case Buycase Sell
}
func order(trade: Trade)// Swift Enum example
enum Trade {case Buycase Sellfunc order()
}

枚舉進階(Advanced Enum Usage）

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

Swift協議定義一個接口或類型以供其他數據結構來遵循。enum當然也不例外。我們先從Swift標準庫中的一個例子開始.

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

protocol CustomStringConvertible {var description: String { get }
}

該協議只有一個要求，即一個只讀(getter)類型的字符串(String類型)。我們可以很容易為enum實現這個協議。

enum Trade: CustomStringConvertible {case Buy, Sellvar 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

一些協議的實現可能需要根據內部狀態來相應處理要求。例如定義一個管理銀行賬號的協議。

protocol AccountCompatible {var remainingFunds: Int { get }mutating func addFunds(amount: Int) throwsmutating func removeFunds(amount: Int) throws
}

你也許會簡單地拿struct實現這個協議，但是考慮應用的上下文，enum是一個更明智的處理方法。不過你無法添加一個存儲屬性到enum中，就像var remainingFuns:Int。那么你會如何構造呢？答案灰常簡單，你可以使用關聯值完美解決:

enum Account {case Emptycase Funds(remaining: Int)enum Error: ErrorType {case Overdraft(amount: Int)}var remainingFunds: Int {switch self {case Empty: return 0case Funds(let remaining): return remaining}}
}

為了保持代碼清爽，我們可以在enum的協議擴展(protocl extension)中定義必須的協議函數:

extension Account: AccountCompatible {mutating func addFunds(amount: Int) throws {var newAmount = amountif 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中實現了協議所有要求項。如此做法還有一個妙不可言的地方:現在整個代碼基礎上你只需要一個模式匹配就能測試空賬號輸入的情況。你不需要關心剩余資金是否等于零。

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

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

enum Entities {case Soldier(x: Int, y: Int)case Tank(x: Int, y: Int)case Player(x: Int, y: Int)
}

現在，我們為enum擴展方法:

extension Entities {mutating func move(dist: CGVector) {}mutating func attack() {}
}

你同樣可以通過寫一個擴展來遵循一個特定的協議:

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)
  枚舉也支持泛型參數定義。你可以使用它們以適應枚舉中的關聯值。就拿直接來自Swift標準庫中的簡單例子來說，即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最直接的用例，并未使用任何語法糖，但是不可否認Swift中語法糖的加入使得你的工作更簡單。如果你觀察上面的實例代碼，你恐怕已經猜到Optional內部實現是這樣的5:

// Simplified implementation of Swift's Optional
enum MyOptional<T> {case Some(T)case None
}

這里有啥特別呢？注意枚舉的關聯值采用泛型參數T作為自身類型，這樣可選類型構造任何你想要的返回值。

枚舉可以擁有多個泛型參數。就拿熟知的Either類為例，它并非是Swift標準庫中的一部分，而是實現于眾多開源庫以及
其他函數式編程語言，比如Haskell或F#。設計想法是這樣的:相比較僅僅返回一個值或沒有值(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 Emptycase Full(contents: T)
}

• 遞歸 / 間接(Indirect)類型
  間接類型是 Swift 2.0 新增的一個類型。 它們允許將枚舉中一個 case 的關聯值再次定義為枚舉。舉個例子，假設我們想定義一個文件系統，用來表示文件以及包含文件的目錄。如果將文件和目錄定義為枚舉的 case，則目錄 case 的關聯值應該再包含一個文件的數組作為它的關聯值。因為這是一個遞歸的操作，編譯器需要對此進行一個特殊的準備。Swift 文檔中是這么寫的：

枚舉和 case 可以被標記為間接的(indrect)，這意味它們的關聯值是被間接保存的，這允許我們定義遞歸的數據結構。

所以，如果我們要定義 FileNode 的枚舉，它應該會是這樣的：

enum FileNode {case File(name: String)indirect case Folder(name: String, files: [FileNode])
}

此處的 indrect 關鍵字告訴編譯器間接地處理這個枚舉的 case。也可以對整個枚舉類型使用這個關鍵字。作為例子，我們來定義一個二叉樹:

indirect enum Tree<Element: Comparable> {case Emptycase Node(Tree<Element>,Element,Tree<Element>)
}

這是一個很強大的特性，可以讓我們用非常簡潔的方式來定義一個有著復雜關聯的數據結構。

• 使用自定義類型作為枚舉的值
  如果我們忽略關聯值，則枚舉的值就只能是整型，浮點型，字符串和布爾類型。如果想要支持別的類型，則可以通過實現 StringLiteralConvertible 協議來完成，這可以讓我們通過對字符串的序列化和反序列化來使枚舉支持自定義類型。

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

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

然而，這段代碼不能通過編譯。因為 CGPoint 并不是一個常量，不能用來定義枚舉的值。我們需要為想要支持的自定義類型增加一個擴展，讓其實現 StringLiteralConvertible 協議。這個協議要求我們實現三個構造方法，這三個方法都需要使用一個String類型的參數，并且我們需要將這個字符串轉換成我們需要的類型(此處是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)}
}

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

enum Devices: CGSize {case iPhone3GS = "{320, 480}"case iPhone5 = "{320, 568}"case iPhone6 = "{375, 667}"case iPhone6Plus = "{414, 736}"
}

終于，我們可以使用 CGPoint 類型的枚舉了。需要注意的是，當要獲取真實的 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的時候)。不僅如此，我們完全可以對自己定義的類型使用這個方法。

• 對枚舉的關聯值進行比較
  在通常情況下，枚舉是很容易進行相等性判斷的。一個簡單的 enum T { case a, b } 實現默認支持相等性判斷 T.a == T.b, T.b != T.a

然而，一旦我們為枚舉增加了關聯值，Swift 就沒有辦法正確地為兩個枚舉進行相等性判斷，需要我們自己實現 == 運行符。這并不是很困難：

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 truecase let (.Sell(stock1, amount1), .Sell(stock2, amount2))where stock1 == stock2 && amount1 == amount2:return truedefault: return false}
}

正如我們所見，我們通過 switch 語句對兩個枚舉的 case 進行判斷，并且只有當它們的 case 是匹配的時候(比如 Buy 和 Buy)才對它們的真實關聯值進行判斷。

• 自定義構造方法
  在 靜態方法 一節當中我們已經提到它們可以作為從不同數據構造枚舉的方便形式。在之前的例子里也展示過，對出版社經常誤用的蘋果設備名返回正確的名字：

enum Device { case AppleWatch static func fromSlang(term: String) -> Device? {if term == "iWatch" {return .AppleWatch}return nil}
}

我們也可以使用自定義構造方法來替換靜態方法。枚舉與結構體和類的構造方法最大的不同在于，枚舉的構造方法需要將隱式的 self 屬性設置為正確的 case。

enum Device { case AppleWatch init?(term: String) {if term == "iWatch" {self = .AppleWatch}return nil}
}

在這個例子中，我們使用了可失敗(failable)的構造方法。但是，普通的構造方法也可以工作得很好：

enum NumberCategory {case Smallcase Mediumcase Bigcase Hugeinit(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 進行迭代
  一個特別經常被問到的問題就是如何對枚舉中的 case 進行迭代?？上У氖?#xff0c;枚舉并沒有遵守SequenceType協議，因此沒有一個官方的做法來對其進行迭代。取決于枚舉的類型，對其進行迭代可能也簡單，也有可能很困難。在StackOverflow上有一個很好的討論貼。貼子里面討論到的不同情況太多了，如果只在這里摘取一些會有片面性，而如果將全部情況都列出來，則會太多。

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

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

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

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

// 這個類型也可以定義在 Objective-C 的代碼中
@objc class OTrade: NSObject {var type: Intvar stock: Stringvar amount: Intinit(type: Int, stock: String, amount: Int) {self.type = typeself.stock = stockself.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}}
}

這個方法有一個的缺點，我們需要將枚舉映射為 Objective-C 中的 NSObject 基礎類型(我們也可以直接使用 NSDictionary)，但是，當我們碰到一些確實需要在 Objective-C 當中獲取有關聯值的枚舉時，這是一個可以使用的方法。

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

枚舉通常都是一個字節長度。[…]如果你真的很傻很天真，你當然可以定義一個有成百上千個 case 的枚舉，在這種情況下，取決于最少所需要的比特數，枚舉可能占據兩個字節或者更多。

• Swift 標準庫中的枚舉
  在我們準備繼續探索枚舉在項目中的不同用例之前，先看一下在 Swift 標準庫當中是如何使用枚舉可能會更誘人，所以現在讓我們先來看看。

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

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

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

Optional 這個就不用多說了

Process 這個枚舉包含了當前進程的命令行參數(Process.argc, Process.arguments)。這是一個相當有趣的枚舉類型，因為在 Swift 1.0 當中，它是被作為一個結構體來實現的。

實踐用例

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

以下列舉了一些枚舉類型在實戰中的使用示例，可以用來點燃你的創造力。

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

Swift 的枚舉特別適用于構建一組相關的錯誤狀態，可以通過關聯值來為其增加額外的附加信息。

作為一個示例，我們來看下流行的JSON解析框架 Argo。當 JSON 解析失敗的時候，它有可能是以下兩種主要原因：

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

enum DecodeError: ErrorType {case TypeMismatch(expected: String, actual: String)case MissingKey(String)case Custom(String)
}

所有的 case 都有一個關聯值用來包含關于錯誤的附加信息。

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

enum APIError : ErrorType {// Can't connect to the server (maybe offline?)case ConnectionError(error: NSError)// The server responded with a non 200 status codecase ServerError(statusCode: Int, error: NSError)// We got no data (0 bytes) back from the servercase NoDataError// The server response can't be converted from JSON to a Dictionarycase JSONSerializationError(error: ErrorType)// The Argo decoding Failedcase JSONMappingError(converstionError: DecodeError)
}

這個 ErrorType 實現了完整的 REST 程序棧解析有可能出現的錯誤，包含了所有在解析結構體與類時會出現的錯誤。

如果你看得夠仔細，會發現在JSONMappingError中，我們將Argo中的DecodeError封裝到了我們的APIError類型當中，因為我們會用 Argo 來作實際的 JSON 解析。

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

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

enum Change {case Insertion(items: [Item])case Deletion(items: [Item])case Update(items: [Item])
}

之后，觀察對象就可以使用一個很簡潔的方式來獲取已經發生的事情的詳細信息。這也可以通過為其增加 oldValue 和 newValue 的簡單方法來擴展它的功能。

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

enum HttpError: String {case Code400 = "Bad Request"case Code401 = "Unauthorized"case Code402 = "Payment Required"case Code403 = "Forbidden"case Code404 = "Not Found"
}

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

enum JSON {case JSONString(Swift.String)case JSONNumber(Double)case JSONObject([String : JSONValue])case JSONArray([JSONValue])case JSONBool(Bool)case JSONNull
}

類似地，如果我們解析了其它的東西，也可以使用這種方式將解析結果轉化我們 Swift 的類型。

• UIKit 標識
  枚舉可以用來將字符串類型的重用標識或者 storyboard 標識映射為類型系統可以進行檢查的類型。假設我們有一個擁有很多原型 Cell 的 UITableView：

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

• 單位
  單位以及單位轉換是另一個使用枚舉的絕佳場合。可以將單位及其對應的轉換率映射起來，然后添加方法來對單位進行自動的轉換。以下是一個相當簡單的示例：

enum Liquid: Float {case ml = 1.0case l = 1000.0func 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))

另一個示例是貨幣的轉換。以及數學符號(比如角度與弧度)也可以從中受益。

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

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

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

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

enum DetailViewImages: String {case Background = "bg1.png"case Sidebar = "sbg.png"case ActionButton1 = "btn1_1.png"case ActionButton2 = "btn2_1.png"
}

對于 iOS 開發者，R.swift這個第三方庫可以為以上提到的情況自動生成結構體。但是有些時候你可能需要有更多的控制(或者你可能是一個Mac開發者8)。

• API 端點
  Rest API 是枚舉的絕佳用例。它們都是分組的，它們都是有限的 API 集合，并且它們也可能會有附加的查詢或者命名的參數，而這可以使用關聯值來實現。

這里有個 Instagram API 的簡化版：

enum Instagram {enum Media {case Popularcase Shortcode(id: String)case Search(lat: Float, min_timestamp: Int, lng: Float, max_timestamp: Int, distance: Int)}enum Users {case User(id: String)case Feedcase Recent(id: String)}
}

Ash Furrow的Moya框架就是基本這個思想，使用枚舉對 rest 端點進行映射。

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

enum List {case Endindirect case Node(Int, next: List)
}

每一個節點(Node) case 都指向了下一個 case， 通過使用枚舉而非其它類型，我們可以避免使用一個可選的 next 類型以用來表示鏈表的結束。

Airspeed Velocity 還寫過一篇超贊的博客，關于如何使用 Swift 的間接枚舉類型來實現紅黑樹，所以如果你已經閱讀過關于鏈表的博客，你可能想繼續閱讀這篇關于紅黑樹的博客。

• 設置字典(Setting Dictionaries)
  這是 Erica Sadun 提出的非常非常機智的解決方案。簡單來講，就是任何我們需要用一個屬性的字典來對一個項進行設置的時候，都應該使用一系列有關聯值的枚舉來替代。使用這方法，類型檢查系統可以確保配置的值都是正確的類型。

關于更多的細節，以及合適的例子，可以閱讀下她的文章。

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

• 提取關聯值
  David Owens寫過一篇文章，他覺得當前的關聯值提取方式是很笨重的。我墻裂推薦你去看一下他的原文，在這里我對它的要旨進行下說明：為了從一個枚舉中獲取關聯值，我們必須使用模式匹配。然而，關聯值就是關聯在特定枚舉 case 的高效元組。而元組是可以使用更簡單的方式來獲取它內部值，即 .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)

如果你也同樣覺得我們應該使用相同的方法來對枚舉進行解構(deconstruct)，這里有個 rdar: rdar://22704262 (譯者注：一開始我不明白 rdar 是啥意思，后來我 google 了下，如果你也有興趣，也可以自己去搜索一下)

• 相等性
  擁有關聯值的枚舉沒有遵守 equatable 協議。這是一個遺憾，因為它為很多事情增加了不必要的復雜和麻煩。深層的原因可能是因為關聯值的底層使用是使用了元組，而元組并沒有遵守 equatable 協議。然而，對于限定的 case 子集，如果這些關聯值的類型都遵守了 equatable 類型，我認為編譯器應該默認為其生成 equatable 擴展。

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

// Swift 應該能夠自動生成這個函數
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 == ddefault:return false}
}

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

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

這似乎看起來并不是一個最好的示例，但是我們一旦開始使用枚舉，就會經常陷入到需要用到類似上面這個示例的情形中。

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

• 默認關聯值
  另一個會碰到的事是枚舉的關聯值總是類型，但是我們卻無法為這些類型指定默認值。假設有這樣一種情況:

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

我們依然可以使用不同的值創建新的 case，但是角色的默認設置依然會被映射。

總結

以上是生活随笔為你收集整理的enum高级教程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。