扩展

扩展就是给存在的类、结构体或者枚举类型添加新的功能。这包括了对不能够访问源代码的类型进行扩展的能力（这被称作逆向建模）。扩展和OC中的categories 类似。（和OC中的categories 不同的是，Swfit的扩展不可以有名字。）

Swift中的扩展可以做以下事情：
添加计算属性和计算静态属性；
定义实例方法和类型方法；
提供新的构造方法；
定义下标；
定义和使用新的潜逃类型；
让被扩展的类型遵循一个协议；

NOTE
扩展可以给一个类型添加新功能，但不能重写已经存在的功能。

扩展语法

使用extension关键字定义扩展：

extension? ?SomeType? {
?    ?// new functionality to add to SomeType goes here
?}

一个扩展可以扩展一个存在的类型，使其遵循一个或多个协议。当这种情况时，像定义一个类或者结构体一样书写协议的名字（译者注：意思是像定义一个类或者结构体的语法一样前面写定义的名字后面跟类型的名字，二者用冒号分割）：

extension? ?SomeType?: ?SomeProtocol?,?AnotherProtocol? {
?    ?// implementation of protocol requirements goes here
?}

这种方式添加对协议的遵循，详见 使用扩展添加对协议的遵循（Adding Portocol Conformance with an Extension） 一节。

NOTE
如果定义了一个扩展给存在的类型添加了功能，新的功能对于所有这个类型的实例都有效，尽管可能实例在扩展定义前就被创建了。

计算属性

扩展可以给存在的类添加实例计算属性和类型计算属性。这个例子给Swift内嵌的Double类型添加了五个实例计算属性，来处理不同的距离单位：

?extension? ?Double? {
?    ?var? ?km?: ?Double? { ?return? ?self? * ?1_000.0? }
?    ?var? ?m?: ?Double? { ?return? ?self? }
?    ?var? ?cm?: ?Double? { ?return? ?self? / ?100.0? }
?    ?var? ?mm?: ?Double? { ?return? ?self? / ?1_000.0? }
?    ?var? ?ft?: ?Double? { ?return? ?self? / ?3.28084? }
?}
?let? ?oneInch? = ?25.4?.?mm
?println?(?"One inch is ?(?oneInch?)? meters"?)
?// prints "One inch is 0.0254 meters"
?let? ?threeFeet? = ?3?.?ft
?println?(?"Three feet is ?(?threeFeet?)? meters"?)
?// prints "Three feet is 0.914399970739201 meters"

这些计算属性表示了一个Double数值将会被作为特定的长度单位被转换。尽管他们是作为计算属性被实现的，但是这些属性名字可以通过采用一个点号附加在一个浮点字面值上，这是一种对那个字面值进行距离表示转换的方式。

这个例子中，一个Double值1.0被当作“1米。这就是为什么m计算属性返回self——表达式1.m被当作一个Double值1.0来计算。

其他的单位需要对以米单位测量的数值进行转换。一千米和1000米是一样的，所以km计算属性会将值乘以1000，做到将数值转换为以米为单位的数字表达式。类似的，一米是3.28024英尺，所以ft计算属性将数值除以3.28024，转换为米制。

这些属性是制度的计算属性，为了简洁，可以不通过get关键字访问。这些属性的返回值都是Double类型的，所以适用于Double类型的计算：

?let? ?aMarathon? = ?42?.?km? + ?195?.?m
?println?(?"A marathon is ?(?aMarathon?)? meters long"?)
?// prints "A marathon is 42195.0 meters long"

NOTE
扩展可以添加新的计算属性，但是不能添加存储属性和给已经存在的属性添加观察者。

构造方法

扩展可以给已经存在的类型添加新的构造方法。这样可以扩展构造方法参数的类型，或者提供类型原始定义中并不存在的额外的构造方法选项。

扩展可以给类添加新的方便构造方法，但是不能给类添加新的指定构造方法或者析构方法。指定构造方法和析构方法必须在类的初始定义中提供。

NOTE
如果使用扩展给值类型添加一个构造方法，同时，这个值类型给所有存储值都提供了默认值并且没有定义任何的定制构造方法，那么可以在扩展的构造方法中调用默认的构造方法和成员初始化构造方法。

如果值类型的原始定义中有定义构造方法，就不能像上述一样做。这在 值类型构造方法的委托 （Initializer Delegation for Value Types）有描述。

下面的例子定义了一个Rect结构体表现一个几何学上的矩形。这个例子同时定义了两个支撑的结构体叫做Size和Point，它们两个给它们的属性提供的默认值都是0.0：

?struct? ?Size? {
?    ?var? ?width? = ?0.0?,?height? = ?0.0
?}
?struct? ?Point? {
?    ?var? ?x? = ?0.0?,?y? = ?0.0
?}
?struct? ?Rect? {
?    ?var? ?origin? = ?Point?()
?    ?var? ?size? = ?Size?()
?}

因为Rect结构体给它所有的属性提供了了默认值，自动地它会得到一个默认的构造方法和一个成员构造方法，就像 默认构造方法（Default Initializers）一节描述的一样。这些初始化方法可以用来创建一个新的Rect实例：

?let? ?defaultRect? = ?Rect?()
?let? ?memberwiseRect? = ?Rect?(?origin?: ?Point?(?x?: ?2.0?,?y?: ?2.0?),?    ?size?: ?Size?(?width?: ?5.0?,?height?: ?5.0?))

可以对Rect结构体进行扩展，添加一个带指定中心点和尺寸的构造方法：

?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?)
?    }
?}

这个新的构造方法一开始根据提供的center点和size值计算合适的初始点。然后调用了结构体的自动成员构造方法init(origin:size:)，这个构造方法给对应的属性存储了新的origin和size值：

let? ?centerRect? = ?Rect?(?center?: ?Point?(?x?: ?4.0?,?y?: ?4.0?),?    ?size?: ?Size?(?width?: ?3.0?,?height?: ?3.0?))
?// centerRect's origin is (2.5,2.5) and its size is (3.0,3.0)

NOTE

如果用扩展的方式添加了一个新的构造方法，仍然需要确保在构造方法完成前所有的实例被完全初始化了。

方法

扩展可以给存在的类型添加新的实例方法和类型方法。下面的例子给Int类型添加了一个叫做repettions的实例方法：

?extension? ?Int? {
?    ?func? ?repetitions?(?task?: () -> ()) {
?        ?for? ?i? ?in? ?0?..<?self? {
?            ?task?()
?        }
?    }
?}

respetitions方法带了一个()->()类型的参数，参数是一个没有参数和返回值的方法。

扩展之后，可以对任何的整型数字调用repetitions方法，执行若干次参数中的方法：

?3?.?repetitions?({
?    ?println?(?"Hello!"?)
?})
?// Hello!
?// Hello!
?// Hello!

使用追踪闭包语法（trailing closure syntax）使得调用更加简明：

?3?.?repetitions? {
?    ?println?(?"Goodbye!"?)
?}
?// Goodbye!
?// Goodbye!
?// Goodbye!

实例方法的变异

通过扩展添加的实力方法可以修改（或变异）实力本身。标记实例方法为mutating，结构体和枚举的方法可以修改self和自身的属性，就像来自最初的变异方法一样。

下面的例子添加了一个变异方法square给Swift的Int类型，它会就是那初始值的平方：

extension? ?Int? {
?    ?mutating? ?func? ?square?() {
?        ?self? = ?self? * ?self
?    }
?}
?var? ?someInt? = ?3
?someInt?.?square?()
?// someInt is now 9

下标

扩展可以给已有的类型添加新的下标。这个例子给Swfit的内嵌Int类型添加了一个整型下标。这个下标[n]返回从数字的右边数起第n位的数字：

123456789[0] returns 9

123456789[1] returns 8

……继续：

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

?746381295?[?0?]
?// returns 5
?746381295?[?1?]
?// returns 9
?746381295?[?2?]
?// returns 2
?746381295?[?8?]
?// returns 7

如果Int值没有足够的数位，下标会返回0，就像从左侧不齐了0一样：

?746381295?[?9?]
?// returns 0,as if you had requested:
?0746381295?[?9?]

嵌套类型

扩展可以给已经存在的类、结构体和枚举类型添加新的嵌套类型：

?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
?        }
?    }
?}

这个例子给Int添加了新的嵌套枚举。这个枚举叫做Kind，表现了特定整型的类型，整型数字无非就是正数、零和负数。

这个例子同时给Int添加了新的实例计算属性，叫做kind，它返回当前整型对应的Kind枚举值。

嵌套枚举可以在任何Int值上使用：

?func? ?printIntegerKinds?(?numbers?: [?Int?]) {
?    ?for? ?number? ?in? ?numbers? {
?        ?switch? ?number?.?kind? {
?        ?case? .?Negative?:
?            ?print?(?"- "?)
?        ?case? .?Zero?:
?            ?print?(?"0 "?)
?        ?case? .?Positive?:
?            ?print?(?"+ "?)
?        }
?    }
?    ?print?(?"n"?)
?}
?printIntegerKinds?([?3?,?19?,-?27?,?0?,-?6?,?7?])
?// prints "+ + - 0 - 0 +"

printIntegerKinds这个函数，参数是一个Int型的数组，对其进行了迭代。对于每个数组中的整数成员，函数会考量其kind计算属性，打印一个对应的描述。

NOTE 已知number.kind是Int.Kind类型的。因此，所有的Int.Kind成员在switch语句中可以简写，比如.Negative是Int.Kind.Negative的简写。