一、枚举
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<Grade>.size：实际占用的内存大小（未进行内存对齐） -
MemoryLayout<Grade>.stride：分配的内存大小（已进行内存对齐） -
MemoryLayout<Grade>.alignment：该类型内存对齐的最小单位
//1.原始值
enum Grade : String {
case perfect = "A"
case great = "B"
case good = "C"
case bad = "D"
}
MemoryLayout<Grade>.size //1
MemoryLayout<Grade>.stride //1
MemoryLayout<Grade>.alignment //11
//2.关联值
enum Password {
case number(Int, Int, Int, Int)
case other
}
MemoryLayout<Password>.size //33
MemoryLayout<Password>.stride //40
MemoryLayout<Password>.alignment //8
5. 思考为什么原始值，无论是 Int 还是 String 都只需要一个字节就能存储枚举变量？
- 因为可以把 rawValue 看成一个方法，代码块中存储原始值就行了。实例中不需要
6. 思考 Password 的枚举变量，为什么 32 个字节不够呢？
- 因为需要额外的 1 个字节，用于标记是
numberorother
二、可选项（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 ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?
public func ?? <T>(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
