一、枚举

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 ，将枚举的相关值取出或许修改。

咱们再举一个相关值的运用场景，比如应用程序有输入暗码解锁的功用，而且能够运用暗码解锁和手势解锁，如图：

iOS-Swift 独孤九剑：五、枚举和可选项

根据需求咱们来界说一个枚举，如下：

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 个字节，那这些枚举成员在内存中是如何存储的呢？咱们经过读取枚举的成员的内存地址来看一下，如图：

iOS-Swift 独孤九剑：五、枚举和可选项

从图中咱们能够看出，在 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 的可选链式调用能够应用于任意类型，而且能查看调用是否成功。