-
-
- - 苹果全球开发者大会WWDC2014召开，发布了苹果最新的开发语言Swift，并释放出XCode6 Beta1版本 -
U+1F436
Code Unit
Code Unit
-其他商品上标有 QR 码格式的二维码，它可以使用任何 ISO 8859-1 字符，并且可以编码一个最多拥有 2953 个字符的字符串:
+其他商品上标有 QR 码格式的二维码，它可以使用任何 ISO 8859-1 字符，并且可以编码一个最多拥有 2,953 个字符的字符串：
-对于库存跟踪系统来说，能够把 UPC-A 码作为四个整型值的元组，和把 QR 码作为一个任何长度的字符串存储起来是方便的。
+这便于库存跟踪系统用包含四个整型值的元组存储 UPC-A 码，以及用任意长度的字符串储存 QR 码。
-在 Swift 中，使用如下方式定义两种商品条码的枚举：
+在 Swift 中，使用如下方式定义表示两种商品条形码的枚举：
```swift
enum Barcode {
- case UPCA(Int, Int, Int, Int)
- case QRCode(String)
+ case UPCA(Int, Int, Int, Int)
+ case QRCode(String)
}
```
以上代码可以这么理解：
-“定义一个名为`Barcode`的枚举类型，它可以是`UPCA`的一个相关值（`Int`，`Int`，`Int`，`Int`），或者是`QRCode`的一个字符串类型（`String`）相关值。”
+“定义一个名为`Barcode`的枚举类型，它的一个成员值是具有`(Int，Int，Int，Int)`类型关联值的`UPCA`，另一个成员值是具有`String`类型关联值的`QRCode`。”
-这个定义不提供任何`Int`或`String`的实际值，它只是定义了，当`Barcode`常量和变量等于`Barcode.UPCA`或`Barcode.QRCode`时，相关值的类型。
+这个定义不提供任何`Int`或`String`类型的关联值，它只是定义了，当`Barcode`常量和变量等于`Barcode.UPCA`或`Barcode.QRCode`时，可以存储的关联值的类型。
-然后可以使用任何一种条码类型创建新的条码，如：
+然后可以使用任意一种条形码类型创建新的条形码，例如：
```swift
var productBarcode = Barcode.UPCA(8, 85909, 51226, 3)
```
-以上例子创建了一个名为`productBarcode`的变量，并且赋给它一个`Barcode.UPCA`的相关元组值`(8, 85909, 51226, 3)`。
+上面的例子创建了一个名为`productBarcode`的变量，并将`Barcode.UPCA`赋值给它，关联的元组值为`(8, 85909, 51226, 3)`。
-同一个商品可以被分配给一个不同类型的条形码，如：
+同一个商品可以被分配一个不同类型的条形码，例如：
```swift
productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
```
-这时，原始的`Barcode.UPCA`和其整数值被新的`Barcode.QRCode`和其字符串值所替代。条形码的常量和变量可以存储一个`.UPCA`或者一个`.QRCode`（连同它的相关值），但是在任何指定时间只能存储其中之一。
+这时，原始的`Barcode.UPCA`和其整数关联值被新的`Barcode.QRCode`和其字符串关联值所替代。`Barcode`类型的常量和变量可以存储一个`.UPCA`或者一个`.QRCode`（连同它们的关联值），但是在同一时间只能存储这两个值中的一个。
-像以前那样，不同的条形码类型可以使用一个 switch 语句来检查，然而这次相关值可以被提取作为 switch 语句的一部分。你可以在`switch`的 case 分支代码中提取每个相关值作为一个常量（用`let`前缀）或者作为一个变量（用`var`前缀）来使用：
+像先前那样，可以使用一个 switch 语句来检查不同的条形码类型。然而，这一次，关联值可以被提取出来作为 switch 语句的一部分。你可以在`switch`的 case 分支代码中提取每个关联值作为一个常量（用`let`前缀）或者作为一个变量（用`var`前缀）来使用：
```swift
switch productBarcode {
@@ -176,7 +183,7 @@ case .QRCode(let productCode):
// 输出 "QR code: ABCDEFGHIJKLMNOP."
```
-如果一个枚举成员的所有相关值被提取为常量，或者它们全部被提取为变量，为了简洁，你可以只放置一个`var`或者`let`标注在成员名称前：
+如果一个枚举成员的所有关联值都被提取为常量，或者都被提取为变量，为了简洁，你可以只在成员名称前标注一个`let`或者`var`：
```swift
switch productBarcode {
@@ -191,9 +198,9 @@ case let .QRCode(productCode):
## 原始值（Raw Values）
-在[相关值](#raw_values)小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的相关值。作为相关值的另一种选择，枚举成员可以被默认值（称为原始值）赋值，其中这些原始值具有相同的类型。
+在[关联值](#associated_values)小节的条形码例子中，演示了如何声明存储不同类型关联值的枚举成员。作为关联值的替代选择，枚举成员可以被默认值（称为*原始值*）预填充，这些原始值的类型必须相同。
-这里是一个枚举成员存储 ASCII 码的例子：
+这是一个使用 ASCII 码作为原始值的枚举：
```swift
enum ASCIIControlCharacter: Character {
@@ -203,21 +210,22 @@ enum ASCIIControlCharacter: Character {
}
```
-在这里，`ASCIIControlCharacter`的枚举类型的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见[字符串和字符](./03_Strings_and_Characters.html)部分。
+枚举类型`ASCIIControlCharacter`的原始值类型被定义为`Character`，并设置了一些比较常见的 ASCII 控制字符。`Character`的描述详见[字符串和字符](./03_Strings_and_Characters.html)部分。
-原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。
+原始值可以是字符串，字符，或者任意整型值或浮点型值。每个原始值在枚举声明中必须是唯一的。
->注意：
->原始值和相关值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。相关值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。
+> 注意
+> 原始值和关联值是不同的。原始值是在定义枚举时被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终不变。关联值是创建一个基于枚举成员的常量或变量时才设置的值，枚举成员的关联值可以变化。
+
### 原始值的隐式赋值（Implicitly Assigned Raw Values）
-在使用原始值为整数或者字符串类型的枚举时，不需要显式的为每一个成员赋值，这时，Swift将会自动为你赋值。
+在使用原始值为整数或者字符串类型的枚举时，不需要显式地为每一个枚举成员设置原始值，Swift 将会自动为你赋值。
-例如，当使用整数作为原始值时，隐式赋值的值依次递增1。如果第一个值没有被赋初值，将会被自动置为0。
+例如，当使用整数作为原始值时，隐式赋值的值依次递增`1`。如果第一个枚举成员没有设置原始值，其原始值将为`0`。
-下面的枚举是对之前`Planet`这个枚举的一个细化，利用原始整型值来表示每个 planet 在太阳系中的顺序：
+下面的枚举是对之前`Planet`这个枚举的一个细化，利用整型的原始值来表示每个行星在太阳系中的顺序：
```swift
enum Planet: Int {
@@ -225,11 +233,11 @@ enum Planet: Int {
}
```
-在上面的例子中，`Plant.Mercury`赋了初值`1`，`Planet.Venus`会拥有隐式赋值`2`，依次类推。
+在上面的例子中，`Plant.Mercury`的显式原始值为`1`，`Planet.Venus`的隐式原始值为`2`，依次类推。
-当使用字符串作为枚举类型的初值时，每个枚举成员的隐式初值则为该成员的名称。
+当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称。
-下面的例子是`CompassPoint`枚举类型的精简版，使用字符串作为初值类型，隐式初始化为各个方向的名称：
+下面的例子是`CompassPoint`枚举的细化，使用字符串类型的原始值来表示各个方向的名称：
```swift
enum CompassPoint: String {
@@ -237,7 +245,7 @@ enum CompassPoint: String {
}
```
-上面例子中，`CompassPoint.South`拥有隐式初值`South`，依次类推。
+上面例子中，`CompassPoint.South`拥有隐式原始值`South`，依次类推。
使用枚举成员的`rawValue`属性可以访问该枚举成员的原始值：
@@ -249,23 +257,24 @@ let sunsetDirection = CompassPoint.West.rawValue
// sunsetDirection 值为 "West"
```
-### 使用原始值初始化枚举变量（Initializing from a Raw Value）
+
+### 使用原始值初始化枚举实例（Initializing from a Raw Value）
-如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法将原始值类型作为参数，返回值是枚举成员或`nil`。你可以使用这种初始化方法来创建一个新的枚举变量。
+如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法接收一个叫做`rawValue`的参数，参数类型即为原始值类型，返回值则是枚举成员或`nil`。你可以使用这个初始化方法来创建一个新的枚举实例。
-这个例子通过原始值`7`从而创建枚举成员：
+这个例子利用原始值`7`创建了枚举成员`Uranus`：
```swift
let possiblePlanet = Planet(rawValue: 7)
// possiblePlanet 类型为 Planet? 值为 Planet.Uranus
```
-然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个**可选**的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
+然而，并非所有`Int`值都可以找到一个匹配的行星。因此，原始值构造器总是返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或者说“可选的`Planet`”。
->注意：
->原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[可失败构造器](../chapter3/05_Declarations#failable_initializers)
+> 注意
+> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[可失败构造器](../chapter3/05_Declarations.html#failable_initializers)
-如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`：
+如果你试图寻找一个位置为`9`的行星，通过原始值构造器返回的可选`Planet`值将是`nil`：
```swift
let positionToFind = 9
@@ -282,19 +291,15 @@ if let somePlanet = Planet(rawValue: positionToFind) {
// 输出 "There isn't a planet at position 9
```
-这个范例使用可选绑定（optional binding），通过原始值`9`试图访问一个行星。`if let somePlanet = Planet(rawValue: 9)`语句获得一个可选`Planet`，如果可选`Planet`可以被获得，把`somePlanet`设置成该可选`Planet`的内容。在这个范例中，无法检索到位置为`9`的行星，所以`else`分支被执行。
+这个例子使用了可选绑定（optional binding），试图通过原始值`9`来访问一个行星。`if let somePlanet = Planet(rawValue: 9)`语句创建了一个可选`Planet`，如果可选`Planet`的值存在，就会赋值给`somePlanet`。在这个例子中，无法检索到位置为`9`的行星，所以`else`分支被执行。
## 递归枚举（Recursive Enumerations）
-在对操作符进行描述的时候，使用枚举类型来对数据建模很方便，因为需要考虑的情况固定可枚举。操作符可以将两个由数字组成的算数表达式连接起来，例如，将`5`连接成复杂一些的表达式`5+4`。
-算术表达式的一个重要特性是，表达式可以嵌套使用。例如，表达式`(5 + 4) * 2`乘号右边是一个数字，左边则是另一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也许要支持这种嵌套————这表示枚举类型需要支持递归。
-
-`递归枚举（recursive enumeration）`是一种枚举类型，表示它的枚举中，有一个或多个枚举成员拥有该枚举的其他成员作为相关值。使用递归枚举时，编译器会插入一个中间层。你可以在枚举成员前加上`indirect`来表示这成员可递归。
-
-例如，下面的例子中，枚举类型存储了简单的算数表达式：
+*递归枚举（recursive enumeration）*是一种枚举类型，它有一个或多个枚举成员使用该枚举类型的实例作为关联值。使用递归枚举时，编译器会插入一个间接层。你可以在枚举成员前加上`indirect`来表示该成员可递归。
+例如，下面的例子中，枚举类型存储了简单的算术表达式：
```swift
enum ArithmeticExpression {
@@ -304,7 +309,7 @@ enum ArithmeticExpression {
}
```
-你也可以在枚举类型开头加上`indirect`关键字来表示它的所有成员都是可递归的：
+你也可以在枚举类型开头加上`indirect`关键字来表明它的所有成员都是可递归的：
```swift
indirect enum ArithmeticExpression {
@@ -314,9 +319,16 @@ indirect enum ArithmeticExpression {
}
```
-上面定义的枚举类型可以存储三种算数表达式：纯数字、两个表达式的相加、两个表达式相乘。`Addition` 和 `Multiplication`成员的相关值也是算数表达式————这些相关值使得嵌套表达式成为可能。
+上面定义的枚举类型可以存储三种算术表达式：纯数字、两个表达式相加、两个表达式相乘。枚举成员`Addition`和`Multiplication`的关联值也是算术表达式——这些关联值使得嵌套表达式成为可能。例如，表达式`(5 + 4) * 2`，乘号右边是一个数字，左边则是另一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也需要支持这种嵌套——这意味着枚举类型需要支持递归。下面的代码展示了使用`ArithmeticExpression `这个递归枚举创建表达式`(5 + 4) * 2`
-递归函数可以很直观地使用具有递归性质的数据结构。例如，下面是一个计算算术表达式的函数：
+```swift
+let five = ArithmeticExpression.Number(5)
+let four = ArithmeticExpression.Number(4)
+let sum = ArithmeticExpression.Addition(five, four)
+let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2))
+```
+
+要操作具有递归性质的数据结构，使用递归函数是一种直截了当的方式。例如，下面是一个对算术表达式求值的函数：
```swift
func evaluate(expression: ArithmeticExpression) -> Int {
@@ -329,12 +341,7 @@ func evaluate(expression: ArithmeticExpression) -> Int {
return evaluate(left) * evaluate(right)
}
}
-
-// 计算 (5 + 4) * 2
-let five = ArithmeticExpression.Number(5)
-let four = ArithmeticExpression.Number(4)
-let sum = ArithmeticExpression.Addition(five, four)
-let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2))
+
print(evaluate(product))
// 输出 "18"
```
diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index 74257884..ac454f4d 100755
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -7,6 +7,12 @@
> 2.0
> 翻译+校对：[SkyJean](https://github.com/SkyJean)
+> 2.1
+> 校对：[shanks](http://codebuild.me)，2015-10-29
+
+> 2.2
+> 校对：[SketchK](https://github.com/SketchK) 2016-05-13
+
本页包含内容：
- [类和结构体对比](#comparing_classes_and_structures)
@@ -16,12 +22,12 @@
- [字符串(String)、数组(Array)、和字典(Dictionary)类型的赋值与复制行为](#assignment_and_copy_behavior_for_strings_arrays_and_dictionaries)
-类和结构体是人们构建代码所用的一种通用且灵活的构造体。我们可以使用完全相同的语法规则来为类和结构体定义属性（常量、变量）和添加方法，从而扩展类和结构体的功能。
+*类*和*结构体*是人们构建代码所用的一种通用且灵活的构造体。我们可以使用完全相同的语法规则来为类和结构体定义属性（常量、变量）和添加方法，从而扩展类和结构体的功能。
与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口。
-> 注意：
-通常一个`类`的实例被称为`对象`。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用`实例`而不是`对象`。
+> 注意
+> 通常一个`类`的实例被称为`对象`。然而在 Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用`实例`而不是`对象`。
###类和结构体对比
@@ -30,26 +36,27 @@ Swift 中类和结构体有很多共同点。共同处在于：
* 定义属性用于存储值
* 定义方法用于提供功能
-* 定义附属脚本用于访问值
+* 定义下标操作使得可以通过下标语法来访问实例所包含的值
* 定义构造器用于生成初始化值
* 通过扩展以增加默认实现的功能
* 实现协议以提供某种标准功能
-更多信息请参见 [属性](./10_Properties.html)，[方法](./11_Methods.html)，[下标脚本](./12_Subscripts.html)，[初始过程](./14_Initialization.html)，[扩展](./20_Extensions.html)，和[协议](./21_Protocols.html)。
+更多信息请参见[属性](./10_Properties.html)，[方法](./11_Methods.html)，[下标](./12_Subscripts.html)，[构造过程](./14_Initialization.html)，[扩展](./21_Extensions.html)，和[协议](./22_Protocols.html)。
与结构体相比，类还有如下的附加功能：
* 继承允许一个类继承另一个类的特征
* 类型转换允许在运行时检查和解释一个类实例的类型
-* 解构器允许一个类实例释放任何其所被分配的资源
+* 析构器允许一个类实例释放任何其所被分配的资源
* 引用计数允许对一个类的多次引用
-更多信息请参见[继承](./13_Inheritance.html)，[类型转换](./20_Type_Casting.html)，[析构过程](./15_Deinitialization)，和[自动引用计数](./16_Automatic_Reference_Counting)。
+更多信息请参见[继承](./13_Inheritance.html)，[类型转换](./19_Type_Casting.html)，[析构过程](./15_Deinitialization.html)，和[自动引用计数](./16_Automatic_Reference_Counting.html)。
-> 注意：
-结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
+> 注意
+> 结构体总是通过被复制的方式在代码中传递，不使用引用计数。
-### 定义
+
+### 定义语法
类和结构体有着类似的定义方式。我们通过关键字`class`和`struct`来分别表示类和结构体，并在一对大括号中定义它们的具体内容：
@@ -62,8 +69,8 @@ struct SomeStructure {
}
```
-> 注意：
-在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的 Swift 类型。因此请使用 `UpperCamelCase` 这种方式来命名（如 `SomeClass` 和`SomeStructure`等），以便符合标准Swift 类型的大写命名风格（如`String`，`Int`和`Bool`）。相反的，请使用`lowerCamelCase`这种方式为属性和方法命名（如`framerate`和`incrementCount`），以便和类区分。
+> 注意
+> 在你每次定义一个新类或者结构体的时候，实际上你是定义了一个新的 Swift 类型。因此请使用`UpperCamelCase`这种方式来命名（如`SomeClass`和`SomeStructure`等），以便符合标准 Swift 类型的大写命名风格（如`String`，`Int`和`Bool`）。相反的，请使用`lowerCamelCase`这种方式为属性和方法命名（如`framerate`和`incrementCount`），以便和类型名区分。
以下是定义结构体和定义类的示例：
@@ -80,10 +87,11 @@ class VideoMode {
}
```
-在上面的示例中我们定义了一个名为`Resolution`的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为`width`和`height`的存储属性。存储属性是捆绑和存储在类或结构体中的常量或变量。当这两个属性被初始化为整数`0`的时候，它们会被推断为`Int`类型。
+在上面的示例中我们定义了一个名为`Resolution`的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为`width`和`height`的存储属性。存储属性是被捆绑和存储在类或结构体中的常量或变量。当这两个属性被初始化为整数`0`的时候，它们会被推断为`Int`类型。
-在上面的示例中我们还定义了一个名为`VideoMode`的类，用来描述一个视频显示器的特定模式。这个类包含了四个储存属性变量。第一个是`分辨率`，它被初始化为一个新的`Resolution`结构体的实例，具有`Resolution`的属性类型。新`VideoMode`实例同时还会初始化其它三个属性，它们分别是，初始值为`false`(意为“非隔行扫描视频”)的`interlaced`，回放帧率初始值为`0.0`的`frameRate`和值为可选`String`的`name`。`name`属性会被自动赋予一个默认值`nil`，意为“没有`name`值”，因为它是一个可选类型。
+在上面的示例中我们还定义了一个名为`VideoMode`的类，用来描述一个视频显示器的特定模式。这个类包含了四个变量存储属性。第一个是`分辨率`，它被初始化为一个新的`Resolution`结构体的实例，属性类型被推断为`Resolution`。新`VideoMode`实例同时还会初始化其它三个属性，它们分别是，初始值为`false`的`interlaced`，初始值为`0.0`的`frameRate`，以及值为可选`String`的`name`。`name`属性会被自动赋予一个默认值`nil`，意为“没有`name`值”，因为它是一个可选类型。
+
### 类和结构体实例
`Resolution`结构体和`VideoMode`类的定义仅描述了什么是`Resolution`和`VideoMode`。它们并没有描述一个特定的分辨率（resolution）或者视频模式（video mode）。为了描述一个特定的分辨率或者视频模式，我们需要生成一个它们的实例。
@@ -97,9 +105,10 @@ let someVideoMode = VideoMode()
结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](./14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
+
### 属性访问
-通过使用*点语法*（*dot syntax*），你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接：
+通过使用*点语法*（*dot syntax*），你可以访问实例的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(`.`)连接：
```swift
print("The width of someResolution is \(someResolution.width)")
@@ -115,7 +124,7 @@ print("The width of someVideoMode is \(someVideoMode.resolution.width)")
// 输出 "The width of someVideoMode is 0"
```
-你也可以使用点语法为属性变量赋值：
+你也可以使用点语法为变量属性赋值：
```swift
someVideoMode.resolution.width = 1280
@@ -123,10 +132,11 @@ print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
// 输出 "The width of someVideoMode is now 1280"
```
-> 注意：
-与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要重新设置`resolution`属性。
+> 注意
+> 与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要重新为整个`resolution`属性设置新值。
-### 结构体类型的成员逐一构造器(Memberwise Initializers for Structure Types)
+
+### 结构体类型的成员逐一构造器（Memberwise Initializers for Structure Types）
所有结构体都有一个自动生成的*成员逐一构造器*，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中：
@@ -139,24 +149,24 @@ let vga = Resolution(width:640, height: 480)
## 结构体和枚举是值类型
-*值类型*被赋予给一个变量、常量或者本身被传递给一个函数的时候，实际上操作的是其的*拷贝*。
+*值类型*被赋予给一个变量、常量或者被传递给一个函数的时候，其值会被*拷贝*。
-在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数（Integer）、浮点数（floating-point）、布尔值（Boolean）、字符串（string)、数组（array）和字典（dictionary），都是值类型，并且都是以结构体的形式在后台所实现。
+在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数（Integer）、浮点数（floating-point）、布尔值（Boolean）、字符串（string)、数组（array）和字典（dictionary），都是值类型，并且在底层都是以结构体的形式所实现。
在 Swift 中，所有的结构体和枚举类型都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
-请看下面这个示例，其使用了前一个示例中`Resolution`结构体：
+请看下面这个示例，其使用了前一个示例中的`Resolution`结构体：
```swift
let hd = Resolution(width: 1920, height: 1080)
var cinema = hd
```
-在以上示例中，声明了一个名为`hd`的常量，其值为一个初始化为全高清视频分辨率（1920 像素宽，1080 像素高）的`Resolution`实例。
+在以上示例中，声明了一个名为`hd`的常量，其值为一个初始化为全高清视频分辨率（`1920` 像素宽，`1080` 像素高）的`Resolution`实例。
-然后示例中又声明了一个名为`cinema`的变量，其值为之前声明的`hd`。因为`Resolution`是一个结构体，所以`cinema`的值其实是`hd`的一个拷贝副本，而不是`hd`本身。尽管`hd`和`cinema`有着相同的宽（width）和高（height）属性，但是在后台中，它们是两个完全不同的实例。
+然后示例中又声明了一个名为`cinema`的变量，并将`hd`赋值给它。因为`Resolution`是一个结构体，所以`cinema`的值其实是`hd`的一个拷贝副本，而不是`hd`本身。尽管`hd`和`cinema`有着相同的宽（width）和高（height），但是在幕后它们是两个完全不同的实例。
-下面，为了符合数码影院放映的需求（2048 像素宽，1080 像素高），`cinema`的`width`属性需要作如下修改：
+下面，为了符合数码影院放映的需求（`2048` 像素宽，`1080` 像素高），`cinema`的`width`属性需要作如下修改：
```swift
cinema.width = 2048
@@ -172,11 +182,11 @@ print("cinema is now \(cinema.width) pixels wide")
然而，初始的`hd`实例中`width`属性还是`1920`：
```swift
-print("hd is still \(hd.width ) pixels wide")
+print("hd is still \(hd.width) pixels wide")
// 输出 "hd is still 1920 pixels wide"
```
-在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所存储的`值（values）`进行拷贝，然后将拷贝的数据存储到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的`width`的值。
+在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所存储的值进行拷贝，然后将拷贝的数据存储到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的`width`的值。
枚举也遵循相同的行为准则：
@@ -193,12 +203,12 @@ if rememberedDirection == .West {
// 输出 "The remembered direction is still .West"
```
-上例中`rememberedDirection`被赋予了`currentDirection`的值（value），实际上它被赋予的是值（value）的一个拷贝。赋值过程结束后再修改`currentDirection`的值并不影响`rememberedDirection`所储存的原始值（value）的拷贝。
+上例中`rememberedDirection`被赋予了`currentDirection`的值，实际上它被赋予的是值的一个拷贝。赋值过程结束后再修改`currentDirection`的值并不影响`rememberedDirection`所储存的原始值的拷贝。
## 类是引用类型
-与值类型不同，引用类型在被赋予到一个变量、常量或者被传递到一个函数时，操作的是引用，其并不是拷贝。因此，引用的是已存在的实例本身而不是其拷贝。
+与值类型不同，引用类型在被赋予到一个变量、常量或者被传递到一个函数时，其值不会被拷贝。因此，引用的是已存在的实例本身而不是其拷贝。
请看下面这个示例，其使用了之前定义的`VideoMode`类：
@@ -210,9 +220,9 @@ tenEighty.name = "1080i"
tenEighty.frameRate = 25.0
```
-以上示例中，声明了一个名为`tenEighty`的常量，其引用了一个`VideoMode`类的新实例。在之前的示例中，这个视频模式（video mode）被赋予了HD分辨率（1920*1080）的一个拷贝（`hd`）。同时设置为交错（interlaced）,命名为`“1080i”`。最后，其帧率是`25.0`帧每秒。
+以上示例中，声明了一个名为`tenEighty`的常量，其引用了一个`VideoMode`类的新实例。在之前的示例中，这个视频模式（video mode）被赋予了HD分辨率（`1920`*`1080`）的一个拷贝（即`hd`实例）。同时设置为`interlaced`，命名为`“1080i”`。最后，其帧率是`25.0`帧每秒。
-然后，`tenEighty` 被赋予名为`alsoTenEighty`的新常量，同时对`alsoTenEighty`的帧率进行修改：
+然后，`tenEighty`被赋予名为`alsoTenEighty`的新常量，同时对`alsoTenEighty`的帧率进行修改：
```swift
let alsoTenEighty = tenEighty
@@ -221,25 +231,26 @@ alsoTenEighty.frameRate = 30.0
因为类是引用类型，所以`tenEight`和`alsoTenEight`实际上引用的是相同的`VideoMode`实例。换句话说，它们是同一个实例的两种叫法。
-下面，通过查看`tenEighty`的`frameRate`属性，我们会发现它正确的显示了基本`VideoMode`实例的新帧率，其值为`30.0`：
+下面，通过查看`tenEighty`的`frameRate`属性，我们会发现它正确的显示了所引用的`VideoMode`实例的新帧率，其值为`30.0`：
```swift
print("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
// 输出 "The frameRate property of theEighty is now 30.0"
```
-需要注意的是`tenEighty`和`alsoTenEighty`被声明为*常量（（constants）*而不是变量。然而你依然可以改变`tenEighty.frameRate`和`alsoTenEighty.frameRate`,因为这两个常量本身不会改变。它们并不`存储`这个`VideoMode`实例，在后台仅仅是对`VideoMode`实例的引用。所以，改变的是被引用的基础`VideoMode`的`frameRate`参数，而不改变常量的值。
+需要注意的是`tenEighty`和`alsoTenEighty`被声明为常量而不是变量。然而你依然可以改变`tenEighty.frameRate`和`alsoTenEighty.frameRate`，因为`tenEighty`和`alsoTenEighty`这两个常量的值并未改变。它们并不“存储”这个`VideoMode`实例，而仅仅是对`VideoMode`实例的引用。所以，改变的是被引用的`VideoMode`的`frameRate`属性，而不是引用`VideoMode`的常量的值。
+
### 恒等运算符
-因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。（对于结构体和枚举来说，这并不成立。因为它们作为值类型，在被赋予到常量、变量或者传递到函数时，其值总是会被拷贝。）
+因为类是引用类型，有可能有多个常量和变量在幕后同时引用同一个类实例。（对于结构体和枚举来说，这并不成立。因为它们作为值类型，在被赋予到常量、变量或者传递到函数时，其值总是会被拷贝。）
如果能够判定两个常量或者变量是否引用同一个类实例将会很有帮助。为了达到这个目的，Swift 内建了两个恒等运算符：
-* 等价于 （ === ）
-* 不等价于 （ !== ）
+* 等价于（`===`）
+* 不等价于（`!==`）
-以下是运用这两个运算符检测两个常量或者变量是否引用同一个实例：
+运用这两个运算符检测两个常量或者变量是否引用同一个实例：
```swift
if tenEighty === alsoTenEighty {
@@ -248,30 +259,31 @@ if tenEighty === alsoTenEighty {
//输出 "tenEighty and alsoTenEighty refer to the same Resolution instance."
```
-请注意```“等价于"```（用三个等号表示，===） 与```“等于"```（用两个等号表示，==）的不同：
+请注意，“等价于”（用三个等号表示，`===`）与“等于”（用两个等号表示，`==`）的不同：
* “等价于”表示两个类类型（class type）的常量或者变量引用同一个类实例。
-* “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
+* “等于”表示两个实例的值“相等”或“相同”，判定时要遵照设计者定义的评判标准，因此相对于“相等”来说，这是一种更加合适的叫法。
-当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[等价操作符](./24_Advanced_Operators.html#equivalence_operators)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
+当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[等价操作符](./25_Advanced_Operators.html#equivalence_operators)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
+
### 指针
-如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用*指针*来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与 C 语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号（*）来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。
+如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用*指针*来引用内存中的地址。一个引用某个引用类型实例的 Swift 常量或者变量，与 C 语言中的指针类似，但是并不直接指向某个内存地址，也不要求你使用星号（`*`）来表明你在创建一个引用。Swift 中的这些引用与其它的常量或变量的定义方式相同。
## 类和结构体的选择
在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。
-然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。
+然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你在考虑一个工程项目的数据结构和功能的时候，你需要决定每个数据结构是定义成类还是结构体。
按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：
-* 结构体的主要目的是用来封装少量相关简单数据值。
-* 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
-* 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
-* 结构体不需要去继承另一个已存在类型的属性或者行为。
+* 该数据结构的主要目的是用来封装少量相关简单数据值。
+* 有理由预计该数据结构的实例在被赋值或传递时，封装的数据将会被拷贝而不是被引用。
+* 该数据结构中储存的值类型属性，也应该被拷贝，而不是被引用。
+* 该数据结构不需要去继承另一个既有类型的属性或者行为。
举例来说，以下情境中适合使用结构体：
@@ -284,11 +296,9 @@ if tenEighty === alsoTenEighty {
## 字符串(String)、数组(Array)、和字典(Dictionary)类型的赋值与复制行为
-Swift 中`字符串（String）`,`数组（Array）`和`字典（Dictionary）`类型均以结构体的形式实现。这意味着String，Array，Dictionary类型数据被赋值给新的常量或变量，或者被传入函数或方法中时，它们的值会发生拷贝行为（值传递方式）。
+Swift 中，许多基本类型，诸如`String`，`Array`和`Dictionary`类型均以结构体的形式实现。这意味着被赋值给新的常量或变量，或者被传入函数或方法中时，它们的值会被拷贝。
-Objective-C中`字符串（NSString）`,`数组（NSArray）`和`字典（NSDictionary）`类型均以类的形式实现，这与Swfit中以值传递方式是不同的。NSString，NSArray，NSDictionary在发生赋值或者传入函数（或方法）时，不会发生值拷贝，而是传递已存在实例的引用。
+Objective-C 中`NSString`，`NSArray`和`NSDictionary`类型均以类的形式实现，而并非结构体。它们在被赋值或者被传入函数或方法时，不会发生值拷贝，而是传递现有实例的引用。
-
-> 注意：
-以上是对于字符串、数组、字典和其它值的`拷贝`的描述。
-在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在 Swift 的后台中，只有确有必要，`实际（actual）`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。（实际赋值由系统管理优化）
+> 注意
+> 以上是对字符串、数组、字典的“拷贝”行为的描述。在你的代码中，拷贝行为看起来似乎总会发生。然而，Swift 在幕后只在绝对必要时才执行实际的拷贝。Swift 管理所有的值拷贝以确保性能最优化，所以你没必要去回避赋值来保证性能最优化。
diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index fb806128..ee844243 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -1,427 +1,438 @@
-# 属性 (Properties)
+# 属性 (Properties)
---
-> 1.0
-> 翻译：[shinyzhu](https://github.com/shinyzhu)
-> 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
-
-> 2.0
-> 翻译+校对：[yangsiy](https://github.com/yangsiy)
-
-本页包含内容：
-
-- [存储属性（Stored Properties）](#stored_properties)
-- [计算属性（Computed Properties）](#computed_properties)
-- [属性观察器（Property Observers）](#property_observers)
-- [全局变量和局部变量（Global and Local Variables）](#global_and_local_variables)
-- [类型属性（Type Properties）](#type_properties)
-
-*属性*将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，而计算属性计算（不是存储）一个值。计算属性可以用于类、结构体和枚举，存储属性只能用于类和结构体。
-
-存储属性和计算属性通常与特定类型的实例关联。但是，属性也可以直接作用于类型本身，这种属性称为类型属性。
-
-另外，还可以定义属性观察器来监控属性值的变化，以此来触发一个自定义的操作。属性观察器可以添加到自己定义的存储属性上，也可以添加到从父类继承的属性上。
-
-
-## 存储属性
-
-简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
-
-可以在定义存储属性的时候指定默认值，请参考[默认属性值](./14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[在初始化阶段修改常量存储属性](./14_Initialization.html#assigning_constant_properties_during_initialization)一节。
-
-下面的例子定义了一个名为`FixedLengthRange`的结构体，它描述了一个在创建后无法修改值域宽度的区间：
-
-```swift
-struct FixedLengthRange {
- var firstValue: Int
- let length: Int
-}
-var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
-// 该区间表示整数0，1，2
-rangeOfThreeItems.firstValue = 6
-// 该区间现在表示整数6，7，8
-```
-
-`FixedLengthRange`的实例包含一个名为`firstValue`的变量存储属性和一个名为`length`的常量存储属性。在上面的例子中，`length`在创建实例的时候被初始化，因为它是一个常量存储属性，所以之后无法修改它的值。
-
-
-### 常量结构体的存储属性
-
-如果创建了一个结构体的实例并将其赋值给一个常量，则无法修改该实例的任何属性，即使定义了变量存储属性：
-
-```swift
-let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
-// 该区间表示整数0，1，2，3
-rangeOfFourItems.firstValue = 6
-// 尽管 firstValue 是个变量属性，这里还是会报错
-```
-
-因为`rangeOfFourItems`被声明成了常量（用`let`关键字），即使`firstValue`是一个变量属性，也无法再修改它了。
-
-这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
-
-属于*引用类型*的类（class）则不一样。把一个引用类型的实例赋给一个常量后，仍然可以修改该实例的变量属性。
-
-
-### 延迟存储属性
-
-延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用`lazy`来标示一个延迟存储属性。
-
-> 注意：
-> 必须将延迟存储属性声明成变量（使用`var`关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
-
-延迟属性很有用，当属性的值依赖于在实例的构造过程结束后才会知道具体值的外部因素时，或者当获得属性的初始值需要复杂或大量计算时，可以只在需要的时候计算它。
-
-下面的例子使用了延迟存储属性来避免复杂类中不必要的初始化。例子中定义了`DataImporter`和`DataManager`两个类，下面是部分代码：
-
-```swift
-class DataImporter {
- /*
- DataImporter 是一个将外部文件中的数据导入的类。
- 这个类的初始化会消耗不少时间。
- */
- var fileName = "data.txt"
- // 这是提供数据导入功能
-}
-
-class DataManager {
- lazy var importer = DataImporter()
- var data = [String]()
- // 这是提供数据管理功能
-}
-
-let manager = DataManager()
-manager.data.append("Some data")
-manager.data.append("Some more data")
-// DataImporter 实例的 importer 属性还没有被创建
-```
-
-`DataManager`类包含一个名为`data`的存储属性，初始值是一个空的字符串（`String`）数组。虽然没有写出全部代码，`DataManager`类的目的是管理和提供对这个字符串数组的访问。
-
-`DataManager`的一个功能是从文件导入数据。该功能由`DataImporter`类提供，`DataImporter`完成初始化需要消耗不少时间：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
-
-`DataManager`也可能不从文件中导入数据就完成了管理数据的功能。所以当`DataManager`的实例被创建时，没必要创建一个`DataImporter`的实例，更明智的是当第一次用到`DataImporter`的时候才去创建它。
-
-由于使用了`lazy`，`importer`属性只有在第一次被访问的时候才被创建。比如访问它的属性`fileName`时：
-
-```swift
-print(manager.importer.fileName)
-// DataImporter 实例的 importer 属性现在被创建了
-// 输出 "data.txt”
-```
-
-> 注意：
-> 如果一个被标记为`lazy`的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。
-
-
-### 存储属性和实例变量
-
-如果您有过 Objective-C 经验，应该知道 Objective-C 为类实例存储值和引用提供两种方法。对于属性来说，也可以使用实例变量作为属性值的后端存储。
-
-Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。
-
-
-## 计算属性
-
-除存储属性外，类、结构体和枚举可以定义*计算属性*。计算属性不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。
-
-```swift
-struct Point {
- var x = 0.0, y = 0.0
-}
-struct Size {
- var width = 0.0, height = 0.0
-}
-struct Rect {
- var origin = Point()
- var size = Size()
- var center: Point {
- get {
- let centerX = origin.x + (size.width / 2)
- let centerY = origin.y + (size.height / 2)
- return Point(x: centerX, y: centerY)
- }
- set(newCenter) {
- origin.x = newCenter.x - (size.width / 2)
- origin.y = newCenter.y - (size.height / 2)
- }
- }
-}
-var square = Rect(origin: Point(x: 0.0, y: 0.0),
- size: Size(width: 10.0, height: 10.0))
-let initialSquareCenter = square.center
-square.center = Point(x: 15.0, y: 15.0)
-print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
-// 输出 "square.origin is now at (10.0, 10.0)”
-```
-
-这个例子定义了 3 个结构体来描述几何形状：
-
-- `Point`封装了一个`(x, y)`的坐标
-- `Size`封装了一个`width`和一个`height`
-- `Rect`表示一个有原点和尺寸的矩形
-
-`Rect`也提供了一个名为`center`的计算属性。一个矩形的中心点可以从原点（`origin`）和尺寸（`size`）算出，所以不需要将它以显式声明的`Point`来保存。`Rect`的计算属性`center`提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
-
-上述例子中创建了一个名为`square`的`Rect`实例，初始值原点是`(0, 0)`，宽度高度都是`10`。如下图中蓝色正方形所示。
-
-`square`的`center`属性可以通过点运算符（`square.center`）来访问，这会调用该属性的 getter 来获取它的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的`Point`来表示`square`的中心点。如代码所示，它正确返回了中心点`(5, 5)`。
-
-`center`属性之后被设置了一个新的值`(15, 15)`，表示向右上方移动正方形到如下图橙色正方形所示的位置。设置属性`center`的值会调用它的 setter 来修改属性`origin`的`x`和`y`的值，从而实现移动正方形到新的位置。
-
-
-
-
-### 便捷 setter 声明
-
-如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称`newValue`。下面是使用了便捷 setter 声明的`Rect`结构体代码：
-
-```swift
-struct AlternativeRect {
- var origin = Point()
- var size = Size()
- var center: Point {
- get {
- let centerX = origin.x + (size.width / 2)
- let centerY = origin.y + (size.height / 2)
- return Point(x: centerX, y: centerY)
- }
- set {
- origin.x = newValue.x - (size.width / 2)
- origin.y = newValue.y - (size.height / 2)
- }
- }
-}
-```
-
-
-### 只读计算属性
-
-只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
-
-> 注意：
-> 必须使用`var`关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。
-
-只读计算属性的声明可以去掉`get`关键字和花括号：
-
-```swift
-struct Cuboid {
- var width = 0.0, height = 0.0, depth = 0.0
- var volume: Double {
- return width * height * depth
- }
-}
-let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
-print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
-// 输出 "the volume of fourByFiveByTwo is 40.0"
-```
-
-这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性。结构体还有一个名为`volume`的只读计算属性用来返回立方体的体积。设置`volume`的值毫无意义，因为无法确定修改`width`、`height`和`depth`三者中的哪些值来匹配新的`volume`，从而造成歧义。然而，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。
-
-
-## 属性观察器
-
-*属性观察器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。
-
-可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。属性重载请参考[重载](./13_Inheritance.html#overriding)。
-
-> 注意：
-> 不需要为非重载的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。
-
-可以为属性添加如下的一个或全部观察器：
-
-- `willSet`在新的值被设置之前调用
-- `didSet`在新的值被设置之后立即调用
-
-`willSet`观察器会将新的属性值作为常量参数传入，在`willSet`的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称`newValue`表示。
-
-类似地，`didSet`观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。
-
-> 注意：
-> 父类的属性在子类的构造器中被赋值时，它在父类中的`willSet`和`didSet`观察器会被调用。
-> 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)和[类的构造器代理规则](./14_Initialization.html#initializer_delegation_for_class_types)。
-
-这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
-
-```swift
-class StepCounter {
- var totalSteps: Int = 0 {
- willSet(newTotalSteps) {
- print("About to set totalSteps to \(newTotalSteps)")
- }
- didSet {
- if totalSteps > oldValue {
- print("Added \(totalSteps - oldValue) steps")
- }
- }
- }
-}
-let stepCounter = StepCounter()
-stepCounter.totalSteps = 200
-// About to set totalSteps to 200
-// Added 200 steps
-stepCounter.totalSteps = 360
-// About to set totalSteps to 360
-// Added 160 steps
-stepCounter.totalSteps = 896
-// About to set totalSteps to 896
-// Added 536 steps
-```
-
-`StepCounter`类定义了一个`Int`类型的属性`totalSteps`，它是一个存储属性，包含`willSet`和`didSet`观察器。
-
-当`totalSteps`设置新值的时候，它的`willSet`和`didSet`观察器都会被调用，甚至当新的值和现在的值完全相同也会调用。
-
-例子中的`willSet`观察器将表示新值的参数自定义为`newTotalSteps`，这个观察器只是简单的将新的值输出。
-
-`didSet`观察器在`totalSteps`的值改变后被调用，它把新的值和旧的值进行对比，如果总的步数增加了，就输出一个消息表示增加了多少步。`didSet`没有为旧的值提供自定义名称，所以默认值`oldValue`表示旧值的参数名。
-
-> 注意：
-> 如果在一个属性的`didSet`观察器里为它赋值，这个值会替换该观察器之前设置的值。
-
-
-##全局变量和局部变量
-
-计算属性和属性观察器所描述的模式也可以用于*全局变量*和*局部变量*。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。
-
-前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它提供特定类型的存储空间，并允许读取和写入。
-
-另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器。计算型变量跟计算属性一样，返回一个计算的值而不是存储值，声明格式也完全一样。
-
-> 注意：
-> 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`lazy`特性。
-> 局部范围的常量或变量不会延迟计算。
-
-
-##类型属性
-
-实例的属性属于一个特定类型实例，每次类型实例化后都拥有自己的一套属性值，实例之间的属性相互独立。
-
-也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
-
-类型属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
-
-值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样只能定义成变量属性。
-
-> 注意：
-> 跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类型属性赋值。
-> 存储型类型属性是延迟初始化的(lazily initialized)，它们只有在第一次被访问的时候才会被初始化。即使它们被多个线程同时访问，系统也保证只会对其进行初始化一次，并且不需要对其使用 `lazy` 修饰符。
-
-
-###类型属性语法
-
-在 C 或 Objective-C 中，与某个类型关联的静态常量和静态变量，是作为全局（*global*）静态变量定义的。但是在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
-
-使用关键字`static`来定义类型属性。在为类（class）定义计算型类型属性时，可以使用关键字`class`来支持子类对父类的实现进行重写。下面的例子演示了存储型和计算型类型属性的语法：
-
-```swift
-struct SomeStructure {
- static var storedTypeProperty = "Some value."
- static var computedTypeProperty: Int {
- return 1
- }
-}
-enum SomeEnumeration {
- static var storedTypeProperty = "Some value."
- static var computedTypeProperty: Int {
- return 6
- }
-}
-class SomeClass {
- static var storedTypeProperty = "Some value."
- static var computedTypeProperty: Int {
- return 27
- }
- class var overrideableComputedTypeProperty: Int {
- return 107
- }
-}
-```
-
-> 注意：
-> 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟实例计算属性的语法类似。
-
-
-###获取和设置类型属性的值
-
-跟实例的属性一样，类型属性的访问也是通过点运算符来进行。但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如：
-
-```swift
-print(SomeStructure.storedTypeProperty)
-// 输出 "Some value."
-SomeStructure.storedTypeProperty = "Another value."
-print(SomeStructure.storedTypeProperty)
-// 输出 "Another value.”
-print(SomeEnumeration.computedTypeProperty)
-// 输出 "6"
-print(SomeClass.computedTypeProperty)
-// 输出 "27"
-```
-
-下面的例子定义了一个结构体，使用两个存储型类型属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。
-
-后面的图表展示了如何联合使用两个声道来表示一个立体声的声音电平值。当声道的电平值是 0，没有一个灯会亮；当声道的电平值是 10，所有灯点亮。本图中，左声道的电平是 9，右声道的电平是 7。
-
-
-
-上面所描述的声道模型使用`AudioChannel`结构体的实例来表示：
-
-```swift
-struct AudioChannel {
- static let thresholdLevel = 10
- static var maxInputLevelForAllChannels = 0
- var currentLevel: Int = 0 {
- didSet {
- if currentLevel > AudioChannel.thresholdLevel {
- // 将新电平值设置为阀值
- currentLevel = AudioChannel.thresholdLevel
- }
- if currentLevel > AudioChannel.maxInputLevelForAllChannels {
- // 存储当前电平值作为新的最大输入电平
- AudioChannel.maxInputLevelForAllChannels = currentLevel
- }
- }
- }
-}
-```
-
-结构`AudioChannel`定义了 2 个存储型类型属性来实现上述功能。第一个是`thresholdLevel`，表示声音电平的最大上限阈值，它是一个取值为 10 的常量，对所有实例都可见，如果声音电平高于 10，则取最大上限值 10（见后面描述）。
-
-第二个类型属性是变量存储型属性`maxInputLevelForAllChannels`，它用来表示所有`AudioChannel`实例的电平值的最大值，初始值是 0。
-
-`AudioChannel`也定义了一个名为`currentLevel`的实例存储属性，表示当前声道现在的电平值，取值为 0 到 10。
-
-属性`currentLevel`包含`didSet`属性观察器来检查每次新设置后的属性值，它有如下两个检查：
-
-- 如果`currentLevel`的新值大于允许的阈值`thresholdLevel`，属性观察器将`currentLevel`的值限定为阈值`thresholdLevel`。
-- 如果前一个修正后的`currentLevel`值大于任何之前任意`AudioChannel`实例中的值，属性观察器将新值保存在静态类型属性`maxInputLevelForAllChannels`中。
-
-> 注意：
-> 在第一个检查过程中，`didSet`属性观察器将`currentLevel`设置成了不同的值，但这时不会再次调用属性观察器。
-
-可以使用结构体`AudioChannel`来创建表示立体声系统的两个声道`leftChannel`和`rightChannel`：
-
-```swift
-var leftChannel = AudioChannel()
-var rightChannel = AudioChannel()
-```
-
-如果将左声道的电平设置成 7，类型属性`maxInputLevelForAllChannels`也会更新成 7：
-
-```swift
-leftChannel.currentLevel = 7
-print(leftChannel.currentLevel)
-// 输出 "7"
-print(AudioChannel.maxInputLevelForAllChannels)
-// 输出 "7"
-```
-
-如果试图将右声道的电平设置成 11，则会将右声道的`currentLevel`修正到最大值 10，同时`maxInputLevelForAllChannels`的值也会更新到 10：
-
-```swift
-rightChannel.currentLevel = 11
-print(rightChannel.currentLevel)
-// 输出 "10"
-print(AudioChannel.maxInputLevelForAllChannels)
-// 输出 "10"
-```
+> 1.0
+> 翻译：[shinyzhu](https://github.com/shinyzhu)
+> 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
+
+
+> 2.0
+> 翻译+校对：[yangsiy](https://github.com/yangsiy)
+
+
+> 2.1
+> 翻译：[buginux](https://github.com/buginux)
+> 校对：[shanks](http://codebuild.me)，2015-10-29
+
+
+> 2.2
+> 翻译：[saitjr](https://github.com/saitjr)，2016-04-11，[SketchK](https://github.com/SketchK) 2016-05-13
+
+
+
+本页包含内容：
+
+- [存储属性（Stored Properties）](#stored_properties)
+- [计算属性（Computed Properties）](#computed_properties)
+- [属性观察器（Property Observers）](#property_observers)
+- [全局变量和局部变量（Global and Local Variables）](#global_and_local_variables)
+- [类型属性（Type Properties）](#type_properties)
+
+*属性*将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，而计算属性计算（不是存储）一个值。计算属性可以用于类、结构体和枚举，存储属性只能用于类和结构体。
+
+存储属性和计算属性通常与特定类型的实例关联。但是，属性也可以直接作用于类型本身，这种属性称为类型属性。
+
+另外，还可以定义属性观察器来监控属性值的变化，以此来触发一个自定义的操作。属性观察器可以添加到自己定义的存储属性上，也可以添加到从父类继承的属性上。
+
+
+## 存储属性
+
+简单来说，一个存储属性就是存储在特定类或结构体实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字 `var` 定义），也可以是*常量存储属性*（用关键字 `let` 定义）。
+
+可以在定义存储属性的时候指定默认值，请参考[默认构造器](./14_Initialization.html#default_initializers)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程中常量属性的修改](./14_Initialization.html#assigning_constant_properties_during_initialization)一节。
+
+下面的例子定义了一个名为 `FixedLengthRange` 的结构体，该结构体用于描述整数的范围，且这个范围值在被创建后不能被修改.
+
+```swift
+struct FixedLengthRange {
+ var firstValue: Int
+ let length: Int
+}
+var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
+// 该区间表示整数0，1，2
+rangeOfThreeItems.firstValue = 6
+// 该区间现在表示整数6，7，8
+```
+
+`FixedLengthRange` 的实例包含一个名为 `firstValue` 的变量存储属性和一个名为 `length` 的常量存储属性。在上面的例子中，`length` 在创建实例的时候被初始化，因为它是一个常量存储属性，所以之后无法修改它的值。
+
+
+### 常量结构体的存储属性
+
+如果创建了一个结构体的实例并将其赋值给一个常量，则无法修改该实例的任何属性，即使有属性被声明为变量也不行：
+
+```swift
+let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
+// 该区间表示整数0，1，2，3
+rangeOfFourItems.firstValue = 6
+// 尽管 firstValue 是个变量属性，这里还是会报错
+```
+
+因为 `rangeOfFourItems` 被声明成了常量（用 `let` 关键字），即使 `firstValue` 是一个变量属性，也无法再修改它了。
+
+这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
+
+属于*引用类型*的类（class）则不一样。把一个引用类型的实例赋给一个常量后，仍然可以修改该实例的变量属性。
+
+
+### 延迟存储属性
+
+延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 `lazy` 来标示一个延迟存储属性。
+
+> 注意
+> 必须将延迟存储属性声明成变量（使用 `var` 关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
+
+延迟属性很有用，当属性的值依赖于在实例的构造过程结束后才会知道影响值的外部因素时，或者当获得属性的初始值需要复杂或大量计算时，可以只在需要的时候计算它。
+
+下面的例子使用了延迟存储属性来避免复杂类中不必要的初始化。例子中定义了 `DataImporter` 和 `DataManager` 两个类，下面是部分代码：
+
+```swift
+class DataImporter {
+ /*
+ DataImporter 是一个负责将外部文件中的数据导入的类。
+ 这个类的初始化会消耗不少时间。
+ */
+ var fileName = "data.txt"
+ // 这里会提供数据导入功能
+}
+
+class DataManager {
+ lazy var importer = DataImporter()
+ var data = [String]()
+ // 这里会提供数据管理功能
+}
+
+let manager = DataManager()
+manager.data.append("Some data")
+manager.data.append("Some more data")
+// DataImporter 实例的 importer 属性还没有被创建
+```
+
+`DataManager` 类包含一个名为 `data` 的存储属性，初始值是一个空的字符串（`String`）数组。这里没有给出全部代码，只需知道 `DataManager` 类的目的是管理和提供对这个字符串数组的访问即可。
+
+`DataManager` 的一个功能是从文件导入数据。该功能由 `DataImporter` 类提供，`DataImporter` 完成初始化需要消耗不少时间：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
+
+`DataManager` 管理数据时也可能不从文件中导入数据。所以当 `DataManager` 的实例被创建时，没必要创建一个 `DataImporter` 的实例，更明智的做法是第一次用到 `DataImporter` 的时候才去创建它。
+
+由于使用了 `lazy` ，`importer` 属性只有在第一次被访问的时候才被创建。比如访问它的属性 `fileName` 时：
+
+```swift
+print(manager.importer.fileName)
+// DataImporter 实例的 importer 属性现在被创建了
+// 输出 "data.txt”
+```
+
+> 注意
+> 如果一个被标记为 `lazy` 的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。
+
+
+### 存储属性和实例变量
+
+如果您有过 Objective-C 经验，应该知道 Objective-C 为类实例存储值和引用提供两种方法。除了属性之外，还可以使用实例变量作为属性值的后端存储。
+
+Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。
+
+
+## 计算属性
+
+除存储属性外，类、结构体和枚举可以定义*计算属性*。计算属性不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。
+
+```swift
+struct Point {
+ var x = 0.0, y = 0.0
+}
+struct Size {
+ var width = 0.0, height = 0.0
+}
+struct Rect {
+ var origin = Point()
+ var size = Size()
+ var center: Point {
+ get {
+ let centerX = origin.x + (size.width / 2)
+ let centerY = origin.y + (size.height / 2)
+ return Point(x: centerX, y: centerY)
+ }
+ set(newCenter) {
+ origin.x = newCenter.x - (size.width / 2)
+ origin.y = newCenter.y - (size.height / 2)
+ }
+ }
+}
+var square = Rect(origin: Point(x: 0.0, y: 0.0),
+ size: Size(width: 10.0, height: 10.0))
+let initialSquareCenter = square.center
+square.center = Point(x: 15.0, y: 15.0)
+print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
+// 输出 "square.origin is now at (10.0, 10.0)”
+```
+
+这个例子定义了 3 个结构体来描述几何形状：
+
+- `Point` 封装了一个 `(x, y)` 的坐标
+- `Size` 封装了一个 `width` 和一个 `height`
+- `Rect` 表示一个有原点和尺寸的矩形
+
+`Rect`也提供了一个名为`center` 的计算属性。一个矩形的中心点可以从原点（`origin`）和大小（`size`）算出，所以不需要将它以显式声明的 `Point` 来保存。`Rect` 的计算属性 `center` 提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
+
+上述例子中创建了一个名为 `square` 的 `Rect` 实例，初始值原点是 `(0, 0)`，宽度高度都是 `10`。如下图中蓝色正方形所示。
+
+`square` 的 `center` 属性可以通过点运算符（`square.center`）来访问，这会调用该属性的 getter 来获取它的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的 `Point` 来表示 `square` 的中心点。如代码所示，它正确返回了中心点 `(5, 5)`。
+
+`center` 属性之后被设置了一个新的值 `(15, 15)`，表示向右上方移动正方形到如下图橙色正方形所示的位置。设置属性`center`的值会调用它的 setter 来修改属性 `origin` 的 `x` 和 `y` 的值，从而实现移动正方形到新的位置。
+
+
+
+
+### 便捷 setter 声明
+
+如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称 `newValue`。下面是使用了便捷 setter 声明的 `Rect` 结构体代码：
+
+```swift
+struct AlternativeRect {
+ var origin = Point()
+ var size = Size()
+ var center: Point {
+ get {
+ let centerX = origin.x + (size.width / 2)
+ let centerY = origin.y + (size.height / 2)
+ return Point(x: centerX, y: centerY)
+ }
+ set {
+ origin.x = newValue.x - (size.width / 2)
+ origin.y = newValue.y - (size.height / 2)
+ }
+ }
+}
+```
+
+
+### 只读计算属性
+
+只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
+
+> 注意
+> 必须使用 `var` 关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。`let` 关键字只用来声明常量属性，表示初始化后再也无法修改的值。
+
+只读计算属性的声明可以去掉 `get` 关键字和花括号：
+
+```swift
+struct Cuboid {
+ var width = 0.0, height = 0.0, depth = 0.0
+ var volume: Double {
+ return width * height * depth
+ }
+}
+let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
+print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
+// 输出 "the volume of fourByFiveByTwo is 40.0"
+```
+
+这个例子定义了一个名为 `Cuboid` 的结构体，表示三维空间的立方体，包含 `width`、`height` 和 `depth` 属性。结构体还有一个名为 `volume` 的只读计算属性用来返回立方体的体积。为 `volume` 提供 setter 毫无意义，因为无法确定如何修改 `width`、`height` 和 `depth` 三者的值来匹配新的 `volume`。然而，`Cuboid` 提供一个只读计算属性来让外部用户直接获取体积是很有用的。
+
+
+## 属性观察器
+
+*属性观察器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，即使新值和当前值相同的时候也不例外。
+
+可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重写属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。你不必为非重写的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。 属性重写请参考[重写](./13_Inheritance.html#overriding)。
+
+
+可以为属性添加如下的一个或全部观察器：
+
+- `willSet` 在新的值被设置之前调用
+- `didSet` 在新的值被设置之后立即调用
+
+`willSet` 观察器会将新的属性值作为常量参数传入，在 `willSet` 的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称 `newValue` 表示。
+
+同样，`didSet` 观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名 `oldValue`。如果在 `didSet` 方法中再次对该属性赋值，那么新值会覆盖旧的值。
+
+> 注意
+> 父类的属性在子类的构造器中被赋值时，它在父类中的 `willSet` 和 `didSet` 观察器会被调用，随后才会调用子类的观察器。在父类初始化方法调用之前，子类给属性赋值时，观察器不会被调用。
+> 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)和[类的构造器代理规则](./14_Initialization.html#initializer_delegation_for_class_types)。
+
+下面是一个 `willSet` 和 `didSet` 实际运用的例子，其中定义了一个名为 `StepCounter` 的类，用来统计一个人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
+
+```swift
+class StepCounter {
+ var totalSteps: Int = 0 {
+ willSet(newTotalSteps) {
+ print("About to set totalSteps to \(newTotalSteps)")
+ }
+ didSet {
+ if totalSteps > oldValue {
+ print("Added \(totalSteps - oldValue) steps")
+ }
+ }
+ }
+}
+let stepCounter = StepCounter()
+stepCounter.totalSteps = 200
+// About to set totalSteps to 200
+// Added 200 steps
+stepCounter.totalSteps = 360
+// About to set totalSteps to 360
+// Added 160 steps
+stepCounter.totalSteps = 896
+// About to set totalSteps to 896
+// Added 536 steps
+```
+
+`StepCounter` 类定义了一个 `Int` 类型的属性 `totalSteps`，它是一个存储属性，包含 `willSet` 和 `didSet` 观察器。
+
+当 `totalSteps` 被设置新值的时候，它的 `willSet` 和 `didSet` 观察器都会被调用，即使新值和当前值完全相同时也会被调用。
+
+例子中的 `willSet` 观察器将表示新值的参数自定义为 `newTotalSteps`，这个观察器只是简单的将新的值输出。
+
+`didSet` 观察器在 `totalSteps` 的值改变后被调用，它把新值和旧值进行对比，如果总步数增加了，就输出一个消息表示增加了多少步。`didSet` 没有为旧值提供自定义名称，所以默认值 `oldValue` 表示旧值的参数名。
+
+>注意
+>
+>如果将属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考[输入输出参数](../chapter3/05_Declarations.html#in-out_parameters)
+
+
+##全局变量和局部变量
+
+计算属性和属性观察器所描述的功能也可以用于*全局变量*和*局部变量*。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。
+
+前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它为特定类型的值提供存储空间，并允许读取和写入。
+
+另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器。计算型变量跟计算属性一样，返回一个计算结果而不是存储值，声明格式也完全一样。
+
+> 注意
+> 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`lazy`修饰符。
+> 局部范围的常量或变量从不延迟计算。
+
+
+##类型属性
+
+实例属性属于一个特定类型的实例，每创建一个实例，实例都拥有属于自己的一套属性值，实例之间的属性相互独立。
+
+也可以为类型本身定义属性，无论创建了多少个该类型的实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
+
+类型属性用于定义某个类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
+
+存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算型属性一样只能定义成变量属性。
+
+> 注意
+> 跟实例的存储型属性不同，必须给存储型类型属性指定默认值，因为类型本身没有构造器，也就无法在初始化过程中使用构造器给类型属性赋值。
+> 存储型类型属性是延迟初始化的，它们只有在第一次被访问的时候才会被初始化。即使它们被多个线程同时访问，系统也保证只会对其进行一次初始化，并且不需要对其使用 `lazy` 修饰符。
+
+
+###类型属性语法
+
+在 C 或 Objective-C 中，与某个类型关联的静态常量和静态变量，是作为全局（*global*）静态变量定义的。但是在 Swift 中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
+
+使用关键字 `static` 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 `class` 来支持子类对父类的实现进行重写。下面的例子演示了存储型和计算型类型属性的语法：
+
+```swift
+struct SomeStructure {
+ static var storedTypeProperty = "Some value."
+ static var computedTypeProperty: Int {
+ return 1
+ }
+}
+enum SomeEnumeration {
+ static var storedTypeProperty = "Some value."
+ static var computedTypeProperty: Int {
+ return 6
+ }
+}
+class SomeClass {
+ static var storedTypeProperty = "Some value."
+ static var computedTypeProperty: Int {
+ return 27
+ }
+ class var overrideableComputedTypeProperty: Int {
+ return 107
+ }
+}
+```
+
+> 注意
+> 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟计算型实例属性的语法相同。
+
+
+###获取和设置类型属性的值
+
+跟实例属性一样，类型属性也是通过点运算符来访问。但是，类型属性是通过类型本身来访问，而不是通过实例。比如：
+
+```swift
+print(SomeStructure.storedTypeProperty)
+// 输出 "Some value."
+SomeStructure.storedTypeProperty = "Another value."
+print(SomeStructure.storedTypeProperty)
+// 输出 "Another value.”
+print(SomeEnumeration.computedTypeProperty)
+// 输出 "6"
+print(SomeClass.computedTypeProperty)
+// 输出 "27"
+```
+
+下面的例子定义了一个结构体，使用两个存储型类型属性来表示两个声道的音量，每个声道具有 `0` 到 `10` 之间的整数音量。
+
+下图展示了如何把两个声道结合来模拟立体声的音量。当声道的音量是 `0`，没有一个灯会亮；当声道的音量是 `10`，所有灯点亮。本图中，左声道的音量是 `9`，右声道的音量是 `7`：
+
+
+
+上面所描述的声道模型使用 `AudioChannel` 结构体的实例来表示：
+
+```swift
+struct AudioChannel {
+ static let thresholdLevel = 10
+ static var maxInputLevelForAllChannels = 0
+ var currentLevel: Int = 0 {
+ didSet {
+ if currentLevel > AudioChannel.thresholdLevel {
+ // 将当前音量限制在阀值之内
+ currentLevel = AudioChannel.thresholdLevel
+ }
+ if currentLevel > AudioChannel.maxInputLevelForAllChannels {
+ // 存储当前音量作为新的最大输入音量
+ AudioChannel.maxInputLevelForAllChannels = currentLevel
+ }
+ }
+ }
+}
+```
+
+结构 `AudioChannel` 定义了 2 个存储型类型属性来实现上述功能。第一个是 `thresholdLevel`，表示音量的最大上限阈值，它是一个值为 `10` 的常量，对所有实例都可见，如果音量高于 `10`，则取最大上限值 `10`（见后面描述）。
+
+第二个类型属性是变量存储型属性 `maxInputLevelForAllChannels`，它用来表示所有 `AudioChannel` 实例的最大音量，初始值是`0`。
+
+`AudioChannel` 也定义了一个名为 `currentLevel` 的存储型实例属性，表示当前声道现在的音量，取值为 `0` 到 `10`。
+
+属性 `currentLevel` 包含 `didSet` 属性观察器来检查每次设置后的属性值，它做如下两个检查：
+
+- 如果 `currentLevel` 的新值大于允许的阈值 `thresholdLevel`，属性观察器将 `currentLevel` 的值限定为阈值 `thresholdLevel`。
+- 如果修正后的 `currentLevel` 值大于静态类型属性 `maxInputLevelForAllChannels` 的值，属性观察器就将新值保存在 `maxInputLevelForAllChannels` 中。
+
+> 注意
+> 在第一个检查过程中，`didSet` 属性观察器将 `currentLevel` 设置成了不同的值，但这不会造成属性观察器被再次调用。
+
+可以使用结构体 `AudioChannel` 创建两个声道 `leftChannel` 和 `rightChannel`，用以表示立体声系统的音量：
+
+```swift
+var leftChannel = AudioChannel()
+var rightChannel = AudioChannel()
+```
+
+如果将左声道的 `currentLevel` 设置成 `7`，类型属性 `maxInputLevelForAllChannels` 也会更新成 `7`：
+
+```swift
+leftChannel.currentLevel = 7
+print(leftChannel.currentLevel)
+// 输出 "7"
+print(AudioChannel.maxInputLevelForAllChannels)
+// 输出 "7"
+```
+
+如果试图将右声道的 `currentLevel` 设置成 `11`，它会被修正到最大值 `10`，同时 `maxInputLevelForAllChannels` 的值也会更新到 `10`：
+
+```swift
+rightChannel.currentLevel = 11
+print(rightChannel.currentLevel)
+// 输出 "10"
+print(AudioChannel.maxInputLevelForAllChannels)
+// 输出 "10"
+```
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index 79cbd413..437d533c 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -8,6 +8,12 @@
> 2.0
> 翻译+校对：[DianQK](https://github.com/DianQK)
+> 2.1
+> 翻译：[DianQK](https://github.com/DianQK)，[Realank](https://github.com/Realank) 校对：[shanks](http://codebuild.me)，2016-01-18
+>
+> 2.2
+> 校对：[SketchK](https://github.com/SketchK) 2016-05-13
+
本页包含内容：
- [实例方法(Instance Methods)](#instance_methods)
@@ -15,7 +21,7 @@
**方法**是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与 Objective-C 中的类方法（class methods）相似。
-结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。
+结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活地在你创建的类型（类/结构体/枚举）上定义方法。
## 实例方法 (Instance Methods)
@@ -28,16 +34,16 @@
```swift
class Counter {
- var count = 0
- func increment() {
- ++count
- }
- func incrementBy(amount: Int) {
- count += amount
- }
- func reset() {
- count = 0
- }
+ var count = 0
+ func increment() {
+ count += 1
+ }
+ func incrementBy(amount: Int) {
+ count += amount
+ }
+ func reset() {
+ count = 0
+ }
}
```
@@ -51,37 +57,37 @@ class Counter {
和调用属性一样，用点语法（dot syntax）调用实例方法：
```swift
- let counter = Counter()
- // 初始计数值是0
- counter.increment()
- // 计数值现在是1
- counter.incrementBy(5)
- // 计数值现在是6
- counter.reset()
- // 计数值现在是0
+let counter = Counter()
+// 初始计数值是0
+counter.increment()
+// 计数值现在是1
+counter.incrementBy(5)
+// 计数值现在是6
+counter.reset()
+// 计数值现在是0
```
-### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)
+### 方法的局部参数名称和外部参数名称 (Local and External Parameter Names for Methods)
函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[指定外部参数名](./06_Functions.html#specifying_external_parameter_names)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。
Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy(_:)`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。
-具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称；默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。
+具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称；默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让富于表达性的方法在调用时不需要再限定参数名称。
看看下面这个`Counter`的另一个版本（它定义了一个更复杂的`incrementBy(_:)`方法）：
```swift
class Counter {
- var count: Int = 0
- func incrementBy(amount: Int, numberOfTimes: Int) {
- count += amount * numberOfTimes
- }
+ var count: Int = 0
+ func incrementBy(amount: Int, numberOfTimes: Int) {
+ count += amount * numberOfTimes
+ }
}
```
-`incrementBy(_:numverOfTimes:)`方法有两个参数： `amount`和`numberOfTimes`。默认情况下，Swift 只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作局部名称又看作外部名称。下面调用这个方法：
+`incrementBy(_:numberOfTimes:)`方法有两个参数： `amount`和`numberOfTimes`。默认情况下，Swift 只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作局部名称又看作外部名称。下面调用这个方法：
```swift
let counter = Counter()
@@ -90,17 +96,16 @@ counter.incrementBy(5, numberOfTimes: 3)
```
你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy(_numberOfTimes:)`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。
-这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
+上面描述的这种默认行为意味着在 Swift 中，定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然且富于表达性的方式被调用。
### 修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)
-有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称作为第一个参数的前缀来把这个局部名称当作外部名称使用。
+有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你自己可以为第一个参数添加一个显式的外部名称。
相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（`_`）作为该参数的显式外部名称，这样做将覆盖默认行为。
-
### self 属性(The self Property)
@@ -110,11 +115,11 @@ counter.incrementBy(5, numberOfTimes: 3)
```swift
func increment() {
- self.count++
+ self.count += 1
}
```
-实际上，你不必在你的代码里面经常写`self`。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写`self`，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的`Counter`中已经示范了：`Counter`中的三个实例方法中都使用的是`count`（而不是`self.count`）。
+实际上，你不必在你的代码里面经常写`self`。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确地写`self`，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的`Counter`中已经示范了：`Counter`中的三个实例方法中都使用的是`count`（而不是`self.count`）。
使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用`self`属性来区分参数名称和属性名称。
@@ -122,14 +127,14 @@ func increment() {
```swift
struct Point {
- var x = 0.0, y = 0.0
- func isToTheRightOfX(x: Double) -> Bool {
- return self.x > x
- }
+ var x = 0.0, y = 0.0
+ func isToTheRightOfX(x: Double) -> Bool {
+ return self.x > x
+ }
}
let somePoint = Point(x: 4.0, y: 5.0)
if somePoint.isToTheRightOfX(1.0) {
- print("This point is to the right of the line where x == 1.0")
+ print("This point is to the right of the line where x == 1.0")
}
// 打印输出: This point is to the right of the line where x == 1.0
```
@@ -139,19 +144,19 @@ if somePoint.isToTheRightOfX(1.0) {
### 在实例方法中修改值类型(Modifying Value Types from Within Instance Methods)
-结构体和枚举是**值类型**。一般情况下，值类型的属性不能在它的实例方法中被修改。
+结构体和枚举是**值类型**。默认情况下，值类型的属性不能在它的实例方法中被修改。
-但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择`变异(mutating)`这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的`self`属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。
+但是，如果你确实需要在某个特定的方法中修改结构体或者枚举的属性，你可以为这个方法选择`可变(mutating)`行为，然后就可以从其方法内部改变它的属性；并且这个方法做的任何改变都会在方法执行结束时写回到原始结构中。方法还可以给它隐含的`self`属性赋予一个全新的实例，这个新实例在方法结束时会替换现存实例。
-要使用`变异`方法， 将关键字`mutating` 放到方法的`func`关键字之前就可以了：
+要使用`可变`方法，将关键字`mutating` 放到方法的`func`关键字之前就可以了：
```swift
struct Point {
- var x = 0.0, y = 0.0
- mutating func moveByX(deltaX: Double, y deltaY: Double) {
- x += deltaX
- y += deltaY
- }
+ var x = 0.0, y = 0.0
+ mutating func moveByX(deltaX: Double, y deltaY: Double) {
+ x += deltaX
+ y += deltaY
+ }
}
var somePoint = Point(x: 1.0, y: 1.0)
somePoint.moveByX(2.0, y: 3.0)
@@ -159,47 +164,47 @@ print("The point is now at (\(somePoint.x), \(somePoint.y))")
// 打印输出: "The point is now at (3.0, 4.0)"
```
-上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX(_:y:)`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字，这才让方法可以修改值类型的属性。
+上面的`Point`结构体定义了一个可变方法 `moveByX(_:y:)` 来移动`Point`实例到给定的位置。该方法被调用时修改了这个点，而不是返回一个新的点。方法定义时加上了`mutating`关键字，从而允许修改属性。
-注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量](./10_Properties.html#global_and_local_variables)：
+注意，不能在结构体类型的常量（a constant of structure type）上调用可变方法，因为其属性不能被改变，即使属性是变量属性，详情参见[常量结构体的存储属性](./10_Properties.html#stored_properties_of_constant_structure_instances)：
```swift
let fixedPoint = Point(x: 3.0, y: 3.0)
fixedPoint.moveByX(2.0, y: 3.0)
-// 这里将会抛出一个错误
+// 这里将会报告一个错误
```
-### 在变异方法中给self赋值(Assigning to self Within a Mutating Method)
+### 在可变方法中给 self 赋值(Assigning to self Within a Mutating Method)
-变异方法能够赋给隐含属性`self`一个全新的实例。上面`Point`的例子可以用下面的方式改写：
+可变方法能够赋给隐含属性`self`一个全新的实例。上面`Point`的例子可以用下面的方式改写：
```swift
struct Point {
- var x = 0.0, y = 0.0
- mutating func moveByX(deltaX: Double, y deltaY: Double) {
- self = Point(x: x + deltaX, y: y + deltaY)
- }
+ var x = 0.0, y = 0.0
+ mutating func moveByX(deltaX: Double, y deltaY: Double) {
+ self = Point(x: x + deltaX, y: y + deltaY)
+ }
}
```
-新版的变异方法`moveByX(_:y:)`创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。
+新版的可变方法`moveByX(_:y:)`创建了一个新的结构体实例，它的 x 和 y 的值都被设定为目标值。调用这个版本的方法和调用上个版本的最终结果是一样的。
-枚举的变异方法可以把`self`设置为相同的枚举类型中不同的成员：
+枚举的可变方法可以把`self`设置为同一枚举类型中不同的成员：
```swift
enum TriStateSwitch {
- case Off, Low, High
- mutating func next() {
- switch self {
- case Off:
- self = Low
- case Low:
- self = High
- case High:
- self = Off
+ case Off, Low, High
+ mutating func next() {
+ switch self {
+ case Off:
+ self = Low
+ case Low:
+ self = High
+ case High:
+ self = Off
+ }
}
- }
}
var ovenLight = TriStateSwitch.Low
ovenLight.next()
@@ -208,34 +213,34 @@ ovenLight.next()
// ovenLight 现在等于 .Off
```
-上面的例子中定义了一个三态开关的枚举。每次调用`next`方法时，开关在不同的电源状态（`Off`，`Low`，`High`）之前循环切换。
+上面的例子中定义了一个三态开关的枚举。每次调用`next()`方法时，开关在不同的电源状态（`Off`，`Low`，`High`）之间循环切换。
## 类型方法 (Type Methods)
-实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。类可能会用关键字`class`来允许子类重写父类的实现方法。
+实例方法是被某个类型的实例调用的方法。你也可以定义在类型本身上调用的方法，这种方法就叫做**类型方法**（Type Methods）。在方法的`func`关键字之前加上关键字`static`，来指定类型方法。类还可以用关键字`class`来允许子类重写父类的方法实现。
-> 注意：
-> 在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。
+> 注意
+> 在 Objective-C 中，你只能为 Objective-C 的类类型（classes）定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法。每一个类型方法都被它所支持的类型显式包含。
-类型方法和实例方法一样用点语法调用。但是，你是在类型层面上调用这个方法，而不是在实例层面上调用。下面是如何在`SomeClass`类上调用类型方法的例子：
+类型方法和实例方法一样用点语法调用。但是，你是在类型上调用这个方法，而不是在实例上调用。下面是如何在`SomeClass`类上调用类型方法的例子：
```swift
class SomeClass {
- static func someTypeMethod() {
- // type method implementation goes here
- }
+ class func someTypeMethod() {
+ // type method implementation goes here
+ }
}
SomeClass.someTypeMethod()
```
-在类型方法的方法体（body）中，`self`指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用`self`来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。
+在类型方法的方法体（body）中，`self`指向这个类型本身，而不是类型的某个实例。这意味着你可以用`self`来消除类型属性和类型方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。
-一般来说，任何未限定的方法和属性名称，将会来自于本类中另外的类型级别的方法和属性。一个类型方法可以调用本类中另一个类型方法的名称，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。
+一般来说，在类型方法的方法体中，任何未限定的方法和属性名称，可以被本类中其他的类型方法和类型属性引用。一个类型方法可以直接通过类型方法的名称调用本类中的其它类型方法，而无需在方法名称前面加上类型名称。类似地，在结构体和枚举中，也能够直接通过类型属性的名称访问本类中的类型属性，而不需要前面加上类型名称。
下面的例子定义了一个名为`LevelTracker`结构体。它监测玩家的游戏发展情况（游戏的不同层次或阶段）。这是一个单人游戏，但也可以存储多个玩家在同一设备上的游戏信息。
-游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。
+游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用类型属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。
```swift
struct LevelTracker {
@@ -258,11 +263,11 @@ struct LevelTracker {
}
```
-`LevelTracker`监测玩家的已解锁的最高等级。这个值被存储在静态属性`highestUnlockedLevel`中。
+`LevelTracker`监测玩家已解锁的最高等级。这个值被存储在类型属性`highestUnlockedLevel`中。
-`LevelTracker`还定义了两个类型方法与`highestUnlockedLevel`配合工作。第一个类型方法是`unlockLevel`：一旦新等级被解锁，它会更新`highestUnlockedLevel`的值。第二个类型方法是`levelIsUnlocked`：如果某个给定的等级已经被解锁，它将返回`true`。（注意：尽管我们没有使用类似`LevelTracker.highestUnlockedLevel`的写法，这个类型方法还是能够访问静态属性`highestUnlockedLevel`）
+`LevelTracker`还定义了两个类型方法与`highestUnlockedLevel`配合工作。第一个类型方法是`unlockLevel`，一旦新等级被解锁，它会更新`highestUnlockedLevel`的值。第二个类型方法是`levelIsUnlocked`，如果某个给定的等级已经被解锁，它将返回`true`。（注意，尽管我们没有使用类似`LevelTracker.highestUnlockedLevel`的写法，这个类型方法还是能够访问类型属性`highestUnlockedLevel`）
-除了静态属性和类型方法，`LevelTracker`还监测每个玩家的进度。它用实例属性`currentLevel`来监测玩家当前的等级。
+除了类型属性和类型方法，`LevelTracker`还监测每个玩家的进度。它用实例属性`currentLevel`来监测每个玩家当前的等级。
为了便于管理`currentLevel`属性，`LevelTracker`定义了实例方法`advanceToLevel`。这个方法会在更新`currentLevel`之前检查所请求的新等级是否已经解锁。`advanceToLevel`方法返回布尔值以指示是否能够设置`currentLevel`。
@@ -270,19 +275,19 @@ struct LevelTracker {
```swift
class Player {
- var tracker = LevelTracker()
- let playerName: String
- func completedLevel(level: Int) {
- LevelTracker.unlockLevel(level + 1)
- tracker.advanceToLevel(level + 1)
- }
- init(name: String) {
- playerName = name
- }
+ var tracker = LevelTracker()
+ let playerName: String
+ func completedLevel(level: Int) {
+ LevelTracker.unlockLevel(level + 1)
+ tracker.advanceToLevel(level + 1)
+ }
+ init(name: String) {
+ playerName = name
+ }
}
```
-`Player`类创建一个新的`LevelTracker`实例来监测这个用户的进度。它提供了`completedLevel`方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）。
+`Player`类创建一个新的`LevelTracker`实例来监测这个用户的进度。它提供了`completedLevel`方法，一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）。
你还可以为一个新的玩家创建一个`Player`的实例，然后看这个玩家完成等级一时发生了什么：
@@ -293,14 +298,14 @@ print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
// 打印输出：highest unlocked level is now 2
```
-如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：
+如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么试图设置玩家当前等级将会失败：
```swift
player = Player(name: "Beto")
if player.tracker.advanceToLevel(6) {
- print("player is now on level 6")
+ print("player is now on level 6")
} else {
- print("level 6 has not yet been unlocked")
+ print("level 6 has not yet been unlocked")
}
// 打印输出：level 6 has not yet been unlocked
```
diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index a09466c4..8c48dfa6 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -1,4 +1,4 @@
-# 下标脚本（Subscripts）
+# 下标（Subscripts）
-----------------
> 1.0
@@ -6,104 +6,109 @@
> 校对：[zq54zquan](https://github.com/zq54zquan)
> 2.0
-> 翻译+校对：[shanksyang](https://github.com/shanksyang)
+> 翻译+校对：[shanks](http://codebuild.me)
+
+> 2.1
+> 翻译+校对：[shanks](http://codebuild.me)，[Realank](https://github.com/Realank)
+
+> 2.2
+> 校对：[SketchK](https://github.com/SketchK) 2016-05-13
+
本页包含内容：
-- [下标脚本语法](#subscript_syntax)
-- [下标脚本用法](#subscript_usage)
-- [下标脚本选项](#subscript_options)
+- [下标语法](#subscript_syntax)
+- [下标用法](#subscript_usage)
+- [下标选项](#subscript_options)
-*下标脚本* 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问集合（collection），列表（list）或序列（sequence的快捷方式，使用下标脚本的索引设置和获取值，不需要再调用实例的特定的赋值和访问方法。举例来说，用下标脚本访问一个数组(Array)实例中的元素可以这样写 `someArray[index]` ，访问字典(Dictionary)实例中的元素可以这样写 `someDictionary[key]`。
+*下标* （subscripts）可以定义在类（class）、结构体（structure）和枚举（enumeration）中，是访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。可以使用下标的索引，设置和获取值，而不需要再调用对应的存取方法。举例来说，用下标访问一个`Array`实例中的元素可以写作`someArray[index]`，访问`Dictionary`实例中的元素可以写作`someDictionary[key]`。
-对于同一个目标可以定义多个下标脚本，通过索引值类型的不同来进行重载，下标脚本不限于单个纬度，你可以定义多个入参的下标脚本满足自定义类型的需求。
-
-> 译者：这里附属脚本重载在本小节中原文并没有任何演示
+一个类型可以定义多个下标，通过不同索引类型进行重载。下标不限于一维，你可以定义具有多个入参的下标满足自定义类型的需求。
-## 下标脚本语法
+## 下标语法
-下标脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和计算型属性的混合。与定义实例方法类似，定义下标脚本使用`subscript`关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是下标脚本可以设定为读写或只读。这种方式又有点像计算型属性的getter和setter：
+下标允许你通过在实例名称后面的方括号中传入一个或者多个索引值来对实例进行存取。语法类似于实例方法语法和计算型属性语法的混合。与定义实例方法类似，定义下标使用`subscript`关键字，指定一个或多个输入参数和返回类型；与实例方法不同的是，下标可以设定为读写或只读。这种行为由 getter 和 setter 实现，有点类似计算型属性：
```swift
subscript(index: Int) -> Int {
get {
- // 返回与入参匹配的Int类型的值
+ // 返回一个适当的 Int 类型的值
}
set(newValue) {
- // 执行赋值操作
+ // 执行适当的赋值操作
}
}
```
-`newValue`的类型必须和下标脚本定义的返回类型相同。与计算型属性相同的是set的入参声明`newValue`就算不写，在set代码块中依然可以使用默认的`newValue`这个变量来访问新赋的值。
+`newValue`的类型和下标的返回类型相同。如同计算型属性，可以不指定 setter 的参数（`newValue`）。如果不指定参数，setter 会提供一个名为`newValue`的默认参数。
-与只读计算型属性一样，可以直接将原本应该写在`get`代码块中的代码写在`subscript`中：
+如同只读计算型属性，可以省略只读下标的`get`关键字：
```swift
subscript(index: Int) -> Int {
- // 返回与入参匹配的Int类型的值
+ // 返回一个适当的 Int 类型的值
}
```
-下面代码演示了一个在`TimesTable`结构体中使用只读下标脚本的用法，该结构体用来展示传入整数的*n*倍。
+下面代码演示了只读下标的实现，这里定义了一个`TimesTable`结构体，用来表示传入整数的乘法表：
```swift
struct TimesTable {
let multiplier: Int
subscript(index: Int) -> Int {
- return multiplier * index
+ return multiplier * index
}
}
let threeTimesTable = TimesTable(multiplier: 3)
-print("3的6倍是\(threeTimesTable[6])")
-// 输出 "3的6倍是18"
+print("six times three is \(threeTimesTable[6])")
+// 输出 "six times three is 18"
```
-在上例中，通过`TimesTable`结构体创建了一个用来表示索引值三倍的实例。数值`3`作为结构体`构造函数`入参初始化实例成员`multiplier`。
+在上例中，创建了一个`TimesTable`实例，用来表示整数`3`的乘法表。数值`3`被传递给结构体的构造函数，作为实例成员`multiplier`的值。
-你可以通过下标脚本来得到结果，比如`threeTimesTable[6]`。这条语句访问了`threeTimesTable`的第六个元素，返回`6`的`3`倍即`18`。
+你可以通过下标访问`threeTimesTable`实例，例如上面演示的`threeTimesTable[6]`。这条语句查询了`3`的乘法表中的第六个元素，返回`3`的`6`倍即`18`。
->注意：
-> `TimesTable`例子是基于一个固定的数学公式。它并不适合对`threeTimesTable[someIndex]`进行赋值操作，这也是为什么附属脚本只定义为只读的原因。
+> 注意
+> `TimesTable`例子基于一个固定的数学公式，对`threeTimesTable[someIndex]`进行赋值操作并不合适，因此下标定义为只读的。
-## 下标脚本用法
+## 下标用法
-根据使用场景不同下标脚本也具有不同的含义。通常下标脚本是用来访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。你可以在你自己特定的类或结构体中自由的实现下标脚本来提供合适的功能。
+下标的确切含义取决于使用场景。下标通常作为访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。你可以针对自己特定的类或结构体的功能来自由地以最恰当的方式实现下标。
-例如，Swift 的字典（Dictionary）实现了通过下标脚本来对其实例中存放的值进行存取操作。在下标脚本中使用和字典索引相同类型的值，并且把一个字典值类型的值赋值给这个下标脚本来为字典设值：
+例如，Swift 的`Dictionary`类型实现下标用于对其实例中储存的值进行存取操作。为字典设值时，在下标中使用和字典的键类型相同的键，并把一个和字典的值类型相同的值赋给这个下标：
```swift
var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
numberOfLegs["bird"] = 2
```
-上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`[String:Int]`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
+上例定义一个名为`numberOfLegs`的变量，并用一个包含三对键值的字典字面量初始化它。`numberOfLegs`字典的类型被推断为`[String: Int]`。字典创建完成后，该例子通过下标将`String`类型的键`bird`和`Int`类型的值`2`添加到字典中。
-更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](./04_Collection_Types.html#accessing_and_modifying_a_dictionary)
+更多关于`Dictionary`下标的信息请参考[读取和修改字典](./04_Collection_Types.html#accessing_and_modifying_a_dictionary)
-> 注意：
-> Swift 中字典的附属脚本实现中，在`get`部分返回值是`Int?`，上例中的`numberOfLegs`字典通过附属脚本返回的是一个`Int?`或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。
+> 注意
+> Swift 的`Dictionary`类型的下标接受并返回可选类型的值。上例中的`numberOfLegs`字典通过下标返回的是一个`Int?`或者说“可选的int”。`Dictionary`类型之所以如此实现下标，是因为不是每个键都有个对应的值，同时这也提供了一种通过键删除对应值的方式，只需将键对应的值赋值为`nil`即可。
-## 下标脚本选项
+## 下标选项
-下标脚本允许任意数量的入参索引，并且每个入参类型也没有限制。下标脚本的返回值也可以是任何类型。下标脚本可以使用变量参数和可变参数，但使用写入读出（in-out）参数或给参数设置默认值都是不允许的。
+下标可以接受任意数量的入参，并且这些入参可以是任意类型。下标的返回值也可以是任意类型。下标可以使用变量参数和可变参数，但不能使用输入输出参数，也不能给参数设置默认值。
-一个类或结构体可以根据自身需要提供多个下标脚本实现，在定义下标脚本时通过入参的类型进行区分，使用下标脚本时会自动匹配合适的下标脚本实现运行，这就是*下标脚本的重载*。
+一个类或结构体可以根据自身需要提供多个下标实现，使用下标时将通过入参的数量和类型进行区分，自动匹配合适的下标，这就是*下标的重载*。
-一个下标脚本入参是最常见的情况，但只要有合适的场景也可以定义多个下标脚本入参。如下例定义了一个`Matrix`结构体，将呈现一个`Double`类型的二维矩阵。`Matrix`结构体的下标脚本需要两个整型参数：
+虽然接受单一入参的下标是最常见的，但也可以根据情况定义接受多个入参的下标。例如下例定义了一个`Matrix`结构体，用于表示一个`Double`类型的二维矩阵。`Matrix`结构体的下标接受两个整型参数：
```swift
struct Matrix {
let rows: Int, columns: Int
var grid: [Double]
init(rows: Int, columns: Int) {
- self.rows = rows
- self.columns = columns
- grid = Array(count: rows * columns, repeatedValue: 0.0)
+ self.rows = rows
+ self.columns = columns
+ grid = Array(count: rows * columns, repeatedValue: 0.0)
}
func indexIsValidForRow(row: Int, column: Int) -> Bool {
return row >= 0 && row < rows && column >= 0 && column < columns
@@ -121,7 +126,7 @@ struct Matrix {
}
```
-`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。通过传入数组长度和初始值0.0到数组的一个构造器，将`Matrix`中每个元素初始值0.0。关于数组的构造方法和析构方法请参考[创建一个空数组](./04_Collection_Types.html#creating_an_empty_array)。
+`Matrix`提供了一个接受两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个`Double`类型的值的数组。通过传入数组长度和初始值`0.0`到数组的构造器，将矩阵中每个位置的值初始化为`0.0`。关于数组的这种构造方法请参考[创建一个空数组](./04_Collection_Types.html#creating_an_empty_array)。
你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例：
@@ -129,32 +134,22 @@ struct Matrix {
var matrix = Matrix(rows: 2, columns: 2)
```
-上例中创建了一个新的两行两列的`Matrix`实例。在阅读顺序从左上到右下的`Matrix`实例中的数组实例`grid`是矩阵二维数组的扁平化存储：
+上例中创建了一个`Matrix`实例来表示两行两列的矩阵。该`Matrix`实例的`grid`数组按照从左上到右下的阅读顺序将矩阵扁平化存储：
-```swift
-// 示意图
-grid = [0.0, 0.0, 0.0, 0.0]
+
- col0 col1
-row0 [0.0, 0.0,
-row1 0.0, 0.0]
-```
-
-将值赋给带有`row`和`column`下标脚本的`matrix`实例表达式可以完成赋值操作，下标脚本入参使用逗号分割
+将`row`和`column`的值传入下标来为矩阵设值，下标的入参使用逗号分隔：
```swift
matrix[0, 1] = 1.5
matrix[1, 0] = 3.2
```
-上面两条语句分别`让matrix`的右上值为 1.5，坐下值为 3.2：
+上面两条语句分别调用下标的 setter 将矩阵右上角位置（即`row`为`0`、`column`为`1`的位置）的值设置为`1.5`，将矩阵左下角位置（即`row`为`1`、`column`为`0`的位置）的值设置为`3.2`：
-```swift
-[0.0, 1.5,
- 3.2, 0.0]
-```
+
-`Matrix`下标脚本的`getter`和`setter`中同时调用了下标脚本入参的`row`和`column`是否有效的判断。为了方便进行断言，`Matrix`包含了一个名为`indexIsValidForRow(_:column:)`的成员方法，用来确认入参的`row`或`column`值是否会造成数组越界：
+`Matrix`下标的 getter 和 setter 中都含有断言，用来检查下标入参`row`和`column`的值是否有效。为了方便进行断言，`Matrix`包含了一个名为`indexIsValidForRow(_:column:)`的便利方法，用来检查入参`row`和`column`的值是否在矩阵范围内：
```swift
func indexIsValidForRow(row: Int, column: Int) -> Bool {
@@ -162,9 +157,9 @@ func indexIsValidForRow(row: Int, column: Int) -> Bool {
}
```
-断言在下标脚本越界时触发：
+断言在下标越界时触发：
```swift
let someValue = matrix[2, 2]
-// 断言将会触发，因为 [2, 2] 已经超过了matrix的最大长度
+// 断言将会触发，因为 [2, 2] 已经超过了 matrix 的范围
```
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index b4d94657..64028c3d 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -1,35 +1,38 @@
# 继承（Inheritance）
--------------------
-
+-------------------
+
> 1.0
> 翻译：[Hawstein](https://github.com/Hawstein)
> 校对：[menlongsheng](https://github.com/menlongsheng)
-> 2.0
-> 翻译+校对：[shanksyang](https://github.com/shanksyang)
+> 2.0，2.1
+> 翻译+校对：[shanks](http://codebuild.me)
+>
+> 2.2
+> 校对：[SketchK](https://github.com/SketchK) 2016-05-13
本页包含内容：
-- [定义一个基类（Base class）](#defining_a_base_class)
+- [定义一个基类（Defining a Base Class）](#defining_a_base_class)
- [子类生成（Subclassing）](#subclassing)
- [重写（Overriding）](#overriding)
-- [防止重写](#preventing_overrides)
+- [防止重写（Preventing Overrides）](#preventing_overrides)
一个类可以*继承（inherit）*另一个类的方法（methods），属性（properties）和其它特性。当一个类继承其它类时，继承类叫*子类（subclass）*，被继承类叫*超类（或父类，superclass）*。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。
-在 Swift 中，类可以调用和访问超类的方法，属性和下标脚本（subscripts），并且可以重写（override）这些方法，属性和下标脚本来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。
+在 Swift 中，类可以调用和访问超类的方法，属性和下标（subscripts），并且可以重写（override）这些方法，属性和下标来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。
可以为类中继承来的属性添加属性观察器（property observers），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。
-## 定义一个基类（Base class）
+## 定义一个基类（Defining a Base Class）
-不继承于其它类的类，称之为*基类（base calss）*。
+不继承于其它类的类，称之为*基类（base class）*。
-> 注意：
+> 注意
Swift 中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。
-下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了一个名为`currentSpeed `，默认值是0.0的存储属性(属性类型推断为`Double `)。`currentSpeed `属性的值被一个`String` 类型的只读计算型属性`description`使用，用来创建车辆的描述。
+下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了一个名为`currentSpeed `，默认值是`0.0`的存储属性（属性类型推断为`Double`）。`currentSpeed`属性的值被一个`String`类型的只读计算型属性`description`使用，用来创建车辆的描述。
`Vehicle`基类也定义了一个名为`makeNoise`的方法。这个方法实际上不为`Vehicle`实例做任何事，但之后将会被`Vehicle`的子类定制：
@@ -45,34 +48,35 @@ class Vehicle {
}
```
-您可以用初始化语法创建一个`Vehicle `的新实例，即类名后面跟一个空括号：
+您可以用初始化语法创建一个`Vehicle`的新实例，即类名后面跟一个空括号：
+
```swift
let someVehicle = Vehicle()
```
-现在已经创建了一个`Vehicle`的新实例，你可以访问它的`description`属性来打印车辆的当前速度。
+现在已经创建了一个`Vehicle`的新实例，你可以访问它的`description`属性来打印车辆的当前速度：
```swift
print("Vehicle: \(someVehicle.description)")
// Vehicle: traveling at 0.0 miles per hour
```
-`Vehicle`类定义了一个通用特性的车辆类，实际上没什么用处。为了让它变得更加有用，需要改进它能够描述一个更加具体的车辆类。
+`Vehicle`类定义了一个通用特性的车辆类，实际上没什么用处。为了让它变得更加有用，需要完善它从而能够描述一个更加具体类型的车辆。
## 子类生成（Subclassing）
-*子类生成（Subclassing）*指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以优化或改变它。你还可以为子类添加新的特性。
+*子类生成（Subclassing）*指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以进一步完善。你还可以为子类添加新的特性。
为了指明某个类的超类，将超类名写在子类名的后面，用冒号分隔：
```swift
class SomeClass: SomeSuperclass {
- // 类的定义
+ // 这里是子类的定义
}
```
-下一个例子，定义一个叫`Bicycle`的子类，继承成父类`Vehicle`
+下一个例子，定义一个叫`Bicycle`的子类，继承成父类`Vehicle`：
```swift
class Bicycle: Vehicle {
@@ -80,18 +84,18 @@ class Bicycle: Vehicle {
}
```
-新的`Bicycle`类自动获得`Vehicle`类的所有特性，比如 `currentSpeed `和`description`属性，还有它的`makeNoise`方法。
+新的`Bicycle`类自动获得`Vehicle`类的所有特性，比如`currentSpeed`和`description`属性，还有它的`makeNoise()`方法。
除了它所继承的特性，`Bicycle`类还定义了一个默认值为`false`的存储型属性`hasBasket`（属性推断为`Bool`）。
-默认情况下，你创建任何新的`Bicycle`实例将不会有一个篮子，创建该实例之后，你可以为特定的`Bicycle`实例设置`hasBasket `属性为`ture`：
+默认情况下，你创建任何新的`Bicycle`实例将不会有一个篮子（即`hasBasket`属性默认为`false`），创建该实例之后，你可以为特定的`Bicycle`实例设置`hasBasket`属性为`ture`：
```swift
let bicycle = Bicycle()
bicycle.hasBasket = true
```
-你还可以修改`Bicycle `实例所继承的`currentSpeed `属性，和查询实例所继承的`description `属性：
+你还可以修改`Bicycle`实例所继承的`currentSpeed`属性，和查询实例所继承的`description`属性：
```swift
bicycle.currentSpeed = 15.0
@@ -99,7 +103,7 @@ print("Bicycle: \(bicycle.description)")
// Bicycle: traveling at 15.0 miles per hour
```
-子类还可以继续被其它类继承，下面的示例为`Bicycle `创建了一个名为`Tandem `（双人自行车）的子类：
+子类还可以继续被其它类继承，下面的示例为`Bicycle`创建了一个名为`Tandem`（双人自行车）的子类：
```swift
class Tandem: Bicycle {
@@ -107,9 +111,9 @@ class Tandem: Bicycle {
}
```
-`Tandem`从`Bicycle`继承了所有的属性与方法，这又使它同时继承了`Vehicle`的所有属性与方法。`Tandem`也增加了一个新的叫做`currentNumberOfPassengers`的存储型属性，默认值为0。
+`Tandem`从`Bicycle`继承了所有的属性与方法，这又使它同时继承了`Vehicle`的所有属性与方法。`Tandem`也增加了一个新的叫做`currentNumberOfPassengers`的存储型属性，默认值为`0`。
-如果你创建了一个`Tandem`的实例，你可以使用它所有的新属性和继承的属性，还能查询从`Vehicle`继承来的只读属性`description `：
+如果你创建了一个`Tandem`的实例，你可以使用它所有的新属性和继承的属性，还能查询从`Vehicle`继承来的只读属性`description`：
```swift
let tandem = Tandem()
@@ -123,27 +127,27 @@ print("Tandem: \(tandem.description)")
## 重写（Overriding）
-子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或下标脚本（subscript）提供自己定制的实现（implementation）。我们把这种行为叫*重写（overriding）*。
+子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或下标（subscript）提供自己定制的实现（implementation）。我们把这种行为叫*重写（overriding）*。
如果要重写某个特性，你需要在重写定义的前面加上`override`关键字。这么做，你就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少`override`关键字的重写都会在编译时被诊断为错误。
`override`关键字会提醒 Swift 编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。
-### 访问超类的方法，属性及下标脚本
+### 访问超类的方法，属性及下标
-当你在子类中重写超类的方法，属性或下标脚本时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以优化已有实现的行为，或在一个继承来的变量中存储一个修改过的值。
+当你在子类中重写超类的方法，属性或下标时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以完善已有实现的行为，或在一个继承来的变量中存储一个修改过的值。
-在合适的地方，你可以通过使用`super`前缀来访问超类版本的方法，属性或下标脚本：
+在合适的地方，你可以通过使用`super`前缀来访问超类版本的方法，属性或下标：
-* 在方法`someMethod`的重写实现中，可以通过`super.someMethod()`来调用超类版本的`someMethod`方法。
+* 在方法`someMethod()`的重写实现中，可以通过`super.someMethod()`来调用超类版本的`someMethod()`方法。
* 在属性`someProperty`的 getter 或 setter 的重写实现中，可以通过`super.someProperty`来访问超类版本的`someProperty`属性。
-* 在下标脚本的重写实现中，可以通过`super[someIndex]`来访问超类版本中的相同下标脚本。
+* 在下标的重写实现中，可以通过`super[someIndex]`来访问超类版本中的相同下标。
### 重写方法
在子类中，你可以重写继承来的实例方法或类方法，提供一个定制或替代的方法实现。
-下面的例子定义了`Vehicle`的一个新的子类，叫`Train `，它重写了从`Vehicle`类继承来的`makeNoise `方法：
+下面的例子定义了`Vehicle`的一个新的子类，叫`Train`，它重写了从`Vehicle`类继承来的`makeNoise()`方法：
```swift
class Train: Vehicle {
@@ -153,28 +157,28 @@ class Train: Vehicle {
}
```
-如果你创建一个`Train `的新实例，并调用了它的`makeNoise `方法，你就会发现`Train `版本的方法被调用：
+如果你创建一个`Train`的新实例，并调用了它的`makeNoise()`方法，你就会发现`Train`版本的方法被调用：
```swift
let train = Train()
train.makeNoise()
-// prints "Choo Choo"
+// 打印 "Choo Choo"
```
### 重写属性
-你可以重写继承来的实例属性或类属性，提供自己定制的getter和setter，或添加属性观察器使重写的属性可以观察属性值什么时候发生改变。
+你可以重写继承来的实例属性或类型属性，提供自己定制的 getter 和 setter，或添加属性观察器使重写的属性可以观察属性值什么时候发生改变。
-#### 重写属性的Getters和Setters
+#### 重写属性的 Getters 和 Setters
你可以提供定制的 getter（或 setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。
-你可以将一个继承来的只读属性重写为一个读写属性，只需要你在重写版本的属性里提供 getter 和 setter 即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。
+你可以将一个继承来的只读属性重写为一个读写属性，只需要在重写版本的属性里提供 getter 和 setter 即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。
-> 注意：
+> 注意
如果你在重写属性中提供了 setter，那么你也一定要提供 getter。如果你不想在重写版本中的 getter 里修改继承来的属性值，你可以直接通过`super.someProperty`来返回继承来的值，其中`someProperty`是你要重写的属性的名字。
-以下的例子定义了一个新类，叫`Car`，它是`Vehicle `的子类。这个类引入了一个新的存储型属性叫做`gear `，默认为整数1。`Car`类重写了继承自`Vehicle `的description属性，提供自定义的，包含当前档位的描述：
+以下的例子定义了一个新类，叫`Car`，它是`Vehicle`的子类。这个类引入了一个新的存储型属性叫做`gear`，默认值为整数`1`。`Car`类重写了继承自`Vehicle`的`description`属性，提供包含当前档位的自定义描述：
```swift
class Car: Vehicle {
@@ -185,9 +189,9 @@ class Car: Vehicle {
}
```
-重写的`description `属性，首先要调用`super.description`返回`Vehicle`类的`description`属性。之后，`Car `类版本的`description`在末尾增加了一些额外的文本来提供关于当前档位的信息。
+重写的`description`属性首先要调用`super.description`返回`Vehicle`类的`description`属性。之后，`Car`类版本的`description`在末尾增加了一些额外的文本来提供关于当前档位的信息。
-如果你创建了`Car `的实例并且设置了它的`gear`和`currentSpeed`属性，你可以看到它的`description`返回了`Car`中定义的`description`：
+如果你创建了`Car`的实例并且设置了它的`gear`和`currentSpeed`属性，你可以看到它的`description`返回了`Car`中的自定义描述：
```swift
let car = Car()
@@ -197,12 +201,14 @@ print("Car: \(car.description)")
// Car: traveling at 25.0 miles per hour in gear 3
```
+
#### 重写属性观察器（Property Observer）
-你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看[属性观察器](../chapter2/10_Properties.html#property_observers)。
+你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看[属性观察器](../chapter2/10_Properties.html#property_observers)。
-> 注意：
-你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供`willSet`或`didSet`实现是不恰当。此外还要注意，你不可以同时提供重写的 setter 和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的 setter，那么你在 setter 中就可以观察到任何值变化了。
+> 注意
+你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供`willSet`或`didSet`实现是不恰当。
+此外还要注意，你不可以同时提供重写的 setter 和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的 setter，那么你在 setter 中就可以观察到任何值变化了。
下面的例子定义了一个新类叫`AutomaticCar`，它是`Car`的子类。`AutomaticCar`表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位:
@@ -216,7 +222,7 @@ class AutomaticCar: Car {
}
```
-当你设置`AutomaticCar`的`currentSpeed `属性，属性的`didSet`观察器就会自动地设置`gear`属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位`gear`的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4：
+当你设置`AutomaticCar`的`currentSpeed`属性，属性的`didSet`观察器就会自动地设置`gear`属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以`10`，然后向下取得最接近的整数值，最后加`1`来得到档位`gear`的值。例如，速度为`35.0`时，挡位为`4`：
```swift
let automatic = AutomaticCar()
@@ -228,8 +234,8 @@ print("AutomaticCar: \(automatic.description)")
## 防止重写
-你可以通过把方法，属性或下标脚本标记为*`final`*来防止它们被重写，只需要在声明关键字前加上`final`特性即可。（例如：`final var`, `final func`, `final class func`, 以及 `final subscript`）
+你可以通过把方法，属性或下标标记为*`final`*来防止它们被重写，只需要在声明关键字前加上`final`修饰符即可（例如：`final var`，`final func`，`final class func`，以及`final subscript`）。
-如果你重写了`final`方法，属性或下标脚本，在编译时会报错。在类扩展中的方法，属性或下标脚本也可以在扩展的定义里标记为 final。
+如果你重写了带有`final`标记的方法，属性或下标，在编译时会报错。在类扩展中的方法，属性或下标也可以在扩展的定义里标记为 final 的。
-你可以通过在关键字`class`前添加`final`特性（`final class`）来将整个类标记为 final 的，这样的类是不可被继承的，任何子类试图继承此类时，在编译时会报错。
+你可以通过在关键字`class`前添加`final`修饰符（`final class`）来将整个类标记为 final 的。这样的类是不可被继承的，试图继承这样的类会导致编译报错。
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 31a9c054..16f73f68 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -8,37 +8,46 @@
> 2.0
> 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
+> 2.1
+> 翻译：[Channe](https://github.com/Channe)，[Realank](https://github.com/Realank)
+> 校对：[shanks](http://codebuild.me)，2016-1-23
+
+> 2.2
+> 翻译：[pmst](https://github.com/colourful987)
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-14
+
本页包含内容：
-- [存储型属性的初始赋值](#setting_initial_values_for_stored_properties)
+- [存储属性的初始赋值](#setting_initial_values_for_stored_properties)
- [自定义构造过程](#customizing_initialization)
- [默认构造器](#default_initializers)
- [值类型的构造器代理](#initializer_delegation_for_value_types)
- [类的继承和构造过程](#class_inheritance_and_initialization)
- [可失败构造器](#failable_initializers)
- [必要构造器](#required_initializers)
-- [通过闭包和函数来设置属性的默认值](#setting_a_default_property_value_with_a_closure_or_function)
+- [通过闭包或函数设置属性的默认值](#setting_a_default_property_value_with_a_closure_or_function)
-构造过程是使用类、结构体或枚举类型一个实例的准备过程。在新实例可用前必须执行这个过程，具体操作包括设置实例中每个存储型属性的初始值和执行其他必须的设置或初始化工作。
+构造过程是使用类、结构体或枚举类型的实例之前的准备过程。在新实例可用前必须执行这个过程，具体操作包括设置实例中每个存储型属性的初始值和执行其他必须的设置或初始化工作。
通过定义构造器（`Initializers`）来实现构造过程，这些构造器可以看做是用来创建特定类型新实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。
类的实例也可以通过定义析构器（`deinitializer`）在实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](./15_Deinitialization.html)。
-## 设置存储型属性的初始值
+## 存储属性的初始赋值
类和结构体在创建实例时，必须为所有存储型属性设置合适的初始值。存储型属性的值不能处于一个未知的状态。
你可以在构造器中为存储型属性赋初值，也可以在定义属性时为其设置默认值。以下小节将详细介绍这两种方法。
->注意：
+> 注意
当你为存储型属性设置默认值或者在构造器中为其赋值时，它们的值是被直接设置的，不会触发任何属性观察者（`property observers`）。
+
### 构造器
-构造器在创建某特定类型的新实例时调用。它的最简形式类似于一个不带任何参数的实例方法，以关键字`init`命名。
+构造器在创建某个特定类型的新实例时被调用。它的最简形式类似于一个不带任何参数的实例方法，以关键字`init`命名：
```swift
init() {
@@ -60,14 +69,15 @@ print("The default temperature is \(f.temperature)° Fahrenheit")
// 输出 "The default temperature is 32.0° Fahrenheit”
```
-这个结构体定义了一个不带参数的构造器`init`，并在里面将存储型属性`temperature`的值初始化为`32.0`（华摄氏度下水的冰点）。
+这个结构体定义了一个不带参数的构造器`init`，并在里面将存储型属性`temperature`的值初始化为`32.0`（华氏温度下水的冰点）。
+
### 默认属性值
如前所述，你可以在构造器中为存储型属性设置初始值。同样，你也可以在属性声明时为其设置默认值。
->注意：
-如果一个属性总是使用相同的初始值，那么为其设置一个默认值比每次都在构造器中赋值要好。两种方法的效果是一样的，只不过使用默认值让属性的初始化和声明结合的更紧密。使用默认值能让你的构造器更简洁、更清晰，且能通过默认值自动推导出属性的类型；同时，它也能让你充分利用默认构造器、构造器继承等特性（后续章节将讲到）。
+> 注意
+如果一个属性总是使用相同的初始值，那么为其设置一个默认值比每次都在构造器中赋值要好。两种方法的效果是一样的，只不过使用默认值让属性的初始化和声明结合得更紧密。使用默认值能让你的构造器更简洁、更清晰，且能通过默认值自动推导出属性的类型；同时，它也能让你充分利用默认构造器、构造器继承等特性（后续章节将讲到）。
你可以使用更简单的方式在定义结构体`Fahrenheit`时为属性`temperature`设置默认值：
@@ -80,13 +90,14 @@ struct Fahrenheit {
## 自定义构造过程
-你可以通过输入参数和可选属性类型来自定义构造过程，也可以在构造过程中修改常量属性。这些都将在后面章节中提到。
+你可以通过输入参数和可选类型的属性来自定义构造过程，也可以在构造过程中修改常量属性。这些都将在后面章节中提到。
+
### 构造参数
自定义`构造过程`时，可以在定义中提供构造参数，指定所需值的类型和名字。构造参数的功能和语法跟函数和方法的参数相同。
-下面例子中定义了一个包含摄氏度温度的结构体`Celsius`。它定义了两个不同的构造器：`init(fromFahrenheit:)`和`init(fromKelvin:)`，二者分别通过接受不同刻度表示的温度值来创建新的实例：
+下面例子中定义了一个包含摄氏度温度的结构体`Celsius`。它定义了两个不同的构造器：`init(fromFahrenheit:)`和`init(fromKelvin:)`，二者分别通过接受不同温标下的温度值来创建新的实例：
```swift
struct Celsius {
@@ -106,15 +117,16 @@ let freezingPointOfWater = Celsius(fromKelvin: 273.15)
第一个构造器拥有一个构造参数，其外部名字为`fromFahrenheit`，内部名字为`fahrenheit`；第二个构造器也拥有一个构造参数，其外部名字为`fromKelvin`，内部名字为`kelvin`。这两个构造器都将唯一的参数值转换成摄氏温度值，并保存在属性`temperatureInCelsius`中。
+
### 参数的内部名称和外部名称
-跟函数和方法参数相同，构造参数也存在一个在构造器内部使用的参数名字和一个在调用构造器时使用的外部参数名字。
+跟函数和方法参数相同，构造参数也拥有一个在构造器内部使用的参数名字和一个在调用构造器时使用的外部参数名字。
-然而，构造器并不像函数和方法那样在括号前有一个可辨别的名字。所以在调用构造器时，主要通过构造器中的参数名和类型来确定需要调用的构造器。正因为参数如此重要，如果你在定义构造器时没有提供参数的外部名字，Swift 会为每个构造器的参数自动生成一个跟内部名字相同的外部名，就相当于在每个构造参数之前加了一个哈希符号。
+然而，构造器并不像函数和方法那样在括号前有一个可辨别的名字。因此在调用构造器时，主要通过构造器中的参数名和类型来确定应该被调用的构造器。正因为参数如此重要，如果你在定义构造器时没有提供参数的外部名字，Swift 会为构造器的每个参数自动生成一个跟内部名字相同的外部名。
-以下例子中定义了一个结构体`Color`，它包含了三个常量：`red`、`green`和`blue`。这些属性可以存储0.0到1.0之间的值，用来指示颜色中红、绿、蓝成分的含量。
+以下例子中定义了一个结构体`Color`，它包含了三个常量：`red`、`green`和`blue`。这些属性可以存储`0.0`到`1.0`之间的值，用来指示颜色中红、绿、蓝成分的含量。
-`Color`提供了一个构造器，其中包含三个`Double`类型的构造参数。`Color`也可以提供第二个构造器，它只包含`Double`类型名叫`white`的参数，它被用于给上述三个构造参数赋予同样的值。
+`Color`提供了一个构造器，其中包含三个`Double`类型的构造参数。`Color`也可以提供第二个构造器，它只包含名为`white`的`Double`类型的参数，它被用于给上述三个构造参数赋予同样的值。
```swift
struct Color {
@@ -132,7 +144,7 @@ struct Color {
}
```
-两种构造器都能用于创建一个新的`Color`实例，你需要为构造器每个外部参数传值。
+两种构造器都能用于创建一个新的`Color`实例，你需要为构造器每个外部参数传值：
```swift
let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
@@ -146,15 +158,16 @@ let veryGreen = Color(0.0, 1.0, 0.0)
// 报编译时错误，需要外部名称
```
+
### 不带外部名的构造器参数
-如果你不希望为构造器的某个参数提供外部名字，你可以使用下划线(_)来显示描述它的外部名，以此重写上面所说的默认行为。
+如果你不希望为构造器的某个参数提供外部名字，你可以使用下划线(`_`)来显式描述它的外部名，以此重写上面所说的默认行为。
-下面是之前`Celsius`例子的扩展，跟之前相比添加了一个带有`Double`类型参数名为`celsius`的构造器，其外部名用`_`代替。
+下面是之前`Celsius`例子的扩展，跟之前相比添加了一个带有`Double`类型参数的构造器，其外部名用`_`代替：
```swift
-struct Celsius {I
- var temperatureInCelsius: Double = 0.0
+struct Celsius {
+ var temperatureInCelsius: Double
init(fromFahrenheit fahrenheit: Double) {
temperatureInCelsius = (fahrenheit - 32.0) / 1.8
}
@@ -169,11 +182,12 @@ let bodyTemperature = Celsius(37.0)
// bodyTemperature.temperatureInCelsius 为 37.0
```
-调用这种不需要外部参数名称的`Celsius(37.0)`构造器看起来十分简明的。因此适当使用这种`init(_ celsius: Double)`构造器可以提供`Double`类型的参数值而不需要加上外部名。
+调用`Celsius(37.0)`意图明确，不需要外部参数名称。因此适合使用`init(_ celsius: Double)`这样的构造器，从而可以通过提供`Double`类型的参数值调用构造器，而不需要加上外部名。
+
### 可选属性类型
-如果你定制的类型包含一个逻辑上允许取值为空的存储型属性--不管是因为它无法在初始化时赋值，还是因为它可以在之后某个时间点可以赋值为空--你都需要将它定义为可选类型`optional type`。可选类型的属性将自动初始化为空`nil`，表示这个属性是故意在初始化时设置为空的。
+如果你定制的类型包含一个逻辑上允许取值为空的存储型属性——无论是因为它无法在初始化时赋值，还是因为它在之后某个时间点可以赋值为空——你都需要将它定义为`可选类型`（optional type）。可选类型的属性将自动初始化为`nil`，表示这个属性是有意在初始化时设置为空的。
下面例子中定义了类`SurveyQuestion`，它包含一个可选字符串属性`response`：
@@ -194,17 +208,17 @@ cheeseQuestion.ask()
cheeseQuestion.response = "Yes, I do like cheese."
```
-调查问题在问题提出之后，我们才能得到回答。所以我们将属性回答`response`声明为`String?`类型，或者说是可选字符串类型`optional String`。当`SurveyQuestion`实例化时，它将自动赋值为空`nil`，表明暂时还不存在此字符串。
+调查问题的答案在回答前是无法确定的，因此我们将属性`response`声明为`String?`类型，或者说是`可选字符串类型`（optional String）。当`SurveyQuestion`实例化时，它将自动赋值为`nil`，表明此字符串暂时还没有值。
### 构造过程中常量属性的修改
-你可以在构造过程中的任意时间点修改常量属性的值，只要在构造过程结束时是一个确定的值。一旦常量属性被赋值，它将永远不可更改。
+你可以在构造过程中的任意时间点给常量属性指定一个值，只要在构造过程结束时是一个确定的值。一旦常量属性被赋值，它将永远不可更改。
->注意：
+> 注意
对于类的实例来说，它的常量属性只能在定义它的类的构造过程中修改；不能在子类中修改。
-你可以修改上面的`SurveyQuestion`示例，用常量属性替代变量属性`text`，表示问题内容`text`在`SurveyQuestion`的实例被创建之后不会再被修改。尽管`text`属性现在是常量，我们仍然可以在其类的构造器中设置它的值：
+你可以修改上面的`SurveyQuestion`示例，用常量属性替代变量属性`text`，表示问题内容`text`在`SurveyQuestion`的实例被创建之后不会再被修改。尽管`text`属性现在是常量，我们仍然可以在类的构造器中设置它的值：
```swift
class SurveyQuestion {
@@ -226,9 +240,9 @@ beetsQuestion.response = "I also like beets. (But not with cheese.)"
## 默认构造器
-如果结构体和类的所有属性都有默认值，同时没有自定义的构造器，那么 Swift 会给这些结构体和类创建一个默认构造器。这个默认构造器将简单的创建一个所有属性值都设置为默认值的实例。
+如果结构体或类的所有属性都有默认值，同时没有自定义的构造器，那么 Swift 会给这些结构体或类提供一个默认构造器（default initializers）。这个默认构造器将简单地创建一个所有属性值都设置为默认值的实例。
-下面例子中创建了一个类`ShoppingListItem`，它封装了购物清单中的某一项的属性：名字（`name`）、数量（`quantity`）和购买状态 `purchase state`。
+下面例子中创建了一个类`ShoppingListItem`，它封装了购物清单中的某一物品的属性：名字（`name`）、数量（`quantity`）和购买状态 `purchase state`：
```swift
class ShoppingListItem {
@@ -244,13 +258,13 @@ var item = ShoppingListItem()
### 结构体的逐一成员构造器
-除上面提到的默认构造器，如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。
+除了上面提到的默认构造器，如果结构体没有提供自定义的构造器，它们将自动获得一个逐一成员构造器，即使结构体的存储型属性没有默认值。
逐一成员构造器是用来初始化结构体新实例里成员属性的快捷方法。我们在调用逐一成员构造器时，通过与成员属性名相同的参数名进行传值来完成对成员属性的初始赋值。
-下面例子中定义了一个结构体`Size`，它包含两个属性`width`和`height`。Swift 可以根据这两个属性的初始赋值`0.0`自动推导出它们的类型`Double`。
+下面例子中定义了一个结构体`Size`，它包含两个属性`width`和`height`。Swift 可以根据这两个属性的初始赋值`0.0`自动推导出它们的类型为`Double`。
-由于这两个存储型属性都有默认值，结构体`Size`自动获得了一个逐一成员构造器 `init(width:height:)`。 你可以用它来为`Size`创建新的实例：
+结构体`Size`自动获得了一个逐一成员构造器`init(width:height:)`。你可以用它来为`Size`创建新的实例：
```swift
struct Size {
@@ -260,18 +274,19 @@ let twoByTwo = Size(width: 2.0, height: 2.0)
```
+
## 值类型的构造器代理
构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。
-构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](./13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
+构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给自己的其它构造器。类则不同，它可以继承自其它类（请参考[继承](./13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
-对于值类型，你可以使用`self.init`在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用`self.init`。
+对于值类型，你可以使用`self.init`在自定义的构造器中引用相同类型中的其它构造器。并且你只能在构造器内部调用`self.init`。
-如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。
+如果你为某个值类型定义了一个自定义的构造器，你将无法访问到默认构造器（如果是结构体，还将无法访问逐一成员构造器）。这种限制可以防止你为值类型增加了一个额外的且十分复杂的构造器之后,仍然有人错误的使用自动生成的构造器
->注意：
-假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](./20_Extensions.html)章节。
+> 注意
+假如你希望默认构造器、逐一成员构造器以及你自己的自定义构造器都能用来创建实例，可以将自定义的构造器写到扩展（`extension`）中，而不是写在值类型的原始定义中。想查看更多内容，请查看[扩展](./21_Extensions.html)章节。
下面例子将定义一个结构体`Rect`，用来代表几何矩形。这个例子需要两个辅助的结构体`Size`和`Point`，它们各自为其所有的属性提供了初始值`0.0`。
@@ -284,7 +299,7 @@ struct Point {
}
```
-你可以通过以下三种方式为`Rect`创建实例--使用默认的0值来初始化`origin`和`size`属性；使用特定的`origin`和`size`实例来初始化；使用特定的`center`和`size`来初始化。在下面`Rect`结构体定义中，我们为这三种方式提供了三个自定义的构造器：
+你可以通过以下三种方式为`Rect`创建实例——使用被初始化为默认值的`origin`和`size`属性来初始化；提供指定的`origin`和`size`实例来初始化；提供指定的`center`和`size`来初始化。在下面`Rect`结构体定义中，我们为这三种方式提供了三个自定义的构造器：
```swift
struct Rect {
@@ -303,11 +318,11 @@ struct Rect {
}
```
-第一个`Rect`构造器`init()`，在功能上跟没有自定义构造器时自动获得的默认构造器是一样的。这个构造器是一个空函数，使用一对大括号`{}`来描述，它没有执行任何定制的构造过程。调用这个构造器将返回一个`Rect`实例，它的`origin`和`size`属性都使用定义时的默认值`Point(x: 0.0, y: 0.0)`和`Size(width: 0.0, height: 0.0)`：
+第一个`Rect`构造器`init()`，在功能上跟没有自定义构造器时自动获得的默认构造器是一样的。这个构造器是一个空函数，使用一对大括号`{}`来表示，它没有执行任何构造过程。调用这个构造器将返回一个`Rect`实例，它的`origin`和`size`属性都使用定义时的默认值`Point(x: 0.0, y: 0.0)`和`Size(width: 0.0, height: 0.0)`：
```swift
let basicRect = Rect()
-// basicRect 的原点是 (0.0, 0.0)，尺寸是 (0.0, 0.0)
+// basicRect 的 origin 是 (0.0, 0.0)，size 是 (0.0, 0.0)
```
第二个`Rect`构造器`init(origin:size:)`，在功能上跟结构体在没有自定义构造器时获得的逐一成员构造器是一样的。这个构造器只是简单地将`origin`和`size`的参数值赋给对应的存储型属性：
@@ -315,39 +330,41 @@ let basicRect = Rect()
```swift
let originRect = Rect(origin: Point(x: 2.0, y: 2.0),
size: Size(width: 5.0, height: 5.0))
-// originRect 的原点是 (2.0, 2.0)，尺寸是 (5.0, 5.0)
+// originRect 的 origin 是 (2.0, 2.0)，size 是 (5.0, 5.0)
```
-第三个`Rect`构造器`init(center:size:)`稍微复杂一点。它先通过`center`和`size`的值计算出`origin`的坐标。然后再调用（或代理给）`init(origin:size:)`构造器来将新的`origin`和`size`值赋值到对应的属性中：
+第三个`Rect`构造器`init(center:size:)`稍微复杂一点。它先通过`center`和`size`的值计算出`origin`的坐标，然后再调用（或者说代理给）`init(origin:size:)`构造器来将新的`origin`和`size`值赋值到对应的属性中：
```swift
let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
size: Size(width: 3.0, height: 3.0))
-// centerRect 的原点是 (2.5, 2.5)，尺寸是 (3.0, 3.0)
+// centerRect 的 origin 是 (2.5, 2.5)，size 是 (3.0, 3.0)
```
-构造器`init(center:size:)`可以自己将`origin`和`size`的新值赋值到对应的属性中。然而尽量利用现有的构造器和它所提供的功能来实现`init(center:size:)`的功能，是更方便、更清晰和更直观的方法。
+构造器`init(center:size:)`可以直接将`origin`和`size`的新值赋值到对应的属性中。然而，利用恰好提供了相关功能的现有构造器会更为方便，构造器`init(center:size:)`的意图也会更加清晰。
->注意：
-如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](./20_Extensions.html)。
+> 注意
+如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](./21_Extensions.html)。
## 类的继承和构造过程
-类里面的所有存储型属性--包括所有继承自父类的属性--都必须在构造过程中设置初始值。
+类里面的所有存储型属性——包括所有继承自父类的属性——都必须在构造过程中设置初始值。
-Swift 提供了两种类型的类构造器来确保所有类实例中存储型属性都能获得初始值，它们分别是指定构造器和便利构造器。
+Swift 为类类型提供了两种构造器来确保实例中所有存储型属性都能获得初始值，它们分别是指定构造器和便利构造器。
+
### 指定构造器和便利构造器
-指定构造器是类中最主要的构造器。一个指定构造器将初始化类中提供的所有属性，并根据父类链往上调用父类的构造器来实现父类的初始化。
+*指定构造器*（designated initializers）是类中最主要的构造器。一个指定构造器将初始化类中提供的所有属性，并根据父类链往上调用父类的构造器来实现父类的初始化。
-每一个类都必须拥有至少一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节[自动构造器的继承](#automatic_initializer_inheritance)。
+每一个类都必须拥有至少一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节[构造器的自动继承](#automatic_initializer_inheritance)。
-便利构造器是类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为其参数提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入的实例。
+*便利构造器*（convenience initializers）是类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为其参数提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入值的实例。
你应当只在必要的时候为类提供便利构造器，比方说某种情况下通过使用便利构造器来快捷调用某个指定构造器，能够节省更多开发时间并让类的构造过程更清晰明了。
+
### 指定构造器和便利构造器的语法
类的指定构造器的写法跟值类型简单构造器一样：
@@ -371,14 +388,14 @@ convenience init(parameters) {
为了简化指定构造器和便利构造器之间的调用关系，Swift 采用以下三条规则来限制构造器之间的代理调用：
-#### 规则 1
+##### 规则 1
指定构造器必须调用其直接父类的的指定构造器。
-#### 规则 2
+##### 规则 2
便利构造器必须调用同一类中定义的其它构造器。
-#### 规则 3
-便利构造器必须最终以调用一个指定构造器结束。
+##### 规则 3
+便利构造器必须最终导致一个指定构造器被调用。
一个更方便记忆的方法是：
@@ -387,109 +404,109 @@ convenience init(parameters) {
这些规则可以通过下面图例来说明：
-
+
-如图所示，父类中包含一个指定构造器和两个便利构造器。其中一个便利构造器调用了另外一个便利构造器，而后者又调用了唯一的指定构造器。这满足了上面提到的规则2和3。这个父类没有自己的父类，所以规则1没有用到。
+如图所示，父类中包含一个指定构造器和两个便利构造器。其中一个便利构造器调用了另外一个便利构造器，而后者又调用了唯一的指定构造器。这满足了上面提到的规则 2 和 3。这个父类没有自己的父类，所以规则 1 没有用到。
-子类中包含两个指定构造器和一个便利构造器。便利构造器必须调用两个指定构造器中的任意一个，因为它只能调用同一个类里的其他构造器。这满足了上面提到的规则2和3。而两个指定构造器必须调用父类中唯一的指定构造器，这满足了规则1。
+子类中包含两个指定构造器和一个便利构造器。便利构造器必须调用两个指定构造器中的任意一个，因为它只能调用同一个类里的其他构造器。这满足了上面提到的规则 2 和 3。而两个指定构造器必须调用父类中唯一的指定构造器，这满足了规则 1。
-> 注意：
-这些规则不会影响使用时，如何用类去创建实例。任何上图中展示的构造器都可以用来完整创建对应类的实例。这些规则只在实现类的定义时有影响。
+> 注意
+这些规则不会影响类的实例如何创建。任何上图中展示的构造器都可以用来创建完全初始化的实例。这些规则只影响类定义如何实现。
-下面图例中展示了一种针对四个类的更复杂的类层级结构。它演示了指定构造器是如何在类层级中充当“管道”的作用，在类的构造器链上简化了类之间的相互关系。
+下面图例中展示了一种涉及四个类的更复杂的类层级结构。它演示了指定构造器是如何在类层级中充当“管道”的作用，在类的构造器链上简化了类之间的相互关系。
-
+
### 两段式构造过程
-Swift 中类的构造过程包含两个阶段。第一个阶段，每个存储型属性通过引入它们的类的构造器来设置初始值。当每一个存储型属性值被确定后，第二阶段开始，它给每个类一次机会在新实例准备使用之前进一步定制它们的存储型属性。
+Swift 中类的构造过程包含两个阶段。第一个阶段，每个存储型属性被引入它们的类指定一个初始值。当每个存储型属性的初始值被确定后，第二阶段开始，它给每个类一次机会，在新实例准备使用之前进一步定制它们的存储型属性。
-两段式构造过程的使用让构造过程更安全，同时在整个类层级结构中给予了每个类完全的灵活性。两段式构造过程可以防止属性值在初始化之前被访问；也可以防止属性被另外一个构造器意外地赋予不同的值。
+两段式构造过程的使用让构造过程更安全，同时在整个类层级结构中给予了每个类完全的灵活性。两段式构造过程可以防止属性值在初始化之前被访问，也可以防止属性被另外一个构造器意外地赋予不同的值。
-> 注意：
-Swift的两段式构造过程跟 Objective-C 中的构造过程类似。最主要的区别在于阶段 1，Objective-C 给每一个属性赋值`0`或空值（比如说`0`或`nil`）。Swift 的构造流程则更加灵活，它允许你设置定制的初始值，并自如应对某些属性不能以`0`或`nil`作为合法默认值的情况。
+> 注意
+Swift 的两段式构造过程跟 Objective-C 中的构造过程类似。最主要的区别在于阶段 1，Objective-C 给每一个属性赋值`0`或空值（比如说`0`或`nil`）。Swift 的构造流程则更加灵活，它允许你设置定制的初始值，并自如应对某些属性不能以`0`或`nil`作为合法默认值的情况。
-Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造过程能顺利完成：
+Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造过程能不出错地完成：
-#### 安全检查 1
+##### 安全检查 1
指定构造器必须保证它所在类引入的所有属性都必须先初始化完成，之后才能将其它构造任务向上代理给父类中的构造器。
如上所述，一个对象的内存只有在其所有存储型属性确定之后才能完全初始化。为了满足这一规则，指定构造器必须保证它所在类引入的属性在它往上代理之前先完成初始化。
-#### 安全检查 2
+##### 安全检查 2
指定构造器必须先向上代理调用父类构造器，然后再为继承的属性设置新值。如果没这么做，指定构造器赋予的新值将被父类中的构造器所覆盖。
-#### 安全检查 3
+##### 安全检查 3
便利构造器必须先代理调用同一类中的其它构造器，然后再为任意属性赋新值。如果没这么做，便利构造器赋予的新值将被同一类中其它指定构造器所覆盖。
-#### 安全检查 4
+##### 安全检查 4
-构造器在第一阶段构造完成之前，不能调用任何实例方法、不能读取任何实例属性的值，`self`的值不能被引用。
+构造器在第一阶段构造完成之前，不能调用任何实例方法，不能读取任何实例属性的值，不能引用`self`作为一个值。
-类实例在第一阶段结束以前并不是完全有效，仅能访问属性和调用方法，一旦完成第一阶段，该实例才会声明为有效实例。
+类实例在第一阶段结束以前并不是完全有效的。只有第一阶段完成后，该实例才会成为有效实例，才能访问属性和调用方法。
以下是两段式构造过程中基于上述安全检查的构造流程展示：
-#### 阶段 1
+##### 阶段 1
-- 某个指定构造器或便利构造器被调用；
-- 完成新实例内存的分配，但此时内存还没有被初始化；
-- 指定构造器确保其所在类引入的所有存储型属性都已赋初值。存储型属性所属的内存完成初始化；
-- 指定构造器将调用父类的构造器，完成父类属性的初始化；
-- 这个调用父类构造器的过程沿着构造器链一直往上执行，直到到达构造器链的最顶部；
-- 当到达了构造器链最顶部，且已确保所有实例包含的存储型属性都已经赋值，这个实例的内存被认为已经完全初始化。此时阶段1完成。
+- 某个指定构造器或便利构造器被调用。
+- 完成新实例内存的分配，但此时内存还没有被初始化。
+- 指定构造器确保其所在类引入的所有存储型属性都已赋初值。存储型属性所属的内存完成初始化。
+- 指定构造器将调用父类的构造器，完成父类属性的初始化。
+- 这个调用父类构造器的过程沿着构造器链一直往上执行，直到到达构造器链的最顶部。
+- 当到达了构造器链最顶部，且已确保所有实例包含的存储型属性都已经赋值，这个实例的内存被认为已经完全初始化。此时阶段 1 完成。
-#### 阶段 2
+##### 阶段 2
- 从顶部构造器链一直往下，每个构造器链中类的指定构造器都有机会进一步定制实例。构造器此时可以访问`self`、修改它的属性并调用实例方法等等。
- 最终，任意构造器链中的便利构造器可以有机会定制实例和使用`self`。
-下图展示了在假定的子类和父类之间构造的阶段1：
+下图展示了在假定的子类和父类之间的构造阶段 1：
-
+
在这个例子中，构造过程从对子类中一个便利构造器的调用开始。这个便利构造器此时没法修改任何属性，它把构造任务代理给同一类中的指定构造器。
-如安全检查1所示，指定构造器将确保所有子类的属性都有值。然后它将调用父类的指定构造器，并沿着造器链一直往上完成父类的构建过程。
+如安全检查 1 所示，指定构造器将确保所有子类的属性都有值。然后它将调用父类的指定构造器，并沿着构造器链一直往上完成父类的构造过程。
-父类中的指定构造器确保所有父类的属性都有值。由于没有更多的父类需要构建，也就无需继续向上做构建代理。
+父类中的指定构造器确保所有父类的属性都有值。由于没有更多的父类需要初始化，也就无需继续向上代理。
-一旦父类中所有属性都有了初始值，实例的内存被认为是完全初始化，而阶段1也已完成。
+一旦父类中所有属性都有了初始值，实例的内存被认为是完全初始化，阶段 1 完成。
-以下展示了相同构造过程的阶段2：
+以下展示了相同构造过程的阶段 2：
-
+
-父类中的指定构造器现在有机会进一步来定制实例（尽管它没有这种必要）。
+父类中的指定构造器现在有机会进一步来定制实例（尽管这不是必须的）。
-一旦父类中的指定构造器完成调用，子类的构指定构造器可以执行更多的定制操作（同样，它也没有这种必要）。
+一旦父类中的指定构造器完成调用，子类中的指定构造器可以执行更多的定制操作（这也不是必须的）。
最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。
### 构造器的继承和重写
-跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。
+跟 Objective-C 中的子类不同，Swift 中的子类默认情况下不会继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更精细的子类继承，并被错误地用来创建子类的实例。
->注意：
-父类的构造器仅在确定和安全的情况下被继承。具体内容请参考后续章节[自动构造器的继承](#automatic_initializer_inheritance)。
+> 注意
+父类的构造器仅会在安全和适当的情况下被继承。具体内容请参考后续章节[构造器的自动继承](#automatic_initializer_inheritance)。
-假如你希望自定义的子类中能实现一个或多个跟父类相同的构造器，也许是为了完成一些定制的构造过程，你可以在你定制的子类中提供和重写与父类相同的构造器。
+假如你希望自定义的子类中能提供一个或多个跟父类相同的构造器，你可以在子类中提供这些构造器的自定义实现。
-当你写一个父类中带有指定构造器的子类构造器时，你需要重写这个指定的构造器。因此，你必须在定义子类构造器时带上`override`修饰符。即使你重写系统提供的默认构造器也需要带上`override`修饰符，具体内容请参考[默认构造器](#default_initializers)。
+当你在编写一个和父类中指定构造器相匹配的子类构造器时，你实际上是在重写父类的这个指定构造器。因此，你必须在定义子类构造器时带上`override`修饰符。即使你重写的是系统自动提供的默认构造器，也需要带上`override`修饰符，具体内容请参考[默认构造器](#default_initializers)。
-无论是重写属性，方法或者是下标脚本，只要含有`override`修饰符就会去检查父类是否有相匹配的重写指定构造器和验证重写构造器参数。
+正如重写属性，方法或者是下标，`override`修饰符会让编译器去检查父类中是否有相匹配的指定构造器，并验证构造器参数是否正确。
->注意：
-当你重写一个父类指定构造器时，你需要写`override`修饰符，甚至你的子类构造器继承的是父类的便利构造器。
+> 注意
+当你重写一个父类的指定构造器时，你总是需要写`override`修饰符，即使你的子类将父类的指定构造器重写为了便利构造器。
-相反地，如果你写了一个和父类便利构造器相匹配的子类构造器，子类都不能直接调用父类的便利构造器，每个规则都在上文[构造器链](#initialization_chain)有所描述。
+相反，如果你编写了一个和父类便利构造器相匹配的子类构造器，由于子类不能直接调用父类的便利构造器（每个规则都在上文[类的构造器代理规则](#initializer_delegation_for_class_types)有所描述），因此，严格意义上来讲，你的子类并未对一个父类构造器提供重写。最后的结果就是，你在子类中“重写”一个父类便利构造器时，不需要加`override`前缀。
-在下面的例子中定义了一个基础类叫`Vehicle`。基础类中声明了一个存储型属性`numberOfWheels`，它是值为`0`的`Int`类型属性。`numberOfWheels`属性用于创建名为`descrpiption`类型为`String`的计算型属性。
+在下面的例子中定义了一个叫`Vehicle`的基类。基类中声明了一个存储型属性`numberOfWheels`，它是值为`0`的`Int`类型的存储型属性。`numberOfWheels`属性用于创建名为`descrpiption`的`String`类型的计算型属性：
```swift
class Vehicle {
@@ -500,7 +517,7 @@ class Vehicle {
}
```
-`Vehicle`类只为存储型属性提供默认值，而不自定义构造器。因此，它会自动生成一个默认构造器，具体内容请参考[默认构造器](#default_initializers)。默认构造器通常在类中是指定构造器，它可以用于创建属性叫`numberOfWheels`值为`0`的`Vehicle`实例。
+`Vehicle`类只为存储型属性提供默认值，而不自定义构造器。因此，它会自动获得一个默认构造器，具体内容请参考[默认构造器](#default_initializers)。自动获得的默认构造器总会是类中的指定构造器，它可以用于创建`numberOfWheels`为`0`的`Vehicle`实例：
```swift
let vehicle = Vehicle()
@@ -521,9 +538,9 @@ class Bicycle: Vehicle {
子类`Bicycle`定义了一个自定义指定构造器`init()`。这个指定构造器和父类的指定构造器相匹配，所以`Bicycle`中的指定构造器需要带上`override`修饰符。
-`Bicycle`的构造器`init()`一开始调用`super.init()`方法，这个方法的作用是调用`Bicycle`的父类`Vehicle`。这样可以确保`Bicycle`在修改属性之前它所继承的属性`numberOfWheels`能被`Vehicle`类初始化。在调用`super.init()`之后，原本的属性`numberOfWheels`被赋值为`2`。
+`Bicycle`的构造器`init()`以调用`super.init()`方法开始，这个方法的作用是调用`Bicycle`的父类`Vehicle`的默认构造器。这样可以确保`Bicycle`在修改属性之前，它所继承的属性`numberOfWheels`能被`Vehicle`类初始化。在调用`super.init()`之后，属性`numberOfWheels`的原值被新值`2`替换。
-如果你创建一个`Bicycle`实例，你可以调用继承的`description`计算型属性去查看属性`numberOfWheels`是否有改变。
+如果你创建一个`Bicycle`实例，你可以调用继承的`description`计算型属性去查看属性`numberOfWheels`是否有改变：
```swift
let bicycle = Bicycle()
@@ -531,34 +548,35 @@ print("Bicycle: \(bicycle.description)")
// Bicycle: 2 wheel(s)
```
->注意
-子类可以在初始化时修改继承变量属性，但是不能修改继承过来的常量属性。
+> 注意
+子类可以在初始化时修改继承来的变量属性，但是不能修改继承来的常量属性。
-### 自动构造器的继承
+### 构造器的自动继承
-如上所述，子类不会默认继承父类的构造器。但是如果特定条件可以满足，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重写父类的构造器，并且在尽可能安全的情况下以最小的代价来继承父类的构造器。
+如上所述，子类在默认情况下不会继承父类的构造器。但是如果满足特定条件，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重写父类的构造器，并且可以在安全的情况下以最小的代价继承父类的构造器。
-假设要为子类中引入的任意新属性提供默认值，请遵守以下2个规则：
+假设你为子类中引入的所有新属性都提供了默认值，以下 2 个规则适用：
-#### 规则 1
+##### 规则 1
如果子类没有定义任何指定构造器，它将自动继承所有父类的指定构造器。
-#### 规则 2
+##### 规则 2
-如果子类提供了所有父类指定构造器的实现--不管是通过规则1继承过来的，还是通过自定义实现的--它将自动继承所有父类的便利构造器。
+如果子类提供了所有父类指定构造器的实现——无论是通过规则 1 继承过来的，还是提供了自定义实现——它将自动继承所有父类的便利构造器。
即使你在子类中添加了更多的便利构造器，这两条规则仍然适用。
->注意：
-子类可以通过部分满足规则2的方式，使用子类便利构造器来实现父类的指定构造器。
+> 注意
+对于规则 2，子类可以将父类的指定构造器实现为便利构造器。
-### 指定构造器和便利构造器操作
+
+### 指定构造器和便利构造器实践
-接下来的例子将在操作中展示指定构造器、便利构造器和自动构造器的继承。它定义了包含三个类`Food`、`RecipeIngredient`以及`ShoppingListItem`的类层次结构，并将演示它们的构造器是如何相互作用的。
+接下来的例子将在实践中展示指定构造器、便利构造器以及构造器的自动继承。这个例子定义了包含三个类`Food`、`RecipeIngredient`以及`ShoppingListItem`的类层次结构，并将演示它们的构造器是如何相互作用的。
-类层次中的基类是`Food`，它是一个简单的用来封装食物名字的类。`Food`类引入了一个叫做`name`的`String`类型属性，并且提供了两个构造器来创建`Food`实例：
+类层次中的基类是`Food`，它是一个简单的用来封装食物名字的类。`Food`类引入了一个叫做`name`的`String`类型的属性，并且提供了两个构造器来创建`Food`实例：
```swift
class Food {
@@ -574,25 +592,25 @@ class Food {
下图中展示了`Food`的构造器链：
-
+
-类没有提供一个默认的逐一成员构造器，所以`Food`类提供了一个接受单一参数`name`的指定构造器。这个构造器可以使用一个特定的名字来创建新的`Food`实例：
+类类型没有默认的逐一成员构造器，所以`Food`类提供了一个接受单一参数`name`的指定构造器。这个构造器可以使用一个特定的名字来创建新的`Food`实例：
```swift
let namedMeat = Food(name: "Bacon")
// namedMeat 的名字是 "Bacon”
```
-`Food`类中的构造器`init(name: String)`被定义为一个指定构造器，因为它能确保所有新`Food`实例的中存储型属性都被初始化。`Food`类没有父类，所以`init(name: String)`构造器不需要调用`super.init()`来完成构造。
+`Food`类中的构造器`init(name: String)`被定义为一个指定构造器，因为它能确保`Food`实例的所有存储型属性都被初始化。`Food`类没有父类，所以`init(name: String)`构造器不需要调用`super.init()`来完成构造过程。
-`Food`类同样提供了一个没有参数的便利构造器 `init()`。这个`init()`构造器为新食物提供了一个默认的占位名字，通过代理调用同一类中定义的指定构造器`init(name: String)`并给参数`name`传值`[Unnamed]`来实现：
+`Food`类同样提供了一个没有参数的便利构造器`init()`。这个`init()`构造器为新食物提供了一个默认的占位名字，通过横向代理到指定构造器`init(name: String)`并给参数`name`传值`[Unnamed]`来实现：
```swift
let mysteryMeat = Food()
// mysteryMeat 的名字是 [Unnamed]
```
-类层级中的第二个类是`Food`的子类`RecipeIngredient`。`RecipeIngredient`类构建了食谱中的一味调味剂。它引入了`Int`类型的数量属性`quantity`（以及从`Food`继承过来的`name`属性），并且定义了两个构造器来创建`RecipeIngredient`实例：
+类层级中的第二个类是`Food`的子类`RecipeIngredient`。`RecipeIngredient`类用来表示食谱中的一项原料。它引入了`Int`类型的属性`quantity`（以及从`Food`继承过来的`name`属性），并且定义了两个构造器来创建`RecipeIngredient`实例：
```swift
class RecipeIngredient: Food {
@@ -609,15 +627,17 @@ class RecipeIngredient: Food {
下图中展示了`RecipeIngredient`类的构造器链：
-
+
-`RecipeIngredient`类拥有一个指定构造器`init(name: String, quantity: Int)`，它可以用来产生新`RecipeIngredient`实例的所有属性值。这个构造器一开始先将传入的`quantity`参数赋值给`quantity`属性，这个属性也是唯一在`RecipeIngredient`中新引入的属性。随后，构造器将任务向上代理给父类`Food`的`init(name: String)`。这个过程满足[两段式构造过程](#two_phase_initialization)中的安全检查1。
+`RecipeIngredient`类拥有一个指定构造器`init(name: String, quantity: Int)`，它可以用来填充`RecipeIngredient`实例的所有属性值。这个构造器一开始先将传入的`quantity`参数赋值给`quantity`属性，这个属性也是唯一在`RecipeIngredient`中新引入的属性。随后，构造器向上代理到父类`Food`的`init(name: String)`。这个过程满足[两段式构造过程](#two_phase_initialization)中的安全检查 1。
-`RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。
+`RecipeIngredient`还定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为`1`，所以不需要显式指明数量即可创建出实例。这个便利构造器的定义可以更加方便和快捷地创建实例，并且避免了创建多个`quantity`为`1`的`RecipeIngredient`实例时的代码重复。这个便利构造器只是简单地横向代理到类中的指定构造器，并为`quantity`参数传递`1`。
-注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识（参见[构造器的继承和重写](#initializer_inheritance_and_overriding)）。
+注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。由于这个便利构造器重写了父类的指定构造器`init(name: String)`，因此必须在前面使用`override`修饰符（参见[构造器的继承和重写](#initializer_inheritance_and_overriding)）。
-在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
+尽管`RecipeIngredient`将父类的指定构造器重写为了便利构造器，它依然提供了父类的所有指定构造器的实现。因此，`RecipeIngredient`会自动继承父类的所有便利构造器。
+
+在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个便利构造器会被`RecipeIngredient`继承。这个继承版本的`init()`在功能上跟`Food`提供的版本是一样的，只是它会代理到`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
所有的这三种构造器都可以用来创建新的`RecipeIngredient`实例：
@@ -627,9 +647,9 @@ let oneBacon = RecipeIngredient(name: "Bacon")
let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
```
-类层级中第三个也是最后一个类是`RecipeIngredient`的子类，叫做`ShoppingListItem`。这个类构建了购物单中出现的某一种调味料。
+类层级中第三个也是最后一个类是`RecipeIngredient`的子类，叫做`ShoppingListItem`。这个类构建了购物单中出现的某一种食谱原料。
-购物单中的每一项总是从`unpurchased`未购买状态开始的。为了展现这一事实，`ShoppingListItem`引入了一个布尔类型的属性`purchased`，它的默认值是`false`。`ShoppingListItem`还添加了一个计算型属性`description`，它提供了关于`ShoppingListItem`实例的一些文字描述：
+购物单中的每一项总是从未购买状态开始的。为了呈现这一事实，`ShoppingListItem`引入了一个布尔类型的属性`purchased`，它的默认值是`false`。`ShoppingListItem`还添加了一个计算型属性`description`，它提供了关于`ShoppingListItem`实例的一些文字描述：
```swift
class ShoppingListItem: RecipeIngredient {
@@ -642,14 +662,14 @@ class ShoppingListItem: RecipeIngredient {
}
```
-> 注意：
-`ShoppingListItem`没有定义构造器来为`purchased`提供初始化值，这是因为任何添加到购物单的项的初始状态总是未购买。
+> 注意
+`ShoppingListItem`没有定义构造器来为`purchased`提供初始值，因为添加到购物单的物品的初始状态总是未购买。
由于它为自己引入的所有属性都提供了默认值，并且自己没有定义任何构造器，`ShoppingListItem`将自动继承所有父类中的指定构造器和便利构造器。
-下图种展示了所有三个类的构造器链：
+下图展示了这三个类的构造器链：
-
+
你可以使用全部三个继承来的构造器来创建`ShoppingListItem`的新实例：
@@ -669,24 +689,24 @@ for item in breakfastList {
// 6 x eggs ✘
```
-如上所述，例子中通过字面量方式创建了一个新数组`breakfastList`，它包含了三个新的`ShoppingListItem`实例，因此数组的类型也能自动推导为`ShoppingListItem[]`。在数组创建完之后，数组中第一个`ShoppingListItem`实例的名字从`[Unnamed]`修改为`Orange juice`，并标记为已购买。接下来通过遍历数组每个元素并打印它们的描述值，展示了所有项当前的默认状态都已按照预期完成了赋值。
+如上所述，例子中通过字面量方式创建了一个数组`breakfastList`，它包含了三个`ShoppingListItem`实例，因此数组的类型也能被自动推导为`[ShoppingListItem]`。在数组创建完之后，数组中第一个`ShoppingListItem`实例的名字从`[Unnamed]`更改为`Orange juice`，并标记为已购买。打印数组中每个元素的描述显示了它们都已按照预期被赋值。
## 可失败构造器
-如果一个类、结构体或枚举类型的对象，在构造自身的过程中有可能失败，则为其定义一个可失败构造器，是非常有用的。这里所指的“失败”是指，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。
+如果一个类、结构体或枚举类型的对象，在构造过程中有可能失败，则为其定义一个可失败构造器。这里所指的“失败”是指，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。
-为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在`init`关键字后面加添问号`(init?)`。
+为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在`init`关键字后面添加问号(`init?`)。
-> 注意：
-可失败构造器的参数名和参数类型，不能与其它非可失败构造器的参数名，及其类型相同。
+> 注意
+可失败构造器的参数名和参数类型，不能与其它非可失败构造器的参数名，及其参数类型相同。
-可失败构造器，在构建对象的过程中，创建一个其自身类型为可选类型的对象。你通过`return nil` 语句，来表明可失败构造器在何种情况下“失败”。
+可失败构造器会创建一个类型为自身类型的可选类型的对象。你通过`return nil`语句来表明可失败构造器在何种情况下应该“失败”。
-> 注意：
-严格来说，构造器都不支持返回值。因为构造器本身的作用，只是为了能确保对象自身能被正确构建。所以即使你在表明可失败构造器，失败的这种情况下，用到了`return nil`。也不要在表明可失败构造器成功的这种情况下，使用关键字 `return`。
+> 注意
+严格来说，构造器都不支持返回值。因为构造器本身的作用，只是为了确保对象能被正确构造。因此你只是用`return nil`表明可失败构造器构造失败，而不要用关键字`return`来表明构造成功。
-下例中，定义了一个名为`Animal`的结构体，其中有一个名为`species`的，`String`类型的常量属性。同时该结构体还定义了一个，带一个`String`类型参数`species`的,可失败构造器。这个可失败构造器，被用来检查传入的参数是否为一个空字符串，如果为空字符串，则该可失败构造器，构建对象失败，否则成功。
+下例中，定义了一个名为`Animal`的结构体，其中有一个名为`species`的`String`类型的常量属性。同时该结构体还定义了一个接受一个名为`species`的`String`类型参数的可失败构造器。这个可失败构造器检查传入的参数是否为一个空字符串。如果为空字符串，则构造失败。否则，`species`属性被赋值，构造成功。
```swift
struct Animal {
@@ -698,7 +718,7 @@ struct Animal {
}
```
-你可以通过该可失败构造器来构建一个Animal的对象，并检查其构建过程是否成功。
+你可以通过该可失败构造器来构建一个`Animal`的实例，并检查构造过程是否成功：
```swift
let someCreature = Animal(species: "Giraffe")
@@ -710,7 +730,7 @@ if let giraffe = someCreature {
// 打印 "An animal was initialized with a species of Giraffe"
```
-如果你给该可失败构造器传入一个空字符串作为其参数，则该可失败构造器失败。
+如果你给该可失败构造器传入一个空字符串作为其参数，则会导致构造失败：
```swift
let anonymousCreature = Animal(species: "")
@@ -722,14 +742,15 @@ if anonymousCreature == nil {
// 打印 "The anonymous creature could not be initialized"
```
-> 注意：
-空字符串（如`""`，而不是`"Giraffe"`）和一个值为`nil`的可选类型的字符串是两个完全不同的概念。上例中的空字符串（`""`）其实是一个有效的，非可选类型的字符串。这里我们只所以让`Animal`的可失败构造器，构建对象失败，只是因为对于`Animal`这个类的`species`属性来说，它更适合有一个具体的值，而不是空字符串。
+> 注意
+空字符串（如`""`，而不是`"Giraffe"`）和一个值为`nil`的可选类型的字符串是两个完全不同的概念。上例中的空字符串（`""`）其实是一个有效的，非可选类型的字符串。这里我们之所以让`Animal`的可失败构造器构造失败，只是因为对于`Animal`这个类的`species`属性来说，它更适合有一个具体的值，而不是空字符串。
-###枚举类型的可失败构造器
+
+### 枚举类型的可失败构造器
-你可以通过构造一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。还能在参数不满足枚举成员期望的条件时，构造失败。
+你可以通过一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。如果提供的参数无法匹配任何枚举成员，则构造失败。
-下例中，定义了一个名为TemperatureUnit的枚举类型。其中包含了三个可能的枚举成员(`Kelvin`，`Celsius`，和 `Fahrenheit`)和一个被用来找到`Character`值所对应的枚举成员的可失败构造器：
+下例中，定义了一个名为`TemperatureUnit`的枚举类型。其中包含了三个可能的枚举成员(`Kelvin`，`Celsius`，和`Fahrenheit`)，以及一个根据`Character`值找出所对应的枚举成员的可失败构造器：
```swift
enum TemperatureUnit {
@@ -749,7 +770,7 @@ enum TemperatureUnit {
}
```
-你可以通过给该可失败构造器传递合适的参数来获取这三个枚举成员中相匹配的其中一个枚举成员。当参数的值不能与任意一枚举成员相匹配时，该枚举类型的构建过程失败：
+你可以利用该可失败构造器在三个枚举成员中获取一个相匹配的枚举成员，当参数的值不能与任何枚举成员相匹配时，则构造失败：
```swift
let fahrenheitUnit = TemperatureUnit(symbol: "F")
@@ -765,11 +786,12 @@ if unknownUnit == nil {
// 打印 "This is not a defined temperature unit, so initialization failed."
```
-###带原始值的枚举类型的可失败构造器
+
+### 带原始值的枚举类型的可失败构造器
-带原始值的枚举类型会自带一个可失败构造器`init?(rawValue:)`,该可失败构造器有一个名为`rawValue`的默认参数,其类型和枚举类型的原始值类型一致，如果该参数的值能够和枚举类型成员所带的原始值匹配，则该构造器构造一个带此原始值的枚举成员，否则构造失败。
+带原始值的枚举类型会自带一个可失败构造器`init?(rawValue:)`，该可失败构造器有一个名为`rawValue`的参数，其类型和枚举类型的原始值类型一致，如果该参数的值能够和某个枚举成员的原始值匹配，则该构造器会构造相应的枚举成员，否则构造失败。
-因此上面的 TemperatureUnit的例子可以重写为：
+因此上面的`TemperatureUnit`的例子可以重写为：
```swift
enum TemperatureUnit: Character {
@@ -780,86 +802,59 @@ let fahrenheitUnit = TemperatureUnit(rawValue: "F")
if fahrenheitUnit != nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
-// prints "This is a defined temperature unit, so initialization succeeded."
+// 打印 "This is a defined temperature unit, so initialization succeeded."
let unknownUnit = TemperatureUnit(rawValue: "X")
if unknownUnit == nil {
print("This is not a defined temperature unit, so initialization failed.")
}
-// prints "This is not a defined temperature unit, so initialization failed."
+// 打印 "This is not a defined temperature unit, so initialization failed."
```
-###类的可失败构造器
+
+### 构造失败的传递
-值类型（如结构体或枚举类型）的可失败构造器，对何时何地触发构造失败这个行为没有任何的限制。比如在前面的例子中，结构体`Animal`的可失败构造器触发失败的行为，甚至发生在`species`属性的值被初始化以前。
+类，结构体，枚举的可失败构造器可以横向代理到类型中的其他可失败构造器。类似的，子类的可失败构造器也能向上代理到父类的可失败构造器。
-而对类而言，就没有那么幸运了。类的可失败构造器只能在所有的类属性被初始化后和所有类之间的构造器之间的代理调用发生完后触发失败行为。
+无论是向上代理还是横向代理，如果你代理到的其他可失败构造器触发构造失败，整个构造过程将立即终止，接下来的任何构造代码不会再被执行。
+
+> 注意
+可失败构造器也可以代理到其它的非可失败构造器。通过这种方式，你可以增加一个可能的失败状态到现有的构造过程中。
+
+下面这个例子，定义了一个名为`CartItem`的`Product`类的子类。这个类建立了一个在线购物车中的物品的模型，它有一个名为`quantity`的常量存储型属性，并确保该属性的值至少为`1`：
-下面例子展示了如何使用隐式解析可选类型来实现这个类的可失败构造器的要求：
```swift
class Product {
- let name: String!
- init?(name: String) {
- self.name = name
+ let name: String
+ init?(name: String) {
if name.isEmpty { return nil }
+ self.name = name
}
}
-```
-上面定义的`Product`类，其内部结构和之前`Animal`结构体很相似。`Product`类有一个不能为空字符串的`name`常量属性。为了强制满足这个要求，`Product`类使用了可失败构造器来确保这个属性的值在构造器成功时不为空。
-毕竟，`Product`是一个类而不是结构体，也就不能和`Animal`一样了。`Product`类的所有可失败构造器必须在自己失败前给`name`属性一个初始值。
-
-上面的例子中，`Product`类的`name`属性被定义为隐式解析可选字符串类型（`String!`）。因为它是一个可选类型，所以在构造过程里的赋值前，`name`属性有个默认值`nil`。用默认值`nil`意味着`Product`类的所有属性都有一个合法的初始值。因而，在构造器中给`name`属性赋一个特定的值前，可失败构造器能够在传入一个空字符串时触发构造过程的失败。
-
-因为`name`属性是一个常量，所以一旦`Product`类构造成功，`name`属性肯定有一个非`nil`的值。即使它被定义为隐式解析可选类型，也完全可以放心大胆地直接访问，而不用考虑`name`属性是否有值。
-
-```swift
-if let bowTie = Product(name: "bow tie") {
- // 不需要检查 bowTie.name == nil
- print("The product's name is \(bowTie.name)")
-}
-// 打印 "The product's name is bow tie"
-```
-
-###构造失败的传递
-
-可失败构造器同样满足在[构造器链](#initialization_chain)中所描述的构造规则。其允许在同一类，结构体和枚举中横向代理其他的可失败构造器。类似的，子类的可失败构造器也能向上代理基类的可失败构造器。
-
-无论是向上代理还是横向代理，如果你代理的可失败构造器，在构造过程中触发了构造失败的行为，整个构造过程都将被立即终止，接下来任何的构造代码都将不会被执行。
-
->注意：
-可失败构造器也可以代理调用其它的非可失败构造器。通过这个方法，你可以为已有的构造过程加入构造失败的条件。
-
-下面这个例子，定义了一个名为`CartItem`的`Product`类的子类。这个类建立了一个在线购物车中的物品的模型，它有一个名为`quantity`的常量参数，用来表示该物品的数量至少为1：
-
-```swift
class CartItem: Product {
- let quantity: Int!
+ let quantity: Int
init?(name: String, quantity: Int) {
+ if quantity < 1 { return nil }
self.quantity = quantity
super.init(name: name)
- if quantity < 1 { return nil }
-
}
}
```
-和`Product`类中的`name`属性相类似的，`CartItem`类中的`quantity`属性的类型也是一个隐式解析可选类型，只不过由（`String!`）变为了（`Int!`）。这样做都是为了确保在构造过程中，该属性在被赋予特定的值之前能有一个默认的初始值nil。
+`CartItem` 可失败构造器首先验证接收的 `quantity` 值是否大于等于 1 。倘若 `quantity` 值无效，则立即终止整个构造过程，返回失败结果，且不再执行余下代码。同样地，`Product` 的可失败构造器首先检查 `name` 值，假如 `name` 值为空字符串，则构造器立即执行失败。
-可失败构造器总是先向上代理调用基类,`Product`的构造器 `init(name:)`。这满足了可失败构造器在触发构造失败这个行为前必须总是执行构造代理调用这个条件。
-
-如果由于`name`的值为空而导致基类的构造器在构造过程中失败。则整个`CartIem`类的构造过程都将失败，后面的子类的构造过程都将不会被执行。如果基类构建成功，则继续运行子类的构造器代码。
-
-如果你构造了一个`CartItem`对象，并且该对象的`name`属性不为空以及`quantity`属性为1或者更多，则构造成功：
+如果你通过传入一个非空字符串 `name` 以及一个值大于等于 1 的 `quantity` 来创建一个 `CartItem` 实例，那么构造方法能够成功被执行：
```swift
if let twoSocks = CartItem(name: "sock", quantity: 2) {
print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
-// 打印 "Item: sock, quantity: 2"
+// 打印 "Item: sock, quantity: 2”
```
-如果你构造一个`CartItem`对象，其`quantity`的值`0`, 则`CartItem`的可失败构造器触发构造失败的行为:
+
+倘若你以一个值为 0 的 `quantity` 来创建一个 `CartItem` 实例，那么将导致 `CartItem` 构造器失败：
```swift
if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
@@ -867,10 +862,10 @@ if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
} else {
print("Unable to initialize zero shirts")
}
-// 打印 "Unable to initialize zero shirts"
-```
+// 打印 "Unable to initialize zero shirts”
+```
-类似的, 如果你构造一个`CartItem`对象，但其`name`的值为空, 则基类`Product`的可失败构造器将触发构造失败的行为，整个`CartItem`的构造行为同样为失败：
+同样地，如果你尝试传入一个值为空字符串的 `name`来创建一个 `CartItem` 实例，那么将导致父类 `Product` 的构造过程失败：
```swift
if let oneUnnamed = CartItem(name: "", quantity: 1) {
@@ -878,34 +873,35 @@ if let oneUnnamed = CartItem(name: "", quantity: 1) {
} else {
print("Unable to initialize one unnamed product")
}
-// 打印 "Unable to initialize one unnamed product"
+// 打印 "Unable to initialize one unnamed product”
```
-###重写一个可失败构造器
+
+### 重写一个可失败构造器
-就如同其它构造器一样，你也可以用子类的可失败构造器重写基类的可失败构造器。或者你也可以用子类的非可失败构造器重写一个基类的可失败构造器。这样做的好处是，即使基类的构造器为可失败构造器，但当子类的构造器在构造过程不可能失败时，我们也可以把它修改过来。
+如同其它的构造器，你可以在子类中重写父类的可失败构造器。或者你也可以用子类的非可失败构造器重写一个父类的可失败构造器。这使你可以定义一个不会构造失败的子类，即使父类的构造器允许构造失败。
-注意当你用一个子类的非可失败构造器重写了一个父类的可失败构造器时，子类的构造器将不再能向上代理父类的可失败构造器。一个非可失败的构造器永远也不能代理调用一个可失败构造器。
+注意，当你用子类的非可失败构造器重写父类的可失败构造器时，向上代理到父类的可失败构造器的唯一方式是对父类的可失败构造器的返回值进行强制解包。
->注意：
-你可以用一个非可失败构造器重写一个可失败构造器，但反过来却行不通。
+> 注意
+你可以用非可失败构造器重写可失败构造器，但反过来却不行。
-下例定义了一个名为`Document`的类，这个类中的`name`属性允许为`nil`和一个非空字符串，但不能是一个空字符串：
+下例定义了一个名为`Document`的类，`name`属性的值必须为一个非空字符串或`nil`，但不能是一个空字符串：
```swift
class Document {
var name: String?
- // 该构造器构建了一个name属性值为nil的document对象
+ // 该构造器创建了一个 name 属性的值为 nil 的 document 实例
init() {}
- // 该构造器构建了一个name属性值为非空字符串的document对象
+ // 该构造器创建了一个 name 属性的值为非空字符串的 document 实例
init?(name: String) {
- if name.isEmpty { return nil }
self.name = name
+ if name.isEmpty { return nil }
}
}
```
-下面这个例子，定义了一个`Document`类的子类`AutomaticallyNamedDocument`。这个子类重写了父类的两个指定构造器，确保不论是通过没有 name 参数的构造器，还是通过传一个空字符串给`init(name:)`构造器，生成的实例中的`name`属性总有初始值`"[Untitled]"`。
+下面这个例子，定义了一个`Document`类的子类`AutomaticallyNamedDocument`。这个子类重写了父类的两个指定构造器，确保了无论是使用`init()`构造器，还是使用`init(name:)`构造器并为参数传递空字符串，生成的实例中的`name`属性总有初始`"[Untitled]"`：
```swift
class AutomaticallyNamedDocument: Document {
@@ -924,9 +920,9 @@ class AutomaticallyNamedDocument: Document {
}
```
-`AutomaticallyNamedDocument`用一个非可失败构造器`init(name:)`,重写了父类的可失败构造器`init?(name:)`。因为子类用不同的方法处理了`name`属性的值为一个空字符串的这种情况。所以子类将不再需要一个可失败的构造器，用一个非可失败版本代替了父类的版本。
+`AutomaticallyNamedDocument`用一个非可失败构造器`init(name:)`重写了父类的可失败构造器`init?(name:)`。因为子类用另一种方式处理了空字符串的情况，所以不再需要一个可失败构造器，因此子类用一个非可失败构造器代替了父类的可失败构造器。
-你可以在构造器中调用父类的可失败构造器强制解包，以实现子类的非可失败构造器。比如，下面的`UntitledDocument `子类总有值为`"[Untitled]"`的 name 属性，它在构造过程中用了父类的可失败的构造器`init(name:)`。
+你可以在子类的非可失败构造器中使用强制解包来调用父类的可失败构造器。比如，下面的`UntitledDocument`子类的`name`属性的值总是`"[Untitled]"`，它在构造过程中使用了父类的可失败构造器`init?(name:)`：
```swift
class UntitledDocument: Document {
@@ -935,49 +931,50 @@ class UntitledDocument: Document {
}
}
```
-在这个例子中，如果在调用父类的构造器`init(name:)`时传给 name 的是空字符串，那么强制解绑操作会造成运行时错误。不过，因为这里是通过字符串常量来调用它，所以并不会发生运行时错误。
-###可失败构造器 init!
+在这个例子中，如果在调用父类的可失败构造器`init?(name:)`时传入的是空字符串，那么强制解包操作会引发运行时错误。不过，因为这里是通过非空的字符串常量来调用它，所以并不会发生运行时错误。
-通常来说我们通过在`init`关键字后添加问号的方式（`init?`）来定义一个可失败构造器，但你也可以使用通过在`init`后面添加惊叹号的方式来定义一个可失败构造器`(init!)`，该可失败构造器将会构建一个特定类型的隐式解析可选类型的对象。
+
+### 可失败构造器 init!
-你可以在 `init? `构造器中代理调用 `init!`构造器，反之亦然。
-你也可以用 `init?`重写 `init!`，反之亦然。
-你还可以用 `init`代理调用`init!`，但这会触发一个断言： `init!` 构造器是否会触发构造失败？
+通常来说我们通过在`init`关键字后添加问号的方式（`init?`）来定义一个可失败构造器，但你也可以通过在`init`后面添加惊叹号的方式来定义一个可失败构造器（`init!`），该可失败构造器将会构建一个对应类型的隐式解包可选类型的对象。
+
+你可以在`init?`中代理到`init!`，反之亦然。你也可以用`init?`重写`init!`，反之亦然。你还可以用`init`代理到`init!`，不过，一旦`init!`构造失败，则会触发一个断言。
-##必要构造器
+## 必要构造器
-在类的构造器前添加 `required` 修饰符表明所有该类的子类都必须实现该构造器：
+在类的构造器前添加`required`修饰符表明所有该类的子类都必须实现该构造器：
```swift
class SomeClass {
required init() {
- // 在这里添加该必要构造器的实现代码
+ // 构造器的实现代码
}
}
```
-在子类重写父类的必要构造器时，必须在子类的构造器前也添加`required`修饰符，这是为了保证继承链上子类的构造器也是必要构造器。在重写父类的必要构造器时，不需要添加`override`修饰符：
+
+在子类重写父类的必要构造器时，必须在子类的构造器前也添加`required`修饰符，表明该构造器要求也应用于继承链后面的子类。在重写父类中必要的指定构造器时，不需要添加`override`修饰符：
```swift
class SomeSubclass: SomeClass {
required init() {
- // 在这里添加子类必要构造器的实现代码
+ // 构造器的实现代码
}
}
```
->注意：
-如果子类继承的构造器能满足必要构造器的需求，则你无需显示的在子类中提供必要构造器的实现。
+> 注意
+如果子类继承的构造器能满足必要构造器的要求，则无须在子类中显式提供必要构造器的实现。
-## 通过闭包和函数来设置属性的默认值
+## 通过闭包或函数设置属性的默认值
-如果某个存储型属性的默认值需要特别的定制或准备，你就可以使用闭包或全局函数来为其属性提供定制的默认值。每当某个属性所属的新类型实例创建时，对应的闭包或函数会被调用，而它们的返回值会当做默认值赋值给这个属性。
+如果某个存储型属性的默认值需要一些定制或设置，你可以使用闭包或全局函数为其提供定制的默认值。每当某个属性所在类型的新实例被创建时，对应的闭包或函数会被调用，而它们的返回值会当做默认值赋值给这个属性。
-这种类型的闭包或函数一般会创建一个跟属性类型相同的临时变量，然后修改它的值以满足预期的初始状态，最后将这个临时变量的值作为属性的默认值进行返回。
+这种类型的闭包或函数通常会创建一个跟属性类型相同的临时变量，然后修改它的值以满足预期的初始状态，最后返回这个临时变量，作为属性的默认值。
-下面列举了闭包如何提供默认值的代码概要：
+下面介绍了如何用闭包为属性提供默认值：
```swift
class SomeClass {
@@ -985,49 +982,49 @@ class SomeClass {
// 在这个闭包中给 someProperty 创建一个默认值
// someValue 必须和 SomeType 类型相同
return someValue
- }()
+ }()
}
```
-注意闭包结尾的大括号后面接了一对空的小括号。这是用来告诉 Swift 需要立刻执行此闭包。如果你忽略了这对括号，相当于是将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。
+注意闭包结尾的大括号后面接了一对空的小括号。这用来告诉 Swift 立即执行此闭包。如果你忽略了这对括号，相当于将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。
->注意：
-如果你使用闭包来初始化属性的值，请记住在闭包执行时，实例的其它部分都还没有初始化。这意味着你不能够在闭包里访问其它的属性，就算这个属性有默认值也不允许。同样，你也不能使用隐式的`self`属性，或者调用其它的实例方法。
+> 注意
+如果你使用闭包来初始化属性，请记住在闭包执行时，实例的其它部分都还没有初始化。这意味着你不能在闭包里访问其它属性，即使这些属性有默认值。同样，你也不能使用隐式的`self`属性，或者调用任何实例方法。
下面例子中定义了一个结构体`Checkerboard`，它构建了西洋跳棋游戏的棋盘：
-
+
-西洋跳棋游戏在一副黑白格交替的 10x10 的棋盘中进行。为了呈现这副游戏棋盘，`Checkerboard`结构体定义了一个属性`boardColors`，它是一个包含 100 个布尔值的数组。数组中的某元素布尔值为`true`表示对应的是一个黑格，布尔值为`false`表示对应的是一个白格。数组中第一个元素代表棋盘上左上角的格子，最后一个元素代表棋盘上右下角的格子。
+西洋跳棋游戏在一副黑白格交替的`10x10`的棋盘中进行。为了呈现这副游戏棋盘，`Checkerboard`结构体定义了一个属性`boardColors`，它是一个包含`100`个`Bool`值的数组。在数组中，值为`true`的元素表示一个黑格，值为`false`的元素表示一个白格。数组中第一个元素代表棋盘上左上角的格子，最后一个元素代表棋盘上右下角的格子。
-`boardColor`数组是通过一个闭包来初始化和组装颜色值的：
+`boardColor`数组是通过一个闭包来初始化并设置颜色值的：
```swift
struct Checkerboard {
let boardColors: [Bool] = {
var temporaryBoard = [Bool]()
var isBlack = false
- for i in 1...10 {
- for j in 1...10 {
+ for i in 1...8 {
+ for j in 1...8 {
temporaryBoard.append(isBlack)
isBlack = !isBlack
}
isBlack = !isBlack
}
return temporaryBoard
- }()
+ }()
func squareIsBlackAtRow(row: Int, column: Int) -> Bool {
- return boardColors[(row * 10) + column]
+ return boardColors[(row * 8) + column]
}
}
```
-每当一个新的`Checkerboard`实例创建时，对应的赋值闭包会执行，一系列颜色值会被计算出来作为默认值赋值给`boardColors`。上面例子中描述的闭包将计算出棋盘中每个格子合适的颜色，将这些颜色值保存到一个临时数组`temporaryBoard`中，并在构建完成时将此数组作为闭包返回值返回。这个返回的值将保存到`boardColors`中，并可以通`squareIsBlackAtRow`这个工具函数来查询。
+每当一个新的`Checkerboard`实例被创建时，赋值闭包会被执行，`boardColors`的默认值会被计算出来并返回。上面例子中描述的闭包将计算出棋盘中每个格子对应的颜色，并将这些值保存到一个临时数组`temporaryBoard`中，最后在构建完成时将此数组作为闭包返回值返回。这个返回的数组会保存到`boardColors`中，并可以通过工具函数`squareIsBlackAtRow`来查询：
```swift
let board = Checkerboard()
print(board.squareIsBlackAtRow(0, column: 1))
-// 输出 "true"
-print(board.squareIsBlackAtRow(9, column: 9))
-// 输出 "false"
+// 打印 "true"
+print(board.squareIsBlackAtRow(7, column: 7))
+// 打印 "false"
```
diff --git a/source/chapter2/15_Deinitialization.md b/source/chapter2/15_Deinitialization.md
index d93844be..f55b48aa 100755
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -8,12 +8,18 @@
> 2.0
> 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
+> 2.1
+> 校对：[shanks](http://codebuild.me)，2015-10-31
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-14
+
本页包含内容：
- [析构过程原理](#how_deinitialization_works)
-- [析构器操作](#deinitializers_in_action)
+- [析构器实践](#deinitializers_in_action)
-析构器只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字`deinit`来标示，类似于构造器要用`init`来标示。
+*析构器*只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字`deinit`来标示，类似于构造器要用`init`来标示。
##析构过程原理
@@ -28,22 +34,22 @@ deinit {
}
```
-析构器是在实例释放发生前被自动调用。析构器是不允许被主动调用的。子类继承了父类的析构器，并且在子类析构器实现的最后，父类的析构器会被自动调用。即使子类没有提供自己的析构器，父类的析构器也同样会被调用。
+析构器是在实例释放发生前被自动调用。你不能主动调用析构器。子类继承了父类的析构器，并且在子类析构器实现的最后，父类的析构器会被自动调用。即使子类没有提供自己的析构器，父类的析构器也同样会被调用。
-因为直到实例的析构器被调用时，实例才会被释放，所以析构器可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件）。
+因为直到实例的析构器被调用后，实例才会被释放，所以析构器可以访问实例的所有属性，并且可以根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件）。
-##析构器操作
+##析构器实践
-这是一个析构器操作的例子。这个例子描述了一个简单的游戏，这里定义了两种新类型，分别是`Bank`和`Player`。`Bank`结构体管理一个虚拟货币的流通，在这个流通中我们设定`Bank`永远不可能拥有超过 10,000 的硬币，而且在游戏中有且只能有一个`Bank`存在，因此`Bank`结构体在实现时会带有静态属性和静态方法来存储和管理其当前的状态。
+这是一个析构器实践的例子。这个例子描述了一个简单的游戏，这里定义了两种新类型，分别是`Bank`和`Player`。`Bank`类管理一种虚拟硬币，确保流通的硬币数量永远不可能超过 10,000。在游戏中有且只能有一个`Bank`存在，因此`Bank`用类来实现，并使用类型属性和类型方法来存储和管理其当前状态。
```swift
-struct Bank {
+class Bank {
static var coinsInBank = 10_000
- static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
- numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
- coinsInBank -= numberOfCoinsToVend
- return numberOfCoinsToVend
+ static func vendCoins(numberOfCoinsRequested: Int) -> Int {
+ let numberOfCoinsToVend = min(numberOfCoinsRequested, coinsInBank)
+ coinsInBank -= numberOfCoinsToVend
+ return numberOfCoinsToVend
}
static func receiveCoins(coins: Int) {
coinsInBank += coins
@@ -51,13 +57,13 @@ struct Bank {
}
```
-`Bank`根据它的`coinsInBank`属性来跟踪当前它拥有的硬币数量。`Bank`还提供两个方法——`vendCoins(_:)`和`receiveCoins(_:)`，分别用来处理硬币的分发和收集。
+`Bank`使用`coinsInBank`属性来跟踪它当前拥有的硬币数量。`Bank`还提供了两个方法，`vendCoins(_:)`和`receiveCoins(_:)`，分别用来处理硬币的分发和收集。
-`vendCoins(_:)`方法在bank对象分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，`Bank`会返回一个比请求时要小的数字(如果没有硬币留在bank对象中就返回 0)。`vendCoins`方法声明`numberOfCoinsToVend`为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。`vendCoins`方法返回一个整型值，表明了提供的硬币的实际数目。
+`vendCoins(_:)`方法在`Bank`对象分发硬币之前检查是否有足够的硬币。如果硬币不足，`Bank`对象会返回一个比请求时小的数字（如果`Bank`对象中没有硬币了就返回`0`）。`vendCoins`方法返回一个整型值，表示提供的硬币的实际数量。
-`receiveCoins`方法只是将bank对象的硬币存储和接收到的硬币数目相加，再保存回bank对象。
+`receiveCoins(_:)`方法只是将`Bank`对象接收到的硬币数目加回硬币存储中。
-`Player`类描述了游戏中的一个玩家。每一个 player 在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过 player 的`coinsInPurse`属性来体现：
+`Player`类描述了游戏中的一个玩家。每一个玩家在任意时间都有一定数量的硬币存储在他们的钱包中。这通过玩家的`coinsInPurse`属性来表示：
```swift
class Player {
@@ -74,22 +80,21 @@ class Player {
}
```
+每个`Player`实例在初始化的过程中，都从`Bank`对象获取指定数量的硬币。如果没有足够的硬币可用，`Player`实例可能会收到比指定数量少的硬币.
-每个`Player`实例构造时都会设定由硬币组成的启动额度值，这些硬币在bank对象初始化的过程中得到。如果在bank对象中没有足够的硬币可用，`Player`实例可能收到比指定数目少的硬币。
-
-`Player`类定义了一个`winCoins(_:)`方法，该方法从bank对象获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构器，这个析构器在`Player`实例释放前被调用。在这里，析构器的作用只是将玩家的所有硬币都返回给bank对象：
+`Player`类定义了一个`winCoins(_:)`方法，该方法从`Bank`对象获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构器，这个析构器在`Player`实例释放前被调用。在这里，析构器的作用只是将玩家的所有硬币都返还给`Bank`对象：
```swift
var playerOne: Player? = Player(coins: 100)
print("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
-// 输出 "A new player has joined the game with 100 coins"
-print("There are now \(Bank.coinsInBank) coins left in the bank")
-// 输出 "There are now 9900 coins left in the bank"
+// 打印 "A new player has joined the game with 100 coins"
+print("There are now \(Bank.coinsInBank) coins left in the bank")
+// 打印 "There are now 9900 coins left in the bank"
```
-一个新的`Player`实例被创建时会设定有 100 个硬币（如果bank对象中硬币的数目足够）。这`个Player`实例存储在一个名为`playerOne`的可选`Player`变量中。这里使用一个可选变量，是因为玩家可以随时离开游戏。设置为可选使得你可以跟踪当前是否有玩家在游戏中。
+创建一个`Player`实例的时候，会向`Bank`对象请求 100 个硬币，如果有足够的硬币可用的话。这个`Player`实例存储在一个名为`playerOne`的可选类型的变量中。这里使用了一个可选类型的变量，因为玩家可以随时离开游戏，设置为可选使你可以追踪玩家当前是否在游戏中。
-因为`playerOne`是可选的，所以用一个感叹号（`!`）作为修饰符，每当其`winCoins(_:)`方法被调用时，`coinsInPurse`属性就会被访问并打印出它的默认硬币数目。
+因为`playerOne`是可选的，所以访问其`coinsInPurse`属性来打印钱包中的硬币数量时，使用感叹号（`!`）来解包：
```swift
playerOne!.winCoins(2_000)
@@ -99,14 +104,14 @@ print("The bank now only has \(Bank.coinsInBank) coins left")
// 输出 "The bank now only has 7900 coins left"
```
-这里，player 已经赢得了 2,000 硬币，所以player 的钱包现在有 2,100 硬币，而bank对象只剩余 7,900 硬币。
+这里，玩家已经赢得了 2,000 枚硬币，所以玩家的钱包中现在有 2,100 枚硬币，而`Bank`对象只剩余 7,900 枚硬币。
```swift
playerOne = nil
print("PlayerOne has left the game")
-// 输出 "PlayerOne has left the game"
+// 打印 "PlayerOne has left the game"
print("The bank now has \(Bank.coinsInBank) coins")
-// 输出 "The bank now has 10000 coins"
+// 打印 "The bank now has 10000 coins"
```
-玩家现在已经离开了游戏。这表明是要将可选的`playerOne`变量设置为`nil`，意思是“不存在`Player`实例”。当这种情况发生的时候，`playerOne`变量对`Player`实例的引用被破坏了。没有其它属性或者变量引用`Player`实例，因此为了清空它占用的内存从而释放它。在这发生前，其析构器会被自动调用，从而使其硬币被返回到bank对象中。
+玩家现在已经离开了游戏。这通过将可选类型的`playerOne`变量设置为`nil`来表示，意味着“没有`Player`实例”。当这一切发生时，`playerOne`变量对`Player`实例的引用被破坏了。没有其它属性或者变量引用`Player`实例，因此该实例会被释放，以便回收内存。在这之前，该实例的析构器被自动调用，玩家的硬币被返还给银行。
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index 55b76166..319ec3a3 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -8,6 +8,13 @@
> 2.0
> 翻译+校对：[Channe](https://github.com/Channe)
+> 2.1
+> 翻译：[Channe](https://github.com/Channe)
+> 校对：[shanks](http://codebuild.me)，[Realank](https://github.com/Realank) ，2016-01-23
+>
+> 2.2
+> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-14
+
本页包含内容：
- [自动引用计数的工作机制](#how_arc_works)
@@ -19,15 +26,15 @@
Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 内存管理机制会一直起作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。
-然而，在少数情况下，ARC 为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用 ARC 来管理你的应用程序的内存。
+然而在少数情况下，为了能帮助你管理内存，ARC 需要更多的，代码之间关系的信息。本章描述了这些情况，并且为你示范怎样才能使 ARC 来管理你的应用程序的所有内存。
-> 注意:
+> 注意
引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。
## 自动引用计数的工作机制
-当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。
+当你每次创建一个类的新的实例的时候，ARC 会分配一块内存来储存该实例信息。内存中会包含实例的类型信息，以及这个实例所有相关的存储型属性的值。
此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
@@ -35,7 +42,7 @@ Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程
为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为1，ARC都不会销毁这个实例。
-为了使上述成为可能，无论你将实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称之为“强”引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被销毁的。
+为了使上述成为可能，无论你将实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称之为“强”引用，是因为它会将实例牢牢地保持住，只要强引用还在，实例是不允许被销毁的。
## 自动引用计数实践
@@ -72,7 +79,7 @@ reference1 = Person(name: "John Appleseed")
// prints "John Appleseed is being initialized”
```
-应当注意到当你调用`Person`类的构造函数的时候，"John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。
+应当注意到当你调用`Person`类的构造函数的时候，`“John Appleseed is being initialized”`会被打印出来。由此可以确定构造函数被执行。
由于`Person`类的新实例被赋值给了`reference1`变量，所以`reference1`到`Person`类的新实例之间建立了一个强引用。正是因为这一个强引用，ARC 会保证`Person`实例被保持在内存中不被销毁。
@@ -92,11 +99,11 @@ reference1 = nil
reference2 = nil
```
-在你清楚地表明不再使用这个`Person`实例时，即第三个也就是最后一个强引用被断开时，ARC 会销毁它。
+在你清楚地表明不再使用这个`Person`实例时，即第三个也就是最后一个强引用被断开时，ARC 会销毁它：
```swift
reference3 = nil
-// prints "John Appleseed is being deinitialized"
+// 打印 “John Appleseed is being deinitialized”
```
@@ -104,11 +111,11 @@ reference3 = nil
在上面的例子中，ARC 会跟踪你所新创建的`Person`实例的引用数量，并且会在`Person`实例不再被需要时销毁它。
-然而，我们可能会写出一个类实例的强引用数永远不能变成0的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的循环强引用。
+然而，我们可能会写出一个类实例的强引用数永远不能变成`0`的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的循环强引用。
你可以通过定义类之间的关系为弱引用或无主引用，以替代强引用，从而解决循环强引用的问题。具体的过程在[解决类实例之间的循环强引用](#resolving_strong_reference_cycles_between_class_instances)中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。
-下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：`Person`和`Apartment`，用来建模公寓和它其中的居民:
+下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：`Person`和`Apartment`，用来建模公寓和它其中的居民：
```swift
class Person {
@@ -130,7 +137,7 @@ class Apartment {
每一个`Person`实例有一个类型为`String`，名字为`name`的属性，并有一个可选的初始化为`nil`的`apartment`属性。`apartment`属性是可选的，因为一个人并不总是拥有公寓。
-类似的，每个`Apartment`实例有一个叫`number`，类型为`Int`的属性，并有一个可选的初始化为`nil`的`tenant`属性。`tenant`属性是可选的，因为一栋公寓并不总是有居民。
+类似的，每个`Apartment`实例有一个叫`unit`，类型为`String`的属性，并有一个可选的初始化为`nil`的`tenant`属性。`tenant`属性是可选的，因为一栋公寓并不总是有居民。
这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓`Person`和`Apartment`的实例是否像预期的那样被销毁。
@@ -163,7 +170,7 @@ unit4A!.tenant = john
-不幸的是，这两个实例关联后会产生一个循环强引用。`Person`实例现在有了一个指向`Apartment`实例的强引用，而`Apartment`实例也有了一个指向`Person`实例的强引用。因此，当你断开`john`和`unit4A`变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
+不幸的是，这两个实例关联后会产生一个循环强引用。`Person`实例现在有了一个指向`Apartment`实例的强引用，而`Apartment`实例也有了一个指向`Person`实例的强引用。因此，当你断开`john`和`unit4A`变量所持有的强引用时，引用计数并不会降为`0`，实例也不会被 ARC 销毁：
```swift
john = nil
@@ -187,13 +194,14 @@ Swift 提供了两种办法用来解决你在使用类的属性时所遇到的
对于生命周期中会变为`nil`的实例使用弱引用。相反地，对于初始化赋值后再也不会被赋值为`nil`的实例，使用无主引用。
+
### 弱引用
弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或者变量时，在前面加上`weak`关键字表明这是一个弱引用。
-在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以避免循环强引用。如果引用总是有值，则可以使用无主引用，在[无主引用](#2)中有描述。在上面`Apartment`的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。
+在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以避免循环强引用。如果引用总是有值，则可以使用无主引用，在[无主引用](#unowned_references)中有描述。在上面`Apartment`的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。
-> 注意:
+> 注意
> 弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。
因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。在 Swift 中，推荐使用可选类型描述可能没有值的类型。
@@ -237,7 +245,7 @@ unit4A!.tenant = john
-`Person`实例依然保持对`Apartment`实例的强引用，但是`Apartment`实例只是对`Person`实例的弱引用。这意味着当你断开`john`变量所保持的强引用时，再也没有指向`Person`实例的强引用了：
+`Person`实例依然保持对`Apartment`实例的强引用，但是`Apartment`实例只持有对`Person`实例的弱引用。这意味着当你断开`john`变量所保持的强引用时，再也没有指向`Person`实例的强引用了：
@@ -245,7 +253,7 @@ unit4A!.tenant = john
```swift
john = nil
-// prints "John Appleseed is being deinitialized"
+// 打印 “John Appleseed is being deinitialized”
```
唯一剩下的指向`Apartment`实例的强引用来自于变量`unit4A`。如果你断开这个强引用，再也没有指向`Apartment`实例的强引用了：
@@ -256,27 +264,23 @@ john = nil
```swift
unit4A = nil
-// prints "Apartment 4A is being deinitialized"
+// 打印 “Apartment 4A is being deinitialized”
```
上面的两段代码展示了变量`john`和`unit4A`在被赋值为`nil`后，`Person`实例和`Apartment`实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。
-
-
- >注意：
- 在使用垃圾收集的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才被销毁。但是在 ARC 中，一旦值的最后一个强引用被删除，就会被立即销毁，这导致弱引用并不适合上面的用途。
+
+ > 注意
+ 在使用垃圾收集的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才被销毁。但是在 ARC 中，一旦值的最后一个强引用被移除，就会被立即销毁，这导致弱引用并不适合上面的用途。
-
+
### 无主引用
和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用是永远有值的。因此，无主引用总是被定义为非可选类型（non-optional type）。你可以在声明属性或者变量时，在前面加上关键字`unowned`表示这是一个无主引用。
由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过 ARC 无法在实例被销毁后将无主引用设为`nil`，因为非可选类型的变量不允许被赋值为`nil`。
-> 注意:
->如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。
+> 注意
+> 如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。
> 还需要注意的是如果你试图访问实例已经被销毁的无主引用，Swift 确保程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。
下面的例子定义了两个类，`Customer`和`CreditCard`，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系可能会造成循环强引用。
@@ -310,16 +314,16 @@ class CreditCard {
}
```
-> 注意:
-> `CreditCard`类的`number`属性被定义为`UInt64`类型而不是`Int`类型，以确保`number`属性的存储量在32位和64位系统上都能足够容纳16位的卡号。
+> 注意
+> `CreditCard`类的`number`属性被定义为`UInt64`类型而不是`Int`类型，以确保`number`属性的存储量在 32 位和 64 位系统上都能足够容纳 16 位的卡号。
-下面的代码片段定义了一个叫`john`的可选类型`Customer`变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为`nil`。
+下面的代码片段定义了一个叫`john`的可选类型`Customer`变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为`nil`：
```swift
var john: Customer?
```
-现在你可以创建`Customer`类的实例，用它初始化`CreditCard`实例，并将新创建的`CreditCard`实例赋值为客户的`card`属性。
+现在你可以创建`Customer`类的实例，用它初始化`CreditCard`实例，并将新创建的`CreditCard`实例赋值为客户的`card`属性：
```swift
john = Customer(name: "John Appleseed")
@@ -340,13 +344,12 @@ john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
```swift
john = nil
-// prints "John Appleseed is being deinitialized"
-// prints "Card #1234567890123456 is being deinitialized"
+// 打印 “John Appleseed is being deinitialized”
+// 打印 ”Card #1234567890123456 is being deinitialized”
```
最后的代码展示了在`john`变量被设为`nil`后`Customer`实例和`CreditCard`实例的构造函数都打印出了“销毁”的信息。
-
###无主引用以及隐式解析可选属性
@@ -384,36 +387,36 @@ class City {
}
```
-为了建立两个类的依赖关系，`City`的构造函数有一个`Country`实例的参数，并且将实例保存为`country`属性。
+为了建立两个类的依赖关系，`City`的构造函数接受一个`Country`实例作为参数，并且将实例保存到`country`属性。
-`Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化完后，`Country`的构造函数才能把`self`传给`City`的构造函数。（在[两段式构造过程](./14_Initialization.html#two_phase_initialization)中有具体描述）
+`Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化后，`Country`的构造函数才能把`self`传给`City`的构造函数。（在[两段式构造过程](./14_Initialization.html#two_phase_initialization)中有具体描述）
-为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（在[隐式解析可选类型](./01_The_Basics.html#implicityly_unwrapped_optionals)中有描述）
+为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这意味着像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（在[隐式解析可选类型](./01_The_Basics.html#implicityly_unwrapped_optionals)中有描述）
-由于`capitalCity`默认值为`nil`，一旦`Country`的实例在构造函数中给`name`属性赋值后，整个初始化过程就完成了。这代表一旦`name`属性被赋值后，`Country`的构造函数就能引用并传递隐式的`self`。`Country`的构造函数在赋值`capitalCity`时，就能将`self`作为参数传递给`City`的构造函数。
+由于`capitalCity`默认值为`nil`，一旦`Country`的实例在构造函数中给`name`属性赋值后，整个初始化过程就完成了。这意味着一旦`name`属性被赋值后，`Country`的构造函数就能引用并传递隐式的`self`。`Country`的构造函数在赋值`capitalCity`时，就能将`self`作为参数传递给`City`的构造函数。
以上的意义在于你可以通过一条语句同时创建`Country`和`City`的实例，而不产生循环强引用，并且`capitalCity`的属性能被直接访问，而不需要通过感叹号来展开它的可选值：
```swift
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
-// prints "Canada's capital city is called Ottawa"
+// 打印 “Canada's capital city is called Ottawa”
```
-在上面的例子中，使用隐式解析可选值的意义在于满足了两个类构造函数的需求。`capitalCity`属性在初始化完成后，能像非可选值一样使用和存取同时还避免了循环强引用。
+在上面的例子中，使用隐式解析可选值意味着满足了类的构造函数的两个构造阶段的要求。`capitalCity`属性在初始化完成后，能像非可选值一样使用和存取，同时还避免了循环强引用。
##闭包引起的循环强引用
前面我们看到了循环强引用是在两个类实例属性互相保持对方的强引用时产生的，还知道了如何用弱引用和无主引用来打破这些循环强引用。
-循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了这个类实例。这个闭包体中可能访问了实例的某个属性，例如`self.someProperty`，或者闭包中调用了实例的某个方法，例如`self.someMethod`。这两种情况都导致了闭包 “捕获" `self`，从而产生了循环强引用。
+循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了这个类实例时。这个闭包体中可能访问了实例的某个属性，例如`self.someProperty`，或者闭包中调用了实例的某个方法，例如`self.someMethod()`。这两种情况都导致了闭包“捕获”`self`，从而产生了循环强引用。
-循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你也把一个引用赋值给了这个闭包。实质上，这跟之前的问题是一样的－两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。
+循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你是将这个闭包的引用赋值给了属性。实质上，这跟之前的问题是一样的——两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。
-Swift 提供了一种优雅的方法来解决这个问题，称之为闭包捕获列表（closuer capture list）。同样的，在学习如何用闭包捕获列表破坏循环强引用之前，先来了解一下这里的循环强引用是如何产生的，这对我们很有帮助。
+Swift 提供了一种优雅的方法来解决这个问题，称之为`闭包捕获列表`（closure capture list）。同样的，在学习如何用闭包捕获列表打破循环强引用之前，先来了解一下这里的循环强引用是如何产生的，这对我们很有帮助。
-下面的例子为你展示了当一个闭包引用了`self`后是如何产生一个循环强引用的。例子中定义了一个叫`HTMLElement`的类，用一种简单的模型表示 HTML 中的一个单独的元素：
+下面的例子为你展示了当一个闭包引用了`self`后是如何产生一个循环强引用的。例子中定义了一个叫`HTMLElement`的类，用一种简单的模型表示 HTML 文档中的一个单独的元素：
```swift
class HTMLElement {
@@ -441,51 +444,49 @@ class HTMLElement {
}
```
-`HTMLElement`类定义了一个`name`属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。`HTMLElement`还定义了一个可选属性`text`，用来设置和展现 HTML 元素的文本。
+`HTMLElement`类定义了一个`name`属性来表示这个元素的名称，例如代表段落的`“p”`，或者代表换行的`“br”`。`HTMLElement`还定义了一个可选属性`text`，用来设置 HTML 元素呈现的文本。
除了上面的两个属性，`HTMLElement`还定义了一个`lazy`属性`asHTML`。这个属性引用了一个将`name`和`text`组合成 HTML 字符串片段的闭包。该属性是`Void -> String`类型，或者可以理解为“一个没有参数，返回`String`的函数”。
-默认情况下，闭包赋值给了`asHTML`属性，这个闭包返回一个代表 HTML 标签的字符串。如果`text`值存在，该标签就包含可选值`text`；如果`text`不存在，该标签就不包含文本。对于段落元素，根据`text`是`"some text"`还是`nil`，闭包会返回"`some text
`"或者"``"。 +默认情况下，闭包赋值给了`asHTML`属性，这个闭包返回一个代表 HTML 标签的字符串。如果`text`值存在，该标签就包含可选值`text`；如果`text`不存在，该标签就不包含文本。对于段落元素，根据`text`是`“some text”`还是`nil`，闭包会返回`"some text
"`或者`""`。 -可以像实例方法那样去命名、使用`asHTML`属性。然而，由于`asHTML`是闭包而不是实例方法，如果你想改变特定元素的 HTML 处理的话，可以用自定义的闭包来取代默认值。 - - -例如，可以将一个闭包赋值给`asHTML`属性，这个闭包能在文本属性是 nil 时用默认文本，这是为了避免返回一个空的 `HTML` 标签： -```swift -let heading = HTMLElement(name: "h1") -let defaultText = "some default text" -heading.asHTML = { - return "<\(heading.name)>\(heading.text ?? defaultText)" -} -print(heading.asHTML()) -// prints "some default text
" -``` +可以像实例方法那样去命名、使用`asHTML`属性。然而，由于`asHTML`是闭包而不是实例方法，如果你想改变特定 HTML 元素的处理方式的话，可以用自定义的闭包来取代默认值。 -> 注意: -`asHTML`声明为`lazy`属性，因为只有当元素确实需要处理为HTML输出的字符串时，才需要使用`asHTML`。也就是说，在默认的闭包中可以使用`self`，因为只有当初始化完成以及`self`确实存在后，才能访问`lazy`属性。 +例如，可以将一个闭包赋值给`asHTML`属性，这个闭包能在`text`属性是`nil`时使用默认文本，这是为了避免返回一个空的 HTML 标签： -`HTMLElement`类只提供一个构造函数，通过`name`和`text`（如果有的话）参数来初始化一个元素。该类也定义了一个析构函数，当`HTMLElement`实例被销毁时，打印一条消息。 +```swift +let heading = HTMLElement(name: "h1") +let defaultText = "some default text" +heading.asHTML = { + return "<\(heading.name)>\(heading.text ?? defaultText)" +} +print(heading.asHTML()) +// 打印 “some default text
” +``` -下面的代码展示了如何用`HTMLElement`类创建实例并打印消息。 +> 注意 +`asHTML`声明为`lazy`属性，因为只有当元素确实需要被处理为 HTML 输出的字符串时，才需要使用`asHTML`。也就是说，在默认的闭包中可以使用`self`，因为只有当初始化完成以及`self`确实存在后，才能访问`lazy`属性。 + +`HTMLElement`类只提供了一个构造函数，通过`name`和`text`（如果有的话）参数来初始化一个新元素。该类也定义了一个析构函数，当`HTMLElement`实例被销毁时，打印一条消息。 + +下面的代码展示了如何用`HTMLElement`类创建实例并打印消息： ```swift var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") print(paragraph!.asHTML()) -// prints"hello, world" +// 打印 “hello, world
” ``` ->注意: -上面的`paragraph`变量定义为`可选HTMLElement`，因此我们可以赋值`nil`给它来演示循环强引用。 +> 注意 +上面的`paragraph`变量定义为可选类型的`HTMLElement`，因此我们可以赋值`nil`给它来演示循环强引用。 -不幸的是，上面写的`HTMLElement`类产生了类实例和`asHTML`默认值的闭包之间的循环强引用。循环强引用如下图所示： +不幸的是，上面写的`HTMLElement`类产生了类实例和作为`asHTML`默认值的闭包之间的循环强引用。循环强引用如下图所示：  实例的`asHTML`属性持有闭包的强引用。但是，闭包在其闭包体内使用了`self`（引用了`self.name`和`self.text`），因此闭包捕获了`self`，这意味着闭包又反过来持有了`HTMLElement`实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考[值捕获](./07_Closures.html#capturing_values)）。 ->注意: +> 注意 虽然闭包多次使用了`self`，它只捕获`HTMLElement`实例的一个强引用。 如果设置`paragraph`变量为`nil`，打破它持有的`HTMLElement`实例的强引用，`HTMLElement`实例和它的闭包都不会被销毁，也是因为循环强引用： @@ -494,26 +495,27 @@ print(paragraph!.asHTML()) paragraph = nil ``` -注意`HTMLElementdeinitializer`中的消息并没有被打印，证明了`HTMLElement`实例并没有被销毁。 +注意，`HTMLElement`的析构函数中的消息并没有被打印，证明了`HTMLElement`实例并没有被销毁。 ##解决闭包引起的循环强引用 在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。 ->注意： +> 注意 Swift 有如下要求：只要在闭包内使用`self`的成员，就要用`self.someProperty`或者`self.someMethod()`（而不只是`someProperty`或`someMethod()`）。这提醒你可能会一不小心就捕获了`self`。 + ###定义捕获列表 -捕获列表中的每一项都由一对元素组成，一个元素是`weak`或`unowned`关键字，另一个元素是类实例的引用（如`self`）或初始化过的变量（如`delegate = self.delegate!`）。这些项在方括号中用逗号分开。 +捕获列表中的每一项都由一对元素组成，一个元素是`weak`或`unowned`关键字，另一个元素是类实例的引用（例如`self`）或初始化过的变量（如`delegate = self.delegate!`）。这些项在方括号中用逗号分开。 如果闭包有参数列表和返回类型，把捕获列表放在它们前面： ```swift lazy var someClosure: (Int, String) -> String = { [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in - // closure body goes here + // 这里是闭包的函数体 } ``` @@ -522,17 +524,18 @@ lazy var someClosure: (Int, String) -> String = { ```swift lazy var someClosure: Void -> String = { [unowned self, weak delegate = self.delegate!] in - // closure body goes here + // 这里是闭包的函数体 } ``` + ###弱引用和无主引用 -在闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。 +在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为`无主引用`。 -相反的，在被捕获的引用可能会变为`nil`时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为`nil`。这使我们可以在闭包体内检查它们是否存在。 +相反的，在被捕获的引用可能会变为`nil`时，将闭包内的捕获定义为`弱引用`。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为`nil`。这使我们可以在闭包体内检查它们是否存在。 ->注意: +> 注意 如果被捕获的引用绝对不会变为`nil`，应该用无主引用，而不是弱引用。 前面的`HTMLElement`例子中，无主引用是正确的解决循环强引用的方法。这样编写`HTMLElement`类来避免循环强引用： @@ -564,23 +567,25 @@ class HTMLElement { } ``` -上面的`HTMLElement`实现和之前的实现一致，除了在`asHTML`闭包中多了一个捕获列表。这里，捕获列表是`[unowned self]`，表示“用无主引用而不是强引用来捕获`self`”。 +上面的`HTMLElement`实现和之前的实现一致，除了在`asHTML`闭包中多了一个捕获列表。这里，捕获列表是`[unowned self]`，表示“将`self`捕获为无主引用而不是强引用”。 和之前一样，我们可以创建并打印`HTMLElement`实例： ```swift var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") print(paragraph!.asHTML()) -// prints "hello, world
" +// 打印 “hello, world
” ``` 使用捕获列表后引用关系如下图所示：  -这一次，闭包以无主引用的形式捕获`self`，并不会持有`HTMLElement`实例的强引用。如果将`paragraph`赋值为`nil`，`HTMLElement`实例将会被销毁，并能看到它的析构函数打印出的消息。 +这一次，闭包以无主引用的形式捕获`self`，并不会持有`HTMLElement`实例的强引用。如果将`paragraph`赋值为`nil`，`HTMLElement`实例将会被销毁，并能看到它的析构函数打印出的消息： ```swift paragraph = nil -// prints "p is being deinitialized" +// 打印 “p is being deinitialized” ``` + +你可以查看[捕获列表](../chapter3/04_Expressions.html)章节，获取更多关于捕获列表的信息。 diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md index 43ee5426..3c5d2ac8 100755 --- a/source/chapter2/17_Optional_Chaining.md +++ b/source/chapter2/17_Optional_Chaining.md @@ -1,4 +1,4 @@ -# 可空链式调用（Optional Chaining） +# 可选链式调用（Optional Chaining） ----------------- @@ -9,23 +9,39 @@ > 2.0 > 翻译+校对：[lyojo](https://github.com/lyojo) +> 2.1 +> 校对：[shanks](http://codebuild.me)，2015-10-31 +> +> 2.2 +> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-15 -可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。 +本页包含内容： -> -注意： -Swift 的可空链式调用和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且能够检查调用是否成功。 +- [使用可选链式调用代替强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping) +- [为可选链式调用定义模型类](#defining_model_classes_for_optional_chaining) +- [通过可选链式调用访问属性](#accessing_properties_through_optional_chaining) +- [通过可选链式调用调用方法](#calling_methods_through_optional_chaining) +- [通过可选链式调用访问下标](#accessing_subscripts_through_optional_chaining) +- [连接多层可选链式调用](#linking_multiple_levels_of_chaining) +- [在方法的可选返回值上进行可选链式调用](#chaining_on_methods_with_optional_return_values) + +可选链式调用（Optional Chaining）是一种可以在当前值可能为`nil`的可选值上请求和调用属性、方法及下标的方法。如果可选值有值，那么调用就会成功；如果可选值是`nil`，那么调用将返回`nil`。多个调用可以连接在一起形成一个调用链，如果其中任何一个节点为`nil`，整个调用链都会失败，即返回`nil`。 + +> 注意 +Swift 的可选链式调用和 Objective-C 中向`nil`发送消息有些相像，但是 Swift 的可选链式调用可以应用于任意类型，并且能检查调用是否成功。 -##使用可空链式调用来强制展开 -通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，然而强制展开将会触发运行时错误。 +## 使用可选链式调用代替强制展开 -为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回`nil`则说明调用失败。 +通过在想调用的属性、方法、或下标的可选值（optional value）后面放一个问号（`?`），可以定义一个可选链。这一点很像在可选值后面放一个叹号（`!`）来强制展开它的值。它们的主要区别在于当可选值为空时可选链式调用只会调用失败，然而强制展开将会触发运行时错误。 -特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回`Int`的类型的结果将会返回`Int?`类型。 +为了反映可选链式调用可以在空值（`nil`）上调用的事实，不论这个调用的属性、方法及下标返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来判断你的可选链式调用是否调用成功，如果调用有返回值则说明调用成功，返回`nil`则说明调用失败。 -下面几段代码将解释可空链式调用和强制展开的不同。 -首先定义两个类`Person`和`Residence`。 +特别地，可选链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可选值。例如，使用可选链式调用访问属性，当可选链式调用成功时，如果属性原本的返回结果是`Int`类型，则会变为`Int?`类型。 + +下面几段代码将解释可选链式调用和强制展开的不同。 + +首先定义两个类`Person`和`Residence`： ```swift class Person { @@ -37,24 +53,24 @@ class Residence { } ``` -`Residence`有一个`Int`类型的属性`numberOfRooms`，其默认值为1。`Person`具有一个可空的`residence`属性，其类型为`Residence?`。 - -如果创建一个新的`Person`实例，因为它的`residence`属性是可空的，`john`属性将初始化为`nil`： +`Residence`有一个`Int`类型的属性`numberOfRooms`，其默认值为`1`。`Person`具有一个可选的`residence`属性，其类型为`Residence?`。 + +假如你创建了一个新的`Person`实例,它的`residence`属性由于是是可选型而将初始化为`nil`,在下面的代码中,`john`有一个值为`nil`的`residence`属性： ```swift let john = Person() ``` -如果使用叹号（！）强制展开获得这个`john`的`residence`属性中的`numberOfRooms`值，会触发运行时错误，因为这时没有可以展开的`residence`： +如果使用叹号（`!`）强制展开获得这个`john`的`residence`属性中的`numberOfRooms`值，会触发运行时错误，因为这时`residence`没有可以展开的值： ```swift let roomCount = john.residence!.numberOfRooms -// this triggers a runtime error +// 这会引发运行时错误 ``` -`john.residence`非空的时候，上面的调用成功，并且把`roomCount`设置为`Int`类型的房间数量。正如上面说到的，当`residence`为空的时候上面这段代码会触发运行时错误。 +`john.residence`为非`nil`值的时候，上面的调用会成功，并且把`roomCount`设置为`Int`类型的房间数量。正如上面提到的，当`residence`为`nil`的时候上面这段代码会触发运行时错误。 -可空链式调用提供了一种另一种访问`numberOfRooms`的方法，使用问号（？）来代替原来叹号（！）的位置： +可选链式调用提供了另一种访问`numberOfRooms`的方式，使用问号（`?`）来替代原来的叹号（`!`）： ```swift if let roomCount = john.residence?.numberOfRooms { @@ -62,22 +78,22 @@ if let roomCount = john.residence?.numberOfRooms { } else { print("Unable to retrieve the number of rooms.") } -// prints "Unable to retrieve the number of rooms." +// 打印 “Unable to retrieve the number of rooms.” ``` -在`residence`后面添加问号之后，Swift就会在`residence`不为空的情况下访问`numberOfRooms`。 +在`residence`后面添加问号之后，Swift 就会在`residence`不为`nil`的情况下访问`numberOfRooms`。 -因为访问`numberOfRooms`有可能失败，可空链式调用会返回`Int?`类型，或称为“可空的Int”。如上例所示，当`residence`为`nil`的时候，可空的`Int`将会为`nil`，表明无法访问`numberOfRooms`。 +因为访问`numberOfRooms`有可能失败，可选链式调用会返回`Int?`类型，或称为“可选的 `Int`”。如上例所示，当`residence`为`nil`的时候，可选的`Int`将会为`nil`，表明无法访问`numberOfRooms`。访问成功时，可选的`Int`值会通过可选绑定展开，并赋值给非可选类型的`roomCount`常量。 -要注意的是，即使`numberOfRooms`是不可空的`Int`时，这一点也成立。只要是通过可空链式调用就意味着最后`numberOfRooms`返回一个`Int?`而不是`Int`。 +要注意的是，即使`numberOfRooms`是非可选的`Int`时，这一点也成立。只要使用可选链式调用就意味着`numberOfRooms`会返回一个`Int?`而不是`Int`。 -通过赋给`john.residence`一个`Residence`的实例变量： +可以将一个`Residence`的实例赋给`john.residence`，这样它就不再是`nil`了： ```swift john.residence = Residence() ``` -这样`john.residence`不为`nil`了。现在就可以正常访问`john.residence.numberOfRooms`，其值为默认的1，类型为`Int?`： +`john.residence`现在包含一个实际的`Residence`实例，而不再是`nil`。如果你试图使用先前的可选链式调用访问`numberOfRooms`，它现在将返回值为`1`的`Int?`类型的值： ```swift if let roomCount = john.residence?.numberOfRooms { @@ -85,15 +101,17 @@ if let roomCount = john.residence?.numberOfRooms { } else { print("Unable to retrieve the number of rooms.") } -// prints "John's residence has 1 room(s)." +// 打印 “John's residence has 1 room(s).” ``` -##为可空链式调用定义模型类 -通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。并且判断能否访问子属性的属性，方法或下标。 + +## 为可选链式调用定义模型类 -下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在`Person`和`Residence`的基础上增加了`Room`和`Address`，以及相关的属性，方法以及下标。 +通过使用可选链式调用可以调用多层属性、方法和下标。这样可以在复杂的模型中向下访问各种子属性，并且判断能否访问子属性的属性、方法或下标。 -Person类定义基本保持不变： +下面这段代码定义了四个模型类，这些例子包括多层可选链式调用。为了方便说明，在`Person`和`Residence`的基础上增加了`Room`类和`Address`类，以及相关的属性、方法以及下标。 + +`Person`类的定义基本保持不变： ```swift class Person { @@ -101,7 +119,7 @@ class Person { } ``` -`Residence`类比之前复杂些，增加了一个`Room`类型的空数组`room`： +`Residence`类比之前复杂些，增加了一个名为`rooms`的变量属性，该属性被初始化为`[Room]`类型的空数组： ```swift class Residence { @@ -124,9 +142,15 @@ class Residence { } ``` -现在`Residence`有了一个存储`Room`类型的数组，`numberOfRooms`属性需要计算，而不是作为单纯的变量。计算后的`numberOfRooms`返回`rooms`数组的`count`属性值。现在的`Residence`还提供访问`rooms`数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供`printNumberOfRooms`方法，这个方法的作用就是输出这个房子中房间的数量。最后，`Residence`定义了一个可空属性`address`，其类型为`Address?`。`Address`类的定义在下面会说明。 +现在`Residence`有了一个存储`Room`实例的数组，`numberOfRooms`属性被实现为计算型属性，而不是存储型属性。`numberOfRooms`属性简单地返回`rooms`数组的`count`属性的值。 -类`Room`是一个简单类，只包含一个属性`name`，以及一个初始化函数： +`Residence`还提供了访问`rooms`数组的快捷方式，即提供可读写的下标来访问`rooms`数组中指定位置的元素。 + +此外，`Residence`还提供了`printNumberOfRooms()`方法，这个方法的作用是打印`numberOfRooms`的值。 + +最后，`Residence`还定义了一个可选属性`address`，其类型为`Address?`。`Address`类的定义在下面会说明。 + +`Room`类是一个简单类，其实例被存储在`rooms`数组中。该类只包含一个属性`name`，以及一个用于将该属性设置为适当的房间名的初始化函数： ```swift class Room { @@ -135,7 +159,7 @@ class Room { } ``` -最后一个类是`Address`，这个类有三个`String?`类型的可空属性。`buildingName`以及`buildingNumber`属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称： +最后一个类是`Address`，这个类有三个`String?`类型的可选属性。`buildingName`以及`buildingNumber`属性分别表示某个大厦的名称和号码，第三个属性`street`表示大厦所在街道的名称： ```swift class Address { @@ -145,8 +169,8 @@ class Address { func buildingIdentifier() -> String? { if buildingName != nil { return buildingName - } else if buildingNumber != nil { - return buildingNumber + } else if buildingNumber != nil && street != nil { + return "\(buildingNumber) \(street)" } else { return nil } @@ -154,12 +178,14 @@ class Address { } ``` -类`Address`提供`buildingIdentifier()`方法，返回值为`String?`。 如果`buildingName`不为空则返回`buildingName`， 如果`buildingNumber`不为空则返回`buildingNumber`。如果这两个属性都为空则返回`nil`。 +`Address`类提供了`buildingIdentifier()`方法，返回值为`String?`。 如果`buildingName`有值则返回`buildingName`。或者，如果`buildingNumber`和`street`均有值则返回`buildingNumber`。否则，返回`nil`。 -##通过可空链式调用访问属性 -正如[使用可空链式调用来强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping)中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。 + +## 通过可选链式调用访问属性 -下面的代码创建了一个`Person`实例，然后访问`numberOfRooms`属性： +正如[使用可选链式调用代替强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping)中所述，可以通过可选链式调用在一个可选值上访问它的属性，并判断访问是否成功。 + +下面的代码创建了一个`Person`实例，然后像之前一样，尝试访问`numberOfRooms`属性： ```swift let john = Person() @@ -168,12 +194,12 @@ if let roomCount = john.residence?.numberOfRooms { } else { print("Unable to retrieve the number of rooms.") } -// prints "Unable to retrieve the number of rooms." +// 打印 “Unable to retrieve the number of rooms.” ``` -因为`john.residence`为`nil`，所以毫无疑问这个可空链式调用失败。 +因为`john.residence`为`nil`，所以这个可选链式调用依旧会像先前一样失败。 -通过可空链式调用来设定属性值： +还可以通过可选链式调用来设置属性值： ```swift let someAddress = Address() @@ -182,11 +208,31 @@ someAddress.street = "Acacia Road" john.residence?.address = someAddress ``` -在这个例子中，通过`john.residence`来设定`address`属性也是不行的，因为`john.residence`为`nil`。 +在这个例子中，通过`john.residence`来设定`address`属性也会失败，因为`john.residence`当前为`nil`。 -##通过可空链式调用来调用方法 -可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。 -`Residence`中的`printNumberOfRooms()`方法输出当前的`numberOfRooms`值： +上面代码中的赋值过程是可选链式调用的一部分，这意味着可选链式调用失败时，等号右侧的代码不会被执行。对于上面的代码来说，很难验证这一点，因为像这样赋值一个常量没有任何副作用。下面的代码完成了同样的事情，但是它使用一个函数来创建`Address`实例，然后将该实例返回用于赋值。该函数会在返回前打印“Function was called”，这使你能验证等号右侧的代码是否被执行。 + +```swift +func createAddress() -> Address { + print("Function was called.") + + let someAddress = Address() + someAddress.buildingNumber = "29" + someAddress.street = "Acacia Road" + + return someAddress +} +john.residence?.address = createAddress() +``` + +没有任何打印消息，可以看出`createAddress()`函数并未被执行。 + + +## 通过可选链式调用调用方法 + +可以通过可选链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。 + +`Residence`类中的`printNumberOfRooms()`方法打印当前的`numberOfRooms`值，如下所示： ```swift func printNumberOfRooms() { @@ -194,9 +240,9 @@ func printNumberOfRooms() { } ``` -这个方法没有返回值。但是没有返回值的方法隐式返回`Void`类型，如[无返回值函数](./06_Functions.html#functions_without_return_values)中所述。这意味着没有返回值的方法也会返回()或者空的元组。 +这个方法没有返回值。然而，没有返回值的方法具有隐式的返回类型`Void`，如[无返回值函数](./06_Functions.html#functions_without_return_values)中所述。这意味着没有返回值的方法也会返回`()`，或者说空的元组。 -如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为`Void?`，而不是`Void`，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用`if`语句来判断能否成功调用`printNumberOfRooms()`方法，即使方法本身没有定义返回值。通过返回值是否为`nil`可以判断调用是否成功： +如果在可选值上通过可选链式调用来调用这个方法，该方法的返回类型会是`Void?`，而不是`Void`，因为通过可选链式调用得到的返回值都是可选的。这样我们就可以使用`if`语句来判断能否成功调用`printNumberOfRooms()`方法，即使方法本身没有定义返回值。通过判断返回值是否为`nil`可以判断调用是否成功： ```swift if john.residence?.printNumberOfRooms() != nil { @@ -204,10 +250,10 @@ if john.residence?.printNumberOfRooms() != nil { } else { print("It was not possible to print the number of rooms.") } -// prints "It was not possible to print the number of rooms." +// 打印 “It was not possible to print the number of rooms.” ``` -同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给`john.residence`中的`address`属性赋值，即使`residence`为`nil`。通过可空链式调用给属性赋值会返回`Void?`，通过判断返回值是否为`nil`可以知道赋值是否成功： +同样的，可以据此判断通过可选链式调用为属性赋值是否成功。在上面的[通过可选链式调用访问属性](#accessing_properties_through_optional_chaining)的例子中，我们尝试给`john.residence`中的`address`属性赋值，即使`residence`为`nil`。通过可选链式调用给属性赋值会返回`Void?`，通过判断返回值是否为`nil`就可以知道赋值是否成功： ```swift if (john.residence?.address = someAddress) != nil { @@ -215,17 +261,18 @@ if (john.residence?.address = someAddress) != nil { } else { print("It was not possible to set the address.") } -// prints "It was not possible to set the address." +// 打印 “It was not possible to set the address.” ``` + +## 通过可选链式调用访问下标 -##通过可空链式调用来访问下标 -通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。 -> -注意： -当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。可空链式调用的问号一般直接跟在可空表达式的后面。 +通过可选链式调用，我们可以在一个可选值上访问下标，并且判断下标调用是否成功。 -下面这个例子用下标访问`john.residence`中`rooms`数组中第一个房间的名称，因为`john.residence`为`nil`，所以下标调用毫无疑问失败了： +> 注意 +通过可选链式调用访问可选值的下标时，应该将问号放在下标方括号的前面而不是后面。可选链式调用的问号一般直接跟在可选表达式的后面。 + +下面这个例子用下标访问`john.residence`属性存储的`Residence`实例的`rooms`数组中的第一个房间的名称，因为`john.residence`为`nil`，所以下标调用失败了： ```swift if let firstRoomName = john.residence?[0].name { @@ -233,22 +280,20 @@ if let firstRoomName = john.residence?[0].name { } else { print("Unable to retrieve the first room name.") } -// prints "Unable to retrieve the first room name." +// 打印 “Unable to retrieve the first room name.” ``` +在这个例子中，问号直接放在`john.residence`的后面，并且在方括号的前面，因为`john.residence`是可选值。 -在这个例子中，问号直接放在`john.residence`的后面，并且在方括号的前面，因为`john.residence`是可空值。 - -类似的，可以通过下标，用可空链式调用来赋值： +类似的，可以通过下标，用可选链式调用来赋值： ```swift john.residence?[0] = Room(name: "Bathroom") ``` - 这次赋值同样会失败，因为`residence`目前是`nil`。 -如果你创建一个`Residence`实例，添加一些`Room`实例并赋值给`john.residence`，那就可以通过可选链和下标来访问数组中的元素： +如果你创建一个`Residence`实例，并为其`rooms`数组添加一些`Room`实例，然后将`Residence`实例赋值给`john.residence`，那就可以通过可选链和下标来访问数组中的元素： ```swift let johnsHouse = Residence() @@ -261,36 +306,40 @@ if let firstRoomName = john.residence?[0].name { } else { print("Unable to retrieve the first room name.") } -// prints "The first room name is Living Room." +// 打印 “The first room name is Living Room.” ``` -##访问可空类型的下标： -如果下标返回可空类型值，比如Swift中`Dictionary`的`key`下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值： + +### 访问可选类型的下标 + +如果下标返回可选类型值，比如 Swift 中`Dictionary`类型的键的下标，可以在下标的结尾括号后面放一个问号来在其可选返回值上进行可选链式调用： ```swift var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]] testScores["Dave"]?[0] = 91 -testScores["Bev"]?[0]++ +testScores["Bev"]?[0] += 1 testScores["Brian"]?[0] = 72 -// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81] +// "Dave" 数组现在是 [91, 82, 84]，"Bev" 数组现在是 [80, 94, 81] ``` -上面的例子中定义了一个`testScores`数组，包含了两个键值对， 把`String`类型的`key`映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个`key`存在。但是key“Brian”在字典中不存在，所以第三个调用失败。 +上面的例子中定义了一个`testScores`数组，包含了两个键值对，把`String`类型的键映射到一个`Int`值的数组。这个例子用可选链式调用把`"Dave"`数组中第一个元素设为`91`，把`"Bev"`数组的第一个元素`+1`，然后尝试把`"Brian"`数组中的第一个元素设为`72`。前两个调用成功，因为`testScores`字典中包含`"Dave"`和`"Bev"`这两个键。但是`testScores`字典中没有`"Brian"`这个键，所以第三个调用失败。 -##多层链接 -可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。 + +## 连接多层可选链式调用 + +可以通过连接多个可选链式调用在更深的模型层级中访问属性、方法以及下标。然而，多层可选链式调用不会增加返回值的可选层级。 也就是说： -+ 如果你访问的值不是可空的，通过可空链式调用将会放回可空值。 -+ 如果你访问的值已经是可空的，通过可空链式调用不会变得“更”可空。 ++ 如果你访问的值不是可选的，可选链式调用将会返回可选值。 ++ 如果你访问的值就是可选的，可选链式调用不会让可选返回值变得“更可选”。 因此： -+ 通过可空链式调用访问一个`Int`值，将会返回`Int?`，不过进行了多少次可空链式调用。 -+ 类似的，通过可空链式调用访问`Int?`值，并不会变得更加可空。 ++ 通过可选链式调用访问一个`Int`值，将会返回`Int?`，无论使用了多少层可选链式调用。 ++ 类似的，通过可选链式调用访问`Int?`值，依旧会返回`Int?`值，并不会返回`Int??`。 -下面的例子访问`john`中的`residence`中的`address`中的`street`属性。这里使用了两层可空链式调用，`residence`以及`address`，这两个都是可空值。 +下面的例子尝试访问`john`中的`residence`属性中的`address`属性中的`street`属性。这里使用了两层可选链式调用，`residence`以及`address`都是可选值： ```swift if let johnsStreet = john.residence?.address?.street { @@ -298,14 +347,14 @@ if let johnsStreet = john.residence?.address?.street { } else { print("Unable to retrieve the address.") } -// prints "Unable to retrieve the address." +// 打印 “Unable to retrieve the address.” ``` -`john.residence`包含`Residence`实例，但是`john.residence.address`为`nil`。因此，不能访问`john.residence?.address?.street`。 +`john.residence`现在包含一个有效的`Residence`实例。然而，`john.residence.address`的值当前为`nil`。因此，调用`john.residence?.address?.street`会失败。 -需要注意的是，上面的例子中，`street`的属性为`String?`。`john.residence?.address?.street`的返回值也依然是`String?`，即使已经进行了两次可空的链式调用。 +需要注意的是，上面的例子中，`street`的属性为`String?`。`john.residence?.address?.street`的返回值也依然是`String?`，即使已经使用了两层可选链式调用。 -如果把`john.residence.address`指向一个实例，并且为`address`中的`street`属性赋值，我们就能过通过可空链式调用来访问`street`属性。 +如果为`john.residence.address`赋值一个`Address`实例，并且为`address`中的`street`属性设置一个有效值，我们就能过通过可选链式调用来访问`street`属性： ```swift let johnsAddress = Address() @@ -318,24 +367,26 @@ if let johnsStreet = john.residence?.address?.street { } else { print("Unable to retrieve the address.") } -// prints "John's street name is Laurel Street." +// 打印 “John's street name is Laurel Street.” ``` -在上面的例子中，因为`john.residence`是一个可用的`Residence`实例，所以对`john.residence`的`address`属性赋值成功。 +在上面的例子中，因为`john.residence`包含一个有效的`Residence`实例，所以对`john.residence`的`address`属性赋值将会成功。 -##对返回可空值的函数进行链接 -上面的例子说明了如何通过可空链式调用来获取可空属性值。我们还可以通过可空链式调用来调用返回可空值的方法，并且可以继续对可空值进行链接。 + +## 在方法的可选返回值上进行可选链式调用 -在下面的例子中，通过可空链式调用来调用`Address`的`buildingIdentifier()`方法。这个方法返回`String?`类型。正如上面所说，通过可空链式调用的方法的最终返回值还是`String?`： +上面的例子展示了如何在一个可选值上通过可选链式调用来获取它的属性值。我们还可以在一个可选值上通过可选链式调用来调用方法，并且可以根据需要继续在方法的可选返回值上进行可选链式调用。 + +在下面的例子中，通过可选链式调用来调用`Address`的`buildingIdentifier()`方法。这个方法返回`String?`类型的值。如上所述，通过可选链式调用来调用该方法，最终的返回值依旧会是`String?`类型： ```swift if let buildingIdentifier = john.residence?.address?.buildingIdentifier() { print("John's building identifier is \(buildingIdentifier).") } -// prints "John's building identifier is The Larches." +// 打印 “John's building identifier is The Larches.” ``` -如果要进一步对方法的返回值进行可空链式调用，在方法`buildingIdentifier()`的圆括号后面加上问号： +如果要在该方法的返回值上进行可选链式调用，在方法的圆括号后面加上问号即可： ```swift if let beginsWithThe = @@ -346,9 +397,8 @@ if let beginsWithThe = print("John's building identifier does not begin with \"The\".") } } -// prints "John's building identifier begins with "The"." +// 打印 “John's building identifier begins with "The".” ``` -> -注意： -在上面的例子中在，在方法的圆括号后面加上问号是因为`buildingIdentifier()`的返回值是可空值，而不是方法本身是可空的。 +> 注意 +在上面的例子中，在方法的圆括号后面加上问号是因为你要在`buildingIdentifier()`方法的可选返回值上进行可选链式调用，而不是方法本身。 diff --git a/source/chapter2/18_Error_Handling.md b/source/chapter2/18_Error_Handling.md index 9fbd27ab..a501ca6f 100755 --- a/source/chapter2/18_Error_Handling.md +++ b/source/chapter2/18_Error_Handling.md @@ -3,63 +3,75 @@ > 2.1 > 翻译+校对：[lyojo](https://github.com/lyojo) [ray16897188](https://github.com/ray16897188) 2015-10-23 +> 校对：[shanks](http://codebuild.me) 2015-10-24 +> +> 2.2 +> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-15 -> 定稿：[shanks](http://codebuild.me) 2015-10-24 +本页包含内容： -本页包含内容： - -- [表示并抛出错误](#representing_and_throwing_errors) -- [处理错误](#handling_errors) +- [表示并抛出错误](#representing_and_throwing_errors) +- [处理错误](#handling_errors) - [指定清理操作](#specifying_cleanup_actions) -*错误处理（Error handling）*是响应错误以及从错误中恢复的过程。swift提供了在运行对可恢复错误抛出，捕获，传送和操作的高级支持。 +*错误处理（Error handling）*是响应错误以及从错误中恢复的过程。Swift 提供了在运行时对可恢复错误的抛出、捕获、传递和操作的一流支持。 -某些操作并不能总是保证执行所有代码都可以执行或总会产出有用的结果。可选类型用来表示值可能为空，但是当执行失败的时候，通常要去了解此次失败是由何引起，你的代码就可以做出与之相应的反应。 +某些操作无法保证总是执行完所有代码或总是生成有用的结果。可选类型可用来表示值缺失，但是当某个操作失败时，最好能得知失败的原因，从而可以作出相应的应对。 -举个例子，假如有个从磁盘上的某个文件读取以并做数据处理的任务，该任务会有多种可能失败的情形，包括指定路径下文件并不存在，文件不具有可读权限，或者文件编码格式不兼容。区分这些错误情形可以让程序解决并处理一部分错误，然后把它解决不了的错误报告给用户。 +举个例子，假如有个从磁盘上的某个文件读取数据并进行处理的任务，该任务会有多种可能失败的情况，包括指定路径下文件并不存在，文件不具有可读权限，或者文件编码格式不兼容。区分这些不同的失败情况可以让程序解决并处理某些错误，然后把它解决不了的错误报告给用户。 -> -注意： -Swift中的错误处理涉及到错误处理模式，这会用到Cocoa和Objective-C中的`NSError`。关于这个class的更多信息请参见：[ Using Swift with Cocoa and Objective-C (Swift 2.1)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)中的[错误处理](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)。 +> 注意 +Swift 中的错误处理涉及到错误处理模式，这会用到 Cocoa 和 Objective-C 中的`NSError`。关于这个类的更多信息请参见 [Using Swift with Cocoa and Objective-C (Swift 2.2)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中的[错误处理](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)。 ##表示并抛出错误 -在Swift中，错误用遵循`ErrorType`协议类型的值来表示。这个空协议表示一种可以用做错误处理的类型。 -Swift的枚举类型尤为适合塑造一组相关的错误情形(error conditions)，枚举的关联值(assiciated values)还可以提供额外信息，表示某些错误情形的性质。比如你可以这样表示在一个游戏中操作自动贩卖机会出现的错误情形： + +在 Swift 中，错误用符合`ErrorType`协议的类型的值来表示。这个空协议表明该类型可以用于错误处理。 + +Swift 的枚举类型尤为适合构建一组相关的错误状态，枚举的关联值还可以提供错误状态的额外信息。例如，你可以这样表示在一个游戏中操作自动贩卖机时可能会出现的错误状态： ```swift enum VendingMachineError: ErrorType { - case InvalidSelection //选择无效 - case InsufficientFunds(coinsNeeded: Int) //金额不足 - case OutOfStock //缺货 + case InvalidSelection //选择无效 + case InsufficientFunds(coinsNeeded: Int) //金额不足 + case OutOfStock //缺货 } ``` -抛出一个错误会让你对所发生的意外情况做出提示，表示正常的执行流程不能被执行下去。抛出错误使用`throws`关键字。比如下面的代码抛出一个错误，提示贩卖机还需要5个硬币： + +抛出一个错误可以让你表明有意外情况发生，导致正常的执行流程无法继续执行。抛出错误使用`throw`关键字。例如，下面的代码抛出一个错误，提示贩卖机还需要`5`个硬币： ```swift throw VendingMachineError.InsufficientFunds(coinsNeeded: 5) ``` + ##处理错误 -某个错误被抛出时，那个地方的某部分代码必须要负责处理这个错误 - 比如纠正这个问题、尝试另外一种方式、或是给用户提示这个错误。 -Swift中有 4 种处理错误的方式。你可以把函数抛出的错误传递给调用此函数的代码、用`do-catch`语句处理错误、将错误作为可选类型处理、或者断言此错误根本不会发生。每种方式在下面相应小节都有描述。 -当一个函数抛出一个错误时，你的程序流程会发生改变，所以关键是你要迅速的标识出代码中抛出错误的地方。为了标识出这些地方，在调用一个能抛出错误的函数，方法，或者构造器之前，加上`try`关键字 - 或者`try?`或者`try!`的变体。这些关键字在下面的小节中有具体讲解。 ->注意 ->Swift中的错误处理和其他语言中的用`try`，`catch`和`throw`的异常处理(exception handling)很像。和其他语言中(包括Objective-C)的异常处理不同的是，Swift中的错误处理并不涉及堆栈解退(Stack unwinding)，这是一个计算昂贵(computationally expensive)的过程。就此而言，`throw`语句的性能特性是可以和`return`语句相当的。 -###用throwing函数传递错误 -用`throws`关键字标来识一个可抛出错误的函数，方法或是构造器。在函数声明中的参数列表之后加上`throws`。一个标识了`throws`的函数被称作*throwing函数*。如果这个函数还有返回值类型，`throws`关键词需要写在箭头(->)的前面。 +某个错误被抛出时，附近的某部分代码必须负责处理这个错误，例如纠正这个问题、尝试另外一种方式、或是向用户报告错误。 + +Swift 中有`4`种处理错误的方式。你可以把函数抛出的错误传递给调用此函数的代码、用`do-catch`语句处理错误、将错误作为可选类型处理、或者断言此错误根本不会发生。每种方式在下面的小节中都有描述。 + +当一个函数抛出一个错误时，你的程序流程会发生改变，所以重要的是你能迅速识别代码中会抛出错误的地方。为了标识出这些地方，在调用一个能抛出错误的函数、方法或者构造器之前，加上`try`关键字，或者`try?`或`try!`这种变体。这些关键字在下面的小节中有具体讲解。 + +> 注意 +> Swift 中的错误处理和其他语言中用`try`，`catch`和`throw`进行异常处理很像。和其他语言中（包括 Objective-C ）的异常处理不同的是，Swift 中的错误处理并不涉及解除调用栈，这是一个计算代价高昂的过程。就此而言，`throw`语句的性能特性是可以和`return`语句相媲美的。 + + +### 用 throwing 函数传递错误 + +为了表示一个函数、方法或构造器可以抛出错误，在函数声明的参数列表之后加上`throws`关键字。一个标有`throws`关键字的函数被称作*throwing 函数*。如果这个函数指明了返回值类型，`throws`关键词需要写在箭头（`->`）的前面。 ```swift func canThrowErrors() throws -> String func cannotThrowErrors() -> String ``` -一个throwing函数从其内部抛出错误，并传递到该函数被调用时所在的区域中。 ->注意 -只有throwing函数可以传递错误。任何在某个非throwing函数内部抛出的错误只能在此函数内部处理 -下面的例子中`VendingMechine`类有一个`vend(itemNamed:)`方法，如果需要的物品不存在，缺货或者花费超过了已投入金额，该方法就会抛出一个相称的`VendingMachineError`。 +一个 throwing 函数可以在其内部抛出错误，并将错误传递到函数被调用时的作用域。 +> 注意 +只有 throwing 函数可以传递错误。任何在某个非 throwing 函数内部抛出的错误只能在函数内部处理。 + +下面的例子中，`VendingMechine`类有一个`vend(itemNamed:)`方法，如果请求的物品不存在、缺货或者投入金额小于物品价格，该方法就会抛出一个相应的`VendingMachineError`： ```swift struct Item { @@ -79,7 +91,7 @@ class VendingMachine { } func vend(itemNamed name: String) throws { - guard var item = inventory[name] else { + guard let item = inventory[name] else { throw VendingMachineError.InvalidSelection } @@ -92,16 +104,19 @@ class VendingMachine { } coinsDeposited -= item.price - --item.count - inventory[name] = item + + var newItem = item + newItem.count -= 1 + inventory[name] = newItem + dispenseSnack(name) } } ``` -`vend(itemNamed:)`方法的实现使用了`guard`语句，确保在购买某个零食所需的条件有任一不被满足时能够尽早退出此方法并抛出相匹配的错误。由于`throw`语句会立即将程序控制转移，所以某件物品只有在所有条件都满足时才会被售出。 +在`vend(itemNamed:)`方法的实现中使用了`guard`语句来提前退出方法，确保在购买某个物品所需的条件中，有任一条件不满足时，能提前退出方法并抛出相应的错误。由于`throw`语句会立即退出方法，所以物品只有在所有条件都满足时才会被售出。 -因为`vend(itemNamed:)`方法会传递出它抛出的任何错误，在你代码中调用它的地方必须要么直接处理这些错误 - 使用`do-catch`语句，`try?`或`try!`，要么继续将这些错误传递下去。例如下面例子中`buyFavoriteSnack(_:vendingMachine)`同样是一个 throwing 函数，任何由`vend(itemNamed:)`方法抛出的错误会一直被传递到`buyFavoriteSnack(_:vendingMachine)`函数被调用的那个地方。 +因为`vend(itemNamed:)`方法会传递出它抛出的任何错误，在你的代码中调用此方法的地方，必须要么直接处理这些错误——使用`do-catch`语句，`try?`或`try!`；要么继续将这些错误传递下去。例如下面例子中，`buyFavoriteSnack(_:vendingMachine:)`同样是一个 throwing 函数，任何由`vend(itemNamed:)`方法抛出的错误会一直被传递到`buyFavoriteSnack(_:vendingMachine:)`函数被调用的地方。 ```swift let favoriteSnacks = [ @@ -114,12 +129,27 @@ func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws { try vendingMachine.vend(itemNamed: snackName) } ``` -上例中`buyFavoriteSnack(_:vendingMachine)`函数会查找某人最喜欢的零食，并通过调用`vend(itemNamed:)`方法来尝试为他们买。因为`vend(itemNamed:)`方法能抛出错误，所以在调用的它时候在它前面加了`try`关键字。 + +上例中，`buyFavoriteSnack(_:vendingMachine:)`函数会查找某人最喜欢的零食，并通过调用`vend(itemNamed:)`方法来尝试为他们购买。因为`vend(itemNamed:)`方法能抛出错误，所以在调用的它时候在它前面加了`try`关键字。 + +throwing构造器能像throwing函数一样传递错误.例如下面代码中的`PurchasedSnack`构造器在构造过程中调用了throwing函数,并且通过传递到它的调用者来处理这些错误。 + +```swift +struct PurchasedSnack { + let name: String + init(name: String, vendingMachine: VendingMachine) throws { + try vendingMachine.vend(itemNamed: name) + self.name = name + } +} +``` ###用 Do-Catch 处理错误 -可以使用一个`do-catch`语句运行一段闭包代码来做错误处理。如果在`do`语句中的代码抛出了一个错误，则这个错误会与`catch`语句做匹配来决定哪条语句能处理它。 -下面是`do-catch`语句的通用形式： + +可以使用一个`do-catch`语句运行一段闭包代码来处理错误。如果在`do`子句中的代码抛出了一个错误，这个错误会与`catch`子句做匹配，从而决定哪条子句能处理它。 + +下面是`do-catch`语句的一般形式： ```swift do { @@ -131,9 +161,10 @@ do { statements } ``` -在`catch`后面写一个模式(pattern)来表示这个语句能处理什么样的错误。如果一条`catch`语句没带一个模式，那么这条语句可以和任何错误相匹配，并且把错误和一个名字为`name`的局部常量做绑定。关于模式匹配的更多信息请参考[Patterns](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/doc/uid/TP40014097-CH36-ID419)。 -`catch`语句不必将`do`语句中代码所抛出的每个可能的错误都处理。如果没有一条`catch`字句来处理错误，错误就会传播到周围的作用域。然而错误还是必须要被某个周围的作用域处理的 - 要么是一个外围的`do-catch`错误处理语句，要么是一个throwing函数的内部。举例来说，下面的代码处理了`VendingMachineError`枚举类型的全部3个枚举实例，但是所有其它的错误就必须由它周围作用域所处理： +在`catch`后面写一个匹配模式来表明这个子句能处理什么样的错误。如果一条`catch`子句没有指定匹配模式，那么这条子句可以匹配任何错误，并且把错误绑定到一个名字为`error`的局部常量。关于模式匹配的更多信息请参考 [模式](../chapter3/07_Patterns.html)。 + +`catch`子句不必将`do`子句中的代码所抛出的每一个可能的错误都作处理。如果所有`catch`子句都未处理错误，错误就会传递到周围的作用域。然而，错误还是必须要被某个周围的作用域处理的——要么是一个外围的`do-catch`错误处理语句，要么是一个 throwing 函数的内部。举例来说，下面的代码处理了`VendingMachineError`枚举类型的全部枚举值，但是所有其它的错误就必须由它周围的作用域处理： ```swift var vendingMachine = VendingMachine() @@ -147,12 +178,14 @@ do { } catch VendingMachineError.InsufficientFunds(let coinsNeeded) { print("Insufficient funds. Please insert an additional \(coinsNeeded) coins.") } -// prints "Insufficient funds. Please insert an additional 2 coins." +// 打印 “Insufficient funds. Please insert an additional 2 coins.” ``` -上面的例子中`buyFavoriteSnack(_:vendingMachine:)`在一个`try`表达式中被调用，因为它能抛出一个错误。如果一个错误被抛出，相应的执行会被马上转移到`catch`语句中来，判断这个错误是否要被继续传递下去。如果没有错误抛出，`do`语句中余下的语句就会被执行。 + +上面的例子中，`buyFavoriteSnack(_:vendingMachine:)`函数在一个`try`表达式中调用，因为它能抛出错误。如果错误被抛出，相应的执行会马上转移到`catch`子句中，并判断这个错误是否要被继续传递下去。如果没有错误抛出，`do`子句中余下的语句就会被执行。 ###将错误转换成可选值 -可以使用`try?`通过将其转换成一个可选值来处理错误。如果在评估`try?`表达式时一个错误被抛出，那么这个表达式的值就是`nil`。例如下面代码中的`x`和`y`有相同的值和特性： + +可以使用`try?`通过将错误转换成一个可选值来处理错误。如果在评估`try?`表达式时一个错误被抛出，那么表达式的值就是`nil`。例如,在下面的代码中,`x`和`y`有着相同的数值和等价的含义： ```swift func someThrowingFunction() throws -> Int { @@ -169,8 +202,9 @@ do { } ``` -如果`someThrowingFunction()`抛出一个错误，`x`和`y`的值是`nil`。否则`x`和`y`的值就是该函数的返回值。注意无论`someThrowingFunction()`的返回值类型是什么类型，`x`和`y`都是这个类型的可选类型。例子中此函数返回一个整型，所以`x`和`y`是整型的可选类型。 -如果你想对所有的错误都采用同样的方式来处理，用`try?`就可以让你写出简洁的错误处理代码。比如下面的代码用一些的方式来获取数据，如果所有的方法都失败则返回`nil`。 +如果`someThrowingFunction()`抛出一个错误，`x`和`y`的值是`nil`。否则`x`和`y`的值就是该函数的返回值。注意，无论`someThrowingFunction()`的返回值类型是什么类型，`x`和`y`都是这个类型的可选类型。例子中此函数返回一个整型，所以`x`和`y`是可选整型。 + +如果你想对所有的错误都采用同样的方式来处理，用`try?`就可以让你写出简洁的错误处理代码。例如，下面的代码用几种方式来获取数据，如果所有方式都失败了则返回`nil`： ```swift func fetchData() -> Data? { @@ -179,9 +213,12 @@ func fetchData() -> Data? { return nil } ``` -###使错误传递失效 -有时你知道某个 throwing 函数实际上在运行时是不会抛出错误的。在这种条件下，你可以在表达式前面写`try!`来使错误传递失效，并把调用包装在一个运行时断言(runtime assertion)中来断定不会有错误抛出。如果实际上确实抛出了错误，你就会得到一个运行时错误。 -例如下面的代码使用了`loadImage(_:)`函数，该函数从给定的路径下装载图片资源，如果图片不能够被载入则抛出一个错误。此种情况下因为图片是和应用绑定的，运行时不会有错误被抛出，所以是错误传递失效是没问题的。 + +### 禁用错误传递 + +有时你知道某个 throwing 函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写`try!`来禁用错误传递，这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误，你会得到一个运行时错误。 + +例如，下面的代码使用了`loadImage(_:)`函数，该函数从给定的路径加载图片资源，如果图片无法载入则抛出一个错误。在这种情况下，因为图片是和应用绑定的，运行时不会有错误抛出，所以适合禁用错误传递： ```swift let photo = try! loadImage("./Resources/John Appleseed.jpg") @@ -189,24 +226,27 @@ let photo = try! loadImage("./Resources/John Appleseed.jpg") ##指定清理操作 -可以使用`defer`语句在代码执行到要离开当前的代码段之前去执行一套语句。该语句让你能够做一些应该被执行的必要清理工作，不管是以何种方式离开当前的代码段的 - 无论是由于抛出错误而离开，或是因为一条`return`或者`break`的类似语句。比如你可以用`defer`语句来保证文件描述符(file descriptors)已被关闭，并且手动分配的内存也被释放了。 -`defer`语句将代码的执行延迟到当前的作用域退出之前。该语句由`defer`关键字和要被延时执行的语句组成。延时执行的语句不会包含任何会将控制权移交到语句外面的代码，例如一条`break`或是`return`语句，或是抛出一个错误。延迟执行的操作是按照它们被指定的相反顺序执行 - 意思是第一条`defer`语句中的代码执行是在第二条`defer`语句中代码被执行之后，以此类推。 + +可以使用`defer`语句在即将离开当前代码块时执行一系列语句。该语句让你能执行一些必要的清理工作，不管是以何种方式离开当前代码块的——无论是由于抛出错误而离开，还是由于诸如`return`或者`break`的语句。例如，你可以用`defer`语句来确保文件描述符得以关闭，以及手动分配的内存得以释放。 + +`defer`语句将代码的执行延迟到当前的作用域退出之前。该语句由`defer`关键字和要被延迟执行的语句组成。延迟执行的语句不能包含任何控制转移语句，例如`break`或是`return`语句，或是抛出一个错误。延迟执行的操作会按照它们被指定时的顺序的相反顺序执行——也就是说，第一条`defer`语句中的代码会在第二条`defer`语句中的代码被执行之后才执行，以此类推。 ```swift - func processFile(filename: String) throws { - if exists(filename) { - let file = open(filename) - defer { - close(file) - } - while let line = try file.readline() { - // 处理文件 - } - // 在这里，作用域的最后调用 close(file) - } - } +func processFile(filename: String) throws { + if exists(filename) { + let file = open(filename) + defer { + close(file) + } + while let line = try file.readline() { + // 处理文件。 + } + // close(file) 会在这里被调用，即作用域的最后。 + } +} ``` -上面的代码用了一条`defer`语句来确保`open(_:)`函数有一个相应的对`close(_:)`的调用。 ->注意 ->即使没有涉及到错误处理代码，你也可以用`defer`语句。 \ No newline at end of file +上面的代码使用一条`defer`语句来确保`open(_:)`函数有一个相应的对`close(_:)`函数的调用。 + +> 注意 +> 即使没有涉及到错误处理，你也可以使用`defer`语句。 diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/19_Nested_Types.md deleted file mode 100644 index fe0bf822..00000000 --- a/source/chapter2/19_Nested_Types.md +++ /dev/null @@ -1,99 +0,0 @@ -> 1.0 -> 翻译：[Lin-H](https://github.com/Lin-H) -> 校对：[shinyzhu](https://github.com/shinyzhu) - -> 2.0 -> 翻译+校对：[SergioChan](https://github.com/SergioChan) - -# 嵌套类型 ------------------ - -本页包含内容： - -- [嵌套类型实例](#nested_types_in_action) -- [嵌套类型的引用](#referring_to_nested_types) - -枚举类型常被用于实现特定类或结构体的功能。也能够在有多种变量类型的环境中，方便地定义通用类或结构体来使用，为了实现这种功能，Swift允许你定义嵌套类型，可以在枚举类型、类和结构体中定义支持嵌套的类型。 - -要在一个类型中嵌套另一个类型，将需要嵌套的类型的定义写在被嵌套类型的区域{}内，而且可以根据需要定义多级嵌套。 - - -##嵌套类型实例 - -下面这个例子定义了一个结构体`BlackjackCard`(二十一点)，用来模拟`BlackjackCard`中的扑克牌点数。`BlackjackCard`结构体包含2个嵌套定义的枚举类型`Suit` 和 `Rank`。 - -在`BlackjackCard`规则中，`Ace`牌可以表示1或者11，`Ace`牌的这一特征用一个嵌套在枚举型`Rank`的结构体`Values`来表示。 - -```swift -struct BlackjackCard { - // 嵌套定义枚举型Suit - enum Suit: Character { - case Spades = "♠", Hearts = "♡", Diamonds = "♢", Clubs = "♣" - } - - // 嵌套定义枚举型Rank - enum Rank: Int { - case Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten - case Jack, Queen, King, Ace - struct Values { - let first: Int, second: Int? - } - var values: Values { - switch self { - case .Ace: - return Values(first: 1, second: 11) - case .Jack, .Queen, .King: - return Values(first: 10, second: nil) - default: - return Values(first: self.rawValue, second: nil) - } - } - } - - // BlackjackCard 的属性和方法 - let rank: Rank, suit: Suit - var description: String { - var output = "suit is \(suit.rawValue)," - output += " value is \(rank.values.first)" - if let second = rank.values.second { - output += " or \(second)" - } - return output - } -} -``` - -枚举型的`Suit`用来描述扑克牌的四种花色，并分别用一个`Character`类型的值代表花色符号。 - -枚举型的`Rank`用来描述扑克牌从`Ace`~10,`J`,`Q`,`K`,13张牌，并分别用一个`Int`类型的值表示牌的面值。(这个`Int`类型的值不适用于`Ace`,`J`,`Q`,`K`的牌)。 - -如上文所提到的，枚举型`Rank`在自己内部定义了一个嵌套结构体`Values`。在这个结构体中，只有`Ace`有两个数值，其余牌都只有一个数值。结构体`Values`中定义的两个属性： - -`first`, 为` Int` -`second`, 为 `Int?`, 或 “optional `Int`” - -`Rank`定义了一个计算属性`values`，它将会返回一个结构体`Values`的实例。这个计算属性会根据牌的面值，用适当的数值去初始化`Values`实例，并赋值给`values`。对于`J`,`Q`,`K`,`Ace`会使用特殊数值，对于数字面值的牌使用`Int`类型的值。 - -`BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。 - -因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[结构体的逐一成员构造器](./14_Initialization.html#memberwise_initializers_for_structure_types)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`: - -```swift -let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades) -print("theAceOfSpades: \(theAceOfSpades.description)") -// 打印出 "theAceOfSpades: suit is ♠, value is 1 or 11" -``` - -尽管`Rank`和`Suit`嵌套在`BlackjackCard`中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中`description`属性能正确得输出对`Ace`牌有1和11两个值。 - - -##嵌套类型的引用 - -在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名： - -```swift -let heartsSymbol = BlackjackCard.Suit.Hearts.rawValue -// 红心的符号 为 "♡" -``` - -对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由定义它们的上下文来限定。 diff --git a/source/chapter2/19_Type_Casting.md b/source/chapter2/19_Type_Casting.md index 538a53ad..8eef424b 100644 --- a/source/chapter2/19_Type_Casting.md +++ b/source/chapter2/19_Type_Casting.md @@ -8,26 +8,32 @@ > 2.0 > 翻译+校对：[yangsiy](https://github.com/yangsiy) +> 2.1 +> 校对：[shanks](http://codebuild.me)，2015-11-01 +> +> 2.2 +> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-16 + 本页包含内容： - [定义一个类层次作为例子](#defining_a_class_hierarchy_for_type_casting) - [检查类型](#checking_type) - [向下转型（Downcasting）](#downcasting) -- [`Any`和`AnyObject`的类型转换](#type_casting_for_any_and_anyobject) +- [`Any` 和 `AnyObject` 的类型转换](#type_casting_for_any_and_anyobject) _类型转换_ 可以判断实例的类型，也可以将实例看做是其父类或者子类的实例。 类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。 -你也可以用它来检查一个类是否实现了某个协议，就像在 [检验协议的一致性](./22_Protocols.html#checking_for_protocol_conformance)部分讲述的一样。 +你也可以用它来检查一个类型是否实现了某个协议，就像在[检验协议的一致性](./22_Protocols.html#checking_for_protocol_conformance)部分讲述的一样。 ## 定义一个类层次作为例子 -你可以将类型转换用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型转换的例子。 +你可以将类型转换用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。下面的三个代码段定义了一个类层次和一个包含了这些类实例的数组，作为类型转换的例子。 -第一个代码片段定义了一个新的基础类 `MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个 `init name` 初始化器。（假定所有的媒体项都有个名称。） +第一个代码片段定义了一个新的基类 `MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个 `init(name:)` 初始化器。（假定所有的媒体项都有个名称。） ```swift class MediaItem { @@ -58,7 +64,7 @@ class Song: MediaItem { } ``` -最后一个代码段创建了一个数组常量 `library`，包含两个 `Movie` 实例和三个 `Song` 实例。`library` 的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift的类型检测器能够推理出 `Movie` 和 `Song` 有共同的父类 `MediaItem`，所以它推断出 `[MediaItem]` 类作为 `library` 的类型。 +最后一个代码段创建了一个数组常量 `library`，包含两个 `Movie` 实例和三个 `Song` 实例。`library` 的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够推断出 `Movie` 和 `Song` 有共同的父类 `MediaItem`，所以它推断出 `[MediaItem]` 类作为 `library` 的类型： ```swift let library = [ @@ -68,7 +74,7 @@ let library = [ Song(name: "The One And Only", artist: "Chesney Hawkes"), Song(name: "Never Gonna Give You Up", artist: "Rick Astley") ] -// the type of "library" is inferred to be [MediaItem] +// 数组 library 的类型被推断为 [MediaItem] ``` 在幕后 `library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的。但是，若你迭代它，依次取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型。为了让它们作为原本的类型工作，你需要检查它们的类型或者向下转换它们到其它类型，就像下面描述的一样。 @@ -76,9 +82,9 @@ let library = [ ## 检查类型（Checking Type） -用类型检查操作符(`is`)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true`，否则返回 `false`。 +用类型检查操作符（`is`）来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true`，否则返回 `false`。 -下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组 `library` 中 `Movie` 和 `Song` 类型的实例数量。 +下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组 `library` 中 `Movie` 和 `Song` 类型的实例数量： ```swift var movieCount = 0 @@ -86,37 +92,36 @@ var songCount = 0 for item in library { if item is Movie { - ++movieCount + movieCount += 1 } else if item is Song { - ++songCount + songCount += 1 } } print("Media library contains \(movieCount) movies and \(songCount) songs") -// prints "Media library contains 2 movies and 3 songs" +// 打印 “Media library contains 2 movies and 3 songs” ``` -示例迭代了数组 `library` 中的所有项。每一次，`for`-`in` 循环设置 +示例迭代了数组 `library` 中的所有项。每一次，`for-in` 循环设置 `item` 为数组中的下一个 `MediaItem`。 若当前 `MediaItem` 是一个 `Movie` 类型的实例，`item is Movie` 返回 -`true`，相反返回 `false`。同样的，`item is -Song` 检查item是否为 `Song` 类型的实例。在循环结束后，`movieCount` 和 `songCount` 的值就是被找到属于各自的类型的实例数量。 +`true`，否则返回 `false`。同样的，`item is Song` 检查 `item` 是否为 `Song` 类型的实例。在循环结束后，`movieCount` 和 `songCount` 的值就是被找到的属于各自类型的实例的数量。 ## 向下转型（Downcasting） -某类型的一个常量或变量可能在幕后实际上属于一个子类。当确定是这种情况时，你可以尝试向下转到它的子类型，用类型转换操作符(`as?` 或 `as!`) +某类型的一个常量或变量可能在幕后实际上属于一个子类。当确定是这种情况时，你可以尝试向下转到它的子类型，用类型转换操作符（`as?` 或 `as!`）。 -因为向下转型可能会失败，类型转型操作符带有两种不同形式。条件形式（conditional form） `as?` 返回一个你试图向下转成的类型的可选值（optional value）。强制形式 `as!` 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。 +因为向下转型可能会失败，类型转型操作符带有两种不同形式。条件形式（conditional form）`as?` 返回一个你试图向下转成的类型的可选值（optional value）。强制形式 `as!` 把试图向下转型和强制解包（force-unwraps）转换结果结合为一个操作。 -当你不确定向下转型可以成功时，用类型转换的条件形式(`as?`)。条件形式的类型转换总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil`。这使你能够检查向下转型是否成功。 +当你不确定向下转型可以成功时，用类型转换的条件形式（`as?`）。条件形式的类型转换总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil`。这使你能够检查向下转型是否成功。 -只有你可以确定向下转型一定会成功时，才使用强制形式(`as!`)。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。 +只有你可以确定向下转型一定会成功时，才使用强制形式（`as!`）。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。 -下面的例子，迭代了 `library` 里的每一个 `MediaItem`，并打印出适当的描述。要这样做，`item` 需要真正作为 `Movie` 或 `Song` 的类型来使用，不仅仅是作为 `MediaItem`。为了能够在描述中使用 `Movie` 或 `Song` 的 `director` 或 `artist` 属性，这是必要的。 +下面的例子，迭代了 `library` 里的每一个 `MediaItem`，并打印出适当的描述。要这样做，`item` 需要真正作为 `Movie` 或 `Song` 的类型来使用，而不仅仅是作为 `MediaItem`。为了能够在描述中使用 `Movie` 或 `Song` 的 `director` 或 `artist` 属性，这是必要的。 -在这个示例中，数组中的每一个 `item` 可能是 `Movie` 或 `Song`。事前你不知道每个 `item` 的真实类型，所以这里使用条件形式的类型转换(`as?`)去检查循环里的每次下转。 +在这个示例中，数组中的每一个 `item` 可能是 `Movie` 或 `Song`。事前你不知道每个 `item` 的真实类型，所以这里使用条件形式的类型转换（`as?`）去检查循环里的每次下转： ```swift for item in library { @@ -136,37 +141,38 @@ for item in library { 示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem` 类型的实例，它可能是一个 `Movie`；同样，它也可能是一个 `Song`，或者仅仅是基类 -`MediaItem`。因为不确定，`as?`形式在试图下转时将返回一个可选值。`item as? Movie` 的返回值是 `Movie?` 或 “可选 `Movie`”类型。 +`MediaItem`。因为不确定，`as?` 形式在试图下转时将返回一个可选值。`item as? Movie` 的返回值是 `Movie?` 或者说“可选 `Movie`”。 当向下转型为 `Movie` 应用在两个 `Song` 实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 `Movie` 真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”，可以这样解读： -“尝试将 `item` 转为 `Movie` 类型。若成功，设置一个新的临时常量 `movie` 来存储返回的可选 `Movie`” +“尝试将 `item` 转为 `Movie` 类型。若成功，设置一个新的临时常量 `movie` 来存储返回的可选 `Movie` 中的值” -若向下转型成功，然后 `movie` 的属性将用于打印一个 `Movie` 实例的描述，包括它的导演的名字 `director` 。相近的原理被用来检测 `Song` 实例，当 `Song` 被找到时则打印它的描述（包含 `artist` 的名字）。 +若向下转型成功，然后 `movie` 的属性将用于打印一个 `Movie` 实例的描述，包括它的导演的名字 `director`。相似的原理被用来检测 `Song` 实例，当 `Song` 被找到时则打印它的描述（包含 `artist` 的名字）。 -> 注意： -> 转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。 +> 注意 +> 转换没有真的改变实例或它的值。根本的实例保持不变；只是简单地把它作为它被转换成的类型来使用。 -## `Any`和`AnyObject`的类型转换 +## `Any` 和 `AnyObject` 的类型转换 -Swift为不确定类型提供了两种特殊类型别名： +Swift 为不确定类型提供了两种特殊的类型别名： -* `AnyObject`可以代表任何class类型的实例。 -* `Any`可以表示任何类型，包括方法类型（function types）。 +* `AnyObject` 可以表示任何类类型的实例。 +* `Any` 可以表示任何类型，包括函数类型。 -> 注意： -> 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。 +> 注意 +> 只有当你确实需要它们的行为和功能时才使用 `Any` 和 `AnyObject`。在你的代码里使用你期望的明确类型总是更好的。 -### `AnyObject`类型 +### `AnyObject` 类型 -当在工作中使用 Cocoa APIs，我们一般会接收一个`[AnyObject]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以从 API 提供的信息中清晰地确定数组中对象的类型。 +当我们使用 Cocoa APIs 时，我们会接收到一个 `[AnyObject]` 类型的数组，或者说“一个任意类型对象的数组”。Objective-C现在支持明确的数组类型，但早期版本的Objective-C并没有这个功能。不管怎样，你都可以确信API提供的信息能够正确的表明数组中的元素类型。 -在这些情况下，你可以使用强制形式的类型转换(`as`)来下转在数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解析（optional unwrapping）。 -下面的示例定义了一个 `[AnyObject]` 类型的数组并填入三个`Movie`类型的实例： +在这些情况下，你可以使用强制形式的类型转换（`as!`）来下转数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解包（optional unwrapping）。 + +下面的示例定义了一个 `[AnyObject]` 类型的数组并填入三个 `Movie` 类型的实例： ```swift let someObjects: [AnyObject] = [ @@ -176,7 +182,7 @@ let someObjects: [AnyObject] = [ ] ``` -因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as!`)下转并解包到不可选的`Movie`类型： +因为知道这个数组只包含 `Movie` 实例，你可以直接用（`as!`）下转并解包到非可选的 `Movie` 类型： ```swift for object in someObjects { @@ -188,7 +194,7 @@ for object in someObjects { // Movie: 'Alien', dir. Ridley Scott ``` -为了变为一个更短的形式，下转`someObjects`数组为`[Movie]`类型来代替下转数组中每一项的方式。 +为了变为一个更简短的形式，下转 `someObjects` 数组为 `[Movie]` 类型而不是下转数组中的每一项： ```swift for movie in someObjects as! [Movie] { @@ -199,9 +205,10 @@ for movie in someObjects as! [Movie] { // Movie: 'Alien', dir. Ridley Scott ``` -### `Any`类型 + +### `Any` 类型 -这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括方法类型和非 `class` 类型。它创建了一个可以存储`Any`类型的数组 `things`。 +这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括函数类型和非类类型。它创建了一个可以存储 `Any` 类型的数组 `things`： ```swift var things = [Any]() @@ -216,9 +223,9 @@ things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman")) things.append({ (name: String) -> String in "Hello, \(name)" }) ``` -`things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，电影“Ghostbusters”，和一个获取 `String` 值并返回另一个 `String` 值的闭包表达式。 +`things` 数组包含两个 `Int` 值，两个 `Double` 值，一个 `String` 值，一个元组 `(Double, Double)`，一个`Movie`实例“Ghostbusters”，以及一个接受 `String` 值并返回另一个 `String` 值的闭包表达式。 -你可以在 `switch` 表达式的cases中使用 `is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject` 的常量或变量的类型。下面的示例迭代 `things` 数组中的每一项的并用`switch`语句查找每一项的类型。这几种 `switch` 语句的情形绑定它们匹配的值到一个规定类型的常量，让它们的值可以被打印： +你可以在 `switch` 表达式的 `case` 中使用 `is` 和 `as` 操作符来找出只知道是 `Any` 或 `AnyObject` 类型的常量或变量的具体类型。下面的示例迭代 `things` 数组中的每一项，并用 `switch` 语句查找每一项的类型。有几个 `switch` 语句的 `case` 绑定它们匹配到的值到一个指定类型的常量，从而可以打印这些值： ```swift for thing in things { @@ -255,7 +262,3 @@ for thing in things { // a movie called 'Ghostbusters', dir. Ivan Reitman // Hello, Michael ``` - - -> 注意： -> 在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 `switch` case 语句的内容中这种检查总是安全的。 diff --git a/source/chapter2/20_Nested_Types.md b/source/chapter2/20_Nested_Types.md index 18dfc46d..a4578df9 100755 --- a/source/chapter2/20_Nested_Types.md +++ b/source/chapter2/20_Nested_Types.md @@ -8,30 +8,36 @@ > 2.0 > 翻译+校对：[SergioChan](https://github.com/SergioChan) +> 2.1 +> 校对：[shanks](http://codebuild.me)，2015-11-01 +> +> 2.2 +> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-16 + 本页包含内容： -- [嵌套类型实例](#nested_types_in_action) -- [嵌套类型的引用](#referring_to_nested_types) +- [嵌套类型实践](#nested_types_in_action) +- [引用嵌套类型](#referring_to_nested_types) -枚举类型常被用于实现特定类或结构体的功能。也能够在有多种变量类型的环境中，方便地定义通用类或结构体来使用，为了实现这种功能，Swift允许你定义嵌套类型，可以在枚举类型、类和结构体中定义支持嵌套的类型。 +枚举常被用于为特定类或结构体实现某些功能。类似的，枚举可以方便的定义工具类或结构体，从而为某个复杂的类型所使用。为了实现这种功能，Swift 允许你定义嵌套类型，可以在支持的类型中定义嵌套的枚举、类和结构体。 -要在一个类型中嵌套另一个类型，将需要嵌套的类型的定义写在被嵌套类型的区域{}内，而且可以根据需要定义多级嵌套。 +要在一个类型中嵌套另一个类型，将嵌套类型的定义写在其外部类型的`{}`内，而且可以根据需要定义多级嵌套。 -##嵌套类型实例 +## 嵌套类型实践 -下面这个例子定义了一个结构体`BlackjackCard`(二十一点)，用来模拟`BlackjackCard`中的扑克牌点数。`BlackjackCard`结构体包含2个嵌套定义的枚举类型`Suit` 和 `Rank`。 +下面这个例子定义了一个结构体`BlackjackCard`（二十一点），用来模拟`BlackjackCard`中的扑克牌点数。`BlackjackCard`结构体包含两个嵌套定义的枚举类型`Suit`和`Rank`。 -在`BlackjackCard`规则中，`Ace`牌可以表示1或者11，`Ace`牌的这一特征用一个嵌套在枚举型`Rank`的结构体`Values`来表示。 +在`BlackjackCard`中，`Ace`牌可以表示`1`或者`11`，`Ace`牌的这一特征通过一个嵌套在`Rank`枚举中的结构体`Values`来表示： ```swift struct BlackjackCard { - // 嵌套定义枚举型Suit + // 嵌套的 Suit 枚举 enum Suit: Character { case Spades = "♠", Hearts = "♡", Diamonds = "♢", Clubs = "♣" } - // 嵌套定义枚举型Rank + // 嵌套的 Rank 枚举 enum Rank: Int { case Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King, Ace @@ -63,37 +69,37 @@ struct BlackjackCard { } ``` -枚举型的`Suit`用来描述扑克牌的四种花色，并分别用一个`Character`类型的值代表花色符号。 +`Suit`枚举用来描述扑克牌的四种花色，并用一个`Character`类型的原始值表示花色符号。 -枚举型的`Rank`用来描述扑克牌从`Ace`~10,`J`,`Q`,`K`,13张牌，并分别用一个`Int`类型的值表示牌的面值。(这个`Int`类型的值不适用于`Ace`,`J`,`Q`,`K`的牌)。 +`Rank`枚举用来描述扑克牌从`Ace`~`10`，以及`J`、`Q`、`K`，这`13`种牌，并用一个`Int`类型的原始值表示牌的面值。（这个`Int`类型的原始值未用于`Ace`、`J`、`Q`、`K`这`4`种牌。） -如上文所提到的，枚举型`Rank`在自己内部定义了一个嵌套结构体`Values`。在这个结构体中，只有`Ace`有两个数值，其余牌都只有一个数值。结构体`Values`中定义的两个属性： +如上所述，`Rank`枚举在内部定义了一个嵌套结构体`Values`。结构体`Values`中定义了两个属性，用于反映只有`Ace`有两个数值，其余牌都只有一个数值： -- `first`为` Int` -- `second`为 `Int?` 或 “optional `Int`” +- `first`的类型为`Int` +- `second`的类型为`Int?`，或者说“optional `Int`” -`Rank`定义了一个计算属性`values`，它将会返回一个结构体`Values`的实例。这个计算属性会根据牌的面值，用适当的数值去初始化`Values`实例，并赋值给`values`。对于`J`,`Q`,`K`,`Ace`会使用特殊数值，对于数字面值的牌使用`Int`类型的值。 +`Rank`还定义了一个计算型属性`values`，它将会返回一个`Values`结构体的实例。这个计算型属性会根据牌的面值，用适当的数值去初始化`Values`实例。对于`J`、`Q`、`K`、`Ace`这四种牌，会使用特殊数值。对于数字面值的牌，使用枚举实例的原始值。 -`BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。 +`BlackjackCard`结构体拥有两个属性——`rank`与`suit`。它也同样定义了一个计算型属性`description`，`description`属性用`rank`和`suit`中的内容来构建对扑克牌名字和数值的描述。该属性使用可选绑定来检查可选类型`second`是否有值，若有值，则在原有的描述中增加对`second`的描述。 -因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[结构体的逐一成员构造器](./14_Initialization.html#memberwise_initializers_for_structure_types)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`: +因为`BlackjackCard`是一个没有自定义构造器的结构体，在[结构体的逐一成员构造器](./14_Initialization.html#memberwise_initializers_for_structure_types)中可知，结构体有默认的成员构造器，所以你可以用默认的构造器去初始化新常量`theAceOfSpades`： ```swift let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades) print("theAceOfSpades: \(theAceOfSpades.description)") -// 打印出 "theAceOfSpades: suit is ♠, value is 1 or 11" +// 打印 “theAceOfSpades: suit is ♠, value is 1 or 11” ``` -尽管`Rank`和`Suit`嵌套在`BlackjackCard`中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中`description`属性能正确得输出对`Ace`牌有1和11两个值。 +尽管`Rank`和`Suit`嵌套在`BlackjackCard`中，但它们的类型仍可从上下文中推断出来，所以在初始化实例时能够单独通过成员名称（`.Ace`和`.Spades`）引用枚举实例。在上面的例子中，`description`属性正确地反映了黑桃A牌具有`1`和`11`两个值。 -##嵌套类型的引用 +## 引用嵌套类型 -在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名： +在外部引用嵌套类型时，在嵌套类型的类型名前加上其外部类型的类型名作为前缀： ```swift let heartsSymbol = BlackjackCard.Suit.Hearts.rawValue -// 红心的符号 为 "♡" +// 红心符号为 “♡” ``` -对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由定义它们的上下文来限定。 +对于上面这个例子，这样可以使`Suit`、`Rank`和`Values`的名字尽可能的短，因为它们的名字可以由定义它们的上下文来限定。 diff --git a/source/chapter2/20_Type_Casting.md b/source/chapter2/20_Type_Casting.md deleted file mode 100644 index 8ecbbfb7..00000000 --- a/source/chapter2/20_Type_Casting.md +++ /dev/null @@ -1,261 +0,0 @@ -> 1.0 -> 翻译：[xiehurricane](https://github.com/xiehurricane) -> 校对：[happyming](https://github.com/happyming) - -> 2.0 -> 翻译+校对：[yangsiy](https://github.com/yangsiy) - -# 类型转换（Type Casting） ------------------ - -本页包含内容： - -- [定义一个类层次作为例子](#defining_a_class_hierarchy_for_type_casting) -- [检查类型](#checking_type) -- [向下转型（Downcasting）](#downcasting) -- [`Any`和`AnyObject`的类型转换](#type_casting_for_any_and_anyobject) - - -_类型转换_可以判断实例的类型，也可以将实例看做是其父类或者子类的实例。 - -类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。 - -你也可以用它来检查一个类是否实现了某个协议，就像在 [检验协议的一致性](./22_Protocols.html#checking_for_protocol_conformance)部分讲述的一样。 - - -## 定义一个类层次作为例子 - -你可以将类型转换用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型转换的例子。 - -第一个代码片段定义了一个新的基础类 `MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个 `init name` 初始化器。（假定所有的媒体项都有个名称。） - -```swift -class MediaItem { - var name: String - init(name: String) { - self.name = name - } -} -``` - -下一个代码段定义了 `MediaItem` 的两个子类。第一个子类 `Movie` 封装了与电影相关的额外信息，在父类（或者说基类）的基础上增加了一个 `director`（导演）属性，和相应的初始化器。第二个子类 `Song`，在父类的基础上增加了一个 `artist`（艺术家）属性，和相应的初始化器： - -```swift -class Movie: MediaItem { - var director: String - init(name: String, director: String) { - self.director = director - super.init(name: name) - } -} - -class Song: MediaItem { - var artist: String - init(name: String, artist: String) { - self.artist = artist - super.init(name: name) - } -} -``` - -最后一个代码段创建了一个数组常量 `library`，包含两个 `Movie` 实例和三个 `Song` 实例。`library` 的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift的类型检测器能够推理出 `Movie` 和 `Song` 有共同的父类 `MediaItem`，所以它推断出 `[MediaItem]` 类作为 `library` 的类型。 - -```swift -let library = [ - Movie(name: "Casablanca", director: "Michael Curtiz"), - Song(name: "Blue Suede Shoes", artist: "Elvis Presley"), - Movie(name: "Citizen Kane", director: "Orson Welles"), - Song(name: "The One And Only", artist: "Chesney Hawkes"), - Song(name: "Never Gonna Give You Up", artist: "Rick Astley") -] -// the type of "library" is inferred to be [MediaItem] -``` - -在幕后 `library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的。但是，若你迭代它，依次取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型。为了让它们作为原本的类型工作，你需要检查它们的类型或者向下转换它们到其它类型，就像下面描述的一样。 - - -## 检查类型（Checking Type） - -用类型检查操作符(`is`)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true`，否则返回 `false`。 - -下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组 `library` 中 `Movie` 和 `Song` 类型的实例数量。 - -```swift -var movieCount = 0 -var songCount = 0 - -for item in library { - if item is Movie { - ++movieCount - } else if item is Song { - ++songCount - } -} - -print("Media library contains \(movieCount) movies and \(songCount) songs") -// prints "Media library contains 2 movies and 3 songs" -``` - -示例迭代了数组 `library` 中的所有项。每一次，`for`-`in` 循环设置 -`item` 为数组中的下一个 `MediaItem`。 - -若当前 `MediaItem` 是一个 `Movie` 类型的实例，`item is Movie` 返回 -`true`，相反返回 `false`。同样的，`item is -Song` 检查item是否为 `Song` 类型的实例。在循环结束后，`movieCount` 和 `songCount` 的值就是被找到属于各自的类型的实例数量。 - - -## 向下转型（Downcasting） - -某类型的一个常量或变量可能在幕后实际上属于一个子类。当确定是这种情况时，你可以尝试向下转到它的子类型，用类型转换操作符(`as?` 或 `as!`) - -因为向下转型可能会失败，类型转型操作符带有两种不同形式。条件形式（conditional form） `as?` 返回一个你试图向下转成的类型的可选值（optional value）。强制形式 `as!` 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。 - -当你不确定向下转型可以成功时，用类型转换的条件形式(`as?`)。条件形式的类型转换总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil`。这使你能够检查向下转型是否成功。 - -只有你可以确定向下转型一定会成功时，才使用强制形式(`as!`)。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。 - -下面的例子，迭代了 `library` 里的每一个 `MediaItem`，并打印出适当的描述。要这样做，`item` 需要真正作为 `Movie` 或 `Song` 的类型来使用，不仅仅是作为 `MediaItem`。为了能够在描述中使用 `Movie` 或 `Song` 的 `director` 或 `artist` 属性，这是必要的。 - -在这个示例中，数组中的每一个 `item` 可能是 `Movie` 或 `Song`。事前你不知道每个 `item` 的真实类型，所以这里使用条件形式的类型转换(`as?`)去检查循环里的每次下转。 - -```swift -for item in library { - if let movie = item as? Movie { - print("Movie: '\(movie.name)', dir. \(movie.director)") - } else if let song = item as? Song { - print("Song: '\(song.name)', by \(song.artist)") - } -} - -// Movie: 'Casablanca', dir. Michael Curtiz -// Song: 'Blue Suede Shoes', by Elvis Presley -// Movie: 'Citizen Kane', dir. Orson Welles -// Song: 'The One And Only', by Chesney Hawkes -// Song: 'Never Gonna Give You Up', by Rick Astley -``` - -示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem` -类型的实例，它可能是一个 `Movie`；同样，它也可能是一个 `Song`，或者仅仅是基类 -`MediaItem`。因为不确定，`as?`形式在试图下转时将返回一个可选值。`item as? Movie` 的返回值是 `Movie?` 或 “可选 `Movie`”类型。 - -当向下转型为 `Movie` 应用在两个 `Song` -实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 `Movie` 真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”，可以这样解读： - -“尝试将 `item` 转为 `Movie` 类型。若成功，设置一个新的临时常量 `movie` 来存储返回的可选 `Movie`” - -若向下转型成功，然后 `movie` 的属性将用于打印一个 `Movie` 实例的描述，包括它的导演的名字 `director` 。相近的原理被用来检测 `Song` 实例，当 `Song` 被找到时则打印它的描述（包含 `artist` 的名字）。 - -> 注意： -> 转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。 - - -## `Any`和`AnyObject`的类型转换 - -Swift为不确定类型提供了两种特殊类型别名： - -* `AnyObject`可以代表任何class类型的实例。 -* `Any`可以表示任何类型，包括方法类型（function types）。 - -> 注意： -> 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。 - - -### `AnyObject`类型 - -当在工作中使用 Cocoa APIs，我们一般会接收一个`[AnyObject]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以从 API 提供的信息中清晰地确定数组中对象的类型。 - -在这些情况下，你可以使用强制形式的类型转换(`as`)来下转在数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解析（optional unwrapping）。 - -下面的示例定义了一个 `[AnyObject]` 类型的数组并填入三个`Movie`类型的实例： - -```swift -let someObjects: [AnyObject] = [ - Movie(name: "2001: A Space Odyssey", director: "Stanley Kubrick"), - Movie(name: "Moon", director: "Duncan Jones"), - Movie(name: "Alien", director: "Ridley Scott") -] -``` - -因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as!`)下转并解包到不可选的`Movie`类型： - -```swift -for object in someObjects { - let movie = object as! Movie - print("Movie: '\(movie.name)', dir. \(movie.director)") -} -// Movie: '2001: A Space Odyssey', dir. Stanley Kubrick -// Movie: 'Moon', dir. Duncan Jones -// Movie: 'Alien', dir. Ridley Scott -``` - -为了变为一个更短的形式，下转`someObjects`数组为`[Movie]`类型来代替下转数组中每一项的方式。 - -```swift -for movie in someObjects as! [Movie] { - print("Movie: '\(movie.name)', dir. \(movie.director)") -} -// Movie: '2001: A Space Odyssey', dir. Stanley Kubrick -// Movie: 'Moon', dir. Duncan Jones -// Movie: 'Alien', dir. Ridley Scott -``` - -### `Any`类型 - -这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括方法类型和非 `class` 类型。它创建了一个可以存储`Any`类型的数组 `things`。 - -```swift -var things = [Any]() - -things.append(0) -things.append(0.0) -things.append(42) -things.append(3.14159) -things.append("hello") -things.append((3.0, 5.0)) -things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman")) -things.append({ (name: String) -> String in "Hello, \(name)" }) -``` - -`things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，电影“Ghostbusters”，和一个获取 `String` 值并返回另一个 `String` 值的闭包表达式。 - -你可以在 `switch` 表达式的cases中使用 `is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject` 的常量或变量的类型。下面的示例迭代 `things` 数组中的每一项的并用`switch`语句查找每一项的类型。这几种 `switch` 语句的情形绑定它们匹配的值到一个规定类型的常量，让它们的值可以被打印： - -```swift -for thing in things { - switch thing { - case 0 as Int: - print("zero as an Int") - case 0 as Double: - print("zero as a Double") - case let someInt as Int: - print("an integer value of \(someInt)") - case let someDouble as Double where someDouble > 0: - print("a positive double value of \(someDouble)") - case is Double: - print("some other double value that I don't want to print") - case let someString as String: - print("a string value of \"\(someString)\"") - case let (x, y) as (Double, Double): - print("an (x, y) point at \(x), \(y)") - case let movie as Movie: - print("a movie called '\(movie.name)', dir. \(movie.director)") - case let stringConverter as String -> String: - print(stringConverter("Michael")) - default: - print("something else") - } -} - -// zero as an Int -// zero as a Double -// an integer value of 42 -// a positive double value of 3.14159 -// a string value of "hello" -// an (x, y) point at 3.0, 5.0 -// a movie called 'Ghostbusters', dir. Ivan Reitman -// Hello, Michael -``` - - -> 注意： -> 在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 `switch` case 语句的内容中这种检查总是安全的。 diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md index 47770030..1ed93023 100644 --- a/source/chapter2/21_Extensions.md +++ b/source/chapter2/21_Extensions.md @@ -6,7 +6,13 @@ > 校对：[Hawstein](https://github.com/Hawstein) > 2.0 -> 翻译+校对：[shanksyang](https://github.com/shanksyang) +> 翻译+校对：[shanks](http://codebuild.me) + +> 2.1 +> 校对：[shanks](http://codebuild.me) +> +> 2.2 +> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-16 本页包含内容： @@ -17,33 +23,34 @@ - [下标](#subscripts) - [嵌套类型](#nested_types) -*扩展*就是向一个已有的类、结构体、枚举类型或者协议类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与 Objective-C 不同的是，Swift 的扩展没有名字。） +*扩展* 就是为一个已有的类、结构体、枚举类型或者协议类型添加新功能。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即 *逆向建模* ）。扩展和 Objective-C 中的分类类似。（与 Objective-C 不同的是，Swift 的扩展没有名字。） Swift 中的扩展可以： -- 添加计算型属性和计算型静态属性 +- 添加计算型属性和计算型类型属性 - 定义实例方法和类型方法 - 提供新的构造器 - 定义下标 - 定义和使用新的嵌套类型 - 使一个已有类型符合某个协议 -在 Swift 中，你甚至可以对一个协议(Protocol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./22_Protocols.html#protocol_extensions)获取更多的细节。 +在 Swift 中，你甚至可以对协议进行扩展，提供协议要求的实现，或者添加额外的功能，从而可以让符合协议的类型拥有这些功能。你可以从[协议扩展](./22_Protocols.html#protocol_extensions)获取更多的细节。 + +> 注意 +扩展可以为一个类型添加新的功能，但是不能重写已有的功能。 ->注意： -扩展可以对一个类型添加新的功能，但是不能重写已有的功能。 - ## 扩展语法（Extension Syntax） -声明一个扩展使用关键字`extension`： +使用关键字 `extension` 来声明扩展： ```swift extension SomeType { - // 加到SomeType的新功能写到这里 + // 为 SomeType 添加的新功能写到这里 } ``` -一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，协议的名字应该完全按照类或结构体的名字的方式进行书写： + +可以通过扩展来扩展一个已有类型，使其采纳一个或多个协议。在这种情况下，无论是类还是结构体，协议名字的书写方式完全一样： ```swift extension SomeType: SomeProtocol, AnotherProctocol { @@ -51,15 +58,15 @@ extension SomeType: SomeProtocol, AnotherProctocol { } ``` -按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](./22_Protocols.html#adding_protocol_conformance_with_an_extension) +通过这种方式添加协议一致性的详细描述请参阅[利用扩展添加协议一致性](./22_Protocols.html#adding_protocol_conformance_with_an_extension)。 ->注意： -如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。 +> 注意 +如果你通过扩展为一个已有类型添加新功能，那么新功能对该类型的所有已有实例都是可用的，即使它们是在这个扩展定义之前创建的。 ## 计算型属性（Computed Properties） -扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持： +扩展可以为已有类型添加计算型实例属性和计算型类型属性。下面的例子为 Swift 的内建 `Double` 类型添加了五个计算型实例属性，从而提供与距离单位协作的基本支持： ```swift extension Double { @@ -71,42 +78,41 @@ extension Double { } let oneInch = 25.4.mm print("One inch is \(oneInch) meters") -// 打印输出："One inch is 0.0254 meters" +// 打印 “One inch is 0.0254 meters” let threeFeet = 3.ft print("Three feet is \(threeFeet) meters") -// 打印输出："Three feet is 0.914399970739201 meters" +// 打印 “Three feet is 0.914399970739201 meters” ``` -这些计算属性表达的含义是把一个`Double`型的值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。 +这些计算型属性表达的含义是把一个 `Double` 值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性的名字仍可紧接一个浮点型字面值，从而通过点语法来使用，并以此实现距离转换。 -在上述例子中，一个`Double`型的值`1.0`被用来表示“1米”。这就是为什么`m`计算型属性返回`self`——表达式`1.m`被认为是计算`1.0`的`Double`值。 +在上述例子中，`Double` 值 `1.0` 用来表示“1米”。这就是为什么计算型属性 `m` 返回 `self`，即表达式 `1.m` 被认为是计算 `Double` 值 `1.0`。 -其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以`km`计算型属性要把值乘以`1_000.00`来转化成单位米下的数值。类似地，1米有3.28024英尺，所以`ft`计算型属性要把对应的`Double`值除以`3.28024`来实现英尺到米的单位换算。 +其它单位则需要一些单位换算。一千米等于 1,000 米，所以计算型属性 `km` 要把值乘以 `1_000.00` 来实现千米到米的单位换算。类似地，一米有 3.28024 英尺，所以计算型属性 `ft` 要把对应的 `Double` 值除以 `3.28024` 来实现英尺到米的单位换算。 -这些属性是只读的计算型属性，所有从简考虑它们不用`get`关键字表示。它们的返回值是`Double`型，而且可以用于所有接受`Double`的数学计算中： +这些属性是只读的计算型属性，为了更简洁，省略了 `get` 关键字。它们的返回值是 `Double`，而且可以用于所有接受 `Double` 值的数学计算中： ```swift let aMarathon = 42.km + 195.m print("A marathon is \(aMarathon) meters long") -// 打印输出："A marathon is 42195.0 meters long" +// 打印 “A marathon is 42195.0 meters long” ``` ->注意： -扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。 +> 注意 +扩展可以添加新的计算型属性，但是不可以添加存储型属性，也不可以为已有属性添加属性观察器。 ## 构造器（Initializers） -扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。 +扩展可以为已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为其构造器参数，或者提供该类型的原始实现中未提供的额外初始化选项。 -扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供。 +扩展能为类添加新的便利构造器，但是它们不能为类添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供。 -> 注意： -如果你使用扩展向一个值类型添加一个构造器，在该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers）时，你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。 -> -正如在[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。 +> 注意 +如果你使用扩展为一个值类型添加构造器，同时该值类型的原始实现中未定义任何定制的构造器且所有存储属性提供了默认值，那么我们就可以在扩展中的构造器里调用默认构造器和逐一成员构造器。 +正如在[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你把定制的构造器写在值类型的原始实现中，上述规则将不再适用。 -下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值： +下面的例子定义了一个用于描述几何矩形的结构体 `Rect`。这个例子同时定义了两个辅助结构体 `Size` 和 `Point`，它们都把 `0.0` 作为所有属性的默认值： ```swift struct Size { @@ -120,7 +126,7 @@ struct Rect { var size = Size() } ``` -因为结构体`Rect`提供了其所有属性的默认值，所以正如[默认构造器](./14_Initialization.html#default_initializers)中描述的，它可以自动接受一个默认构造器和一个逐一成员构造器。这些构造器可以用于构造新的`Rect`实例： +因为结构体 `Rect` 未提供定制的构造器，因此它会获得一个逐一成员构造器。又因为它为所有存储型属性提供了默认值，它又会获得一个默认构造器。详情请参阅[默认构造器](./14_Initialization.html#default_initializers)。这些构造器可以用于构造新的 `Rect` 实例： ```swift let defaultRect = Rect() @@ -128,7 +134,7 @@ let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0), size: Size(width: 5.0, height: 5.0)) ``` -你可以提供一个额外的使用特殊中心点和大小的构造器来扩展`Rect`结构体： +你可以提供一个额外的接受指定中心点和大小的构造器来扩展 `Rect` 结构体： ```swift extension Rect { @@ -139,50 +145,50 @@ extension Rect { } } ``` -这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的逐一成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中： + +这个新的构造器首先根据提供的 `center` 和 `size` 的值计算一个合适的原点。然后调用该结构体的逐一成员构造器 `init(origin:size:)`，该构造器将新的原点和大小的值保存到了相应的属性中： ```swift let centerRect = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0)) -// centerRect的原点是 (2.5, 2.5)，大小是 (3.0, 3.0) +// centerRect 的原点是 (2.5, 2.5)，大小是 (3.0, 3.0) ``` - ->注意： -如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。 +> 注意 +如果你使用扩展提供了一个新的构造器，你依旧有责任确保构造过程能够让实例完全初始化。 ## 方法（Methods） -扩展可以向已有类型添加新的实例方法和类型方法。下面的例子向`Int`类型添加一个名为`repetitions`的新实例方法： +扩展可以为已有类型添加新的实例方法和类型方法。下面的例子为 `Int` 类型添加了一个名为 `repetitions` 的实例方法： ```swift extension Int { - func repetitions(task: () -> ()) { - for i in 0..+> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) **(** [*参数名称*](#argument-names) **)** +> + +> *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)可选
+ +> *参数名* → [*标识符*](02_Lexical_Structure.md#identifier) **:** -### 后缀self表达式（Postfix Self Expression） + +### 后缀 self 表达式 -后缀表达式由 某个表达式 + '.self' 组成. 形式如下： +后缀 `self` 表达式由某个表达式或类型名紧跟 `.self` 组成，其形式如下： -> `expression`.self -> `type`.self +> `表达式`.self +> `类型`.self -形式1 表示会返回 expression 的值。例如： x.self 返回 x +第一种形式返回表达式的值。例如：`x.self` 返回 `x`。 -形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。 +第二种形式返回相应的类型。我们可以用它来获取某个实例的类型作为一个值来使用。例如，`SomeClass.self` 会返回 `SomeClass` 类型本身，你可以将其传递给相应函数或者方法作为参数。 -> 后置Self 表达式语法 -> *后置self表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self** +> 后缀 self 表达式语法 + +> *后缀 self 表达式* → [*后缀表达式*](#postfix-expression) **.** **self** -### dynamic表达式（Dynamic Type Expression） + +### dynamicType 表达式 -（因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression） +dynamicType 表达式由类似[函数调用表达式(Function Call Expression)](#function-call-expression)的特殊语法表达式组成,形式如下: -dynamicType 表达式由 某个表达式 + '.dynamicType' 组成。 +> type(of:`表达式`) -> `expression`.dynamicType - -上面的形式中， expression 不能是某type的名字（当然了，如果我都知道它的名字了还需要动态来获取它吗）。动态类型表达式会返回"运行时"某个instance的type, 具体请看下面的列子： +上述形式中的表达式不能是类型名。type(of:) 表达式会返回某个实例在运行时的类型，具体请看下面的例子： ```swift class SomeBaseClass { class func printClassName() { - println("SomeBaseClass") + print("SomeBaseClass") } } class SomeSubClass: SomeBaseClass { override class func printClassName() { - println("SomeSubClass") + print("SomeSubClass") } } let someInstance: SomeBaseClass = SomeSubClass() - -// someInstance is of type SomeBaseClass at compile time, but -// someInstance is of type SomeSubClass at runtime -someInstance.dynamicType.printClassName() -// prints "SomeSubClass" +// someInstance 在编译时的静态类型为 SomeBaseClass， +// 在运行时的动态类型为 SomeSubClass +type(of: someInstance).printClassName() +// 打印 “SomeSubClass” ``` > 动态类型表达式语法 -> *动态类型表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType** + +> *动态类型表达式* → type(of:表达式) **.** **dynamicType** -### 下标脚本表达式（Subscript Expression） + +### 下标表达式 -下标脚本表达式提供了通过下标脚本访问getter/setter 的方法。它的形式是： +可通过下标表达式访问相应的下标，形式如下： -> `expression`[`index expressions`] +> `表达式`[`索引表达式`] -可以通过下标脚本表达式通过getter获取某个值，或者通过setter赋予某个值. +要获取下标表达式的值，可将索引表达式作为下标表达式的参数来调用下标 getter。下标 setter 的调用方式与之一样。 -关于subscript的声明，请参见： Protocol Subscript Declaration. +关于下标的声明，请参阅 [协议下标声明](05_Declarations.md#protocol_subscript_declaration)。 -> 附属脚本表达式语法 -> *附属脚本表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式列表*](../chapter3/04_Expressions.html#expression_list) **]** +> 下标表达式语法 + +> *下标表达式* → [*后缀表达式*](#postfix-expression) **[** [*表达式列表*](#expression-list) **]** -### 强制取值表达式（Forced-Value Expression） + +### 强制取值表达式 -强制取值表达式用来获取某个目标表达式的值（该目标表达式的值必须不是nil ）。它的形式如下： +当你确定可选值不是 `nil` 时，可以使用强制取值表达式来强制解包，形式如下： -> `expression`! +> `表达式`! + +如果该表达式的值不是 `nil`，则返回解包后的值。否则，抛出运行时错误。 + +返回的值可以被修改，无论是修改值本身，还是修改值的成员。例如： -如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误（runtime error）。 -返回的值可能会被需改，可以是被赋值了，也可以是出现异常造成的。比如： ```swift var x: Int? = 0 x!++ -// x is now 1 +// x 现在是 1 var someDictionary = ["a": [1, 2, 3], "b": [10, 20]] someDictionary["a"]![0] = 100 -// someDictionary is now [b: [10, 20], a: [100, 2, 3]] +// someDictionary 现在是 [b: [10, 20], a: [100, 2, 3]] ``` -> 强制取值(Forced Value)语法 -> *强制取值(Forced Value)表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!** +> 强制取值语法 + +> *强制取值表达式* → [*后缀表达式*](#postfix-expression) **!** -### 可选链表达式（Optional-Chaining Expression） + +### 可选链表达式 -可选链表达式由目标表达式 + '?' 组成，形式如下： +可选链表达式提供了一种使用可选值的便捷方法，形式如下： -> `expression`? +> `表达式`? -后缀'?' 返回目标表达式的值，把它做为可选的参数传递给后续的表达式 +后缀 `?` 运算符会根据表达式生成可选链表达式而不会改变表达式的值。 -如果某个后缀表达式包含了可选链表达式，那么它的执行过程就比较特殊： 首先先判断该可选链表达式的值，如果是 nil, 整个后缀表达式都返回 nil, 如果该可选链的值不是nil, 则正常返回该后缀表达式的值（依次执行它的各个子表达式）。在这两种情况下，该后缀表达式仍然是一个optional type（In either case, the value of the postfix expression is still of an optional type） +如果某个后缀表达式包含可选链表达式，那么它的执行过程会比较特殊。如果该可选链表达式的值是 `nil`，整个后缀表达式会直接返回 `nil`。如果该可选链表达式的值不是 `nil`，则返回可选链表达式解包后的值，并将该值用于后缀表达式中剩余的表达式。在这两种情况下，整个后缀表达式的值都会是可选类型。 -如果某个"后缀表达式"的"子表达式"中包含了"可选链表达式"，那么只有最外层的表达式返回的才是一个optional type. 例如，在下面的例子中， 如果c 不是nil, 那么 c?.property.performAction（） 这句代码在执行时，就会先获得c 的property方法，然后调用 performAction（）方法。 然后对于 "c?.property.performAction（）" 这个整体，它的返回值是一个optional type. +如果某个后缀表达式中包含了可选链表达式，那么只有最外层的表达式会返回一个可选类型。例如，在下面的例子中，如果 `c` 不是 `nil`，那么它的值会被解包，然后通过 `.property` 访问它的属性，接着进一步通过 `.performAction()` 调用相应方法。整个 `c?.property.performAction()` 表达式返回一个可选类型的值，而不是多重可选类型。 ```swift var c: SomeClass? var result: Bool? = c?.property.performAction() ``` -如果不使用可选链表达式，那么 上面例子的代码跟下面例子等价： +上面的例子跟下面的不使用可选链表达式的例子等价： ```swift +var result: Bool? = nil if let unwrappedC = c { result = unwrappedC.property.performAction() } ``` -后缀'?' 返回目标表达式的值可能会被修改，可能是由于出现了赋值，也有可能是出现异常而产生的修改。如果可选链表达式为`nil`，则表达式右边的复制操作不会被执行。比如： + +可选链表达式解包后的值可以被修改，无论是修改值本身，还是修改值的成员。如果可选链表达式的值为 `nil`，则表达式右侧的赋值操作不会被执行。例如： + ```swift func someFunctionWithSideEffects() -> Int { - return 42 // No actual side effects. + // 译者注：为了能看出此函数是否被执行，加上了一句打印 + print("someFunctionWithSideEffects") + return 42 } var someDictionary = ["a": [1, 2, 3], "b": [10, 20]] - + someDictionary["not here"]?[0] = someFunctionWithSideEffects() -// someFunctionWithSideEffects is not evaluated -// someDictionary is still [b: [10, 20], a: [1, 2, 3]] - +// someFunctionWithSideEffects 不会被执行 +// someDictionary 依然是 ["b": [10, 20], "a": [1, 2, 3]] + someDictionary["a"]?[0] = someFunctionWithSideEffects() -// someFunctionWithSideEffects is evaluated and returns 42 -// someDictionary is now [b: [10, 20], a: [42, 2, 3]] +// someFunctionWithSideEffects 被执行并返回 42 +// someDictionary 现在是 ["b": [10, 20], "a": [42, 2, 3]] ``` - > 可选链表达式语法 -> *可选链表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **?** + +> *可选链表达式* → [*后缀表达式*](#postfix-expression) **?** diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md index 5ad0a93a..3e8f602a 100755 --- a/source/chapter3/05_Declarations.md +++ b/source/chapter3/05_Declarations.md @@ -1,1087 +1,1247 @@ - -# 声明（Declarations） ------------------ - -> 1.0 -> 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon) -> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) - -> 2.0 -> 翻译+校对：[Lenhoon](https://github.com/Lenhoon), + +# 声明（Declarations） +----------------- + +> 1.0 +> 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon) +> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) + +> 2.0 +> 翻译+校对：[Lenhoon](https://github.com/Lenhoon), > [BridgeQ](https://github.com/WXGBridgeQ) > 2.1 -> 翻译+校队：[shanks](http://codebuild.me) - -本页包含内容： - -- [顶级代码](#top-level_code) -- [代码块](#code_blocks) -- [引入声明](#import_declaration) -- [常量声明](#constant_declaration) -- [变量声明](#variable_declaration) -- [类型的别名声明](#type_alias_declaration) -- [函数声明](#function_declaration) -- [枚举声明](#enumeration_declaration) -- [结构体声明](#structure_declaration) -- [类声明](#class_declaration) -- [协议声明](#protocol_declaration) -- [构造器声明](#initializer_declaration) -- [析构声明](#deinitializer_declaration) -- [扩展声明](#extension_declaration) -- [下标脚本声明](#subscript_declaration) -- [运算符声明](#operator_declaration) -- [声明修饰符](#declaration_modifiers) - -一条*声明(declaration)*可以在程序里引入新的名字或者构造。举例来说，可以使用声明来引入函数和方法，变量和常量，或者来定义新的命名好的枚举，结构，类和协议类型。可以使用一条声明来延长一个已经存在的命名好的类型的行为。或者在程序里引入在其它地方声明的符号。 - -在Swift中，大多数声明在某种意义上讲也是执行或同时声明它们的初始化定义。这意味着，因为协议和它们的成员不匹配，大多数协议成员需要单独的声明。为了方便起见，也因为这些区别在Swift里不是很重要，*声明语句(declaration)*同时包含了声明和定义。 - -> 声明语法 -> *声明* → [*导入声明*](#grammer_of_an_import_declaration) -> *声明* → [*常量声明*](#grammer_of_a_constant_declaration) -> *声明* → [*变量声明*](#grammer_of_a_variable_declaration) -> *声明* → [*类型别名声明*](#grammer_of_a_type_alias_declaration) -> *声明* → [*函数声明*](#grammer_of_a_function_declaration) -> *声明* → [*枚举声明*](#grammer_of_a_enumeration_declaration) -> *声明* → [*结构体声明*](#grammer_of_a_structure_declaration) -> *声明* → [*类声明*](#grammer_of_a_class_declaration) -> *声明* → [*协议声明*](#grammer_of_a_protocol_declaration) -> *声明* → [*构造器声明*](#grammer_of_an_initializer_declaration) -> *声明* → [*析构器声明*](#grammer_of_a_deinitializer_declaration) -> *声明* → [*扩展声明*](#grammer_of_an_extension_declaration) -> *声明* → [*附属脚本声明*](#grammer_of_a_subscript_declaration) -> *声明* → [*运算符声明*](#grammer_of_an_operator_declaration) -> *声明(Declarations)列表* → [*声明*](#declaration) [*声明(Declarations)列表*](#declarations) _可选_ - - -##顶级代码 - -Swift 的源文件中的顶级代码由零个或多个语句，声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他命名的声明语句可以被同一模块部分里的每一个源文件中的代码访问。可以通过使用一个访问级别修饰符来标记这个声明，从而重写这个默认行为，[访问控制级别(Access Control Levels)](#access_control_levels)中有所介绍。 - -> 顶级(Top Level) 声明语法 -> *顶级声明* → [*多条语句(Statements)*](../chapter3/04_Expressions.html) _可选_ - - -##代码块 - -*代码块*用来将一些声明和控制结构的语句组织在一起。它有如下的形式： - -> { -> `statements` -> } - -代码块中的*语句(statements)*包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。 - -> 代码块语法 -> *代码块* → **{** [*多条语句(Statements)*](../chapter3/04_Expressions.html) _可选_ **}** - - -##引入声明 - -可以使用在其他文件中声明的内容*引入声明(import declaration)*。引入语句的基本形式是引入整个代码模块；它由`import`关键字开始，后面 -紧跟一个模块名： - -> import `module` - -可以提供更多的细节来限制引入的符号，如声明一个特殊的子模块或者在一个模块或子模块中做特殊的声明。（待改进） -当使用了这些细节后，在当前的程序汇总只有引入的符号是可用的（并不是声明的整个模块）。 - -> import `import kind` `module`.`symbol name` -> import `module`.`submodule` - - -> 导入(Import)声明语法 -> *导入声明* → [*特性(attributes)列表*](../chapter3/06_Attributes.html) _可选_ **import** [*导入类型*](../chapter3/05_Declarations.html#import_kind) _可选_ [*导入路径*](../chapter3/05_Declarations.html#import_path) -> *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func** -> *导入路径* → [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) | [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) **.** [*导入路径*](../chapter3/05_Declarations.html#import_path) -> *导入路径标识符* → [*标识符*](../chapter3/02_Lexical_Structure.html) | [*运算符*](../chapter3/02_Lexical_Structure.html) - - -##常量声明 - -*常量声明(constant declaration)*可以在程序里命名一个常量。常量以关键词`let`来声明，遵循如下的格式: - -> let `constant name`: `type` = `expression` - -当常量的值被给定后，常量就将*常量名称(constant name)*和*表达式(expression)*初始值不变的结合在了一起，而且不能更改。 - -这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。 - -当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，它被认为是一个*常量属性(constant property)*。常量并不是可计算的属性，因此不包含getters和setters。 - -如果*常量名(constant name)*是一个元组形式，元组中的每一项初始化*表达式(expression)*中都要有对应的值。 - -```swift -let (firstNumber, secondNumber) = (10, 42) -``` - -在上例中，`firstNumber`是一个值为`10`的常量，`secnodeName`是一个值为`42`的常量。所有常量都可以独立的使用： - -```swift -println("The first number is /(firstNumber).") -// prints "The first number is 10." -println("The second number is /(secondNumber).") -// prints "The second number is 42." -``` - -当*常量名称(constant name)*的类型可以被推断出时，类型标注*（:type）*在常量声明中是一个可选项，它可以用来描述在[类型推断(Type Inference)](./03_Types.html#type_inference)中找到的类型。 - -声明一个常量类型属性要使用关键字`static`声明修饰符。类型属性在[类型属性(Type Properties)](../chapter2/10_Properties.html#type_properties)中有介绍。 - -如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看[常量和变量](../chapter2/01_The_Basics.html#constants_and_variables)和[存储属性(Stored Properties)](../chapter2/10_Properties.html#stored_properties)等节。 - - -> 常数声明语法 -> *常量声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list) -> *模式构造器列表* → [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) | [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list) -> *模式构造器* → [*模式*](../chapter3/07_Patterns.html#pattern) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ -> *构造器* → **=** [*表达式*](../chapter3/04_Expressions.html#expression) - - -##变量声明 - -*变量声明(variable declaration)*可以在程序里声明一个变量，它以关键字`var`来声明。 - -变量声明有几种不同的形式声明不同种类的命名值和计算型值，如存储和计算变量和属性，存储变量和属性监视，和静态变量属性。所使用的声明形式取决于变量所声明的范围和打算声明的变量类型。 - ->注意： ->也可以在协议声明的上下文声明属性，详情参见[协议属性声明(Protocal Property Declaration)](./05_Declarations.html#protocol_declaration)。 - -可以重载一个子类中的属性，通过使用'override'声明修饰符来标记子类的属性声明，[重写(Overriding)](../chapter2/13_Inheritance.html#overriding)中有所介绍。 - - -###存储型变量和存储型属性 - -下面的形式声明了一个存储型变量或存储型变量属性 - -> var `variable name`: `type` = `expression` - -可以在全局，函数内，或者在类和结构体的声明(context)中使用这种形式来声明一个变量。当变量以这种形式 -在全局或者一个函数内被声明时，它代表一个*存储型变量(stored variable)*。当它在类或者结构体中被声明时，它代表一个*存储型变量属性(stored variable property)*。 - -初始化的*表达式（expression）*不可以在协议的声明中出现，在其他情况下，初始化*表达式(expression)*是可选的（optional），如果没有初始化*表达式(expression)*，那么变量定义时必须显示包括类型标注（*:type*) - -对于常量的定义，如果*变量名字（variable name）*是一个元组（tuple），元组中每一项的名称都要和初始化*表达式(expression)*中的相应值一致。 - -正如名字一样，存储型变量的值或存储型变量属性存储在内存中。 - - -###计算型变量和计算型属性 - -如下形式声明一个一个存储型变量或存储型属性： - -> var `variable name`: `type` { -> get { -> `statements` -> } -> set(`setter name`) { -> `statements` -> } -> } - -可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。当变量以这种形式在全局或者一个函数内被声明时，它代表一个*计算型变量(computed variable)*。当它在类，结构体，枚举，扩展声明的上下文中中被声明时，它代表一个*计算型变量(computed variable)*。 - -getter用来读取变量值，setter用来写入变量值。setter子句是可选择的，只有getter是必需的，可以将这些语句 -都省略，只是简单的直接返回请求值，正如在[只读计算属性(Read-Only Computed Properties)](../chapter2/10_Properties.html#computed_properties)中描述的那样。但是如果提供了一个setter语句，也必需提供一个getter语句。 - -setter的名字和圆括号内的语句是可选的。如果写了一个setter名，它就会作为setter的参数被使用。如果不写setter名，setter的初始名为'newValue'，正如在[便捷 setter 声明(Shorthand Setter Declaration)](../chapter2/10_Properties.html#shorthand_setter_declaration)中提到的那样。 - -不像存储型变量和存储型属性那样，计算型属性和计算型变量的值不存储在内存中。 - -获得更多信息，查看更多关于计算型属性的例子，请查看[计算属性(Computed Properties)](../chapter2/10_Properties.html#computed_properties)一节。 - - -###存储型变量监视器和属性监视器 - -可以用`willset`和`didset`监视器来声明一个存储型变量或属性。一个包含监视器的存储型变量或属性按如下的形式声明： - -> var `variable name`: `type` = expression { -> willSet(setter name) { -> `statements` -> } -> didSet(`setter name`) { -> `statements` -> } -> } - -可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。当变量以这种形式在全局或者一个函数内被声明时，监视器代表一个*存储型变量监视器(stored variable observers)*；当它在类，结构体，枚举，扩展声明的上下文中被声明时，监视器代表*属性监视器(property observers)*。 - -可以为适合的监视器添加任何存储型属性。也可以通过重写子类属性的方式为适合的监视器添加任何继承的属性 -(无论是存储型还是计算型的)，参见[重写属性监视器(Overriding Property Observers)](../chapter2/13_Inheritance.html#overriding)。 - -初始化*表达式(expression)*在一个类中或者结构体的声明中是可选的，但是在其他地方是必需的。当类型可以从初始化*表达式(expression)*中推断而来，那么这个*类型(type)*标注是可选的。 - -当变量或属性的值被改变时，`willset`和`didset`监视器提供了一个监视方法（适当的回应）。 -监视器不会在变量或属性第一次初始化时运行，它们只有在值被外部初始化语句改变时才会被运行。 - -`willset`监视器只有在变量或属性值被改变之前运行。新的值作为一个常量经过过`willset`监视器，因此不可以在`willset`语句中改变它。`didset`监视器在变量或属性值被改变后立即运行。和`willset`监视器相反，为了以防止仍然需要获得旧的数据，旧变量值或者属性会经过`didset`监视器。这意味着，如果在变量或属性自身的`didiset`监视器语句中设置了一个值，设置的新值会取代刚刚在`willset`监视器中经过的那个值。 - -在`willset`和`didset`语句中，*setter名(setter name)*和圆括号的语句是可选的。如果写了一个setter名，它就会作为`willset`和`didset`的参数被使用。如果不写setter名， -`willset`监视器初始名为`newvalue`，`didset`监视器初始名为`oldvalue`。 - -当提供一个`willset`语句时，`didset`语句是可选的。同样的，在提供了一个`didset`语句时，`willset`语句是可选的。 - -获得更多信息，查看如何使用属性监视器的例子，请查看[属性监视器(Property Observers)](../chapter2/10_Properties.html#property_observers)一节。 -声明修饰符 - - -###类型变量属性 - -声明一个类型变量属性，要用`static`声明修饰符标记该声明。类可能需要`class`声明修饰符去标记类的类型计算型属性从而允许子类可以重写超类的实现。类型属性在[类型属性(Type Properties)](../chapter2/10_Properties.html#type_properties)章节讨论。 - ->>注意 ->> ->在一个类声明中，关键字`static`与用声明修饰符`class`和`final`去标记一个声明的效果相同 - - -> 变量声明语法 -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*代码块*](../chapter3/05_Declarations.html#code_block) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*getter-setter块*](../chapter3/05_Declarations.html#getter_setter_block) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*构造器*](../chapter3/05_Declarations.html#initializer) [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block) -> *变量声明头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var** -> *变量名称* → [*标识符*](LexicalStructure.html#identifier) -> *getter-setter块* → **{** [*getter子句*](../chapter3/05_Declarations.html#getter_clause) [*setter子句*](../chapter3/05_Declarations.html#setter_clause) _可选_ **}** -> *getter-setter块* → **{** [*setter子句*](../chapter3/05_Declarations.html#setter_clause) [*getter子句*](../chapter3/05_Declarations.html#getter_clause) **}** -> *getter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block) -> *setter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) -> *setter名称* → **(** [*标识符*](LexicalStructure.html#identifier) **)** -> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) _可选_ **}** -> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) **}** -> *getter关键字(Keyword)子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get** -> *setter关键字(Keyword)子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set** -> *willSet-didSet代码块* → **{** [*willSet子句*](../chapter3/05_Declarations.html#willSet_clause) [*didSet子句*](../chapter3/05_Declarations.html#didSet_clause) _可选_ **}** -> *willSet-didSet代码块* → **{** [*didSet子句*](../chapter3/05_Declarations.html#didSet_clause) [*willSet子句*](../chapter3/05_Declarations.html#willSet_clause) **}** -> *willSet子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) -> *didSet子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) - - -##类型的别名声明 - -*类型别名声明(type alias declaration)*可以在程序里为一个已存在的类型声明一个别名。类型的别名声明语句使用关键字`typealias`声明，遵循如下的形式： - -> `typealias name` = `existing type` - -当声明一个类型的别名后，可以在程序的任何地方使用别*名(name)*来代替*已存在的类型(existing type)*。已存在的类型可以是已经被命名的类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。 - -查看更多[协议关联类型声明(Protocol Associated Type Declaration)](./05_Declarations.html#protocol_associated_type_declaration). - - -> 类型别名声明语法 -> *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) -> *类型别名头(Head)* → [*属性列表*](../chapter3/06_Attributes.html) _可选_ [*访问级别修饰符*](../chapter3/05_Declarations.html#declaration_modifiers) _可选_ **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name) -> *类型别名名称* → [*标识符*](LexicalStructure.html#identifier) -> *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type) - - -##函数声明 - -使用*函数声明(function declaration)*在程序里引入新的函数或者方法。一个函数被声明在类的上下文，结构体，枚举，或者协议中，从而作为*方法(method)*被引用。 -函数声明使用关键字`func`，遵循如下的形式： - -> func `function name`(`parameters`) -> `return type` { -> `statements` -> } - -如果函数返回`Void`类型，返回类型可以被忽略，如下所示： - -> func `function name`(`parameters`) { -> `statements` -> } - -每个参数的类型都要标明，它们不能被推断出来。虽然函数的参数默认是常量，也可以使用参数名前使用`let`来强调这一行为。在这些参数前面添加`var`使它们成为变量，作用域内任何对变量的改变只在函数体内有效，或者用`inout`使的这些改变可以在调用域内生效。更多关于in-out参数的讨论，参见[In-Out参数(In-Out Parameters)](#) - -函数可以使用元组类型作为返回值来返回多个变量。 - -函数定义可以出现在另一个函数声明内。这种函数被称作nested函数。更多关于*嵌套函数(Nested Functions)*的讨论，参见[嵌套函数(Nested Functions)](../chapter2/06_Functions.html#Nested_Functions)。 - - -###参数名 - -函数的参数是一个以逗号分隔的列表 。函数调用是的变量顺序必须和函数声明时的参数顺序一致。 -最简单的参数列表有着如下的形式： - -> `parameter name`: `parameter type` - -一个参数有一个内部名称，这个内部名称可以在函数体内被使用。同样也可以作为外部名称，当调用方法时这个外部名称被作为实参的标签来使用。默认情况下，第一个参数的外部名称省略不写，第二个和其之后的参数使用它们的内部名称作为它们的外部名称。 - -```swift -func f(x: Int, y: Int) -> Int{ return x + y} -f(1, y: 2) // y是有标记的，x没有 -``` - -可以按如下的一种形式，重写参数名被使用的默认过程： - -> `external parameter name` `local parameter name`: `parameter type` -> _ `local parameter name`: `parameter type` - -在内部参数名前的名称赋予这个参数一个外部名称，这个名称可以和内部参数的名称不同。外部参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有外部名 。 - -内部参数名前的强调字符下划线(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。 - -```swift -func f(x x: Int, withY y: Int, _z: Int) -> Int{ - return x + y + z } -f(x: 1, withY: 2, 3) // x和y是有标记的，z没有 -``` +> 翻译：[mmoaay](https://github.com/mmoaay), [shanks](http://codebuild.me) +> 校对：[shanks](http://codebuild.me) - - - -###特殊类型的参数 - -参数可以被忽略，参数的值的数量可变，并且还可以提供默认值，使用形式如下： - -> _ : `parameter type`. -> `parameter name`: `parameter type`... -> `parameter name`: `parameter type` = `default argument value` - -以下划线(_)命名的参数是明确忽略的，在函数体内不能被访问。 - -一个以基础类型名的参数，如果紧跟着三个点(`...`)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数`Int...`被看做是`[Int]`。查看可变参数的使用例子，详见[可变参数(Variadic Parameters)](../chapter2/06_Functions.html#Function_Parameters_and_Return_Values)一节。 - -在参数的类型后面有一个以等号(`=`)连接的表达式，这样的参数被看做有着给定表达式的初始值。当函数被调用时，给定的表达式被求值。如果参数在函数调用时被省略了，就会使用初始值。 - -```swift -func f(x: Int = 42) -> Int { return x} -f() // 有效的，使用默认值 -f(7) // 有效的，提供了值，没有提供值的名称 -f(x: 7) //无效的，值和值的名称都提供了 -``` - -###特殊方法 - -枚举或结构体的方法来修改`self`属性，必须以`mutating`声明修饰符标记。 - -子类方法重写超类中的方法必须以`override`声明修饰符标记。重写一个方法不使用`override`修饰符，或者使用了`override`修饰符却并没有重写超类方法都会产生一个编译时错误。 - -枚举或者结构体中的类型方法而不是实例方法，要以`static`声明修饰符标记，而对于类中的类型方法，要使用`class`声明修饰符标记。 - - -###柯里化函数(Curried Functions) - -可以重写一个带有多个参数的函数使它等同于一个只有一个参数并且返回一个函数的函数，这个返回函数携带下一个参数并且返回另外一个函数，一直持续到再没有剩余的参数，此时要返回的函数返回原来的多参函数要返回的原始值。这个重写的函数被称为*柯里化函数(curried function)*。例如，可以为`addTwoInts(a:b:)`重写一个等价的`addTwoIntsCurried(a:)(b:)`的函数。 - -```swift -func addTwoInts(a: Int, b: Int) -> Int { - return a + b -} - -func addTwoIntsCurried(a: Int) -> (Int -> Int) { - func addTheOtherInt(b: Int) -> Int { - return a + b - } - return addTheOtherInt -} -``` - -这个`addTwoInts(a:b:)`函数带有两个整型值并且返回他们的和。`addTwoIntsCurried(a:)(b:)`函数带有一个整型值，并且返回另外一个带有第二个整型值的函数并使其和第一个整型值相加（这个内嵌的函数从包含它的函数中捕获第一个整型参数的值）。 - -在Swift中，可以通过以下语法非常简明的写一个柯里化函数： - -> func `function name`(`parameter`)(`parameter`) -> `return type` { -> `statements` -> } - -举例来说，下面的两个声明是等价的: - -```swift -func addTwoIntsCurried(a a: Int)(b: Int) -> Int { - return a + b -} - -func addTwoIntsCurried(a a: Int) -> (Int -> Int) - { - func addTheOtherInt(b: Int) -> Int { - return a + b - } - return addTheOtherInt -} -``` - -为了像使用非柯里化函数一样的方式使用`addTwoIntsCurried(a:)(b:)`函数，必须用第一个整型参数调用`addTwoIntsCurried(a:)(b:)`,紧接着用第二个整型参数调用其返回的函数： - -```swift -addTwoInts(a: 4, b: 5) -//返回值为9 -addTwoIntsCurried(a: 4)(b: 5) -//返回值为9 -``` - -虽然在每次调用一个非柯里化函数时必须提供所有的参数，可以使用函数的柯里化形式把参数分配在多次函数调用中，称之为“*偏函数应用(partial function application)*”，例如可以为`addTwoIntsCurried(a:)(b:)`函数使用参数`1`然后把返回的结果赋值给常量`plusOne`： - -```swift -let plusOne = addTwoIntsCurried(a: 1) -// plusOne 是类型为 Int -> Int的函数 -``` - -因为`plusOne`是函数`addTwoIntsCurried(a:)(b:)`绑定参数为`1`时结果，所以可以调用`plusOne`并且传入一个整型使其和`1`相加。 - -```swift -plusOne(10) -// 返回值为11 -``` - - -###抛出异常函数和抛出异常方法(Throwing Functions and Methods) - -可以抛出一个错误的函数或方法必需使用`throws`关键字标记。这些函数和方法被称为*抛出异常函数(throwing functions)*和*抛出异常方法(throwing methods)*。它们有着下面的形式: - -> func `function name`(`parameters`) throws -> -> `return type` { -> `statements` -> } - -调用一个抛出异常函数或抛出异常方法必需用一个`try`或者`try!`表达式来封装（也就是说，在一个范围内使用一个`try`或者`try!`运算符）。 - -`throws`关键字是函数的类型的一部分，不抛出异常的函数是抛出异常函数的一个子类型。所以，可以在使用抛出异常函数的地方使用不抛出异常函数。对于柯里化函数，`throws`关键字仅运用于最内层的函数。 - -不能重写一个仅基于是否能抛出错误的函数。也就是说，可以重载一个基于函数*参数(parameter)*能否抛出一个错误的函数。 - -一个抛出异常的方法不能重写一个不能抛出异常的方法，而且一个异常抛出方法不能满足一个协议对于不抛出异常方法的需求。也就是说，一个不抛出异常的方法可以重写一个抛出异常的方法，而且一个不抛出异常的方法可以满足一个协议对于抛出异常的需求。 - - -###重抛出异常函数和重抛出异常方法(Rethrowing Functions and Methods) - -一个函数或方法可以使用`rethrows`关键字来声明，从而表明仅当这个函数或方法的一个函数参数抛出错误时这个函数或方法才抛出错误。这些函数和方法被称为*重抛出异常函数(rethrowing functions)*和*重抛出异常方法(rethrowing methods)*。重抛出异常函数或方法必需有至少一个抛出异常函数参数。 - -``` - func functionWithCallback(callback: () throws -> Int) rethrows { - try callback() - } -``` -一个抛出异常函数方法不能重写一个重抛出异常函数方法，一个抛出异常方法不能满足一个协议对于重抛出异常方法的需求。也就是说，一个重抛出异常方法可以重写一个抛出异常方法，而且一个重抛出异常方法可以满足一个协议对于抛出异常方法的需求。 - - -> 函数声明语法 -> *函数声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature) [*函数体*](../chapter3/05_Declarations.html#function_body) -> *函数头* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **func** -> *函数名* → [*标识符*](LexicalStructure.html#identifier) | [*运算符*](LexicalStructure.html#operator) -> *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ -> *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ -> *函数结果* → **->** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) -> *函数体* → [*代码块*](../chapter3/05_Declarations.html#code_block) -> *parameter-clauses* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) _可选_ -> *参数子句* → **(** **)** | **(** [*参数列表*](../chapter3/05_Declarations.html#parameter_list) **...** _可选_ **)** -> *参数列表* → [*参数*](../chapter3/05_Declarations.html#parameter) | [*参数*](../chapter3/05_Declarations.html#parameter) **,** [*参数列表*](../chapter3/05_Declarations.html#parameter_list) -> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](../chapter3/05_Declarations.html#parameter_name)_可选_ [*内部参数名*](../chapter3/05_Declarations.html#local_parameter_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*默认参数子句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_ -> *参数* → **inout** _可选_ **var** [*外部参数名*](../chapter3/05_Declarations.html#parameter_name) [*内部参数名*](../chapter3/05_Declarations.html#local_parameter_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*默认参数子句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_ -> *参数* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) -> *参数名* → [*标识符*](LexicalStructure.html#identifier) | **_** -> *内部参数名* → [*标识符*](LexicalStructure.html#identifier) | **_** -> *默认参数子句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression) - - -##枚举声明 - -在程序里使用*枚举声明(enumeration)*来引入一个枚举类型。 - -枚举声明有两种基本的形式，使用关键字`enum`来声明。枚举声明体使用从零开始的变量——叫做*枚举用例(enumeration cases)*，和任意数量的声明，包括计算型属性，实例方法，类型方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能包含析构器或者协议声明。 - -枚举类型可以采用任何数量的协议，但是这些协议不能从类，结构体和其他的枚举继承。 - -不像类或者结构体。枚举类型并不提供隐式的初始构造器，所有构造器必须显式的声明。构造器可以委托枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例指定给`self`才全部完成。 - -和结构体类似但是和类不同，枚举是值类型：枚举实例在赋予变量或常量时，或者被函数调用时被复制。 -更多关于值类型的信息，参见结构体和枚举都是[值类型(Structures and Enumerations Are Value Types)](../chapter2/09_Classes_and_Structures.html#structures_and_enumerations_are_value_types)一节。 - -可以扩展枚举类型，正如在[扩展声明(Extension Declaration)](./05_Declarations.html#extension_declaration)中讨论的一样。 - - -###任意用例类型的枚举 - -如下的形式声明了一个包含任意类型枚举用例的枚举变量 - -> enum `enumeration name`: `adopted protocols`{ -> case `enumeration case 1` -> case `enumeration case 2`(`associated value types`) -> } - -这种形式的枚举声明在其他语言中有时被叫做*可识别联合(discrinminated)*。 - -这种形式中，每一个用例块由关键字`case`开始，后面紧接着一个或多个以逗号分隔的枚举用例。每一个用例名必须是独一无二的。每一个用例也可以指定它所存储的指定类型的值，这些类型在*关联值类型(associated values types)*的元组里被指定，立即书写在用例名后。 - -枚举用例也可以指定函数作为其存储的值，从而通过特定的关联值创建一个枚举实例。和真正的函数一样，你可以获取一个枚举用例的引用，然后在后续代码中调用它。 - -```swift -enum Number { - case Integer(Int) - case Real(Double) -} -let f = Number.Integer -// f is a function of type (Int) -> Number -// f 是一个传入 Int 返回 Number 类型的函数 - -// Apply f to create an array of Number instances with integer values -// 利用函数 f 把一个整数数组转成 Number 数组 -let evenInts: [Number] = [0, 2, 4, 6].map(f) -``` - -获得更多关于关联值类型的信息和例子，请查看[关联值(Associated Values)](../chapter2/08_Enumerations.html#associated_values)一节。 +> 2.2 +> 翻译：[星夜暮晨](https://github.com/SemperIdem) - - -### 间接的枚举 - -枚举有一个递归结构，就是说，枚举有着枚举类型自身实例的关联值的用例。然而，枚举类型的实例有值语义，意味着它们在内存中有着固定的位置。为了支持递归，编译器必需插入一个间接层。 - -为间接使用特殊的枚举用例，使用`indirect`声明修饰符标记。 - -> enum Tree
`introduced=version number`
这里的`version number`由一个正的十进制整数或浮点数构成。 +*版本号*由一个或多个正整数构成，由句点分隔的。 -- `deprecated`参数表示：该声明第一次被建议弃用时所在平台的版本。格式如下： -
`deprecated=version number`
这里的`version number`由一个正的十进制整数或浮点数构成。 +- `deprecated`参数表示指定平台从哪一版本开始弃用该声明。格式如下： -- `obsoleted`参数表示：该声明第一次被弃用时所在平台的版本。当一个声明被弃用时，它就从此平台中被移除，不能再被使用。格式如下： -
`obsoleted=version number`
这里的`version number`由一个正的十进制整数或浮点数构成。 +`deprecated`=`版本号` -- `message`参数用来提供文本信息。当使用建议弃用或者被弃用的声明时，编译器会抛出错误或警告信息。格式如下： -
`message=message`
这里的`message`由一个字符串文字构成。 +可选的*版本号*由一个或多个正整数构成，由句点分隔的。省略版本号表示该声明目前已弃用，当弃用出现时无需给出任何有关信息。如果你省略了版本号，冒号（:）也可省略。 -- `renamed`参数用来提供文本信息，用以表示被重命名的声明的新名字。当使用这个重命名的声明遇到错误时，编译器会显示出该新名字。格式如下： -
`renamed=new name`
这里的`new name`由一个字符串文字构成。 +- `obsoleted` 参数表示指定平台从哪一版本开始废弃该声明。当一个声明被废弃后，它就从平台中移除，不能再被使用。格式如下： -你可以将`renamed`参数和`unavailable`参数以及类型别名声明组合使用，以向用户表示：在你的代码中，一个声明已经被重命名。当一个声明的名字在一个框架或者库的不同发布版本间发生变化时，这会相当有用。 +`obsoleted`=`版本号` + +*版本号*由一个或多个正整数构成，由句点分隔的。 + +- `message` 参数用来提供文本信息。当使用被弃用或者被废弃的声明时，编译器会抛出警告或错误信息。格式如下： + +`message`=`信息内容` + +信息内容由一个字符串构成。 + +- `renamed` 参数用来提供文本信息，用以表示被重命名的声明的新名字。当使用声明的旧名字时，编译器会报错提示新名字。格式如下： + +`renamed`=`新名字` + +新名字由一个字符串构成。 + +你可以将`renamed` 参数和 `unavailable` 参数以及类型别名声明组合使用，以此向用户表示某个声明已经被重命名。当某个声明的名字在一个框架或者库的不同发布版本间发生变化时，这会相当有用。 ```swift -// First release +// 首发版本 protocol MyProtocol { - // protocol definition -} -``` - -```swift -// Subsequent release renames MyProtocol -protocol MyRenamedProtocol { - // protocol definition +// 这里是协议定义 } - -@available(*, unavailable, renamed="MyRenamedProtocol") +``` + +```swift +// 后续版本重命名了 MyProtocol +protocol MyRenamedProtocol { +// 这里是协议定义 +} +@available(*, unavailable, renamed:"MyRenamedProtocol") typealias MyProtocol = MyRenamedProtocol ``` -你可以在一个单独的声明上使用多个`available`特性，以详细说明该声明在不同平台上的有效性。编译器只有在当前的目标平台和`available`特性中指定的平台匹配时，才会使用`available`特性。 +你可以在某个声明上使用多个 `available` 特性，以指定该声明在不同平台上的可用性。编译器只有在当前目标平台和 `available` 特性中指定的平台匹配时，才会使用 `available` 特性。 -如果`available`特性除了平台名称参数外，只指定了一个`introduced `参数，那么可以使用以下简写语法代替： +如果 `available` 特性除了平台名称参数外，只指定了一个 `introduced` 参数，那么可以使用以下简写语法代替： -@available(`platform name` `version number`, *) +@available（平台名称 版本号，*） -`available`特性的简写语法可以简明地表达出多个平台的可用性。尽管这两种形式在功能上是相同的，但请尽可能地使用简明语法形式。 +`available` 特性的简写语法可以简明地表达出声明在多个平台上的可用性。尽管这两种形式在功能上是相同的，但请尽可能地使用简写语法形式。 ```swift -@available(iOS 8.0, OSX 10.10, *) +@available(iOS 10.0, macOS 10.12, *) class MyClass { - // class definition +// 这里是类定义 } ``` +`discardableResult` + +该特性用于的函数或方法声明,以抑制编译器中 函数或方法的返回值被调而没有使用其结果的警告。 + +`GKInspectable` + +应用此属性，暴露一个自定义GameplayKit组件属性给SpriteKit编辑器UI。 + `objc` -该特性用于修饰任何可以在Objective-C中表示的声明。比如，非嵌套类、协议、非泛型枚举（仅限整型值类型）、类和协议的属性和方法（包括`getter`和`setter`）、构造器、析构器以及下标。`objc`特性告诉编译器这个声明可以在Objective-C代码中使用。 +该特性用于修饰任何可以在 Objective-C 中表示的声明。比如，非嵌套类、协议、非泛型枚举（仅限原始值为整型的枚举）、类和协议中的属性和方法（包括存取方法）、构造器、析构器以及下标运算符。`objc` 特性告诉编译器这个声明可以在 Objective-C 代码中使用。 -标有`objc`特性的类必须继承自Objective-C中定义的类。如果你将`objc`特性应用于一个类或协议，它也会隐式地应用于那个类的成员或协议。对于标记了`objc`特性的类，编译器会隐式地为它的子类添加`objc`特性。标记了`objc`特性的协议不能继承没有标记`objc`的协议。 +标有 `objc` 特性的类必须继承自 Objective-C 中定义的类。如果你将 `objc` 特性应用于一个类或协议，它也会隐式地应用于类或协议中兼容 Objective-C 的成员。对于标记了 `objc` 特性的类，编译器会隐式地为它的子类添加 `objc` 特性。标记了 `objc` 特性的协议不能继承没有标记 `objc` 的协议。 -如果你将`objc`特性应用于枚举，每一个枚举的`case`都会以枚举名称和`case`名称组合的方式暴露在Objective-C代码中。例如：一个名为`Venus`的`case`在`Planet`枚举中，这个`case`暴露在Objective-C代码中时叫做`PlanetVenus`。 +如果你将 `objc` 特性应用于枚举，每一个枚举用例都会以枚举名称和用例名称组合的方式暴露在 Objective-C 代码中。例如，在 `Planet` 枚举中有一个名为 `Venus` 的用例，该用例暴露在 Objective-C 代码中时叫做 `PlanetVenus`。 -`objc`特性有一个可选的参数，由标记符组成。当你想把`objc`所修饰的实体以一个不同的名字暴露给Objective-C时，你就可以使用这个特性参数。你可以使用这个参数来命名类，协议，方法，getters，setters，以及构造器。下面的例子把`ExampleClass`中`enabled`属性的getter暴露给Objective-C，名字是`isEnabled`，而不是它原来的属性名。 +`objc` 特性有一个可选的参数，由标识符构成。当你想把 objc 所修饰的实体以一个不同的名字暴露给 Objective-C 时，你就可以使用这个特性参数。你可以使用这个参数来命名类、枚举类型、枚举用例、协议、方法、存取方法以及构造器。下面的例子把 `ExampleClass` 中的 `enabled` 属性的取值方法暴露给 Objective-C，名字是 `isEnabled`，而不是它原来的属性名。 ```swift @objc class ExampleClass: NSObject { - var enabled: Bool { - @objc(isEnabled) get { - // Return the appropriate value - } - } +var enabled: Bool { +@objc(isEnabled) get { +// 返回适当的值 } +} } ``` - -`noescape` - -在函数或者方法声明上使用该特性，它表示参数将不会被存储用作后续的计算，其用来确保不会超出函数调用的生命周期。对于其属性或方法来说，使用`noescape`声明属性的函数类型不需要显式的使用`self.`。 - `nonobjc` -该特性用于方法、属性、下标、或构造器的声明，这些声明本是可以在Objective-C代码中表示的。使用`nonobjc`特性告诉编译器这个声明不能在Objective-C代码中使用。 +该特性用于方法、属性、下标、或构造器的声明，这些声明本可以在 Objective-C 代码中使用，而使用 `nonobjc` 特性则告诉编译器这个声明不能在 Objective-C 代码中使用。 -可以使用`nonobjc`特性解决标有`objc`的类中桥接方法的循环问题，该特性还允许标有`objc`的类的构造器和方法进行重载(overload)。 +可以使用 `nonobjc` 特性解决标有 `objc` 的类中桥接方法的循环问题，该特性还允许对标有 `objc` 的类中的构造器和方法进行重载。 -标有`nonobjc`特性的方法不能重写(override)一个标有`objc`特性的方法。然而，标有`objc`特性的方法可以重写标有`nonobjc`特性的方法。同样，标有`nonobjc`特性的方法不能满足一个需要标有`@objc`特性的方法的协议。 - -`noreturn` - -该特性用于修饰函数或方法声明，表明该函数或方法的对应类型，`T`，是`@noreturn T`。你可以用这个特性修饰函数或方法的类型，这样一来，函数或方法就不会返回到它的调用者中去。 - -对于一个没有用`noreturn`特性标记的函数或方法，你可以将它重写为用该特性标记的。相反，对于一个已经用`noreturn`特性标记的函数或方法，你则不可以将它重写为没使用该特性标记的。当你在一个comforming类型中实现一个协议方法时，该规则同样适用。 +标有 `nonobjc` 特性的方法不能重写标有 `objc` 特性的方法。然而，标有 `objc` 特性的方法可以重写标有 `nonobjc` 特性的方法。同样，标有 `nonobjc` 特性的方法不能满足标有 `@objc` 特性的协议中的方法要求。 `NSApplicationMain` -在类上使用该特性表示该类是应用程序委托类，使用该特性与调用`NSApplicationMain(_:_:)`函数并且把该类的名字作为委托类的名字传递给函数的效果相同。 +在类上使用该特性表示该类是应用程序委托类，使用该特性与调用 `NSApplicationMain`(\_:_:) 函数并且把该类的名字作为委托类的名字传递给函数的效果相同。 -如果你不想使用这个特性，可以提供一个`main.swift`文件，并且提供一个`main()`函数去调用`NSApplicationMain(_:_:)`函数。比如，如果你的应用程序使用一个派生于`NSApplication`的自定义子类作为主要类，你可以调用`NSApplicationMain`函数而不是使用该特性。 +如果你不想使用这个特性，可以提供一个 main.swift 文件，并在代码**顶层**调用`NSApplicationMain`(\_:_:) 函数,如下所示: +```swift +import AppKit +NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv) +``` `NSCopying` -该特性用于修饰一个类的存储型变量属性。该特性将使属性的setter与属性值的一个副本合成，这个值由`copyWithZone(_:)`方法返回，而不是属性本身的值。该属性的类型必需遵循`NSCopying`协议。 +该特性用于修饰一个类的存储型变量属性。该特性将使属性的设值方法使用传入值的副本进行赋值，这个值由传入值的 `copyWithZone`(\_:) 方法返回。该属性的类型必需符合 `NSCopying` 协议。 -`NSCopying`特性的原理与Objective-C中的`copy`特性相似。 +`NSCopying` 特性的行为与 Objective-C 中的 `copy` 特性相似。 `NSManaged` -该特性用于修饰`NSManagedObject`子类中的实例方法或存储型变量属性，表明属性的存储和实现由Core Data在运行时基于相关实体描述动态提供。对于标记了`NSManaged`特性的属性，Core Data也会在运行时提供存储。 +该特性用于修饰 `NSManagedObject` 子类中的实例方法或存储型变量属性，表明它们的实现由 `Core Data` 在运行时基于相关实体描述动态提供。对于标记了 `NSManaged` 特性的属性，`Core Data` 也会在运行时为其提供存储。应用这个特性也意味着`objc`特性。 `testable` -该特性用于`import`声明可以测试的编译模块，它能访问任何标有`internal`权限标识符的实体，这和将它声明为`public`权限标识符有同样的效果。 +在导入允许测试的编译模块时，该特性用于修饰 `import` 声明，这样就能访问被导入模块中的任何标有 `internal` 访问级别修饰符的实体，犹如它们被标记了 `public` 访问级别修饰符。测试也可以访问使用`internal`或者`public`访问级别修饰符标记的类和类成员,就像它们是`open`访问修饰符声明的。 `UIApplicationMain` -在类上使用该特性表示该类是应用程序委托类，使用该特性与调用`UIApplicationMain(_:_:)`函数并且把该类的名字作为委托类的名字传递给函数的效果相同。 +在类上使用该特性表示该类是应用程序委托类，使用该特性与调用 `UIApplicationMain`函数并且把该类的名字作为委托类的名字传递给函数的效果相同。 -如果你不想使用这个特性，可以提供一个`main.swift`文件，并且提供一个`main`函数去调用`UIApplicationMain(_:_:)`函数。比如，如果你的应用程序使用一个派生于`UIApplication`的自定义子类作为主要类，你可以调用`UIApplicationMain`函数而不是使用该特性。 +如果你不想使用这个特性，可以提供一个 main.swift 文件，并在代码顶层调用 `UIApplicationMain`(\_:\_:\_:) 函数。比如，如果你的应用程序使用一个继承于 UIApplication 的自定义子类作为主要类，你可以调用 `UIApplicationMain`(\_:\_:\_:) 函数而不是使用该特性。 -`warn_unused_result` + +###Interface Builder 使用的声明特性 +`Interface Builder` 特性是 `Interface Builder` 用来与 Xcode 同步的声明特性。`Swift` 提供了以下的 `Interface Builder` 特性：`IBAction`，`IBOutlet`，`IBDesignable`，以及`IBInspectable` 。这些特性与 Objective-C 中对应的特性在概念上是相同的。 -该特性应用于方法或函数声明，当方法或函数被调用，但其结果未被使用时，该特性会让编译器会产生警告。 +`IBOutlet` 和 `IBInspectable` 用于修饰一个类的属性声明，`IBAction` 特性用于修饰一个类的方法声明，`IBDesignable` 用于修饰类的声明。 -你可以使用这个特性提供一个警告信息，这个警告信息是关于不正确地使用未变异的方法，这个方法也有一个对应的变异方法。 - -`warn_unused_result`特性会有选择地采用下面两个参数之一。 - -- `message`参数用来提供警告信息。在当方法或函数被调用，但其结果未被使用时，会显示警告信息。格式如下： -
`message=message`
这里的`message`由一个字符串文字构成。 - -- `mutable_variant`参数用于提供变异方法的名称，如果未变异方法以一个可变的值被调用而且其结果并未被使用时，应该使用此变异方法。格式如下（方法名有字符串构成）：
`mutable_variant=method name`
-比如，Swift标准库同时提供了变异方法`sortInPlace()`和未变异方法`sort()`集合，它们的元素生成器符合`Comparable`协议。如果你调用了`sort()`方法，而没有使用它的结果，其实很有可能，你是打算使用变异方法`sortInPlace()`。
-
-### Interface Builder使用的声明特性
-
-Interface Builder特性是Interface Builder用来与Xcode同步的声明特性。Swift提供了以下的Interface Builder特性：`IBAction`，`IBDesignable`，`IBInspectable`，以及`IBOutlet`。这些特性与Objective-C中对应的特性在概念上是相同的。
-
-`IBOutlet`和`IBInspectable`用于修饰一个类的属性声明；`IBAction`特性用于修饰一个类的方法声明；`IBDesignable`用于修饰类的声明。
+`IBAction` 和 `IBOutlet` 特性都意味着`objc`特性。
-## 类型特性
+##类型特性
+类型特性只能用于修饰类型。
-类型特性只能用于修饰类型。然而，你也可以用`noreturn`特性去修饰函数或方法声明。
+`autoclosure`
+
+这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 autoclosure 特性的例子，请参阅 [自动闭包](http://wiki.jikexueyuan.com/project/swift/chapter2/07_Closures.html/) 和 [函数类型](http://wiki.jikexueyuan.com/project/swift/chapter3/03_Types.html)。
`convention`
+该特性用于修饰函数类型，它指出了函数调用的约定。
-该特性用于函数的类型，它指出函数调用的约定。
+convention 特性总是与下面的参数之一一起出现。
-`convention`特性总是与下面的参数之一一起出现。
+- `swift` 参数用于表示一个 Swift 函数引用。这是 Swift 中函数值的标准调用约定。
-- `swift`参数用于表明一个Swift函数引用。这是Swift中标准的函数值调用约定。
+- `block` 参数用于表示一个 Objective-C 兼容的块引用。函数值会作为一个块对象的引用，块是一种 `id` 兼容的 Objective-C 对象，其中嵌入了调用函数。调用函数使用 C 的调用约定。
-- `block`参数用于表明一个Objective-C兼容的块引用。函数值表示为一个块对象的引用，这是一个`id-`兼容的Objective-C对象，对象中嵌入了调用函数。调用函数使用C的调用约定。
+- `c` 参数用于表示一个 C 函数引用。函数值没有上下文，不具备捕获功能，同样使用 C 的调用约定。
-- `c`参数用于表明一个C函数引用。函数值没有上下文，这个函数也使用C的调用约定。
+使用 C 函数调用约定的函数也可用作使用 Objective-C 块调用约定的函数，同时使用 Objective-C 块调用约定的函数也可用作使用 Swift 函数调用约定的函数。然而，只有非泛型的全局函数、局部函数以及未捕获任何局部变量的闭包，才可以被用作使用 C 函数调用约定的函数。
-使用C函数调用约定的函数也可用作使用Objective-C块调用约定的函数，同时使用Objective-C块调用约定的函数也可用作使用Swift函数调用约定的函数。然而，只有非泛型的全局函数和本地函数或者不使用任何本地变量的闭包可以被用作使用C函数调用约定的函数。
+`escaping`
+在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行，这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 声明特性的函数类型中访问属性和方法时不需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](http://wiki.jikexueyuan.com/project/swift/chapter2/07_Closures.html)。
-`noreturn`
+>特性语法
-该特性用于修饰函数或方法的类型，表明该函数或方法不会返回到它的调用者中去。你也可以用它标记函数或方法的声明，表示函数或方法的相应类型，`T`，是`@noreturn T`。
+> *特性 *→ @ 特性名 特性参数子句可选
-> 特性语法
-> *特性* → **@** [*特性名*](#attribute_name) [*特性参数子句*](#attribute_argument_clause) (可选)
-> *特性名* → [*标识符*](02_Lexical_Structure.html#identifiers)
-> *特性参数子句* → **(** [*平衡令牌列表*](#balanced_tokens) (可选) **)**
-> *特性(Attributes)列表* → [*特色*](#attribute) [*特性(Attributes)列表*](#attributes) (可选)
-> *平衡令牌列表* → [*平衡令牌*](#balanced_token) [*平衡令牌列表*](#balanced_tokens) (可选)
-> *平衡令牌* → **(** [*平衡令牌列表*](#balanced_tokens) (可选) **)**
-> *平衡令牌* → **[** [*平衡令牌列表*](#balanced_tokens) (可选) **]**
-> *平衡令牌* → **{** [*平衡令牌列表*](#balanced_tokens) (可选) **}**
-> *平衡令牌* → **任意标识符, 关键字, 字面量或运算符**
-> *平衡令牌* → **任意标点除了(, ), [, ], {, 或 }**
+> *特性名* → 标识符
+> *特性参数子句* → ( 均衡令牌列表可选 )
+> *特性列表* → 特性 特性列表可选
+> *均衡令牌列表* → 均衡令牌 均衡令牌列表可选
+> *均衡令牌* → ( 均衡令牌列表可选 )
+
+> *均衡令牌* → [ 均衡令牌列表可选 ]
+
+> *均衡令牌* → { 均衡令牌列表可选}
+
+> *均衡令牌* → 任意标识符，关键字，字面量或运算符
+
+> *均衡令牌* → 任意标点除了 (，)，[，]，{，或 }
diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index d9aa54c2..058c338e 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -1,13 +1,15 @@
# 模式（Patterns）
------------------
-
+-----------------
+
> 1.0
> 翻译：[honghaoz](https://github.com/honghaoz)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
-> 翻译+校对：[ray16897188](https://github.com/ray16897188),
-> [BridgeQ](https://github.com/WXGBridgeQ)
+> 翻译+校对：[ray16897188](https://github.com/ray16897188),
+
+> 2.1
+> 翻译：[BridgeQ](https://github.com/WXGBridgeQ)
本页内容包括：
@@ -17,97 +19,101 @@
- [元组模式（Tuple Pattern）](#tuple_pattern)
- [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern)
- [可选模式（Optional Pattern）](#optional_pattern)
-- [类型转换模式（Type-Casting Pattern）](#type-casting_pattern)
+- [类型转换模式（Type-Casting Pattern）](#type-casting_patterns)
- [表达式模式（Expression Pattern）](#expression_pattern)
-模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从复合值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
+模式代表单个值或者复合值的结构。例如，元组 `(1, 2)` 的结构是由逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以利用模式来匹配各种各样的值。比如，`(x, y)` 可以匹配元组 `(1, 2)`，以及任何含两个元素的元组。除了利用模式匹配一个值以外，你可以从复合值中提取出部分或全部值，然后分别把各个部分的值和一个常量或变量绑定起来。
-swift语言中模式有2个基本的分类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。
+Swift 中的模式分为两类：一种能成功匹配任何类型的值，另一种在运行时匹配某个特定值时可能会失败。
-第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard patterns），标识符模式（identifier patterns），以及任何包含了它们的值绑定模式（value binding patterns）或者元祖模式（tuple patterns）。你可以为这类模式指定一个类型标注（type annotation）从而限制它们只能匹配某种特定类型的值。
+第一类模式用于解构简单变量、常量和可选绑定中的值。此类模式包括通配符模式、标识符模式，以及包含前两种模式的值绑定模式和元组模式。你可以为这类模式指定一个类型标注，从而限制它们只能匹配某种特定类型的值。
-第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式（enumeration case patterns），可选模式（optional patterns），表达式模式（expression patterns）和类型转换模式（type-casting patterns）。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
+第二类模式用于全模式匹配，这种情况下你试图匹配的值在运行时可能不存在。此类模式包括枚举用例模式、可选模式、表达式模式和类型转换模式。你在 `switch` 语句的 `case` 标签中，`do` 语句的 `catch` 子句中，或者在 `if`、`while`、`guard` 和 `for-in` 语句的 `case` 条件句中使用这类模式。
-> 模式(Patterns) 语法
-> *模式* → [*通配符模式*](../chapter3/07_Patterns.html#wildcard_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_
-> *模式* → [*标识符模式*](../chapter3/07_Patterns.html#identifier_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotati(Value Binding)on) _可选_
-> *模式* → [*值绑定模式*](../chapter3/07_Patterns.html#value_binding_pattern)
-> *模式* → [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_
-> *模式* → [*枚举用例模式*](../chapter3/07_Patterns.html#enum_case_pattern)
-> *模式* → [*可选模式*](../chapter3/07_Patterns.html#optional_pattern)
-> *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern)
-> *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern)
+> 模式语法
+
+> *模式* → [*通配符模式*](#wildcard_pattern) [*类型标注*](03_Types.md#type-annotation)可选
+> *模式* → [*标识符模式*](#identifier_pattern) [*类型标注*](03_Types.md#type-annotation)可选
+> *模式* → [*值绑定模式*](#value-binding-pattern)
+> *模式* → [*元组模式*](#tuple-pattern) [*类型标注*](03_Types.md#type-annotation)可选
+> *模式* → [*枚举用例模式*](#enum-case-pattern)
+> *模式* → [*可选模式*](#optional-pattern)
+> *模式* → [*类型转换模式*](#type-casting-pattern)
+> *模式* → [*表达式模式*](#expression-pattern)
## 通配符模式（Wildcard Pattern）
-通配符模式由一个下划线（_）构成，且匹配并忽略任何值。当你不在乎被匹配的值时可以使用该模式。例如，下面这段代码在闭区间`1...3`中循环，每次循环时忽略该区间内的当前值：
+通配符模式由一个下划线（`_`）构成，用于匹配并忽略任何值。当你想忽略被匹配的值时可以使用该模式。例如，下面这段代码在闭区间 `1...3` 中迭代，每次迭代都忽略该区间的当前值：
```swift
for _ in 1...3 {
- // Do something three times.
+ // ...
}
```
> 通配符模式语法
+
> *通配符模式* → **_**
## 标识符模式（Identifier Pattern）
-标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量声明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。
+标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量声明中，`someValue` 是一个标识符模式，匹配了 `Int` 类型的 `42`：
```swift
let someValue = 42
```
-当匹配成功时，`42`被绑定（赋值）给常量`someValue`。
+当匹配成功时，`42` 被绑定（赋值）给常量 `someValue`。
-如果一个变量或常量声明的左边的模式是一个标识符模式，那么这个标识符模式是一个隐式的值绑定模式（value-binding pattern）。
+如果一个变量或常量声明的左边是一个标识符模式，那么这个标识符模式是值绑定模式的子模式。
> 标识符模式语法
-> *标识符模式* → [*标识符*](LexicalStructure.html#identifier)
+
+> *标识符模式* → [*标识符*](02_Lexical_Structure.md#identifier)
## 值绑定模式（Value-Binding Pattern）
-值绑定模式把匹配到的值绑定给一个变量或常量名。把绑定匹配到的值绑定给常量时，用关键字`let`,绑定给变量时，用关键字`var`。
+值绑定模式把匹配到的值绑定给一个变量或常量。把匹配到的值绑定给常量时，用关键字 `let`，绑定给变量时，用关键字 `var`。
-在值绑定模式中的标识符模式会把新命名的变量或常量与匹配值做绑定。例如，你可以拆开一个元组的元素，然后把每个元素绑定到其相应一个的标识符模式中。
+在值绑定模式中的标识符模式会把新命名的变量或常量与匹配到的值做绑定。例如，你可以拆开一个元组，然后把每个元素绑定到相应的标识符模式中。
```swift
let point = (3, 2)
switch point {
- // Bind x and y to the elements of point.
+// 将 point 中的元素绑定到 x 和 y
case let (x, y):
print("The point is at (\(x), \(y)).")
}
-// prints "The point is at (3, 2).”
+// 打印 “The point is at (3, 2).”
```
-在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。正是由于这么做，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配到的值是一样的。
+在上面这个例子中，`let` 会分配到元组模式 `(x, y)` 中的各个标识符模式。因此，`switch` 语句中 `case let (x, y):` 和 `case (let x, let y):` 的匹配效果是一样的。
-> 值绑定(Value Binding)模式语法
-> *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../chapter3/07_Patterns.html#pattern)
+> 值绑定模式语法
+
+> *值绑定模式* → **var** [*模式*](#pattern) | **let** [*模式*](#pattern)
-## 元组模式（Tuple Pattern）
+## 元组模式
-元组模式是逗号分隔的，有零个或多个模式的列表，并被一对圆括号括起来。元组模式匹配相应元组类型的值。
+元组模式是由逗号分隔的，具有零个或多个模式的列表，并由一对圆括号括起来。元组模式匹配相应元组类型的值。
-你可以使用类型标注去限制一个元组模式能匹配哪些种元组类型。例如，在常量声明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式可以和任何有两个元素，且第一个元素类型是`String`的元组类型匹配。
+你可以使用类型标注去限制一个元组模式能匹配哪种元组类型。例如，在常量声明 `let (x, y): (Int, Int) = (1, 2)` 中的元组模式 `(x, y): (Int, Int)` 只匹配两个元素都是 `Int` 类型的元组。
-当元组模式被用在`for-in`语句或者变量或常量声明时，它仅可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。比如下面这段代码就不正确，因为`(x, 0)`中的元素`0`是一个表达式模式：
+当元组模式被用于 `for-in` 语句或者变量和常量声明时，它仅可以包含通配符模式、标识符模式、可选模式或者其他包含这些模式的元组模式。比如下面这段代码就不正确，因为 `(x, 0)` 中的元素 `0` 是一个表达式模式：
```swift
let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
-// This code isn't valid.
+// 下面的代码是错误的
for (x, 0) in points {
/* ... */
}
```
-对于只包含一个元素的元组，括号是不起作用的。模式只匹配这个单个元素的类型。举例来说，下面3条语句是等效的：
+只包含一个元素的元组模式的圆括号没有效果，模式只匹配这个单个元素的类型。举例来说，下面的语句是等效的：
```swift
let a = 2 // a: Int = 2
@@ -116,80 +122,89 @@ let (a): Int = 2 // a: Int = 2
```
> 元组模式语法
-> *元组模式* → **(** [*元组模式元素列表*](../chapter3/07_Patterns.html#tuple_pattern_element_list) _可选_ **)**
-> *元组模式元素列表* → [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](../chapter3/07_Patterns.html#tuple_pattern_element_list)
-> *元组模式元素* → [*模式*](../chapter3/07_Patterns.html#pattern)
+
+> *元组模式* → **(** [*元组模式元素列表*](#tuple-pattern-element-list)可选 **)**
+
+> *元组模式元素列表* → [*元组模式元素*](#tuple-pattern-element) | [*元组模式元素*](#tuple-pattern-element) **,** [*元组模式元素列表*](#tuple-pattern-element-list)
+
+> *元组模式元素* → [*模式*](#pattern)
## 枚举用例模式（Enumeration Case Pattern）
-一个枚举用例模式匹配现有的某个枚举类型的某个用例（case）。枚举用例模式出现在`switch`语句中的case标签中，以及`if`，`while`，`guard`和`for-in`语句的case条件中。
+枚举用例模式匹配现有的某个枚举类型的某个用例。枚举用例模式出现在 `switch` 语句中的 `case` 标签中，以及 `if`、`while`、`guard` 和 `for-in` 语句的 `case` 条件中。
-如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`.
+如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../chapter2/08_Enumerations.md#associated_values)。
> 枚举用例模式语法
-> *enum-case-pattern* → [*类型标识*](../chapter3/03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) _可选_
+
+> *枚举用例模式* → [*类型标识*](03_Types.md#type-identifier)可选 **.** [*枚举用例名*](05_Declarations.md#enum-case-name) [*元组模式*](#tuple-pattern)可选
## 可选模式（Optional Pattern）
-可选模式与封装在一个`Optional(Wrapped)`或者一个`ExplicitlyUnwrappedOptional(Wrapped)`枚举中的`Some(Wrapped)`用例相匹配。可选模式由一个标识符模式和紧随其后的一个问号组成，在某些情况下表现为枚举用例模式。
+可选模式匹配包装在一个 `Optional(Wrapped)` 或者 `ExplicitlyUnwrappedOptional(Wrapped)` 枚举中的 `Some(Wrapped)` 用例中的值。可选模式由一个标识符模式和紧随其后的一个问号组成，可以像枚举用例模式一样使用。
-由于可选模式是`optional`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖（syntactic sugar），下面的2种写法是一样的：
+由于可选模式是 `Optional` 和 `ImplicitlyUnwrappedOptional` 枚举用例模式的语法糖，下面两种写法是等效的：
```swift
let someOptional: Int? = 42
-// Match using an enumeration case pattern
+// 使用枚举用例模式匹配
if case .Some(let x) = someOptional {
print(x)
}
-// Match using an optional pattern
+// 使用可选模式匹配
if case let x? = someOptional {
print(x)
}
```
-如果一个数组的元素是可选类型，可选模式为`for-in`语句提供了一种在该数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环体。
+
+可选模式为 `for-in` 语句提供了一种迭代数组的简便方式，只为数组中非 `nil` 的元素执行循环体。
```swift
let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
-// Match only non-nil values
+// 只匹配非 nil 的元素
for case let number? in arrayOfOptinalInts {
print("Found a \(number)")
}
-//Found a 2
-//Found a 3
-//Found a 5
-
+// Found a 2
+// Found a 3
+// Found a 5
```
+
> 可选模式语法
-> *可选模式* → [*标识符模式*](../chapter3/03_Types.html#type_identifier) ?
+
+> *可选模式* → [*标识符模式*](03_Types.md#type-identifier) **?**
## 类型转换模式（Type-Casting Patterns）
-有两种类型转换模式，`is`模式和`as`模式。这两种模式只出现在`switch`语句中的case标签中。`is`模式和`as`模式有以下形式：
+有两种类型转换模式，`is` 模式和 `as` 模式。`is` 模式只出现在 `switch` 语句中的 `case` 标签中。`is` 模式和 `as` 模式形式如下：
-> is `type`
-> `pattern` as `type`
+> is `类型`
+> `模式` as `类型`
-`is`模式仅当一个值的类型在运行时（runtime）和`is`模式右边的指定类型一致 - 或者是该类型的子类 - 的情况下，才会匹配这个值。`is`模式和`is`操作符有相似表现，它们都进行类型转换，却舍弃返回的类型。
+`is` 模式仅当一个值的类型在运行时和 `is` 模式右边的指定类型一致，或者是其子类的情况下，才会匹配这个值。`is` 模式和 `is` 运算符有相似表现，它们都进行类型转换，但是 `is` 模式没有返回类型。
-`as`模式仅当一个值的类型在运行时（runtime）和`as`模式右边的指定类型一致 - 或者是该类型的子类 - 的情况下，才会匹配这个值。如果匹配成功，被匹配的值的类型被转换成`as`模式左边指定的模式。
+`as` 模式仅当一个值的类型在运行时和 `as` 模式右边的指定类型一致，或者是其子类的情况下，才会匹配这个值。如果匹配成功，被匹配的值的类型被转换成 `as` 模式右边指定的类型。
-关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。
+关于使用 `switch` 语句配合 `is` 模式和 `as` 模式来匹配值的例子，请参阅 [Any 和 AnyObject 的类型转换](../chapter2/19_Type_Casting.md#type_casting_for_any_and_anyobject)。
> 类型转换模式语法
-> *type-casting-pattern* → [*is模式*](../chapter3/07_Patterns.html#is_pattern) | [*as模式*](../chapter3/07_Patterns.html#as_pattern)
-> *is模式* → **is** [*类型*](../chapter3/03_Types.html#type)
-> *as模式* → [*模式*](../chapter3/07_Patterns.html#pattern) **as** [*类型*](../chapter3/03_Types.html#type)
+
+> *类型转换模式* → [*is模式*](#is-pattern) | [*as模式*](#as-pattern)
+
+> *is模式* → **is** [*类型*](03_Types.md#type)
+
+> *as模式* → [*模式*](#pattern) **as** [*类型*](03_Types.md#type)
## 表达式模式（Expression Pattern）
-一个表达式模式代表了一个表达式的值。表达式模式只出现在`switch`语句中的`case`标签中。
+表达式模式代表表达式的值。表达式模式只出现在 `switch` 语句中的 `case` 标签中。
-由表达式模式所代表的表达式与使用了Swift标准库中`~=`操作符的输入表达式的值进行比较。如果`~=`操作符返回`true`，则匹配成功。默认情况下，`~=`操作符使用`==`操作符来比较两个相同类型的值。它也可以将一个整型数值与一个`Range`对象中的一段整数区间做匹配，正如下面这个例子所示：
+表达式模式代表的表达式会使用 Swift 标准库中的 `~=` 运算符与输入表达式的值进行比较。如果 `~=` 运算符返回 `true`，则匹配成功。默认情况下，`~=` 运算符使用 `==` 运算符来比较两个相同类型的值。它也可以将一个整型数值与一个 `Range` 实例中的一段整数区间做匹配，正如下面这个例子所示：
```swift
let point = (1, 2)
@@ -201,24 +216,26 @@ case (-2...2, -2...2):
default:
print("The point is at (\(point.0), \(point.1)).")
}
-// prints "(1, 2) is near the origin.”
+// 打印 “(1, 2) is near the origin.”
```
-你可以重载`~=`操作符来提供自定义的表达式匹配行为。比如你可以重写上面的例子，拿`point`表达式去比较字符串形式的点。
+你可以重载 `~=` 运算符来提供自定义的表达式匹配行为。比如你可以重写上面的例子，将 `point` 表达式与字符串形式表示的点进行比较。
```swift
-// Overload the ~= operator to match a string with an integer
+// 重载 ~= 运算符对字符串和整数进行比较
func ~=(pattern: String, value: Int) -> Bool {
return pattern == "\(value)"
}
+
switch point {
case ("0", "0"):
print("(0, 0) is at the origin.")
default:
print("The point is at (\(point.0), \(point.1)).")
}
-// prints "(1, 2) is near the origin.”
+// 打印 “The point is at (1, 2).”
```
> 表达式模式语法
-> *表达式模式* → [*表达式*](../chapter3/04_Expressions.html#expression)
+
+> *表达式模式* → [*表达式*](04_Expressions.md#expression)
diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index fc4657f8..84e92707 100755
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -8,34 +8,37 @@
> 2.0
> 翻译+校对：[wardenNScaiyi](https:github.com/wardenNScaiyi)
+> 3.0
+> 翻译+校对：[chenmingjia](https:github.com/chenmingjia)
+
本页包含内容：
- [泛型形参子句](#generic_parameter)
+ - [Where 子句](#where_clauses)
- [泛型实参子句](#generic_argument)
-本节涉及泛型类型、泛型函数以及泛型初始化器（**initializer**）的参数，包括形参和实参。声明泛型类型、函数或初始化器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型初始化器时，就用具体的类型实参替代之。
+本节涉及泛型类型、泛型函数以及泛型构造器的参数，包括形参和实参。声明泛型类型、函数或构造器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型构造器时，就用具体的类型实参替代之。
-关于 Swift 语言的泛型概述，见[泛型](../chapter2/23_Generics.md)(第二部分第23章)。
+关于 Swift 语言的泛型概述，请参阅 [泛型](../chapter2/23_Generics.md)。
## 泛型形参子句
-泛型形参子句指定泛型类型或函数的类型形参，以及这些参数的关联约束和关联类型要求（**requirement**）。泛型形参子句用尖括号（<>）包住，并且有以下两种形式：
+泛型形参子句指定泛型类型或函数的类型形参，以及这些参数相关的约束和要求。泛型形参子句用尖括号（`<>`）包住，形式如下：
> <`泛型形参列表`>
-> <`泛型形参列表` where `关联类型要求`>
泛型形参列表中泛型形参用逗号分开，其中每一个采用以下形式：
> `类型形参` : `约束`
-泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如 T，U，V，Key，Value 等）的名字而已。你可以在泛型类型、函数的其余部分或者初始化器声明，包括函数或初始化器的签名中使用它（与其任何相关类型）。
+泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如 `T`，`U`，`V`，`Key`，`Value` 等）的名字而已。你可以在泛型类型、函数的其余部分或者构造器声明，包括函数或构造器的签名中使用它（以及它的关联类型）。
-约束用于指明该类型形参继承自某个类或者遵守某个协议或协议的一部分。例如，在下面的泛型函数中，泛型形参`T: Comparable`表示任何用于替代类型形参`T`的类型实参必须满足`Comparable`协议。
+约束用于指明该类型形参继承自某个类或者符合某个协议或协议组合。例如，在下面的泛型函数中，泛型形参 `T: Comparable` 表示任何用于替代类型形参 `T` 的类型实参必须满足 `Comparable` 协议。
```swift
-func simpleMax