The Swift Programming Language学习笔记(十八)——可选链式调
可选链式调用
注意,Swift的可选链式调用和Objective-C中向 使用可选链式调用代替强制展开通过在想调用的属性、方法、或下标的可选值(optional value)后面放一个问号( 为了反映可选链式调用可以在空值( 特别地,可选链式调用的返回结果与原本的返回结果具有相同的类型,但是被包装成了一个可选值。例如,使用可选链式调用访问属性,当可选链式调用成功时,如果属性原本的返回结果是 下面看看可选链式调用和强制展开的不同。 class Person {
var residence: Residence?
}
class Residence {
var numberOfRooms = 1
}
let p = Person()
// print(p.residence!.numberOfRooms) // 强制展开将触发运行时错误:fatal error: unexpectedly found nil while unwrapping an Optional value
print(p.residence?.numberOfRooms) // nil
if let count = p.residence?.numberOfRooms { // 使用可选绑定
print(count)
} else {
print("没有值") // 没有值
}
let p2 = Person()
p2.residence = Residence()
print(p2.residence?.numberOfRooms) // 返回可选类型:Optional(1)
if let count = p2.residence?.numberOfRooms { // 使用可选绑定
print(count) // 1
} else {
print("没有值")
}
为可选链式调用定义模型类通过使用可选链式调用可以调用多层属性、方法和下标。这样可以在复杂的模型中向下访问各种子属性,并且判断能否访问子属性的属性、方法或下标。 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("numberOfRooms = (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 && street != nil {
return "(buildingNumber) (street)"
} else {
return nil
}
}
}
通过可选链式调用访问属性可以通过可选链式调用在一个可选值上访问它的属性,并判断访问是否成功。还可以通过可选链式调用来设置属性值。 可选链式调用失败时,等号右侧的代码不会被执行。而实际上很难验证这一点,因为像这样赋值一个常量没有任何副作用。 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("numberOfRooms = (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 && street != nil {
return "(buildingNumber) (street)"
} else {
return nil
}
}
}
let p = Person()
if let count = p.residence?.numberOfRooms {
print("numberOfRooms = (count)")
} else {
print("numberOfRooms没有值") // numberOfRooms没有值
}
let a = Address()
a.buildingNumber = "29"
a.street = "Shengli Road"
p.residence?.address = a // 可选链式调用失败时,等号右侧的代码不会被执行。对于上面的代码来说,很难验证这一点,因为像这样赋值一个常量没有任何副作用。然而可选链式则可以通过if的可选绑定判断,并赋值。
print(p.residence?.address) // nil
// 下面使用等价的函数方法完成判断和赋值
func createAddress() -> Address {
print("Function was called")
let a = Address()
a.buildingNumber = "29"
a.street = "Shengli Road"
return a
}
p.residence?.address = createAddress() // 并没有打印Function was called
通过可选链式调用调用方法可以通过可选链式调用来调用方法,并判断是否调用成功,即使这个方法没有返回值。 没有返回值的方法具有隐式的返回类型 如果在可选值上通过可选链式调用来调用这个方法,该方法的返回类型会是 同样的,可以据此判断通过可选链式调用为属性赋值是否成功。属性赋值应该返回 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("numberOfRooms = (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 && street != nil {
return "(buildingNumber) (street)"
} else {
return nil
}
}
}
let p = Person()
var b = 2
print(b = 3) // (),表示返回Void
if p.residence?.printNumberOfRooms() != nil {
print("调用成功")
} else {
print("调用失败") // 调用失败
}
let a = Address()
a.buildingNumber = "29"
a.street = "Shengli Road"
if (p.residence?.address = a) != nil {
print("赋值成功")
} else {
print("赋值失败")
}
通过可选链式调用访问下标通过可选链式调用,我们可以在一个可选值上访问下标,并且判断下标调用是否成功。 注意,通过可选链式调用访问可选值的下标时,应该将问号放在下标方括号的前面而不是后面。可选链式调用的问号一般直接跟在 可以通过下标,用可选链式调用来赋值。 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("numberOfRooms = (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 && street != nil {
return "(buildingNumber) (street)"
} else {
return nil
}
}
}
let p = Person()
if let name = p.residence?[0].name {
print("下标调用成功,name = (name)")
} else {
print("下标调用失败") // 下标调用失败
}
if (p.residence?[0] = Room(name: "Bathroom")) != nil {
print("下标赋值成功")
} else {
print("下标赋值失败") // 下标赋值失败
}
访问可选类型的下标如果下标返回可选类型值,比如Swift中 var scores = ["Tim": [100,98,96],"Kate": [98,95,99]]
scores["Tim"]?[1] = 94
scores["Kate"]?[0]++
scores["Dog"]?[2] = 100
print(scores) // ["Kate": [99,99],"Tim": [100,94,96]]
连接多层可选链式调用可以通过连接多个可选链式调用在更深的模型层级中访问属性、方法以及下标。然而,多层可选链式调用不会增加返回值的可选层级。即
例如,
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("numberOfRooms = (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 && street != nil {
return "(buildingNumber) (street)"
} else {
return nil
}
}
}
let p = Person()
let r = Residence()
let a = Address()
a.buildingName = "White House"
a.buildingNumber = "00001"
a.street = "God Road"
r.address = a
p.residence = r // 直接赋值
print(p.residence?.address?.street) // Optional("God Road"),虽然进行了两层可选链式调用,但是Optional只有“一层”!
if let s = p.residence?.address?.street { // street没有值
print("street = (s)")
} else {
print("street没有值")
}
在方法的可选返回值上进行可选链式调用可以在一个可选值上通过可选链式调用来调用方法,并且可以根据需要继续在方法的可选返回值上进行可选链式调用。 如果要在该方法的返回值(不是方法本身!)上进行可选链式调用,在方法的圆括号后面加上问号即可。 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("numberOfRooms = (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 && street != nil {
return "(buildingNumber) (street)"
} else {
return nil
}
}
}
let p = Person()
let r = Residence()
let a = Address()
a.buildingName = "White House"
a.buildingNumber = "00001"
a.street = "God Road"
r.address = a
p.residence = r // 直接赋值
if let buildingIdentifier = p.residence?.address?.buildingIdentifier() {
print("buildingIdentifier = (buildingIdentifier)") // buildingIdentifier = White House
} else {
print("buildingIdentifier没有值")
}
print(p.residence?.address?.buildingIdentifier()?.hasPrefix("White")) // Optional(true),注意返回的一定是可选类型,所以下面不能直接判断,而必须进行可选绑定!
if let flag = p.residence?.address?.buildingIdentifier()?.hasPrefix("White") {
if flag {
print("has white") // has white
} else {
print("doesn't have white")
}
} else {
print("没有取到值")
}
(编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |