枚举

枚举为一组相关的值定义了一个共同的类型，使你可以在你的代码中以类型安全的方式来使用这些值。

在C语言中，枚举会为一组整型值分配相关联的名称。Swift中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符、或是一个整型值或浮点数。

此外，枚举成员可以指定任意类型的关联值存储到枚举成员中，就像其他语言中的联合体（unions）和变体（variants）。每一个枚举成员都可以有适当类型的关联值。

在Swift中，枚举类型是一等类型（first-class）。它们采用了很多在传统上只被类（class）所支持的特性，例如计算型属性（computed properties），用于提供枚举值的附加信息，实例方法（instance methods），用于提供和枚举值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始实现的基础上扩展它们的功能；还可以遵守协议（protocols）来提供标准的功能。

枚举语法

使用enum关键词来创建枚举并且把它们的整个定义放在一对大括号内。

枚举中定义的值是这个枚举的成员值（或成员）。你使用case关键字来定义一个新的枚举成员值。

注意，与C和Objective-C不同，Swift的枚举成员在被创建时不会被赋予一个默认的整型值。在上面的Compasspoint例子中，north，South，East和West不会被隐式地赋值为0，1，2和3。相反，这些枚举成员本身就是完备的值，这些值的类型是已经明确定义好的Compasspoint类型。

多个成员值可以出现在同一行上，用逗号隔开。

每个枚举定义了一个全新的类型。像其他类型一样，它们的名字应该以一个大写字母开头。给枚举类型起一个单数名字而不是复数名字，以便于读起来更加容易理解。

使用let和var定义枚举常量和变量。其类型可以在它被枚举类型的某个值初始化时推断出来。一旦枚举变量类型确定，可以使用更简短的点语法将其设置为另一个枚举类型的值。在使用具有显式类型的枚举值时，这种写法让代码具有更好的可读性。

enum Compasspoint {
    case north
    case South
    case East
    case West
}

enum Planet {
    case Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune
}

var b = Planet.Jupiter      // 类型可被推断，无需写成var b: Planet = Planet.Jupiter
print(b)        // Jupiter
b = .Mars
print(b)        // Mars
let c = Planet.Venus
print(c)        // Venus

使用switch语句匹配枚举值

使用switch语句匹配单个枚举值。

enum Compasspoint {
    case north
    case South
    case East
    case West
}

let a = Compasspoint.East
switch a {
case .north:
    print("north")
case .South:
    print("South")
case .East:
    print("East")
case .West:
    print("West")   // East，此时switch已经完备了，无需default分支。
}

在判断一个枚举类型的值时，switch语句必须穷举所有情况，否则报编译时错误。强制穷举确保了枚举成员不会被意外遗漏。当不需要匹配每个枚举成员的时候，你可以提供一个default分支来涵盖所有未明确处理的枚举成员。

关联值

有时候能够把其他类型的关联值和成员值一起存储起来会很有用。这能让你连同成员值一起存储额外的自定义信息，并且你每次在代码中使用该枚举成员时，还可以修改这个关联值。

你可以定义Swift枚举来存储任意类型的关联值，每个枚举成员的关联值类型可以各不相同。枚举的这种特性跟其他语言中的可识别联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。

例如，有些商品上标有使用0到9的数字的UPC-A格式的一维条形码。每一个条形码都有一个代表“数字系统”的数字，该数字后接五位代表“厂商代码”的数字，接下来是五位代表“产品代码”的数字。最后一个数字是“检查”位，用来验证代码是否被正确扫描，如“885909512263”。还有些商品上标有QR码格式的二维码，它可以使用任何ISO8859-1字符，并且可以编码一个最多拥有2953个字符的字符串。

enum Barcode {
    case UPCA(Int,Int,Int)
    case QRCode(String)
}

var a = Barcode.UPCA(8,85909,51226,3)    // 是枚举类型值Barcode.UPCA，并关联了元组值：(8,85909,51226,3)
print(a)    // UPCA(8,3)
a = .QRCode("ABCDEFGHIJKLMnop")     // 替换成新的字符串关联值

上面的枚举定义中，定义一个名为Barcode的枚举类型，它的一个成员值是具有(Int，Int，Int，Int)类型关联值的UPCA，另一个成员值是具有String类型关联值的QRCode。

Barcode类型的常量和变量可以存储一个.UPCA或者一个.QRCode（连同它们的关联值），但是在同一时间只能存储这两个值中的一个。

同样，关联值可以被提取出来作为switch语句的一部分。你可以在switch的case分支代码中提取每个关联值作为一个常量（用let前缀）或者作为一个变量（用var前缀）来使用。

如果一个枚举成员的所有关联值都被提取为常量，或者都被提取为变量，为了简洁，你可以只在成员名称前标注一个let或者var。

enum Barcode {
    case UPCA(Int,Int)
    case QRCode(String)
}

var a = Barcode.UPCA(8,3)
var b = Barcode.QRCode("ABCDEFGHIJKLMnop")
switch a {
case .UPCA(let numberSystem,let manufacturer,let product,let check):
    print("\(numberSystem),\(manufacturer),\(product),\(check)")
case .QRCode(let productCode):
    print("\(productCode)")
}
switch b {
case let .UPCA(numberSystem,manufacturer,product,check):
    print("\(numberSystem),\(check)")
case let .QRCode(productCode):
    print("\(productCode)")
}

原始值

作为关联值的替代选择，枚举成员可以被默认值（称为原始值）预填充，这些原始值的类型必须相同。

原始值可以是字符串，字符，或者任意整型值或浮点型值。每个原始值在枚举声明中必须是唯一的。

注意，原始值和关联值是不同的。原始值是在定义枚举时被预先填充的值。对于一个特定的枚举成员，它的原始值始终不变。关联值是创建一个基于枚举成员的常量或变量时才设置的值，枚举成员的关联值可以变化。

enum ASCIIControlCharacter: Character {
    case Tab = "\t"
    case LineFeed = "\n"
    case CarriageReturn = "\r"
}

原始值的隐式赋值

在使用原始值为整数或者字符串*类型的枚举时，不需要显式地为每一个枚举成员设置原始值，Swift将会自动为你赋值。例如，当使用整数作为原始值时，隐式赋值的值依次递增1。如果第一个枚举成员没有设置原始值，其原始值将为0。当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称。

使用枚举成员的rawValue属性可以访问该枚举成员的原始值。

enum Planet: Int {
    case Mercury = 1,Neptune  // 利用整型的原始值来表示每个行星在太阳系中的顺序
}
print(Planet.Mercury.rawValue)  // 1
print(Planet.Earth.rawValue)    // 3

enum Compasspoint: String {
    case north,South,East,West
}
print(Compasspoint.south)   // South

使用原始值初始化枚举实例

如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法接收一个叫做rawValue的参数，参数类型即为原始值类型，返回值则是枚举成员或nil。你可以使用这个初始化方法来创建一个新的枚举实例。

原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。因此，原始值构造器总是返回一个可选的枚举成员。

enum Planet: Int {
    case Mercury = 1,Neptune  // 利用整型的原始值来表示每个行星在太阳系中的顺序
}
let a = Planet(rawValue: 3)
print(a)    // 返回可选类型：Optional(Planet.Earth)
print(Planet(rawValue: 100))    // nil

递归枚举

当各种可能的情况可以被穷举时，非常适合使用枚举进行数据建模，例如可以用枚举来表示用于简单整数运算的操作符。算术表达式的一个重要特性是，表达式可以嵌套使用。例如，表达式(5 + 4) * 2，乘号右边是一个数字，左边则是另一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也需要支持这种嵌套——枚举类型需要支持递归。

递归枚举（recursive enumeration）是一种枚举类型，它有一个或多个枚举成员使用该枚举类型的实例作为关联值。使用递归枚举时，编译器会插入一个间接层。你可以在枚举成员前加上indirect来表示该成员可递归。

也可以在枚举类型开头加上indirect关键字来表明它的所有成员都是可递归的。

indirect enum ArithmeticExpression2 {
    case Number(Int)
    case Addition(ArithmeticExpression,ArithmeticExpression)
    case Multiplication(ArithmeticExpression,ArithmeticExpression)
}

要操作具有递归性质的数据结构，使用递归函数是一种直截了当的方式。

/** * 使用枚举类型存储简单地算术表达式 */
enum ArithmeticExpression {
    case Number(Int)
    indirect case Addition(ArithmeticExpression,ArithmeticExpression)
    indirect case Multiplication(ArithmeticExpression,ArithmeticExpression)
}

func evaluate(expression: ArithmeticExpression) -> Int {
    switch expression {
    case .Number(let value):
        return value
    case .Addition(let left,let right):
        return evaluate(left) + evaluate(right)
    case .Multiplication(let left,let right):
        return evaluate(left) * evaluate(right)
    }
}

// 计算 (5 + 4) * 2
let a = ArithmeticExpression.Addition(ArithmeticExpression.Number(5),ArithmeticExpression.Number(4))
print(a)    // Addition(ArithmeticExpression.Number(5),ArithmeticExpression.Number(4))

let b = ArithmeticExpression.Multiplication(a,ArithmeticExpression.Number(2))
print(b)    // Multiplication(ArithmeticExpression.Addition(ArithmeticExpression.Number(5),ArithmeticExpression.Number(4)),ArithmeticExpression.Number(2))

print(evaluate(b))  // 18