// 可选链式调用 是一种在当前值可能为 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??
// 在方法的可选返回值上 进行可选链式调用
// 如果要在该方法的返回值上 进行可选链式调用, 在方法的圆括号后面 加上 问好
// 注意 : 在方法的圆括号 后面加上 问好 是因为你要在 方法的可选返回值上进行可选链式调用, 而不是方法本身