一、枚举
1. 枚举的基本用法
Swift 中可以通过 enum 关键字来声明一个枚举，如下：
enum Season {
case spring
case summer
case autumn
case winter
}
上面这种写法等价于下面这种写法：
enum Season {
case spring, summer, autumn, winter
}
2. 关联值（Associated Values）
枚举的成员可以跟其他类型关联起来存储在一起。什么意思呢？请看下面的代码：
enum Score {
case points(Int)
case grade(Character)
}
我们定一个枚举 - Score，Score 有两个成员 points 和 grade。Score 是用来表达分数的意思，那分数有数字类型和字符类型的，比如 90，95，100 和 A，B，C。
使用的时候可以这么去使用：
var score = Score.points(100)
score = Score.grade("A")
switch score {
case let .points(i):
print("points: ",i)
case var .grade(i):
print("grade: ",i)
i = "B"
print("grade: ",i)
}
在使用 switch 的时候，我们可以在 case 的后面加上 let 或者 var ，将枚举的关联值取出或者修改。
我们再举一个关联值的使用场景，比如应用程序有输入密码解锁的功能，并且可以使用密码解锁和手势解锁，如图：
根据需求我们来定义一个枚举，如下：
enum Password {
case number(Int, Int, Int, Int)
case gesture(String)
}
枚举 Password 的 number 的关联值为 4 个 Int 类型的，对应输入密码的四位数。但因为需求有支持手势解锁，用户在设置手势解锁的密码时，可能不止 4 位数，所以添加了成员 gesture，并且它的关联值是一个 String 类型的。
使用的时候可以这么使用：
var pwd = Password.number(1, 2, 3, 4)
pwd = Password.gesture("12369")
switch pwd {
case .number(let n1, let n2, let n3, var n4):
print("number is :",n1,n2,n3,n4)
n4 = 5
print("number is :",n1,n2,n3,n4)
case let .gesture(str):
print("gesture is :",str)
}
在使用 switch 的时候，我们也可以在枚举的关联值前加上 let 或者 var ，将枚举的关联值取出或者修改。
3. 原始值（Raw Values）
枚举成员可以使用相同类型的默认值预先对应，这个默认值叫做原始值。什么意思呢，我们看下面的代码：
enum Season: String {
case spring = "spring"
case summer = "summer"
case autumn = "autumn"
case winter = "winter"
}
var season = Season.spring
print(season.rawValue) // spring
season = Season.autumn
print(season.rawValue) // autumn
在枚举 Season 的后面加上 : 并指定具体的类型，这个时候枚举的原始值默认就是指定的类型，这个类型可以是字符串、字符、任意的整数值，或者是 浮点类型。我们可以通过 rawValue 拿到枚举成员的原始值。
注意：原始值并不占用枚举变量的内存。
4. 隐式原始值（Implicitly Assigned Raw Values）
如果枚举的原始值类型是 Int、String，Swift 会自动分配原始值。例如，枚举 Season 可以这么去定义：
enum Season: String {
case spring, summer, autumn, winter
}
他完全等价于第 3 点的 Season。如果枚举的原始值是 Int 类型的，自动分配的原始值从第一个成员开始，下标从 0 计算，依次 +1。代码如下：
enum Season: Int {
case spring, summer, autumn, winter
}
print(Season.spring.rawValue) // 0
print(Season.summer.rawValue) // 1
print(Season.autumn.rawValue) // 2
print(Season.winter.rawValue) // 3
此时，假设我把 autumn 的原始值指定成 6，那么从 autumn 开始，下标从 6 开始计算，依次 +1。如果后面还有类似的，也是从指定的原始值开始依次计算。代码如下：
enum Season: Int {
case spring, summer, autumn = 6, winter
}
print(Season.spring.rawValue) // 0
print(Season.summer.rawValue) // 1
print(Season.autumn.rawValue) // 6
print(Season.winter.rawValue) // 7
5. 枚举的内存大小
接下来我们探讨一下枚举的内存大小，探讨的过程中分三种情况：第一种是无关联值的枚举；第二种是只有一个关联值的枚举；第三种是有多个关联值的枚举。先来看第一种情况。
5.1 无关联值的枚举
enum Season {
case spring
case summer
case autumn
case winter
}
print(MemoryLayout<Season>.size) // 1
print(MemoryLayout<Season>.stride) // 1
print(MemoryLayout<Season>.alignment) // 1
通过打印，当前枚举的内存大小为 1 个字节。这么多个枚举成员，才占 1 个字节，那这些枚举成员在内存中是如何存储的呢？我们通过读取枚举的成员的内存地址来看一下，如图：
从图中我们可以看出，在 Swift 中进行枚举的内存布局时，一直是尝试使用最少的空间来存储枚举。无关联值的枚举默认是以 UInt8（1个字节） 的方式去存储枚举值，1 个字节可以存储 256 个 case，也就意味着一个没有关联值的枚举可以拥有 256 个 case。如果超出 256，这个枚举会升级成以 UInt 16 的方式去存储枚举值，如果还超出，以此类推。
5.2 只有一个关联值的枚举
enum Season {
case spring(Bool)
case summer
case autumn
case winter
}
print(MemoryLayout<Season>.size) // 1
print(MemoryLayout<Season>.stride) // 1
print(MemoryLayout<Season>.alignment) // 1
当枚举的关联值为 Bool 类型时，枚举只占 1 个字节。对于 Bool 类型来说，它本身是 1 个字节的大小，但实际上它只需要 1 位来存储 Bool 值，而且由于此时的枚举是以 UInt8 的方式进行存储，在这 8 位当中，有 1 位是用来存储 Bool 值的，余下的 7 位才是用来存储 case 的，那此时这个枚举最多只能有 128 个 case。
我们再来看一个例子，当枚举的关联值为 Int 类型的时候，代码如下：
enum Season {
case spring(Int)
case summer
case autumn
case winter
}
print(MemoryLayout<Season>.size) // 9
print(MemoryLayout<Season>.stride) // 16
print(MemoryLayout<Season>.alignment) // 8
当枚举的关联值为 Int 类型时，枚举占用 9 个字节。对于 Int 类型来说，其实系统是没有办法推算当前负载所要使用的位数，也就意味着当前 Int 类型的负载是没有额外的剩余空间的，这个时候我们就需要额外开辟内存空间来存储我们的 case 值。
5.3 多个关联值的枚举
最后是有多个关联值的枚举，它的内存又是怎么去分配的，代码如下：
enum Season1 {
case spring(Bool)
case summer(Bool)
case autumn(Bool)
case winter(Bool)
}
enum Season2 {
case spring(Int)
case summer(Int)
case autumn(Int)
case winter(Int)
}
enum Season3 {
case spring(Bool)
case summer(Int)
case autumn
case winter
}
enum Season4 {
case spring(Int, Int, Int, Int)
case summer
case autumn
case winter
}
print(MemoryLayout<Season1>.size) // 1
print(MemoryLayout<Season2>.size) // 9
print(MemoryLayout<Season3>.size) // 9
print(MemoryLayout<Season4>.size) // 33
通过打印我们得知：如果枚举中多个成员有关联值，且最大的关联值类型大于 1 个字节（8 位）的时候，此时枚举的大小为：最大关联值的大小 + 1。
5.4 特殊情况
enum Season {
case season
}
print(MemoryLayout<Season>.size) // 0
对于当前的 Season 只有一个 case，此时不需要用任何东⻄来去区分当前的 case，所以当我们打印当前的 Season 大小是 0。
6. 关联值和原始值的区别
枚举的关联值和原始值在本质上的区别就是，关联值占用枚举的内存，而原始值不占用枚举的内存。
并且 rawValue 本质上是一个计算属性。举个例子，rawValue 的实现大概应该是这样子的：
enum Season: Int {
case spring, summer, autumn , winter
var rawValue: Int {
get {
switch self {
case .spring:
return 10
case .summer:
return 20
case .autumn:
return 30
case .winter:
return 40
}
}
}
}
print(Season.spring.rawValue) // 10
print(Season.summer.rawValue) // 20
print(Season.autumn.rawValue) // 30
print(Season.winter.rawValue) // 40
所以，枚举的原始值不占内存大小的原因是因为 rawValue 可能是一个计算属性，而计算属性的本质就是方法，方法并不占用枚举的内存。
7. 递归枚举（Recursive Enumeration）
递归枚举是一种枚举类型，它有一个或多个枚举成员使用该枚举类型的实例作为关联值。使用递归枚举时，编译器会插入一个间接层。可以在枚举成员前加上 indirect 来表示该成员可递归。
我们来看下面的代码：
indirect enum ArithExpr {
case number(Int)
case sum(ArithExpr, ArithExpr)
case difference(ArithExpr, ArithExpr)
}
我们也可以单独对枚举的某个成员加上 indirect 修饰，代码如下：
enum ArithExpr {
case number(Int)
indirect case sum(ArithExpr, ArithExpr)
indirect case difference(ArithExpr, ArithExpr)
}
在使用的时候我们可以定义一个方法，这个方法用来处理枚举的成员，如下：
let five = ArithExpr.number(5)
let four = ArithExpr.number(4)
let two = ArithExpr.number(2)
let sum = ArithExpr.sum(five, four)
let difference = ArithExpr.difference(sum, two)
func calculate(_ expr: ArithExpr) -> Int {
switch expr {
case let .number(value):
return value
case let .sum(left, right):
return calculate(left) + calculate(right)
case let .difference(left, right):
return calculate(left) - calculate(right)
}
}
print(calculate(difference))
二、可选项（Optional）
1. 初识可选项
可选项，一般也叫可选类型，它允许将值设置为 nil。在类型后面添加一个问号（?）来定义一个可选项，如下：
var name: String? = "Coder_张三"
name = nil
// 这么定义的时候 age 默认就是 nil。
var age: Int?
age = 10
age = nil
除了可以用问号（?）表达之外，我们也可以使用 Optional 关键字来表达，代码如下：
var name: Optional<String> = "Coder_张三"
name = nil
// 这么定义的时候 age 默认就是 nil。
var age: Optional<Int> = 10
age = 10
age = nil
这两种写法是完全等价的，也就是 String? == Optional<String>，Int? == Optional<Int>。
2. 强制解包
可选项是对其他类型的一层包装，可以将它理解为一个盒子：如果为 nil，那么它是个空盒子。如果不为 nil，那么盒子里装的是被包装类型的数据。
可以使用感叹号（!）将盒子里的东西取出来，这种行为通常叫强制解包。代码如下：
var age: Int? = 10
let age2 = age!
如果对一个空的盒子进行强制解包，会产生运行时错误，报错如下：
Fatal error: Unexpectedly found nil while unwrapping an Optional value
3. 可选项绑定
我们可以通过 if 语句来判断这个可选项是否有值，如下：
var age: Int?
if age == nil {
print("age is nil")
}else {
print("age is \(age!)")
}
除了通过这种方式，我们还可以通过可选项绑定来判断可选项是否有值，并且取出来。如果可选项包含有值，会自动解包，把值赋给一个临时的常量（let）或者变量（var），并返回一个 Bool 类型。
代码如下：
var age: Int? = 10
if let age = age {
print("age is \(age)")
}else {
print("age is nil")
}
在 while 循环中也可以使用可选项绑定，代码如下：
var nums = [10, 20, nil, 40, nil, 50, 60]
var index = 0
while let num = nums[index] {
print(num)
index += 1
}
4. 隐式解包
在某些情况下，可选项一旦被设定值之后，就会一直拥有值。在这种情况下，可以去掉检查，不必每次访问的时候都进行解包，因为它能确定每次访问的时候都有值，可以在类型后面加个感叹号（!） 定义一个隐式解包的可选项。
代码如下：
let num1: Int! = 10
let num2: Int = num1
if num1 != nil {
print(num1 + 6) // 16
}
if let num3 = num1 {
print(num3) // 10
}
5. 空合并运算符 ??（Nil-Coalescing Operator）
空合并运算符以 ?? 的形式来表达，它本质上是一个函数，其函数的定义如下：
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?
public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T
?? 函数有两个参数，它使用的条件通过函数的定义也可以看出来：
- 第一个参数必须是可选项。第二个参数可以是可选项，也可以不是可选项。
- 第一个参数和第二个参数定义的存储类型必须一致。
我们来看一下它的使用方式：
let a: Int? = 1
let b: Int? = 2
let c = a ?? b // Int? 类型，Optional(1)
let a: Int? = nil
let b: Int? = 2
let c = a ?? b // Int? 类型，Optional(2)
let a: Int? = nil
let b: Int? = nil
let c = a ?? b // Int? 类型，nil
let a: Int? = 1
let b: Int = 2
let c = a ?? b // Int 类型，1
let a: Int? = nil
let b: Int = 2
let c = a ?? b // Int 类型，2
通过上面几个案例的打印，其规律如下：
- 如果 a 不为 nil，就返回 a，而且，如果此时 b 不是可选项的话，返回的 a 会自动解包。
- 如果 a 为 nil，就返回 b。
通过这两个规律，我们得出一个结论：?? 的返回值取决于 b 的类型，也就是 第二个参数的类型。
6. 多重可选项
我们可以通过 ?? 来定义一个多重可选项，这里需要注意！多重可选项虽然也是用 ?? 表达，但是和第 5 点的空合并运算符一点关系都没有，它们是两个完全不同的东西。
在前面说过，可以把可选项比作一个盒子，盒子里装着存储的类型的值。那多重可选项可以比作盒子里装着盒子。
代码如下：
var num1: Int? = 10
var num2: Int?? = num1
var num3: Int?? = 10
print(num2 == num3) // true
怎么去理解这三个变量呢，num1 这个盒子里装的是 Int 类型的 10。num2 这个盒子里装的是 Int? 类型的盒子，Int? 类型的盒子里装着 10。num3 和 num2，它们两个是完全相等的。
这个时候我把代码改一下，如下：
var num1: Int? = nil
var num2: Int?? = num1
var num3: Int?? = nil
print(num2 == num3) // false
num1 这个盒子里什么都没有，是一个 nil。num2 这个盒子里装的是 Int? 类型的盒子，Int? 类型的盒子是一个 nil。这个时候 num2 和 num3 就不是相等的了，num3 和 num1 也不是相等的，他其实就是只有一个大盒子，大盒子里什么都没有，没有 Int? 类型的空盒子，可以把它理解为一个 Int?? 类型的大空盒子。
7. Optional 的类型
Optional 本质上是一个枚举，我们可以按 command 点击进去看，其定义大致如下：
@frozen public enum Optional<Wrapped> : ExpressibleByNilLiteral {
case none
case some(Wrapped)
public init(_ some: Wrapped)
// ......
}
它有两个成员，分别为 none 和 some，并且 some 有一个关联值 Wrapped，Wrapped 是一个泛型，这也是可选项可以作用在任意类型的原因。当可选项的值为 nil 的时候，为 none，并且把 nil 赋值到变量。当可选项的值不为 nil 的时候，为 some，并且把 some 的关联值赋值给变量。
我们通过一个案例来理解，如下：
var name: Optional<String> = .some("Coder_张三")
name = nil
var age: Optional<Int> = .some(10)
age = 10
age = nil
这个案例的代码和第 1 点的效果是一模一样的，并且，这么看的话，可以更加深刻的体会到，可选项的类型本质是枚举。而我们平时可以直接用问号（?）表达这是 Swift 的语法糖问题了。
这个 Optional 这么设计的原因是为了限制语法的安全性，我们可以通过 Optional 的可选模式使应用程序更加安全。
8. 可选链（Optional Chaining）
可选链式调用是一种可以在当前值可能为 nil 的可选值上请求和调用属性、方法及下标的方法。代码如下：
class Car { var price = 0 }
class Dog { var weight = 0 }
class Person {
var name: String = ""
var dog: Dog = Dog()
var car: Car? = Car()
func age() -> Int { 18 }
func eat() { print("Person eat") }
subscript(index: Int) -> Int { index }
}
var person: Person? = Person()
var age1 = person!.age() // Int
var age2 = person?.age() // Int?
var name = person?.name // String?
var index = person?[6] // Int?
如果可选值有值，那么调用就会成功；如果可选值是 nil，那么调用将返回 nil。
var dog = person?.dog // Dog?
var weight = person?.dog.weight // Int?
var price = person?.car?.price // Int?
多个调用可以连接在一起形成一个调用链，如果其中任何一个节点为 nil，整个调用链都会失败，即返回 nil。
var dog = person?.dog // Dog?
var weight = person?.dog.weight // Int?
var price = person?.car?.price // Int?
注意：Swift 的可选链式调用和 Objective-C 中向 nil 发送消息有些相像，但是 Swift 的可选链式调用可以应用于任意类型，并且能检查调用是否成功。
