swift 学习- 19 -- 可选链式调用

// 可选链式调用 是一种在当前值可能为 nil 的可选值上请求 和 调用属性, 方法以及下标, 如果 可选值有值, 那么调用就会成功, 如果可选值是 nil, 那么就会将返回 nil ,

// 多个调用可以连接在一起形成一个调用链, 如果其中任何一个节点为 nil, 整个调用链都会失败, 即返回 nil.

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

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

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

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

// 特别地, 可选链式调用的返回结果与原来的返回结果具有相同的类型, 但是被包装成了一个可选值

// 下面极端代码将解释可选链式调用 和 强制展开的不同

//class Person{

//    var residence: ResidenceTwo?

//}

// Residence 有一个 Int 类型的属性 numberOfRooms, 其默认值为 1, Person 具有一个可选的 residence 属性,其类型为 Residence?

// 假如你创建了一个新的 Person 实例. 他的 residence 属性由于是是可选类型 而将初始化为 nil,

//let john = Person()

// 如果使用感叹号(!) 强制展开获得这个 john 的residence 属性中的 numberOfRooms, 会触发运行时错误, 因为这时 residence 没有可展开的值

// let roomCount = john.residence!.numberOfRooms

// 这会引发运行时错误

// john.residence 为 非 nil 的时候, 上面的调用会成功,并且把 roomCount 设置为 Int 类型的房间数量, 正如上面提到的, 当 residence 为 nil 的时候上面这段代码出触发运行时错误

// 可选链式调用提供了另一种访问 numberOfRooms 的方式, 使用问好(?) 来替代原来的叹号(!)

//if let roomCount = john.residence?.numberOfRooms {

//    print("John's residence has \(roomCount) room(s)")

//}else{

//    print("Unable to retrieve the number of rooms.")

//}

// 在 residene 后面添加问号 之后, Swift 就会在 residence 不为 nil 的情况下访问 numberOfRooms

// 因为访问 numberOfRooms 有可能失效, 可选链式调用会返回 Int? 类型, 或称为 可选的 Int, 如上栗所示, 当 residence 为 nil 的时候, 可选的 Int 将会为 nil , 表明无法访问 numberOfRooms, 访问成功时, 可选的Int 值会通过可选绑定展开, 并赋值给可选类型的 roomCount 常量

// 要注意的是, 即使 numberOfRooms 是非可选的 Int, 只要使用可选链式调用, 就意味着 numberOfRooms 会返回一个 Int? 而不是 Int

//john.residence = Residence.init()

// john.residence 现在包含一个实际的 Residence 实例, 而不是 nil, 如果你试图使用先前的可选链式调用访问 numberOfRooms, 它现在返回的值 为1 的Int? 类型的值

//if let roomCount = john.residence?.numberOfRooms {

//    print("john's room is \(roomCount)")

//}else{

//    print("none rooms")

//}

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

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

class Person{

var residence: ResidenceTwo?

}

class Room{

let name: String

init(name: String) {

self.name = name

}

}

class ResidenceTwo{

var rooms = [Room]()

var numberOfRooms: Int{

return rooms.count

}

subscript(i: Int) -> Room{

get{

return rooms[i]

}

set{

rooms[i] = newValue

}

}

func printNumberofRooms() {

print("The number of rooms is \(numberOfRooms)")

}

var address: Address?

}

// 现在 ResidenceTwo 有了一个 存储 Room 实例的数组, numberOfRooms 属性被实现为 计算型属性, 而不是存储型属性, numberOfRooms 属性简单地返回 rooms 数组的 count 属性的值

// ResidenceTwo 还提供了访问 rooms 数组的快捷方式, 即提供可读写的下标来访问 rooms 数组中指定位置的 元素

// 此外,ResidenceTwo 还提供了 printNumOfRooms 方法, 这个方法是打印 numberOfRooms 的值.

// 最后一个类是Address，这个类有三个String?类型的可选属性。buildingName以及buildingNumber属性分别表示某个大厦的名称和号码，第三个属性street表示大厦所在街道的名称：

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

}

}

}

// Address类提供了buildingIdentifier()方法，返回值为String?。 如果buildingName有值则返回buildingName。或者，如果buildingNumber和street均有值则返回buildingNumber。否则，返回nil。

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

// 正如 使用可选链式调用代替强制展开 中所述, 可以通过可选链式调用在一个可选值上访问他的属性, 并判断访问是否成功

let john2 = Person()

if let roomCount = john2.residence?.numberOfRooms {

print("John's residence has \(roomCount)")

}else{

print("none rooms")

}

// 因为 john2.residence 为 nil, 所以这个可选链式调用依旧会想先前一样失败

// 你可以通过可选链式调用来设置属性值

let someAddress = Address()

someAddress.buildingNumber = "29"

someAddress.street = "Acacia Road"

john2.residence?.address = someAddress

// 在这个例子中, 通过 john.residence 来设定 address 属性也会失败, 因为 john.residence 当前为 nil

// 上面代码中的赋值过程是可选链式调用的一部分, 这意味着可选链式调用失败时, 等号右侧的代码不会被执行,

func createAddress() -> Address{

print("Function was called")

let someAddress = Address()

someAddress.buildingNumber = "29"

someAddress.street = "Acacia Road"

return someAddress

}

john2.residence?.address = createAddress()

// 没有任何打印消息, 可以看出 creatAddress() 函数并未执行

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

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

// Residence类中的printNumberOfRooms()方法打印当前的numberOfRooms值，如下所示：

//  func printNumberOfRooms() {

//      print("The number of rooms is \(numberOfRooms)")

//  }

// 这个方法没有返回值, 然而, 没有返回值的方法具有隐式的返回类型 void. 如 无返回值的函数, 或者说 空的元组

// 如果在可选值上通过可选链式调用来调用这个方法, 该方法的返回类型会是 Void?, 而不是 Void. 因为通过可选链式调用得到的返回值都是可选的, 这样我们就可以 使用 if 语句来判断是否成功调用 printNumberOfRooms() 方法, 即使方法本身没有定义返回值, 通过判断返回值是否为 nil 可以判断调用是否成功

if john2.residence?.printNumberofRooms() != nil {

print("It was possible to print the number of rooms")

}else{

print("It was not possible to print the number of rooms")

}

// 同样的. 可以据此判断通过可选链式调用为属性赋值是否成功,

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

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

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

if let firstRoomName = john2.residence?[0].name {

print("The first room name is \(firstRoomName)")

}else{

print("Unable to retrieve the first room name")

}

// 在这个例子中. 问好直接放在 john.residence 的后面, 并且在方括号的前面, 因为 john.residence 是可选值. 类似的, 可以通过下标, 用可选链式调用来赋值

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

// 这次赋值同样会失败, 因为 residence ,目前是 nil

// 如果你创建一个 Residence 实例, 并为其 rooms 数组添加一些 Room 实例, 然后将 Residence 实例赋值给 john.residence ,那就可以通过可选链 和 下标来访问数组中的元素

let johnsHouse = ResidenceTwo.init()

johnsHouse.rooms.append(Room.init(name: "Living Room"))

johnsHouse.rooms.append(Room.init(name: "kitchen"))

john2.residence = johnsHouse

if let firsrRoomName = john2.residence?[0].name {

print(firsrRoomName)

}else{

print("none")

}

// 访问可选类型的下标

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

var testScores = ["Dave":[8,82,84],"Bev":[76,94,81]]

testScores["Dave"]?[0] = 91

testScores["Bev"]?[0] += 1

// 连接 多层可选链式调用

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

// 也就是说

// 如果你访问的值不是可选的, 可选链式调用将会返回可选值

// 如果你访问的值就是可选的, 可选链式调用不会让可选返回值变得 '更可选'

// 因此, 通过可选链式调用访问一个 Int 值, 将会返回 Int? 值, 无论使用了多少层可选链式调用

// 类似的, 通过可选链式调用访问 Int? 依旧会返回 Int? 值, 并不会返回 Int??

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

// 如果要在该方法的返回值上 进行可选链式调用, 在方法的圆括号后面 加上 问好

// 注意 : 在方法的圆括号 后面加上 问好 是因为你要在 方法的可选返回值上进行可选链式调用, 而不是方法本身