下标语法

一般配合 Switch 使用

类、结构体和枚举都可以定义下标，下标是用于访问集合、列表或序列的成员元素的快捷方式。例如，用下标访问一个Array实例中的元素可以写作someArr[index]，访问Dictionary实例中的元素可以写作someDict[key]。

使用subscript关键字定义下标，指定一个或多个输入参数和返回类型。与实例方法不同，要有 getter 方法，可以没有 setter 方法。

• subscript 中定义的返回值类型决定了
  • get 方法的返回值类型
  • set 方法中 newValue 的类型

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

• 只读属性的简化：删除get关键字及其大括号
• 设置参数标签(访问时必须带上标签)
• 可以接受多个参数，并且类型任意
• 下标可以是类型方法 static

class Sum {
    static subscript(index v1: Int, v2: Int) -> Int { v1+v2 }
}
// Sum[index: 10, 20]

• 以类或结构体为返回值: 结构体要实现 setter，类不实现 setter

class ClzPoint { var x = 0, y = 0 }
class ClzPointManager {
    var point = ClzPoint()
    subscript(index: Int) -> ClzPoint {
    // 以类为返回值，不写 setter，因为 getter 返回的是指针地址
    // 写 setter 相当于修改了指针的指向
        get { point }
    }
}
var cpm = ClzPointManager()
cpm[0].x = 11 // cmp[0] 调用 getter 拿到地址即可修改成员变量
cpm[0].y = 22


struct StructPoint { var x = 0, y = 0 }
class StructPointManager {
    var point = StructPoint()
    subscript(index: Int) -> StructPoint {
    // 以结构为返回值，需要写 setter，因为 getter 返回的是值对象
    // setter 是编译器优化，实现可以使我们修改结构体成功
        set { point = newValue }
        get { point }
    }
}

var spm = StructPointManager()
spm[0].x = 11
spm[0].y = 22

示例

class Student: NSObject {
    var name = ""
    var age = 10
    var height = 170
    subscript(index:Int) -> AnyObject{
        switch index {
        case 0: return name as AnyObject
        case 1: return age as AnyObject
        case 2: return height as AnyObject
        default: return name as AnyObject
        }
    }
}
//调用
let stu = Student()
stu.name = "海王"
print(stu[0])  //海王
print(stu[1])  //10
print(stu[2])  //170

/// 三维向量的结构体
struct Vector3 {
    var x: Double = 0.0
    var y: Double = 0.0
    var z: Double = 0.0
    // 新的关键字 subscript 理解成一个特殊的函数, 后面的参数可以随意指定, 这里下标访问可读可写
    subscript(index: Int) -> Double {
        get{
            switch index {
            case 0: return x
            case 1: return y
            case 2: return z
            default: fatalError("下标越界")
            }
        }
        set{  //set 里面的 newValue 的类型和函数的返回值类型是一致的
            switch index {
            case 0: x = newValue
            case 1: y = newValue
            case 2: z = newValue
            default: fatalError("下标越界")
            }
        }
    }
    // 这个下标访问只读
    subscript(axis: String) -> Double {
        switch axis {
        case "x","X": return x
        case "y","Y": return y
        case "z","Z": return z
        default: fatalError("非法下标")
        }
    }
}

class LearningViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        var v3 = Vector3(x: 1, y: 2, z: 3)
        //一般的访问形式是
        print("\(v3.x)    \(v3.y)    \(v3.z)")
        //现在我要和数组字典一样访问 array[0]
        print("\(v3[0])   \(v3[1])   \(v3[2])")
        print("\(v3["x"]) \(v3["y"])   \(v3["Z"])")
        v3[0] = 100;   print("\(v3[0])")
    }
}