swift下标的基本用法 #3

访问数组的方法是 arry[index],访问字典的值为:dictionary[key], 这种方式获取值的方法就是下标的使用。

所有的swift类型(枚举 结构体 类)都支持下标的用法。下标可以作为访问对象、集合或序列的简化方式。

同一个类型可以定义多个下标,swift允许通过下标的形参列表或返回值类型类区分不同的下标,同一个类型中定义多个不同的下标被称为下标的重载。

举个栗子:

在结构体中的使用

//: Playground - noun: a place where people can play

struct FKRest{
    
    var x: Int
    var y: Int
    var height : Int
    var width : Int
    //定义下标,指定下标只能接受一个int类型的参数,下标的返回值类型为Int
    
    subscript( idx : Int )->Int {
        //定义下标的 get部分
        get{
            switch( idx ){
            case 0 :
                return self.x
            case 1:
                return self.y
            case 2:
                return self.height
            case 3:
                return self.width
            default:
                print("不支持该索引")
                return 0
            }
        }
        
        set{
            
            switch( idx ){
            case 0 :
                self.x = newValue
            case 1:
                self.y = newValue
            case 2:
                self.height  = newValue
            case 3:
                self.width  = newValue
            default:
                print("不支持该索引")
            }
        }
    }
}
var rect = FKRest(x:1,y:2,height:30,width:40)
rect[0] = 100
rect[1] = 200
print( "x:\(rect[0]),y:\(rect[1])" )



上面的实例就是通过下标对结构体的值进行访问和设置。(newValue是swift提供隐形的形参名)

如果希望只定义自读下标get部分代码,则可以省略set部门,包括省略get关键字。

代码如下:

//: Playground - noun: a place where people can play

struct FKRest{
    
    var x: Int
    var y: Int
    var height : Int
    var width : Int
    //定义下标,指定下标只能接受一个int类型的参数,下标的返回值类型为Int
    
    subscript( idx : Int )->Int {
        //定义下标的 get部分
    
            switch( idx ){
            case 0 :
                return self.x
            case 1:
                return self.y
            case 2:
                return self.height
            case 3:
                return self.width
            default:
                print("不支持该索引")
                return 0
            }
        
    }
}
var rect = FKRest(x:1,y:2,height:30,width:40)
//rect[0] = 100
//rect[1] = 200 只读下标这里就不能在进行下标赋值
print( "x:\(rect[0]),y:\(rect[1])" )


下标的重载

下标不仅可以接受一个Int类型的参数,实际上下标的形参列表与函数的形参大致相同,只是下标的形参列表不支持外部形参名和默认值而已。

一个类型可以包含多个下标,只要多个下标的形参列表不同(形参数量或形参类型不同)或返回值的类型不同即可,这种功能被称为下标的重载。

//: [Previous](@previous)

import Foundation


extension String{
    subscript (idx:Int)->String{
        
        get{
            var len = (self).characters.count
            if( idx > -1 && len < 10 ){
                var count = 0
                var result = ""
                for ch in self {
                    if(count==idx){
                        result = "\(ch)"
                    }
                    count = count+1
                }
                return result
            }else{
                return ""
            }
        }
        
        set{
            var result = ""
            var count = 0
            for ch in self{
                if(count==idx) {
                    result += newValue
                }else{
                    result += "\(ch)"
                }
                count = count+1
            }
            self = result
            
        }
        
        
    }
    subscript( start:Int, end:Int)->String{
        var len = (self).characters.count
        if( start >-1 && start<len && end >-1 && end<= len && start<end){
            var result = ""
            var count = 0
            for ch in self{
                if( count>= start && count<end ){
                    result += ch
                }
                count += 1
            }
        }else{
            return ""
        }
        
    }
}
var s = "xiaobai"

print(s[3])

s[0] = "e"
s[1] = "f"

print( s )

print(s[2,4])


注:extention 是 swift的关键字
一个下标是 int->String 一个是 int, int ->String 两个下标形参列表并不相同,siwft可以区分2个下标, 这种就是下标的重载