《Swift从入门到精通》（十四）：可选项响应链

可选项响应链

• 可选项响应链是一个用于访问和调用属性、方法、下标的过程，这些属性、方法、下标可能为 nil；如果有值就会调用成功，如果响应链中只要有一处为 nil，则整个链就会失败；Swift 中可选项响应链类似于 Objective-C 中传递消息 nil，但其可用于任何类型，并且可以检查成功不是失败。

可选项作为强制解包一种替代方案

• 示例

  class Person {
      var residence: Residence?
  }
  // 
  class Residence {
      var numberOfRooms = 1
  }
  let john = Person()
  let roomCount = john.residence!.numberOfRooms
  // this triggers a runtime error
  if let roomCount = john.residence?.numberOfRooms {
      print("John's residence has \(roomCount) room(s).")
  } else {
      print("Unable to retrieve the number of rooms.")
  }
  // Prints "Unable to retrieve the number of rooms."
  // 如果你给residence赋值，结果如下
  john.residence = Residence()
  if let roomCount = john.residence?.numberOfRooms {
      print("John's residence has \(roomCount) room(s).")
  } else {
      print("Unable to retrieve the number of rooms.")
  }
  // Prints "John's residence has 1 room(s)."
  
  

为可选项响应链定义模型类

• 示例代码块

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 let buildingNumber = buildingNumber, let street = street {
            return "\(buildingNumber) \(street)"
        } else if buildingName != nil {
            return buildingName
        } else {
            return nil
        }
    }
}

通过可选项访问属性

• 示例代码块

// 用上面创建的类
let john = Person()
if let roomCount = john.residence?.numberOfRooms {
    print("John's residence has \(roomCount) room(s).")
} else {
    print("Unable to retrieve the number of rooms.")
}
// Prints "Unable to retrieve the number of rooms."
// 通过响应链设置值
// 由于此之前并没有为residence设值，为nil，因此用someAddress赋值不会成功
let someAddress = Address()
someAddress.buildingNumber = "29"
someAddress.street = "Acacia Road"
john.residence?.address = someAddress
// 上面的情况不好观察，下面用函数会比较好观察
func createAddress() -> Address {
    print("Function was called.")
//
    let someAddress = Address()
    someAddress.buildingNumber = "29"
    someAddress.street = "Acacia Road"
//
    return someAddress
}
john.residence?.address = createAddress()
// 可以发现上面的 "Function was called."不会打印

通过可选项调用方法

• 示例代码块

// 本例中方法 printNumberOfRooms() 有一个隐式返回值 `Void` （或者 `()` 即空元组）
// 如果是可选的值调用，则返回的是 `Void?`，不是 `Void`
// 因此可以用 `if` 语句来判断方法是否调用成功
// 
if john.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.")
}
// Prints "It was not possible to print the number of rooms."
//
// 如果属性返回是 `Void?`，也可用同样的判断方法
if (john.residence?.address = someAddress) != nil {
    print("It was possible to set the address.")
} else {
    print("It was not possible to set the address.")
}
// Prints "It was not possible to set the address."

通过可选项访问下标

• ? 放在 [] 之前，总是紧跟表达式之后

if let firstRoomName = john.residence?[0].name {
    print("The first room name is \(firstRoomName).")
} else {
    print("Unable to retrieve the first room name.")
}
// Prints "Unable to retrieve the first room name."
// `?` 的执行是在紧跟 residence 之后， 在 `[]` 调用之前
john.residence?[0] = Room(name: "Bathroom")
// 上面的尝试赋值也会失败，因为 residence 仍然是 nil

let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "Living Room"))
johnsHouse.rooms.append(Room(name: "Kitchen"))
john.residence = johnsHouse
// 
if let firstRoomName = john.residence?[0].name {
    print("The first room name is \(firstRoomName).")
} else {
    print("Unable to retrieve the first room name.")
}
// Prints "The first room name is Living Room."

• 可选类型的下标访问，? 要写在 [] 之后

var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91
testScores["Bev"]?[0] += 1
testScores["Brian"]?[0] = 72
// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]

连接多层级的响应链

• 如果要获取的值不是可选项，但由于可选响应链，它将会成为可选项
• 如果要获取的值是可选项，也不会因为可选项响应链变成多层可选（类似：??, ???）

if let johnsStreet = john.residence?.address?.street {
    print("John's street name is \(johnsStreet).")
} else {
    print("Unable to retrieve the address.")
}
// Prints "Unable to retrieve the address."
// 如果你给 address 赋一个值
let johnsAddress = Address()
johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street"
john.residence?.address = johnsAddress
// 
if let johnsStreet = john.residence?.address?.street {
    print("John's street name is \(johnsStreet).")
} else {
    print("Unable to retrieve the address.")
}
// Prints "John's street name is Laurel Street."

方法返回可选项的响应链

• 示例代码块

if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
    print("John's building identifier is \(buildingIdentifier).")
}
// Prints "John's building identifier is The Larches."
// 要执行更深层的响应链，如下
if let beginsWithThe =
    john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
    if beginsWithThe {
        print("John's building identifier begins with \"The\".")
    } else {
        print("John's building identifier does not begin with \"The\".")
    }
}
// Prints "John's building identifier begins with "The"."
// 注意：`?` 是加在 `()` 之后因为返回值才是可选项，而不是方法名之后