Swift Day03 枚举 可选项

一、枚举

1. 枚举（enum）的基本写法？

//1. 定义一
enum Direction {
    case north
    case south
    case east
    case west
}
//2. 定义二
enum Direction2 {
    case north, south, east, west
}
//3. 使用枚举
var dir = Direction.west
dir = Direction.east
dir = .south
print(dir)

2. 枚举（enum）的关联值（Associated Value）？

• 有时会将枚举的成员值跟其他类型的值关联存储在一起，会非常有用

enum Score {
    case points(Int)
    case grade(Character)
}

var score = Score.points(96)
score = .grade("A")

switch score {
case let .points(i):
    print(i, "Points")
case let .grade(i):
    print("grade",i)
}

3. 枚举（enum）的原始值（Raw Values）？

• 枚举成员可以使用相同类型的默认值预先关联，这个默认值叫做：原始值

enum Grade : String {
    case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}

var studentGrade:Grade = .perfect
studentGrade = .good
print(studentGrade) // good
print(studentGrade.rawValue) // C

4. MemoryLayout 有什么用？

• MemoryLayout 可以帮助我们观察类型实例的占用内存大小情况
• MemoryLayout.size ：实际占用的内存大小（未进行内存对齐）
• MemoryLayout.stride ：分配的内存大小（已进行内存对齐）
• MemoryLayout.alignment ：该类型内存对齐的最小单位

//1.原始值
enum Grade : String {
    case perfect = "A"
    case great = "B"
    case good = "C"
    case bad = "D"
}
MemoryLayout.size    //1
MemoryLayout.stride  //1
MemoryLayout.alignment //11

//2.关联值
enum Password {
    case number(Int, Int, Int, Int)
    case other
}
MemoryLayout.size    //33
MemoryLayout.stride  //40
MemoryLayout.alignment //8

5. 思考为什么原始值，无论是 Int 还是 String 都只需要一个字节就能存储枚举变量？

• 因为可以把 rawValue 看成一个方法，代码块中存储原始值就行了。实例中不需要

6. 思考 Password 的枚举变量，为什么 32 个字节不够呢？

• 因为需要额外的 1 个字节，用于标记是 number or other

二、可选项（Optional）

1. 可选项的基本概念

• 可选项，一般也叫可选类型，它允许将值设置为 nil
• 在类型名称后面加个问号 ? 来定义一个可选项
• 本质其实就是为了解决可能出现 nil 的情况

var name: String? = "Jack"
name = nil

var age: Int? // 如果可选项不赋予初始值,默认就是 nil
age = 10
age = nil

var array = [1, 15, 40, 29]
func get(_ index: Int) -> Int? {
    if index < 0 || index >= array.count {
        return nil
    }
    return array[index]
}
print(get(1)) //Optional(15)
print(get(-1)) //nil
print(get(4)) //nil

2. 什么是强制解包（Forced Unwrapped）？

解包

3. 什么是可选项绑定（Optional Binding） ？

• 不使用可选项绑定技术的解包获取数据

let number = Int("123") // number 的类型是 Int?
if number != nil {
    print("字符串转换整数成功: \(number!)")
} else {
    print("字符串转换整数失败")
}

• 使用可选项绑定技术获取数据

 if let number = Int("123") {
    print("字符串转换整数成功: \(number)")
    //number 是强制解包之后的 Int 值
    //number 作用域仅限于这个大括号
} else {
    print("字符串转换整数失败")
}

• 使用可选项绑定代码更加精简
• 我们通常使用可选项绑定来判断可选项是否包含值，如果包含就自动解包，把值赋给一个临时的常量 let 或者变量 var，并返回 true，否则返回 false

4. 通过下面的例子，加强认知可选项绑定（Optional Binding） ？

• 遍历下面的数组，将遇到的正数都加起来，如果遇到负数或者非数字，停止变量
• var strs = ["10", "20", "abc", "-20", "30"]

var strs = ["10", "20", "abc", "-20", "30"]
var index = 0
var total = 0
while let number = Int(strs[index]), number > 0 {
    total += number
    index += 1
}
print(total) // 30

5. 空合并运算符 ?? （Nil-Coalescing Operator）

public func ?? (optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?
public func ?? (optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T

• a ?? b
• a 是可选项
• b 是可选项 或者 不是可选项
• b 跟 a 的存储类型必须相同
• 如果 a 不为 nil，就返回 a
• 如果 a 为 nil，就返回 b
• 如果 b 不是可选项，就返回 a 时会自动解包
• 总结：空合并运算符结果的类型取决于 b 的类型

var a: Int? = 10
var b = 2
let c = a ?? b // c 是 Int, 值是 10

var d: Int? = nil
var e: Int? = 2
let g = d ?? e // g 是 Int?, 值是 2

6. guard 语句（通常用在什么情况？）

• guard 语句特别适合用来 提前退出

guard 条件 else {
  //do something
  退出当前作用域
  // return、break、continue、throw error
}

• 当 guard 语句的条件为 false 时，就会执行大括号里面的代码
• 当 guard 语句的条件为 true 时，就会跳过 guard 语句
• 当 guard 语句进行可选项绑定时，绑定的常量 let、变量 var 也能在外层作用域中使用

7. 隐式解包（Implicitly Unwrapped Optional）

• 比较少用，了解即可，如果非要用，还不如直接用非可选项类型
• 大致用法如下，可自动解包，但是保证非 nil

let num1: Int! = 10
let num2: Int = num1
if num1 != nil {
    print(num1 + 6) //直接使用，不需要解包
}
if let num3 = num1 {
    print(num3)
}

8. 可选项在字符串插值或者直接打印时，编译器会发出警告，如何解决？（3 种思路）

• 问题代码如下：

var age: Int? = 10
print("My age is\(age)")

• 至少有 3 种方法消除警告

var age: Int? = 10
print("My age is\(age!)")
print("My age is\(age ?? 0)")
print("My age is\(String(describing: age))")

9. 多重可选项，以及如何查看多重可选项结构？

image.png