关于ios:在Swift开发中关于Optionals你需要知道的5件事译

Optionals 是 Swift 的外围，并且在第一个版本中就曾经存在；optional 润饰的值容许咱们在关注可能为 nil 值的时候书写整洁的代码。

如果你刚开始接触 Swift，那么你可能须要相熟在属性中增加？的语法；只有你相熟了这个语法你就能够从中受害，比方 extensions。

在咱们深刻理解 optionals 之前须要理解基本知识。

属性、办法、下标可能返回一个可选值，这个值可能不为 nil 可能为 nil。多个援用能够链接在一起，这称为可选链接。这是强制解包的另一种形式，稍后将对其进行更具体的解说。

上面的示例代码展现了自定义可选的 String 并且 print 字符数的可选链接。

let name: String? = "Antoine van der Lee"
print(name?.count ?? 0)

强制解包可选值可能返回一个存在的值或者是一个导致 runtime 运行时谬误的空值。

然而在咱们深刻理解强制解包之前，让咱们先来看看在没有强制的状况下解包可选值有哪些可能性。

在 Swift 中有很多办法能够解包可选值。你能够应用 guard 申明：

let name: String? = "Antoine van der Lee"
guard let unwrappedName = name else {return}
print(unwrappedName.count)

或者能够应用 if let 申明：

let name: String? = "Antoine van der Lee"
if let unwrappedName = name {print(unwrappedName.count)
}

或者你能够应用?? 运算符，也称为 nil 合并运算符。如果它存在，这种将会返回一个可选值或者比方上面自定义的默认值 0:

let name: String? = "Antoine van der Lee"
print(name?.count ?? 0)

能够在可选值前面应用! 进行强制解包。

var name: String? = "Antoine van der Lee"
print(name!.count)

当上述示例中的 name 变量设置为 nil 的时候它将导致致命的运行时谬误，比方上面这种谬误：

Fatal error: Unexpectedly found nil while unwrapping an Optional value

能够用上面的形式进行可选链：

struct BlogPost {let title: String?}

let post: BlogPost? = BlogPost(title: "Learning everything about optionals")
print(post?.title?.count ?? 0)

同时对 counts 应用强制解包：

let post: BlogPost? = BlogPost(title: "Learning everything about optionals")
print(post!.title!.count)

然而要留神如果你解包最初一个可选值，那么你依然将失去一个可选值；在上面的示例中，咱们仅仅解包 title 而不是 post；这就意味着如果 post 为 nil 的时候，那么咱们就不能获取到一个 title 值：

let post: BlogPost? = BlogPost(title: "Learning everything about optionals")
print(post?.title!.count) // Prints: Optional(35)

应用可选值最好的形式在默认的状况下最好不要应用！；一些人甚至倡议启用 force unwrapping SwiftLint rule；这将避免你援用更多不冀望的闪退。

然而有时候如果值为 nil 的时候，在编程谬误时应用强制解包也很好；因而在晚期的时候你能够通过调试强制解包帮你本人发现一个 bug。

很快乐晓得可选总体来说是枚举中的 2 种状况：

enum Optional<Wrapped> {
    /// The absence of a value.
    case none

    /// The presence of a value, stored as `Wrapped`.
    case some(Wrapped)
}

然而如果不应用.none，你将应用 nil 来示意缺失值。

思考到这一点，你还能够应用枚举将上述 name 变量定义为可选的：

let name = Optional.some("Antoine van der Lee")
print(name!.count)

或者你能够像切换一般枚举一样切换可选值：

func printName(_ name: String?) {
    switch name {case .some(let unwrappedValue):
        print("Name is \(unwrappedValue)")
    case .none:
        print("Name is nil")
    }
}

printName(nil) // Prints: "Name is nil"
printName("Antoine van der Lee") // Prints: "Name is Antoine van der Lee"

看看它的文档你会发现一个可选值附带了一些十分不便的办法；一个不错的示例就是 map 办法：

let sideLength: Int? = Int("20")
let possibleSquare = sideLength.map {$0 * $0}
print(possibleSquare) // Prints: "Optional(400)"

或者 flatMap 办法，在本例中该办法仅在失去至多 5 个字符的验证时才返回 name：

var name: String? = "Antoine van der Lee"
let validName = name.flatMap { name -> String? in
    guard name.count > 5 else {return nil}
    return name
}
print(validName) // Prints: "Optional("Antoine van der Lee")"

如果你想理解更多 map、flatMap 以及 compactMap，查看我的博客：<u>CompactMap vs flatMap: The differences explained</u>

你当初晓得一个可选被定义为一个枚举，你能猜到你能够为它写扩大

最常见的示例是扩大可选字符串并解决空值：

extension Optional where Wrapped == String {
    var orEmpty: String {return self ?? ""}
}

var name: String? = "Antoine van der Lee"
print(name.orEmpty) // Prints: "Antoine van der Lee"
name = nil
print(name.orEmpty) // Prints: ""

当你在写测试的时候，有一个很好的办法能够在不强制解包的状况下应用可选值；如果要应用强制解包，你可能会导致致命谬误，从而阻断所有测试的胜利。

如果可选值不蕴含值你能够应用 XCTUnwrap，它将会抛出异样：

func testBlogPostTitle() throws {let blogPost: BlogPost? = fetchSampleBlogPost()
    let unwrappedTitle = try XCTUnwrap(blogPost?.title, "Title should be set")
    XCTAssertEqual(unwrappedTitle, "Learning everything about optionals")
}

如果你有过编写 Objective- C 的教训，你可能会错过可选的协定办法。只管用 Swift 编写可选的协定办法有更好的形式，然而规范库中最常见的形式如下：

@objc protocol UITableViewDataSource : NSObjectProtocol {@objc optional func numberOfSections(in tableView: UITableView) -> Int

    // ...
}

上面容许你应用？调用办法：

let tableView = UITableView()
let numberOfSections = tableView.dataSource?.numberOfSections?(in: tableView)

尽管 SE-0230 – Flatten nested optionals resulting from‘try?’是删除嵌套可选的最常见起因之一，但它依然是一个重要的性能！

var name: String?? = "Antoine van der Lee"
print(name!!.count)

你解包了一个可选值依然会返回一个可选值，以前在晚期的 Swift 版本中应用 try？运算符就是这种状况。

一个常见的示例是当你应用蕴含可选值字典的时候：

let nameAndAges: [String:Int?] = ["Antoine van der Lee": 28]
let antoinesAge = nameAndAges["Antoine van der Lee"]
print(antoinesAge) // Prints: "Optional(Optional(28))"
print(antoinesAge!) // Prints: "Optional(28)"
print(antoinesAge!!) // Prints: "28"

你能够看到它基本上只须要应用一个额定的！或者是？。

当你在 Swift 中应用 optionals 的时候咱们涵盖了很多你须要晓得的常识；解包可选值从最根本的应用感叹号!! 到扩大可选枚举的高级实现。

本文翻译自原文：https://www.avanderlee.com/sw…

关于ios:在Swift开发中关于Optionals你需要知道的5件事译

在 Swift 中什么是可选值？

1. 在 Swift 中强制解包可选值

如何解包一个可选值

应用！强制解包可选值

链接解包

强制解包捕捉 erros 是可选值最好的形式

2. 可选是枚举中的 2 种状况

扩大中的可选

3. 为可选值编写单元测试

4. 可选的协定办法

5. 嵌套可选是一个重要的性能

总结