Swift小知识点之 下标

前言

Swift中的Array或Dictionary类型可以通过下标或者键值对的方式来进行数据的访问。实际上在Swift的语法中，下标可以定义在类、结构体和枚举中，可以通过下标(subscript)的方式来对属性进行访问而不用使用专门的存取方法。对于定义的下标不限于一维，可以定义多维的下标来满足需求。

使用规则

• 使用subscript可以给任意类型（枚举、结构体、类）增加下标功能，有些地方也翻译为：下标脚本
• subscript的语法类似于实例方法、计算属性，本质就是方法（函数）
  例如下面的代码中，类Point中，的属性 x 和 y,可以用下标访问
  

  class Point {
      var x = 0.0, y = 0.0
      subscript(index: Int) -> Double {
          set {
              if index == 0 {
                  x = newValue
              } else if index == 1 {
                  y = newValue
              }
          }
          get {
              if index == 0 {
                  return x
              } else if index == 1 {
                  return y
              }
              return 0
          }
      }
  }

  访问的时候

  var p = Point()
  p[0] = 11.1
  p[1] = 22.2
  print(p.x) // 11.1
  print(p.y) // 22.2
  print(p[0]) // 11.1
  print(p[1]) // 22.2

注意点

• subscript中定义的返回值类型决定了
  • get方法的返回值类型
  • set方法中newValue的类型
• subscript可以接受多个参数，并且类型任意

下标语法

• 下标使用关键字subscript修饰，有些类似于方法，参数和返回值作为下标入参和通过下标获取的值。在subscript的实现部分，类似计算属性，需要实现getter方法和可选的setter方法，getter方法用于通过下标取值，setter方法用于通过下标设置值。下标语法看起来像计算属性和方法的混合体。

  subscript(index: Int) -> Int {
      get {
        // 返回一个适当的 Int 类型的值
      }
      set(newValue) {
        // 执行适当的赋值操作
      }
  }

• 通过getter方法实现只读的下标访问，与只读计算属性类似，可以通过删除getter关键字及其大括号来简化只读下标的声明

  class stringsOfText {
      var strArr = ["A", "B", "C", "D"]
      subscript(index: Int) -> String {
          return strArr[index]
      }
  }
  
  var str = stringsOfText()
  var string = str.strArr[1];
  print(string)

  结果:

  B

• 通过getter方法和setter方法实现的下标读写

  class Student {
      var name = ""
      var age = "";
      var hobby = ""
  
      subscript(index: Int) -> String {
          get {
              switch index {
              case 0:
                  return(name)
              case 1:
                  return(age)
              case 2:
                  return(hobby)
              default:
                  return "\(index)"
              }
          }
          set(newValue) {
              switch index {
              case 0:
                  name = newValue
              case 1:
                  age = newValue
              case 2:
                  hobby = newValue
              default:
                  print(newValue)
              }
          }
      }
  }
  
  var student = Student()
  student[0] = "li lei"
  student[1] = "18"
  student[2] = "play football"
  
  print("姓名:\(student.name)")
  print("年龄:\(student.age)")
  print("爱好:\(student.hobby)")

  结果:

  姓名:li lei
  年龄:18
  爱好:play football

下标选项

• Swift中的下标可以自定参数个数和参数类型，返回数据的类型也可以进行自定义。但是有一点需要注意，下标的参数不能设置默认值，也不能设置为in-out类型
  

  class SectionAndRow {
    var array:Array<Array<Int>> = [[1,2],
                                   [3,4],
                                   [5,6],
                                   [7,8]]
      
    subscript(section:Int,row:Int)->Int{
      get{
        let temp = array[section]
        return temp[row]
      }
    }
  }
  
  var data = SectionAndRow()
  //通过二维下标取值
  var value = data[2,1]
  print(value)

  结果

  6

类型下标

• 类型下标：定义在类型本身上调用的下标。
• 类型下标语法：可以把在static关键字放置在subscript之前用来表示类型下标。如果是类可以使用class关键字代替static，以允许子类覆盖超类对该下标的实现
  

  class Student {
      static var name = ""
      static var age = "";
      
      class subscript(index: Int) -> String {
          get {
              if index == 0 {
                  return(name)
              }else{
                  return(age)
              }
          }
          set(newValue) {
              if index == 0 {
                  name = newValue
              }else{
                  age = newValue
              }
          }
      }
  }
  
  Student[0] = "li lei"
  Student[1] = "18"
  
  print("姓名:\(Student.name)")
  print("年龄:\(Student.age)")

  结果:

  姓名:li lei
  年龄:18