您的位置:时时app平台注册网站 > 编程知识 > 斯威夫特语言中与C/C 和Java不相同的语法(四卡

斯威夫特语言中与C/C 和Java不相同的语法(四卡

2019-11-03 08:47

 

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?
}

当有三个重返值的时候能够选用元组作为再次回到类型

Room 类是三个洗练类,其实例被寄存在 rooms 数组中。该类只含有三个属性 name,以至二个用来将该属性设置为方便的屋家名的开端化函数:

亟待在意的是Void 的V是大写的,因为Void是一个品类。

在这里个事例中,问号直接放在 john.residence 的前面,况兼在方括号的前边,因为 john.residence 是可选值。 肖似的,能够由此下标,用可选链式调用来赋值:

func findMaxAndMin(numbers:[Int])->(maxValue:Int,minVlue:Int)?{
      guard numbers.count > 0 else{
      return nil
      }
  return (maxValue,minVlue)
}    

Person 类的定义基本保持不改变:

func sayHello (name:String) -> Void {

} 
或者
func sayHello (name:String) -> () {

} 
func createAddress() -> Address {
     print("Function was called.")
     let someAddress = Address()
     someAddress.buildingNumber = "29"
     someAddress.street = "Acacia Road"
     return someAddress
}
john.residence?.address = createAddress()

当函数未有重临值的时候能够那样写:

if let roomCount = john.residence?.numberOfRooms {
     print("John's residence has (roomCount) room(s).")
} else {
     print("Unable to retrieve the number of rooms.")
}
// 打印 “Unable to retrieve the number of rooms.”
func sayHello (name:String) -> String {
   return "Hello" name            
} 

采纳可选链式调用代替强制展开

func函数声明的关键字 
sayHello函数名 
(name:String)参数列表 
-> String函数的返回值
 {
   return "Hello" name函数体         
} 

上边包车型地铁代码创设了叁个 Person 实例,然后像在此之前相通,尝试访谈 numberOfRooms 属性:

在对函数举办调用的时候,全数的参数名都不得以归纳:

因为访谈 numberOfRooms 有希望停业,可选链式调用会重回 Int? 类型,或称为“可选的 *Int *”。如上例所示,当 residencenil 的时候,可选的 Int 将会为 nil ,阐明不只怕访谈 numberOfRooms 。访问成功时,可选的 Int 值会通过可选绑定张开,并赋值给非可选类型的 roomCount 常量。

率先是函数的创导:

这几个方法没有重临值。可是,未有再次来到值的点子具有隐式的归来类型 Void。那意味着未有重临值的措施也会回来 () ,也许说空的元组。

那黄金年代节,大家将会研商一下斯维夫特中的函数相关的宗旨内容

if let roomCount = john.residence?.numberOfRooms {
     print("John's residence has (roomCount) room(s).")
} else {
     print("Unable to retrieve the number of rooms.")
}
// 打印 “John's residence has 1 room(s).”
func findMaxAndMin(numbers:[Int])->(maxValue:Int,minVlue:Int){

  return (maxValue,minVlue)
}
let result = findMaxAndMin([1,2,3,4,5,6])
result.maxValue
result.minValue

Residence 还提供了访谈 rooms 数组的火速形式,即提供可读写的下标来访谈 rooms 数组中钦命地点的成分。其余,* Residence* 还提供了 printNumberOfRooms 方法,那个方法的作用是打字与印刷 numberOfRooms 的值。

上述就是函数的创设方法:

因为 john.residencenil ,所以那些可选链式调用还是会像在此以前同等没戏。

func sayHello (name:String, greeting:String) -> String {
   return name greeting            
}

sayHello(name:“PlayGround”, greeting:“Hello”)
如果在函数声明中用下划线代替:
func sayHello (name:String, _:String) -> String {
   return name greeting            
}
那么调用的时候可以省略
sayHello(name:“PlayGround”, “Hello”)

经过利用可选链式调用能够调用多层属性、方法和下标。那样能够在千头万绪的模子中向下访谈各样子属性,並且剖断能或无法访谈子属性的属性、方法或下标。

经过guard关键字打开决断,在可选型中我们早就讲过了

john.residence 为非 nil 值的时候,上边包车型地铁调用会成功,况兼把 roomCount 设置为 Int 类型的屋家数目。正如上 面提到的,当 residencenil 的时候上面这段代码会触发运营时不当。

重回值必要与评释中的再次回到值名称相像。

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.")
}
// 打印 “It was not possible to print the number of rooms.”

为了防止扩散的值为空,供给改为可选型:

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
         } 
     }
}

john.residence 今后含有叁个实在的 Residence 实例,而不再是 nil 。假设您希图动用早前的可选链式调用访谈 numberOfRooms ,它将来将再次来到值为 1Int? 类型的值:

注意
Swift 的可选链式调用和 Objective-C 中向 nil 发送音信有些相像,但是 Swift 的可选链式调用能够行使于自由档案的次序,而且能检查调用是否成功。

此外,Residence 还提供了 printNumberOfRooms 方法,那几个点子的效应是打字与印刷 numberOfRooms 的值。

经过可选链式调用访谈属性

此次赋值近似会退步,因为 residence 目前是 nil
设若你创设八个 Residence 实例,并为其 rooms 数组增多一些 Room 实例,然后将 Residence 实例赋值给 john.residence,那就足以经过可选链和下标来访问数组中的元素:

为可选链式调用定义模型类

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.")
}
// 打印 “Unable to retrieve the number of rooms.”

下边那些事例用下标访问 john.residence 属性存储的 Residence 实例的 rooms 数组中的第三个房间的名号,因为 john.residencenil ,所以下标调用退步了:

先是定义四个类 PersonResidence :

还足以经过可选链式调用来安装属性值:

可选链式调用 是风华正茂种可以在这里时此刻值大概为 nil 的可选值上呼吁和调用属性、方法及下标的主意。假使可选值有值,那么调用就能够中标;借使可选值是 nil ,那么调用将回到 nil 。几个调用能够三番两回在联合产生三个调用 链,倘使内部任何两个节点为 nil ,整个调用链都会停业,即重临 nil

能够透过可选链式调用来调用方法,并剖断是还是不是调用成功,固然那一个点子未有再次来到值。 Residence 类中的 printNumberOfRooms() 方法打字与印刷当前的 numberOfRooms 值,如下所示:

若是你创制了二个新的 Person 实例,它的 residence 属性由于是是可选型而将伊始化为 nil ,在底下的代码中, john 有二个值为 nilresidence 属性:

通过可选链式调用访谈下标

residence 后边增加问号之后,Swift 就会在 residence 不为 nil 的事态下访问 numberOfRooms

if (john.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.”

从没此外打字与印刷音讯,可以见见 createAddress() 函数并未有被施行。

能够由此可选链式调用在二个可选值上访谈它的品质,并认清访问是还是不是中标。

能够将二个 Residence 的实例赋给 john.residence ,那样它就不再是 nil 了:

class Room {
     let name: String
     init(name: String) { self.name = name }
}
class Person {
    var residence: Residence?
}

注意
由此可选链式调用访谈可选值的下标时,应该将问号放在下标方括号的前面并不是末端。可选链式调用的问号常常直接跟在可选表达式的末端。

john.residence?[0] = Room(name: "Bathroom") 

最后,Residence 还定义了二个可选属性 address,其品种为 Address?

let roomCount = john.residence!.numberOfRooms 
// 这会引发运行时错误

为了反映可选链式调用能够在空值( nil )上调用的实际,不论这些调用的习性、方法及下标重临的值是否可选值,它的回到结果都以叁个可选值。你能够行使那些重回值来判定你的可选链式调用是或不是调用成功,假设调用 有再次回到值则表明调用成功,重返 nil 则表明调用失利。

如出生机勃勃辙的,能够据此判别通过可选链式调用为属性赋值是不是中标。通过可选链式调用给属性赋值会重临 Void? ,通过判别再次来到值是还是不是为 nil 就足以通晓赋值是还是不是中标:

if let firstRoomName = john.residence?[0].name {
    print("The first room name is (firstRoomName).")
} else {
    print("Unable to retrieve the first room name.")
}
// 打印 “Unable to retrieve the first room name.”
class Person {
     var residence: Residence?
}
class Residence {
     var numberOfRooms = 1
}

现在 Residence 有了三个积存 Room 实例的数组,numberOfRooms 属性被实现为计算型属性,实际不是存款和储蓄型属性。 numberOfRooms 属性轻便地回到 rooms 数组的 count 属性的值。

因此可选链式调用,我们能够在一个可选值上访谈下标,并且推断下标调用是不是中标。

上边代码中的赋值进度是可选链式调用的后生可畏有个别,那表示可选链式调用失利时,等号侧边的代码不会被实行。对于地点的代码来讲,很难验证这点,因为像那样赋值三个常量未有其余副成效。下边包车型客车代码完结了平等 的工作,不过它应用多个函数来成立 Address 实例,然后将该实例重临用于赋值。该函数会在回到前打字与印刷“Funct ion was called”,那让你能印证等号左边的代码是或不是被施行。

经过可选链式调用调用方法

Residence 有一个 Int 类型的属性 numberOfRooms ,其暗中认可值为 1Person 具有一个可选的 residence 属性,其种类为 Residence?

在这里个事例中,通过 john.residence 来设定 address 属性也会战败,因为 john.residence 当前为 nil

Residence 类比从前复杂些,扩展了三个名称叫 rooms 的变量属性,该属性被开端化为 [Room] 类型的空数组:

可选链式调用提供了另风流倜傥种访问 numberOfRooms 的章程,使用问号( ? )来代替原先的叹号( ! ):

func printNumberOfRooms() {
    print("The number of rooms is (numberOfRooms)")
}

最后一个类是 Address,那几个类有八个 String? 类型的可选属性。buildingName 以及 buildingNumber 属性分别代表某些大厦的名称和号码,第1个属性 street 表示大厦所在大街的称号:

上面这段代码定义了多少个模型类,那么些事例包含多层可选链式调用。为了便于表明,在 PersonResidence 的底工上加码了 Room 类和 Address 类,以致有关的质量、方法以至下标。

Address 类提供了 buildingIdentifier() 方法,重返值为 String?,如果 buildingName 有值则赶回 buildingName。或者,如果 buildingNumberstreet 均有值则赶回 buildingNumber。否则,返回 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.")
}
// 打印 “The first room name is Living Room.”

纵然在可选值上通过可选链式调用来调用那一个办法,该情势的回来类型会是 Void? ,而不是 Void ,因为通过可选 链式调用获得的重返值都是可选的。那样咱们就能够使用 if 语句来决断能还是不能够打响调用 printNumberOfRooms() 方法,固然方法自个儿未有定义重临值。通过推断再次回到值是还是不是为 nil 能够判明调用是还是不是中标:

let someAddress = Address()
someAddress.buildingNumber = "29"
someAddress.street = "Acacia Road"
john.residence?.address = someAddress

要注意的是,即使 numberOfRooms 是非可选的 Int 时,那一点也树立。只要选择可选链式调用就意味着 numberOfRooms 会重临二个 Int? 而不是 Int

斯威夫特语言中与C/C 和Java不相同的语法(四卡塔 尔(英语:State of Qatar)。风姿浪漫旦使用叹号( ! )强制张开获得这几个 johnresidence 属性中的 numberOfRooms 值,会触发运营时不当,因为 这时候 residence 未有能够展开的值:

经过在想调用的性质、方法、或下标的可选值前边放四个问号( ? ),能够定义一个可选链。那点很像在可选 值前面放三个叹号( ! )来强制张开它的值。它们的基本点不同在于当可选值为空时可选链式调用只会调用失败,不过强制张开将会触发运营时不当。

非常地,可选链式调用的回来结果与原来的回来结果有所同等的档期的顺序,可是棉被服装进成了一个可选值。举例,使用 可选链式调用访谈属性,当可选链式调用成功时,借使属性原来的回到结果是 Int 类型,则会化为 Int? 类型。

let john = Person()
john.residence = Residence()
拜望可选类型的下标

设若下标重回可选类型值,比方 斯威夫特 中 类型的键的下标,能够在下标的结尾括号前边放二个问号 来在其可选再次来到值上开展可选链式调用:

var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91
testScores["Bev"]?[0]  = 1
testScores["Brian"]?[0] = 72
// "Dave" 数组现在是 [91, 82, 84],"Bev" 数组现在是 [80, 94, 81]

上边的例证中定义了三个 testScores 数组,富含了多少个键值对,把 String 类型的键映射到三个 Int 值得数组。那些事例用可选链式调用把 ”Dave“ 数组中的第八个因素设为 91,把 ”Bev“ 数组的第1个成分 1,然后尝试把 ”Brian“ 数组中的第二个因素设为 72。前八个调用成功,因为 testScores 字典中隐含 ”Dave“”Bev“ 那多个键。可是 testScores 字典中从不 ”Brian“ 那些键,所以第2个调用失利。

一而再接二连三多层可选链式调用

能够透过接连几日两个可选链式调用在更加深的模子层级中访谈属性、方法以致下标。可是,多层可选链式调用不会加多再次来到值的可选层级。

约等于说:

  • 只要你拜见的值不是可选的,可选链式调用将会回到可选值。
  • 设若您拜会的值正是可选的,可选链式调用不会让可选重回值变得“更可选”。

因此:

  • 透过可选链式调用访问叁个 Int 值,将会回来 Int? ,无论选用了不怎么层可选链式调用。
  • 相像的,通过可选链式调用访谈 Int? 值,依然会再次回到 Int? 值,并不会回去 Int??

下边包车型客车事例尝试访谈 john 中的 residence 属性中的 address 属性中的 street 属性。这里运用了两层可选链式调用, residence 以及 address 都以可选值:

if let johnsStreet = john.residence?.address?.street {
     print("John's street name is (johnsStreet).")
} else {
     print("Unable to retrieve the address.")
}
// 打印 “Unable to retrieve the address.”

john.residence斯威夫特语言中与C/C 和Java不相同的语法(四卡塔 尔(英语:State of Qatar)。 未来包括四个卓有效能的 Residence 实例。然而, john.residence.address 的值当前为 nil 。因此,调用 john.residence?.address?.street 会失败。

内需潜心的是,下边的事例中, street 的天性为 String?john.residence?.address?.street 的再次来到值也照例是 String? ,就算已经接受了两层可选链式调用。

如果为 john.residence.address 赋值二个 Address 实例,并且为 address 中的 street 属性设置二个平价值,咱们就能够过通过可选链式调用来访谈 street 属性:

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.")
}
// 打印 “John's street name is Laurel Street.”

在地点的事例中,因为 john.residence 富含三个卓有效率的 Residence 实例,所以对 john.residenceaddress 属性赋值将会水到渠成。

在议程的可选重回值上开展可选链式调用

上面的例证体现了哪些在三个可选值上经过可选链式调用来收获它的属性值。我们还能在八个可选值上通过可选链式调用来调用方法,並且能够依靠供给三番五次在点子的可选再次来到值上实行可选链式调用。

在底下的例子中,通过可选链式调用来调用 Address斯威夫特语言中与C/C 和Java不相同的语法(四卡塔 尔(英语:State of Qatar)。buildingIdentifier() 方法。这几个措施重返 String? 类型的值。如上所述,通过可选链式调用来调用该方法,最后的重临值还是会是 String? 类型:

if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
    print("John's building identifier is (buildingIdentifier).")
}
// 打印 “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".")
         } 
}
// 打印 “John's building identifier begins with "The".”

注意
在上边的事例中,在方式的圆括号前边加上问号是因为您要在 buildingIdentifier() 方法的可选再次回到值上展开可选链式调用,而不是艺术本人。

上面几段代码将表明可选链式调用和吓唬张开的比不上。

本文由时时app平台注册网站发布于编程知识,转载请注明出处:斯威夫特语言中与C/C 和Java不相同的语法(四卡

关键词: