swift2.0学习之拓展

拓展：和oc的拓展方法功能差不多，就是给已经存在的类，结构体，枚举，协议类型增加新的方法

拓展语法：

用extension关键字声明：

extension SomeType {

[code]// new functionality to add to SomeType goes here

}

[/code]拓展可以：

（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), size: Size(width: 3.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, 0, -6, 0, 7])