指南：枚举（Enumerations）

• 枚举为一组相关的值定义了一个共同的类型，可以在代码中以类型安全的方式来使用这些值。
• 不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
• 枚举成员可以指定任意类型的关联值存储到枚举成员中，每一个枚举成员都可以有适当类型的关联值。
• 在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多在传统上只被类（class）所支持的特性，例如计算型属性（computed properties），用于提供枚举值的附加信息，实例方法（instance methods），用于提供和枚举值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始实现的基础上扩展它们的功能；还可以遵守协议（protocols）来提供标准的功能。

枚举语法（Enumeration Syntax）

• 使用enum关键词来创建枚举并且把它们的整个定义放在一对大括号内
• 多个成员值可以出现在同一行上，用逗号隔开：
• 与 C 和 Objective-C 不同，Swift 的枚举成员在被创建时不会被赋予一个默认的整型值。
• 每个枚举定义了一个全新的类型。像 Swift 中其他类型一样，它们的名字（例如CompassPoint和Planet）应该以一个大写字母开头。给枚举类型起一个单数名字而不是复数名字，以便于读起来更加容易理解：
• 当类型已知时，再次为其赋值可以省略枚举类型名。在使用具有显式类型的枚举值时，这种写法让代码具有更好的可读性。
• 可以使用switch语句匹配单个枚举值：
• switch语句必须穷举所有情况，当不需要匹配每个枚举成员的时候，可以提供一个default分支来涵盖所有未明确处理的枚举成员：

enum CompassPoint {
    case North
    case South
    case East
    case West
}
enum Planet {
    case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}
var directionToHead = CompassPoint.West

directionToHead = .South
switch directionToHead {
    case .North:
        print("Lots of planets have a north")
    case .South:
        print("Watch out for penguins")
    case .East:
        print("Where the sun rises")
    case .West:
        print("Where the skies are blue")
}
// 输出 "Watch out for penguins”

let somePlanet = Planet.Earth
switch somePlanet {
case .Earth:
    print("Mostly harmless")
default:
    print("Not a safe place for humans")
}
// 输出 "Mostly harmless”

关联值（Associated Values）

• 可以定义 Swift 枚举来存储任意类型的关联值，如果需要的话，每个枚举成员的关联值类型可以各不相同。

表现有点像C语言中的联合union

• 可以用元组来关联枚举成员，使用起来比较方便。
• 关联值可以被提取出来作为 switch 语句的一部分。
• 如果一个枚举成员的所有关联值都被提取为常量，或者都被提取为变量，为了简洁，可以只在成员名称前标注一个let或者var：

• 推荐统一提取为let的写法
• 曾经尝试过网络命令用枚举，用户输入参数用关联变量的方式写过网络接口

enum Barcode {
    case UPCA(Int, Int, Int, Int)
    case QRCode(String)
}
var productBarcode = Barcode.UPCA(8, 85909, 51226, 3)
productBarcode = .QRCode("ABCDEFGHIJKLMNOP")

switch productBarcode {
case .UPCA(let numberSystem, let manufacturer, let product, let check):
    print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
case .QRCode(let productCode):
    print("QR code: \(productCode).")
}
// 输出 "QR code: ABCDEFGHIJKLMNOP."

productBarcode = .UPCA(8, 85909, 51226, 3)
switch productBarcode {
case let .UPCA(numberSystem, manufacturer, product, check):
    print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
case let .QRCode(productCode):
    print("QR code: \(productCode).")
}
// 输出 "UPC-A: 8, 85909, 51226, 3"
// 推荐这种写法，多用let

• 推荐用没有原始值的枚举类型，也就是在定义不指定类型
• 推荐有关联值得枚举类型，这样做更有枚举的意义

原始值（Raw Values）

• 原始值：枚举成员可以用原始值预填充，这些原始值的类型必须相同。
• 原始值可以是字符串，字符，或者任意整型值或浮点型值。每个原始值在枚举声明中必须是唯一的。

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

• 在使用原始值为整数或者字符串类型的枚举时，不需要显式地为每一个枚举成员设置原始值，Swift 将会自动赋值。

• 当使用整数作为原始值时，隐式赋值的值依次递增1。如果第一个枚举成员没有设置原始值，其原始值将为0。
• 当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称。

• 使用枚举成员的rawValue属性可以访问该枚举成员的原始值.
• 如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法接收一个叫做rawValue的参数，参数类型即为原始值类型，返回值则是枚举成员或nil。（可选类型）

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

enum RawValuePlanet: Int {
    case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

enum RawValueCompassPoint: String {
    case North, South, East, West
}

let earthsOrder = RawValuePlanet.Earth.rawValue
// earthsOrder 值为 3

let sunsetDirection = RawValueCompassPoint.West.rawValue
// sunsetDirection 值为 "West"

let possiblePlanet = RawValuePlanet(rawValue: 7)
// possiblePlanet 类型为 RawValuePlanet? 值为 Planet.Uranus

let positionToFind = 9
if let somePlanet = RawValuePlanet(rawValue: positionToFind) {
    switch somePlanet {
    case .Earth:
        print("Mostly harmless")
    default:
        print("Not a safe place for humans")
    }
} else {
    print("There isn't a planet at position \(positionToFind)")
}
// 输出 "There isn't a planet at position 9

递归枚举（Recursive Enumerations）

• 递归枚举（recursive enumeration）是一种枚举类型，它有一个或多个枚举成员使用该枚举类型的实例作为关联值。使用递归枚举时，编译器会插入一个间接层。可以在枚举成员前加上indirect来表示该成员可递归。
• 也可以在枚举类型开头加上indirect关键字来表明它的所有成员都是可递归的：
• 要操作具有递归性质的数据结构，使用递归函数是一种直截了当的方式。

enum ArithmeticExpression {
    case Number(Int)
    indirect case Addition(ArithmeticExpression, ArithmeticExpression)
    indirect case Multiplication(ArithmeticExpression, ArithmeticExpression)
}
//indirect enum ArithmeticExpression {
//    case Number(Int)
//    case Addition(ArithmeticExpression, ArithmeticExpression)
//    case Multiplication(ArithmeticExpression, ArithmeticExpression)
//}
let five = ArithmeticExpression.Number(5)
let four = ArithmeticExpression.Number(4)
let sum = ArithmeticExpression.Addition(five, four)
let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2))

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

print(evaluate(product))
// 输出 "18"

这个功能挺好的，递归思想不错，但是在编程上实现一直很难理解。不过这里提供了一个直截了当的案例，以后推荐多试一试。提高编程效率，又好理解。