swift学习－可选链（十七）
可选(空)链式调用(Optional Chaining)
定义：是一种可以请求和调用属性、方法及下标的过程。
特性：可空性－调用目标有值则调用成功，目标为空（nil）调用将返回控(nil)。多个连续的调用可以背链接在一起形成一个调用链，
如果其中任何一个节点为空(nil)将导致整个链调用失败
使用可空链式调用来强制展开
通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。
这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，
然而强制展开将会触发运行时错误。
为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，
它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，
返回nil则说明调用失败。
特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，
一个本应该返回Int的类型的结果将会返回Int?类型
*/
class Person0 {
var residence :Residence0?
}
class Residence0 {
var numberOfRooms = 1
}
let john = Person0()
//let roomCount = john.residence!.numberOfRooms
//这里将触发运行错误
//在residence后面添加问号之后，Swift就会在residence不为空的情况下访问numberOfRooms。
//因为访问numberOfRooms有可能失败，可空链式调用会返回Int?类型，或称为“可空的Int”
if let roomCount = john.residence?.numberOfRooms {
print("John's resdience has \(roomCount) room(s).")
}else {
print("Unable to retrieve the number of rooms.")
}
//通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。
//并且判断能否访问子属性的属性，方法或下标。
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("The number of rooms is \(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 {
return buildingNumber
} else {
return nil
}
}
}
//可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。
let jack = Person()
if let roomCount = jack.residence?.numberOfRooms {
print("Jack's resdience has \(roomCount) room(s).")
}else {
print("Unable to retrieve the number of rooms.")
}
//prints "Unable to retrieve the number of rooms."
//因为jack.residence为nil，所以毫无疑问这个可空链式调用失败。
let someAddress = Address()
someAddress.buildingNumber = "10"
someAddress.street = "China Road"
jack.residence?.address = someAddress
//因为jack.residence为空赋值不可行
print(jack.residence?.address)//nil
/*通过可空链式调用来调用方法
可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
方法没有返回值。但是没有返回值的方法隐式返回Void类型，如无返回值函数中所述。
这意味着没有返回值的方法也会返回()或者空的元组。
如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为Void?，而不是Void，
因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用if语句来判断能否成功调用printNumberOfRooms()方法，
即使方法本身没有定义返回值。通过返回值是否为nil可以判断调用是否成功：
*/
if jack.residence?.printNumberOfRooms() != nil {
print("It was possible to print the number of romms.")
}else{
print("It was not possible to print the number of rooms")
}
//It was not possible to print the number of rooms
//通过可空链式调用给属性赋值会返回Void?，通过判断返回值是否为nil可以知道赋值是否成功：
if (jack.residence?.address = someAddress) != nil {
print("It was possible to set the address.")
}else {
print("It was not possible to set the address.")
}
//It was not possible to set the address.
/*通过可空链式调用来访问下标
通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。
注意： 当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。
可空链式调用的问号一般直接跟在可空表达式的后面。
*/
if let fristRoomName = jack.residence?[0].name {
print("The first room name is \(fristRoomName).")
}else{
print("Unable to retrieve the first room name.")
}
//Unable to retrieve the first room name.
//赋值 失败residence为空
jack.residence?[0] = Room(name: "Bathroom")
let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "Living Room"))
johnsHouse.rooms.append(Room(name: "Kitchen"))
jack.residence = johnsHouse
if let fristRoomName = jack.residence?[0].name {
print("The first room name is \(fristRoomName)")
}else{
print("Unable to retrieve the first room name")
}
//The first room name is Living Room
/*访问可空类型的下标：
如果下标返回可空类型值，比如Swift中Dictionary的key下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值：
*/
var testScores = ["Dave":[86,82,84], "Bev":[78,90,64]]
testScores["Dave"]?[0] = 91
testScores["Bev"]?[0]++
testScores["Brian"]?[0] = 72
print(testScores)
//["Bev": [79, 90, 64], "Dave": [91, 82, 84]]
多层链接
可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。
也就是说：
如果你访问的值不是可空的，通过可空链式调用将会放回可空值。
如果你访问的值已经是可空的，通过可空链式调用不会变得“更”可空。
因此：
通过可空链式调用访问一个Int值，将会返回Int?，不过进行了多少次可空链式调用。
类似的，通过可空链式调用访问Int?值，并不会变得更加可空。
if let jacksStreet = jack.residence?.address?.street {
print("jack's street name is \(jacksStreet)")
}else {
print("Unable to retrieve the address.")
}
//输出：Unable to retrieve the address.
//需要注意的是，上面的例子中，street的属性为String?。john.residence?.address?.street的返回值也依然是String?，
//即使已经进行了两次可空的链式调用。
let jacksAddress = Address()
jacksAddress.buildingName = "The larches"
jacksAddress.street = "laurel Street"
jack.residence?.address = jacksAddress
if let jacksStreet = jack.residence?.address?.street {
print("jack's street name is \(jacksStreet)")
}else {
print("Unable to retrieve the address.")
}
//输出：jack's street name is laurel Street
/*对返回可空值的函数进行链接
通过可空链式调用来调用Address的buildingIdentifier()方法。这个方法返回String?类型。
正如上面所说，通过可空链式调用的方法的最终返回值还是String?：
*/
if let buildingIndentifier = jack.residence?.address?.buildingIdentifier() {
print("jack's building indentifier is \(buildingIndentifier)")
}
//输出：jack's building indentifier is The larches
//如果要进一步对方法的返回值进行可空链式调用，在方法buildingIdentifier()的圆括号后面加上问号：
if let beginWithThe = jack.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
if beginWithThe {
print("Jack's building indentifier begins width \"The\".")
}else{
print("Jack's building indentifier does not begins width \"The\".")
}
}
//输出：Jack's building indentifier begins width "The".
//注意： 在上面的例子中在，在方法的圆括号后面加上问号是因为buildingIdentifier()的返回值是可空值，而不是方法本身是可空的。