本文是阅读了《Swift 进阶》 一书后，对平常接触不到的一些知识点的总结。因为最基础的知识不会在本文进行说明，因此比较适合使用 Swift 一段时间后的同学，初学者可以去看看 Swift 官方文档。
出现的初衷
在其它语言中，函数都返回了一个“魔法”数来表示并没有返回真实的值
存在的问题：
- 返回的结果看起来像是真实的值
- 使用它们需要前置知识，比如阅读文档
实现原理
Swift 通过枚举实现了可选值 Optional
// Wrapped 表示可选值的实际类型
enum Optional<Wrapped> {
case none
case some(Wrapped)
}
ExpressibleByNilLiteral
如果按照上一节的写法，每次定义一个可选量的时候，需要写成
var maybeInt: Optional<Int> = .some(1)
maybeInt = .none
可以看到上面的写法比较繁琐，并且平时大家的写法也不是这样的，简洁的写法是
var maybeInt: Int? = 1
maybeInt = nil
这是因为 Optional 实际上还遵守 ExpressibleByNilLiteral 协议，因此可以使用 nil 替代 .none
if var and while var
除了 if let 这种平常常用的可选绑定方式外，其实还可以使用 var 和 if、while、for 来搭配使用，这样子就可以在语句块中改变变量。这里一般是针对值类型的变量，对引用类型来说没有意义。
// 值类型的可选值
let number = "1"
if var i = Int(number) {
i += 1
// 打印 2
print(i)
}
请注意，i 会是一个本地的复制，任何对 i 的改变都不会影响到原来的可选值。
nil 合并运算符
这个运算符的功能是在解包可选值的同时，为 nil 的情况设置一个默认值
let stringteger = "1"
let number = Int(stringteger) ?? 0
原理
// ?? 基本实现原理
func ??<T>(optional: T?, defaultValue: @autoclosure () -> T) -> T
// ?? 后面可以带自动闭包，属于懒加载形式。
// 注意：只有当 optionalInt 是 nil 时，才会执行自动避免
var optionalInt: Int?
let a = optionalInt ?? (1 + 2)
在字符串插值中使用可选值
在字符串插值时使用可选值，会存在如下情况：
var optionalInt: Int?
let label = UILabel()
// 编译器会报警告：String interpolation produces a debug description for an optional value; did you mean to make this explicit?
// 这是为了防止不小心把 Optional(...) 这样的内容展示给用户
label.text = "\(optionalInt)"
// 但是在调试的时候将值打印出来，同样会产生这样的情况，这是我们不希望的。
print(optionalInt)
编译器提升了三种方法：
- Provide a default value to avoid this warning：提供默认值
- Force-unwrap the value to avoid this warning：强制解包
- Explicitly cast to 'Any' with 'as Any' to silence this warning：转为 Any 类型
除此之外，还有两种方法
方法一：
var optionalInt: Int?
print(String(describing: optionalInt))
方法二：
/// 自定义运算符 ??? ，如果可选值为空的时候，提供默认的字符串显示
infix operator ???: NilCoalescingPrecedence
func ???<T>(optional: T?, defaultValue: @autoclosure () -> String) -> String {
switch optional {
case let value?: return String(describing: value)
case nil: return defaultValue()
}
}
var optionalInt: Int? = nil
print("OptionalInt is \(optionalInt ??? "n/a")")
flatMap
flatMap 可以将多重嵌套的可选值，展平为单个可选值。
let stringNumbers = ["1" , "2", "3", "foo"]
// x 类型是 Int??
let x = stringNumbers.first.map { Int($0) }
// y 类型是 Int？
let y = stringNumbers.first.flatMap { Int($0) }
compactMap
如果在序列中包含可选值，并且只对非 nil 值感兴趣的，可以使用 compactMap。
let numbers = ["1", "2", "3", "foo"]
// 想要求 Int 值的和
var sum = numbers.compactMap { Int($0) }.reduce(0, +)
// 输出 6
可选值判等
可选值判等，需要保证类型是遵守 Equatable 的。
extension Optional: Equatable where Wrapped: Equatable {
static func ==(lhs: Wrapped?, rhs: Wrapped?) -> Bool {
switch(lhs, rhs) {
case (nil, nil): return true
case let (x?, y?): return x == y
case (_?, nil), (nil, _?): return false
}
}
}
let regex = "^Hello$"
if regex.first == "^" {
print("匹配首字母是 ^")
}
上面代码存在一个疑问：regex.first 是 Character？ 类型，而 "^" 是 Character 类型，两者为什么能比较？
这是因为编译器会在需要时将非可选值转为可选值。这样子做的原因是可以大大简化我们的代码。再举个例子
var dic: [String: Int] = []
// 取值的时候，因为键有可能不存在，所以返回值是可选值
// 那么在使用 key，进行赋值的时候，其实也应该需要传入可选值
dic["someKey"] = Optional(1)
// 实际上，赋值是 1 即可，这也依赖于这个隐式转换
dic["someKey"] = 1
当使用下标操作作为字典的某个键赋值 nil 的时候，这个键会从字典中被移除
var dictWithNils: [String: Int?] = [
"one": 1,
"two": 2,
"none": nil
]
print("处理前 \(dictWithNils)")
dictWithNils["two"] = nil // ["one": Optional(1), "none": nil]
dictWithNils["two"] = Optional(nil) // ["one": Optional(1), "none": nil]
// 如果想把 value 置为 nil，请按照下面两种方式完成
dictWithNils["two"] = .some(nil) // ["one": Optional(1), "none": nil, "two": nil]
dictWithNils["two"]? = nil // ["one": Optional(1), "none": nil, "two": nil]
可选值比较
可选值原先曾拥有 <、>、<=、>= 等操作符。但在 Swift 3.0 中，全部被移除了。因为它们容易意外的结果发生。请看下面例子:
let temps = ["-232.1", "98.6", "warm"]
let belowFreezing = temps.filter { Double($0) < 0 }
Double("warm") 会返回 nil，而 nil 是小于 0，这样子会导致也被包含在 belowFreezing 里，这样子做肯定是我们不想要的。
使用强制解包的时机
尽量使用其他手段来避免使用强制解包，当你能确定你的某个值不可能是 nil 的时候，可以使用叹号。
func compactMap<B>(_ transform: (Element) -> B?) -> [B] {
return lazy.map(transform).filter { $0 != nil }.map {$0!}
}
这里因为 filter 运算符已经把所有 nil 过滤掉了，所以 map 的强制解包不会 crash。
改进强制解包的错误信息
直接使用强制解包，有个缺点，当 crash 发生时，你无法从 log 中知晓原因，这里可以自定义一个 !! 操作符：
infix operator !!
func !!<T>(wrapped: T?, failureText: @autoclsure () -> String) -> T {
if let x = wrapped { return x }
fatalError(failureText())
}
let s = "foo"
let i = Int(s) !! "Expecting integer, got \"\(s)"\"
在调试版本中进行断言
在对外发布版本中，让应用 crash 还是太粗暴了，最好的方法还是使用断言，这样保证只有在调试阶段，应用才会崩溃，其他时候会使用一个默认值。
func !?<T>(wrapped: T?, nilDefault: @autoclosure () -> (value: T, text: String)) -> T {
assert(wrapped != nil, nilDefault().text)
return wrapped ?? nilDefault().value
}
隐式解包可选值
隐式解包可选值，虽然在使用的使用时候不用解包了，但其本质上仍然是一个可选。至于为什么要使用，有两个原因：
- 保持和
Objective-C、C的兼容性 - 一个值只是很短暂地为 nil，在一段时间后就不再是 nil 了，比如 IBOutlet
