1. 概述

当某个可选值可能为空时，如果要访问它的属性、方法、下标脚本，需要使用Optional chaining 对它进行解包，然后进行访问。

如果这个可选值包含一个值，那么访问成功。

如果这个可选值为 nil ，那么访问返回nil。

多个访问可以组合在一起，成为一个访问链条，任何一个链条为nil，整个链条返回nil。

注意：Swift的 Optional Chaining 和 bjective-C 中的消息为空有些相像，但是Swift可以使用在任意类型中，并且失败与否可以被检测到。

2. 使用Optional Chaining代替强制拆包

如果某个可选值是 non-nil 的，你想访问它的属性、方法和下标脚本时，通过在可选值后面加上 (?) 指定为 Optional Chaining。这个与使用 (!) 对可选值进行强制拆包类似。主要不同点在于当可选值为 nil 时，如果使用 Optional Chaining ，那么返回 nil；如果使用强制拆包，那么将触发运行时错误。

为了反映 Optional Chaining 可以调用空（nil），不论你调用的属性、方法、下标脚本等返回的值是不是可选值类型，它的返回结果都是可选值类型。你可以利用这个返回值来检测你的Optional Chaining是否调用成功，有返回值即成功，返回nil则失败。

调用 Optional Chaining 的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个可选值类型，当 Optional Chaining 调用成功时，一个应该返回Int的属性将会返回Int？。

下面几段代码将解释自判断链接和强制拆包的不同。

    class Person {var residence: Residence?}class Residence {var numberOfRooms = 1}

如果你创建一个新的Person实例，它的residence属性由于是被定义为自判断型的，此属性将默认初始化为空：

let john = Person()

如果你想使用声明符！强制拆包获得这个人residence属性numberOfRooms属性值，将会引发运行时错误，因为这时没有可以供拆包的residence值。

    let roomCount = john.residence!.numberOfRooms// this triggers a runtime error

当john.residence不是nil时，会运行通过，且会将roomCount 设置为一个int类型的合理值。然而，如上所述，当residence为空时，这个代码将会导致运行时错误。

Optional Chaining 提供了一种另一种获得numberOfRooms的方法。利用Optional Chaining，使用 ？ 来代替原来 ！的位置：

    if let roomCount = john.residence?.numberOfRooms {println("John's residence has \(roomCount) room(s).")} else {println("Unable to retrieve the number of rooms.")}// prints "Unable to retrieve the number of rooms."

这告诉Swift来链接可选值类型的属性 residence？，如果residence存在则取回numberOfRooms的值。

因为访问 numberOfRooms 存在失败的可能性，所以Optional chaining 返回一个 Int? 类型的值。在上面的例子中，当residence为空时，Int? 也是nil。

虽然 numberOfRooms  不是Int? 类型，由于它在 Optional Chainning 中被访问，它将返回 Int? 类型，而不是 Int 类型。

你可以自己定义一个Residence实例给john.residence，这样它就不再为空了：

　　john.residence = Residence()

john.residence 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的 Optional Chainning 来获得 numberOfRoooms，它将返回一个包含默认值1的Int？：

    if let roomCount = john.residence?.numberOfRooms {println("John's residence has \(roomCount) room(s).")} else {println("Unable to retrieve the number of rooms.")}// prints "John's residence has 1 room(s)."

3. 为Optional Chainning定义一个模型类 Defining Model Classes for Optional Chaining

你可以使用 Optional Chainning 来调用多层的属性、方法和下标脚本。这让你可以利用它们之间的复杂模型来获取更底层的属性，并检查是否可以成功获取此类底层属性。

后面的代码定义了四个将在后面使用的模型类，其中包括多层 Optional Chainning 。这些类是由上面的Person和Residence模型通过添加一个Room和一个Address类拓展来。

Person类定义与之前相同：

    class Person {var residence: Residence?}

Residence类比之前复杂些。这次，它定义了一个变量 rooms，它被初始化为一个[Room]类型的空数组：

    class Residence {var rooms = [Room]()var numberOfRooms: Int {　　return rooms.count}subscript(i: Int) -> Room {get {return rooms[i]}set {rooms[i] = newValue}}func printNumberOfRooms() {println("The number of rooms is \(numberOfRooms)")}var address: Address?}

    class Room {let name: Stringinit(name: String) { self.name = name }}

    class Address {var buildingName: String?var buildingNumber: String?var street: String?func buildingIdentifier() -> String? {if buildingName != nil {return buildingName} else if buildingNumber != nil {return buildingNumber} else {return nil}}}

4.1. 通过Optional Chaning 访问属性 Accessing Properties Through Optional Chaining

如上所述，你可以使用 Optional Channing 访问可选值属性，并检查是否访问成功。

使用上述定义的类来创建一个 Person 实例，并尝试去f访问它的numberOfRooms属性：

    let john = Person()if let roomCount = john.residence?.numberOfRooms {println("John's residence has \(roomCount) room(s).")} else {println("Unable to retrieve the number of rooms.")}// prints "Unable to retrieve the number of rooms."

因为 john.residence 为nil，所以Optional Chaning 访问失败。

你可以尝试着通过 Optional Chaning 给属性赋值：

    let someAddress = Address()someAddress.buildingNumber = "29"someAddress.street = "Acacia Road"john.residence?.address = someAddress //给address的赋值将失败，因为john.residence为nil

4.2. 通过Optional Chaning 调用方法 Calling Methods Through Optional Chaining

你可以使用 Optional Chaning 调用一个可选值的方法，检查方法是否调用成功。即使这个方法没有返回值，你也可以这么做。

Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法如下：

    func printNumberOfRooms() {println("The number of rooms is \(numberOfRooms)")}

这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型Void（参见Function Without Return Values），这意味着它返回 ( )，或者说一个空的元祖。

如果你通过一个 Optional Chaning 调用这个方法，它将返回 Void?，而不是 Void，因为在 Optional Chaning 中返回值总是可选值类型。那么即使这个方法本身没有定义返回值，你也可以将它与 nil 进行比较检查它是否调用成功：

    if john.residence?.printNumberOfRooms() != nil {println("It was possible to print the number of rooms.")} else {println("It was not possible to print the number of rooms.")}// prints "It was not possible to print the number of rooms."

这与给 Optional Chaning 中的属性赋值是一样的，任何通过给 Optional Chaning 中的属性赋值的表达式都返回 Void? 类型，让你可以将它与 nil 进行比较，检查赋值是否成功：

if (john.residence?.address = someAddress) != nil {println("It was possible to set the address.")
} else {println("It was not possible to set the address.")
}
// prints "It was not possible to set the address."

4.3. 通过 Optional Chaning 访问下标脚本 Accessing Subscripts Through Optional Chaining

你可以通过Optional Chaning来尝试从下标脚本获取值并检查下标脚本的调用是否成功。

注意：通过 (?) 表示使用 Optional Chaning 访问下标脚本，(?) 在 ([]) 之前，而不是之后！

    if let firstRoomName = john.residence?[0].name {println("The first room name is \(firstRoomName).")} else {println("Unable to retrieve the first room name.")}// prints "Unable to retrieve the first room name."

因为john.residence目前为nil，所以调用失败。

你也可以通过Optional Chaning给小标脚本赋值：

john.residence?[0] = Room(name: "Bathroom")

同样，赋值失败，因为john.residence为nil。

如果你创建一个Residence实例给john.residence，且在他的rooms数组中有一个或多个Room实例，那么你可以使用Optional Chaning通过Residence下标来获取在rooms数组中的实例了：

    let johnsHouse = Residence()johnsHouse.rooms.append(Room(name: "Living Room"))johnsHouse.rooms.append(Room(name: "Kitchen"))john.residence = johnsHouseif let firstRoomName = john.residence?[0].name {println("The first room name is \(firstRoomName).")} else {println("Unable to retrieve the first room name.")}// prints "The first room name is Living Room."

4.4. 访问可选值类型的下表脚本 Accessing Subscripts of Optional Type

如果下标返回可选值类型——比如键值对的Dictionary——将 ? 放在 [] 后使它加入 Optional Chaning：

    var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]testScores["Dave"]?[0] = 91   // 使用Optional Chaning 尝试将字典的”Dave“第一项赋值为91，赋值成功！testScores["Bev"]?[0]++ 　　  // 赋值成功testScores["Brian"]?[0] = 72  // 赋值失败，不存在 ”Brian“// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]

5. 连接多层链接 Linking Multiple Levels of Chaining

你可以将多层 Optional Chaning 连接在一起，访问更底层的属性、方法和下标。

• 1）如果你尝试获得的类型不是可选值类型，在Optional Chaning中，它会变为可选值类型。
• 2）如果你尝试获得的类型已经是可选值类型，它不会变的 “more optional”

也就是：

• 1）如果你通过 Optional Chaning 尝试获得 Int，总是返回 Int? ，不管经过了多少层。
• 2）如果你通过 Optional Chaning 尝试获得 Int?，总是返回 Int? ，不管经过了多少层。

下面的例子试图获取john的residence属性里的address的street属性。这里使用了两层 Optional Chaning 来联系residence和address属性，他们两者都是可选值类型：

    if let johnsStreet = john.residence?.address?.street {println("John's street name is \(johnsStreet).")} else {println("Unable to retrieve the address.")}// prints "Unable to retrieve the address."

john.residence的值现在包含一个Residence实例，然而john.residence.address现在是nil，因此john.residence?.address?.street调用失败。

从上面的例子发现，你试图获得street属性值。这个属性的类型是String?。因此尽管在可选值属性前使用了两层Optional Chaning，john.residence?.address?.street的返回值类型也是String?。

如果你为Address设定一个实例来作为john.residence.address的值，并为address的street属性设定一个实际值，你可以通过多层Optional Chaning来得到这个属性值：

    let johnsAddress = Address()johnsAddress.buildingName = "The Larches"johnsAddress.street = "Laurel Street"john.residence!.address = johnsAddressif let johnsStreet = john.residence?.address?.street {println("John's street name is \(johnsStreet).")} else {println("Unable to retrieve the address.")}// prints "John's street name is Laurel Street."

值得注意的是，“!”符的在定义address实例时的使用（john.residence.address）。john.residence属性是一个可选值类型，因此你需要在它获取address属性之前使用！拆包以获得它的实际值。

6. 链接可选返回值方法

上面介绍了如何使用 Optional Chaning 来访问可选值属性。你也可以使用 Optional Chaning 来调用返回值为可选值方法。

下面的例子通过 Optional Chaning 调用了Address类中的buildingIdentifier 方法。这个方法的返回值类型是String?。如上所述，这个方法在自判断链接调用后最终的返回值类型依然是String?：

    if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {println("John's building identifier is \(buildingIdentifier).")}// prints "John's building identifier is The Larches."

如果你还想进一步对方法返回值执行 Optional Chaning 链接，将Optional Chaning 问号符放在方法括号的后面：

    if let beginsWithThe = john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {if beginsWithThe {println("John's building identifier begins with \"The\".")} else {println("John's building identifier does not begin with \"The\".")}}// prints "John's building identifier begins with "The"."

注意： 在上面的例子中，你将 ? 放在括号后面是因为你想要进行Optional Chaning 的是 buildingIdentifier方法的返回值，不是buildingIdentifier方法本身。

参考：https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html#//apple_ref/doc/uid/TP40014097-CH21-ID245

http://c.biancheng.net/cpp/html/2286.html