Swift 下标脚本

前言

• 在访问一个数组实例的元素时，可以使用 Array[index] 的形式。在访问一个字典实例的元素时，可以使用 Dictionary[index] 的形式。这种方括号的形式就是 “下标脚本”。

• 下标脚本就是对一个东西通过索引，快速取值的一种语法，在 Swift 中，我们可以在类（Class）、结构体（structure）和枚举（enumeration）中自己定义下标脚本的语法。

• 下标脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。

1、下标脚本的定义

• 下标脚本定义需要关键字 subscript，与计算属性类似，下标脚本需要指定参数类型和返回值的类型。其一般格式为

  subscript(参数名1: 参数类型, 参数名2: 参数类型, ...) -> 返回类型 {
      
      get {
          // 返回类型声明中返回类型的值
      }
      
      set(newValue) {
          // 执行赋值操作
      }
  }

• 参数

  • 参数也可以使用可变参数，但使用输入/输出（in-out）参数或和给参数设置默认值都是不允许的。

• get 方法

  • 在下表脚本中可以定义 get 方法和 set 方法，其中 set 方法不是必须的。
  • 如果下标脚本中没有写 set 方法，则可以把 get 方法中的内容直接写到下标脚本的方法体中，从而省略外面的 get{}。

• set 方法

  • 在下表脚本中可以定义 get 方法和 set 方法，其中 set 方法不是必须的。
  • set 方法有一个默认的参数 newValue，用来表示传入的新值。
  • 即便不在参数列表中显示的写出 newValue，依旧可以在 set 方法中使用 newValue。
  • 可以在参数列表中写上其它名字以替换默认的参数名 newValue。

• 外部形参

  • 和方法不同的是，无论你的下标脚本中有多少个参数，如果没有指定外部参数名，那么在调用的时候参数名称都是隐藏的，如果你觉得表义不够明确，则可以像方法那样加上外部参数名。

    subscript(外部形参名1 本地形参名1: 参数类型, 外部形参名2 本地形参名2: 参数类型, ...) -> 返回类型 {
    
        get {
            // 返回类型声明中返回类型的值
        }
    
        set(newValue) {
            // 执行赋值操作
        }
    }

2、下标脚本的使用

2.1 一般格式

• 下标脚本的用法非常灵活，下标脚本的定义中，参数的数量、类型和返回值都可以是任意的。

• 定义

  struct myString {
          
      var str: String = ""
          
      subscript(start: Int, length: Int) -> String {
      
          get {
              let startIndex = str.index(str.startIndex, offsetBy: start)
              let endIndex = str.index(str.startIndex, offsetBy: start + length)
              
              return String(str[startIndex...endIndex])
          }
      
          set {           
              str = newValue
          }
      }
  }

• 使用

  let str1 = myString(str: "hello world")
  print(str1[0, 11])          // hello world
  
  let str2 = str1[2, 5]
  print(str2)                 // llo w
  
  var str3 = myString()
  str3[0, 0] = "world"
  print(str3[0, 5])           // world

2.2 重载格式

• 下标脚本支持重载，在调用时根据参数的不同而调用不同的下标脚本方法。

• 定义

  class Student1 {
      
      var scores: [Int] = Array(repeating: 0, count: 5)
      
      subscript(index: Int) -> Int {
      
          get {
              return scores[index];
          }
          set {
              scores[index] = newValue
          }
      }
      
      subscript(indexs: Int...) -> [Int] {
      
          get {
              var values: [Int] = Array()
              for index in indexs {
                  values.append(scores[index])
              }
              return values
          }
          set {
              var i = 0
              for index in indexs {
                  scores[index] = newValue[i]
                  i += 1
              }
          }
      }
  }

• 使用

  let stu1 = Student1()
  stu1[0] = 1
  stu1[1] = 2
  
  print("a[0]: \(stu1[0]), a[1]: \(stu1[1])")     // a[0]: 1, a[1]: 2
  
  let stu2 = Student1()
  stu2[1, 2, 3] = [5, 6, 7]
  
  print(stu2[0, 1, 2, 3, 4])                      // [0, 5, 6, 7, 0]