《Swift 进阶》可选值-读书笔记

本文是阅读了《Swift 进阶》 一书后，对平常接触不到的一些知识点的总结。因为最基础的知识不会在本文进行说明，因此比较适合使用 Swift 一段时间后的同学，初学者可以去看看 Swift 官方文档。

出现的初衷

在其它语言中，函数都返回了一个“魔法”数来表示并没有返回真实的值

存在的问题：

1. 返回的结果看起来像是真实的值
2. 使用它们需要前置知识，比如阅读文档

实现原理

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)

编译器提升了三种方法：

1. Provide a default value to avoid this warning：提供默认值
2. Force-unwrap the value to avoid this warning：强制解包
3. 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
}

隐式解包可选值

隐式解包可选值，虽然在使用的使用时候不用解包了，但其本质上仍然是一个可选。至于为什么要使用，有两个原因：

1. 保持和 Objective-C、C 的兼容性
2. 一个值只是很短暂地为 nil，在一段时间后就不再是 nil 了，比如 IBOutlet