swift2.0学习之拓展

拓展：和oc的拓展方法功能差不多，就是给已经存在的类，结构体，枚举，协议类型增加新的方法
拓展语法：
用extension关键字声明： @H_301_6@
 
 
  
   
    
    extension SomeType {@H_301_6@
 
    // new functionality to add to SomeType goes here@H_301_6@
 
    }@H_301_6@
 
   
 
  
 
 
 @H_301_6@拓展可以： 
 
（1）添加计算型属性和计算属性 
（2）提供新的构造器 
（3）定义实例方法和类型方法 
（4）定义下标 
（5）定义和使用嵌套类型 
(一)计算型属性 
 
extension Double {

    var km: Double { return self*1_000 }
    var m: Double { return self }
    var cm: Double { return self/100 }
    var mm: Double { return self/1_000 }
    var ft: Double { return self/3.28084 }
    
} 
        let oneInch = 25.4.km
        print("One inch is \(oneInch) meters")
        let threeFeet = 3.ft
        print("Three is \(threeFeet) meters") 

 （二）构造器 
 
 
struct Rect {
    var origin = Point()
    var size = Size()
}

extension Rect {
    init(center: Point,size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX,y: originY),size: size)
    }
}<pre name="code" class="plain">        var someInt = 5
        someInt.square()
        print(someInt) 

 
 
 

 
//        let defaultRect = Rect()
//        let memberwiseRect = Rect(origin: Point(x: 2.0,y: 2.0),size: Size(width: 3.0,height: 3.0))
        let centerRect = Rect(center: Point(x: 4.0,y: 4.0),height: 3.0))
        print("\(centerRect.origin),\(centerRect.size)") 

 （三）方法 
 
a.实例方法的栗子 
 
extension Int {
    func repetitions(task: () -> Void) {
        for _ in 0..<self {
            task()
        }
    }
    
} 
     3.repetitions({ print("hello!") }) 

 
 
b,改变实例方法 
extension修饰的实例方法可以改变实例本身，正如结构体和枚举，想改变自身的属性和方法，就必须在实例方法前面加mutating关键字，好像是从原始实现改变了方法一样 
 
extension Int {
    mutating func square() {
        self = self * self
    }
} 
        var someInt = 5
        someInt.square()
        print(someInt) 

 someInt.square()实例方法调用后，someInt实例本身发生了改变 
 
（四）下标 
拓展可以给已经存在的类型增加下标。下面通过一个Int型栗子给其添加内联下标，这个下标所取的值是从数字右边开始算起的 
比如12345[0]返回的值是5 
这个算法就是取这个数字某一位上的数，取个位数的话直接%10就好，取十位上的数就是先除10在%10，取百位上的数就是先/100再%10，等等。。。 
所以拓展代码是： 
 
extension Int {

    subscript(var digitIndex: Int) -> Int {
        var decimalBase = 1
        while digitIndex > 0 {
            decimalBase *= 10
            --digitIndex
        }
        
        return (self / decimalBase) % 10
    }
    
} 

 可以随便拿几个数字试试： 
 
 
        231[0]
        534[1]
        14597346[3]
        print("\(231[0]),\(534[1]),\(14597346[3])",appendNewLine:false) 

 （五）嵌套 
 
我们可以在已经存在的类，结构体，枚举中拓展嵌套 
 
extension Int {
    enum Kind {
        case Negative,Zero,Positive
    }
    var kind: Kind {
        switch self{
        case 0:
            return .Zero
        case let x where x > 0:
            return .Positive
        default:
            return .Negative
        }
    }
    
} 

 
func printIntegerKinds(numbers: [Int]) {
    for number in numbers {
        switch number.kind {
        case .Negative:
            print("- ",appendNewline: false)
        case .Zero:
            print("0 ",appendNewline: false)
        case .Positive:
            print("+ ",appendNewline: false)
        }
    }
    print("")
} 
        printIntegerKinds([3,19,-27,-6,7])
 原文链接：https://www.f2er.com/swift/326353.html
swift2.0学习之拓展

猜你在找的Swift相关文章
