实用的可选项（Optional）扩展
做者：terhechte，原文连接，原文日期：2018-01-10 译者：rsenjoyer；校对：numbbbbb，Yousanflics；定稿：Forelaxgit
可选值（Optional）是 Swift 语言最基础的内容。我想每一个人都赞成它带来了巨大的福音，由于它迫使开发者妥善处理边缘状况。可选值的语言特性能让发者在开发阶段发现并处理整个类别的 bug。github
然而，Swift 标准库中可选值的 API 至关的有限。若是忽略 customMirror 和 debugDescription 属性，Swift 文档 仅仅列出了几个方法/属性：数据库
var unsafelyUnwrapped: Wrapped { get }
func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U?
func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U?
复制代码
即便方法如此少，可选值仍然很是有用，这是由于 Swift 在语法上经过 可选链、模式匹配、if let 或 guard let 等功能来弥补它。但在某些状况下，可选值容易形成多分支条件。有时，一个很是简洁的方法一般容许你用一行代码表达某个概念，而不是用多行组合的 if let 语句。swift
我筛选了 Github 上的 Swift 项目以及 Rust、Scala 或 C＃ 等其余语言的可选实现，目的是为 Optional 找一些有用的补充。如下 14 个可选扩展，我将分类逐一解释，同时给每一个类别举几个例子。最后，我将编写一个更复杂的示例，它同时使用多个可选扩展。windows
判空（Emptiness）
extension Optional {
/// 可选值为空的时候返回 true
var isNone: Bool {
switch self {
case .none:
return true
case .some:
return false
}
}
/// 可选值非空返回 true
var isSome: Bool {
return !isNone
}
}
复制代码
这是对可选类型最基础的补充。我很喜欢这些补充，由于它们将可选项为空的概念从代码中移除了。在使用的细节上， 使用 optional.isSome 比 if optional == nil 更简洁明了。网络
// 使用前
guard leftButton != nil, rightButton != nil else { fatalError("Missing Interface Builder connections") }
// 使用后
guard leftButton.isSome, rightButton.isSome else { fatalError("Missing Interface Builder connections") }
复制代码
或（Or）
extension Optional {
/// 返回可选值或默认值
/// - 参数: 若是可选值为空，将会默认值
func or(_ default: Wrapped) -> Wrapped {
return self ?? `default`
}
/// 返回可选值或 `else` 表达式返回的值
/// 例如. optional.or(else: print("Arrr"))
func or(else: @autoclosure () -> Wrapped) -> Wrapped {
return self ?? `else`()
}
/// 返回可选值或者 `else` 闭包返回的值
// 例如. optional.or(else: {
/// ... do a lot of stuff
/// })
func or(else: () -> Wrapped) -> Wrapped {
return self ?? `else`()
}
/// 当可选值不为空时，返回可选值
/// 若是为空，抛出异常
func or(throw exception: Error) throws -> Wrapped {
guard let unwrapped = self else { throw exception }
return unwrapped
}
}
extension Optional where Wrapped == Error {
/// 当可选值不为空时，执行 `else`
func or(_ else: (Error) -> Void) {
guard let error = self else { return }
`else`(error)
}
}
复制代码
isNone / isSome 的另外一个抽象概念是可以指定当变量不成立的时须要执行的指令。这能让咱们避免编写 if 或 guard 分支，而是将逻辑封装为一个易于理解的方法。闭包
这个概念很是的有用，它可在四个不一样功能中被定义。app
默认值（Default Value）
第一个扩展方法是返回可选值或者默认值：函数
let optional: Int? = nil
print(optional.or(10)) // 打印 10
复制代码
默认闭包（Default Closure）
默认闭包和默认值很是的类似，但它容许从闭包中返回默认值。性能
let optional: Int? = nil
optional.or(else: secretValue * 32)
复制代码
因为使用了 @autoclosure 参数, 咱们实际上使用的是默认闭包。使用默认值将会自动转换为返回值的闭包。然而，我倾向于将两个实现单独分开，由于它可让用户用更加复杂的逻辑编写闭包。
let cachedUserCount: Int? = nil
...
return cachedUserCount.or(else: {
let db = database()
db.prefetch()
guard db.failures.isEmpty else { return 0 }
return db.amountOfUsers
})
复制代码
当你对一个为空的可选值赋值的时候，使用 or 就是一个不错的选择。
if databaseController == nil {
databaseController = DatabaseController(config: config)
}
复制代码
上面的代码能够写的更加优雅:
databaseController = databaseController.or(DatabaseController(config: config)
复制代码
抛出异常（Throw an error）
这也是一个很是有用的补充，由于它将 Swift 中可选值与错误处理链接起来。根据项目中的代码，方法或函数经过返回一个为空的可选值（例如访问字典中不存在的键）时，抛出错误来表述这一无效的行为。将二者链接起来可以使代码更加清晰：
func buildCar() throws -> Car {
let tires = try machine1.createTires()
let windows = try machine2.createWindows()
guard let motor = externalMachine.deliverMotor() else {
throw MachineError.motor
}
let trunk = try machine3.createTrunk()
if let car = manufacturer.buildCar(tires, windows, motor, trunk) {
return car
} else {
throw MachineError.manufacturer
}
}
复制代码
在这个例子中，咱们经过调用内部及外部代码共同构建汽车对象，外部代码（external_machine 和 manufacturer）选择使用可选值而不是错误处理。这使得代码变得很复杂，咱们可以使用 or(throw:) 使函数可读性更高。
func build_car() throws -> Car {
let tires = try machine1.createTires()
let windows = try machine2.createWindows()
let motor = try externalMachine.deliverMotor().or(throw: MachineError.motor)
let trunk = try machine3.createTrunk()
return try manufacturer.buildCar(tires, windows, motor, trunk).or(throw: MachineError.manufacturer)
}
复制代码
错误处理（Handling Errors）
当代码中包含 Stijn Willems 在 Github 自由函数，上面抛出异常部分的代码变动加有用。感谢 Stijn Willems 的建议。
func should(_ do: () throws -> Void) -> Error? {
do {
try `do`()
return nil
} catch let error {
return error
}
}
复制代码
这个自由函数（可选的，可将它当作一个可选项的类方法）使用 do {} catch {} 块并返回一个错误。当且仅当 do 代码块捕捉到异常。如下面 Swift 代码为例：
do {
try throwingFunction()
} catch let error {
print(error)
}
复制代码
这是 Swift 中错误处理的基本原则之一，但它不够简单明了。使用上面的提供的函数，你可使代码变得足够简单。
should { try throwingFunction) }.or(print($0))
复制代码
我以为在不少状况下，这样进行错误处理效果更好。
变换（Map）
正如上面所见，map 和 flatMap 是 Swift 标准库在可选项上面提供的的所有方法。然而，在多数状况下，也能够对它们稍微改进使得更加通用。这有两个扩展 map 容许定义一个默认值，相似于上面 or 的实现方式：
extension Optional {
/// 可选值变换返回，若是可选值为空，则返回默认值
/// - 参数 fn: 映射值的闭包
/// - 参数 default: 可选值为空时，将做为返回值
func map<T>(_ fn: (Wrapped) throws -> T, default: T) rethrows -> T {
return try map(fn) ?? `default`
}
/// 可选值变换返回，若是可选值为空，则调用 `else` 闭包
/// - 参数 fn: 映射值的闭包
/// - 参数 else: The function to call if the optional is empty
func map<T>(_ fn: (Wrapped) throws -> T, else: () throws -> T) rethrows -> T {
return try map(fn) ?? `else`()
}
}
复制代码
第一个方法容许你将可选值 map 成一个新的类型 T. 若是可选值为空，你能够提供一个 T 类型的默认值：
let optional1: String? = "appventure"
let optional2: String? = nil
// 使用前
print(optional1.map({ $0.count }) ?? 0)
print(optional2.map({ $0.count }) ?? 0)
// 使用后
print(optional1.map({ $0.count }, default: 0)) // prints 10
print(optional2.map({ $0.count }, default: 0)) // prints 0
复制代码
这里改动很小，咱们不再须要使用 ?? 操做符，取而代之的是更能表达意图的 default 值。
第二个方法也与第一个很类似，主要区别在于它接受（再次）返回 T 类型的闭包，而不是使用一个默认值。这里有个简单的例子：
let optional: String? = nil
print(optional.map({ $0.count }, else: { "default".count })
复制代码
组合可选项（Combining Optionals）
这个类别包含了四个函数，容许你定义多个可选项之间的关系。
extension Optional {
/// 当可选值不为空时，解包并返回参数 `optional`
func and<B>(_ optional: B?) -> B? {
guard self != nil else { return nil }
return optional
}
/// 解包可选值，当可选值不为空时，执行 `then` 闭包，并返回执行结果
/// 容许你将多个可选项链接在一块儿
func and<T>(then: (Wrapped) throws -> T?) rethrows -> T? {
guard let unwrapped = self else { return nil }
return try then(unwrapped)
}
/// 将当前可选值与其余可选值组合在一块儿
/// 当且仅当两个可选值都不为空时组合成功，不然返回空
func zip2<A>(with other: Optional<A>) -> (Wrapped, A)? {
guard let first = self, let second = other else { return nil }
return (first, second)
}
/// 将当前可选值与其余可选值组合在一块儿
/// 当且仅当三个可选值都不为空时组合成功，不然返回空
func zip3<A, B>(with other: Optional<A>, another: Optional<B>) -> (Wrapped, A, B)? {
guard let first = self,
let second = other,
let third = another else { return nil }
return (first, second, third)
}
}
复制代码
上面的四个函数都以传入可选值当作参数，最终都返回一个可选值，然而，他们的实现方式彻底不一样。
依赖（Dependencies）
若一个可选值的解包仅做为另外一可选值解包的前提，and<B>(_ optional) 就显得很是使用：
// 使用前
if user != nil, let account = userAccount() ...
// 使用后
if let account = user.and(userAccount()) ...
复制代码
在上面的例子中，咱们对 user 的具体内容不感兴趣，可是要求在调用 userAccount 函数前保证它非空。虽然这种关系也可使用 user != nil，但我以为 and 使它们的意图更加清晰。
链式调用（Chaining）
and<T>(then:) 是另外一个很是有用的函数, 它将多个可选项连接起来，以便将可选项 A 的解包值当作可选项 B 的输入。咱们从一个简单的例子开始：
protocol UserDatabase {
func current() -> User?
func spouse(of user: User) -> User?
func father(of user: User) -> User?
func childrenCount(of user: User) -> Int
}
let database: UserDatabase = ...
// 思考以下关系该如何表达：
// Man -> Spouse -> Father -> Father -> Spouse -> children
// 使用前
let childrenCount: Int
if let user = database.current(),
let father1 = database.father(user),
let father2 = database.father(father1),
let spouse = database.spouse(father2),
let children = database.childrenCount(father2) {
childrenCount = children
} else {
childrenCount = 0
}
// 使用后
let children = database.current().and(then: { database.spouse($0) })
.and(then: { database.father($0) })
.and(then: { database.spouse($0) })
.and(then: { database.childrenCount($0) })
.or(0)
复制代码
使用 and(then) 函数对代码有很大的提高。首先，你不必声明临时变量名（user, father1, father2, spouse, children），其次，代码更加的简洁。并且，使用 or(0) 比 let childrenCount 可读性更好。
最后，原来的 Swift 代码很容易致使逻辑错误。也许你尚未注意到，但示例中存在一个 bug。在写那样的代码时，就很容易地引入复制粘贴错误。你观察到了么？
是的，children 属性应该由调用 database.childrenCount(spouse) 建立，但我写成了 database.childrenCount(father2)。很难发现这样的错误。使用 and(then:) 就容易发现这个错误，由于它使用的是变量 $0。
组合（Zipping）
这是现有 Swift 概念的另外一个扩展，zip 能够组合多个可选值，它们一块儿解包成功或解包失败。在上面的代码片断中，我提供了 zip2 与 zip3 函数，但你也能够命名为 zip22（好吧，也许对合理性和编译速度有一点点影响）。
// 正常示例
func buildProduct() -> Product? {
if let var1 = machine1.makeSomething(),
let var2 = machine2.makeAnotherThing(),
let var3 = machine3.createThing() {
return finalMachine.produce(var1, var2, var3)
} else {
return nil
}
}
// 使用扩展
func buildProduct() -> Product? {
return machine1.makeSomething()
.zip3(machine2.makeAnotherThing(), machine3.createThing())
.map { finalMachine.produce($0.1, $0.2, $0.3) }
}
复制代码
代码量更少，代码更清晰，更优雅。然而，也存一个缺点，就是更复杂了。读者必须了解并理解 zip 才能彻底掌握它。
On
extension Optional {
/// 当可选值不为空时，执行 `some` 闭包
func on(some: () throws -> Void) rethrows {
if self != nil { try some() }
}
/// 当可选值为空时，执行 `none` 闭包
func on(none: () throws -> Void) rethrows {
if self == nil { try none() }
}
}
复制代码
不论可选值是否为空，上面两个扩展都容许你执行一些额外的操做。与上面讨论过的方法相反，这两个方法忽略可选值。on(some:) 会在可选值不为空的时候执行闭包 some，可是闭包 some 不会获取可选项的值。
/// 若是用户不存在将登出
self.user.on(none: { AppCoordinator.shared.logout() })
/// 当用户不为空时，链接网络
self.user.on(some: { AppCoordinator.shared.unlock() })
复制代码
Various
extension Optional {
/// 可选值不为空且可选值知足 `predicate` 条件才返回，不然返回 `nil`
func filter(_ predicate: (Wrapped) -> Bool) -> Wrapped? {
guard let unwrapped = self,
predicate(unwrapped) else { return nil }
return self
}
/// 可选值不为空时返回，不然 crash
func expect(_ message: String) -> Wrapped {
guard let value = self else { fatalError(message) }
return value
}
}
复制代码
过滤（Filter）
这个方法相似于一个守护者同样，只有可选值知足 predicate 条件时才进行解包。好比说，咱们但愿全部的老用户都升级为高级帐户，以便与咱们保持更长久的联系。
// 仅会影响 id < 1000 的用户
// 正常写法
if let aUser = user, user.id < 1000 { aUser.upgradeToPremium() }
// 使用 `filter`
user.filter({ $0.id < 1000 })?.upgradeToPremium()
复制代码
在这里，user.filter 使用起来更加天然。此外，它的实现相似于 Swift 集合中的功能。
指望（Expect）
这是我最喜欢的功能之一。这是我从 Rush 语言中借鉴而来的。我试图避免强行解包代码库中的任何东西。相似于隐式解包可选项。
然而，当在项目中使用可视化界面构建 UI 时，下面的这种方式很常见：
func updateLabel() {
guard let label = valueLabel else {
fatalError("valueLabel not connected in IB")
}
label.text = state.title
}
复制代码
显然，另外一种方式是强制解包 label, 这么作可能会形成应用程序崩溃相似于 fatalError。 然而，我必须插入 !, 当形成程序崩溃后，! 并不能给明确的错误信息。在这里，使用上面实现的 expect 函数就是一个更好的选择：
func updateLabel() {
valueLabel.expect("valueLabel not connected in IB").text = state.title
}
复制代码
示例（Example）
至此咱们已经实现了一系列很是有用的可选项扩展。我将会给出个综合示例，以便更好的了解如何组合使用这些扩展。首先，咱们须要先说明一下这个示例，原谅我使用这个不太恰当的例子：
假如你是为 80 年代的软件商工做。每月都有不少的人为你编写应用软件和游戏。你须要追踪销售量，你从会计那里收到一个 XML 文件，你须要进行解析并将结果存入到数据库中（若是在 80 年代就有 Swift 语言 以及 XML，这将是多么奇妙）。你的软件系统有一个XML解析器和一个数据库（固然都是用6502 ASM编写的），它们实现了如下协议：
protocol XMLImportNode {
func firstChild(with tag: String) -> XMLImportNode?
func children(with tag: String) -> [XMLImportNode]
func attribute(with name: String) -> String?
}
typealias DatabaseUser = String
typealias DatabaseSoftware = String
protocol Database {
func user(for id: String) throws -> DatabaseUser
func software(for id: String) throws -> DatabaseSoftware
func insertSoftware(user: DatabaseUser, name: String, id: String, type: String, amount: Int) throws
func updateSoftware(software: DatabaseSoftware, amount: Int) throws
}
复制代码
XML 文件可能看起来像这样：
<users>
<user name="" id="158">
<software>
<package type="game" name="Maniac Mansion" id="4332" amount="30" />
<package type="game" name="Doom" id="1337" amount="50" />
<package type="game" name="Warcraft 2" id="1000" amount="10" />
</software>
</user>
</users>
复制代码
解析 XML 的代码以下：
enum ParseError: Error {
case msg(String)
}
func parseGamesFromXML(from root: XMLImportNode, into database: Database) throws {
guard let users = root.firstChild(with: "users")?.children(with: "user") else {
throw ParseError.msg("No Users")
}
for user in users {
guard let software = user.firstChild(with: "software")?
.children(with: "package"),
let userId = user.attribute(with: "id"),
let dbUser = try? database.user(for: userId)
else { throw ParseError.msg("Invalid User") }
for package in software {
guard let type = package.attribute(with: "type"),
type == "game",
let name = package.attribute(with: "name"),
let softwareId = package.attribute(with: "id"),
let amountString = package.attribute(with: "amount")
else { throw ParseError.msg("Invalid Package") }
if let existing = try? database.software(for: softwareId) {
try database.updateSoftware(software: existing,
amount: Int(amountString) ?? 0)
} else {
try database.insertSoftware(user: dbUser, name: name,
id: softwareId,
type: type,
amount: Int(amountString) ?? 0)
}
}
}
}
复制代码
让咱们运用下上面学到的内容：
func parseGamesFromXML(from root: XMLImportNode, into database: Database) throws {
for user in try root.firstChild(with: "users")
.or(throw: ParseError.msg("No Users")).children(with: "user") {
let dbUser = try user.attribute(with: "id")
.and(then: { try? database.user(for: $0) })
.or(throw: ParseError.msg("Invalid User"))
for package in (user.firstChild(with: "software")?
.children(with: "package")).or([]) {
guard (package.attribute(with: "type")).filter({ $0 == "game" }).isSome
else { continue }
try package.attribute(with: "name")
.zip3(with: package.attribute(with: "id"),
another: package.attribute(with: "amount"))
.map({ (tuple) -> Void in
switch try? database.software(for: tuple.1) {
case let e?: try database.updateSoftware(software: e,
amount: Int(tuple.2).or(0))
default: try database.insertSoftware(user: dbUser, name: tuple.0,
id: tuple.1, type: "game",
amount: Int(tuple.2).or(0))
}
}, or: { throw ParseError.msg("Invalid Package") })
}
}
}
复制代码
若是咱们对比下，至少会有两点映入眼帘：
- 代码量更少
- 代码看起来更复杂了
在组合使用可选扩展时，我故意形成一种过载状态。其中的一部分使用很恰当，可是另外一部分却不那么合适。然而，使用扩展的关键不在于过分依赖（正如我上面作的那样），而在于这些扩展是否使语义更加清晰明了。比较上面的两个实现方式， 在第二个实现中，考虑下是使用 Swift 自己提供的功能好仍是使用可选扩展更佳。
这就是本文的所有内容，感谢阅读！
本文由 SwiftGG 翻译组翻译，已经得到做者翻译受权，最新文章请访问 swift.gg。
- 1. Optional 可选值
- 2. Node.js项目实践：构建可扩展的Web应用
- 3. 可扩展的 MySQL
- 4. 可扩展的ListView1
- 5. Swift中的可选类型（Optional）
- 6. IPv6扩展头部 (一) 扩展头部格式、类型与扩展选项
- 7. 可扩展性
- 8. VScode 扩展不可用
- 9. unity打包选项编辑器扩展
- 10. Java中可扩展性的实现
- 更多相关文章...
- • Kotlin 扩展 - Kotlin 教程
- • Swift 扩展 - Swift 教程
- • Git可视化极简易教程 — Git GUI使用方法
- • TiDB 在摩拜单车在线数据业务的应用和实践
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Optional 可选值
- 2. Node.js项目实践：构建可扩展的Web应用
- 3. 可扩展的 MySQL
- 4. 可扩展的ListView1
- 5. Swift中的可选类型（Optional）
- 6. IPv6扩展头部 (一) 扩展头部格式、类型与扩展选项
- 7. 可扩展性
- 8. VScode 扩展不可用
- 9. unity打包选项编辑器扩展
- 10. Java中可扩展性的实现