// 可選鏈?zhǔn)秸{(diào)用
//“可選鏈?zhǔn)秸{(diào)用是一種可以在當(dāng)前值可能為nil的可選值上請求和調(diào)用屬性、方法及下標(biāo)的方法。如果可選值有值，那么調(diào)用就會成功；如果可選值是nil，那么調(diào)用將返回nil。多個調(diào)用可以連接在一起形成一個調(diào)用鏈，如果其中任何一個節(jié)點為nil，整個調(diào)用鏈都會失敗，即返回nil。”
//“Swift 的可選鏈?zhǔn)秸{(diào)用和 Objective-C 中向nil發(fā)送消息有些相像，但是 Swift 的可選鏈?zhǔn)秸{(diào)用可以應(yīng)用于任意類型，并且能檢查調(diào)用是否成功”

//1.使用可選鏈?zhǔn)秸{(diào)用代替強(qiáng)制展開
//“通過在想調(diào)用的屬性、方法、或下標(biāo)的可選值后面放一個問號（?），可以定義一個可選鏈。這一點很像在可選值后面放一個嘆號（!）來強(qiáng)制展開它的值。它們的主要區(qū)別在于當(dāng)可選值為空時可選鏈?zhǔn)秸{(diào)用只會調(diào)用失敗，然而強(qiáng)制展開將會觸發(fā)運行時錯誤?！?br> //“為了反映可選鏈?zhǔn)秸{(diào)用可以在空值（nil）上調(diào)用的事實，不論這個調(diào)用的屬性、方法及下標(biāo)返回的值是不是可選值，它的返回結(jié)果都是一個可選值。你可以利用這個返回值來判斷你的可選鏈?zhǔn)秸{(diào)用是否調(diào)用成功，如果調(diào)用有返回值則說明調(diào)用成功，返回nil則說明調(diào)用失敗。”
//“特別地，可選鏈?zhǔn)秸{(diào)用的返回結(jié)果與原本的返回結(jié)果具有相同的類型，但是被包裝成了一個可選值。例如，使用可選鏈?zhǔn)秸{(diào)用訪問屬性，當(dāng)可選鏈?zhǔn)秸{(diào)用成功時，如果屬性原本的返回結(jié)果是Int類型，則會變?yōu)镮nt?類型?！?/p>

class Person {
    var residence: Residence?
}
class Residence{
    var numberOfRooms = 1
}
let john = Person()
//let roomCount = john.residence!.numberOfRooms
//強(qiáng)制展開值為nil的可選值會報運行時錯誤
if let roomCount = john.residence?.numberOfRooms {
    print("john's residence has \(roomCount) rooms")
}else{
    print("unable to retrieve the number of rooms")
}

//“在residence后面添加問號之后，Swift 就會在residence不為nil的情況下訪問numberOfRooms”
//“因為訪問numberOfRooms有可能失敗，可選鏈?zhǔn)秸{(diào)用會返回Int?類型，或稱為“可選的 Int”。如上例所示，當(dāng)residence為nil的時候，可選的Int將會為nil，表明無法訪問numberOfRooms。訪問成功時，可選的Int值會通過可選綁定展開，并賦值給非可選類型的roomCount常量。要注意的是，即使numberOfRooms是非可選的Int時，這一點也成立。只要使用可選鏈?zhǔn)秸{(diào)用就意味著numberOfRooms會返回一個Int?而不是Int?！?/p>

//2. 為可選鏈?zhǔn)秸{(diào)用定義模型類
//“通過使用可選鏈?zhǔn)秸{(diào)用可以調(diào)用多層屬性、方法和下標(biāo)。這樣可以在復(fù)雜的模型中向下訪問各種子屬性，并且判斷能否訪問子屬性的屬性、方法或下標(biāo)。”

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 TestResidence {
    var rooms = [Room]()
    var numberOfRoomsd:Int{
        return rooms.count
    }
    subscript(i:Int)->Room{
        get{
            return rooms[i]
        }
        set{
            rooms[i] = newValue
        }
    }
    func printNumberOfRooms(){
        print("the number of rooms is \(numberOfRoomsd)")
    }
    var address:Address?
}
class TestPerson {
    var testResidence : TestResidence?
}

//3. 通過可選鏈?zhǔn)秸{(diào)用訪問屬性

let johntatol = TestPerson()
if let roomCount = johntatol.testResidence?.numberOfRoomsd{
    print("johntatol's testResidence has \(roomCount) rooms")
}else{
    print("unable to retrieve the number of rooms")
}

//可以通過可選鏈?zhǔn)秸{(diào)用來設(shè)置屬性值

let someAddress = Address()
someAddress.buildingNumber = "29"
someAddress.street = "Acacia Road"
johntatol.testResidence?.address = someAddress

//“面代碼中的賦值過程是可選鏈?zhǔn)秸{(diào)用的一部分，這意味著可選鏈?zhǔn)秸{(diào)用失敗時，等號右側(cè)的代碼不會被執(zhí)行。對于上面的代碼來說，很難驗證這一點，因為像這樣賦值一個常量沒有任何副作用”

func creatAdress()->Address{
    print("Function was called")
    let someAdress = Address()
    someAdress.buildingNumber = "29"
    someAdress.street = "Acacia Road"
    return someAdress
}

johntatol.testResidence?.address = creatAdress()

// 沒有打印，function was called。說明creatAdress() 沒有被執(zhí)行。因為testResidence是nil的。

//4. 通過可選鏈?zhǔn)秸{(diào)用調(diào)用方法
//“可以通過可選鏈?zhǔn)秸{(diào)用來調(diào)用方法，并判斷是否調(diào)用成功，即使這個方法沒有返回值”
//“沒有返回值的方法具有隱式的返回類型Void，如無返回值函數(shù)中所述。這意味著沒有返回值的方法也會返回()，或者說空的元組“如果在可選值上通過可選鏈?zhǔn)秸{(diào)用來調(diào)用這個方法，該方法的返回類型會是Void?，而不是Void，因為通過可選鏈?zhǔn)秸{(diào)用得到的返回值都是可選的。這樣我們就可以使用if語句來判斷能否成功調(diào)用printNumberOfRooms()方法，即使方法本身沒有定義返回值。通過判斷返回值是否為nil可以判斷調(diào)用是否成功”

if johntatol.testResidence?.printNumberOfRooms() != nil {
    print("it was possible to print the rooms")
}else{
    print("it was not possible to print number of rooms")
}
//打印it was not possible to print number of rooms

//同樣，“可以據(jù)此判斷通過可選鏈?zhǔn)秸{(diào)用為屬性賦值是否成功”
if (johntatol.testResidence?.address = someAddress) != nil {
    print("可以賦值屬性")
}else{
    print("不能賦值屬性")
}
//打印不能賦值屬性

// 5. 可選鏈?zhǔn)秸{(diào)用訪問下標(biāo)
//“通過可選鏈?zhǔn)秸{(diào)用，我們可以在一個可選值上訪問下標(biāo)，并且判斷下標(biāo)調(diào)用是否成功”
//“注意 通過可選鏈?zhǔn)秸{(diào)用訪問可選值的下標(biāo)時，應(yīng)該將問號放在下標(biāo)方括號的前面而不是后面?？蛇x鏈?zhǔn)秸{(diào)用的問號一般直接跟在可選表達(dá)式的后面”

if let firstRoomName = johntatol.testResidence?[0].name {
    print("\(firstRoomName) 存在")
}else{
    print("不能獲得第一個房間的名字")
}
//打印 不能獲得第一個房間的名字
johntatol.testResidence?[0] = Room(name:"bathroom")
//賦值同樣會失敗，因為testResidence目前是nil

let johnsHouse = TestResidence()
johnsHouse.rooms.append(Room(name:"livingroom"))
johntatol.testResidence = johnsHouse
//可選值賦值不用使用？ 可選值的屬性方法調(diào)用賦值需要用？
if let anotherRoomName = johntatol.testResidence?[0].name {
    print("賦值成功了，\(anotherRoomName)")
}else{
    print("賦值失敗")
}
//打印 賦值成功了，livingroom

//“如果下標(biāo)返回可選類型值，比如 Swift 中Dictionary類型的鍵的下標(biāo)，可以在下標(biāo)的結(jié)尾括號后面放一個問號來在其可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用：

var testScores = ["dave":[98,90,80],"bev":[70,49,82]]
testScores["dave"]?[0] = 91
testScores["bev"]?[0] += 1
testScores["brian"]?[0] = 75
print("\(testScores)")
//打印 ["bev": [71, 49, 82], "dave": [91, 90, 80]]

//6. 連續(xù)多層的可選鏈?zhǔn)秸{(diào)用
//“可以通過連接多個可選鏈?zhǔn)秸{(diào)用在更深的模型層級中訪問屬性、方法以及下標(biāo)。然而，多層可選鏈?zhǔn)秸{(diào)用不會增加返回值的可選層級”
/*
“如果你訪問的值不是可選的，可選鏈?zhǔn)秸{(diào)用將會返回可選值。
如果你訪問的值就是可選的，可選鏈?zhǔn)秸{(diào)用不會讓可選返回值變得“更可選”。

因此：
通過可選鏈?zhǔn)秸{(diào)用訪問一個Int值，將會返回Int?，無論使用了多少層可選鏈?zhǔn)秸{(diào)用。
類似的，通過可選鏈?zhǔn)秸{(diào)用訪問Int?值，依舊會返回Int?值，并不會返回Int??。”

*/

if let jhonStress = johntatol.testResidence?.address?.street {
    print("jhon's stress name is \(jhonStress)")
}else{
    print("unable to retrieve the address")
}
let jhonAddress = Address()
jhonAddress.buildingName = "the larches"
jhonAddress.street = "laurel stress"
johntatol.testResidence?.address = jhonAddress
if let jhonstress = johntatol.testResidence?.address?.street {
    print("the stress is \(jhonstress)")
}else{
   print("can't to retrieve")
}
//打印 the stress is laurel stress  賦值成功

//7. “在方法的可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用”
//“我們還可以在一個可選值上通過可選鏈?zhǔn)秸{(diào)用來調(diào)用方法，并且可以根據(jù)需要繼續(xù)在方法的可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用”

if let buildingIdentifier = johntatol.testResidence?.address?.buildingIdentifier() {
    print("johntatol's builing identifier is \(buildingIdentifier)")
}
//打印johntatol's builing identifier is the larches

//“如果要在該方法的返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用，在方法的圓括號后面加上問號即可”

if let beginsWithThe = johntatol.testResidence?.address?.buildingIdentifier()?.hasPrefix("The"){
    if beginsWithThe {
        print("jhon's building identifier begins with \"The\"...")
    }else{
        print("jhon's building identifier does not beging with \"The\"...")
    }
}else{
    print("can't reach ,the optional return nil")
}
//打印jhon's building identifier does not beging with "The"...

//“在方法的圓括號后面加上問號是因為你要在buildingIdentifier()方法的可選返回值上進(jìn)行可選鏈?zhǔn)秸{(diào)用，而不是方法本身?！?/p>