swift2.0, 21_Extensions, tranlation into Chinese

source/chapter2/21_Extensions.md

@@ -13,22 +13,24 @@
 - [下标](#subscripts)
 - [嵌套类型](#nested_types)
 
-*扩展*就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与Objective-C不同的是，Swift 的扩展没有名字。）
+*扩展*就是向一个已有的类、结构体、枚举类型或者协议类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与 Objective-C 不同的是，Swift 的扩展没有名字。）
 
 Swift 中的扩展可以：
 
-- 添加计算型属性和计算静态属性
+- 添加计算型属性和计算型静态属性
 - 定义实例方法和类型方法
 - 提供新的构造器
 - 定义下标
 - 定义和使用新的嵌套类型
 - 使一个已有类型符合某个协议
 
+TODO：
+在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](#)获取更多的细节。
 
 >注意：  
-如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
+扩展可以对一个类型添加新的功能，但是不能重写已有的功能。
-
 <a name="extension_syntax"></a>
+
 ## 扩展语法（Extension Syntax）
 
 声明一个扩展使用关键字`extension`：
@@ -38,7 +40,6 @@ extension SomeType {
     // 加到SomeType的新功能写到这里
 }
 ```
-
 一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，协议的名字应该完全按照类或结构体的名字的方式进行书写：
 
 ```swift
@@ -49,10 +50,13 @@ extension SomeType: SomeProtocol, AnotherProctocol {
 
 按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](21_Protocols.html#adding_protocol_conformance_with_an_extension)
 
+>注意：  
+如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
+
 <a name="computed_properties"></a>
 ## 计算型属性（Computed Properties）
 
-扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持。
+扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持：
 
 ```swift
 extension Double {
@@ -84,7 +88,6 @@ println("A marathon is \(aMarathon) meters long")
 // 打印输出："A marathon is 42195.0 meters long"
 ```
 
-
 >注意：  
 扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。
 
@@ -93,14 +96,13 @@ println("A marathon is \(aMarathon) meters long")
 
 扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。  
 
-扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构函数。指定构造器和析构函数必须总是由原始的类实现来提供。
+扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供。
 
 > 注意：  
 如果你使用扩展向一个值类型添加一个构造器，在该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers）时，你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
 >
 正如在[值类型的构造器代理](14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
 
-
 下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值：
 
 ```swift
@@ -115,8 +117,7 @@ struct Rect {
     var size = Size()
 }
 ```
-
+因为结构体`Rect`提供了其所有属性的默认值，所以正如[默认构造器](14_Initialization.html#default_initializers)中描述的，它可以自动接受一个默认构造器和一个逐一成员构造器。这些构造器可以用于构造新的`Rect`实例：
-因为结构体`Rect`提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的`Rect`实例：
 
 ```swift
 let defaultRect = Rect()
@@ -135,8 +136,7 @@ extension Rect {
     }
 }
 ```
-
+这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的逐一成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中：
-这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中：
 
 ```swift
 let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
@@ -250,52 +250,51 @@ extension Int {
 扩展可以向已有的类、结构体和枚举添加新的嵌套类型：
 
 ```swift
-extension Character {
+extension Int {
     enum Kind {
-        case Vowel, Consonant, Other
+        case Negative, Zero, Positive
     }
     var kind: Kind {
-        switch String(self).lowercaseString {
+        switch self {
-        case "a", "e", "i", "o", "u":
+        case 0:
-            return .Vowel
+            return .Zero
-        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
+        case let x where x > 0:
-             "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
+            return .Positive
-            return .Consonant
         default:
-            return .Other
+            return .Negative
         }
     }
 }
 ```
 
-该例子向`Character`添加了新的嵌套枚举。这个名为`Kind`的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。
+该例子向`Int`添加了新的嵌套枚举。这个名为`Kind`的枚举表示特定整数的类型。具体来说，就是表示整数是正数，零或者负数。
 
-这个例子还向`Character`添加了一个新的计算实例属性，即`kind`，用来返回合适的`Kind`枚举成员。
+这个例子还向`Int`添加了一个新的计算实例属性，即`kind`，用来返回合适的`Kind`枚举成员。
+
+现在，这个嵌套枚举可以和一个`Int`值联合使用了：
 
-现在，这个嵌套枚举可以和一个`Character`值联合使用了：
 
 ```swift
-func printLetterKinds(word: String) {
+func printIntegerKinds(numbers: [Int]) {
-    println("'\(word)' is made up of the following kinds of letters:")
+    for number in numbers {
-    for character in word {
+        switch number.kind {
-        switch character.kind {
+        case .Negative:
-        case .Vowel:
+            print("- ", appendNewline: false)
-            print("vowel ")
+        case .Zero:
-        case .Consonant:
+            print("0 ", appendNewline: false)
-            print("consonant ")
+        case .Positive:
-        case .Other:
+            print("+ ", appendNewline: false)
-            print("other ")
         }
     }
-    print("\n")
+    print("")
 }
-printLetterKinds("Hello")
+printIntegerKinds([3, 19, -27, 0, -6, 0, 7])
-// 'Hello' is made up of the following kinds of letters:
+// prints "+ + - 0 - 0 +"
-// consonant vowel consonant consonant vowel
 ```
 
-函数`printLetterKinds`的输入是一个`String`值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的`kind`计算属性，并打印出合适的类别描述。所以`printLetterKinds`就可以用来打印一个完整单词中所有字母的类型，正如上述单词`"hello"`所展示的。
+函数`printIntegerKinds`的输入是一个`Int`数组值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的`kind`计算属性，并打印出合适的类别描述。
+
+>注意：
+由于已知`number.kind `是`Int.Kind`型，所以`Int.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `. Negative`代替`Int.Kind.Negative`。
 
->注意：  
-由于已知`character.kind`是`Character.Kind`型，所以`Character.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `.Vowel`代替`Character.Kind.Vowel`