Swift Learning (10) - Enumeration (Fully Ver.)

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

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

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

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

枚举语法

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

enum SomeEnumeration {
    // 枚举定义放这里
}
// 下面使用枚举表示指南针四个方向的例子：
enum CompassPoint {
    case north
    case south
    case east
    case west
}

枚举中定义的值（如north，south，east和west）是这个枚举的成员值（或成员）。可以使用case关键字来定义一个新的枚举成员值。

注意

与C和Objective-C不同，Swift的枚举成员在被创建时不会赋予一个默认的整型值。在上面的CompassPoint例子中，north，south，east和west不会被隐式的赋值为0，1，2和3。相反，这些枚举成员本身就是完备的值，这些值的类型是已经明确定义好的CompassPoint类型。 多个成员值可以出现在同一行上，用逗号隔开：

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

每个枚举定义了一个全新的类型。像Swift中的其他类型一样，它们的名字（例如CompassPoint和Planet）以一个大写字母开头。给枚举类型起一个单数名字而不是复数名字，以便于：

var directionToHead = CompassPoint.west

directionToHead的类型还可以在它被CompassPoint的某个值初始化时推断出来，一旦directionToHead被声明为CompassPoint类型，可以使用更简短的点语法将其设置为另一个CompassPoint的值：

directionToHead = .east

当directionToHead的类型已知时，再次为其赋值可以省略枚举类型名。在使用具有显式类型的枚举值时，这种写法让代码具有更好的可读性。

print("directionToHead: \(directionToHead).")
---
output: directionToHead: east.

使用Switch语句匹配枚举值

可以使用switch语句匹配单个枚举值：

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 the penguins.”
---
output: Watch out for penguins.

可以这样理解这段代码：

“判断directionToHead的值。当它等于.north，打印‘Lots of planets have a north.’。当它等于.south，打印‘Watch out for penguins.’” ……以此类推

正如在控制流中介绍的那样，在判断一个枚举类型的值时，switch语句必须穷举所有的情况。如果忽略了.west这种情况，上面那段代码将无法通过编译，因为其没有考虑到CompassPoint的全部成员。强制穷举确保了枚举成员不会被意外遗漏。

当不需要匹配每个枚举成员的时候，可以提供一个default分支来涵盖所有未明确处理的枚举成员：

let somePlanet = Planet.earth
switch somePlanet {
case .earth:
    print("Mostly harmless.")
default:
    print("Not a safe place for humans.")
}  // 打印输出“Mostly harmless.”
---
output: Mostly harmless.

枚举成员的遍历

在一些情况下，可能会需要得到一个包含枚举所有成员的集合。可以通过如下代码的实现：

令枚举遵循CaseIterable协议。Swift会生成一个allCases属性，用于表示一个包含枚举所有成员的集合。下面是一个例子：

enum Beverage: CaseIterable {
    case coffee, tea, juice
}
let numberOfChoices = Beverage.allCases.count
print("\(numberOfChoices) beverages available.")
---
output: 3 beverages available.

在前面的例子中，通过Beverage.allCases可以访问到包含Beverage枚举所有成员的集合。allCases的使用方法和其他一般集合一样：集合中的元素是枚举类型的实例，所以在上面的情况中，这些元素是Beverage值。在前面的例子中，统计了总共多少个枚举成员。而在下面的例子中，则使用for-in循环来遍历所有枚举成员。

for beverage in Beverage.allCases {
    print(beverage)
}  // coffee  // tea  // juice
---
output: coffee
tea
juice

在前面的例子中，使用的语法表明这个枚举遵循CaseIterable协议。

关联值

枚举语法那一小节的例子演示了如何定义和分类枚举成员。可以为Planet.earth设置一个常量或者变量，并在赋值之后查看这个值。然而，有时候把其他类型的值和成员值一起存储起来会很有用。这额外的信息被称为关联值，并且每次在代码中使用该枚举成员时，还可以修改这个关联值。

可以定义Swift枚举来存储任意类型的关联值，如果需要的话，每个枚举成员的关联值类型可以各不相同。枚举的这种特性跟其他语言中的可识别联合（Discriminated Unions），标签联合（Tagged Unions），或者变体（Variants）相似。

例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品，有些商品商标有使用0到9的数字的UPC格式的一维条形码。每一个条形码都有一个代表数字系统的数字，该数字后接五位代表厂商代码的数字，接下来是五位代表“产品代码”的数字。最后一位数字是检查位，用来验证代码是否被正确扫描：

其他商品上标有QR码格式的二维码，它可以使用任何ISO 8859-1字符，并且可以编码一个最多拥有2953个字符的字符串：

这便于库存跟踪系统用包含四个整型值的元组存储UPC码，以及用任意长度的字符串储存QR码：

在Swift中，使用如下方法定义表示两种商品条形码的枚举：

enum BarCode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

以上代码可以这么理解：

“定义一个名为BarCode的枚举类型，它的一个成员值是具有(Int, Int, Int, Int)类型关联值的upc，另一个成员值是具有String类型关联值的qrCode。”

这个定义不提供任何Int或String类型的关联值，它只是定义了，当BarCode常量和变量等于BarCode.upc或BarCode.qrCode时，可以存储的关联值的类型。

然后可以使用任意一种条形码类型创建新的条形码。例如：

var productBarCode = BarCode.upc(8, 85909, 51226, 3)

上面的例子创建了一个名为productBarCode的变量，并将BarCode.upc赋值给它，关联的元组值为(8, 85909, 51226, 3)。

同一个商品可以被分配成一个不同类型的条形码，例如：

productBarCode = .qrCode("ABCDEFGHIJKLMNOP")

这时，原始的BarCode.upc和其整数关联值被新的BarCode.qrCode和其字符串关联值所替代。BarCode类型的常量和变量可以存储一个.upc或者.qrCode（连同它们的关联值），但是在同一时间只能存持这两个值中的一个。

可以使用一个switch语句来检查不同的条形码类型，和之前使用Switch语句来匹配枚举值的例子一样。然而，这一次，关联值可以被提取出来作为switch语句的一部分。可以在switch的case分支代码中提取每个关联值作为一个常量（用let前缀）或者一个变量（用var前缀）来使用：

switch productBarCode {
case .upc(let numberSystem, let manuFacturer, let product, let check):
    print("UPC: \(numberSystem), \(manuFacturer), \(product), \(check).")
case .qrCode(let productCode):
    print("QR code: \(productCode).")
}  // 打印输出“QR code: ABCDEFGHIJKLMNOP”
---
output: QR code: ABCDEFGHIJKLMNOP.

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

productBarCode = .upc(8, 86751, 62119, 3)
switch productBarCode {
case let .upc(numberSystem, manuFactor, product, check):
    print("UPC: \(numberSystem), \(manuFactor), \(product), \(check).")
case let .qrCode(productCode):
    print("QR code: \(productCode)")
}  // 打印输出“UPC: 8, 86751, 62119, 3.”
---
output: UPC: 8, 86751, 62119, 3.

原始值

在关联值小节的条形码例子中，演示了如何声明存储不同类型关联值的枚举成员。作为关联值的替代选择，枚举成员可以被默认值（称为原始值）预填充，这些原始值的类型必须相同。

这是一个使用ASCII码作为原始值的枚举：

enum ASCIIControlCharacter: Character {
    case tab = "\t"
    case lineFeed = "\n"
    case carriageReturn = "\r"
}

枚举类型ASCIIControlCharacter的原始值类型被定义为Character，并设置了一些比较常见的ASCII控制字符。Character的描述详见字符串和字符部分。

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

注意

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

原始值的隐式赋值

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

例如，当使用整数作为原始值时，隐式赋值的值以此递增1。如果第一个枚举成员没有原始值，则其原始值被设置为0。

下面的枚举是对之前Planet这个枚举的一个细化，利用整型的原始值来表示每个行星在太阳系中的顺序：

enum Planets: Int {
    case mercury = 1, venus, earth
    case mars, jupiter, saturn, uranus, neptune
}
extension Planets: CaseIterable {}
for planet in Planets.allCases {
    print("\(planet)'s raw value is \(planet.rawValue).")
}
---
output: mercury's raw value is 1.
venus's raw value is 2.
earth's raw value is 3.
mars's raw value is 4.
jupiter's raw value is 5.
saturn's raw value is 6.
uranus's raw value is 7.
neptune's raw value is 8.

在上面的例子中，Planet.mercury的显式原始值为1，Planet.venus的隐式原始值为2，依次类推。

当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始成员值为该枚举成员的名称。

下面例子是CompassPoint枚举的细化，使用字符串类型的原始值来表示各个方向的名称：

enum CompassPoints: String {
    case north, south, east, west
}

上面的例子中，CompassPoints.south拥有隐式原始值south，依次类推。

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

extension CompassPoints: CaseIterable {}
for point in CompassPoints.allCases {
    print("The point's raw value is \(point.rawValue).")
}
---
output: The point's raw value is north.
The point's raw value is south.
The point's raw value is east.
The point's raw value is west.

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

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

这个例子利用原始值7创建了枚举成员Uranus：

let possiblePlanet = Planets(rawValue: 7)  // possiblePlanet类型为Planets？值为Planets.uranus
print("\(possiblePlanet!)'s raw value is \(possiblePlanet!.rawValue).")
---
output: uranus's raw value is 7.

然而，并非所有Int值都可以找到一个匹配的行星🪐。因此，原始值构造器总是返回一个可选的枚举成员。在上面的例子中，possiblePlanet是Planets?类型，或者说“可选的Planets”。

注意

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

如果试图寻找一个位置为11的行星🪐，通过原始值构造器返回的Planets值将是nil：

let positionToFind = 11
if let somePlanet = Planets(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 11.”
---
output: There isn't a planet at position 11.

这个例子使用了可选绑定（Optional Binding），试图通过原始值11来访问这个行星🪐。if let somePlanet = Planets(rawValue: 11)语句创建了一个可选Planets，如果可选Planets的值存在，就会赋值给somePlanet。这个例子中，无法检索到位置11的行星，所以else分支被执行。

递归枚举

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

例如，下面的例子中，枚举类型存储了简单的算术表达式：

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

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

indirect enum ArithmeticExpressions {
    case number(Int)
    case addition(ArithmeticExpressions, ArithmeticExpressions)
    case multiplication(ArithmeticExpressions, ArithmeticExpressions)
}

上面定义的枚举类型可以存储三种算术表达式：纯数字，两个表达式相加，两个表达式相乘。枚举成员addition和multiplication的关联值也是算术表达式–这些关联值使得嵌套表达式成为可能。例如，表达式(5 + 4) * 2，乘号右边是一个数字，左边则是一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也需要支持这种嵌套–这意味着枚举类型需要支持递归。下面的代码展示了使用ArithmeticExpression这个递归枚举创建表达式(5 + 4) * 2：

let five = ArithmeticExpressions.number(5)
let four = ArithmeticExpressions.number(4)
let sum = ArithmeticExpressions.addition(five, four)
let product = ArithmeticExpressions.multiplication(sum, ArithmeticExpressions.number(2))

要操作具有递归性质的数据结构，使用递归函数是一种直截了当的方式。例如，下面是一个对算术表达式求值的函数：

func evaluate(_ expression: ArithmeticExpressions) -> Int {
    switch expression {
    case let .number(value):
        return value
    case let .addition(left, right):
        return evaluate(left) + evaluate(right)
    case let .multiplication(left, right):
        return evaluate(left) * evaluate(right)
    }
}
print(evaluate(product))  // 打印输出“18”
---
output: 18