Swift2.0语言教程之下标脚本

前端之家收集整理的这篇文章主要介绍了Swift2.0语言教程之下标脚本前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

Swift2.0语言教程之下标脚本

下标脚本

下标脚本是访问对象、集合或者序列的快速方式。开发者不需要调用实例特定的赋值和访问方法,就可以直接访问所需要的数值。例如在数组中,可以直接使用下标去访问或者修改数组中的某一个元素。代码如下:

  • import Foundation
  • var array=["One","Two","Three","Four","Five"]
  • print("访问元素:\(array[2])")
  • array[2]="Third"
  • print("访问修改后的元素:\(array[2])")

运行结果如下:

  • 访问元素:Three
  • 访问修改后的元素:Third

在Swift中,下标脚本也可以定义在类中。这样,开发者就可以像数组一样,快速访问类中的属性。本节将主要讲解类中如何使用下标脚本。

定义下标脚本

下标脚本通过subscript关键字进行定义,其定义形式如下:

  • subscript(名称1:数据类型,参数名称2:数据类型,…) ->返回值的数据类型{
  • get {
  • //返回与参数类型匹配的类型的值
  • }
  • set(参数名称) {
  • //执行赋值操作
  • }
  • }

注意:set参数名称必须和下标脚本定义的返回值类型相同,所以不为它指定数据类型。与计算属性相同,set后面如果没有声明参数,那么就使用默认的newValue。

【示例8-18】以下将在类中定义一个下标脚本,实现通过下标脚本获取某一属性的值。代码如下:

  • class NewClass{
  • var english:Int=0
  • var chinese:Int=0
  • var math:Int=0
  • //定义下标脚本
  • subscript(index:Int)->Int{
  • get{
  • switch index{
  • case 0:
  • return english
  • case 1:
  • return chinese
  • case 2:
  • return math
  • default:
  • return 0
  • }
  • }
  • set{
  • english=newValue
  • chinese=newValue
  • math=newValue
  • }
  • }
  • }

调用下标脚本

定义下标脚本后,就可以进行调用了,其调用形式如下:

  • 实例对象[参数1,参数2,…]

其中,[]和它里面的内容就代表了在类中定义的下标脚本。

使用下标脚本

下标脚本可以根据传入参数的不同,分为具有一个入参参数的下标脚本和具有多个入参参数的下标脚本。以下就是对这两个下标脚本在类中的使用。

1.具有一个传入参数的下标脚本

具有一个入参参数的下标脚本是最常见的。在集合以及字符串中使用的下标就是具有一个传入参数的下标脚本。

【示例8-19】以下程序通过使用下标脚本计算3门成绩的和。代码如下:

  • import Foundation
  • class score{
  • var english:Int=0
  • var chinese:Int=0
  • var math:Int=0
  • //定义下标脚本
  • subscript(index:Int)->Int{
  • get{
  • switch index{
  • case 0:
  • return english
  • case 1:
  • return chinese
  • case 2:
  • return math
  • default:
  • return 0
  • }
  • }
  • set{
  • english=newValue
  • chinese=newValue
  • math=newValue
  • }
  • }
  • }
  • var myscore=score()
  • var sum:Int=0
  • var i:Int=0
  • //遍历
  • for i=0;i<3;++i{
  • sum+=myscore[i]
  • }
  • print(sum)
  • //修改属性
  • myscore[0]=100
  • myscore[1]=90
  • myscore[2]=80
  • //遍历求和
  • for i=0;i<3;++i{
  • sum+=myscore[i]
  • }
  • print(sum)

运行结果如下所示:

  • 0
  • 240

注意:下标脚本可以和计算属性一样设置为读写或只读。以上的代码是读写的形式。只读的一般语法形式如下:

  • subscript(参数名称:数据类型) -> Int {
  • get{
  • //返回与参数匹配的Int类型的值
  • }
  • }
  • 可以简写为以下的形式:
  • subscript(参数名称:数据类型) -> Int {
  • //返回与参数匹配的Int类型的值
  • }

【示例8-20】以下就使用只读的形式实现使用下标访问属性值的功能代码如下:

  • import Foundation
  • class score{
  • var english:Int=50
  • var chinese:Int=100
  • var math:Int=30
  • //定义下标脚本
  • subscript(index:Int)->Int{
  • switch index{
  • case 0:
  • return english
  • case 1:
  • return chinese
  • case 2:
  • return math
  • default:
  • return 0
  • }
  • }
  • }
  • var myscore=score()
  • var sum:Int=0
  • var i:Int=0
  • //遍历输出属性
  • for i=0;i<3;++i{
  • print(myscore[i])
  • }

运行结果如下所示:

  • 50
  • 100
  • 30

2.具有多个参数的下标脚本

具有一个入参参数的下标脚本一般使用在多维维数组中。以下就是使用具有两个参数的下标为二维数组赋值。代码如下:

  • import Foundation
  • var value:Int=0
  • class NewClass{
  • var rows: Int = 0,columns: Int=0
  • var grid: [Double]
  • //初始化方法
  • init(rows: Int,columns: Int) {
  • self.rows = rows
  • self.columns = columns
  • grid = Array(count: rows * columns,repeatedValue: 0.0)
  • }
  • func indexIsValidForRow(row: Int,column: Int) -> Bool {
  • return row >= 0 && row < rows && column >= 0 && column < columns
  • }
  • //下标脚本
  • subscript(row: Int,column: Int) -> Double {
  • get {
  • assert(indexIsValidForRow(row,column: column),"Index out of range")
  • return grid[(row * columns) + column]
  • }
  • set {
  • assert(indexIsValidForRow(row,"Index out of range")
  • grid[(row * columns) + column] = newValue
  • }
  • }
  • }
  • var matrix = NewClass(rows: 2,columns: 2)
  • print("没有赋值前")
  • print(matrix[0,0])
  • print(matrix[0,1])
  • print(matrix[1,0])
  • print(matrix[1,1])
  • print("赋值后")
  • matrix[0,0]=1.0
  • matrix[0,1]=5.6
  • matrix[1,0]=2.4
  • matrix[1,1]=3.2
  • print(matrix[0,1])

运行结果如下所示:

  • 没有赋值前
  • 0.0
  • 0.0
  • 0.0
  • 0.0

赋值后

  • 1.0
  • 5.6
  • 2.4
  • 3.2

当然,下标脚本除了可以对访问对象以及对象中的属性外,还可以实现一些自定义功能,如以下的代码,此代码实现的功能是计算下标值和10的乘积。代码如下:

  • import Foundation
  • class NewClass{
  • var count1: Int=10
  • //定义下标脚本
  • subscript(index:Int) -> Int {
  • get {
  • var count=index*count1
  • return count
  • }
  • set(newvalue){
  • //执行赋值操作
  • count1=newvalue
  • }
  • }
  • }
  • let newClass=NewClass()
  • print(newClass.count1)
  • print(newClass[6])

运行结果如下:

  • 10
  • 60

本文选自:Swift2.0语言快速入门v3.0大学霸内部资料,转载请注明出处,尊重技术尊重IT人!

猜你在找的Swift相关文章