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, column: column), "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,0])

• print(matrix[0,1])

• print(matrix[1,0])

• print(matrix[1,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人！