可选链式调用

可选链式调用

可选链式调用（Optional Chaining）是一种可以在当前值可能为nil的可选值上请求和调用属性、方法及下标的方法。如果可选值有值，那么调用就会成功；如果可选值是nil，那么调用将返回nil。多个调用可以连接在一起形成一个调用链，如果其中任何一个节点为nil，整个调用链都会失败，即返回nil。

注意，Swift的可选链式调用和Objective-C中向nil发送消息有些相像，但是Swift的可选链式调用可以应用于任意类型，并且能检查调用是否成功。

使用可选链式调用代替强制展开

通过在想调用的属性、方法、或下标的可选值（optional value）后面放一个问号（?），可以定义一个可选链。这一点很像在可选值后面放一个叹号（!）来强制展开它的值。它们的主要区别在于当可选值为空时可选链式调用只会调用失败，然而强制展开将会触发运行时错误。

为了反映可选链式调用可以在空值（nil）上调用的事实，不论这个调用的属性、方法及下标返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来判断你的可选链式调用是否调用成功，如果调用有返回值则说明调用成功，返回nil则说明调用失败。

特别地，可选链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可选值。例如，使用可选链式调用访问属性，当可选链式调用成功时，如果属性原本的返回结果是Int类型，则会变为Int?类型。

下面看看可选链式调用和强制展开的不同。

class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms = 1
}

let p = Person()
// print(p.residence!.numberOfRooms) // 强制展开将触发运行时错误：fatal error: unexpectedly found nil while unwrapping an Optional value
print(p.residence?.numberOfRooms)   // nil
if let count = p.residence?.numberOfRooms {     // 使用可选绑定
    print(count)
} else {
    print("没有值")    // 没有值
}

let p2 = Person()
p2.residence = Residence()
print(p2.residence?.numberOfRooms)      // 返回可选类型：Optional(1)
if let count = p2.residence?.numberOfRooms {     // 使用可选绑定
    print(count)        // 1
} else {
    print("没有值")
}

为可选链式调用定义模型类

通过使用可选链式调用可以调用多层属性、方法和下标。这样可以在复杂的模型中向下访问各种子属性，并且判断能否访问子属性的属性、方法或下标。

class Person {
    var residence: Residence?
}

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() {
        print("numberOfRooms = \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(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 && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}

通过可选链式调用访问属性

可以通过可选链式调用在一个可选值上访问它的属性，并判断访问是否成功。还可以通过可选链式调用来设置属性值。

可选链式调用失败时，等号右侧的代码不会被执行。而实际上很难验证这一点，因为像这样赋值一个常量没有任何副作用。

class Person {
    var residence: Residence?
}

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() {
        print("numberOfRooms = \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(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 && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}

let p = Person()
if let count = p.residence?.numberOfRooms {
    print("numberOfRooms = \(count)")
} else {
    print("numberOfRooms没有值")   // numberOfRooms没有值
}

let a = Address()
a.buildingNumber = "29"
a.street = "Shengli Road"
p.residence?.address = a    // 可选链式调用失败时，等号右侧的代码不会被执行。对于上面的代码来说，很难验证这一点，因为像这样赋值一个常量没有任何副作用。然而可选链式则可以通过if的可选绑定判断，并赋值。
print(p.residence?.address) // nil

// 下面使用等价的函数方法完成判断和赋值
func createAddress() -> Address {
    print("Function was called")
    let a = Address()
    a.buildingNumber = "29"
    a.street = "Shengli Road"
    return a
}
p.residence?.address = createAddress()  // 并没有打印Function was called

通过可选链式调用 调用 方法

可以通过可选链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。

没有返回值的方法具有隐式的返回类型Void，这意味着没有返回值的方法也会返回()，或者说空的元组。

如果在可选值上通过可选链式调用来调用这个方法，该方法的返回类型会是Void?，而不是Void，因为通过可选链式调用得到的返回值都是可选的。

同样的，可以据此判断通过可选链式调用为属性赋值是否成功。属性赋值应该返回()或Void。

class Person {
    var residence: Residence?
}

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() {
        print("numberOfRooms = \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(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 && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}

let p = Person()

var b = 2
print(b = 3)    // ()，表示返回Void

if p.residence?.printNumberOfRooms() != nil {
    print("调用成功")
} else {
    print("调用失败")   // 调用失败
}

let a = Address()
a.buildingNumber = "29"
a.street = "Shengli Road"

if (p.residence?.address = a) != nil {
    print("赋值成功")
} else {
    print("赋值失败")
}

通过可选链式调用访问下标

通过可选链式调用，我们可以在一个可选值上访问下标，并且判断下标调用是否成功。

注意，通过可选链式调用访问可选值的下标时，应该将问号放在下标方括号的前面而不是后面。可选链式调用的问号一般直接跟在可选表达式的后面。

可以通过下标，用可选链式调用来赋值。

class Person {
    var residence: Residence?
}

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() {
        print("numberOfRooms = \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(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 && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}

let p = Person()

if let name = p.residence?[0].name {
    print("下标调用成功，name = \(name)")
} else {
    print("下标调用失败")     // 下标调用失败
}

if (p.residence?[0] = Room(name: "Bathroom")) != nil {
    print("下标赋值成功")
} else {
    print("下标赋值失败")     // 下标赋值失败
}

访问可选类型的下标

如果下标返回可选类型值，比如Swift中Dictionary类型的键的下标，可以在下标的结尾括号后面放一个问号来在其可选返回值上进行可选链式调用

var scores = ["Tim": [100,98,96],"Kate": [98,95,99]]
scores["Tim"]?[1] = 94
scores["Kate"]?[0]++
scores["Dog"]?[2] = 100
print(scores)   // ["Kate": [99,99],"Tim": [100,94,96]]

连接多层可选链式调用

可以通过连接多个可选链式调用在更深的模型层级中访问属性、方法以及下标。然而，多层可选链式调用不会增加返回值的可选层级。即

如果你访问的值不是可选的，可选链式调用将会返回可选值。
如果你访问的值就是可选的，可选链式调用不会让可选返回值变得“更可选”。

例如，

通过可选链式调用访问一个Int值，将会返回Int?，无论使用了多少层可选链式调用。
类似地，通过可选链式调用访问Int?值，依旧会返回Int?值，并不会返回Int??。

class Person {
    var residence: Residence?
}

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() {
        print("numberOfRooms = \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(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 && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}

let p = Person()
let r = Residence()
let a = Address()
a.buildingName = "White House"
a.buildingNumber = "00001"
a.street = "God Road"
r.address = a
p.residence = r     // 直接赋值

print(p.residence?.address?.street)     // Optional("God Road")，虽然进行了两层可选链式调用，但是Optional只有“一层”！
if let s = p.residence?.address?.street {   // street没有值
    print("street = \(s)")
} else {
    print("street没有值")
}

在方法的可选返回值上进行可选链式调用

可以在一个可选值上通过可选链式调用来调用方法，并且可以根据需要继续在方法的可选返回值上进行可选链式调用。

如果要在该方法的返回值（不是方法本身！）上进行可选链式调用，在方法的圆括号后面加上问号即可。

class Person {
    var residence: Residence?
}

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() {
        print("numberOfRooms = \(numberOfRooms)")
    }
    var address: Address?
}

class Room {
    let name: String
    init(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 && street != nil {
            return "\(buildingNumber) \(street)"
        } else {
            return nil
        }
    }
}

let p = Person()
let r = Residence()
let a = Address()
a.buildingName = "White House"
a.buildingNumber = "00001"
a.street = "God Road"
r.address = a
p.residence = r     // 直接赋值

if let buildingIdentifier = p.residence?.address?.buildingIdentifier() {
    print("buildingIdentifier = \(buildingIdentifier)")     // buildingIdentifier = White House
} else {
    print("buildingIdentifier没有值")
}

print(p.residence?.address?.buildingIdentifier()?.hasPrefix("White"))   // Optional(true)，注意返回的一定是可选类型，所以下面不能直接判断，而必须进行可选绑定！
if let flag = p.residence?.address?.buildingIdentifier()?.hasPrefix("White") {
    if flag {
        print("has white")  // has white
    } else {
        print("doesn't have white")
    }
} else {
    print("没有取到值")
}

原文链接：/swift/324565.html

The Swift Programming Language学习笔记（十八）——可选链式调用