@@ -162,7 +158,7 @@ enum Barcode {
这个定义不提供任何 `Int` 或 `String` 类型的关联值，它只是定义了，当 `Barcode` 常量和变量等于 `Barcode.upc` 或 `Barcode.qrCode` 时，可以存储的关联值的类型。
-然后可以使用任意一种条形码类型创建新的条形码，例如：
+然后你可以使用任意一种条形码类型创建新的条形码，例如：
```swift
var productBarcode = Barcode.upc(8, 85909, 51226, 3)
@@ -178,7 +174,7 @@ productBarcode = .qrCode("ABCDEFGHIJKLMNOP")
这时，原始的 `Barcode.upc` 和其整数关联值被新的 `Barcode.qrCode` 和其字符串关联值所替代。`Barcode` 类型的常量和变量可以存储一个 `.upc` 或者一个 `.qrCode`（连同它们的关联值），但是在同一时间只能存储这两个值中的一个。
-像先前那样，可以使用一个 switch 语句来检查不同的条形码类型。然而，这一次，关联值可以被提取出来作为 switch 语句的一部分。你可以在 `switch` 的 case 分支代码中提取每个关联值作为一个常量（用 `let` 前缀）或者作为一个变量（用 `var` 前缀）来使用：
+你可以使用一个 switch 语句来检查不同的条形码类型，和之前使用 Switch 语句来匹配枚举值的例子一样。然而，这一次，关联值可以被提取出来作为 switch 语句的一部分。你可以在 `switch` 的 case 分支代码中提取每个关联值作为一个常量（用 `let` 前缀）或者作为一个变量（用 `var` 前缀）来使用：
```swift
switch productBarcode {
@@ -187,7 +183,7 @@ case .upc(let numberSystem, let manufacturer, let product, let check):
case .qrCode(let productCode):
print("QR code: \(productCode).")
}
-// 打印 "QR code: ABCDEFGHIJKLMNOP."
+// 打印“QR code: ABCDEFGHIJKLMNOP.”
```
如果一个枚举成员的所有关联值都被提取为常量，或者都被提取为变量，为了简洁，你可以只在成员名称前标注一个 `let` 或者 `var`：
@@ -199,11 +195,10 @@ case let .upc(numberSystem, manufacturer, product, check):
case let .qrCode(productCode):
print("QR code: \(productCode).")
}
-// 打印 "QR code: ABCDEFGHIJKLMNOP."
+// 打印“QR code: ABCDEFGHIJKLMNOP.”
```
-
-## 原始值
+## 原始值 {#raw-values}
在[关联值](#associated_values)小节的条形码例子中，演示了如何声明存储不同类型关联值的枚举成员。作为关联值的替代选择，枚举成员可以被默认值（称为*原始值*）预填充，这些原始值的类型必须相同。
@@ -217,7 +212,7 @@ enum ASCIIControlCharacter: Character {
}
```
-枚举类型 `ASCIIControlCharacter` 的原始值类型被定义为 `Character`，并设置了一些比较常见的 ASCII 控制字符。`Character` 的描述详见[字符串和字符](./03_Strings_and_Characters.html)部分。
+枚举类型 `ASCIIControlCharacter` 的原始值类型被定义为 `Character`，并设置了一些比较常见的 ASCII 控制字符。`Character` 的描述详见[字符串和字符](./03_Strings_and_Characters.md)部分。
原始值可以是字符串、字符，或者任意整型值或浮点型值。每个原始值在枚举声明中必须是唯一的。
@@ -225,8 +220,7 @@ enum ASCIIControlCharacter: Character {
>
> 原始值和关联值是不同的。原始值是在定义枚举时被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终不变。关联值是创建一个基于枚举成员的常量或变量时才设置的值，枚举成员的关联值可以变化。
-
-### 原始值的隐式赋值
+### 原始值的隐式赋值 {#implicitly-assigned-raw-values}
在使用原始值为整数或者字符串类型的枚举时，不需要显式地为每一个枚举成员设置原始值，Swift 将会自动为你赋值。
@@ -264,8 +258,7 @@ let sunsetDirection = CompassPoint.west.rawValue
// sunsetDirection 值为 "west"
```
-
-### 使用原始值初始化枚举实例
+### 使用原始值初始化枚举实例 {#initializing-from-a-raw-value}
如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法接收一个叫做 `rawValue` 的参数，参数类型即为原始值类型，返回值则是枚举成员或 `nil`。你可以使用这个初始化方法来创建一个新的枚举实例。
@@ -296,13 +289,12 @@ if let somePlanet = Planet(rawValue: positionToFind) {
} else {
print("There isn't a planet at position \(positionToFind)")
}
-// 打印 "There isn't a planet at position 11"
+// 打印“There isn't a planet at position 11”
```
这个例子使用了可选绑定（optional binding），试图通过原始值 `11` 来访问一个行星。`if let somePlanet = Planet(rawValue: 11)` 语句创建了一个可选 `Planet`，如果可选 `Planet` 的值存在，就会赋值给 `somePlanet`。在这个例子中，无法检索到位置为 `11` 的行星，所以 `else` 分支被执行。
-
-## 递归枚举
+## 递归枚举 {#recursive-enumerations}
*递归枚举*是一种枚举类型，它有一个或多个枚举成员使用该枚举类型的实例作为关联值。使用递归枚举时，编译器会插入一个间接层。你可以在枚举成员前加上 `indirect` 来表示该成员可递归。
@@ -350,7 +342,7 @@ func evaluate(_ expression: ArithmeticExpression) -> Int {
}
print(evaluate(product))
-// 打印 "18"
+// 打印“18”
```
该函数如果遇到纯数字，就直接返回该数字的值。如果遇到的是加法或乘法运算，则分别计算左边表达式和右边表达式的值，然后相加或相乘。
diff --git a/source/chapter2/09_Structures_And_Classes.md b/source/chapter2/09_Structures_And_Classes.md
index fdce2153..e34733bc 100755
--- a/source/chapter2/09_Structures_And_Classes.md
+++ b/source/chapter2/09_Structures_And_Classes.md
@@ -8,8 +8,7 @@
>
> 通常一个*类*的实例被称为*对象*。然而相比其他语言，Swift 中结构体和类的功能更加相近，本章中所讨论的大部分功能都可以用在结构体或者类上。因此，这里会使用*实例*这个更通用的术语。
-
-## 结构体和类对比
+## 结构体和类对比 {#comparing-structures-and-classes}
Swift 中结构体和类有很多共同点。两者都可以：
@@ -20,7 +19,7 @@ Swift 中结构体和类有很多共同点。两者都可以：
* 通过扩展以增加默认实现之外的功能
* 遵循协议以提供某种标准功能
-更多信息请参见 [属性](./10_Properties.html)、[方法](./11_Methods.html)、[下标](./12_Subscripts.html)、[构造过程](./14_Initialization.html)、[扩展](./20_Extensions.html) 和 [协议](./21_Protocols.html)。
+更多信息请参见 [属性](./10_Properties.md)、[方法](./11_Methods.md)、[下标](./12_Subscripts.md)、[构造过程](./14_Initialization.md)、[扩展](./20_Extensions.md) 和 [协议](./21_Protocols.md)。
与结构体相比，类还有如下的附加功能：
@@ -29,12 +28,11 @@ Swift 中结构体和类有很多共同点。两者都可以：
* 析构器允许一个类实例释放任何其所被分配的资源
* 引用计数允许对一个类的多次引用
-更多信息请参见 [继承](./13_Inheritance.html)、[类型转换](./18_Type_Casting.html)、[析构过程](./15_Deinitialization.html) 和 [自动引用计数](./23_Automatic_Reference_Counting.html)。
+更多信息请参见 [继承](./13_Inheritance.md)、[类型转换](./18_Type_Casting.md)、[析构过程](./15_Deinitialization.md) 和 [自动引用计数](./23_Automatic_Reference_Counting.md)。
类支持的附加功能是以增加复杂性为代价的。作为一般准则，优先使用结构体，因为它们更容易理解，仅在适当或必要时才使用类。实际上，这意味着你的大多数自定义数据类型都会是结构体和枚举。更多详细的比较参见 [在结构和类之间进行选择](https://developer.apple.com/documentation/swift/choosing_between_structures_and_classes)。
-
-### 类型定义的语法
+### 类型定义的语法 {#definition-syntax}
结构体和类有着相似的定义方式。你通过 `struct` 关键字引入结构体，通过 `class` 关键字引入类，并将它们的具体定义放在一对大括号中：
@@ -70,8 +68,7 @@ class VideoMode {
在上面的示例还定义了一个名为 `VideoMode` 的类，用来描述视频显示器的某个特定视频模式。这个类包含了四个可变的存储属性。第一个， `resolution`，被初始化为一个新的 `Resolution` 结构体的实例，属性类型被推断为 `Resolution`。新 `VideoMode` 实例同时还会初始化其它三个属性，它们分别是初始值为 `false` 的 `interlaced`（意为“非隔行视频”），初始值为 `0.0` 的 `frameRate`，以及值为可选 `String` 的 `name`。因为 `name` 是一个可选类型，它会被自动赋予一个默认值 `nil`，意为“没有 `name` 值”。
-
-### 结构体和类的实例
+### 结构体和类的实例 {#class-and-structure-instances}
`Resolution` 结构体和 `VideoMode` 类的定义仅描述了什么是 `Resolution` 和 `VideoMode`。它们并没有描述一个特定的分辨率（resolution）或者视频模式（video mode）。为此，你需要创建结构体或者类的一个实例。
@@ -82,10 +79,9 @@ let someResolution = Resolution()
let someVideoMode = VideoMode()
```
-结构体和类都使用构造器语法来创建新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如 `Resolution()` 或 `VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](./14_Initialization.html) 章节会对类和结构体的初始化进行更详细的讨论。
+结构体和类都使用构造器语法来创建新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如 `Resolution()` 或 `VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](./14_Initialization.md) 章节会对类和结构体的初始化进行更详细的讨论。
-
-### 属性访问
+### 属性访问 {#accessing-properties}
你可以通过使用*点语法*访问实例的属性。其语法规则是，实例名后面紧跟属性名，两者以点号（`.`）分隔，不带空格：
@@ -111,8 +107,7 @@ print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
// 打印 "The width of someVideoMode is now 1280"
```
-
-### 结构体类型的成员逐一构造器
+### 结构体类型的成员逐一构造器 {#memberwise-initializers-for-structure-types}
所有结构体都有一个自动生成的*成员逐一构造器*，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中：
@@ -120,10 +115,9 @@ print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
let vga = Resolution(width: 640, height: 480)
```
-与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](./14_Initialization.html) 章节会对构造器进行更详细的讨论。
+与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](./14_Initialization.md) 章节会对构造器进行更详细的讨论。
-
-## 结构体和枚举是值类型
+## 结构体和枚举是值类型 {#structures-and-enumerations-are-value-types}
*值类型*是这样一种类型，当它被赋值给一个变量、常量或者被传递给一个函数的时候，其值会被*拷贝*。
@@ -191,8 +185,7 @@ print("The remembered direction is \(rememberedDirection)")
当 `rememberedDirection` 被赋予了 `currentDirection` 的值，实际上它被赋予的是值的一个拷贝。赋值过程结束后再修改 `currentDirection` 的值并不影响 `rememberedDirection` 所储存的原始值的拷贝。
-
-## 类是引用类型
+## 类是引用类型 {#classes-are-reference-types}
与值类型不同，*引用类型*在被赋予到一个变量、常量或者被传递到一个函数时，其值不会被拷贝。因此，使用的是已存在实例的引用，而不是其拷贝。
@@ -230,8 +223,7 @@ print("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
需要注意的是 `tenEighty` 和 `alsoTenEighty` 被声明为常量而不是变量。然而你依然可以改变 `tenEighty.frameRate` 和 `alsoTenEighty.frameRate`，这是因为 `tenEighty` 和 `alsoTenEighty` 这两个常量的值并未改变。它们并不“存储”这个 `VideoMode` 实例，而仅仅是对 `VideoMode` 实例的引用。所以，改变的是底层 `VideoMode` 实例的 `frameRate` 属性，而不是指向 `VideoMode` 的常量引用的值。
-
-### 恒等运算符
+### 恒等运算符 {#identity-operators}
因为类是引用类型，所以多个常量和变量可能在幕后同时引用同一个类实例。（对于结构体和枚举来说，这并不成立。因为它们作为值类型，在被赋予到常量、变量或者传递到函数时，其值总是会被拷贝。）
@@ -251,9 +243,8 @@ if tenEighty === alsoTenEighty {
请注意，“相同”（用三个等号表示，`===`）与“等于”（用两个等号表示，`==`）的不同。“相同”表示两个类类型（class type）的常量或者变量引用同一个类实例。“等于”表示两个实例的值“相等”或“等价”，判定时要遵照设计者定义的评判标准。
-当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./26_Advanced_Operators.html#equivalence_operators) 中将会详细介绍实现自定义 == 和 !== 运算符的流程。
+当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./26_Advanced_Operators.md#equivalence_operators) 中将会详细介绍实现自定义 == 和 !== 运算符的流程。
-
-### 指针
+### 指针 {#pointers}
如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用*指针*来引用内存中的地址。Swift 中引用了某个引用类型实例的常量或变量，与 C 语言中的指针类似，不过它并不直接指向某个内存地址，也不要求你使用星号（`*`）来表明你在创建一个引用。相反，Swift 中引用的定义方式与其它的常量或变量的一样。如果需要直接与指针交互，你可以使用标准库提供的指针和缓冲区类型 —— 参见 [手动管理内存](https://developer.apple.com/documentation/swift/swift_standard_library/manual_memory_management)。
diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 2de5aee1..d8432148 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -1,19 +1,18 @@
# 属性
-*属性*将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，而计算属性计算（不是存储）一个值。计算属性可以用于类、结构体和枚举，存储属性只能用于类和结构体。
+*属性*将值与特定的类、结构体或枚举关联。存储属性会将常量和变量存储为实例的一部分，而计算属性则是直接计算（而不是存储）值。计算属性可以用于类、结构体和枚举，而存储属性只能用于类和结构体。
-存储属性和计算属性通常与特定类型的实例关联。但是，属性也可以直接作用于类型本身，这种属性称为类型属性。
+存储属性和计算属性通常与特定类型的实例关联。但是，属性也可以直接与类型本身关联，这种属性称为类型属性。
-另外，还可以定义属性观察器来监控属性值的变化，以此来触发一个自定义的操作。属性观察器可以添加到自己定义的存储属性上，也可以添加到从父类继承的属性上。
+另外，还可以定义属性观察器来监控属性值的变化，以此来触发自定义的操作。属性观察器可以添加到类本身定义的存储属性上，也可以添加到从父类继承的属性上。
-
-## 存储属性
+## 存储属性 {#stored-properties}
简单来说，一个存储属性就是存储在特定类或结构体实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字 `var` 定义），也可以是*常量存储属性*（用关键字 `let` 定义）。
-可以在定义存储属性的时候指定默认值，请参考[默认构造器](./14_Initialization.html#default_initializers)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程中常量属性的修改](./14_Initialization.html#assigning_constant_properties_during_initialization)一节。
+可以在定义存储属性的时候指定默认值，请参考[默认构造器](./14_Initialization.md#default_initializers)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程中常量属性的修改](./14_Initialization.md#assigning_constant_properties_during_initialization)一节。
-下面的例子定义了一个名为 `FixedLengthRange` 的结构体，该结构体用于描述整数的范围，且这个范围值在被创建后不能被修改。
+下面的例子定义了一个名为 `FixedLengthRange` 的结构体，该结构体用于描述整数的区间，且这个范围值在被创建后不能被修改。
```swift
struct FixedLengthRange {
@@ -21,43 +20,41 @@ struct FixedLengthRange {
let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
-// 该区间表示整数0，1，2
+// 该区间表示整数 0，1，2
rangeOfThreeItems.firstValue = 6
-// 该区间现在表示整数6，7，8
+// 该区间现在表示整数 6，7，8
```
-`FixedLengthRange` 的实例包含一个名为 `firstValue` 的变量存储属性和一个名为 `length` 的常量存储属性。在上面的例子中，`length` 在创建实例的时候被初始化，因为它是一个常量存储属性，所以之后无法修改它的值。
+`FixedLengthRange` 的实例包含一个名为 `firstValue` 的变量存储属性和一个名为 `length` 的常量存储属性。在上面的例子中，`length` 在创建实例的时候被初始化，且之后无法修改它的值，因为它是一个常量存储属性。
-
-### 常量结构体的存储属性
+### 常量结构体实例的存储属性 {#stored-properties-of-constant-structure-instances}
-如果创建了一个结构体的实例并将其赋值给一个常量，则无法修改该实例的任何属性，即使有属性被声明为变量也不行：
+如果创建了一个结构体实例并将其赋值给一个常量，则无法修改该实例的任何属性，即使被声明为可变属性也不行:
```swift
let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
-// 该区间表示整数0，1，2，3
+// 该区间表示整数 0，1，2，3
rangeOfFourItems.firstValue = 6
-// 尽管 firstValue 是个变量属性，这里还是会报错
+// 尽管 firstValue 是个可变属性，但这里还是会报错
```
-因为 `rangeOfFourItems` 被声明成了常量（用 `let` 关键字），即使 `firstValue` 是一个变量属性，也无法再修改它了。
+因为 `rangeOfFourItems` 被声明成了常量（用 `let` 关键字），所以即使 `firstValue` 是一个可变属性，也无法再修改它了。
-这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
+这种行为是由于结构体属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
-属于*引用类型*的类（class）则不一样。把一个引用类型的实例赋给一个常量后，仍然可以修改该实例的变量属性。
+属于*引用类型*的类则不一样。把一个引用类型的实例赋给一个常量后，依然可以修改该实例的可变属性。
-
-### 延迟存储属性
+### 延时加载存储属性 {#lazy-stored-properties}
-*延迟存储属性*是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 `lazy` 来标示一个延迟存储属性。
+*延时加载存储属性*是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 `lazy` 来标示一个延时加载存储属性。
> 注意
>
-> 必须将延迟存储属性声明成变量（使用 `var` 关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
+> 必须将延时加载属性声明成变量（使用 `var` 关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延时加载。
-延迟属性很有用，当属性的值依赖于在实例的构造过程结束后才会知道影响值的外部因素时，或者当获得属性的初始值需要复杂或大量计算时，可以只在需要的时候计算它。
+当属性的值依赖于一些外部因素且这些外部因素只有在构造过程结束之后才会知道的时候，延时加载属性就会很有用。或者当获得属性的值因为需要复杂或者大量的计算，而需要采用需要的时候再计算的方式，延时加载属性也会很有用。
-下面的例子使用了延迟存储属性来避免复杂类中不必要的初始化。例子中定义了 `DataImporter` 和 `DataManager` 两个类，下面是部分代码：
+下面的例子使用了延时加载存储属性来避免复杂类中不必要的初始化工作。例子中定义了 `DataImporter` 和 `DataManager` 两个类，下面是部分代码：
```swift
class DataImporter {
@@ -81,33 +78,31 @@ manager.data.append("Some more data")
// DataImporter 实例的 importer 属性还没有被创建
```
-`DataManager` 类包含一个名为 `data` 的存储属性，初始值是一个空的字符串（`String`）数组。这里没有给出全部代码，只需知道 `DataManager` 类的目的是管理和提供对这个字符串数组的访问即可。
+`DataManager` 类包含一个名为 `data` 的存储属性，初始值是一个空的字符串数组。这里没有给出全部代码，只需知道 `DataManager` 类的目的是管理和提供对这个字符串数组的访问即可。
-`DataManager` 的一个功能是从文件导入数据。该功能由 `DataImporter` 类提供，`DataImporter` 完成初始化需要消耗不少时间：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
+`DataManager` 的一个功能是从文件中导入数据。这个功能由 `DataImporter` 类提供，`DataImporter` 完成初始化需要消耗不少时间：因为它的实例在初始化时可能需要打开文件并读取文件中的内容到内存中。
`DataManager` 管理数据时也可能不从文件中导入数据。所以当 `DataManager` 的实例被创建时，没必要创建一个 `DataImporter` 的实例，更明智的做法是第一次用到 `DataImporter` 的时候才去创建它。
-由于使用了 `lazy`，`importer` 属性只有在第一次被访问的时候才被创建。比如访问它的属性 `fileName` 时：
+由于使用了 `lazy`，`DataImporter` 的实例 `importer` 属性只有在第一次被访问的时候才被创建。比如访问它的属性 `fileName` 时：
```swift
print(manager.importer.fileName)
// DataImporter 实例的 importer 属性现在被创建了
-// 输出 "data.txt”
+// 输出“data.txt”
```
> 注意
>
> 如果一个被标记为 `lazy` 的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。
-
-### 存储属性和实例变量
+### 存储属性和实例变量 {#stored-properties-and-instance-variables}
-如果您有过 Objective-C 经验，应该知道 Objective-C 为类实例存储值和引用提供两种方法。除了属性之外，还可以使用实例变量作为属性值的后端存储。
+如果您有过 Objective-C 经验，应该知道 Objective-C 为类实例存储值和引用提供两种方法。除了属性之外，还可以使用实例变量作为一个备份存储将变量值赋值给属性。
-Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。属性的全部信息——包括命名、类型和内存管理特征——作为类型定义的一部分，都定义在一个地方。
+Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的备份存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。属性的全部信息——包括命名、类型和内存管理特征——作为类型定义的一部分，都定义在一个地方。
-
-## 计算属性
+## 计算属性 {#computed-properties}
除存储属性外，类、结构体和枚举可以定义*计算属性*。计算属性不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。
@@ -138,7 +133,7 @@ var square = Rect(origin: Point(x: 0.0, y: 0.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)”
+// 打印“square.origin is now at (10.0, 10.0)”
```
这个例子定义了 3 个结构体来描述几何形状：
@@ -147,7 +142,7 @@ print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
- `Size` 封装了一个 `width` 和一个 `height`
- `Rect` 表示一个有原点和尺寸的矩形
-`Rect` 也提供了一个名为 `center` 的计算属性。一个矩形的中心点可以从原点（`origin`）和大小（`size`）算出，所以不需要将它以显式声明的 `Point` 来保存。`Rect` 的计算属性 `center` 提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
+`Rect` 也提供了一个名为 `center` 的计算属性。一个 `Rect` 的中心点可以从 `origin`（原点）和 `size`（大小）算出，所以不需要将中心点以 `Point` 类型的值来保存。`Rect` 的计算属性 `center` 提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
上述例子中创建了一个名为 `square` 的 `Rect` 实例，初始值原点是 `(0, 0)`，宽度高度都是 `10`。如下图中蓝色正方形所示。
@@ -157,8 +152,7 @@ print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
-
-### 简化 Setter 声明
+### 简化 Setter 声明 {#shorthand-setter-declaration}
如果计算属性的 setter 没有定义表示新值的参数名，则可以使用默认名称 `newValue`。下面是使用了简化 setter 声明的 `Rect` 结构体代码：
@@ -180,10 +174,9 @@ struct AlternativeRect {
}
```
-
-### 只读计算属性
+### 只读计算属性 {#readonly-computed-properties}
-只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
+只有 getter 没有 setter 的计算属性叫*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
> 注意
>
@@ -200,32 +193,31 @@ struct Cuboid {
}
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"
+// 打印“the volume of fourByFiveByTwo is 40.0”
```
这个例子定义了一个名为 `Cuboid` 的结构体，表示三维空间的立方体，包含 `width`、`height` 和 `depth` 属性。结构体还有一个名为 `volume` 的只读计算属性用来返回立方体的体积。为 `volume` 提供 setter 毫无意义，因为无法确定如何修改 `width`、`height` 和 `depth` 三者的值来匹配新的 `volume`。然而，`Cuboid` 提供一个只读计算属性来让外部用户直接获取体积是很有用的。
-
-## 属性观察器
+## 属性观察器 {#property-observers}
属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，即使新值和当前值相同的时候也不例外。
-你可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重写属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。你不必为非重写的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。 属性重写请参考[重写](./13_Inheritance.html#overriding)。
+你可以为除了延时加载存储属性之外的其他存储属性添加属性观察器，你也可以在子类中通过重写属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。你不必为非重写的计算属性添加属性观察器，因为你可以直接通过它的 setter 监控和响应值的变化。属性重写请参考[重写](./13_Inheritance.md#overriding)。
-可以为属性添加如下的一个或全部观察器：
+可以为属性添加其中一个或两个观察器：
- `willSet` 在新的值被设置之前调用
-- `didSet` 在新的值被设置之后立即调用
+- `didSet` 在新的值被设置之后调用
`willSet` 观察器会将新的属性值作为常量参数传入，在 `willSet` 的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称 `newValue` 表示。
-同样，`didSet` 观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名 `oldValue`。如果在 `didSet` 方法中再次对该属性赋值，那么新值会覆盖旧的值。
+同样，`didSet` 观察器会将旧的属性值作为参数传入，可以为该参数指定一个名称或者使用默认参数名 `oldValue`。如果在 `didSet` 方法中再次对该属性赋值，那么新值会覆盖旧的值。
> 注意
+>
+> 在父类初始化方法调用之后，在子类构造器中给父类的属性赋值时，会调用父类属性的 `willSet` 和 `didSet` 观察器。而在父类初始化方法调用之前，给子类的属性赋值时不会调用子类属性的观察器。
>
-> 父类的属性在子类的构造器中被赋值时，它在父类中的 `willSet` 和 `didSet` 观察器会被调用，随后才会调用子类的观察器。在父类初始化方法调用之前，子类给属性赋值时，观察器不会被调用。
->
-> 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)和[类的构造器代理规则](./14_Initialization.html#initializer_delegation_for_class_types)。
+> 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.md#initializer_delegation_for_value_types)和[类的构造器代理](./14_Initialization.md#initializer_delegation_for_class_types)。
下面是一个 `willSet` 和 `didSet` 实际运用的例子，其中定义了一个名为 `StepCounter` 的类，用来统计一个人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
@@ -233,28 +225,28 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
class StepCounter {
var totalSteps: Int = 0 {
willSet(newTotalSteps) {
- print("About to set totalSteps to \(newTotalSteps)")
+ print("将 totalSteps 的值设置为 \(newTotalSteps)")
}
didSet {
if totalSteps > oldValue {
- print("Added \(totalSteps - oldValue) steps")
+ print("增加了 \(totalSteps - oldValue) 步")
}
}
}
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
-// About to set totalSteps to 200
-// Added 200 steps
+// 将 totalSteps 的值设置为 200
+// 增加了 200 步
stepCounter.totalSteps = 360
-// About to set totalSteps to 360
-// Added 160 steps
+// 将 totalSteps 的值设置为 360
+// 增加了 160 步
stepCounter.totalSteps = 896
-// About to set totalSteps to 896
-// Added 536 steps
+// 将 totalSteps 的值设置为 896
+// 增加了 536 步
```
-`StepCounter` 类定义了一个 `Int` 类型的属性 `totalSteps`，它是一个存储属性，包含 `willSet` 和 `didSet` 观察器。
+`StepCounter` 类定义了一个叫 `totalSteps` 的 `Int` 类型的属性。它是一个存储属性，包含 `willSet` 和 `didSet` 观察器。
当 `totalSteps` 被设置新值的时候，它的 `willSet` 和 `didSet` 观察器都会被调用，即使新值和当前值完全相同时也会被调用。
@@ -264,12 +256,11 @@ stepCounter.totalSteps = 896
> 注意
>
-> 如果将属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考[输入输出参数](../chapter3/05_Declarations.html#in-out_parameters)
+> 如果将带有观察器的属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出内存模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考[输入输出参数](../chapter3/05_Declarations.html#in-out_parameters)
-
-## 全局变量和局部变量
+## 全局变量和局部变量 {#global-and-local-variables}
-计算属性和属性观察器所描述的功能也可以用于*全局变量*和*局部变量*。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。
+计算属性和观察属性所描述的功能也可以用于*全局变量*和*局部变量*。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。
前面章节提到的全局或局部变量都属于*存储型变量*，跟存储属性类似，它为特定类型的值提供存储空间，并允许读取和写入。
@@ -277,16 +268,15 @@ stepCounter.totalSteps = 896
> 注意
>
-> 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记 `lazy` 修饰符。
+> 全局的常量或变量都是延迟计算的，跟[延时加载存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记 `lazy` 修饰符。
>
-> 局部范围的常量或变量从不延迟计算。
+> 局部范围的常量和变量从不延迟计算。
-
-## 类型属性
+## 类型属性 {#type-properties}
实例属性属于一个特定类型的实例，每创建一个实例，实例都拥有属于自己的一套属性值，实例之间的属性相互独立。
-也可以为类型本身定义属性，无论创建了多少个该类型的实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
+你也可以为类型本身定义属性，无论创建了多少个该类型的实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
类型属性用于定义某个类型所有实例共享的数据，比如*所有*实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
@@ -298,10 +288,9 @@ stepCounter.totalSteps = 896
>
> 存储型类型属性是延迟初始化的，它们只有在第一次被访问的时候才会被初始化。即使它们被多个线程同时访问，系统也保证只会对其进行一次初始化，并且不需要对其使用 `lazy` 修饰符。
-
-### 类型属性语法
+### 类型属性语法 {#type-property-syntax}
-在 C 或 Objective-C 中，与某个类型关联的静态常量和静态变量，是作为全局（*global*）静态变量定义的。但是在 Swift 中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
+在 C 或 Objective-C 中，与某个类型关联的静态常量和静态变量，是作为 *global*（全局）静态变量定义的。但是在 Swift 中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
使用关键字 `static` 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 `class` 来支持子类对父类的实现进行重写。下面的例子演示了存储型和计算型类型属性的语法：
@@ -333,21 +322,20 @@ class SomeClass {
>
> 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟计算型实例属性的语法相同。
-
-### 获取和设置类型属性的值
+### 获取和设置类型属性的值 {#querying-and-setting-type-properties}
-跟实例属性一样，类型属性也是通过点运算符来访问。但是，类型属性是通过类型本身来访问，而不是通过实例。比如：
+跟实例属性一样，类型属性也是通过点运算符来访问。但是，类型属性是通过*类型*本身来访问，而不是通过实例。比如：
```swift
print(SomeStructure.storedTypeProperty)
-// 打印 "Some value."
+// 打印“Some value.”
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
-// 打印 "Another value.”
+// 打印“Another value.”
print(SomeEnumeration.computedTypeProperty)
-// 打印 "6"
+// 打印“6”
print(SomeClass.computedTypeProperty)
-// 打印 "27"
+// 打印“27”
```
下面的例子定义了一个结构体，使用两个存储型类型属性来表示两个声道的音量，每个声道具有 `0` 到 `10` 之间的整数音量。
@@ -377,9 +365,9 @@ struct AudioChannel {
}
```
-结构 `AudioChannel` 定义了 2 个存储型类型属性来实现上述功能。第一个是 `thresholdLevel`，表示音量的最大上限阈值，它是一个值为 `10` 的常量，对所有实例都可见，如果音量高于 `10`，则取最大上限值 `10`（见后面描述）。
+`AudioChannel` 结构定义了 2 个存储型类型属性来实现上述功能。第一个是 `thresholdLevel`，表示音量的最大上限阈值，它是一个值为 `10` 的常量，对所有实例都可见，如果音量高于 `10`，则取最大上限值 `10`（见后面描述）。
-第二个类型属性是变量存储型属性 `maxInputLevelForAllChannels`，它用来表示所有 `AudioChannel` 实例的最大音量，初始值是 `0`。
+第二个类型属性是变量存储型属性 `maxInputLevelForAllChannels`，它用来表示所有 `AudioChannel` 实例的最大输入音量，初始值是 `0`。
`AudioChannel` 也定义了一个名为 `currentLevel` 的存储型实例属性，表示当前声道现在的音量，取值为 `0` 到 `10`。
@@ -404,9 +392,9 @@ var rightChannel = AudioChannel()
```swift
leftChannel.currentLevel = 7
print(leftChannel.currentLevel)
-// 输出 "7"
+// 输出“7”
print(AudioChannel.maxInputLevelForAllChannels)
-// 输出 "7"
+// 输出“7”
```
如果试图将右声道的 `currentLevel` 设置成 `11`，它会被修正到最大值 `10`，同时 `maxInputLevelForAllChannels` 的值也会更新到 `10`：
@@ -414,7 +402,7 @@ print(AudioChannel.maxInputLevelForAllChannels)
```swift
rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
-// 输出 "10"
+// 输出“10”
print(AudioChannel.maxInputLevelForAllChannels)
-// 输出 "10"
+// 输出“10”
```
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index f80c1832..4e27a3d3 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -4,8 +4,7 @@
结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活地在你创建的类型（类/结构体/枚举）上定义方法。
-
-## 实例方法（Instance Methods）
+## 实例方法（Instance Methods） {#instance-methods}
*实例方法*是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](./06_Functions.md)。
@@ -48,10 +47,9 @@ counter.reset()
// 计数值现在是0
```
-函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[指定外部参数名](./06_Functions.html#specifying_external_parameter_names)。方法参数也一样，因为方法就是函数，只是这个函数与某个类型相关联了。
+函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[指定外部参数名](./06_Functions.md#specifying_external_parameter_names)。方法参数也一样，因为方法就是函数，只是这个函数与某个类型相关联了。
-
-### self 属性
+### self 属性 {#the-self-property}
类型的每一个实例都有一个隐含属性叫做 `self`，`self` 完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的 `self` 属性来引用当前实例。
@@ -72,21 +70,20 @@ func increment() {
```swift
struct Point {
var x = 0.0, y = 0.0
- func isToTheRightOfX(_ x: Double) -> Bool {
+ func isToTheRightOf(x: Double) -> Bool {
return self.x > x
}
}
let somePoint = Point(x: 4.0, y: 5.0)
-if somePoint.isToTheRightOfX(1.0) {
+if somePoint.isToTheRightOf(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"
+// 打印“This point is to the right of the line where x == 1.0”
```
-如果不使用 `self` 前缀，Swift 就认为两次使用的 `x` 都指的是名称为 `x` 的函数参数。
+如果不使用 `self` 前缀，Swift会认为 `x` 的两个用法都引用了名为 `x` 的方法参数。
-
-### 在实例方法中修改值类型
+### 在实例方法中修改值类型 {#modifying-value-types-from-within-instance-methods}
结构体和枚举是*值类型*。默认情况下，值类型的属性不能在它的实例方法中被修改。
@@ -97,29 +94,28 @@ if somePoint.isToTheRightOfX(1.0) {
```swift
struct Point {
var x = 0.0, y = 0.0
- mutating func moveByX(_ deltaX: Double, y deltaY: Double) {
+ mutating func moveBy(x 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)
+somePoint.moveBy(x: 2.0, y: 3.0)
print("The point is now at (\(somePoint.x), \(somePoint.y))")
-// 打印 "The point is now at (3.0, 4.0)"
+// 打印“The point is now at (3.0, 4.0)”
```
-上面的 `Point` 结构体定义了一个可变方法 `moveByX(_:y:)` 来移动 `Point` 实例到给定的位置。该方法被调用时修改了这个点，而不是返回一个新的点。方法定义时加上了 `mutating` 关键字，从而允许修改属性。
+上面的 `Point` 结构体定义了一个可变方法 `moveBy（x：y :)` 来移动 `Point` 实例到给定的位置。该方法被调用时修改了这个点，而不是返回一个新的点。方法定义时加上了 `mutating` 关键字，从而允许修改属性。
-注意，不能在结构体类型的常量（a constant of structure type）上调用可变方法，因为其属性不能被改变，即使属性是变量属性，详情参见[常量结构体的存储属性](./10_Properties.html#stored_properties_of_constant_structure_instances)：
+注意，不能在结构体类型的常量（a constant of structure type）上调用可变方法，因为其属性不能被改变，即使属性是变量属性，详情参见[常量结构体的存储属性](./10_Properties.md#stored_properties_of_constant_structure_instances)：
```swift
let fixedPoint = Point(x: 3.0, y: 3.0)
-fixedPoint.moveByX(2.0, y: 3.0)
+fixedPoint.moveBy(x: 2.0, y: 3.0)
// 这里将会报告一个错误
```
-
-### 在可变方法中给 self 赋值
+### 在可变方法中给 self 赋值 {#assigning-to-self-within-a-mutating-method}
可变方法能够赋给隐含属性 `self` 一个全新的实例。上面 `Point` 的例子可以用下面的方式改写：
@@ -138,29 +134,28 @@ struct Point {
```swift
enum TriStateSwitch {
- case Off, Low, High
+ case off, low, high
mutating func next() {
switch self {
- case .Off:
- self = .Low
- case .Low:
- self = .High
- case .High:
- self = .Off
+ case .off:
+ self = .low
+ case .low:
+ self = .high
+ case .high:
+ self = .off
}
}
}
-var ovenLight = TriStateSwitch.Low
+var ovenLight = TriStateSwitch.low
ovenLight.next()
-// ovenLight 现在等于 .High
+// ovenLight 现在等于 .high
ovenLight.next()
-// ovenLight 现在等于 .Off
+// ovenLight 现在等于 .off
```
-上面的例子中定义了一个三态开关的枚举。每次调用 `next()` 方法时，开关在不同的电源状态（`Off`，`Low`，`High`）之间循环切换。
+上面的例子中定义了一个三态切换的枚举。每次调用 `next()` 方法时，开关在不同的电源状态（`off`, `low`, `high`）之间循环切换。
-
-## 类型方法
+## 类型方法 {#type-methods}
实例方法是被某个类型的实例调用的方法。你也可以定义在类型本身上调用的方法，这种方法就叫做*类型方法*。在方法的 `func` 关键字之前加上关键字 `static`，来指定类型方法。类还可以用关键字 `class` 来允许子类重写父类的方法实现。
@@ -179,7 +174,7 @@ class SomeClass {
SomeClass.someTypeMethod()
```
-在类型方法的方法体（body）中，`self` 指向这个类型本身，而不是类型的某个实例。这意味着你可以用 `self` 来消除类型属性和类型方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。
+在类型方法的方法体（body）中，`self` 属性指向这个类型本身，而不是类型的某个实例。这意味着你可以用 `self` 来消除类型属性和类型方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。
一般来说，在类型方法的方法体中，任何未限定的方法和属性名称，可以被本类中其他的类型方法和类型属性引用。一个类型方法可以直接通过类型方法的名称调用本类中的其它类型方法，而无需在方法名称前面加上类型名称。类似地，在结构体和枚举中，也能够直接通过类型属性的名称访问本类中的类型属性，而不需要前面加上类型名称。
@@ -218,7 +213,7 @@ struct LevelTracker {
除了类型属性和类型方法，`LevelTracker` 还监测每个玩家的进度。它用实例属性 `currentLevel` 来监测每个玩家当前的等级。
-为了便于管理 `currentLevel` 属性，`LevelTracker` 定义了实例方法 `advance(to:)`。这个方法会在更新 `currentLevel` 之前检查所请求的新等级是否已经解锁。`advance(to:)` 方法返回布尔值以指示是否能够设置 `currentLevel`。因为允许在调用 `advance(to:)` 时候忽略返回值，不会产生编译警告，所以函数被标注为 `@ discardableResult` 属性，更多关于属性信息，请参考[属性](../chapter3/07_Attributes.html)章节。
+为了便于管理 `currentLevel` 属性，`LevelTracker` 定义了实例方法 `advance(to:)`。这个方法会在更新 `currentLevel` 之前检查所请求的新等级是否已经解锁。`advance(to:)` 方法返回布尔值以指示是否能够设置 `currentLevel`。因为允许在调用 `advance(to:)` 时候忽略返回值，不会产生编译警告，所以函数被标注为 `@discardableResult` 属性，更多关于属性信息，请参考[特性](../chapter3/07_Attributes.html)章节。
下面，`Player` 类使用 `LevelTracker` 来监测和更新每个玩家的发展进度：
@@ -244,7 +239,7 @@ class Player {
var player = Player(name: "Argyrios")
player.complete(level: 1)
print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
-// 打印 "highest unlocked level is now 2"
+// 打印“highest unlocked level is now 2”
```
如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么试图设置玩家当前等级将会失败：
@@ -256,5 +251,5 @@ if player.tracker.advance(to: 6) {
} else {
print("level 6 has not yet been unlocked")
}
-// 打印 "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 8ba418b7..c5aa4c0d 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -4,8 +4,7 @@
一个类型可以定义多个下标，通过不同索引类型进行重载。下标不限于一维，你可以定义具有多个入参的下标满足自定义类型的需求。
-
-## 下标语法
+## 下标语法 {#subscript-syntax}
下标允许你通过在实例名称后面的方括号中传入一个或者多个索引值来对实例进行存取。语法类似于实例方法语法和计算型属性语法的混合。与定义实例方法类似，定义下标使用 `subscript` 关键字，指定一个或多个输入参数和返回类型；与实例方法不同的是，下标可以设定为读写或只读。这种行为由 getter 和 setter 实现，有点类似计算型属性：
@@ -41,7 +40,7 @@ struct TimesTable {
}
let threeTimesTable = TimesTable(multiplier: 3)
print("six times three is \(threeTimesTable[6])")
-// 打印 "six times three is 18"
+// 打印“six times three is 18”
```
在上例中，创建了一个 `TimesTable` 实例，用来表示整数 `3` 的乘法表。数值 `3` 被传递给结构体的构造函数，作为实例成员 `multiplier` 的值。
@@ -52,8 +51,7 @@ print("six times three is \(threeTimesTable[6])")
>
> `TimesTable` 例子基于一个固定的数学公式，对 `threeTimesTable[someIndex]` 进行赋值操作并不合适，因此下标定义为只读的。
-
-## 下标用法
+## 下标用法 {#subscript-usage}
下标的确切含义取决于使用场景。下标通常作为访问集合，列表或序列中元素的快捷方式。你可以针对自己特定的类或结构体的功能来自由地以最恰当的方式实现下标。
@@ -66,14 +64,13 @@ numberOfLegs["bird"] = 2
上例定义一个名为 `numberOfLegs` 的变量，并用一个包含三对键值的字典字面量初始化它。`numberOfLegs` 字典的类型被推断为 `[String: Int]`。字典创建完成后，该例子通过下标将 `String` 类型的键 `bird` 和 `Int` 类型的值 `2` 添加到字典中。
-更多关于 `Dictionary` 下标的信息请参考 [读取和修改字典](./04_Collection_Types.html#accessing_and_modifying_a_dictionary)。
+更多关于 `Dictionary` 下标的信息请参考 [读取和修改字典](./04_Collection_Types.md#accessing_and_modifying_a_dictionary)。
> 注意
>
> Swift 的 `Dictionary` 类型的下标接受并返回可选类型的值。上例中的 `numberOfLegs` 字典通过下标返回的是一个 `Int?` 或者说“可选的 int”。`Dictionary` 类型之所以如此实现下标，是因为不是每个键都有个对应的值，同时这也提供了一种通过键删除对应值的方式，只需将键对应的值赋值为 `nil` 即可。
-
-## 下标选项
+## 下标选项 {#subscript-options}
下标可以接受任意数量的入参，并且这些入参可以是任意类型。下标的返回值也可以是任意类型。下标可以使用变量参数和可变参数，但不能使用输入输出参数，也不能给参数设置默认值。
@@ -106,7 +103,7 @@ struct Matrix {
}
```
-`Matrix` 提供了一个接受两个入参的构造方法，入参分别是 `rows` 和 `columns`，创建了一个足够容纳 `rows * columns` 个 `Double` 类型的值的数组。通过传入数组长度和初始值 `0.0` 到数组的构造器，将矩阵中每个位置的值初始化为 `0.0`。关于数组的这种构造方法请参考 [创建一个带有默认值的数组](./04_Collection_Types.html#creating_an_array_with_a_default_value)。
+`Matrix` 提供了一个接受两个入参的构造方法，入参分别是 `rows` 和 `columns`，创建了一个足够容纳 `rows * columns` 个 `Double` 类型的值的数组。通过传入数组长度和初始值 `0.0` 到数组的构造器，将矩阵中每个位置的值初始化为 `0.0`。关于数组的这种构造方法请参考 [创建一个带有默认值的数组](./04_Collection_Types.md#creating_an_array_with_a_default_value)。
你可以通过传入合适的 `row` 和 `column` 的数量来构造一个新的 `Matrix` 实例：
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index 32d33fd6..c312f190 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -6,8 +6,7 @@
可以为类中继承来的属性添加属性观察器，这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性还是计算型属性。
-
-## 定义一个基类
+## 定义一个基类 {#defining-a-base-class}
不继承于其它类的类，称之为*基类*。
@@ -26,7 +25,7 @@ class Vehicle {
return "traveling at \(currentSpeed) miles per hour"
}
func makeNoise() {
- // 什么也不做-因为车辆不一定会有噪音
+ // 什么也不做——因为车辆不一定会有噪音
}
}
```
@@ -41,13 +40,12 @@ let someVehicle = Vehicle()
```swift
print("Vehicle: \(someVehicle.description)")
-// 打印 "Vehicle: traveling at 0.0 miles per hour"
+// 打印“Vehicle: traveling at 0.0 miles per hour”
```
`Vehicle` 类定义了一个具有通用特性的车辆类，但实际上对于它本身来说没什么用处。为了让它变得更加有用，还需要进一步完善它，从而能够描述一个具体类型的车辆。
-
-## 子类生成
+## 子类生成 {#subclassing}
*子类生成*指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以进一步完善。你还可以为子类添加新的特性。
@@ -83,7 +81,7 @@ bicycle.hasBasket = true
```swift
bicycle.currentSpeed = 15.0
print("Bicycle: \(bicycle.description)")
-// 打印 "Bicycle: traveling at 15.0 miles per hour"
+// 打印“Bicycle: traveling at 15.0 miles per hour”
```
子类还可以继续被其它类继承，下面的示例为 `Bicycle` 创建了一个名为 `Tandem`（双人自行车）的子类：
@@ -104,11 +102,10 @@ tandem.hasBasket = true
tandem.currentNumberOfPassengers = 2
tandem.currentSpeed = 22.0
print("Tandem: \(tandem.description)")
-// 打印："Tandem: traveling at 22.0 miles per hour"
+// 打印：“Tandem: traveling at 22.0 miles per hour”
```
-
-## 重写
+## 重写 {#overriding}
子类可以为继承来的实例方法，类方法，实例属性，类属性，或下标提供自己定制的实现。我们把这种行为叫*重写*。
@@ -116,7 +113,7 @@ print("Tandem: \(tandem.description)")
`override` 关键字会提醒 Swift 编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。
-### 访问超类的方法，属性及下标
+### 访问超类的方法，属性及下标 {#accessing-superclass-methods-properties-and-subscripts}
当你在子类中重写超类的方法，属性或下标时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以完善已有实现的行为，或在一个继承来的变量中存储一个修改过的值。
@@ -126,7 +123,7 @@ print("Tandem: \(tandem.description)")
* 在属性 `someProperty` 的 getter 或 setter 的重写实现中，可以通过 `super.someProperty` 来访问超类版本的 `someProperty` 属性。
* 在下标的重写实现中，可以通过 `super[someIndex]` 来访问超类版本中的相同下标。
-### 重写方法
+### 重写方法 {#overriding-methods}
在子类中，你可以重写继承来的实例方法或类方法，提供一个定制或替代的方法实现。
@@ -145,14 +142,14 @@ class Train: Vehicle {
```swift
let train = Train()
train.makeNoise()
-// 打印 "Choo Choo"
+// 打印“Choo Choo”
```
-### 重写属性
+### 重写属性 {#overriding-properties}
你可以重写继承来的实例属性或类型属性，提供自己定制的 getter 和 setter，或添加属性观察器，使重写的属性可以观察到底层的属性值什么时候发生改变。
-#### 重写属性的 Getters 和 Setters
+#### 重写属性的 Getters 和 Setters {#overriding-property-etters-and-setters}
你可以提供定制的 getter（或 setter）来重写任何一个继承来的属性，无论这个属性是存储型还是计算型属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必须将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。
@@ -182,11 +179,10 @@ let car = Car()
car.currentSpeed = 25.0
car.gear = 3
print("Car: \(car.description)")
-// 打印 "Car: traveling at 25.0 miles per hour in gear 3"
+// 打印“Car: traveling at 25.0 miles per hour in gear 3”
```
-
-#### 重写属性观察器
+#### 重写属性观察器 {#overriding-property-observers}
你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，无论被继承属性原本是如何实现的，当其属性值发生改变时，你就会被通知到。关于属性观察器的更多内容，请看[属性观察器](../chapter2/10_Properties.html#property_observers)。
@@ -213,14 +209,13 @@ class AutomaticCar: Car {
let automatic = AutomaticCar()
automatic.currentSpeed = 35.0
print("AutomaticCar: \(automatic.description)")
-// 打印 "AutomaticCar: traveling at 35.0 miles per hour in gear 4"
+// 打印“AutomaticCar: traveling at 35.0 miles per hour in gear 4”
```
-
-## 防止重写
+## 防止重写 {#preventing-overrides}
-你可以通过把方法，属性或下标标记为*`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 。这样的类是不可被继承的，试图继承这样的类会导致编译报错。
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index c4150025..111d9c79 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -4,11 +4,9 @@
你要通过定义*构造器*来实现构造过程，它就像用来创建特定类型新实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器没有返回值。它们的主要任务是保证某种类型的新实例在第一次使用前完成正确的初始化。
-类的实例也可以通过实现*析构器*来执行它释放之前自定义的清理工作。想了解更多关于析构器的内容，请参考[析构过程](./15_Deinitialization.html)。
+类的实例也可以通过实现*析构器*来执行它释放之前自定义的清理工作。想了解更多关于析构器的内容，请参考[析构过程](./15_Deinitialization.md)。
-
-
-## 存储属性的初始赋值
+## 存储属性的初始赋值 {#setting-initial-values-for-stored-properties}
类和结构体在创建实例时，必须为所有存储型属性设置合适的初始值。存储型属性的值不能处于一个未知的状态。
@@ -18,8 +16,7 @@
>
> 当你为存储型属性分配默认值或者在构造器中为设置初始值时，它们的值是被直接设置的，不会触发任何属性观察者。
-
-### 构造器
+### 构造器 {#initializers}
构造器在创建某个特定类型的新实例时被调用。它的最简形式类似于一个不带任何形参的实例方法，以关键字 `init` 命名：
@@ -40,13 +37,12 @@ struct Fahrenheit {
}
var f = Fahrenheit()
print("The default temperature is \(f.temperature)° Fahrenheit")
-// 打印 "The default temperature is 32.0° Fahrenheit"
+// 打印“The default temperature is 32.0° Fahrenheit”
```
这个结构体定义了一个不带形参的构造器 `init`，并在里面将存储型属性 `temperature` 的值初始化为 `32.0`（华氏温度下水的冰点）。
-
-### 默认属性值
+### 默认属性值 {#default-property-values}
如前所述，你可以在构造器中为存储型属性设置初始值。同样，你也可以在属性声明时为其设置默认值。
@@ -62,14 +58,11 @@ struct Fahrenheit {
}
```
-
-
-## 自定义构造过程
+## 自定义构造过程 {#customizing-initialization}
你可以通过输入形参和可选属性类型来自定义构造过程，也可以在构造过程中分配常量属性。这些都将在后面章节中提到。
-
-### 形参的构造过程
+### 形参的构造过程 {#initialization-parameters}
自定义构造过程时，可以在定义中提供*构造形参*，指定其值的类型和名字。构造形参的功能和语法跟函数和方法的形参相同。
@@ -94,8 +87,7 @@ let freezingPointOfWater = Celsius(fromKelvin: 273.15)
第一个构造器拥有一个构造形参，其实参标签为 `fromFahrenheit`，形参命名为 `fahrenheit`；第二个构造器也拥有一个构造形参，其实参标签为 `fromKelvin`，形参命名为 `kelvin`。这两个构造器都将单一的实参转换成摄氏温度值，并保存在属性 `temperatureInCelsius` 中。
-
-### 形参命名和实参标签
+### 形参命名和实参标签 {#parameter-names-and-argument-labels}
跟函数和方法形参相同，构造形参可以同时使用在构造器里使用的形参命名和一个外部调用构造器时使用的实参标签。
@@ -135,8 +127,7 @@ let veryGreen = Color(0.0, 1.0, 0.0)
// 报编译期错误-需要实参标签
```
-
-### 不带实参标签的构造器形参
+### 不带实参标签的构造器形参 {#initializer-parameters-without-external-names}
如果你不希望构造器的某个形参使用实参标签，可以使用下划线（`_`）来代替显式的实参标签来重写默认行为。
@@ -162,11 +153,9 @@ let bodyTemperature = Celsius(37.0)
构造器调用 `Celsius(37.0)` 意图明确，不需要实参标签。因此适合使用 `init(_ celsius: Double)` 这样的构造器，从而可以通过提供未命名的 `Double` 值来调用构造器。
-
+### 可选属性类型 {#optional-property-types}
-### 可选属性类型
-
-如果你自定义的类型有一个逻辑上允许值为空的存储型属性——无论是因为它无法在初始化时赋值，还是因为它在之后某个时机可以赋值为空——都需要将它y声明为 `可选类型`。可选类型的属性将自动初始化为 `nil`，表示这个属性是特意在构造过程设置为空。
+如果你自定义的类型有一个逻辑上允许值为空的存储型属性——无论是因为它无法在初始化时赋值，还是因为它在之后某个时机可以赋值为空——都需要将它声明为 `可选类型`。可选类型的属性将自动初始化为 `nil`，表示这个属性是特意在构造过程设置为空。
下面例子中定义了类 `SurveyQuestion`，它包含一个可选 ` String` 属性 `response`：
@@ -184,14 +173,13 @@ class SurveyQuestion {
let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
cheeseQuestion.ask()
-// 打印 "Do you like cheese?"
+// 打印“Do you like cheese?”
cheeseQuestion.response = "Yes, I do like cheese."
```
调查问题的答案在询问前是无法确定的，因此我们将属性 `response` 声明为 `String?` 类型，或者说是 “可选类型 `String`“。当 `SurveyQuestion` 的实例初始化时，它将自动赋值为 `nil`，表明“暂时还没有字符“。
-
-### 构造过程中常量属性的赋值
+### 构造过程中常量属性的赋值 {#assigning-constant-properties-during-initialization}
你可以在构造过程中的任意时间点给常量属性赋值，只要在构造过程结束时它设置成确定的值。一旦常量属性被赋值，它将永远不可更改。
@@ -214,12 +202,11 @@ class SurveyQuestion {
}
let beetsQuestion = SurveyQuestion(text: "How about beets?")
beetsQuestion.ask()
-// 打印 "How about beets?"
+// 打印“How about beets?”
beetsQuestion.response = "I also like beets. (But not with cheese.)"
```
-
-## 默认构造器
+## 默认构造器 {#default-initializers}
如果结构体或类为所有属性提供了默认值，又没有提供任何自定义的构造器，那么 Swift 会给这些结构体或类提供一个*默认构造器*。这个默认构造器将简单地创建一个所有属性值都设置为它们默认值的实例。
@@ -236,8 +223,7 @@ var item = ShoppingListItem()
由于 `ShoppingListItem` 类中的所有属性都有默认值，且它是没有父类的基类，它将自动获得一个将为所有属性设置默认值的并创建实例的默认构造器（由于 `name` 属性是可选 `String` 类型，它将接收一个默认 `nil` 的默认值，尽管代码中没有写出这个值）。上面例子中使用默认构造器创造了一个 `ShoppingListItem` 类的实例（使用 `ShoppingListItem()` 形式的构造器语法），并将其赋值给变量 `item`。
-
-### 结构体的逐一成员构造器
+### 结构体的逐一成员构造器 {#memberwise-initializers-for-structure-types}
结构体如果没有定义任何自定义构造器，它们将自动获得一个*逐一成员构造器（memberwise initializer）*。不像默认构造器，即使存储型属性没有默认值，结构体也能会获得逐一成员构造器。
@@ -254,12 +240,11 @@ struct Size {
let twoByTwo = Size(width: 2.0, height: 2.0)
```
-
-## 值类型的构造器代理
+## 值类型的构造器代理 {#initializer-delegation-for-value-types}
构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为*构造器代理*，它能避免多个构造器间的代码重复。
-构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给自己的其它构造器。类则不同，它可以继承自其它类（请参考[继承](./13_Inheritance.html)）。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
+构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给自己的其它构造器。类则不同，它可以继承自其它类（请参考[继承](./13_Inheritance.md)）。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
对于值类型，你可以使用 `self.init` 在自定义的构造器中引用相同类型中的其它构造器。并且你只能在构造器内部调用 `self.init`。
@@ -267,7 +252,7 @@ let twoByTwo = Size(width: 2.0, height: 2.0)
> 注意
>
-> 假如你希望默认构造器、逐一成员构造器以及你自己的自定义构造器都能用来创建实例，可以将自定义的构造器写到扩展（`extension`）中，而不是写在值类型的原始定义中。想查看更多内容，请查看[扩展](./20_Extensions.html)章节。
+> 假如你希望默认构造器、逐一成员构造器以及你自己的自定义构造器都能用来创建实例，可以将自定义的构造器写到扩展（`extension`）中，而不是写在值类型的原始定义中。想查看更多内容，请查看[扩展](./20_Extensions.md)章节。
下面例子定义一个自定义结构体 `Rect`，用来代表几何矩形。这个例子需要两个辅助的结构体 `Size` 和 `Point`，它们各自为其所有的属性提供了默认初始值 `0.0`。
@@ -329,16 +314,15 @@ let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
> 注意
>
-> 如果你想用另外一种不需要自己定义 `init()` 和 `init(origin:size:)` 的方式来实现这个例子，请参考[扩展](./21_Extensions.html)。
+> 如果你想用另外一种不需要自己定义 `init()` 和 `init(origin:size:)` 的方式来实现这个例子，请参考[扩展](./21_Extensions.md)。
-
-## 类的继承和构造过程
+## 类的继承和构造过程 {#class-inheritance-and-initialization}
类里面的所有存储型属性——包括所有继承自父类的属性——都*必须*在构造过程中设置初始值。
+
Swift 为类类型提供了两种构造器来确保实例中所有存储型属性都能获得初始值，它们被称为指定构造器和便利构造器。
-
-### 指定构造器和便利构造器
+### 指定构造器和便利构造器 {#designated-initializers-and-convenience-initializers}
*指定构造器*是类中最主要的构造器。一个指定构造器将初始化类中提供的所有属性，并调用合适的父类构造器让构造过程沿着父类链继续往上进行。
@@ -350,8 +334,7 @@ Swift 为类类型提供了两种构造器来确保实例中所有存储型属
你应当只在必要的时候为类提供便利构造器，比方说某种情况下通过使用便利构造器来快捷调用某个指定构造器，能够节省更多开发时间并让类的构造过程更清晰明了。
-
-### 指定构造器和便利构造器的语法
+### 指定构造器和便利构造器的语法 {#syntax-for-designated-and-convenience-initializers}
类的指定构造器的写法跟值类型简单构造器一样：
@@ -369,8 +352,7 @@ convenience init(parameters) {
}
```
-
-### 类类型的构造器代理
+### 类类型的构造器代理 {#initializer-delegation-for-class-types}
为了简化指定构造器和便利构造器之间的调用关系，Swift 构造器之间的代理调用遵循以下三条规则：
@@ -407,9 +389,7 @@ convenience init(parameters) {
-i
-
-### 两段式构造过程
+### 两段式构造过程 {#two-phase-initialization}
Swift 中类的构造过程包含两个阶段。第一个阶段，类中的每个存储型属性赋一个初始值。当每个存储型属性的初始值被赋值后，第二阶段开始，它给每个类一次机会，在新实例准备使用之前进一步自定义它们的存储型属性。
@@ -479,8 +459,7 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造
最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的自定义操作。
-
-### 构造器的继承和重写
+### 构造器的继承和重写 {#initializer-inheritance-and-overriding}
跟 Objective-C 中的子类不同，Swift 中的子类默认情况下不会继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更精细的子类继承，而在用来创建子类时的新实例时没有完全或错误被初始化。
@@ -500,7 +479,7 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造
相反，如果你编写了一个和父类便利构造器相匹配的子类构造器，由于子类不能直接调用父类的便利构造器（每个规则都在上文[类的构造器代理规则](#initializer_delegation_for_class_types)有所描述），因此，严格意义上来讲，你的子类并未对一个父类构造器提供重写。最后的结果就是，你在子类中“重写”一个父类便利构造器时，不需要加 `override` 修饰符。
-在下面的例子中定义了一个叫 Vehicle 的基类。基类中声明了一个存储型属性 numberOfWheels，它是默认值为 Int 类型的 0。numberOfWheels 属性用在一个描述车辆特征 String 类型为 descrpiption 的计算型属性中：
+在下面的例子中定义了一个叫 `Vehicle` 的基类。基类中声明了一个存储型属性 `numberOfWheels`，它是默认值为 `Int` 类型的 `0`。`numberOfWheels` 属性用在一个描述车辆特征 `String` 类型为 `descrpiption` 的计算型属性中：
```swift
class Vehicle {
@@ -511,8 +490,7 @@ class Vehicle {
}
```
-`Vehicle` 类只为存储型属性提供默认值，也没有提供自定义构造器。因此，它会自动获得一个默认构造器，具体内容请参考[默认构造器](#default_initializers)。默认构造器（如果有的话）总是类中的指定构造器，可以用于创建 `numberOfWheels` 为 `0` 的 `Vehicle`
-实例：
+`Vehicle` 类只为存储型属性提供默认值，也没有提供自定义构造器。因此，它会自动获得一个默认构造器，具体内容请参考[默认构造器](#default_initializers)。默认构造器（如果有的话）总是类中的指定构造器，可以用于创建 `numberOfWheels` 为 `0` 的 `Vehicle` 实例：
```swift
let vehicle = Vehicle()
@@ -540,10 +518,10 @@ class Bicycle: Vehicle {
```swift
let bicycle = Bicycle()
print("Bicycle: \(bicycle.description)")
-// 打印 "Bicycle: 2 wheel(s)"
+// 打印“Bicycle: 2 wheel(s)”
```
-如果父类的构造器没有在阶段 2 过程中做自定义操作，并且父类有一个无参数的自定义构造器。你可以省略 `super.init()` 的调用在所有父类的存储属性赋值之后。
+如果子类的构造器没有在阶段 2 过程中做自定义操作，并且父类有一个无参数的自定义构造器。你可以在所有父类的存储属性赋值之后省略 `super.init()` 的调用。
这个例子定义了另一个 `Vehicle` 的子类 `Hoverboard` ，只设置它的 `color` 属性。这个构造器依赖隐式调用父类的构造器来完成，而不是显示调用 `super.init()`。
@@ -572,9 +550,7 @@ print("Hoverboard: \(hoverboard.description)")
>
> 子类可以在构造过程修改继承来的变量属性，但是不能修改继承来的常量属性。
-
-
-### 构造器的自动继承
+### 构造器的自动继承 {#automatic-initializer-inheritance}
如上所述，子类在默认情况下不会继承父类的构造器。但是如果满足特定条件，父类构造器是可以被自动继承的。事实上，这意味着对于许多常见场景你不必重写父类的构造器，并且可以在安全的情况下以最小的代价继承父类的构造器。
@@ -594,8 +570,7 @@ print("Hoverboard: \(hoverboard.description)")
>
> 子类可以将父类的指定构造器实现为便利构造器来满足规则 2。
-
-### 指定构造器和便利构造器实践
+### 指定构造器和便利构造器实践 {#designated-and-convenience-initializers-in-action}
接下来的例子将在实践中展示指定构造器、便利构造器以及构造器的自动继承。这个例子定义了包含三个类 `Food`、`RecipeIngredient` 以及 `ShoppingListItem` 的层级结构，并将演示它们的构造器是如何相互作用的。
@@ -716,8 +691,7 @@ for item in breakfastList {
如上所述，例子中通过字面量方式创建了一个数组 `breakfastList`，它包含了三个 `ShoppingListItem` 实例，因此数组的类型也能被自动推导为 `[ShoppingListItem]`。在数组创建完之后，数组中第一个 `ShoppingListItem` 实例的名字从 `[Unnamed]` 更改为 `Orange juice`，并标记状态为已购买。打印数组中每个元素的描述显示了它们都已按照预期被赋值。
-
-## 可失败构造器
+## 可失败构造器 {#failable-initializers}
有时，定义一个构造器可失败的类，结构体或者枚举是很有用的。这里所指的“失败” 指的是，如给构造器传入无效的形参，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。
@@ -742,7 +716,7 @@ let pi = 3.14159
if let valueMaintained = Int(exactly: wholeNumber) {
print("\(wholeNumber) conversion to Int maintains value of \(valueMaintained)")
}
-// 打印 "12345.0 conversion to Int maintains value of 12345"
+// 打印“12345.0 conversion to Int maintains value of 12345”
let valueChanged = Int(exactly: pi)
// valueChanged 是 Int? 类型，不是 Int 类型
@@ -750,7 +724,7 @@ let valueChanged = Int(exactly: pi)
if valueChanged == nil {
print("\(pi) conversion to Int does not maintain value")
}
-// 打印 "3.14159 conversion to Int does not maintain value"
+// 打印“3.14159 conversion to Int does not maintain value”
```
下例中，定义了一个名为 `Animal` 的结构体，其中有一个名为 `species` 的 `String` 类型的常量属性。同时该结构体还定义了一个接受一个名为 `species` 的 `String` 类型形参的可失败构造器。这个可失败构造器检查传入的`species` 值是否为一个空字符串。如果为空字符串，则构造失败。否则，`species` 属性被赋值，构造成功。
@@ -776,7 +750,7 @@ let someCreature = Animal(species: "Giraffe")
if let giraffe = someCreature {
print("An animal was initialized with a species of \(giraffe.species)")
}
-// 打印 "An animal was initialized with a species of Giraffe"
+// 打印“An animal was initialized with a species of Giraffe”
```
如果你给该可失败构造器传入一个空字符串到形参 `species`，则会导致构造失败：
@@ -788,15 +762,14 @@ let anonymousCreature = Animal(species: "")
if anonymousCreature == nil {
print("The anonymous creature could not be initialized")
}
-// 打印 "The anonymous creature could not be initialized"
+// 打印“The anonymous creature could not be initialized”
```
> 注意
>
> 检查空字符串的值（如 `""`，而不是 `"Giraffe"` ）和检查值为 `nil` 的可选类型的字符串是两个完全不同的概念。上例中的空字符串（`""`）其实是一个有效的，非可选类型的字符串。这里我们之所以让 `Animal` 的可失败构造器构造失败，只是因为对于 `Animal` 这个类的 `species` 属性来说，它更适合有一个具体的值，而不是空字符串。
-
-### 枚举类型的可失败构造器
+### 枚举类型的可失败构造器 {#failable-nitializers-for-enumerations}
你可以通过一个带一个或多个形参的可失败构造器来获取枚举类型中特定的枚举成员。如果提供的形参无法匹配任何枚举成员，则构造失败。
@@ -827,17 +800,16 @@ let fahrenheitUnit = TemperatureUnit(symbol: "F")
if fahrenheitUnit != nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
-// 打印 "This is a defined temperature unit, so initialization succeeded."
+// 打印“This is a defined temperature unit, so initialization succeeded.”
let unknownUnit = TemperatureUnit(symbol: "X")
if unknownUnit == nil {
print("This is not a defined temperature unit, so initialization failed.")
}
-// 打印 "This is not a defined temperature unit, so initialization failed."
+// 打印“This is not a defined temperature unit, so initialization failed.”
```
-
-### 带原始值的枚举类型的可失败构造器
+### 带原始值的枚举类型的可失败构造器 {#failable-initializers-for-enumerations-with-raw-values}
带原始值的枚举类型会自带一个可失败构造器 `init?(rawValue:)`，该可失败构造器有一个合适的原始值类型的 `rawValue` 形参，选择找到的相匹配的枚举成员，找不到则构造失败。
@@ -852,19 +824,18 @@ let fahrenheitUnit = TemperatureUnit(rawValue: "F")
if fahrenheitUnit != nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
-// 打印 "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.")
}
-// 打印 "This is not a defined temperature unit, so initialization failed."
+// 打印“This is not a defined temperature unit, so initialization failed.”
```
-
-### 构造失败的传递
+### 构造失败的传递 {#propagation-of-initialization-failure}
-类，结构体，枚举的可失败构造器可以横向代理到它们自己其他的可失败构造器。类似的，子类的可失败构造器也能向上代理到父类的可失败构造器。
+类、结构体、枚举的可失败构造器可以横向代理到它们自己其他的可失败构造器。类似的，子类的可失败构造器也能向上代理到父类的可失败构造器。
无论是向上代理还是横向代理，如果你代理到的其他可失败构造器触发构造失败，整个构造过程将立即终止，接下来的任何构造代码不会再被执行。
@@ -901,7 +872,7 @@ class CartItem: Product {
if let twoSocks = CartItem(name: "sock", quantity: 2) {
print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
}
-// 打印 "Item: sock, quantity: 2"
+// 打印“Item: sock, quantity: 2”
```
倘若你以一个值为 0 的 `quantity` 来创建一个 `CartItem` 实例，那么将导致 `CartItem` 构造器失败：
@@ -912,7 +883,7 @@ 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”
```
同样地，如果你尝试传入一个值为空字符串的 `name` 来创建一个 `CartItem` 实例，那么将导致父类 `Product` 的构造过程失败：
@@ -923,11 +894,10 @@ 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”
```
-
-### 重写一个可失败构造器
+### 重写一个可失败构造器 {#overriding-a-failable-initializer}
如同其它的构造器，你可以在子类中重写父类的可失败构造器。或者你也可以用子类的非可失败构造器重写一个父类的可失败构造器。这使你可以定义一个不会构造失败的子类，即使父类的构造器允许构造失败。
@@ -985,15 +955,13 @@ class UntitledDocument: Document {
在这个例子中，如果在调用父类的可失败构造器 `init?(name:)` 时传入的是空字符串，那么强制解包操作会引发运行时错误。不过，因为这里是通过字符串常量来调用它，构造器不会失败，所以并不会发生运行时错误。
-
-### init! 可失败构造器
+### init! 可失败构造器 {#the-init!-failable-initializer}
通常来说我们通过在 `init` 关键字后添加问号的方式（`init?`）来定义一个可失败构造器，但你也可以通过在 `init` 后面添加感叹号的方式来定义一个可失败构造器（`init!`），该可失败构造器将会构建一个对应类型的隐式解包可选类型的对象。
你可以在 `init?` 中代理到 `init!`，反之亦然。你也可以用 `init?` 重写 `init!`，反之亦然。你还可以用 `init` 代理到 `init!`，不过，一旦 `init!` 构造失败，则会触发一个断言。
-
-## 必要构造器
+## 必要构造器 {#required-initializers}
在类的构造器前添加 `required` 修饰符表明所有该类的子类都必须实现该构造器：
@@ -1019,8 +987,7 @@ class SomeSubclass: SomeClass {
>
> 如果子类继承的构造器能满足必要构造器的要求，则无须在子类中显式提供必要构造器的实现。
-
-## 通过闭包或函数设置属性的默认值
+## 通过闭包或函数设置属性的默认值 {#setting-a-default-property-value-with-a-closure-or-function}
如果某个存储型属性的默认值需要一些自定义或设置，你可以使用闭包或全局函数为其提供定制的默认值。每当某个属性所在类型的新实例被构造时，对应的闭包或函数会被调用，而它们的返回值会当做默认值赋值给这个属性。
@@ -1077,7 +1044,7 @@ struct Chessboard {
```swift
let board = Chessboard()
print(board.squareIsBlackAt(row: 0, column: 1))
-// 打印 "true"
+// 打印“true”
print(board.squareIsBlackAt(row: 7, column: 7))
-// 打印 "false”
+// 打印“false”
```
diff --git a/source/chapter2/15_Deinitialization.md b/source/chapter2/15_Deinitialization.md
index 112e6dd6..f17efacb 100755
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -2,10 +2,9 @@
*析构器*只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字 `deinit` 来标示，类似于构造器要用 `init` 来标示。
-
-## 析构过程原理
+## 析构过程原理 {#how-deinitialization-works}
-Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](./23_Automatic_Reference_Counting.html)章节中所讲述，Swift 通过*自动引用计数（ARC)* 处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。
+Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](./23_Automatic_Reference_Counting.md)章节中所讲述，Swift 通过*自动引用计数（ARC)* 处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。
在类的定义中，每个类最多只能有一个析构器，而且析构器不带任何参数和圆括号，如下所示：
@@ -19,8 +18,7 @@ deinit {
因为直到实例的析构器被调用后，实例才会被释放，所以析构器可以访问实例的所有属性，并且可以根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件）。
-
-## 析构器实践
+## 析构器实践 {#deinitializers-in-action}
这是一个析构器实践的例子。这个例子描述了一个简单的游戏，这里定义了两种新类型，分别是 `Bank` 和 `Player`。`Bank` 类管理一种虚拟硬币，确保流通的硬币数量永远不可能超过 10,000。在游戏中有且只能有一个 `Bank` 存在，因此 `Bank` 用类来实现，并使用类型属性和类型方法来存储和管理其当前状态。
@@ -68,9 +66,9 @@ class Player {
```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"
+// 打印“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"
+// 打印“There are now 9900 coins left in the bank”
```
创建一个 `Player` 实例的时候，会向 `Bank` 对象申请得到 100 个硬币，前提是有足够的硬币可用。这个 `Player` 实例存储在一个名为 `playerOne` 的可选类型的变量中。这里使用了一个可选类型的变量，是因为玩家可以随时离开游戏，设置为可选使你可以追踪玩家当前是否在游戏中。
@@ -80,9 +78,9 @@ print("There are now \(Bank.coinsInBank) coins left in the bank")
```swift
playerOne!.win(coins: 2_000)
print("PlayerOne won 2000 coins & now has \(playerOne!.coinsInPurse) coins")
-// 打印 "PlayerOne won 2000 coins & now has 2100 coins"
+// 打印“PlayerOne won 2000 coins & now has 2100 coins”
print("The bank now only has \(Bank.coinsInBank) coins left")
-// 打印 "The bank now only has 7900 coins left"
+// 打印“The bank now only has 7900 coins left”
```
在这里，玩家已经赢得了 2,000 枚硬币，所以玩家的钱包中现在有 2,100 枚硬币，而 `Bank` 对象只剩余 7,900 枚硬币。
@@ -90,9 +88,9 @@ print("The bank now only has \(Bank.coinsInBank) coins left")
```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` 实例，因此该实例会被释放，以便回收内存。在这之前，该实例的析构器被自动调用，玩家的硬币被返还给银行。
diff --git a/source/chapter2/16_Optional_Chaining.md b/source/chapter2/16_Optional_Chaining.md
index e9e4945c..26942c7b 100755
--- a/source/chapter2/16_Optional_Chaining.md
+++ b/source/chapter2/16_Optional_Chaining.md
@@ -1,383 +1,374 @@
-# 可选链式调用
-
-*可选链式调用*是一种可以在当前值可能为 `nil` 的可选值上请求和调用属性、方法及下标的方法。如果可选值有值，那么调用就会成功；如果可选值是 `nil`，那么调用将返回 `nil`。多个调用可以连接在一起形成一个调用链，如果其中任何一个节点为 `nil`，整个调用链都会失败，即返回 `nil`。
-
-> 注意
->
-> Swift 的可选链式调用和 Objective-C 中向 `nil` 发送消息有些相像，但是 Swift 的可选链式调用可以应用于任意类型，并且能检查调用是否成功。
-
-
-## 使用可选链式调用代替强制展开
-
-通过在想调用的属性、方法，或下标的可选值后面放一个问号（`?`），可以定义一个可选链。这一点很像在可选值后面放一个叹号（`!`）来强制展开它的值。它们的主要区别在于当可选值为空时可选链式调用只会调用失败，然而强制展开将会触发运行时错误。
-
-为了反映可选链式调用可以在空值（`nil`）上调用的事实，不论这个调用的属性、方法及下标返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来判断你的可选链式调用是否调用成功，如果调用有返回值则说明调用成功，返回 `nil` 则说明调用失败。
-
-这里需要特别指出，可选链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可选值。例如，使用可选链式调用访问属性，当可选链式调用成功时，如果属性原本的返回结果是 `Int` 类型，则会变为 `Int?` 类型。
-
-下面几段代码将解释可选链式调用和强制展开的不同。
-
-首先定义两个类 `Person` 和 `Residence`：
-
-```swift
-class Person {
- var residence: Residence?
-}
-
-class Residence {
- var numberOfRooms = 1
-}
-```
-
-`Residence` 有一个 `Int` 类型的属性 `numberOfRooms`，其默认值为 `1`。`Person` 具有一个可选的 `residence` 属性，其类型为 `Residence?`。
-
-假如你创建了一个新的 `Person` 实例，它的 `residence` 属性由于是可选类型而将被初始化为 `nil`，在下面的代码中，`john` 有一个值为 `nil` 的 `residence` 属性：
-
-```swift
-let john = Person()
-```
-
-如果使用叹号（`!`）强制展开获得这个 `john` 的 `residence` 属性中的 `numberOfRooms` 值，会触发运行时错误，因为这时 `residence` 没有可以展开的值：
-
-```swift
-let roomCount = john.residence!.numberOfRooms
-// 这会引发运行时错误
-```
-
-`john.residence` 为非 `nil` 值的时候，上面的调用会成功，并且把 `roomCount` 设置为 `Int` 类型的房间数量。正如上面提到的，当 `residence` 为 `nil` 的时候，上面这段代码会触发运行时错误。
-
-可选链式调用提供了另一种访问 `numberOfRooms` 的方式，使用问号（`?`）来替代原来的叹号（`!`）：
-
-```swift
-if let roomCount = john.residence?.numberOfRooms {
- print("John's residence has \(roomCount) room(s).")
-} else {
- print("Unable to retrieve the number of rooms.")
-}
-// 打印 “Unable to retrieve the number of rooms.”
-```
-
-在 `residence` 后面添加问号之后，Swift 就会在 `residence` 不为 `nil` 的情况下访问 `numberOfRooms`。
-
-因为访问 `numberOfRooms` 有可能失败，可选链式调用会返回 `Int?` 类型，或称为“可选的 `Int`”。如上例所示，当 `residence` 为 `nil` 的时候，可选的 `Int` 将会为 `nil`，表明无法访问 `numberOfRooms`。访问成功时，可选的 `Int` 值会通过可选绑定展开，并赋值给非可选类型的 `roomCount` 常量。
-
-要注意的是，即使 `numberOfRooms` 是非可选的 `Int` 时，这一点也成立。只要使用可选链式调用就意味着 `numberOfRooms` 会返回一个 `Int?` 而不是 `Int`。
-
-可以将一个 `Residence` 的实例赋给 `john.residence`，这样它就不再是 `nil` 了：
-
-```swift
-john.residence = Residence()
-```
-
-`john.residence` 现在包含一个实际的 `Residence` 实例，而不再是 `nil`。如果你试图使用先前的可选链式调用访问 `numberOfRooms`，它现在将返回值为 `1` 的 `Int?` 类型的值：
-
-```swift
-if let roomCount = john.residence?.numberOfRooms {
- print("John's residence has \(roomCount) room(s).")
-} else {
- print("Unable to retrieve the number of rooms.")
-}
-// 打印 “John's residence has 1 room(s).”
-```
-
-
-## 为可选链式调用定义模型类
-
-通过使用可选链式调用可以调用多层属性、方法和下标。这样可以在复杂的模型中向下访问各种子属性，并且判断能否访问子属性的属性、方法和下标。
-
-下面这段代码定义了四个模型类，这些例子包括多层可选链式调用。为了方便说明，在 `Person` 和 `Residence` 的基础上增加了 `Room` 类和 `Address` 类，以及相关的属性、方法以及下标。
-
-`Person` 类的定义基本保持不变：
-
-```swift
-class Person {
- var residence: Residence?
-}
-```
-
-`Residence` 类比之前复杂些，增加了一个名为 `rooms` 的变量属性，该属性被初始化为 `[Room]` 类型的空数组：
-
-```swift
-class Residence {
- var rooms = [Room]()
- var numberOfRooms: Int {
- return rooms.count
- }
- subscript(i: Int) -> Room {
- get {
- return rooms[i]
- }
- set {
- rooms[i] = newValue
- }
- }
- func printNumberOfRooms() {
- print("The number of rooms is \(numberOfRooms)")
- }
- var address: Address?
-}
-```
-
-现在 `Residence` 有了一个存储 `Room` 实例的数组，`numberOfRooms` 属性被实现为计算型属性，而不是存储型属性。`numberOfRooms` 属性简单地返回 `rooms` 数组的 `count` 属性的值。
-
-`Residence` 还提供了访问 `rooms` 数组的快捷方式，即提供可读写的下标来访问 `rooms` 数组中指定位置的元素。
-
-此外，`Residence` 还提供了 `printNumberOfRooms` 方法，这个方法的作用是打印 `numberOfRooms` 的值。
-
-最后，`Residence` 还定义了一个可选属性 `address`，其类型为 `Address?`。`Address` 类的定义在下面会说明。
-
-`Room` 类是一个简单类，其实例被存储在 `rooms` 数组中。该类只包含一个属性 `name`，以及一个用于将该属性设置为适当的房间名的初始化函数：
-
-```swift
-class Room {
- let name: String
- init(name: String) { self.name = name }
-}
-```
-
-最后一个类是 `Address`，这个类有三个 `String?` 类型的可选属性。`buildingName` 以及 `buildingNumber` 属性分别表示大厦的名称和号码，第三个属性 `street` 表示大厦所在街道的名称：
-
-```swift
-class Address {
- var buildingName: String?
- var buildingNumber: String?
- var street: String?
- func buildingIdentifier() -> String? {
- if buildingName != nil {
- return buildingName
- } else if let buildingNumber = buildingNumber, let street = street {
- return "\(buildingNumber) \(street)"
- } else {
- return nil
- }
- }
-}
-```
-
-`Address` 类提供了 `buildingIdentifier()` 方法，返回值为 `String?`。 如果 `buildingName` 有值则返回 `buildingName`。或者，如果 `buildingNumber` 和 `street` 均有值，则返回两者拼接得到的字符串。否则，返回 `nil`。
-
-
-## 通过可选链式调用访问属性
-
-正如[使用可选链式调用代替强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping)中所述，可以通过可选链式调用在一个可选值上访问它的属性，并判断访问是否成功。
-
-使用前面定义过的类，创建一个 `Person` 实例，然后像之前一样，尝试访问 `numberOfRooms` 属性：
-
-```swift
-let john = Person()
-if let roomCount = john.residence?.numberOfRooms {
- print("John's residence has \(roomCount) room(s).")
-} else {
- print("Unable to retrieve the number of rooms.")
-}
-// 打印 “Unable to retrieve the number of rooms.”
-```
-
-因为 `john.residence` 为 `nil`，所以这个可选链式调用依旧会像先前一样失败。
-
-还可以通过可选链式调用来设置属性值：
-
-```swift
-let someAddress = Address()
-someAddress.buildingNumber = "29"
-someAddress.street = "Acacia Road"
-john.residence?.address = someAddress
-```
-
-在这个例子中，通过 `john.residence` 来设定 `address` 属性也会失败，因为 `john.residence` 当前为 `nil`。
-
-上面代码中的赋值过程是可选链式调用的一部分，这意味着可选链式调用失败时，等号右侧的代码不会被执行。对于上面的代码来说，很难验证这一点，因为像这样赋值一个常量没有任何副作用。下面的代码完成了同样的事情，但是它使用一个函数来创建 `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() {
- print("The number of rooms is \(numberOfRooms)")
-}
-```
-
-这个方法没有返回值。然而，没有返回值的方法具有隐式的返回类型 `Void`，如[无返回值函数](./06_Functions.html#functions_without_return_values)中所述。这意味着没有返回值的方法也会返回 `()`，或者说空的元组。
-
-如果在可选值上通过可选链式调用来调用这个方法，该方法的返回类型会是 `Void?`，而不是 `Void`，因为通过可选链式调用得到的返回值都是可选的。这样我们就可以使用 `if` 语句来判断能否成功调用 `printNumberOfRooms()` 方法，即使方法本身没有定义返回值。通过判断返回值是否为 `nil` 可以判断调用是否成功：
-
-```swift
-if john.residence?.printNumberOfRooms() != nil {
- print("It was possible to print the number of rooms.")
-} else {
- print("It was not possible to print the number of rooms.")
-}
-// 打印 “It was not possible to print the number of rooms.”
-```
-
-同样的，可以据此判断通过可选链式调用为属性赋值是否成功。在上面的[通过可选链式调用访问属性](#accessing_properties_through_optional_chaining)的例子中，我们尝试给 `john.residence` 中的 `address` 属性赋值，即使 `residence` 为 `nil`。通过可选链式调用给属性赋值会返回 `Void?`，通过判断返回值是否为 `nil` 就可以知道赋值是否成功：
-
-```swift
-if (john.residence?.address = someAddress) != nil {
- print("It was possible to set the address.")
-} else {
- print("It was not possible to set the address.")
-}
-// 打印 “It was not possible to set the address.”
-```
-
-
-## 通过可选链式调用访问下标
-
-通过可选链式调用，我们可以在一个可选值上访问下标，并且判断下标调用是否成功。
-
-> 注意
->
-> 通过可选链式调用访问可选值的下标时，应该将问号放在下标方括号的前面而不是后面。可选链式调用的问号一般直接跟在可选表达式的后面。
-
-下面这个例子用下标访问 `john.residence` 属性存储的 `Residence` 实例的 `rooms` 数组中的第一个房间的名称，因为 `john.residence` 为 `nil`，所以下标调用失败了：
-
-```swift
-if let firstRoomName = john.residence?[0].name {
- print("The first room name is \(firstRoomName).")
-} else {
- print("Unable to retrieve the first room name.")
-}
-// 打印 “Unable to retrieve the first room name.”
-```
-
-在这个例子中，问号直接放在 `john.residence` 的后面，并且在方括号的前面，因为 `john.residence` 是可选值。
-
-类似的，可以通过下标，用可选链式调用来赋值：
-
-```swift
-john.residence?[0] = Room(name: "Bathroom")
-```
-
-这次赋值同样会失败，因为 `residence` 目前是 `nil`。
-
-如果你创建一个 `Residence` 实例，并为其 `rooms` 数组添加一些 `Room` 实例，然后将 `Residence` 实例赋值给 `john.residence`，那就可以通过可选链和下标来访问数组中的元素：
-
-```swift
-let johnsHouse = Residence()
-johnsHouse.rooms.append(Room(name: "Living Room"))
-johnsHouse.rooms.append(Room(name: "Kitchen"))
-john.residence = johnsHouse
-
-if let firstRoomName = john.residence?[0].name {
- print("The first room name is \(firstRoomName).")
-} else {
- print("Unable to retrieve the first room name.")
-}
-// 打印 “The first room name is Living Room.”
-```
-
-
-### 访问可选类型的下标
-
-如果下标返回可选类型值，比如 Swift 中 `Dictionary` 类型的键的下标，可以在下标的结尾括号后面放一个问号来在其可选返回值上进行可选链式调用：
-
-```swift
-var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
-testScores["Dave"]?[0] = 91
-testScores["Bev"]?[0] += 1
-testScores["Brian"]?[0] = 72
-// "Dave" 数组现在是 [91, 82, 84]，"Bev" 数组现在是 [80, 94, 81]
-```
-
-上面的例子中定义了一个 `testScores` 数组，包含了两个键值对，分别把 `String` 类型的键映射到一个 `Int` 值的数组。这个例子用可选链式调用把 `"Dave"` 数组中第一个元素设为 `91`，把 `"Bev"` 数组的第一个元素 `+1`，然后尝试把 `"Brian"` 数组中的第一个元素设为 `72`。前两个调用成功，因为 `testScores` 字典中包含 `"Dave"` 和 `"Bev"` 这两个键。但是 `testScores` 字典中没有 `"Brian"` 这个键，所以第三个调用失败。
-
-
-## 连接多层可选链式调用
-
-可以通过连接多个可选链式调用在更深的模型层级中访问属性、方法以及下标。然而，多层可选链式调用不会增加返回值的可选层级。
-
-也就是说：
-
-+ 如果你访问的值不是可选的，可选链式调用将会返回可选值。
-+ 如果你访问的值就是可选的，可选链式调用不会让可选返回值变得“更可选”。
-
-因此：
-
-+ 通过可选链式调用访问一个 `Int` 值，将会返回 `Int?`，无论使用了多少层可选链式调用。
-+ 类似的，通过可选链式调用访问 `Int?` 值，依旧会返回 `Int?` 值，并不会返回 `Int??`。
-
-下面的例子尝试访问 `john` 中的 `residence` 属性中的 `address` 属性中的 `street` 属性。这里使用了两层可选链式调用，`residence` 以及 `address` 都是可选值：
-
-```swift
-if let johnsStreet = john.residence?.address?.street {
- print("John's street name is \(johnsStreet).")
-} else {
- print("Unable to retrieve the address.")
-}
-// 打印 “Unable to retrieve the address.”
-```
-
-`john.residence` 现在包含一个有效的 `Residence` 实例。然而，`john.residence.address` 的值当前为 `nil`。因此，调用 `john.residence?.address?.street` 会失败。
-
-需要注意的是，上面的例子中，`street` 的属性为 `String?`。`john.residence?.address?.street` 的返回值也依然是 `String?`，即使已经使用了两层可选链式调用。
-
-如果为 `john.residence.address` 赋值一个 `Address` 实例，并且为 `address` 中的 `street` 属性设置一个有效值，我们就能过通过可选链式调用来访问 `street` 属性：
-
-```swift
-let johnsAddress = Address()
-johnsAddress.buildingName = "The Larches"
-johnsAddress.street = "Laurel Street"
-john.residence?.address = johnsAddress
-
-if let johnsStreet = john.residence?.address?.street {
- print("John's street name is \(johnsStreet).")
-} else {
- print("Unable to retrieve the address.")
-}
-// 打印 “John's street name is Laurel Street.”
-```
-
-在上面的例子中，因为 `john.residence` 包含一个有效的 `Address` 实例，所以对 `john.residence` 的 `address` 属性赋值将会成功。
-
-
-## 在方法的可选返回值上进行可选链式调用
-
-上面的例子展示了如何在一个可选值上通过可选链式调用来获取它的属性值。我们还可以在一个可选值上通过可选链式调用来调用方法，并且可以根据需要继续在方法的可选返回值上进行可选链式调用。
-
-在下面的例子中，通过可选链式调用来调用 `Address` 的 `buildingIdentifier()` 方法。这个方法返回 `String?` 类型的值。如上所述，通过可选链式调用来调用该方法，最终的返回值依旧会是 `String?` 类型：
-
-```swift
-if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
- print("John's building identifier is \(buildingIdentifier).")
-}
-// 打印 “John's building identifier is The Larches.”
-```
-
-如果要在该方法的返回值上进行可选链式调用，在方法的圆括号后面加上问号即可：
-
-```swift
-if let beginsWithThe =
-
- john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
- if beginsWithThe {
- print("John's building identifier begins with \"The\".")
- } else {
- print("John's building identifier does not begin with \"The\".")
- }
-}
-// 打印 “John's building identifier begins with "The".”
-```
-
-> 注意
->
-> 在上面的例子中，在方法的圆括号后面加上问号是因为你要在 `buildingIdentifier()` 方法的可选返回值上进行可选链式调用，而不是 `buildingIdentifier()` 方法本身。
+# 可选链式调用
+
+*可选链式调用*是一种可以在当前值可能为 `nil` 的可选值上请求和调用属性、方法及下标的方法。如果可选值有值，那么调用就会成功；如果可选值是 `nil`，那么调用将返回 `nil`。多个调用可以连接在一起形成一个调用链，如果其中任何一个节点为 `nil`，整个调用链都会失败，即返回 `nil`。
+
+> 注意
+>
+> Swift 的可选链式调用和 Objective-C 中向 `nil` 发送消息有些相像，但是 Swift 的可选链式调用可以应用于任意类型，并且能检查调用是否成功。
+
+## 使用可选链式调用代替强制展开 {#optional-chaining-as-an-alternative-to-forced-unwrapping}
+
+通过在想调用的属性、方法，或下标的可选值后面放一个问号（`?`），可以定义一个可选链。这一点很像在可选值后面放一个叹号（`!`）来强制展开它的值。它们的主要区别在于当可选值为空时可选链式调用只会调用失败，然而强制展开将会触发运行时错误。
+
+为了反映可选链式调用可以在空值（`nil`）上调用的事实，不论这个调用的属性、方法及下标返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来判断你的可选链式调用是否调用成功，如果调用有返回值则说明调用成功，返回 `nil` 则说明调用失败。
+
+这里需要特别指出，可选链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可选值。例如，使用可选链式调用访问属性，当可选链式调用成功时，如果属性原本的返回结果是 `Int` 类型，则会变为 `Int?` 类型。
+
+下面几段代码将解释可选链式调用和强制展开的不同。
+
+首先定义两个类 `Person` 和 `Residence`：
+
+```swift
+class Person {
+ var residence: Residence?
+}
+
+class Residence {
+ var numberOfRooms = 1
+}
+```
+
+`Residence` 有一个 `Int` 类型的属性 `numberOfRooms`，其默认值为 `1`。`Person` 具有一个可选的 `residence` 属性，其类型为 `Residence?`。
+
+假如你创建了一个新的 `Person` 实例，它的 `residence` 属性由于是可选类型而将被初始化为 `nil`，在下面的代码中，`john` 有一个值为 `nil` 的 `residence` 属性：
+
+```swift
+let john = Person()
+```
+
+如果使用叹号（`!`）强制展开获得这个 `john` 的 `residence` 属性中的 `numberOfRooms` 值，会触发运行时错误，因为这时 `residence` 没有可以展开的值：
+
+```swift
+let roomCount = john.residence!.numberOfRooms
+// 这会引发运行时错误
+```
+
+`john.residence` 为非 `nil` 值的时候，上面的调用会成功，并且把 `roomCount` 设置为 `Int` 类型的房间数量。正如上面提到的，当 `residence` 为 `nil` 的时候，上面这段代码会触发运行时错误。
+
+可选链式调用提供了另一种访问 `numberOfRooms` 的方式，使用问号（`?`）来替代原来的叹号（`!`）：
+
+```swift
+if let roomCount = john.residence?.numberOfRooms {
+ print("John's residence has \(roomCount) room(s).")
+} else {
+ print("Unable to retrieve the number of rooms.")
+}
+// 打印“Unable to retrieve the number of rooms.”
+```
+
+在 `residence` 后面添加问号之后，Swift 就会在 `residence` 不为 `nil` 的情况下访问 `numberOfRooms`。
+
+因为访问 `numberOfRooms` 有可能失败，可选链式调用会返回 `Int?` 类型，或称为“可选的 `Int`”。如上例所示，当 `residence` 为 `nil` 的时候，可选的 `Int` 将会为 `nil`，表明无法访问 `numberOfRooms`。访问成功时，可选的 `Int` 值会通过可选绑定展开，并赋值给非可选类型的 `roomCount` 常量。
+
+要注意的是，即使 `numberOfRooms` 是非可选的 `Int` 时，这一点也成立。只要使用可选链式调用就意味着 `numberOfRooms` 会返回一个 `Int?` 而不是 `Int`。
+
+可以将一个 `Residence` 的实例赋给 `john.residence`，这样它就不再是 `nil` 了：
+
+```swift
+john.residence = Residence()
+```
+
+`john.residence` 现在包含一个实际的 `Residence` 实例，而不再是 `nil`。如果你试图使用先前的可选链式调用访问 `numberOfRooms`，它现在将返回值为 `1` 的 `Int?` 类型的值：
+
+```swift
+if let roomCount = john.residence?.numberOfRooms {
+ print("John's residence has \(roomCount) room(s).")
+} else {
+ print("Unable to retrieve the number of rooms.")
+}
+// 打印“John's residence has 1 room(s).”
+```
+
+## 为可选链式调用定义模型类 {#defining-model-classes-for-optional-chaining}
+
+通过使用可选链式调用可以调用多层属性、方法和下标。这样可以在复杂的模型中向下访问各种子属性，并且判断能否访问子属性的属性、方法和下标。
+
+下面这段代码定义了四个模型类，这些例子包括多层可选链式调用。为了方便说明，在 `Person` 和 `Residence` 的基础上增加了 `Room` 类和 `Address` 类，以及相关的属性、方法以及下标。
+
+`Person` 类的定义基本保持不变：
+
+```swift
+class Person {
+ var residence: Residence?
+}
+```
+
+`Residence` 类比之前复杂些，增加了一个名为 `rooms` 的变量属性，该属性被初始化为 `[Room]` 类型的空数组：
+
+```swift
+class Residence {
+ var rooms = [Room]()
+ var numberOfRooms: Int {
+ return rooms.count
+ }
+ subscript(i: Int) -> Room {
+ get {
+ return rooms[i]
+ }
+ set {
+ rooms[i] = newValue
+ }
+ }
+ func printNumberOfRooms() {
+ print("The number of rooms is \(numberOfRooms)")
+ }
+ var address: Address?
+}
+```
+
+现在 `Residence` 有了一个存储 `Room` 实例的数组，`numberOfRooms` 属性被实现为计算型属性，而不是存储型属性。`numberOfRooms` 属性简单地返回 `rooms` 数组的 `count` 属性的值。
+
+`Residence` 还提供了访问 `rooms` 数组的快捷方式，即提供可读写的下标来访问 `rooms` 数组中指定位置的元素。
+
+此外，`Residence` 还提供了 `printNumberOfRooms` 方法，这个方法的作用是打印 `numberOfRooms` 的值。
+
+最后，`Residence` 还定义了一个可选属性 `address`，其类型为 `Address?`。`Address` 类的定义在下面会说明。
+
+`Room` 类是一个简单类，其实例被存储在 `rooms` 数组中。该类只包含一个属性 `name`，以及一个用于将该属性设置为适当的房间名的初始化函数：
+
+```swift
+class Room {
+ let name: String
+ init(name: String) { self.name = name }
+}
+```
+
+最后一个类是 `Address`，这个类有三个 `String?` 类型的可选属性。`buildingName` 以及 `buildingNumber` 属性分别表示大厦的名称和号码，第三个属性 `street` 表示大厦所在街道的名称：
+
+```swift
+class Address {
+ var buildingName: String?
+ var buildingNumber: String?
+ var street: String?
+ func buildingIdentifier() -> String? {
+ if buildingName != nil {
+ return buildingName
+ } else if let buildingNumber = buildingNumber, let street = street {
+ return "\(buildingNumber) \(street)"
+ } else {
+ return nil
+ }
+ }
+}
+```
+
+`Address` 类提供了 `buildingIdentifier()` 方法，返回值为 `String?`。 如果 `buildingName` 有值则返回 `buildingName`。或者，如果 `buildingNumber` 和 `street` 均有值，则返回两者拼接得到的字符串。否则，返回 `nil`。
+
+## 通过可选链式调用访问属性 {#accessing-properties-through-optional-chaining}
+
+正如[使用可选链式调用代替强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping)中所述，可以通过可选链式调用在一个可选值上访问它的属性，并判断访问是否成功。
+
+使用前面定义过的类，创建一个 `Person` 实例，然后像之前一样，尝试访问 `numberOfRooms` 属性：
+
+```swift
+let john = Person()
+if let roomCount = john.residence?.numberOfRooms {
+ print("John's residence has \(roomCount) room(s).")
+} else {
+ print("Unable to retrieve the number of rooms.")
+}
+// 打印“Unable to retrieve the number of rooms.”
+```
+
+因为 `john.residence` 为 `nil`，所以这个可选链式调用依旧会像先前一样失败。
+
+还可以通过可选链式调用来设置属性值：
+
+```swift
+let someAddress = Address()
+someAddress.buildingNumber = "29"
+someAddress.street = "Acacia Road"
+john.residence?.address = someAddress
+```
+
+在这个例子中，通过 `john.residence` 来设定 `address` 属性也会失败，因为 `john.residence` 当前为 `nil`。
+
+上面代码中的赋值过程是可选链式调用的一部分，这意味着可选链式调用失败时，等号右侧的代码不会被执行。对于上面的代码来说，很难验证这一点，因为像这样赋值一个常量没有任何副作用。下面的代码完成了同样的事情，但是它使用一个函数来创建 `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()` 函数并未被执行。
+
+## 通过可选链式调用来调用方法 {#calling-methods-through-optional-chaining}
+
+可以通过可选链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
+
+`Residence` 类中的 `printNumberOfRooms()` 方法打印当前的 `numberOfRooms` 值，如下所示：
+
+```swift
+func printNumberOfRooms() {
+ print("The number of rooms is \(numberOfRooms)")
+}
+```
+
+这个方法没有返回值。然而，没有返回值的方法具有隐式的返回类型 `Void`，如[无返回值函数](./06_Functions.md#functions_without_return_values)中所述。这意味着没有返回值的方法也会返回 `()`，或者说空的元组。
+
+如果在可选值上通过可选链式调用来调用这个方法，该方法的返回类型会是 `Void?`，而不是 `Void`，因为通过可选链式调用得到的返回值都是可选的。这样我们就可以使用 `if` 语句来判断能否成功调用 `printNumberOfRooms()` 方法，即使方法本身没有定义返回值。通过判断返回值是否为 `nil` 可以判断调用是否成功：
+
+```swift
+if john.residence?.printNumberOfRooms() != nil {
+ print("It was possible to print the number of rooms.")
+} else {
+ print("It was not possible to print the number of rooms.")
+}
+// 打印“It was not possible to print the number of rooms.”
+```
+
+同样的，可以据此判断通过可选链式调用为属性赋值是否成功。在上面的[通过可选链式调用访问属性](#accessing_properties_through_optional_chaining)的例子中，我们尝试给 `john.residence` 中的 `address` 属性赋值，即使 `residence` 为 `nil`。通过可选链式调用给属性赋值会返回 `Void?`，通过判断返回值是否为 `nil` 就可以知道赋值是否成功：
+
+```swift
+if (john.residence?.address = someAddress) != nil {
+ print("It was possible to set the address.")
+} else {
+ print("It was not possible to set the address.")
+}
+// 打印“It was not possible to set the address.”
+```
+
+## 通过可选链式调用访问下标 {#accessing-subscripts-through-optional-chaining}
+
+通过可选链式调用，我们可以在一个可选值上访问下标，并且判断下标调用是否成功。
+
+> 注意
+>
+> 通过可选链式调用访问可选值的下标时，应该将问号放在下标方括号的前面而不是后面。可选链式调用的问号一般直接跟在可选表达式的后面。
+
+下面这个例子用下标访问 `john.residence` 属性存储的 `Residence` 实例的 `rooms` 数组中的第一个房间的名称，因为 `john.residence` 为 `nil`，所以下标调用失败了：
+
+```swift
+if let firstRoomName = john.residence?[0].name {
+ print("The first room name is \(firstRoomName).")
+} else {
+ print("Unable to retrieve the first room name.")
+}
+// 打印“Unable to retrieve the first room name.”
+```
+
+在这个例子中，问号直接放在 `john.residence` 的后面，并且在方括号的前面，因为 `john.residence` 是可选值。
+
+类似的，可以通过下标，用可选链式调用来赋值：
+
+```swift
+john.residence?[0] = Room(name: "Bathroom")
+```
+
+这次赋值同样会失败，因为 `residence` 目前是 `nil`。
+
+如果你创建一个 `Residence` 实例，并为其 `rooms` 数组添加一些 `Room` 实例，然后将 `Residence` 实例赋值给 `john.residence`，那就可以通过可选链和下标来访问数组中的元素：
+
+```swift
+let johnsHouse = Residence()
+johnsHouse.rooms.append(Room(name: "Living Room"))
+johnsHouse.rooms.append(Room(name: "Kitchen"))
+john.residence = johnsHouse
+
+if let firstRoomName = john.residence?[0].name {
+ print("The first room name is \(firstRoomName).")
+} else {
+ print("Unable to retrieve the first room name.")
+}
+// 打印“The first room name is Living Room.”
+```
+
+### 访问可选类型的下标 {#accessing-subscripts-of-optional-type}
+
+如果下标返回可选类型值，比如 Swift 中 `Dictionary` 类型的键的下标，可以在下标的结尾括号后面放一个问号来在其可选返回值上进行可选链式调用：
+
+```swift
+var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
+testScores["Dave"]?[0] = 91
+testScores["Bev"]?[0] += 1
+testScores["Brian"]?[0] = 72
+// "Dave" 数组现在是 [91, 82, 84]，"Bev" 数组现在是 [80, 94, 81]
+```
+
+上面的例子中定义了一个 `testScores` 数组，包含了两个键值对，分别把 `String` 类型的键映射到一个 `Int` 值的数组。这个例子用可选链式调用把 `"Dave"` 数组中第一个元素设为 `91`，把 `"Bev"` 数组的第一个元素 `+1`，然后尝试把 `"Brian"` 数组中的第一个元素设为 `72`。前两个调用成功，因为 `testScores` 字典中包含 `"Dave"` 和 `"Bev"` 这两个键。但是 `testScores` 字典中没有 `"Brian"` 这个键，所以第三个调用失败。
+
+## 连接多层可选链式调用 {#linking-multiple-levels-of-chaining}
+
+可以通过连接多个可选链式调用在更深的模型层级中访问属性、方法以及下标。然而，多层可选链式调用不会增加返回值的可选层级。
+
+也就是说：
+
++ 如果你访问的值不是可选的，可选链式调用将会返回可选值。
++ 如果你访问的值就是可选的，可选链式调用不会让可选返回值变得“更可选”。
+
+因此：
+
++ 通过可选链式调用访问一个 `Int` 值，将会返回 `Int?`，无论使用了多少层可选链式调用。
++ 类似的，通过可选链式调用访问 `Int?` 值，依旧会返回 `Int?` 值，并不会返回 `Int??`。
+
+下面的例子尝试访问 `john` 中的 `residence` 属性中的 `address` 属性中的 `street` 属性。这里使用了两层可选链式调用，`residence` 以及 `address` 都是可选值：
+
+```swift
+if let johnsStreet = john.residence?.address?.street {
+ print("John's street name is \(johnsStreet).")
+} else {
+ print("Unable to retrieve the address.")
+}
+// 打印“Unable to retrieve the address.”
+```
+
+`john.residence` 现在包含一个有效的 `Residence` 实例。然而，`john.residence.address` 的值当前为 `nil`。因此，调用 `john.residence?.address?.street` 会失败。
+
+需要注意的是，上面的例子中，`street` 的属性为 `String?`。`john.residence?.address?.street` 的返回值也依然是 `String?`，即使已经使用了两层可选链式调用。
+
+如果为 `john.residence.address` 赋值一个 `Address` 实例，并且为 `address` 中的 `street` 属性设置一个有效值，我们就能过通过可选链式调用来访问 `street` 属性：
+
+```swift
+let johnsAddress = Address()
+johnsAddress.buildingName = "The Larches"
+johnsAddress.street = "Laurel Street"
+john.residence?.address = johnsAddress
+
+if let johnsStreet = john.residence?.address?.street {
+ print("John's street name is \(johnsStreet).")
+} else {
+ print("Unable to retrieve the address.")
+}
+// 打印“John's street name is Laurel Street.”
+```
+
+在上面的例子中，因为 `john.residence` 包含一个有效的 `Address` 实例，所以对 `john.residence` 的 `address` 属性赋值将会成功。
+
+## 在方法的可选返回值上进行可选链式调用 {#chaining-on-methods-with-optional-return-values}
+
+上面的例子展示了如何在一个可选值上通过可选链式调用来获取它的属性值。我们还可以在一个可选值上通过可选链式调用来调用方法，并且可以根据需要继续在方法的可选返回值上进行可选链式调用。
+
+在下面的例子中，通过可选链式调用来调用 `Address` 的 `buildingIdentifier()` 方法。这个方法返回 `String?` 类型的值。如上所述，通过可选链式调用来调用该方法，最终的返回值依旧会是 `String?` 类型：
+
+```swift
+if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
+ print("John's building identifier is \(buildingIdentifier).")
+}
+// 打印“John's building identifier is The Larches.”
+```
+
+如果要在该方法的返回值上进行可选链式调用，在方法的圆括号后面加上问号即可：
+
+```swift
+if let beginsWithThe =
+ john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
+ if beginsWithThe {
+ print("John's building identifier begins with \"The\".")
+ } else {
+ print("John's building identifier does not begin with \"The\".")
+ }
+}
+// 打印“John's building identifier begins with "The".”
+```
+
+> 注意
+>
+> 在上面的例子中，在方法的圆括号后面加上问号是因为你要在 `buildingIdentifier()` 方法的可选返回值上进行可选链式调用，而不是 `buildingIdentifier()` 方法本身。
diff --git a/source/chapter2/17_Error_Handling.md b/source/chapter2/17_Error_Handling.md
index eac4ed4e..60f7d5b8 100755
--- a/source/chapter2/17_Error_Handling.md
+++ b/source/chapter2/17_Error_Handling.md
@@ -10,8 +10,7 @@
>
> Swift 中的错误处理涉及到错误处理模式，这会用到 Cocoa 和 Objective-C 中的 `NSError`。更多详情参见 [用 Swift 解决 Cocoa 错误](https://developer.apple.com/documentation/swift/cocoa_design_patterns/handling_cocoa_errors_in_swift)。
-
-## 表示与抛出错误
+## 表示与抛出错误 {#representing-and-throwing-errors}
在 Swift 中，错误用遵循 `Error` 协议的类型的值来表示。这个空协议表明该类型可以用于错误处理。
@@ -31,8 +30,7 @@ enum VendingMachineError: Error {
throw VendingMachineError.insufficientFunds(coinsNeeded: 5)
```
-
-## 处理错误
+## 处理错误 {#handling-errors}
某个错误被抛出时，附近的某部分代码必须负责处理这个错误，例如纠正这个问题、尝试另外一种方式、或是向用户报告错误。
@@ -44,8 +42,7 @@ Swift 中有 `4` 种处理错误的方式。你可以把函数抛出的错误传
>
> Swift 中的错误处理和其他语言中用 `try`，`catch` 和 `throw` 进行异常处理很像。和其他语言中（包括 Objective-C ）的异常处理不同的是，Swift 中的错误处理并不涉及解除调用栈，这是一个计算代价高昂的过程。就此而言，`throw` 语句的性能特性是可以和 `return` 语句相媲美的。
-
-### 用 throwing 函数传递错误
+### 用 throwing 函数传递错误 {#propagating-errors-using-throwing-functions}
为了表示一个函数、方法或构造器可以抛出错误，在函数声明的参数之后加上 `throws` 关键字。一个标有 `throws` 关键字的函数被称作 *throwing 函数*。如果这个函数指明了返回值类型，`throws` 关键词需要写在返回箭头（`->`）的前面。
@@ -131,7 +128,7 @@ struct PurchasedSnack {
}
```
-### 用 Do-Catch 处理错误
+### 用 Do-Catch 处理错误 {#handling-errors-using-do-Catch}
你可以使用一个 `do-catch` 语句运行一段闭包代码来处理错误。如果在 `do` 子句中的代码抛出了一个错误，这个错误会与 `catch` 子句做匹配，从而决定哪条子句能处理它。
@@ -169,7 +166,7 @@ do {
} catch {
print("Unexpected error: \(error).")
}
-// 打印 “Insufficient funds. Please insert an additional 2 coins.”
+// 打印“Insufficient funds. Please insert an additional 2 coins.”
```
上面的例子中，`buyFavoriteSnack(person:vendingMachine:)` 函数在一个 `try` 表达式中被调用，是因为它能抛出错误。如果错误被抛出，相应的执行会马上转移到 `catch` 子句中，并判断这个错误是否要被继续传递下去。如果错误没有被匹配，它会被最后一个 `catch` 语句捕获，并赋值给一个 `error` 常量。如果没有错误被抛出，`do` 子句中余下的语句就会被执行。
@@ -192,14 +189,14 @@ do {
} catch {
print("Unexpected non-vending-machine-related error: \(error)")
}
-// 打印 "Invalid selection, out of stock, or not enough money."
+// 打印“Invalid selection, out of stock, or not enough money.”
```
如果 `vend(itemNamed:)` 抛出的是一个 `VendingMachineError` 类型的错误，`nourish(with:)` 会打印一条消息，否则 `nourish(with:)` 会将错误抛给它的调用方。这个错误之后会被通用的 `catch` 语句捕获。
-### 将错误转换成可选值
+### 将错误转换成可选值 {#converting_errors_to_optional_values}
-可以使用 `try?` 通过将错误转换成一个可选值来处理错误。如果在评估 `try?` 表达式时一个错误被抛出，那么表达式的值就是 `nil`。例如，在下面的代码中，`x` 和 `y` 有着相同的数值和等价的含义：
+可以使用 `try?` 通过将错误转换成一个可选值来处理错误。如果是在计算 `try?` 表达式时抛出错误，该表达式的结果就为 `nil`。例如，在下面的代码中，`x` 和 `y` 有着相同的数值和等价的含义：
```swift
func someThrowingFunction() throws -> Int {
@@ -228,7 +225,7 @@ func fetchData() -> Data? {
}
```
-### 禁用错误传递
+### 禁用错误传递 {#disabling_error_propagation}
有时你知道某个 `throwing` 函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写 `try!` 来禁用错误传递，这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误，你会得到一个运行时错误。
@@ -238,8 +235,7 @@ func fetchData() -> Data? {
let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")
```
-
-## 指定清理操作
+## 指定清理操作 {#specifying-cleanup-actions}
你可以使用 `defer` 语句在即将离开当前代码块时执行一系列语句。该语句让你能执行一些必要的清理工作，不管是以何种方式离开当前代码块的——无论是由于抛出错误而离开，或是由于诸如 `return`、`break` 的语句。例如，你可以用 `defer` 语句来确保文件描述符得以关闭，以及手动分配的内存得以释放。
diff --git a/source/chapter2/18_Type_Casting.md b/source/chapter2/18_Type_Casting.md
index 434e3a5a..76077f2a 100644
--- a/source/chapter2/18_Type_Casting.md
+++ b/source/chapter2/18_Type_Casting.md
@@ -4,10 +4,9 @@
类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符分别提供了一种简单达意的方式去检查值的类型或者转换它的类型。
-你也可以用它来检查一个类型是否遵循了某个协议，就像在[检验协议遵循](./21_Protocols.html#checking_for_protocol_conformance)部分讲述的一样。
+你也可以用它来检查一个类型是否遵循了某个协议，就像在[检验协议遵循](./21_Protocols.md#checking_for_protocol_conformance)部分讲述的一样。
-
-## 为类型转换定义类层次
+## 为类型转换定义类层次 {#defining-a-class-hierarchy-for-type-casting}
你可以将类型转换用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。下面的三个代码段定义了一个类层次和一个包含了这些类实例的数组，作为类型转换的例子。
@@ -57,8 +56,7 @@ let library = [
在幕后 `library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的。但是，若你迭代它，依次取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型。为了让它们作为原本的类型工作，你需要检查它们的类型或者向下转换它们到其它类型，就像下面描述的一样。
-
-## 检查类型
+## 检查类型 {#checking-type}
用*类型检查操作符*（`is`）来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true`，否则返回 `false`。
@@ -77,7 +75,7 @@ for item in library {
}
print("Media library contains \(movieCount) movies and \(songCount) songs")
-// 打印 "Media library contains 2 movies and 3 songs"
+// 打印“Media library contains 2 movies and 3 songs”
```
示例迭代了数组 `library` 中的所有项。每一次，`for-in` 循环设置
@@ -86,8 +84,7 @@ print("Media library contains \(movieCount) movies and \(songCount) songs")
若当前 `MediaItem` 是一个 `Movie` 类型的实例，`item is Movie` 返回
`true`，否则返回 `false`。同样的，`item is Song` 检查 `item` 是否为 `Song` 类型的实例。在循环结束后，`movieCount` 和 `songCount` 的值就是被找到的属于各自类型的实例的数量。
-
-## 向下转型
+## 向下转型 {#downcasting}
某类型的一个常量或变量可能在幕后实际上属于一个子类。当确定是这种情况时，你可以尝试用*类型转换操作符*（`as?` 或 `as!`）向下转到它的子类型。
@@ -132,8 +129,7 @@ for item in library {
>
> 转换没有真的改变实例或它的值。根本的实例保持不变；只是简单地把它作为它被转换成的类型来使用。
-
-## `Any` 和 `AnyObject` 的类型转换
+## `Any` 和 `AnyObject` 的类型转换 {#type-casting-for-any-and-anyobject}
Swift 为不确定类型提供了两种特殊的类型别名：
@@ -200,8 +196,6 @@ for thing in things {
> 注意
>
> `Any` 类型可以表示所有类型的值，包括可选类型。Swift 会在你用 `Any` 类型来表示一个可选值的时候，给你一个警告。如果你确实想使用 `Any` 类型来承载可选值，你可以使用 `as` 操作符显式转换为 `Any`，如下所示：
->
->
```swift
let optionalNumber: Int? = 3
diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/19_Nested_Types.md
index 4b92f8fe..ef0bca88 100755
--- a/source/chapter2/19_Nested_Types.md
+++ b/source/chapter2/19_Nested_Types.md
@@ -4,8 +4,7 @@
要在一个类型中嵌套另一个类型，将嵌套类型的定义写在其外部类型的 `{}` 内，而且可以根据需要定义多级嵌套。
-
-## 嵌套类型实践
+## 嵌套类型实践 {#nested-types-in-action}
下面这个例子定义了一个结构体 `BlackjackCard`（二十一点），用来模拟 `BlackjackCard` 中的扑克牌点数。`BlackjackCard` 结构体包含两个嵌套定义的枚举类型 `Suit` 和 `Rank`。
@@ -62,26 +61,25 @@ struct BlackjackCard {
`Rank` 还定义了一个计算型属性 `values`，它将会返回一个 `Values` 结构体的实例。这个计算型属性会根据牌的面值，用适当的数值去初始化 `Values` 实例。对于 `J`、`Q`、`K`、`Ace` 这四种牌，会使用特殊数值。对于数字面值的牌，使用枚举实例的 `Int` 类型的原始值。
-`BlackjackCard` 结构体拥有两个属性—— `rank` 与 `suit`。它也同样定义了一个计算型属性 `description`，`description` 属性用 `rank` 和 `suit` 中的内容来构建对扑克牌名字和数值的描述。该属性使用可选绑定来检查可选类型 `second` 是否有值，若有值，则在原有的描述中增加对 `second` 的描述。
+`BlackjackCard` 结构体拥有两个属性——`rank` 与 `suit`。它也同样定义了一个计算型属性 `description`，`description` 属性用 `rank` 和 `suit` 中的内容来构建对扑克牌名字和数值的描述。该属性使用可选绑定来检查可选类型 `second` 是否有值，若有值，则在原有的描述中增加对 `second` 的描述。
-因为 `BlackjackCard` 是一个没有自定义构造器的结构体，在[结构体的逐一成员构造器](./14_Initialization.html#memberwise_initializers_for_structure_types)中可知，结构体有默认的成员构造器，所以你可以用默认的构造器去初始化新常量 `theAceOfSpades`：
+因为 `BlackjackCard` 是一个没有自定义构造器的结构体，在[结构体的逐一成员构造器](./14_Initialization.md#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` 中，但它们的类型仍可从上下文中推断出来，所以在初始化实例时能够单独通过成员名称（`.ace` 和 `.spades`）引用枚举实例。在上面的例子中，`description` 属性正确地反映了黑桃 A 牌具有 `1` 和 `11` 两个值。
-
-## 引用嵌套类型
+## 引用嵌套类型 {#referring-to-nested-types}
在外部引用嵌套类型时，在嵌套类型的类型名前加上其外部类型的类型名作为前缀：
```swift
let heartsSymbol = BlackjackCard.Suit.hearts.rawValue
-// 红心符号为 “♡”
+// 红心符号为“♡”
```
对于上面这个例子，这样可以使 `Suit`、`Rank` 和 `Values` 的名字尽可能的短，因为它们的名字可以由定义它们的上下文来限定。
diff --git a/source/chapter2/20_Extensions.md b/source/chapter2/20_Extensions.md
index 5a8ca127..26815e65 100644
--- a/source/chapter2/20_Extensions.md
+++ b/source/chapter2/20_Extensions.md
@@ -1,49 +1,51 @@
# 扩展
-*扩展*可以给一个现有的类，结构体，枚举，还有协议添加新的功能。它还拥有不需要访问被扩展类型源代码就能完成扩展的能力（即*逆向建模*）。扩展和 Objective-C 的分类很相似。（与 Objective-C 分类不同的是，Swift 扩展是没有名字的。）
+*扩展*可以给一个现有的类，结构体，枚举，还有协议添加新的功能。它还拥有不需要访问被扩展类型源代码就能完成扩展的能力（即*逆向建模*）。扩展和 Objective-C 的分类很相似。（与 Objective-C 分类不同的是，Swift 扩展是没有名字的。）
-Swift 中的扩展可以：
+Swift 中的扩展可以：
- - 添加计算型实例属性和计算型类属性
- - 定义实例方法和类方法
- - 提供新的构造器
- - 定义下标
- - 定义和使用新的嵌套类型
- - 使已经存在的类型遵循（conform）一个协议
+ - 添加计算型实例属性和计算型类属性
+ - 定义实例方法和类方法
+ - 提供新的构造器
+ - 定义下标
+ - 定义和使用新的嵌套类型
+ - 使已经存在的类型遵循（conform）一个协议
在 Swift 中，你甚至可以扩展协议以提供其需要的实现，或者添加额外功能给遵循的类型所使用。你可以从 [协议扩展](https://docs.swift.org/swift-book/LanguageGuide/Protocols.html#ID521) 获取更多细节。
-> 注意
+> 注意
>
-> 扩展可以给一个类型添加新的功能，但是不能重写已经存在的功能。
+> 扩展可以给一个类型添加新的功能，但是不能重写已经存在的功能。
-## 扩展的语法
-使用 **extension** 关键字声明扩展：
+## 扩展的语法 {#extension-syntax}
+
+使用 `extension` 关键字声明扩展：
```swift
extension SomeType {
// 在这里给 SomeType 添加新的功能
}
-```
+```
-扩展可以扩充一个现有的类型，给它添加一个或多个协议。协议名称的写法和类或者结构体一样：
+扩展可以扩充一个现有的类型，给它添加一个或多个协议。协议名称的写法和类或者结构体一样：
```swift
extension SomeType: SomeProtocol, AnotherProtocol {
// 协议所需要的实现写在这里
}
-```
+```
-这种遵循协议的方式在 [使用扩展遵循协议](https://docs.swift.org/swift-book/LanguageGuide/Protocols.html#ID277) 中有描述。
+这种遵循协议的方式在 [使用扩展遵循协议](https://docs.swift.org/swift-book/LanguageGuide/Protocols.html#ID277) 中有描述。
-扩展可以使用在现有范型类型上，就像 [扩展范型类型](https://docs.swift.org/swift-book/LanguageGuide/Generics.html#ID185) 中描述的一样。你还可以使用扩展给泛型类型有条件的添加功能，就像 [扩展一个带有 Where 字句的范型](https://docs.swift.org/swift-book/LanguageGuide/Generics.html#ID553) 中描述的一样。
+扩展可以使用在现有范型类型上，就像 [扩展范型类型](https://docs.swift.org/swift-book/LanguageGuide/Generics.html#ID185) 中描述的一样。你还可以使用扩展给泛型类型有条件的添加功能，就像 [扩展一个带有 Where 字句的范型](https://docs.swift.org/swift-book/LanguageGuide/Generics.html#ID553) 中描述的一样。
-> 注意
+> 注意
>
> 对一个现有的类型，如果你定义了一个扩展来添加新的功能，那么这个类型的所有实例都可以使用这个新功能，包括那些在扩展定义之前就存在的实例。
-## 计算型属性
-扩展可以给现有类型添加计算型实例属性和计算型类属性。这个例子给 Swift 内建的 **Double** 类型添加了五个计算型实例属性，从而提供与距离单位相关工作的基本支持：
+## 计算型属性 {#computed-properties}
+
+扩展可以给现有类型添加计算型实例属性和计算型类属性。这个例子给 Swift 内建的 `Double` 类型添加了五个计算型实例属性，从而提供与距离单位相关工作的基本支持：
```swift
extension Double {
@@ -55,40 +57,41 @@ extension Double {
}
let oneInch = 25.4.mm
print("One inch is \(oneInch) meters")
-// 打印“一英寸是 0.0254 米”
+// 打印“One inch is 0.0254 meters”
let threeFeet = 3.ft
print("Three feet is \(threeFeet) meters")
-// 打印“三英尺是 0.914399970739201 米”
-```
+// 打印“Three feet is 0.914399970739201 meters”
+```
-这些计算型属性表示的含义是把一个 **Double** 值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性的名字仍可紧接一个浮点型字面值，从而通过点语法来使用，并以此实现距离转换。
+这些计算型属性表示的含义是把一个 `Double` 值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性的名字仍可紧接一个浮点型字面值，从而通过点语法来使用，并以此实现距离转换。
-在上述例子中，**Double** 类型的 **1.0** 代表的是“一米”。这就是为什么计算型属性 **m** 返回的是 **self** - 表达式 **1.m** 被认为是计算一个 **Double** 类型的 **1.0**。
+在上述例子中，`Double` 类型的 `1.0` 代表的是“一米”。这就是为什么计算型属性 `m` 返回的是 `self`——表达式 `1.m` 被认为是计算一个 `Double` 类型的 `1.0`。
-其它单位则需要一些单位换算。一千米等于 1,000 米，所以计算型属性 **km** 要把值乘以 **1_000.00** 来实现千米到米的单位换算。类似地，一米有 3.28084 英尺，所以计算型属性 **ft** 要把对应的 **Double** 值除以 **3.28084**，来实现英尺到米的单位换算。
+其它单位则需要一些单位换算。一千米等于 1,000 米，所以计算型属性 `km` 要把值乘以 `1_000.00` 来实现千米到米的单位换算。类似地，一米有 3.28084 英尺，所以计算型属性 `ft` 要把对应的 `Double` 值除以 `3.28084`，来实现英尺到米的单位换算。
-这些属性都是只读的计算型属性，所以为了简便，它们的表达式里面都不包含 **get** 关键字。它们使用 **Double** 作为返回值类型，并可用于所有接受 **Double** 类型的数学计算中：
+这些属性都是只读的计算型属性，所以为了简便，它们的表达式里面都不包含 `get` 关键字。它们使用 `Double` 作为返回值类型，并可用于所有接受 `Double` 类型的数学计算中：
```swift
let aMarathon = 42.km + 195.m
print("A marathon is \(aMarathon) meters long")
-// 打印“马拉松赛跑全长 42195.0 米。”
-```
+// 打印“A marathon is 42195.0 meters long”
+```
-> 注意
+> 注意
>
-> 扩展可以添加新的计算属性，但是它们不能添加存储属性，或向现有的属性添加属性观察者。
+> 扩展可以添加新的计算属性，但是它们不能添加存储属性，或向现有的属性添加属性观察者。
-## 构造器
-扩展可以给现有的类型添加新的构造器。它使你可以把自定义类型作为参数来供其他类型的构造器使用，或者在类型的原始实现上添加额外的构造选项。
+## 构造器 {#initializers}
-扩展可以给一个类添加新的便利构造器，但是它们不能给类添加新的指定构造器或者析构器。指定构造器和析构器必须始终由类的原始实现提供。
+扩展可以给现有的类型添加新的构造器。它使你可以把自定义类型作为参数来供其他类型的构造器使用，或者在类型的原始实现上添加额外的构造选项。
-如果你使用扩展给一个值类型添加构造器只是用于给所有的存储属性提供默认值，并且没有定义任何自定义构造器，那么你可以在该值类型扩展的构造器中使用默认构造器和成员构造器。如果你把构造器写到了值类型的原始实现中，就像 [值类型的构造器委托](https://docs.swift.org/swift-book/LanguageGuide/Initialization.html#ID215) 中所描述的，那么就不属于在扩展中添加构造器。
+扩展可以给一个类添加新的便利构造器，但是它们不能给类添加新的指定构造器或者析构器。指定构造器和析构器必须始终由类的原始实现提供。
-如果你使用扩展给另一个模块中定义的结构体添加构造器，那么新的构造器直到定义模块中使用一个构造器之前，不能访问 **self**。
+如果你使用扩展给一个值类型添加构造器只是用于给所有的存储属性提供默认值，并且没有定义任何自定义构造器，那么你可以在该值类型扩展的构造器中使用默认构造器和成员构造器。如果你把构造器写到了值类型的原始实现中，就像 [值类型的构造器委托](https://docs.swift.org/swift-book/LanguageGuide/Initialization.html#ID215) 中所描述的，那么就不属于在扩展中添加构造器。
-在下面的例子中，自定义了一个的 **Rect** 结构体用来表示一个几何矩形。这个例子中还定义了两个给予支持的结构体 **Size** 和 **Point**，它们都把属性的默认值设置为 **0.0**：
+如果你使用扩展给另一个模块中定义的结构体添加构造器，那么新的构造器直到定义模块中使用一个构造器之前，不能访问 `self`。
+
+在下面的例子中，自定义了一个的 `Rect` 结构体用来表示一个几何矩形。这个例子中还定义了两个给予支持的结构体 `Size` 和 `Point`，它们都把属性的默认值设置为 `0.0`：
```swift
struct Size {
@@ -101,17 +104,17 @@ struct Rect {
var origin = Point()
var size = Size()
}
-```
+```
-因为 **Rect** 结构体给所有的属性都提供了默认值，所以它自动获得了一个默认构造器和一个成员构造器，就像 [默认构造器](https://docs.swift.org/swift-book/LanguageGuide/Initialization.html#ID213) 中描述的一样。这些构造器可以用来创建新的 **Rect** 实例：
+因为 `Rect` 结构体给所有的属性都提供了默认值，所以它自动获得了一个默认构造器和一个成员构造器，就像 [默认构造器](https://docs.swift.org/swift-book/LanguageGuide/Initialization.html#ID213) 中描述的一样。这些构造器可以用来创建新的 `Rect` 实例：
```swift
let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
size: Size(width: 5.0, height: 5.0))
-```
+```
-你可以通过扩展 **Rect** 结构体来提供一个允许指定 point 和 size 的构造器：
+你可以通过扩展 `Rect` 结构体来提供一个允许指定 point 和 size 的构造器：
```swift
extension Rect {
@@ -123,20 +126,21 @@ extension Rect {
}
```
-这个新的构造器首先根据提供的 **center** 和 **size** 计算一个适当的原点。然后这个构造器调用结构体自带的成员构造器 **init(origin:size:)**，它会将新的 origin 和 size 值储存在适当的属性中：
+这个新的构造器首先根据提供的 `center` 和 `size` 计算一个适当的原点。然后这个构造器调用结构体自带的成员构造器 `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 的 origin 是 (2.5, 2.5) 并且它的 size 是 (3.0, 3.0)
-```
+```
-> 注意
+> 注意
>
> 如果你通过扩展提供一个新的构造器，你有责任确保每个通过该构造器创建的实例都是初始化完整的。
-## 方法
-扩展可以给现有类型添加新的实例方法和类方法。在下面的例子中，给 **Int** 类型添加了一个新的实例方法叫做 **repetitions**：
+## 方法 {#methods}
+
+扩展可以给现有类型添加新的实例方法和类方法。在下面的例子中，给 `Int` 类型添加了一个新的实例方法叫做 `repetitions`：
```swift
extension Int {
@@ -148,9 +152,9 @@ extension Int {
}
```
-**repetitions(task:)** 方法仅接收一个 **() -> Void** 类型的参数，它表示一个没有参数没有返回值的方法。
+`repetitions(task:)` 方法仅接收一个 `() -> Void` 类型的参数，它表示一个没有参数没有返回值的方法。
-定义了这个扩展之后，你可以对任意整形数值调用 **repetitions(task:)** 方法，来执行对应次数的任务：
+定义了这个扩展之后，你可以对任意整形数值调用 `repetitions(task:)` 方法，来执行对应次数的任务：
```swift
3.repetitions {
@@ -159,12 +163,13 @@ extension Int {
// Hello!
// Hello!
// Hello!
-```
+```
-### 可变实例方法
-通过扩展添加的实例方法同样也可以修改（或 *mutating（改变）*）实例本身。结构体和枚举的方法，若是可以修改 **self** 或者它自己的属性，则必须将这个实例方法标记为 **mutating**，就像是改变了方法的原始实现。
+### 可变实例方法 {#mutating-instance-methods}
-在下面的例子中，对 Swift 的 **Int** 类型添加了一个新的 mutating 方法，叫做 **square**，它将原始值求平方：
+通过扩展添加的实例方法同样也可以修改（或 *mutating（改变）*）实例本身。结构体和枚举的方法，若是可以修改 `self` 或者它自己的属性，则必须将这个实例方法标记为 `mutating`，就像是改变了方法的原始实现。
+
+在下面的例子中，对 Swift 的 `Int` 类型添加了一个新的 mutating 方法，叫做 `square`，它将原始值求平方：
```swift
extension Int {
@@ -175,15 +180,16 @@ extension Int {
var someInt = 3
someInt.square()
// someInt 现在是 9
-```
+```
-## 下标
-扩展可以给现有的类型添加新的下标。下面的例子中，对 Swift 的 **Int** 类型添加了一个整数类型的下标。下标 **[n]** 从数字右侧开始，返回小数点后的第 **n** 位：
+## 下标 {#subscripts}
-- **123456789[0]** returns **9**
-- **123456789[1]** returns **8**
+扩展可以给现有的类型添加新的下标。下面的例子中，对 Swift 的 `Int` 类型添加了一个整数类型的下标。下标 `[n]` 从数字右侧开始，返回小数点后的第 `n` 位：
-……以此类推：
+- `123456789[0]` 返回 `9`
+- `123456789[1]` 返回 `8`
+
+……以此类推：
```swift
extension Int {
subscript(digitIndex: Int) -> Int {
@@ -195,25 +201,26 @@ extension Int {
}
}
746381295[0]
-// returns 5
+// 返回 5
746381295[1]
-// returns 9
+// 返回 9
746381295[2]
-// returns 2
+// 返回 2
746381295[8]
-// returns 7
-```
+// 返回 7
+```
-如果操作的 **Int** 值没有足够的位数满足所请求的下标，那么下标的现实将返回 **0**，将好像在数字的左边补上了 0：
+如果操作的 `Int` 值没有足够的位数满足所请求的下标，那么下标的现实将返回 `0`，将好像在数字的左边补上了 0：
```swift
746381295[9]
// 返回 0，就好像你进行了这个请求：
0746381295[9]
-```
+```
-## 嵌套类型
-扩展可以给现有的类，结构体，还有枚举添加新的嵌套类型：
+## 嵌套类型 {#nested-yypes}
+
+扩展可以给现有的类，结构体，还有枚举添加新的嵌套类型：
```swift
extension Int {
@@ -231,13 +238,13 @@ extension Int {
}
}
}
-```
+```
-这个例子给 **Int** 添加了一个新的嵌套枚举。这个枚举叫做 **Kind**，表示特定整数所代表的数字类型。具体来说，它表示数字是负的、零的还是正的。
+这个例子给 `Int` 添加了一个新的嵌套枚举。这个枚举叫做 `Kind`，表示特定整数所代表的数字类型。具体来说，它表示数字是负的、零的还是正的。
-这个例子同样给 **Int** 添加了一个新的计算型实例属性，叫做 **kind**，它返回被操作整数所对应的 **Kind** 枚举 case 分支。
+这个例子同样给 `Int` 添加了一个新的计算型实例属性，叫做 `kind`，它返回被操作整数所对应的 `Kind` 枚举 case 分支。
-现在，任意 **Int** 的值都可以使用这个嵌套类型：
+现在，任意 `Int` 的值都可以使用这个嵌套类型：
```swift
func printIntegerKinds(_ numbers: [Int]) {
@@ -254,13 +261,11 @@ func printIntegerKinds(_ numbers: [Int]) {
print("")
}
printIntegerKinds([3, 19, -27, 0, -6, 0, 7])
-// 打印 "+ + - 0 - 0 + "
+// 打印“+ + - 0 - 0 + ”
```
-方法 **printIntegerKinds(_:)**，使用一个 **Int** 类型的数组作为输入，然后依次迭代这些值。对于数组中的每一个整数，方法会检查它的 **kind** 计算型属性，然后打印适当的描述。
+方法 `printIntegerKinds(_:)`，使用一个 `Int` 类型的数组作为输入，然后依次迭代这些值。对于数组中的每一个整数，方法会检查它的 `kind` 计算型属性，然后打印适当的描述。
-> 注意
+> 注意
>
-> **number.kind** 已经被认为是 **Int.Kind** 类型。所以，在 **switch** 语句中所有的 **Int.Kind** case 分支可以被缩写，就像使用 **.negative** 替代 **Int.Kind.negative.**。
-
-
+> `number.kind` 已经被认为是 `Int.Kind` 类型。所以，在 `switch` 语句中所有的 `Int.Kind` case 分支可以被缩写，就像使用 `.negative` 替代 `Int.Kind.negative.`。
diff --git a/source/chapter2/21_Protocols.md b/source/chapter2/21_Protocols.md
index 3accbc73..59c3f48b 100644
--- a/source/chapter2/21_Protocols.md
+++ b/source/chapter2/21_Protocols.md
@@ -4,8 +4,7 @@
除了遵循协议的类型必须实现的要求外，还可以对协议进行扩展，通过扩展来实现一部分要求或者实现一些附加功能，这样遵循协议的类型就能够使用这些功能。
-
-## 协议语法
+## 协议语法 {#protocol-syntax}
协议的定义方式与类、结构体和枚举的定义非常相似：
@@ -23,7 +22,7 @@ struct SomeStructure: FirstProtocol, AnotherProtocol {
}
```
-拥有父类的类在遵循协议时，应该将父类名放在协议名之前，以逗号分隔：
+若一个拥有父类的类在遵循协议时，应该将父类名放在协议名之前，以逗号分隔：
```swift
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
@@ -31,14 +30,13 @@ class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
}
```
-
-## 属性要求
+## 属性要求 {#property-requirements}
-协议可以要求遵循协议的类型提供特定名称和类型的实例属性或类型属性。协议不指定属性是存储型属性还是计算型属性，它只指定属性的名称和类型。此外，协议还指定属性是可读的还是*可读可写的*。
+协议可以要求遵循协议的类型提供特定名称和类型的实例属性或类型属性。协议不指定属性是存储属性还是计算属性，它只指定属性的名称和类型。此外，协议还指定属性是*可读*的还是*可读可写的*。
如果协议要求属性是可读可写的，那么该属性不能是常量属性或只读的计算型属性。如果协议只要求属性是可读的，那么该属性不仅可以是可读的，如果代码需要的话，还可以是可写的。
-协议总是用 `var` 关键字来声明变量属性，在类型声明后加上 `{ set get }` 来表示属性是可读可写的，可读属性则用 `{ get }` 来表示：
+协议总是用 `var` 关键字来声明变量属性，在类型声明后加上 `{ set get }` 来表示属性是*可读可写*的，*可读*属性则用 `{ get }` 来表示：
```swift
protocol SomeProtocol {
@@ -69,7 +67,7 @@ protocol FullyNamed {
```swift
struct Person: FullyNamed {
- var fullName: String
+ var fullName: String
}
let john = Person(fullName: "John Appleseed")
// john.fullName 为 "John Appleseed"
@@ -77,9 +75,9 @@ let john = Person(fullName: "John Appleseed")
这个例子中定义了一个叫做 `Person` 的结构体，用来表示一个具有名字的人。从第一行代码可以看出，它遵循了 `FullyNamed` 协议。
-`Person` 结构体的每一个实例都有一个 `String` 类型的存储型属性 `fullName`。这正好遵循了 `FullyNamed` 协议的要求，也就意味着 `Person` 结构体正确地遵循了协议。（如果协议要求未被完全遵循，在编译时会报错。）
+`Person` 结构体的每一个实例都有一个 `String` 类型的存储型属性 `fullName`。这正好满足了 `FullyNamed` 协议的要求，也就意味着 `Person` 结构体正确地符合了协议。（如果协议要求未被完全满足，在编译时会报错。）
-下面是一个更为复杂的类，它适配并遵循了 `FullyNamed` 协议：
+下面是一个更为复杂的类，它采纳并遵循了 `FullyNamed` 协议：
```swift
class Starship: FullyNamed {
@@ -94,17 +92,16 @@ class Starship: FullyNamed {
}
}
var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
-// ncc1701.fullName 是 "USS Enterprise"
+// ncc1701.fullName 为 "USS Enterprise"
```
-`Starship` 类把 `fullName` 属性实现为只读的计算型属性。每一个 `Starship` 类的实例都有一个名为 `name` 的非可选属性和一个名为 `prefix` 的可选属性。 当 `prefix` 存在时，计算型属性 `fullName` 会将 `prefix` 插入到 `name` 之前，从而为星际飞船构建一个全名。
+`Starship` 类把 `fullName` 作为只读的计算属性来实现。每一个 `Starship` 类的实例都有一个名为 `name` 的非可选属性和一个名为 `prefix` 的可选属性。 当 `prefix` 存在时，计算属性 `fullName` 会将 `prefix` 插入到 `name` 之前，从而得到一个带有 `prefix` 的 `fullName`。
-
-## 方法要求
+## 方法要求 {#method-requirements}
-协议可以要求遵循协议的类型实现某些指定的实例方法或类方法。这些方法作为协议的一部分，像普通方法一样放在协议的定义中，但是不需要大括号和方法体。可以在协议中定义具有可变参数的方法，和普通方法的定义方式相同。但是，不支持为协议中的方法的参数提供默认值。
+协议可以要求遵循协议的类型实现某些指定的实例方法或类方法。这些方法作为协议的一部分，像普通方法一样放在协议的定义中，但是不需要大括号和方法体。可以在协议中定义具有可变参数的方法，和普通方法的定义方式相同。但是，不支持为协议中的方法提供默认参数。
-正如属性要求中所述，在协议中定义类方法的时候，总是使用 `static` 关键字作为前缀。当类类型遵循协议时，除了 `static` 关键字，还可以使用 `class` 关键字作为前缀：
+正如属性要求中所述，在协议中定义类方法的时候，总是使用 `static` 关键字作为前缀。即使在类实现时，类方法要求使用 `class` 或 `static` 作为关键字前缀，前面的规则仍然适用：
```swift
protocol SomeProtocol {
@@ -116,26 +113,26 @@ protocol SomeProtocol {
```swift
protocol RandomNumberGenerator {
- func random() -> Double
+ func random() -> Double
}
```
-`RandomNumberGenerator` 协议要求遵循协议的类型必须拥有一个名为 `random`， 返回值类型为 `Double` 的实例方法。尽管这里并未指明，但是我们假设返回值是从0.0到（但不包括）1.0。
+`RandomNumberGenerator` 协议要求遵循协议的类型必须拥有一个名为 `random`， 返回值类型为 `Double` 的实例方法。尽管这里并未指明，但是我们假设返回值是从 `0.0` 到（但不包括）`1.0`。
`RandomNumberGenerator` 协议并不关心每一个随机数是怎样生成的，它只要求必须提供一个随机数生成器。
-如下所示，下边是一个遵循 `RandomNumberGenerator` 协议的类。该类实现了一个叫做 *线性同余生成器（linear congruential generator）* 的伪随机数算法。
+如下所示，下边是一个遵循并符合 `RandomNumberGenerator` 协议的类。该类实现了一个叫做 *线性同余生成器（linear congruential generator）* 的伪随机数算法。
```swift
class LinearCongruentialGenerator: RandomNumberGenerator {
- var lastRandom = 42.0
- let m = 139968.0
- let a = 3877.0
- let c = 29573.0
- func random() -> Double {
- lastRandom = ((lastRandom * a + c).truncatingRemainder(dividingBy:m))
- return lastRandom / m
- }
+ var lastRandom = 42.0
+ let m = 139968.0
+ let a = 3877.0
+ let c = 29573.0
+ func random() -> Double {
+ lastRandom = ((lastRandom * a + c).truncatingRemainder(dividingBy:m))
+ return lastRandom / m
+ }
}
let generator = LinearCongruentialGenerator()
print("Here's a random number: \(generator.random())")
@@ -144,10 +141,9 @@ print("And another one: \(generator.random())")
// 打印 “And another one: 0.729023776863283”
```
-
-## 异变方法要求
+## 异变方法要求 {#mutating-method-requirements}
-有时需要在方法中改变（或*异变*）方法所属的实例。例如，在值类型（即结构体和枚举）的实例方法中，将 `mutating` 关键字作为方法的前缀，写在 `func` 关键字之前，表示可以在该方法中修改它所属的实例以及实例的任意属性的值。这一过程在[在实例方法中修改值类型](./11_Methods.html#modifying_value_types_from_within_instance_methods)章节中有详细描述。
+有时需要在方法中改变（或*异变*）方法所属的实例。例如，在值类型（即结构体和枚举）的实例方法中，将 `mutating` 关键字作为方法的前缀，写在 `func` 关键字之前，表示可以在该方法中修改它所属的实例以及实例的任意属性的值。这一过程在 [在实例方法中修改值类型](./11_Methods.md#modifying_value_types_from_within_instance_methods) 章节中有详细描述。
如果你在协议中定义了一个实例方法，该方法会改变遵循该协议的类型的实例，那么在定义协议时需要在方法前加 `mutating` 关键字。这使得结构体和枚举能够遵循此协议并满足此方法要求。
@@ -155,13 +151,13 @@ print("And another one: \(generator.random())")
>
> 实现协议中的 `mutating` 方法时，若是类类型，则不用写 `mutating` 关键字。而对于结构体和枚举，则必须写 `mutating` 关键字。
-如下所示，`Togglable` 协议只要求实现一个名为 `toggle` 的实例方法。根据名称的暗示，`toggle()` 方法将改变实例属性，从而切换遵循该协议类型的实例的状态。
+如下所示，`Togglable` 协议只定义了一个名为 `toggle` 的实例方法。顾名思义，`toggle()` 方法将改变实例属性，从而切换遵循该协议类型的实例的状态。
`toggle()` 方法在定义的时候，使用 `mutating` 关键字标记，这表明当它被调用时，该方法将会改变遵循协议的类型的实例：
```swift
protocol Togglable {
- mutating func toggle()
+ mutating func toggle()
}
```
@@ -186,8 +182,7 @@ lightSwitch.toggle()
// lightSwitch 现在的值为 .on
```
-
-## 构造器要求
+## 构造器要求 {#initializer-requirements}
协议可以要求遵循协议的类型实现指定的构造器。你可以像编写普通构造器那样，在协议的定义里写下构造器的声明，但不需要写花括号和构造器的实体：
@@ -197,7 +192,7 @@ protocol SomeProtocol {
}
```
-### 协议构造器要求的类实现
+### 协议构造器要求的类实现 {#class-implementations-of-protocol-initializer-requirements}
你可以在遵循协议的类中实现构造器，无论是作为指定构造器，还是作为便利构造器。无论哪种情况，你都必须为构造器实现标上 `required` 修饰符：
@@ -209,13 +204,13 @@ class SomeClass: SomeProtocol {
}
```
-使用 `required` 修饰符可以确保所有子类也必须提供此构造器实现，从而也能遵循协议。
+使用 `required` 修饰符可以确保所有子类也必须提供此构造器实现，从而也能符合协议。
-关于 `required` 构造器的更多内容，请参考[必要构造器](./14_Initialization.html#required_initializers)。
+关于 `required` 构造器的更多内容，请参考 [必要构造器](./14_Initialization.md#required_initializers)。
> 注意
>
-> 如果类已经被标记为 `final`，那么不需要在协议构造器的实现中使用 `required` 修饰符，因为 `final` 类不能有子类。关于 `final` 修饰符的更多内容，请参见[防止重写](./13_Inheritance.html#preventing_overrides)。
+> 如果类已经被标记为 `final`，那么不需要在协议构造器的实现中使用 `required` 修饰符，因为 `final` 类不能有子类。关于 `final` 修饰符的更多内容，请参见 [防止重写](./13_Inheritance.md#preventing_overrides)。
如果一个子类重写了父类的指定构造器，并且该构造器满足了某个协议的要求，那么该构造器的实现需要同时标注 `required` 和 `override` 修饰符：
@@ -239,16 +234,15 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
}
```
-### 可失败构造器要求
+### 可失败构造器要求 {#failable-initializer-requirements}
-协议还可以为遵循协议的类型定义可失败构造器要求，详见[可失败构造器](./14_Initialization.html#failable_initializers)。
+协议还可以为遵循协议的类型定义可失败构造器要求，详见 [可失败构造器](./14_Initialization.md#failable_initializers)。
遵循协议的类型可以通过可失败构造器（`init?`）或非可失败构造器（`init`）来满足协议中定义的可失败构造器要求。协议中定义的非可失败构造器要求可以通过非可失败构造器（`init`）或隐式解包可失败构造器（`init!`）来满足。
-
-## 协议作为类型
+## 协议作为类型 {#protocols-as-types}
-尽管协议本身并未实现任何功能，但是协议可以被当做一个成熟的类型来使用。
+尽管协议本身并未实现任何功能，但是协议可以被当做一个功能完备的类型来使用。
协议可以像其他普通类型一样使用，使用场景如下：
@@ -264,15 +258,15 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
```swift
class Dice {
- let sides: Int
- let generator: RandomNumberGenerator
- init(sides: Int, generator: RandomNumberGenerator) {
- self.sides = sides
- self.generator = generator
- }
- func roll() -> Int {
- return Int(generator.random() * Double(sides)) + 1
- }
+ let sides: Int
+ let generator: RandomNumberGenerator
+ init(sides: Int, generator: RandomNumberGenerator) {
+ self.sides = sides
+ self.generator = generator
+ }
+ func roll() -> Int {
+ return Int(generator.random() * Double(sides)) + 1
+ }
}
```
@@ -289,7 +283,7 @@ class Dice {
```swift
var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
for _ in 1...5 {
- print("Random dice roll is \(d6.roll())")
+ print("Random dice roll is \(d6.roll())")
}
// Random dice roll is 3
// Random dice roll is 5
@@ -298,8 +292,7 @@ for _ in 1...5 {
// Random dice roll is 4
```
-
-## 委托
+## 委托 {#delegation}
*委托*是一种设计模式，它允许类或结构体将一些需要它们负责的功能委托给其他类型的实例。委托模式的实现很简单：定义协议来封装那些需要被委托的功能，这样就能确保遵循协议的类型能提供这些功能。委托模式可以用来响应特定的动作，或者接收外部数据源提供的数据，而无需关心外部数据源的类型。
@@ -317,44 +310,46 @@ protocol DiceGameDelegate {
}
```
-`DiceGame` 协议可以被任意涉及骰子的游戏遵循。`DiceGameDelegate` 协议可以被任意类型遵循，用来追踪 `DiceGame` 的游戏过程。
+`DiceGame` 协议可以被任意涉及骰子的游戏遵循。
-如下所示，`SnakesAndLadders` 是 [控制流](./05_Control_Flow.html) 章节引入的蛇梯棋游戏的新版本。新版本使用 `Dice` 实例作为骰子，并且实现了 `DiceGame` 和 `DiceGameDelegate` 协议，后者用来记录游戏的过程：
+`DiceGameDelegate` 协议可以被任意类型遵循，用来追踪 `DiceGame` 的游戏过程。为了防止强引用导致的循环引用问题，可以把协议声明为弱引用，更多相关的知识请看 [类实例之间的循环强引用](./23_Automatic_Reference_Counting.md#strong_reference_cycles_between_class_instances)，当协议标记为类专属可以使 `SnakesAndLadders` 类在声明协议时强制要使用弱引用。若要声明类专属的协议就必须继承于 `AnyObject` ，更多请看 [类专属的协议](#class_only_protocol)。
+
+如下所示，`SnakesAndLadders` 是 [控制流](./05_Control_Flow.md) 章节引入的蛇梯棋游戏的新版本。新版本使用 `Dice` 实例作为骰子，并且实现了 `DiceGame` 和 `DiceGameDelegate` 协议，后者用来记录游戏的过程：
```swift
class SnakesAndLadders: DiceGame {
- let finalSquare = 25
- let dice = Dice(sides: 6, generator: LinearCongruentialGenerator())
- var square = 0
- var board: [Int]
- init() {
- board = [Int](repeating: 0, count: finalSquare + 1)
- board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
- board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
- }
- var delegate: DiceGameDelegate?
- func play() {
- square = 0
- delegate?.gameDidStart(self)
- gameLoop: while square != finalSquare {
- let diceRoll = dice.roll()
- delegate?.game(self, didStartNewTurnWithDiceRoll: diceRoll)
- switch square + diceRoll {
- case finalSquare:
- break gameLoop
- case let newSquare where newSquare > finalSquare:
- continue gameLoop
- default:
- square += diceRoll
- square += board[square]
- }
- }
- delegate?.gameDidEnd(self)
- }
+ let finalSquare = 25
+ let dice = Dice(sides: 6, generator: LinearCongruentialGenerator())
+ var square = 0
+ var board: [Int]
+ init() {
+ board = Array(repeating: 0, count: finalSquare + 1)
+ board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
+ board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
+ }
+ var delegate: DiceGameDelegate?
+ func play() {
+ square = 0
+ delegate?.gameDidStart(self)
+ gameLoop: while square != finalSquare {
+ let diceRoll = dice.roll()
+ delegate?.game(self, didStartNewTurnWithDiceRoll: diceRoll)
+ switch square + diceRoll {
+ case finalSquare:
+ break gameLoop
+ case let newSquare where newSquare > finalSquare:
+ continue gameLoop
+ default:
+ square += diceRoll
+ square += board[square]
+ }
+ }
+ delegate?.gameDidEnd(self)
+ }
}
```
-关于这个*蛇梯棋*游戏的详细描述请参阅 [中断（Break）](./05_Control_Flow.html#break)。
+关于这个*蛇梯棋*游戏的详细描述请参阅 [中断（Break）](./05_Control_Flow.md#break)。
这个版本的游戏封装到了 `SnakesAndLadders` 类中，该类遵循了 `DiceGame` 协议，并且提供了相应的可读的 `dice` 属性和 `play()` 方法。（ `dice` 属性在构造之后就不再改变，且协议只要求 `dice` 为可读的，因此将 `dice` 声明为常量属性。）
@@ -392,7 +387,7 @@ class DiceGameTracker: DiceGameDelegate {
`gameDidStart(_:)` 方法从 `game` 参数获取游戏信息并打印。`game` 参数是 `DiceGame` 类型而不是 `SnakeAndLadders` 类型，所以在 `gameDidStart(_:)` 方法中只能访问 `DiceGame` 协议中的内容。当然了，`SnakeAndLadders` 的方法也可以在类型转换之后调用。在上例代码中，通过 `is` 操作符检查 `game` 是否为 `SnakesAndLadders` 类型的实例，如果是，则打印出相应的消息。
-无论当前进行的是何种游戏，由于 `game` 遵循 `DiceGame` 协议，可以确保 `game` 含有 `dice` 属性。因此在 `gameDidStart(_:)` 方法中可以通过传入的 `game` 参数来访问 `dice` 属性，进而打印出 `dice` 的 `sides` 属性的值。
+无论当前进行的是何种游戏，由于 `game` 符合 `DiceGame` 协议，可以确保 `game` 含有 `dice` 属性。因此在 `gameDidStart(_:)` 方法中可以通过传入的 `game` 参数来访问 `dice` 属性，进而打印出 `dice` 的 `sides` 属性的值。
`DiceGameTracker` 的运行情况如下所示：
@@ -410,14 +405,13 @@ game.play()
// The game lasted for 4 turns
```
-
-## 在扩展里添加协议遵循
+## 在扩展里添加协议遵循 {#adding-protocol-conformance-with-an-extension}
-即便无法修改源代码，依然可以通过扩展令已有类型遵循协议。扩展可以为已有类型添加属性、方法、下标以及构造器，因此可以遵循协议中的相应要求。详情请在[扩展](./20_Extensions.html)章节中查看。
+即便无法修改源代码，依然可以通过扩展令已有类型遵循并符合协议。扩展可以为已有类型添加属性、方法、下标以及构造器，因此可以符合协议中的相应要求。详情请在 [扩展](./20_Extensions.md) 章节中查看。
> 注意
>
-> 通过扩展令已有类型遵循协议时，该类型的所有实例也会随之获得协议中定义的各项功能。
+> 通过扩展令已有类型遵循并符合协议时，该类型的所有实例也会随之获得协议中定义的各项功能。
例如下面这个 `TextRepresentable` 协议，任何想要通过文本表示一些内容的类型都可以实现该协议。这些想要表示的内容可以是实例本身的描述，也可以是实例当前状态的文本描述：
@@ -427,17 +421,17 @@ protocol TextRepresentable {
}
```
-可以通过扩展，令先前提到的 `Dice` 类遵循 `TextRepresentable` 协议：
+可以通过扩展，令先前提到的 `Dice` 类可以扩展来采纳和遵循 `TextRepresentable` 协议：
```swift
extension Dice: TextRepresentable {
var textualDescription: String {
- return "A \(sides)-sided dice"
- }
+ return "A \(sides)-sided dice"
+ }
}
```
-通过扩展遵循协议，和在原始定义中遵循协议的效果完全相同。协议名称写在类型名之后，以冒号隔开，然后在扩展的大括号内实现协议要求的内容。
+通过扩展遵循并采纳协议，和在原始定义中遵循并符合协议的效果完全相同。协议名称写在类型名之后，以冒号隔开，然后在扩展的大括号内实现协议要求的内容。
现在所有 `Dice` 的实例都可以看做 `TextRepresentable` 类型：
@@ -447,22 +441,21 @@ print(d12.textualDescription)
// 打印 “A 12-sided dice”
```
-同样，`SnakesAndLadders` 类也可以通过扩展遵循 `TextRepresentable` 协议：
+同样，`SnakesAndLadders` 类也可以通过扩展来采纳和遵循 `TextRepresentable` 协议：
```swift
extension SnakesAndLadders: TextRepresentable {
var textualDescription: String {
- return "A game of Snakes and Ladders with \(finalSquare) squares"
- }
+ return "A game of Snakes and Ladders with \(finalSquare) squares"
+ }
}
print(game.textualDescription)
// 打印 “A game of Snakes and Ladders with 25 squares”
```
-
-## 有条件地遵循协议
+## 有条件地遵循协议 {#Conditionally-Conforming-to-a-Protocol}
-泛型类型可能只在某些情况下满足一个协议的要求，比如当类型的泛型形式参数遵循对应协议时。你可以通过在扩展类型时列出限制让泛型类型有条件地遵循某协议。在你遵循协议的名字后面写泛型 `where` 分句。更多关于泛型 `where` 分句，见[泛型 Where 分句](./22_Generics.html##where_clauses)。
+泛型类型可能只在某些情况下满足一个协议的要求，比如当类型的泛型形式参数遵循对应协议时。你可以通过在扩展类型时列出限制让泛型类型有条件地遵循某协议。在你采纳协议的名字后面写泛型 `where` 分句。更多关于泛型 `where` 分句，见 [泛型 Where 分句](./22_Generics.md##where_clauses)。
下面的扩展让 `Array` 类型只要在存储遵循 `TextRepresentable` 协议的元素时就遵循 `TextRepresentable` 协议。
@@ -478,10 +471,9 @@ print(myDice.textualDescription)
// 打印 "[A 6-sided dice, A 12-sided dice]"
```
-
-## 在扩展里声明遵循协议
+## 在扩展里声明采纳协议 {#declaring-protocol-adoption-with-an-extension}
-当一个类型已经遵循了某个协议中的所有要求，却还没有声明遵循该协议时，可以通过空扩展体的扩展遵循该协议：
+当一个类型已经符合了某个协议中的所有要求，却还没有声明采纳该协议时，可以通过空的扩展来让它采纳该协议：
```swift
struct Hamster {
@@ -506,10 +498,9 @@ print(somethingTextRepresentable.textualDescription)
>
> 即使满足了协议的所有要求，类型也不会自动遵循协议，必须显式地遵循协议。
-
-## 协议类型的集合
+## 协议类型的集合 {#collections-of-protocol-types}
-协议类型可以在数组或者字典这样的集合中使用，在[协议类型](./21_Protocols.html##protocols_as_types)提到了这样的用法。下面的例子创建了一个元素类型为 `TextRepresentable` 的数组：
+协议类型可以在数组或者字典这样的集合中使用，在 [协议类型](./21_Protocols.md##protocols_as_types) 提到了这样的用法。下面的例子创建了一个元素类型为 `TextRepresentable` 的数组：
```swift
let things: [TextRepresentable] = [game, d12, simonTheHamster]
@@ -519,17 +510,16 @@ let things: [TextRepresentable] = [game, d12, simonTheHamster]
```swift
for thing in things {
- print(thing.textualDescription)
+ print(thing.textualDescription)
}
// A game of Snakes and Ladders with 25 squares
// A 12-sided dice
// A hamster named Simon
```
-`thing` 是 `TextRepresentable` 类型而不是 `Dice`，`DiceGame`，`Hamster` 等类型，即使实例在幕后确实是这些类型中的一种。由于 `thing` 是 `TextRepresentable` 类型，任何 `TextRepresentable` 的实例都有一个 `textualDescription` 属性，所以在每次循环中可以安全地访问 `thing.textualDescription`。
+注意 `thing` 常量是 `TextRepresentable` 类型而不是 `Dice`，`DiceGame`，`Hamster` 等类型，即使实例在幕后确实是这些类型中的一种。由于 `thing` 是 `TextRepresentable` 类型，任何 `TextRepresentable` 的实例都有一个 `textualDescription` 属性，所以在每次循环中可以安全地访问 `thing.textualDescription`。
-
-## 协议的继承
+## 协议的继承 {#protocol-inheritance}
协议能够*继承*一个或多个其他协议，可以在继承的协议的基础上增加新的要求。协议的继承语法与类的继承相似，多个被继承的协议间用逗号分隔：
@@ -543,13 +533,13 @@ protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
```swift
protocol PrettyTextRepresentable: TextRepresentable {
- var prettyTextualDescription: String { get }
+ var prettyTextualDescription: String { get }
}
```
例子中定义了一个新的协议 `PrettyTextRepresentable`，它继承自 `TextRepresentable` 协议。任何遵循 `PrettyTextRepresentable` 协议的类型在满足该协议的要求时，也必须满足 `TextRepresentable` 协议的要求。在这个例子中，`PrettyTextRepresentable` 协议额外要求遵循协议的类型提供一个返回值为 `String` 类型的 `prettyTextualDescription` 属性。
-如下所示，扩展 `SnakesAndLadders`，使其遵循 `PrettyTextRepresentable` 协议：
+如下所示，扩展 `SnakesAndLadders`，使其遵循并符合 `PrettyTextRepresentable` 协议：
```swift
extension SnakesAndLadders: PrettyTextRepresentable {
@@ -584,25 +574,23 @@ print(game.prettyTextualDescription)
// ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
```
-
-## 类专属的协议
+## 类专属的协议 {#class-only-protocol}
-你通过添加 `AnyObject` 关键字到协议的继承列表，就可以限制协议只能被类类型遵循（以及非结构体或者非枚举的类型）。
+你通过添加 `AnyObject` 关键字到协议的继承列表，就可以限制协议只能被类类型采纳（以及非结构体或者非枚举的类型）。
```swift
-protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
+protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol {
// 这里是类专属协议的定义部分
}
```
-在以上例子中，协议 `SomeClassOnlyProtocol` 只能被类类型遵循。如果尝试让结构体或枚举类型遵循 `SomeClassOnlyProtocol` 协议，则会导致编译时错误。
+在以上例子中，协议 `SomeClassOnlyProtocol` 只能被类类型采纳。如果尝试让结构体或枚举类型采纳 `SomeClassOnlyProtocol`，则会导致编译时错误。
> 注意
>
-> 当协议定义的要求需要遵循协议的类型必须是引用语义而非值语义时，应该采用类类型专属协议。关于引用语义和值语义的更多内容，请查看[结构体和枚举是值类型](./09_Classes_and_Structures.html#structures_and_enumerations_are_value_types)和[类是引用类型](./09_Classes_and_Structures.html#classes_are_reference_types)。
+> 当协议定义的要求需要遵循协议的类型必须是引用语义而非值语义时，应该采用类类型专属协议。关于引用语义和值语义的更多内容，请查看 [结构体和枚举是值类型](./09_Classes_and_Structures.md#structures_and_enumerations_are_value_types) 和 [类是引用类型](./09_Classes_and_Structures.md#classes_are_reference_types)。
-
-## 协议合成
+## 协议合成 {#protocol-composition}
要求一个类型同时遵循多个协议是很有用的。你可以使用*协议组合*来复合多个协议到一个要求里。协议组合行为就和你定义的临时局部协议一样拥有构成中所有协议的需求。协议组合不定义任何新的协议类型。
@@ -629,11 +617,11 @@ wishHappyBirthday(to: birthdayPerson)
// 打印 “Happy birthday Malcolm - you're 21!”
```
-`Named` 协议包含 `String` 类型的 `name` 属性。`Aged` 协议包含 `Int` 类型的 `age` 属性。`Person` 结构体遵循了这两个协议。
+`Named` 协议包含 `String` 类型的 `name` 属性。`Aged` 协议包含 `Int` 类型的 `age` 属性。`Person` 结构体采纳了这两个协议。
-`wishHappyBirthday(to:)` 函数的参数 `celebrator` 的类型为 `Named & Aged`， 这意味着“任何同时遵循 Named 和 Aged 的协议”。它不关心参数的具体类型，只要参数遵循这两个协议即可。
+`wishHappyBirthday(to:)` 函数的参数 `celebrator` 的类型为 `Named & Aged`， 这意味着“任何同时遵循 Named 和 Aged 的协议”。它不关心参数的具体类型，只要参数符合这两个协议即可。
-上面的例子创建了一个名为 `birthdayPerson` 的 `Person` 的实例，作为参数传递给了 `wishHappyBirthday(to:)` 函数。因为 `Person` 同时遵循这两个协议，所以这个参数合法，函数将打印生日问候语。
+上面的例子创建了一个名为 `birthdayPerson` 的 `Person` 的实例，作为参数传递给了 `wishHappyBirthday(to:)` 函数。因为 `Person` 同时符合这两个协议，所以这个参数合法，函数将打印生日问候语。
这里有一个例子：将 Location 类和前面的 Named 协议进行组合：
@@ -656,24 +644,23 @@ class City: Location, Named {
func beginConcert(in location: Location & Named) {
print("Hello, \(location.name)!")
}
-
+
let seattle = City(name: "Seattle", latitude: 47.6, longitude: -122.3)
beginConcert(in: seattle)
-// Prints "Hello, Seattle!"
+// 打印 "Hello, Seattle!"
```
-`beginConcert(in:)` 方法接受一个类型为 `Location & Named` 的参数，这意味着“任何 Location 的子类，并且遵循 Named 协议”。例如，City 就满足这样的条件。
+`beginConcert(in:)` 函数接受一个类型为 `Location & Named` 的参数，这意味着“任何 Location 的子类，并且遵循 Named 协议”。例如，City 就满足这样的条件。
-将 birthdayPerson 传入 `beginConcert(in:)` 函数是不合法的，因为 Person 不是一个 Location 的子类。就像，如果你新建一个类继承与 Location，但是没有遵循 Named 协议，你用这个类的实例去调用 `beginConcert(in:)` 函数也是不合法的。
+将 birthdayPerson 传入 `beginConcert(in:)` 函数是不合法的，因为 Person 不是 Location 的子类。同理，如果你新建一个类继承于 Location，但是没有遵循 Named 协议，而用这个类的实例去调用 `beginConcert(in:)` 函数也是非法的。
-
-## 检查协议遵循
+## 检查协议一致性 {#checking-for-protocol-conformance}
-你可以使用[类型转换](./18_Type_Casting.html)中描述的 `is` 和 `as` 操作符来检查协议遵循，即是否遵循了某协议，并且可以转换到指定的协议类型。检查和转换到某个协议类型在语法上和类型的检查和转换完全相同：
+你可以使用[类型转换](./18_Type_Casting.md)中描述的 `is` 和 `as` 操作符来检查协议一致性，即是否符合某协议，并且可以转换到指定的协议类型。检查和转换协议的语法与检查和转换类型是完全一样的：
-* `is` 用来检查实例是否遵循某个协议，若遵循则返回 `true`，否则返回 `false`。
-* `as?` 返回一个可选值，当实例遵循某个协议时，返回类型为协议类型的可选值，否则返回 `nil`。
-* `as!` 将实例强制向下转换到某个协议类型，如果强转失败，会引发运行时错误。
+* `is` 用来检查实例是否符合某个协议，若符合则返回 `true`，否则返回 `false`；
+* `as?` 返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回 `nil`；
+* `as!` 将实例强制向下转换到某个协议类型，如果强转失败，将触发运行时错误。
下面的例子定义了一个 `HasArea` 协议，该协议定义了一个 `Double` 类型的可读属性 `area`：
@@ -704,8 +691,8 @@ class Country: HasArea {
```swift
class Animal {
- var legs: Int
- init(legs: Int) { self.legs = legs }
+ var legs: Int
+ init(legs: Int) { self.legs = legs }
}
```
@@ -713,15 +700,15 @@ class Animal {
```swift
let objects: [AnyObject] = [
- Circle(radius: 2.0),
- Country(area: 243_610),
- Animal(legs: 4)
+ Circle(radius: 2.0),
+ Country(area: 243_610),
+ Animal(legs: 4)
]
```
`objects` 数组使用字面量初始化，数组包含一个 `radius` 为 `2` 的 `Circle` 的实例，一个保存了英国国土面积的 `Country` 实例和一个 `legs` 为 `4` 的 `Animal` 实例。
-如下所示，`objects` 数组可以被迭代，并对迭代出的每一个元素进行检查，看它是否遵循 `HasArea` 协议：
+如下所示，`objects` 数组可以被迭代，并对迭代出的每一个元素进行检查，看它是否符合 `HasArea` 协议：
```swift
for object in objects {
@@ -736,24 +723,23 @@ for object in objects {
// Something that doesn't have an area
```
-当迭代出的元素遵循 `HasArea` 协议时，将 `as?` 操作符返回的可选值通过可选绑定，绑定到 `objectWithArea` 常量上。`objectWithArea` 是 `HasArea` 协议类型的实例，因此 `area` 属性可以被访问和打印。
+当迭代出的元素符合 `HasArea` 协议时，将 `as?` 操作符返回的可选值通过可选绑定，绑定到 `objectWithArea` 常量上。`objectWithArea` 是 `HasArea` 协议类型的实例，因此 `area` 属性可以被访问和打印。
`objects` 数组中的元素的类型并不会因为强转而丢失类型信息，它们仍然是 `Circle`，`Country`，`Animal` 类型。然而，当它们被赋值给 `objectWithArea` 常量时，只被视为 `HasArea` 类型，因此只有 `area` 属性能够被访问。
-
-## 可选的协议要求
+## 可选的协议要求 {#optional-protocol-requirements}
协议可以定义*可选要求*，遵循协议的类型可以选择是否实现这些要求。在协议中使用 `optional` 关键字作为前缀来定义可选要求。可选要求用在你需要和 Objective-C 打交道的代码中。协议和可选要求都必须带上 `@objc` 属性。标记 `@objc` 特性的协议只能被继承自 Objective-C 类的类或者 `@objc` 类遵循，其他类以及结构体和枚举均不能遵循这种协议。
使用可选要求时（例如，可选的方法或者属性），它们的类型会自动变成可选的。比如，一个类型为 `(Int) -> String` 的方法会变成 `((Int) -> String)?`。需要注意的是整个函数类型是可选的，而不是函数的返回值。
-协议中的可选要求可通过可选链式调用来使用，因为遵循协议的类型可能没有实现这些可选要求。类似 `someOptionalMethod?(someArgument)` 这样，你可以在可选方法名称后加上 `?` 来调用可选方法。详细内容可在[可选链式调用](./16_Optional_Chaining.html)章节中查看。
+协议中的可选要求可通过可选链式调用来使用，因为遵循协议的类型可能没有实现这些可选要求。类似 `someOptionalMethod?(someArgument)` 这样，你可以在可选方法名称后加上 `?` 来调用可选方法。详细内容可在[可选链式调用](./16_Optional_Chaining.md)章节中查看。
-下面的例子定义了一个名为 `Counter` 的用于整数计数的类，它使用外部的数据源来提供每次的增量。数据源由 `CounterDataSource` 协议定义，包含两个可选要求：
+下面的例子定义了一个名为 `Counter` 的用于整数计数的类，它使用外部的数据源来提供每次的增量。数据源由 `CounterDataSource` 协议定义，它包含两个可选要求：
```swift
@objc protocol CounterDataSource {
- @objc optional func incrementForCount(count: Int) -> Int
+ @objc optional func increment(forCount count: Int) -> Int
@objc optional var fixedIncrement: Int { get }
}
```
@@ -771,7 +757,7 @@ class Counter {
var count = 0
var dataSource: CounterDataSource?
func increment() {
- if let amount = dataSource?.incrementForCount?(count) {
+ if let amount = dataSource?.increment?(forCount: count) {
count += amount
} else if let amount = dataSource?.fixedIncrement {
count += amount
@@ -786,7 +772,7 @@ class Counter {
这里使用了两层可选链式调用。首先，由于 `dataSource` 可能为 `nil`，因此在 `dataSource` 后边加上了 `?`，以此表明只在 `dataSource` 非空时才去调用 `increment(forCount:)` 方法。其次，即使 `dataSource` 存在，也无法保证其是否实现了 `increment(forCount:)` 方法，因为这个方法是可选的。因此，`increment(forCount:)` 方法同样使用可选链式调用进行调用，只有在该方法被实现的情况下才能调用它，所以在 `increment(forCount:)` 方法后边也加上了 `?`。
-调用 `increment(forCount:)` 方法在上述两种情形下都有可能失败，所以返回值为 `Int?` 类型。虽然在 `CounterDataSource` 协议中，`increment(forCount:)` 的返回值类型是非可选 `Int`。另外，即使这里使用了两层可选链式调用，最后的返回结果依旧是单层的可选类型。关于这一点的更多信息，请查阅[连接多层可选链式调用](./16_Optional_Chaining)
+调用 `increment(forCount:)` 方法在上述两种情形下都有可能失败，所以返回值为 `Int?` 类型。虽然在 `CounterDataSource` 协议中，`increment(forCount:)` 的返回值类型是非可选 `Int`。另外，即使这里使用了两层可选链式调用，最后的返回结果依旧是单层的可选类型。关于这一点的更多信息，请查阅 [连接多层可选链式调用](./16_Optional_Chaining)
在调用 `increment(forCount:)` 方法后，`Int?` 型的返回值通过可选绑定解包并赋值给常量 `amount`。如果可选值确实包含一个数值，也就是说，数据源和方法都存在，数据源方法返回了一个有效值。之后便将解包后的 `amount` 加到 `count` 上，增量操作完成。
@@ -815,12 +801,12 @@ for _ in 1...4 {
// 12
```
-上述代码新建了一个 `Counter` 实例，并将它的数据源设置为一个 `ThreeSource` 的实例，然后调用 `increment()` 方法四次。和预期一样，每次调用都会将 `count` 的值增加 `3`.
+上述代码新建了一个 `Counter` 实例，并将它的数据源设置为一个 `ThreeSource` 的实例，然后调用 `increment()` 方法 `4` 次。按照预期预期一样，每次调用都会将 `count` 的值增加 `3`.
下面是一个更为复杂的数据源 `TowardsZeroSource`，它将使得最后的值变为 `0`：
```swift
-@objc class TowardsZeroSource: NSObject, CounterDataSource {
+class TowardsZeroSource: NSObject, CounterDataSource {
func increment(forCount count: Int) -> Int {
if count == 0 {
return 0
@@ -833,7 +819,7 @@ for _ in 1...4 {
}
```
-`TowardsZeroSource` 实现了 `CounterDataSource` 协议中的 `increment(forCount:)` 方法，以 `count` 参数为依据，计算出每次的增量。如果 `count` 已经为 `0`，此方法返回 `0`，以此表明之后不应再有增量操作发生。
+`TowardsZeroSource` 实现了 `CounterDataSource` 协议中的 `increment(forCount:)` 方法，以 `count` 参数为依据，计算出每次的增量。如果 `count` 已经为 `0`，此方法将返回 `0`，以此表明之后不应再有增量操作发生。
你可以使用 `TowardsZeroSource` 实例将 `Counter` 实例来从 `-4` 增加到 `0`。一旦增加到 `0`，数值便不会再有变动：
@@ -851,8 +837,7 @@ for _ in 1...5 {
// 0
```
-
-## 协议扩展
+## 协议扩展 {#protocol-extensions}
协议可以通过扩展来为遵循协议的类型提供属性、方法以及下标的实现。通过这种方式，你可以基于协议本身来实现这些功能，而无需在每个遵循协议的类型中都重复同样的实现，也无需使用全局函数。
@@ -866,7 +851,7 @@ extension RandomNumberGenerator {
}
```
-通过协议扩展，所有遵循协议的类型，都能自动获得这个扩展所增加的方法实现，无需任何额外修改：
+通过协议扩展，所有遵循协议的类型，都能自动获得这个扩展所增加的方法实现而无需任何额外修改：
```swift
let generator = LinearCongruentialGenerator()
@@ -876,8 +861,7 @@ print("And here's a random Boolean: \(generator.randomBool())")
// 打印 “And here's a random Boolean: true”
```
-
-### 提供默认实现
+### 提供默认实现 {#providing-default-implementations}
可以通过协议扩展来为协议要求的属性、方法以及下标提供默认的实现。如果遵循协议的类型为这些要求提供了自己的实现，那么这些自定义实现将会替代扩展中的默认实现被使用。
@@ -885,7 +869,7 @@ print("And here's a random Boolean: \(generator.randomBool())")
>
> 通过协议扩展为协议要求提供的默认实现和可选的协议要求不同。虽然在这两种情况下，遵循协议的类型都无需自己实现这些要求，但是通过扩展提供的默认实现可以直接调用，而无需使用可选链式调用。
-例如，`PrettyTextRepresentable` 协议继承自 `TextRepresentable` 协议，可以为其提供一个默认的 `prettyTextualDescription` 属性，只是简单地返回 `textualDescription` 属性的值：
+例如，`PrettyTextRepresentable` 协议继承自 `TextRepresentable` 协议，可以为其提供一个默认的 `prettyTextualDescription` 属性来简单地返回 `textualDescription` 属性的值：
```swift
extension PrettyTextRepresentable {
@@ -895,12 +879,11 @@ extension PrettyTextRepresentable {
}
```
-
-### 为协议扩展添加限制条件
+### 为协议扩展添加限制条件 {#adding-constraints-to-protocol-extensions}
-在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。这些限制条件写在协议名之后，使用 `where` 子句来描述，正如[泛型 Where 子句](./22_Generics.html#where_clauses)中所描述的。
+在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。这些限制条件写在协议名之后，使用 `where` 子句来描述，正如[泛型 Where 子句](./22_Generics.md#where_clauses)中所描述的。
-例如，你可以扩展 `Collection` 协议，适用于集合中的元素遵循了 `Equatable` 协议的情况。通过限制集合元素遵循 `Equatable` 协议， 作为标准库的一部分， 你可以使用 `==` 和 `!=` 操作符来检查两个元素的等价性和非等价性。
+例如，你可以扩展 `Collection` 协议，适用于集合中的元素遵循了 `Equatable` 协议的情况。通过限制集合元素遵 `Equatable` 协议， 作为标准库的一部分， 你可以使用 `==` 和 `!=` 操作符来检查两个元素的等价性和非等价性。
```swift
extension Collection where Element: Equatable {
@@ -917,7 +900,6 @@ extension Collection where Element: Equatable {
如果集合中的所有元素都一致，`allEqual()` 方法才返回 `true`。
-
看看两个整数数组，一个数组的所有元素都是一样的，另一个不一样：
```swift
@@ -927,7 +909,6 @@ let differentNumbers = [100, 100, 200, 100, 200]
由于数组遵循 `Collection` 而且整数遵循 `Equatable`，`equalNumbers` 和 `differentNumbers` 都可以使用 `allEqual()` 方法。
-
```swift
print(equalNumbers.allEqual())
// 打印 "true"
@@ -937,4 +918,4 @@ print(differentNumbers.allEqual())
> 注意
>
-> 如果一个遵循的类型满足了为同一方法或属性提供实现的多个限制型扩展的要求， Swift 使用这个实现方法去匹配那个最特殊的限制。
+> 如果一个遵循的类型满足了为同一方法或属性提供实现的多个限制型扩展的要求， Swift 会使用最匹配限制的实现。
diff --git a/source/chapter2/22_Generics.md b/source/chapter2/22_Generics.md
index 526ec35c..11794432 100644
--- a/source/chapter2/22_Generics.md
+++ b/source/chapter2/22_Generics.md
@@ -1,11 +1,10 @@
# 泛型
-*泛型代码*让你能够根据自定义的需求，编写出适用于任意类型、灵活可重用的函数及类型。它能让你避免代码的重复，用一种清晰和抽象的方式来表达代码的意图。
+*泛型代码*让你能根据自定义的需求，编写出适用于任意类型的、灵活可复用的函数及类型。你可避免编写重复的代码，用一种清晰抽象的方式来表达代码的意图。
-泛型是 Swift 最强大的特性之一，许多 Swift 标准库是通过泛型代码构建的。事实上，泛型的使用贯穿了整本语言手册，只是你可能没有发现而已。例如，Swift 的 `Array` 和 `Dictionary` 都是泛型集合。你可以创建一个 `Int` 数组，也可创建一个 `String` 数组，甚至可以是任意其他 Swift 类型的数组。同样的，你也可以创建存储任意指定类型的字典。
+泛型是 Swift 最强大的特性之一，很多 Swift 标准库是基于泛型代码构建的。实际上，即使你没有意识到，你也一直在*语言指南*中使用泛型。例如，Swift 的 `Array` 和 `Dictionary` 都是泛型集合。你可以创建一个 `Int` 类型数组，也可创建一个 `String` 类型数组，甚至可以是任意其他 Swift 类型的数组。同样，你也可以创建一个存储任意指定类型的字典，并对该类型没有限制。
-
-## 泛型所解决的问题
+## 泛型解决的问题 {#the-problem-that-generics-solve}
下面是一个标准的非泛型函数 `swapTwoInts(_:_:)`，用来交换两个 `Int` 值：
@@ -17,19 +16,19 @@ func swapTwoInts(_ a: inout Int, _ b: inout Int) {
}
```
-这个函数使用输入输出参数（`inout`）来交换 `a` 和 `b` 的值，请参考[输入输出参数](./06_Functions.html#in_out_parameters)。
+这个函数使用输入输出参数（`inout`）来交换 `a` 和 `b` 的值，具体请参考[输入输出参数](./06_Functions.md#in_out_parameters)。
-`swapTwoInts(_:_:)` 函数交换 `b` 的原始值到 `a`，并交换 `a` 的原始值到 `b`。你可以调用这个函数交换两个 `Int` 变量的值：
+`swapTwoInts(_:_:)` 函数将 `b` 的原始值换成了 `a`，将 `a` 的原始值换成了 `b`，你可以调用这个函数来交换两个 `Int` 类型变量：
```swift
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
-// 打印 “someInt is now 107, and anotherInt is now 3”
+// 打印“someInt is now 107, and anotherInt is now 3”
```
-诚然，`swapTwoInts(_:_:)` 函数挺有用，但是它只能交换 `Int` 值，如果你想要交换两个 `String` 值或者 `Double` 值，就不得不写更多的函数，例如 `swapTwoStrings(_:_:)` 和 `swapTwoDoubles(_:_:)`，如下所示：
+`swapTwoInts(_:_:)` 函数很实用，但它只能作用于 `Int` 类型。如果你想交换两个 `String` 类型值，或者 `Double` 类型值，你必须编写对应的函数，类似下面 `swapTwoStrings(_:_:)` 和 `swapTwoDoubles(_:_:)` 函数：
```swift
func swapTwoStrings(_ a: inout String, _ b: inout String) {
@@ -45,7 +44,7 @@ func swapTwoDoubles(_ a: inout Double, _ b: inout Double) {
}
```
-你可能注意到 `swapTwoInts(_:_:)`、`swapTwoStrings(_:_:)` 和 `swapTwoDoubles(_:_:)` 的函数功能都是相同的，唯一不同之处就在于传入的变量类型不同，分别是 `Int`、`String` 和 `Double`。
+你可能注意到了，`swapTwoInts(_:_:‘)`、`swapTwoStrings(_:_:)` 和 `swapTwoDoubles(_:_:)` 函数体是一样的，唯一的区别是它们接受的参数类型（`Int`、`String` 和 `Double`）。
在实际应用中，通常需要一个更实用更灵活的函数来交换两个任意类型的值，幸运的是，泛型代码帮你解决了这种问题。（这些函数的泛型版本已经在下面定义好了。）
@@ -53,10 +52,9 @@ func swapTwoDoubles(_ a: inout Double, _ b: inout Double) {
>
> 在上面三个函数中，`a` 和 `b` 类型必须相同。如果 `a` 和 `b` 类型不同，那它们俩就不能互换值。Swift 是类型安全的语言，所以它不允许一个 `String` 类型的变量和一个 `Double` 类型的变量互换值。试图这样做将导致编译错误。
-
-## 泛型函数
+## 泛型函数 {#generic-functions}
-泛型函数可以适用于任何类型，下面的 `swapTwoValues(_:_:)` 函数是上面三个函数的泛型版本：
+泛型函数可适用于任意类型，下面是函数 `swapTwoInts(_:_:)` 的泛型版本，命名为 `swapTwoValues(_:_:)`：
```swift
func swapTwoValuessome default text
" +// 打印“some default text
” ``` > 注意 @@ -451,7 +442,7 @@ print(heading.asHTML()) ```swift var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") print(paragraph!.asHTML()) -// 打印 "hello, world
" +// 打印“hello, world
” ``` > 注意 @@ -462,7 +453,7 @@ print(paragraph!.asHTML())  -实例的 `asHTML` 属性持有闭包的强引用。但是，闭包在其闭包体内使用了 `self`（引用了 `self.name` 和 `self.text`），因此闭包捕获了 `self`，这意味着闭包又反过来持有了 `HTMLElement` 实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考[值捕获](./07_Closures.html#capturing_values)）。 +实例的 `asHTML` 属性持有闭包的强引用。但是，闭包在其闭包体内使用了 `self`（引用了 `self.name` 和 `self.text`），因此闭包捕获了 `self`，这意味着闭包又反过来持有了 `HTMLElement` 实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考[值捕获](./07_Closures.md#capturing_values)）。 > 注意 > @@ -476,8 +467,7 @@ paragraph = nil 注意，`HTMLElement` 的析构器中的消息并没有被打印，证明了 `HTMLElement` 实例并没有被销毁。 - -## 解决闭包的循环强引用 +## 解决闭包的循环强引用 {#resolving-strong-reference-cycles-for-closures} 在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。 @@ -485,8 +475,7 @@ paragraph = nil > > Swift 有如下要求：只要在闭包内使用 `self` 的成员，就要用 `self.someProperty` 或者 `self.someMethod()`（而不只是 `someProperty` 或 `someMethod()`）。这提醒你可能会一不小心就捕获了 `self`。 - -### 定义捕获列表 +### 定义捕获列表 {#defining-a-capture-list} 捕获列表中的每一项都由一对元素组成，一个元素是 `weak` 或 `unowned` 关键字，另一个元素是类实例的引用（例如 `self`）或初始化过的变量（如 `delegate = self.delegate!`）。这些项在方括号中用逗号分开。 @@ -502,14 +491,13 @@ lazy var someClosure: (Int, String) -> String = { 如果闭包没有指明参数列表或者返回类型，它们会通过上下文推断，那么可以把捕获列表和关键字 `in` 放在闭包最开始的地方： ```swift -lazy var someClosure: Void -> String = { +lazy var someClosure: () -> String = { [unowned self, weak delegate = self.delegate!] in // 这里是闭包的函数体 } ``` - -### 弱引用和无主引用 +### 弱引用和无主引用 {#weak-and-unowned-references} 在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为 `无主引用`。 @@ -527,7 +515,7 @@ class HTMLElement { let name: String let text: String? - lazy var asHTML: Void -> String = { + lazy var asHTML: () -> String = { [unowned self] in if let text = self.text { return "<\(self.name)>\(text)" @@ -555,7 +543,7 @@ class HTMLElement { ```swift var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world") print(paragraph!.asHTML()) -// 打印 "hello, world
" +// 打印“hello, world
” ``` 使用捕获列表后引用关系如下图所示： @@ -566,7 +554,7 @@ print(paragraph!.asHTML()) ```swift paragraph = nil -// 打印 "p is being deinitialized" +// 打印“p is being deinitialized” ``` 你可以查看[捕获列表](../chapter3/04_Expressions.html)章节，获取更多关于捕获列表的信息。 diff --git a/source/chapter2/24_Memory_Safety.md b/source/chapter2/24_Memory_Safety.md index 16c6585e..4bf64961 100644 --- a/source/chapter2/24_Memory_Safety.md +++ b/source/chapter2/24_Memory_Safety.md @@ -4,8 +4,7 @@ Swift 也保证同时访问同一块内存时不会冲突，通过约束代码里对于存储地址的写操作，去获取那一块内存的访问独占权。因为 Swift 自动管理内存，所以大部分时候你完全不需要考虑内存访问的事情。然而，理解潜在的冲突也是很重要的，可以避免你写出访问冲突的代码。而如果你的代码确实存在冲突，那在编译时或者运行时就会得到错误。 - -## 理解内存访问冲突 +## 理解内存访问冲突 {#understanding-conflicting-access-to-memory} 内存的访问，会发生在你给变量赋值，或者传递参数给函数时。例如，下面的代码就包含了读和写的访问： @@ -33,9 +32,7 @@ print("We're number \(one)!") > > 如果你曾经在单线程代码里有访问冲突，Swift 可以保证你在编译或者运行时会得到错误。对于多线程的代码，可以使用 [Thread Sanitizer](https://developer.apple.com/documentation/code_diagnostics/thread_sanitizer) 去帮助检测多线程的冲突。 - - -### 内存访问性质 +### 内存访问性质 {#characteristics-of-memory-access} 内存访问冲突时，要考虑内存访问上下文中的这三个性质：访问是读还是写，访问的时长，以及被访问的存储地址。特别是，冲突会发生在当你有两个访问符合下列的情况： @@ -55,19 +52,18 @@ func oneMore(than number: Int) -> Int { var myNumber = 1 myNumber = oneMore(than: myNumber) print(myNumber) -// 打印 "2" +// 打印“2” ``` 然而，有几种被称为长期访问的内存访问方式，会在别的代码执行时持续进行。瞬时访问和长期访问的区别在于别的代码有没有可能在访问期间同时访问，也就是在时间线上的重叠。一个长期访问可以被别的长期访问或瞬时访问重叠。 重叠的访问主要出现在使用 in-out 参数的函数和方法或者结构体的 mutating 方法里。Swift 代码里典型的长期访问会在后面进行讨论。 - -## In-Out 参数的访问冲突 +## In-Out 参数的访问冲突 {#conflicting-access-to-in-out-parameters} 一个函数会对它所有的 in-out 参数进行长期写访问。in-out 参数的写访问会在所有非 in-out 参数处理完之后开始，直到函数执行完毕为止。如果有多个 in-out 参数，则写访问开始的顺序与参数的顺序一致。 -长期访问的存在会造成一个结果，你不能在访问以 in-out 形式传入后的原变量，即使作用域原则和访问权限允许 —— 任何访问原变量的行为都会造成冲突。例如： +长期访问的存在会造成一个结果，你不能在访问以 in-out 形式传入后的原变量，即使作用域原则和访问权限允许——任何访问原变量的行为都会造成冲突。例如： ```swift var stepSize = 1 @@ -119,8 +115,7 @@ balance(&playerOneScore, &playerOneScore) > > 因为操作符也是函数，它们也会对 in-out 参数进行长期访问。例如，假设 `balance(_:_:)` 是一个名为 `<^>` 的操作符函数，那么 `playerOneScore <^> playerOneScore` 也会造成像 `balance(&playerOneScore, &playerOneScore)` 一样的冲突。 - -## 方法里 self 的访问冲突 +## 方法里 self 的访问冲突 {#conflicting-access-to-self-in-methods} 一个结构体的 mutating 方法会在调用期间对 `self` 进行写访问。例如，想象一下这么一个游戏，每一个玩家都有血量，受攻击时血量会下降，并且有敌人的数量，使用特殊技能时会减少敌人数量。 @@ -162,13 +157,11 @@ oscar.shareHealth(with: &oscar) // 错误：oscar 访问冲突 ``` -mutating 方法在调用期间需要对 `self` 发起写访问，而同时 in-out 参数也需要写访问。在方法里，`self` 和 `teammate` 都指向了同一个存储地址 —— 就像下面展示的那样。对于同一块内存同时进行两个写访问，并且它们重叠了，就此产生了冲突。 +mutating 方法在调用期间需要对 `self` 发起写访问，而同时 in-out 参数也需要写访问。在方法里，`self` 和 `teammate` 都指向了同一个存储地址——就像下面展示的那样。对于同一块内存同时进行两个写访问，并且它们重叠了，就此产生了冲突。  - - -## 属性的访问冲突 +## 属性的访问冲突 {#conflicting-access-to-properties} 如结构体，元组和枚举的类型都是由多个独立的值组成的，例如结构体的属性或元组的元素。因为它们都是值类型，修改值的任何一部分都是对于整个值的修改，意味着其中一个属性的读或写访问都需要访问整一个值。例如，元组元素的写访问重叠会产生冲突： @@ -198,12 +191,10 @@ func someFunction() { 上面的例子里，`oscar` 的 `health` 和 `energy` 都作为 in-out 参数传入了 `balance(_:_:)` 里。编译器可以保证内存安全，因为两个存储属性任何情况下都不会相互影响。 -限制结构体属性的重叠访问对于保证内存安全不是必要的。保证内存安全是必要的，但因为访问独占权的要求比内存安全还要更严格 —— 意味着即使有些代码违反了访问独占权的原则，也是内存安全的，所以如果编译器可以保证这种非专属的访问是安全的，那 Swift 就会允许这种行为的代码运行。特别是当你遵循下面的原则时，它可以保证结构体属性的重叠访问是安全的： +限制结构体属性的重叠访问对于保证内存安全不是必要的。保证内存安全是必要的，但因为访问独占权的要求比内存安全还要更严格——意味着即使有些代码违反了访问独占权的原则，也是内存安全的，所以如果编译器可以保证这种非专属的访问是安全的，那 Swift 就会允许这种行为的代码运行。特别是当你遵循下面的原则时，它可以保证结构体属性的重叠访问是安全的： * 你访问的是实例的存储属性，而不是计算属性或类的属性 * 结构体是本地变量的值，而非全局变量 * 结构体要么没有被闭包捕获，要么只被非逃逸闭包捕获了 如果编译器无法保证访问的安全性，它就不会允许那次访问。 - - diff --git a/source/chapter2/25_Access_Control.md b/source/chapter2/25_Access_Control.md index 8bdebb19..680b217e 100644 --- a/source/chapter2/25_Access_Control.md +++ b/source/chapter2/25_Access_Control.md @@ -10,8 +10,7 @@ Swift 不仅提供了多种不同的访问级别，还为某些典型场景提 > > 为了简单起见，对于代码中可以设置访问级别的特性（属性、基本类型、函数等），在下面的章节中我们会称之为“实体”。 - -## 模块和源文件 +## 模块和源文件 {#modules-and-source-files} Swift 中的访问控制模型基于模块和源文件这两个概念。 @@ -21,8 +20,7 @@ Swift 中的访问控制模型基于模块和源文件这两个概念。 *源文件*就是 Swift 中的源代码文件，它通常属于一个模块，即一个应用程序或者框架。尽管我们一般会将不同的类型分别定义在不同的源文件中，但是同一个源文件也可以包含多个类型、函数之类的定义。 - -## 访问级别 +## 访问级别 {#access-levels} Swift 为代码中的实体提供了五种不同的*访问级别*。这些访问级别不仅与源文件中定义的实体相关，同时也与源文件所属的模块相关。 @@ -42,10 +40,9 @@ Open 只能作用于类和类的成员，它和 Public 的区别如下： 把一个类标记为 `open`，明确的表示你已经充分考虑过外部模块使用此类作为父类的影响，并且设计好了你的类的代码了。 - -### 访问级别基本原则 +### 访问级别基本原则 {#guiding-principle-of-access-levels} -Swift 中的访问级别遵循一个基本原则：*不可以在某个实体中定义访问级别更低（更严格）的实体*。 +Swift 中的访问级别遵循一个基本原则：*实体不能定义在具有更低访问级别（更严格）的实体中*。 例如： @@ -54,34 +51,29 @@ Swift 中的访问级别遵循一个基本原则：*不可以在某个实体中 关于此原则在各种情况下的具体表现，将在下文有所体现。 - -### 默认访问级别 +### 默认访问级别 {#default-access-levels} 如果你没有为代码中的实体显式指定访问级别，那么它们默认为 `internal` 级别（有一些例外情况，稍后会进行说明）。因此，在大多数情况下，我们不需要显式指定实体的访问级别。 - -### 单 target 应用程序的访问级别 +### 单 target 应用程序的访问级别 {#access-levels-for-single-target-apps} 当你编写一个单目标应用程序时，应用的所有功能都是为该应用服务，而不需要提供给其他应用或者模块使用，所以我们不需要明确设置访问级别，使用默认的访问级别 Internal 即可。但是，你也可以使用 `fileprivate` 访问或 `private` 访问级别，用于隐藏一些功能的实现细节。 - -### 框架的访问级别 +### 框架的访问级别 {#access-levels-for-frameworks} 当你开发框架时，就需要把一些对外的接口定义为 Open 或 Public，以便使用者导入该框架后可以正常使用其功能。这些被你定义为对外的接口，就是这个框架的 API。 > 注意 > -> 框架依然会使用默认的 `internal` ，也可以指定为 `fileprivate` 访问或者 `private` 访问级别。当你想把某个实体作为框架的 API 的时候，需显式为其指定开放访问或公开访问级别。 +> 框架的内部实现仍然可以使用默认的访问级别 `internal`，当你需要对框架内部其它部分隐藏细节时可以使用 `private` 或 `fileprivate`。对于框架的对外 API 部分，你就需要将它们设置为 `open` 或 `public` 了。 - -### 单元测试 target 的访问级别 +### 单元测试 target 的访问级别 {#access-levels-for-unit-test-targets} 当你的应用程序包含单元测试 target 时，为了测试，测试模块需要访问应用程序模块中的代码。默认情况下只有 `open` 或 `public` 级别的实体才可以被其他模块访问。然而，如果在导入应用程序模块的语句前使用 `@testable` 特性，然后在允许测试的编译设置（`Build Options -> Enable Testability`）下编译这个应用程序模块，单元测试目标就可以访问应用程序模块中所有内部级别的实体。 - -## 访问控制语法 +## 访问控制语法 {#access-control-syntax} -通过修饰符 `open`，`public`，`internal`，`fileprivate`，`private` 来声明实体的访问级别： +通过修饰符 `open`、`public`、`internal`、`fileprivate`、`private` 来声明实体的访问级别： ```swift public class SomePublicClass {} @@ -102,12 +94,11 @@ class SomeInternalClass {} // 隐式 internal var someInternalConstant = 0 // 隐式 internal ``` - -## 自定义类型 +## 自定义类型 {#custom-types} 如果想为一个自定义类型指定访问级别，在定义类型时进行指定即可。新类型只能在它的访问级别限制范围内使用。例如，你定义了一个 `fileprivate` 级别的类，那这个类就只能在定义它的源文件中使用，可以作为属性类型、函数参数类型或者返回类型，等等。 -一个类型的访问级别也会影响到类型*成员*（属性、方法、构造器、下标）的默认访问级别。如果你将类型指定为 `private` 或者 `fileprivate` 级别，那么该类型的所有成员的默认访问级别也会变成 `private` 或者 `fileprivate` 级别。如果你将类型指定为公开或者 `internal` （或者不明确指定访问级别，而使用默认的 `internal` ），那么该类型的所有成员的默认访问级别将是内部访问。 +一个类型的访问级别也会影响到类型*成员*（属性、方法、构造器、下标）的默认访问级别。如果你将类型指定为 `private` 或者 `fileprivate` 级别，那么该类型的所有成员的默认访问级别也会变成 `private` 或者 `fileprivate` 级别。如果你将类型指定为 `internal` 或 `public`（或者不明确指定访问级别，而使用默认的 `internal` ），那么该类型的所有成员的默认访问级别将是 `internal`。 > 重点 > @@ -135,10 +126,8 @@ fileprivate class SomeFilePrivateClass { // 显式 fileprivate 类 private class SomePrivateClass { // 显式 private 类 func somePrivateMethod() {} // 隐式 private 类成员 } - -```swift - -### 元组类型 +``` +### 元组类型 {#tuple-types} 元组的访问级别将由元组中访问级别最严格的类型来决定。例如，如果你构建了一个包含两种不同类型的元组，其中一个类型为 `internal`，另一个类型为 `private`，那么这个元组的访问级别为 `private`。 @@ -146,8 +135,7 @@ private class SomePrivateClass { // 显式 private 类 > > 元组不同于类、结构体、枚举、函数那样有单独的定义。元组的访问级别是在它被使用时自动推断出的，而无法明确指定。 - -### 函数类型 +### 函数类型 {#function-types} 函数的访问级别根据访问级别最严格的参数类型或返回类型的访问级别来决定。但是，如果这种访问级别不符合函数定义所在环境的默认访问级别，那么就需要明确地指定该函数的访问级别。 @@ -155,7 +143,7 @@ private class SomePrivateClass { // 显式 private 类 ```swift func someFunction() -> (SomeInternalClass, SomePrivateClass) { - // 此处是函数实现部分 + // 此处是函数实现部分 } ``` @@ -165,14 +153,13 @@ func someFunction() -> (SomeInternalClass, SomePrivateClass) { ```swift private func someFunction() -> (SomeInternalClass, SomePrivateClass) { - // 此处是函数实现部分 + // 此处是函数实现部分 } ``` 将该函数指定为 `public` 或 `internal`，或者使用默认的访问级别 `internal` 都是错误的，因为如果把该函数当做 `public` 或 `internal` 级别来使用的话，可能会无法访问 `private` 级别的返回值。 - -### 枚举类型 +### 枚举类型 {#enumeration-types} 枚举成员的访问级别和该枚举类型相同，你不能为枚举成员单独指定不同的访问级别。 @@ -180,25 +167,22 @@ private func someFunction() -> (SomeInternalClass, SomePrivateClass) { ```swift public enum CompassPoint { - case North - case South - case East - case West + case north + case south + case east + case west } ``` - -#### 原始值和关联值 +#### 原始值和关联值 {#raw-values-and-associated-values} 枚举定义中的任何原始值或关联值的类型的访问级别至少不能低于枚举类型的访问级别。例如，你不能在一个 `internal` 的枚举中定义 `private` 的原始值类型。 - -### 嵌套类型 +### 嵌套类型 {#nested-types} 如果在 `private` 的类型中定义嵌套类型，那么该嵌套类型就自动拥有 `private` 访问级别。如果在 `public` 或者 `internal` 级别的类型中定义嵌套类型，那么该嵌套类型自动拥有 `internal` 访问级别。如果想让嵌套类型拥有 `public` 访问级别，那么需要明确指定该嵌套类型的访问级别。 - -## 子类 +## 子类 {#subclassing} 子类的访问级别不得高于父类的访问级别。例如，父类的访问级别是 `internal`，子类的访问级别就不能是 `public`。 @@ -208,11 +192,11 @@ public enum CompassPoint { ```swift public class A { - private func someMethod() {} + fileprivate func someMethod() {} } internal class B: A { - override internal func someMethod() {} + override internal func someMethod() {} } ``` @@ -220,7 +204,7 @@ internal class B: A { ```swift public class A { - private func someMethod() {} + fileprivate func someMethod() {} } internal class B: A { @@ -232,8 +216,7 @@ internal class B: A { 因为父类 `A` 和子类 `B` 定义在同一个源文件中，所以在子类 `B` 可以在重写的 `someMethod()` 方法中调用 `super.someMethod()`。 - -## 常量、变量、属性、下标 +## 常量、变量、属性、下标 {#constants-variables-properties-subscripts} 常量、变量、属性不能拥有比它们的类型更高的访问级别。例如，你不能定义一个 `public` 级别的属性，但是它的类型却是 `private` 级别的。同样，下标也不能拥有比索引类型或返回类型更高的访问级别。 @@ -243,8 +226,7 @@ internal class B: A { private var privateInstance = SomePrivateClass() ``` - -### Getter 和 Setter +### Getter 和 Setter {#getters-and-setters} 常量、变量、属性、下标的 `Getters` 和 `Setters` 的访问级别和它们所属类型的访问级别相同。 @@ -279,7 +261,7 @@ stringToEdit.value = "This string will be tracked." stringToEdit.value += " This edit will increment numberOfEdits." stringToEdit.value += " So will this one." print("The number of edits is \(stringToEdit.numberOfEdits)") -// 打印 “The number of edits is 3” +// 打印“The number of edits is 3” ``` 虽然你可以在其他的源文件中实例化该结构体并且获取到 `numberOfEdits` 属性的值，但是你不能对其进行赋值。这一限制保护了该记录功能的实现细节，同时还提供了方便的访问方式。 @@ -298,29 +280,25 @@ public struct TrackedString { } ``` - -## 构造器 +## 构造器 {#initializers} -自定义构造器的访问级别可以低于或等于其所属类型的访问级别。唯一的例外是[必要构造器](./14_Initialization.html#required_initializers)，它的访问级别必须和所属类型的访问级别相同。 +自定义构造器的访问级别可以低于或等于其所属类型的访问级别。唯一的例外是[必要构造器](./14_Initialization.md#required_initializers)，它的访问级别必须和所属类型的访问级别相同。 如同函数或方法的参数，构造器参数的访问级别也不能低于构造器本身的访问级别。 - -### 默认构造器 +### 默认构造器 {#default-initializers} -如[默认构造器](./14_Initialization.html#default_initializers)所述，Swift 会为结构体和类提供一个默认的无参数的构造器，只要它们为所有存储型属性设置了默认初始值，并且未提供自定义的构造器。 +如[默认构造器](./14_Initialization.md#default_initializers)所述，Swift 会为结构体和类提供一个默认的无参数的构造器，只要它们为所有存储型属性设置了默认初始值，并且未提供自定义的构造器。 默认构造器的访问级别与所属类型的访问级别相同，除非类型的访问级别是 `public`。如果一个类型被指定为 `public` 级别，那么默认构造器的访问级别将为 `internal`。如果你希望一个 `public` 级别的类型也能在其他模块中使用这种无参数的默认构造器，你只能自己提供一个 `public` 访问级别的无参数构造器。 - -### 结构体默认的成员逐一构造器 +### 结构体默认的成员逐一构造器 {#default-memberwise-initializers-for-structure-types} 如果结构体中任意存储型属性的访问级别为 `private`，那么该结构体默认的成员逐一构造器的访问级别就是 `private`。否则，这种构造器的访问级别依然是 `internal`。 如同前面提到的默认构造器，如果你希望一个 `public` 级别的结构体也能在其他模块中使用其默认的成员逐一构造器，你依然只能自己提供一个 `public` 访问级别的成员逐一构造器。 - -## 协议 +## 协议 {#protocols} 如果想为一个协议类型明确地指定访问级别，在定义协议时指定即可。这将限制该协议只能在适当的访问级别范围内被遵循。 @@ -330,13 +308,11 @@ public struct TrackedString { > > 如果你定义了一个 `public` 访问级别的协议，那么该协议的所有实现也会是 `public` 访问级别。这一点不同于其他类型，例如，当类型是 `public` 访问级别时，其成员的访问级别却只是 `internal`。 - -### 协议继承 +### 协议继承 {#protocol-inheritance} 如果定义了一个继承自其他协议的新协议，那么新协议拥有的访问级别最高也只能和被继承协议的访问级别相同。例如，你不能将继承自 `internal` 协议的新协议定义为 `public` 协议。 - -### 协议遵循 +### 协议遵循 {#protocol-conformance} 一个类型可以遵循比它级别更低的协议。例如，你可以定义一个 `public` 级别类型，它能在别的模块中使用，但是如果它遵循一个 `internal` 协议，这个遵循的部分就只能在这个 `internal` 协议所在的模块中使用。 @@ -348,8 +324,7 @@ public struct TrackedString { > > Swift 和 Objective-C 一样，协议遵循是全局的，也就是说，在同一程序中，一个类型不可能用两种不同的方式实现同一个协议。 - -## Extension +## Extension {#extensions} Extension 可以在访问级别允许的情况下对类、结构体、枚举进行扩展。Extension 的成员具有和原始类型成员一致的访问级别。例如，你使用 extension 扩展了一个 `public` 或者 `internal` 类型，extension 中的成员就默认使用 `internal` 访问级别，和原始类型中的成员一致。如果你使用 extension 扩展了一个 `private` 类型，则 extension 的成员默认使用 `private` 访问级别。 @@ -357,8 +332,7 @@ Extension 可以在访问级别允许的情况下对类、结构体、枚举进 如果你使用 extension 来遵循协议的话，就不能显式地声明 extension 的访问级别。extension 每个 protocol 要求的实现都默认使用 protocol 的访问级别。 - -### Extension 的私有成员 +### Extension 的私有成员 {#Private Members in Extensions} 扩展同一文件内的类，结构体或者枚举，extension 里的代码会表现得跟声明在原类型里的一模一样。也就是说你可以这样： @@ -370,7 +344,7 @@ Extension 可以在访问级别允许的情况下对类、结构体、枚举进 ```swift protocol SomeProtocol { - func doSomething() {} + func doSomething() } ``` @@ -388,13 +362,11 @@ extension SomeStruct: SomeProtocol { } ``` - -## 泛型 +## 泛型 {#generics} 泛型类型或泛型函数的访问级别取决于泛型类型或泛型函数本身的访问级别，还需结合类型参数的类型约束的访问级别，根据这些访问级别中的最低访问级别来确定。 - -## 类型别名 +## 类型别名 {#type-aliases} 你定义的任何类型别名都会被当作不同的类型，以便于进行访问控制。类型别名的访问级别不可高于其表示的类型的访问级别。例如，`private` 级别的类型别名可以作为 `private`、`file-private`、`internal`、`public` 或者 `open` 类型的别名，但是 `public` 级别的类型别名只能作为 `public` 类型的别名，不能作为 `internal`、`file-private` 或 `private` 类型的别名。 diff --git a/source/chapter2/26_Advanced_Operators.md b/source/chapter2/26_Advanced_Operators.md index 1300d7b9..ee1a99ae 100644 --- a/source/chapter2/26_Advanced_Operators.md +++ b/source/chapter2/26_Advanced_Operators.md @@ -1,108 +1,101 @@ # 高级运算符 -除了在之前介绍过的[基本运算符](./02_Basic_Operators.html)，Swift 中还有许多可以对数值进行复杂运算的高级运算符。这些高级运算符包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。 +除了之前介绍过的[基本运算符](./02_Basic_Operators.md)，Swift 还提供了数种可以对数值进行复杂运算的高级运算符。它们包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。 与 C 语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符（`&+`）。所有的这些溢出运算符都是以 `&` 开头的。 -自定义结构体、类和枚举时，如果也为它们提供标准 Swift 运算符的实现，将会非常有用。在 Swift 中自定义运算符非常简单，运算符也会针对不同类型使用对应实现。 +自定义结构体、类和枚举时，如果也为它们提供标准 Swift 运算符的实现，将会非常有用。在 Swift 中为这些运算符提供自定义的实现非常简单，运算符也会针对不同类型使用对应实现。 -我们不用被预定义的运算符所限制。在 Swift 中可以自由地定义中缀、前缀、后缀和赋值运算符，以及相应的优先级与结合性。这些运算符在代码中可以像预定义的运算符一样使用，我们甚至可以扩展已有的类型以支持自定义的运算符。 +我们不用被预定义的运算符所限制。在 Swift 中可以自由地定义中缀、前缀、后缀和赋值运算符，它们具有自定义的优先级与关联值。这些运算符在代码中可以像预定义的运算符一样使用，你甚至可以扩展已有的类型以支持自定义运算符。 - -## 位运算符 +## 位运算符 {#bitwise-operators} *位运算符*可以操作数据结构中每个独立的比特位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。 Swift 支持 C 语言中的全部位运算符，接下来会一一介绍。 - -### 按位取反运算符 +### Bitwise NOT Operator（按位取反运算符） {#bitwise-not-operator} -*按位取反运算符（`~`）*可以对一个数值的全部比特位进行取反： +*按位取反运算符（`~`）*对一个数值的全部比特位进行取反：  -按位取反运算符是一个前缀运算符，需要直接放在运算的数之前，并且它们之间不能添加任何空格： +按位取反运算符是一个前缀运算符，直接放在运算数之前，并且它们之间不能添加任何空格： -```swift +```Swift let initialBits: UInt8 = 0b00001111 let invertedBits = ~initialBits // 等于 0b11110000 ``` -`UInt8` 类型的整数有 8 个比特位，可以存储 `0 ~ 255` 之间的任意整数。这个例子初始化了一个 `UInt8` 类型的整数，并赋值为二进制的 `00001111`，它的前 4 位都为 `0`，后 4 位都为 `1`。这个值等价于十进制的 `15`。 +`UInt8` 类型的整数有 8 个比特位，可以存储 `0 ~ 255` 之间的任意整数。这个例子初始化了一个 `UInt8` 类型的整数，并赋值为二进制的 `00001111`，它的前 4 位为 `0`，后 4 位为 `1`。这个值等价于十进制的 `15`。 接着使用按位取反运算符创建了一个名为 `invertedBits` 的常量，这个常量的值与全部位取反后的 `initialBits` 相等。即所有的 `0` 都变成了 `1`，同时所有的 `1` 都变成 `0`。`invertedBits` 的二进制值为 `11110000`，等价于无符号十进制数的 `240`。 - -### 按位与运算符 +### Bitwise AND Operator（按位与运算符） {#bitwise-and-operator} -*按位与运算符（`&`）*可以对两个数的比特位进行合并。它返回一个新的数，只有当两个数的对应位都为 `1` 的时候，新数的对应位才为 `1`： +*按位与运算符（`&`）* 对两个数的比特位进行合并。它返回一个新的数，只有当两个数的对应位*都*为 `1` 的时候，新数的对应位才为 `1`：  -在下面的示例当中，`firstSixBits` 和 `lastSixBits` 中间 4 个位的值都为 `1`。按位与运算符对它们进行了运算，得到二进制数值 `00111100`，等价于无符号十进制数的 `60`： +在下面的示例当中，`firstSixBits` 和 `lastSixBits` 中间 4 个位的值都为 `1`。使用按位与运算符之后，得到二进制数值 `00111100`，等价于无符号十进制数的 `60`： -```swift +```Swift let firstSixBits: UInt8 = 0b11111100 let lastSixBits: UInt8 = 0b00111111 let middleFourBits = firstSixBits & lastSixBits // 等于 00111100 ``` - -### 按位或运算符 +### Bitwise OR Operator（按位或运算符） {#bitwise-or-operator} -*按位或运算符（`|`）*可以对两个数的比特位进行比较。它返回一个新的数，只要两个数的对应位中有任意一个为 `1` 时，新数的对应位就为 `1`： +*按位或运算符（`|`）*可以对两个数的比特位进行比较。它返回一个新的数，只要两个数的对应位中有*任意一个*为 `1` 时，新数的对应位就为 `1`： - + -在下面的示例中，`someBits` 和 `moreBits` 不同的位会被设置为 `1`。接位或运算符对它们进行了运算，得到二进制数值 `11111110`，等价于无符号十进制数的 `254`： +在下面的示例中，`someBits` 和 `moreBits` 存在不同的位被设置为 `1`。使用按位或运算符之后，得到二进制数值 `11111110`，等价于无符号十进制数的 `254`： -```swift +```Swift let someBits: UInt8 = 0b10110010 let moreBits: UInt8 = 0b01011110 let combinedbits = someBits | moreBits // 等于 11111110 ``` - -### 按位异或运算符 +### Bitwise XOR Operator（按位异或运算符） {#bitwise-xor-operator} -*按位异或运算符（`^`）*可以对两个数的比特位进行比较。它返回一个新的数，当两个数的对应位不相同时，新数的对应位就为 `1`： +*按位异或运算符*，或称“排外的或运算符”（`^`），可以对两个数的比特位进行比较。它返回一个新的数，当两个数的对应位不相同时，新数的对应位就为 `1`，并且对应位相同时则为 `0`： - + -在下面的示例当中，`firstBits` 和 `otherBits` 都有一个自己的位为 `1` 而对方的对应位为 `0` 的位。 按位异或运算符将新数的这两个位都设置为 `1`，同时将其它位都设置为 `0`： +在下面的示例当中，`firstBits` 和 `otherBits` 都有一个自己为 `1`，而对方为 `0` 的位。按位异或运算符将新数的这两个位都设置为 `1`。在其余的位上 `firstBits` 和 `otherBits` 是相同的，所以设置为 `0`： -```swift +```Swift let firstBits: UInt8 = 0b00010100 let otherBits: UInt8 = 0b00000101 let outputBits = firstBits ^ otherBits // 等于 00010001 ``` - -### 按位左移、右移运算符 +### Bitwise Left and Right Shift Operators（按位左移、右移运算符） {#bitwise-left-and-right-shift-operators} -*按位左移运算符（`<<`）*和*按位右移运算符（`>>`）*可以对一个数的所有位进行指定位数的左移和右移，但是需要遵守下面定义的规则。 +*按位左移运算符（`<<`）* 和 *按位右移运算符（`>>`）*可以对一个数的所有位进行指定位数的左移和右移，但是需要遵守下面定义的规则。 对一个数进行按位左移或按位右移，相当于对这个数进行乘以 2 或除以 2 的运算。将一个整数左移一位，等价于将这个数乘以 2，同样地，将一个整数右移一位，等价于将这个数除以 2。 - -#### 无符号整数的移位运算 +#### 无符号整数的移位运算 {#shifting-behavior-for-unsigned-integers} 对无符号整数进行移位的规则如下： -1. 已经存在的位按指定的位数进行左移和右移。 +1. 已存在的位按指定的位数进行左移和右移。 2. 任何因移动而超出整型存储范围的位都会被丢弃。 3. 用 `0` 来填充移位后产生的空白位。 这种方法称为*逻辑移位*。 -以下这张图展示了 `11111111 << 1`（即把 `11111111` 向左移动 `1` 位），和 `11111111 >> 1`（即把 `11111111` 向右移动 `1` 位）的结果。蓝色的部分是被移位的，灰色的部分是被抛弃的，橙色的部分则是被填充进来的： +以下这张图展示了 `11111111 << 1`（即把 `11111111` 向左移动 `1` 位），和 `11111111 >> 1`（即把 `11111111` 向右移动 `1` 位）的结果。蓝色的数字是被移位的，灰色的数字是被抛弃的，橙色的 `0` 则是被填充进来的： - + 下面的代码演示了 Swift 中的移位运算： -```swift +```Swift let shiftBits: UInt8 = 4 // 即二进制的 00000100 shiftBits << 1 // 00001000 shiftBits << 2 // 00010000 @@ -113,105 +106,100 @@ shiftBits >> 2 // 00000001 可以使用移位运算对其他的数据类型进行编码和解码： -```swift +```Swift let pink: UInt32 = 0xCC6699 let redComponent = (pink & 0xFF0000) >> 16 // redComponent 是 0xCC，即 204 let greenComponent = (pink & 0x00FF00) >> 8 // greenComponent 是 0x66， 即 102 let blueComponent = pink & 0x0000FF // blueComponent 是 0x99，即 153 ``` -这个示例使用了一个命名为 `pink` 的 `UInt32` 型常量来存储 CSS 中粉色的颜色值。该 CSS 的十六进制颜色值 `#CC6699`，在 Swift 中表示为 `0xCC6699`。然后利用按位与运算符（`&`）和按位右移运算符（`>>`）从这个颜色值中分解出红（`CC`）、绿（`66`）以及蓝（`99`）三个部分。 +这个示例使用了一个命名为 `pink` 的 `UInt32` 型常量来存储 Cascading Style Sheets（CSS）中粉色的颜色值。该 CSS 的颜色值 `#CC6699`，在 Swift 中表示为十六进制的 `0xCC6699`。然后利用按位与运算符（`&`）和按位右移运算符（`>>`）从这个颜色值中分解出红（`CC`）、绿（`66`）以及蓝（`99`）三个部分。 红色部分是通过对 `0xCC6699` 和 `0xFF0000` 进行按位与运算后得到的。`0xFF0000` 中的 `0` 部分“掩盖”了 `OxCC6699` 中的第二、第三个字节，使得数值中的 `6699` 被忽略，只留下 `0xCC0000`。 -然后，再将这个数按向右移动 16 位（`>> 16`）。十六进制中每两个字符表示 8 个比特位，所以移动 16 位后 `0xCC0000` 就变为 `0x0000CC`。这个数和 `0xCC` 是等同的，也就是十进制数值的 `204`。 +然后，将这个数向右移动 16 位（`>> 16`）。十六进制中每两个字符占用 8 个比特位，所以移动 16 位后 `0xCC0000` 就变为 `0x0000CC`。这个数和 `0xCC` 是等同的，也就是十进制数值的 `204`。 同样的，绿色部分通过对 `0xCC6699` 和 `0x00FF00` 进行按位与运算得到 `0x006600`。然后将这个数向右移动 8 位，得到 `0x66`，也就是十进制数值的 `102`。 -最后，蓝色部分通过对 `0xCC6699` 和 `0x0000FF` 进行按位与运算得到 `0x000099`。这里不需要再向右移位，所以结果为 `0x99` ，也就是十进制数值的 `153`。 +最后，蓝色部分通过对 `0xCC6699` 和 `0x0000FF` 进行按位与运算得到 `0x000099`。这里不需要再向右移位，而 `0x000099` 也就是 `0x99` ，也就是十进制数值的 `153`。 - -#### 有符号整数的移位运算 +#### 有符号整数的移位运算 {#shifting-behavior-for-signed-integers} -对比无符号整数，有符号整数的移位运算相对复杂得多，这种复杂性源于有符号整数的二进制表现形式。（为了简单起见，以下的示例都是基于 8 比特位的有符号整数的，但是其中的原理对任何位数的有符号整数都是通用的。） +对比无符号整数，有符号整数的移位运算相对复杂得多，这种复杂性源于有符号整数的二进制表现形式。（为了简单起见，以下的示例都是基于 8 比特的有符号整数，但是其中的原理对任何位数的有符号整数都是通用的。） -有符号整数使用第 1 个比特位（通常被称为符号位）来表示这个数的正负。符号位为 `0` 代表正数，为 `1` 代表负数。 +有符号整数使用第 1 个比特位（通常被称为*符号位*）来表示这个数的正负。符号位为 `0` 代表正数，为 `1` 代表负数。 -其余的比特位（通常被称为数值位）存储了实际的值。有符号正整数和无符号数的存储方式是一样的，都是从 `0` 开始算起。这是值为 `4` 的 `Int8` 型整数的二进制位表现形式： +其余的比特位（通常被称为*数值位*）存储了实际的值。有符号正整数和无符号数的存储方式是一样的，都是从 `0` 开始算起。这是值为 `4` 的 `Int8` 型整数的二进制位表现形式： - + -符号位为 `0`，说明这是一个正数，另外 7 位则代表了十进制数值 `4` 的二进制表示。 +符号位为 `0`（代表这是一个“正数”），另外 7 位则代表了十进制数值 `4` 的二进制表示。 -负数的存储方式略有不同。它存储的值的绝对值等于 `2` 的 `n` 次方减去它的实际值（也就是数值位表示的值），这里的 `n` 为数值位的比特位数。一个 8 比特位的数有 7 个比特位是数值位，所以是 `2` 的 `7` 次方，即 `128`。 +负数的存储方式略有不同。它存储 `2` 的 `n` 次方减去其实际值的绝对值，这里的 `n` 是数值位的位数。一个 8 比特位的数有 7 个比特位是数值位，所以是 `2` 的 `7` 次方，即 `128`。 -这是值为 `-4` 的 `Int8` 型整数的二进制位表现形式： +这是值为 `-4` 的 `Int8` 型整数的二进制表现形式： - + 这次的符号位为 `1`，说明这是一个负数，另外 7 个位则代表了数值 `124`（即 `128 - 4`）的二进制表示： - + -负数的表示通常被称为*二进制补码*表示。用这种方法来表示负数乍看起来有点奇怪，但它有几个优点。 +负数的表示通常被称为*二进制补码*。用这种方法来表示负数乍看起来有点奇怪，但它有几个优点。 -首先，如果想对 `-1` 和 `-4` 进行加法运算，我们只需要将这两个数的全部 8 个比特位进行相加，并且将计算结果中超出 8 位的数值丢弃： +首先，如果想对 `-1` 和 `-4` 进行加法运算，我们只需要对这两个数的全部 8 个比特位执行标准的二进制相加（包括符号位），并且将计算结果中超出 8 位的数值丢弃： - + -其次，使用二进制补码可以使负数的按位左移和右移运算得到跟正数同样的效果，即每向左移一位就将自身的数值乘以 2，每向右一位就将自身的数值除以 2。要达到此目的，对有符号整数的右移有一个额外的规则： +其次，使用二进制补码可以使负数的按位左移和右移运算得到跟正数同样的效果，即每向左移一位就将自身的数值乘以 2，每向右一位就将自身的数值除以 2。要达到此目的，对有符号整数的右移有一个额外的规则：当对有符号整数进行按位右移运算时，遵循与无符号整数相同的规则，但是对于移位产生的空白位使用*符号位*进行填充，而不是用 `0`。 -* 当对整数进行按位右移运算时，遵循与无符号整数相同的规则，但是对于移位产生的空白位使用*符号位*进行填充，而不是用 `0`。 - - + 这个行为可以确保有符号整数的符号位不会因为右移运算而改变，这通常被称为*算术移位*。 由于正数和负数的特殊存储方式，在对它们进行右移的时候，会使它们越来越接近 `0`。在移位的过程中保持符号位不变，意味着负整数在接近 `0` 的过程中会一直保持为负。 - -## 溢出运算符 +## 溢出运算符 {#overflow-operators} -在默认情况下，当向一个整数赋予超过它容量的值时，Swift 默认会报错，而不是生成一个无效的数。这个行为为我们在运算过大或着过小的数的时候提供了额外的安全性。 +当向一个整数类型的常量或者变量赋予超过它容量的值时，Swift 默认会报错，而不是允许生成一个无效的数。这个行为为我们在运算过大或者过小的数时提供了额外的安全性。 -例如，`Int16` 型整数能容纳的有符号整数范围是 `-32768` 到 `32767`，当为一个 `Int16` 型变量赋的值超过这个范围时，系统就会报错： +例如，`Int16` 型整数能容纳的有符号整数范围是 `-32768` 到 `32767`。当为一个 `Int16` 类型的变量或常量赋予的值超过这个范围时，系统就会报错： -```swift +```Swift var potentialOverflow = Int16.max // potentialOverflow 的值是 32767，这是 Int16 能容纳的最大整数 potentialOverflow += 1 // 这里会报错 ``` -为过大或者过小的数值提供错误处理，能让我们在处理边界值时更加灵活。 +在赋值时为过大或者过小的情况提供错误处理，能让我们在处理边界值时更加灵活。 -然而，也可以选择让系统在数值溢出的时候采取截断处理，而非报错。可以使用 Swift 提供的三个溢出运算符来让系统支持整数溢出运算。这些运算符都是以 `&` 开头的： +然而，当你希望的时候也可以选择让系统在数值溢出的时候采取截断处理，而非报错。Swift 提供的三个*溢出运算符*来让系统支持整数溢出运算。这些运算符都是以 `&` 开头的： * 溢出加法 `&+` * 溢出减法 `&-` * 溢出乘法 `&*` - -### 数值溢出 +### 数值溢出 {#value-overflow} 数值有可能出现上溢或者下溢。 这个示例演示了当我们对一个无符号整数使用溢出加法（`&+`）进行上溢运算时会发生什么： -```swift +```Swift var unsignedOverflow = UInt8.max // unsignedOverflow 等于 UInt8 所能容纳的最大整数 255 unsignedOverflow = unsignedOverflow &+ 1 // 此时 unsignedOverflow 等于 0 ``` -`unsignedOverflow` 被初始化为 `UInt8` 所能容纳的最大整数（`255`，以二进制表示即 `11111111`）。然后使用了溢出加法运算符（`&+`）对其进行加 `1` 运算。这使得它的二进制表示正好超出 `UInt8` 所能容纳的位数，也就导致了数值的溢出，如下图所示。数值溢出后，留在 `UInt8` 边界内的值是 `00000000`，也就是十进制数值的 `0`。 +`unsignedOverflow` 被初始化为 `UInt8` 所能容纳的最大整数（`255`，以二进制表示即 `11111111`）。然后使用溢出加法运算符（`&+`）对其进行加 `1` 运算。这使得它的二进制表示正好超出 `UInt8` 所能容纳的位数，也就导致了数值的溢出，如下图所示。数值溢出后，仍然留在 `UInt8` 边界内的值是 `00000000`，也就是十进制数值的 `0`。 - + -同样地，当我们对一个无符号整数使用溢出减法（`&-`）进行下溢运算时也会产生类似的现象： +当允许对一个无符号整数进行下溢运算时也会产生类似的情况。这里有一个使用溢出减法运算符（`&-`）的例子： -```swift +```Swift var unsignedOverflow = UInt8.min // unsignedOverflow 等于 UInt8 所能容纳的最小整数 0 unsignedOverflow = unsignedOverflow &- 1 @@ -220,38 +208,37 @@ unsignedOverflow = unsignedOverflow &- 1 `UInt8` 型整数能容纳的最小值是 `0`，以二进制表示即 `00000000`。当使用溢出减法运算符对其进行减 `1` 运算时，数值会产生下溢并被截断为 `11111111`， 也就是十进制数值的 `255`。 - + -溢出也会发生在有符号整型数值上。在对有符号整型数值进行溢出加法或溢出减法运算时，符号位也需要参与计算，正如[按位左移、右移运算符](#bitwise_left_and_right_shift_operators)所描述的。 +溢出也会发生在有符号整型上。针对有符号整型的所有溢出加法或者减法运算都是按位运算的方式执行的，符号位也需要参与计算，正如[按位左移、右移运算符](#bitwise_left_and_right_shift_operators)所描述的。 -```swift +```Swift var signedOverflow = Int8.min // signedOverflow 等于 Int8 所能容纳的最小整数 -128 signedOverflow = signedOverflow &- 1 // 此时 signedOverflow 等于 127 ``` -`Int8` 型整数能容纳的最小值是 `-128`，以二进制表示即 `10000000`。当使用溢出减法运算符对其进行减 `1` 运算时，符号位被翻转，得到二进制数值 `01111111`，也就是十进制数值的 `127`，这个值也是 `Int8` 型整数所能容纳的最大值。 +`Int8` 型整数能容纳的最小值是 `-128`，以二进制表示即 `10000000`。当使用溢出减法运算符对其进行减 `1` 运算时，符号位被翻转，得到二进制数值 `01111111`，也就是十进制数值的 `127`，这个值也是 `Int8` 型整所能容纳的最大值。 - + -对于无符号与有符号整型数值来说，当出现上溢时，它们会从数值所能容纳的最大数变成最小的数。同样地，当发生下溢时，它们会从所能容纳的最小数变成最大的数。 +对于无符号与有符号整型数值来说，当出现上溢时，它们会从数值所能容纳的最大数变成最小数。同样地，当发生下溢时，它们会从所能容纳的最小数变成最大数。 - -## 优先级和结合性 +## 优先级和结合性 {#precedence-and-associativity} -运算符的*优先级*使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。 +运算符的*优先级*使得一些运算符优先于其他运算符；它们会先被执行。 -*结合性*定义了相同优先级的运算符是如何结合的，也就是说，是与左边结合为一组，还是与右边结合为一组。可以将这意思理解为“它们是与左边的表达式结合的”或者“它们是与右边的表达式结合的”。 +*结合性*定义了相同优先级的运算符是如何结合的，也就是说，是与左边结合为一组，还是与右边结合为一组。可以将其理解为“它们是与左边的表达式结合的”，或者“它们是与右边的表达式结合的”。 -在复合表达式的运算顺序中，运算符的优先级和结合性是非常重要的。举例来说，运算符优先级解释了为什么下面这个表达式的运算结果会是 `17`。 +当考虑一个复合表达式的计算顺序时，运算符的优先级和结合性是非常重要的。举例来说，运算符优先级解释了为什么下面这个表达式的运算结果会是 `17`。 -```swift +```Swift 2 + 3 % 4 * 5 // 结果是 17 ``` -如果完全从左到右进行运算，则运算的过程是这样的： +如果你直接从左到右进行运算，你可能认为运算的过程是这样的： - 2 + 3 = 5 - 5 % 4 = 1 @@ -259,42 +246,41 @@ signedOverflow = signedOverflow &- 1 但是正确答案是 `17` 而不是 `5`。优先级高的运算符要先于优先级低的运算符进行计算。与 C 语言类似，在 Swift 中，乘法运算符（`*`）与取余运算符（`%`）的优先级高于加法运算符（`+`）。因此，它们的计算顺序要先于加法运算。 -而乘法与取余的优先级相同。这时为了得到正确的运算顺序，还需要考虑结合性。乘法与取余运算都是左结合的。可以将这考虑成为这两部分表达式都隐式地加上了括号： +而乘法运算与取余运算的优先级*相同*。这时为了得到正确的运算顺序，还需要考虑结合性。乘法运算与取余运算都是左结合的。可以将这考虑成，从它们的左边开始为这两部分表达式都隐式地加上括号： -```swift +```Swift 2 + ((3 % 4) * 5) ``` `(3 % 4)` 等于 `3`，所以表达式相当于： -```swift +```Swift 2 + (3 * 5) ``` `3 * 5` 等于 `15`，所以表达式相当于： -```swift +```Swift 2 + 15 ``` 因此计算结果为 `17`。 -如果想查看完整的 Swift 运算符优先级和结合性规则，请参考[表达式](../chapter3/04_Expressions.html)。如果想查看 Swift 标准库提供所有的运算符，请查看 [Swift Standard Library Operators Reference](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_StandardLibrary_Operators/index.html#//apple_ref/doc/uid/TP40016054)。 +有关 Swift 标准库提供的操作符信息，包括操作符优先级组和结核性设置的完整列表，请参见[操作符声明](https://developer.apple.com/documentation/swift/operator_declarations)。 > 注意 > -> 相对 C 语言和 Objective-C 来说，Swift 的运算符优先级和结合性规则更加简洁和可预测。但是，这也意味着它们相较于 C 语言及其衍生语言并不是完全一致的。在对现有的代码进行移植的时候，要注意确保运算符的行为仍然符合你的预期。 +> 相对 C 语言和 Objective-C 来说，Swift 的运算符优先级和结合性规则更加简洁和可预测。但是，这也意味着它们相较于 C 语言及其衍生语言并不是完全一致。在对现有的代码进行移植的时候，要注意确保运算符的行为仍然符合你的预期。 - -## 运算符函数 +## 运算符函数 {#operator-functions} -类和结构体可以为现有的运算符提供自定义的实现，这通常被称为*运算符重载*。 +类和结构体可以为现有的运算符提供自定义的实现。这通常被称为运算符*重载*。 -下面的例子展示了如何为自定义的结构体实现加法运算符（`+`）。算术加法运算符是一个双目运算符，因为它可以对两个值进行运算，同时它还是中缀运算符，因为它出现在两个值中间。 +下面的例子展示了如何让自定义的结构体支持加法运算符（`+`）。算术加法运算符是一个*二元运算符*，因为它是对两个值进行运算，同时它还可以称为*中缀*运算符，因为它出现在两个值中间。 -例子中定义了一个名为 `Vector2D` 的结构体用来表示二维坐标向量 `(x, y)`，紧接着定义了一个可以对两个 `Vector2D` 结构体进行相加的运算符函数： +例子中定义了一个名为 `Vector2D` 的结构体用来表示二维坐标向量 `(x, y)`，紧接着定义了一个可以将两个 `Vector2D` 结构体实例进行相加的*运算符函数*： -```swift +```Swift struct Vector2D { var x = 0.0, y = 0.0 } @@ -306,13 +292,13 @@ extension Vector2D { } ``` -该运算符函数被定义为 `Vector2D` 上的一个类方法，并且函数的名字与它要进行重载的 `+` 名字一致。因为加法运算并不是一个向量必需的功能，所以这个类方法被定义在 `Vector2D` 的一个扩展中，而不是 `Vector2D` 结构体声明内。而算术加法运算符是双目运算符，所以这个运算符函数接收两个类型为 `Vector2D` 的参数，同时有一个 `Vector2D` 类型的返回值。 +该运算符函数被定义为 `Vector2D` 上的一个类方法，并且函数的名字与它要进行重载的 `+` 名字一致。因为加法运算并不是一个向量必需的功能，所以这个类方法被定义在 `Vector2D` 的一个扩展中，而不是 `Vector2D` 结构体声明内。而算术加法运算符是二元运算符，所以这个运算符函数接收两个类型为 `Vector2D` 的参数，同时有一个 `Vector2D` 类型的返回值。 在这个实现中，输入参数分别被命名为 `left` 和 `right`，代表在 `+` 运算符左边和右边的两个 `Vector2D` 实例。函数返回了一个新的 `Vector2D` 实例，这个实例的 `x` 和 `y` 分别等于作为参数的两个实例的 `x` 和 `y` 的值之和。 这个类方法可以在任意两个 `Vector2D` 实例中间作为中缀运算符来使用： -```swift +```Swift let vector = Vector2D(x: 3.0, y: 1.0) let anotherVector = Vector2D(x: 2.0, y: 4.0) let combinedVector = vector + anotherVector @@ -321,16 +307,15 @@ let combinedVector = vector + anotherVector 这个例子实现两个向量 `(3.0，1.0)` 和 `(2.0，4.0)` 的相加，并得到新的向量 `(5.0，5.0)`。这个过程如下图示： - + - -### 前缀和后缀运算符 +### 前缀和后缀运算符 {#prefix-and-postfix-operators} -上个例子演示了一个双目中缀运算符的自定义实现。类与结构体也能提供标准*单目运算符*的实现。单目运算符只运算一个值。当运算符出现在值之前时，它就是*前缀*的（例如 `-a`），而当它出现在值之后时，它就是*后缀*的（例如 `b!`）。 +上个例子演示了一个二元中缀运算符的自定义实现。类与结构体也能提供标准*一元运算符*的实现。一元运算符只运算一个值。当运算符出现在值之前时，它就是*前缀*的（例如 `-a`），而当它出现在值之后时，它就是*后缀*的（例如 `b!`）。 要实现前缀或者后缀运算符，需要在声明运算符函数的时候在 `func` 关键字之前指定 `prefix` 或者 `postfix` 修饰符： -```swift +```Swift extension Vector2D { static prefix func - (vector: Vector2D) -> Vector2D { return Vector2D(x: -vector.x, y: -vector.y) @@ -338,11 +323,11 @@ extension Vector2D { } ``` -这段代码为 `Vector2D` 类型实现了单目负号运算符。由于该运算符是前缀运算符，所以这个函数需要加上 `prefix` 修饰符。 +这段代码为 `Vector2D` 类型实现了一元运算符（`-a`）。由于该运算符是前缀运算符，所以这个函数需要加上 `prefix` 修饰符。 -对于简单数值，单目负号运算符可以对它们的正负性进行改变。对于 `Vector2D` 来说，该运算将其 `x` 和 `y` 属性的正负性都进行了改变： +对于简单数值，一元负号运算符可以对它们的正负性进行改变。对于 `Vector2D` 来说，该运算将其 `x` 和 `y` 属性的正负性都进行了改变： -```swift +```Swift let positive = Vector2D(x: 3.0, y: 4.0) let negative = -positive // negative 是一个值为 (-3.0, -4.0) 的 Vector2D 实例 @@ -350,12 +335,13 @@ let alsoPositive = -negative // alsoPositive 是一个值为 (3.0, 4.0) 的 Vector2D 实例 ``` - -### 复合赋值运算符 +### 复合赋值运算符 {#compound-assignment-operators} *复合赋值运算符*将赋值运算符（`=`）与其它运算符进行结合。例如，将加法与赋值结合成加法赋值运算符（`+=`）。在实现的时候，需要把运算符的左参数设置成 `inout` 类型，因为这个参数的值会在运算符函数内直接被修改。 -```swift +在下面的例子中，对 `Vector2D` 实例实现了一个加法赋值运算符函数： + +```Swift extension Vector2D { static func += (left: inout Vector2D, right: Vector2D) { left = left + right @@ -365,7 +351,7 @@ extension Vector2D { 因为加法运算在之前已经定义过了，所以在这里无需重新定义。在这里可以直接利用现有的加法运算符函数，用它来对左值和右值进行相加，并再次赋值给左值： -```swift +```Swift var original = Vector2D(x: 1.0, y: 2.0) let vectorToAdd = Vector2D(x: 3.0, y: 4.0) original += vectorToAdd @@ -374,16 +360,15 @@ original += vectorToAdd > 注意 > -> 不能对默认的赋值运算符（`=`）进行重载。只有组合赋值运算符可以被重载。同样地，也无法对三目条件运算符 （`a ? b : c`） 进行重载。 +> 不能对默认的赋值运算符（`=`）进行重载。只有复合赋值运算符可以被重载。同样地，也无法对三元条件运算符 （`a ? b : c`） 进行重载。 - -### 等价运算符 +### 等价运算符 {#equivalence-operators} -自定义的类和结构体没有对*等价运算符*进行默认实现，等价运算符通常被称为“相等”运算符（`==`）与“不等”运算符（`!=`）。对于自定义类型，Swift 无法判断其是否“相等”，因为“相等”的含义取决于这些自定义类型在你的代码中所扮演的角色。 +通常情况下，自定义的类和结构体没有对*等价运算符*进行默认实现，等价运算符通常被称为*相等*运算符（`==`）与*不等*运算符（`!=`）。 -为了使用等价运算符能对自定义的类型进行判等运算，需要为其提供自定义实现，实现的方法与其它中缀运算符一样, 并且增加对标准库 `Equatable` 协议的遵循： +为了使用等价运算符对自定义的类型进行判等运算，需要为“相等”运算符提供自定义实现，实现的方法与其它中缀运算符一样, 并且增加对标准库 `Equatable` 协议的遵循： -```swift +```Swift extension Vector2D: Equatable { static func == (left: Vector2D, right: Vector2D) -> Bool { return (left.x == right.x) && (left.y == right.y) @@ -391,30 +376,30 @@ extension Vector2D: Equatable { } ``` -上述代码实现了“相等”运算符（`==`）来判断两个 `Vector2D` 实例是否相等。对于 `Vector2D` 类型来说，“相等”意味着“两个实例的 `x` 属性和 `y` 属性都相等”，这也是代码中用来进行判等的逻辑。示例里同时也实现了“不等”运算符（`!=`），它简单地将“相等”运算符的结果进行取反后返回。 +上述代码实现了“相等”运算符（`==`）来判断两个 `Vector2D` 实例是否相等。对于 `Vector2D` 来说，“相等”意味着“两个实例的 `x` 和 `y` 都相等”，这也是代码中用来进行判等的逻辑。如果你已经实现了“相等”运算符，通常情况下你并不需要自己再去实现“不等”运算符（`!=`）。标准库对于“不等”运算符提供了默认的实现，它简单地将“相等”运算符的结果进行取反后返回。 现在我们可以使用这两个运算符来判断两个 `Vector2D` 实例是否相等： -```swift +```Swift let twoThree = Vector2D(x: 2.0, y: 3.0) let anotherTwoThree = Vector2D(x: 2.0, y: 3.0) if twoThree == anotherTwoThree { print("These two vectors are equivalent.") } -// 打印 “These two vectors are equivalent.” +// 打印“These two vectors are equivalent.” ``` -Swift 为以下自定义类型提等价运算符供合成实现： +多数简单情况下，您可以使用 Swift 为您提供的等价运算符默认实现。Swift 为以下数种自定义类型提供等价运算符的默认实现： -- 只拥有遵循 `Equatable` 协议存储属性的结构体； -- 只拥有遵循 `Equatable` 协议关联类型的枚举； -- 没有关联类型的枚举。 +- 只拥有存储属性，并且它们全都遵循 `Equatable` 协议的结构体 +- 只拥有关联类型，并且它们全都遵循 `Equatable` 协议的枚举 +- 没有关联类型的枚举 -在类型原本的声明中声明遵循 `Equatable` 来接收这些默认实现。 +在类型原始的声明中声明遵循 `Equatable` 来接收这些默认实现。 -下面为三维位置向量 `(x, y, z)` 定义的 `Vector3D` 结构体，与 `Vector2D` 类似，由于 `x`，`y` 和 `z` 属性都是 `Equatable` 类型，`Vector3D` 就收到默认的等价运算符实现了。 +下面为三维位置向量 `(x, y, z)` 定义的 `Vector3D` 结构体，与 `Vector2D` 类似。由于 `x`，`y` 和 `z` 属性都是 `Equatable` 类型，`Vector3D` 获得了默认的等价运算符实现。 -```swift +```Swift struct Vector3D: Equatable { var x = 0.0, y = 0.0, z = 0.0 } @@ -424,23 +409,22 @@ let anotherTwoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0) if twoThreeFour == anotherTwoThreeFour { print("These two vectors are also equivalent.") } -// Prints "These two vectors are also equivalent." +// 打印“These two vectors are also equivalent.” ``` - -## 自定义运算符 +## 自定义运算符 {#custom-operators} 除了实现标准运算符，在 Swift 中还可以声明和实现*自定义运算符*。可以用来自定义运算符的字符列表请参考[运算符](../chapter3/02_Lexical_Structure.html#operators)。 新的运算符要使用 `operator` 关键字在全局作用域内进行定义，同时还要指定 `prefix`、`infix` 或者 `postfix` 修饰符： -```swift +```Swift prefix operator +++ ``` -上面的代码定义了一个新的名为 `+++` 的前缀运算符。对于这个运算符，在 Swift 中并没有意义，因此我们针对 `Vector2D` 的实例来定义它的意义。对这个示例来讲，`+++` 被实现为“前缀双自增”运算符。它使用了前面定义的复合加法运算符来让矩阵对自身进行相加，从而让 `Vector2D` 实例的 `x` 属性和 `y` 属性的值翻倍。实现 `+++` 运算符的方式如下： +上面的代码定义了一个新的名为 `+++` 的前缀运算符。对于这个运算符，在 Swift 中并没有已知的意义，因此在针对 `Vector2D` 实例的特定上下文中，给予了它自定义的意义。对这个示例来讲，`+++` 被实现为“前缀双自增”运算符。它使用了前面定义的复合加法运算符来让矩阵与自身进行相加，从而让 `Vector2D` 实例的 `x` 属性和 `y` 属性值翻倍。你可以像下面这样通过对 `Vector2D` 添加一个 `+++` 类方法，来实现 `+++` 运算符： -```swift +```Swift extension Vector2D { static prefix func +++ (vector: inout Vector2D) -> Vector2D { vector += vector @@ -454,16 +438,15 @@ let afterDoubling = +++toBeDoubled // afterDoubling 现在的值也为 (2.0, 8.0) ``` - -### 自定义中缀运算符的优先级 +### 自定义中缀运算符的优先级 {#precedence-and-associativity-for-custom-infix-operators} -每个自定义中缀运算符都属于某个优先级组。这个优先级组指定了这个运算符和其他中缀运算符的优先级和结合性。[优先级和结合性](#precedence_and_associativity)中详细阐述了这两个特性是如何对中缀运算符的运算产生影响的。 +每个自定义中缀运算符都属于某个优先级组。优先级组指定了这个运算符相对于其他中缀运算符的优先级和结合性。[优先级和结合性](#precedence_and_associativity)中详细阐述了这两个特性是如何对中缀运算符的运算产生影响的。 -而没有明确放入优先级组的自定义中缀运算符会放到一个默认的优先级组内，其优先级高于三元运算符。 +而没有明确放入某个优先级组的自定义中缀运算符将会被放到一个默认的优先级组内，其优先级高于三元运算符。 以下例子定义了一个新的自定义中缀运算符 `+-`，此运算符属于 `AdditionPrecedence` 优先组： -```swift +```Swift infix operator +-: AdditionPrecedence extension Vector2D { static func +- (left: Vector2D, right: Vector2D) -> Vector2D { @@ -476,8 +459,9 @@ let plusMinusVector = firstVector +- secondVector // plusMinusVector 是一个 Vector2D 实例，并且它的值为 (4.0, -2.0) ``` -这个运算符把两个向量的 `x` 值相加，同时用第一个向量的 `y` 值减去第二个向量的 `y` 值。因为它本质上是属于“相加型”运算符，所以将它放置 `+` 和 `-` 等默认的中缀“相加型”运算符相同的优先级组中。关于 Swift 标准库提供的运算符，以及完整的运算符优先级组和结合性设置，请参考 [Swift Standard Library Operators Reference](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_StandardLibrary_Operators/index.html#//apple_ref/doc/uid/TP40016054)。而更多关于优先级组以及自定义操作符和优先级组的语法，请参考[运算符声明](#operator_declaration) +这个运算符把两个向量的 `x` 值相加，同时从第一个向量的 `y` 中减去第二个向量的 `y` 。因为它本质上是属于“相加型”运算符，所以将它放置在 `+` 和 `-` 等默认中缀“相加型”运算符相同的优先级组中。关于 Swift 标准库提供的运算符，以及完整的运算符优先级组和结合性设置，请参考 [运算符声明](https://developer.apple.com/documentation/swift/operator_declarations)。而更多关于优先级组以及自定义操作符和优先级组的语法，请参考[运算符声明](./06_Declarations.md#operator_declaration)。 > 注意 > > 当定义前缀与后缀运算符的时候，我们并没有指定优先级。然而，如果对同一个值同时使用前缀与后缀运算符，则后缀运算符会先参与运算。 + diff --git a/source/chapter2/27_contributors.md b/source/chapter2/27_contributors.md deleted file mode 100755 index 11807c8e..00000000 --- a/source/chapter2/27_contributors.md +++ /dev/null @@ -1,613 +0,0 @@ -# 翻译历史记录 - -## The Basic - -> 1.0 -> 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus) -> 校对：[lslxdx](https://github.com/lslxdx) - -> 2.0 -> 翻译+校对：[xtymichael](https://github.com/xtymichael) - -> 2.1 -> 翻译：[Prayer](https://github.com/futantan) -> 校对：[shanks](http://codebuild.me)，[overtrue](https://github.com/overtrue) - -> 2.2 -> 校对：[SketchK](https://github.com/SketchK) - -> 3.0 -> 校对：[CMB](https://github.com/chenmingbiao)，版本时间2016-09-13 - -> 3.0.1, 2016-11-11，shanks - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io) - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Basic_Operators - -> 1.0 -> 翻译：[XieLingWang](https://github.com/xielingwang) -> 校对：[EvilCome](https://github.com/Evilcome) - -> 2.0 -> 翻译+校对：[JackAlan](https://github.com/AlanMelody) - -> 2.1 -> 校对：[shanks](http://codebuild.me) - -> 2.2 -> 翻译+校对：[Cee](https://github.com/Cee) 校对：[SketchK](https://github.com/SketchK)，2016-05-11 -> 3.0.1，shanks，2016-11-11 - -> 4.0 -> 翻译+校对：[kemchenj](https://kemchenj.github.io) - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Strings_and_Characters - -> 1.0 -> 翻译：[wh1100717](https://github.com/wh1100717) -> 校对：[Hawstein](https://github.com/Hawstein) - -> 2.0 -> 翻译+校对：[DianQK](https://github.com/DianQK) - -> 2.1 -> 翻译：[DianQK](https://github.com/DianQK) -> 校对：[shanks](http://codebuild.me), [Realank](https://github.com/Realank), - -> 2.2 -> 校对：[SketchK](https://github.com/SketchK) - -> 3.0 -> 校对：[CMB](https://github.com/chenmingbiao)，版本日期：2016-09-13 -> 3.0.1, shanks, 2016-11-11 - -> 4.0 -> 翻译：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Collection_Types - -> 1.0 -> 翻译：[zqp](https://github.com/zqp) -> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin) - -> 2.0 -> 翻译+校对：[JackAlan](https://github.com/AlanMelody) - -> 2.1 -> 校对：[shanks](http://codebuild.me) - -> 2.2 -> 校对：[SketchK](https://github.com/SketchK) 2016-05-11 - -> 3.0 -> 校对：[shanks](http://codebuild.me) ，2016-10-09 -> 3.0.1，shanks，2016-11-12 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Control Flow - -> 1.0 -> 翻译：[vclwei](https://github.com/vclwei), [coverxit](https://github.com/coverxit), [NicePiao](https://github.com/NicePiao) -> 校对：[coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai) - -> 2.0 -> 翻译+校对：[JackAlan](https://github.com/AlanMelody) - -> 2.1 -> 翻译：[Prayer](https://github.com/futantan) -> 校对：[shanks](http://codebuild.me) - -> 2.2 -> 翻译：[LinusLing](https://github.com/linusling) -> 校对：[SketchK](https://github.com/SketchK) - -> 3.0 -> 翻译：[Realank](https://github.com/realank) 2016-09-13 -> 3.0.1，shanks，2016-11-12 - -> 3.1 -> 翻译：[qhd](https://github.com/qhd) 2017-04-17 - -> 4.0 -> 翻译：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Functions - -> 1.0 -> 翻译：[honghaoz](https://github.com/honghaoz) -> 校对：[LunaticM](https://github.com/LunaticM) - -> 2.0 -> 翻译+校对：[dreamkidd](https://github.com/dreamkidd) - -> 2.1 -> 翻译：[DianQK](https://github.com/DianQK) -> 定稿：[shanks](http://codebuild.me) - -> 2.2 -> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-12 - -> 3.0 -> 翻译: [crayygy](https://github.com/crayygy) 2016-09-12 -> 校对: [shanks](http://codebuild.me) 2016-09-27 - -> 3.0.1，shanks，2016-11-12 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Closures - -> 1.0 -> 翻译：[wh1100717](https://github.com/wh1100717) -> 校对：[lyuka](https://github.com/lyuka) - -> 2.0 -> 翻译+校对：[100mango](https://github.com/100mango) - -> 2.1 -> 翻译：[100mango](https://github.com/100mango), [magicdict](https://github.com/magicdict) -> 校对：[shanks](http://codebuild.me) - -> 2.2 -> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-12 - -> 3.0 -> 翻译：[Lanford](https://github.com/LanfordCai) 2016-09-19 - -> 3.0.1，shanks，2016-11-12 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - - -## Enumerations - -> 1.0 -> 翻译：[yankuangshi](https://github.com/yankuangshi) -> 校对：[shinyzhu](https://github.com/shinyzhu) - -> 2.0 -> 翻译+校对：[futantan](https://github.com/futantan) - -> 2.1 -> 翻译：[Channe](https://github.com/Channe) -> 校对：[shanks](http://codebuild.me) - -> 2.2 -> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-13 - -> 3.0 -> 翻译+校对：[shanks](https://codebuild.me) 2016-09-24 -> 3.0.1，shanks，2016-11-12 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Classes And Structures - -> 1.0 -> 翻译：[JaySurplus](https://github.com/JaySurplus) -> 校对：[sg552](https://github.com/sg552) - -> 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 -> -> 3.0.1， shanks， 2016-11-12 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## 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) - -> 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 -> -> 3.0.1，shanks，2016-11-12 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Methods - -> 1.0 -> 翻译：[pp-prog](https://github.com/pp-prog) -> 校对：[zqp](https://github.com/zqp) - -> 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 - -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - - -## Subscripts - -> 1.0 -> 翻译：[siemenliu](https://github.com/siemenliu) -> 校对：[zq54zquan](https://github.com/zq54zquan) - -> 2.0 -> 翻译+校对：[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 -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Inheritance - -> 1.0 -> 翻译：[Hawstein](https://github.com/Hawstein) -> 校对：[menlongsheng](https://github.com/menlongsheng) - -> 2.0，2.1 -> 翻译+校对：[shanks](http://codebuild.me) - -> 2.2 -> 校对：[SketchK](https://github.com/SketchK) 2016-05-13 - -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Initialization - -> 1.0 -> 翻译：[lifedim](https://github.com/lifedim) -> 校对：[lifedim](https://github.com/lifedim) - -> 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 -> 3.0.1，shanks，2016-11-13 - -> 3.1 -> 翻译：[qhd](https://github.com/qhd) 2017-04-18 - -> 4.0 -> 翻译：[muhlenXi](https://github.com/muhlenxi) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Deinitialization - -> 1.0 -> 翻译：[bruce0505](https://github.com/bruce0505) -> 校对：[fd5788](https://github.com/fd5788) - -> 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 - -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Optional Chaining - -> 1.0 -> 翻译：[Jasonbroker](https://github.com/Jasonbroker) -> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) - -> 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 - -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Error Handling - -> 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 - -> 3.0 -> 翻译+校对：[shanks](http://codebuild.me) 2016-09-24 - -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 翻译+校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Type Casting - -> 1.0 -> 翻译：[xiehurricane](https://github.com/xiehurricane) -> 校对：[happyming](https://github.com/happyming) - -> 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 -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Nested Types - -> 1.0 -> 翻译：[Lin-H](https://github.com/Lin-H) -> 校对：[shinyzhu](https://github.com/shinyzhu) - -> 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 -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 翻译+校对：[EyreFree](https://www.eyrefree.org/) 2017-10-19 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Extensions - -> 1.0 -> 翻译：[lyuka](https://github.com/lyuka) -> 校对：[Hawstein](https://github.com/Hawstein) - -> 2.0 -> 翻译+校对：[shanks](http://codebuild.me) - -> 2.1 -> 校对：[shanks](http://codebuild.me) -> -> 2.2 -> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-16 -> 3.0.1，shanks，2016-11-13 - -> 4.0 -> 校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Protocols - -> 1.0 -> 翻译：[geek5nan](https://github.com/geek5nan) -> 校对：[dabing1022](https://github.com/dabing1022) - -> 2.0 -> 翻译+校对：[futantan](https://github.com/futantan) - -> 2.1 -> 翻译：[小铁匠 Linus](https://github.com/kevin833752) -> 校对：[shanks](http://codebuild.me) -> -> 2.2 -> 翻译+校对：[SketchK](https://github.com/SketchK) -> -> 3.0 -> 校对：[CMB](https://github.com/chenmingbiao)，版本日期：2016-09-13 - -> 3.0.1 -> shanks，2016-11-13 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Generics - -> 1.0 -> 翻译：[takalard](https://github.com/takalard) -> 校对：[lifedim](https://github.com/lifedim) - -> 2.0 -> 翻译+校对： [SergioChan](https://github.com/SergioChan) - -> 2.1 -> 校对：[shanks](http://codebuild.me)，2015-11-01 - -> 2.2：翻译+校对：[Lanford](https://github.com/LanfordCai)，2016-04-08 [SketchK](https://github.com/SketchK) 2016-05-16 - -> 3.0：翻译+校对：[chenmingjia](https://github.com/chenmingjia)，2016-09-12 -> 3.0.1，shanks，2016-11-13 - -> 3.1：翻译：[qhd](https://github.com/qhd)，2017-04-10 - -> 4.0 -> 翻译+校对：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Automatic Reference Counting - -> 1.0 -> 翻译：[TimothyYe](https://github.com/TimothyYe) -> 校对：[Hawstein](https://github.com/Hawstein) - -> 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 - -> 3.0.1 -> shanks，2016-11-13 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Memory Safety - -> 4.0 -> 翻译：[kemchenj](https://kemchenj.github.io/) 2017-09-21 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -## Access Control - -> 1.0 -> 翻译：[JaceFu](http://www.devtalking.com/) -> 校对：[ChildhoodAndy](http://childhood.logdown.com) - -> 2.0 -> 翻译+校对：[mmoaay](https://github.com/mmoaay) - -> 2.1 -> 翻译：[Prayer](https://github.com/futantan) -> 校对：[shanks](http://codebuild.me)，2015-11-01 - -> 2.2 -> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-17 - -> 3.0.1 -> 翻译+校对： shanks，2016-11-13 - -> 4.0 -> 翻译：kemchenj，2017-09-23 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - - -## Advanced Operators - -> 1.0 -> 翻译：[xielingwang](https://github.com/xielingwang) -> 校对：[numbbbbb](https://github.com/numbbbbb) - -> 2.0 -> 翻译+校对：[buginux](https://github.com/buginux) - -> 2.1 -> 校对：[shanks](http://codebuild.me)，2015-11-01 -> -> 2.2 -> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-17 -> -> 3.0 -> 翻译+校对：[mmoaay](https://github.com/mmoaay) 2016-09-20 - -> 3.0.1 -> shanks，2016-11-13 - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md index 78faf33d..2bac40fd 100755 --- a/source/chapter3/01_About_the_Language_Reference.md +++ b/source/chapter3/01_About_the_Language_Reference.md @@ -1,26 +1,10 @@ # 关于语言参考（About the Language Reference） ------------------ - -> 1.0 -> 翻译：[dabing1022](https://github.com/dabing1022) -> 校对：[numbbbbb](https://github.com/numbbbbb) - -> 2.0 -> 翻译+校对：[KYawn](https://github.com/KYawn) - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -本页内容包括： - -- [如何阅读语法](#how_to_read_the_grammar) 本书的这一节描述了 Swift 编程语言的形式语法。这里描述的语法是为了帮助您了解该语言的更多细节，而不是让您直接实现一个解析器或编译器。 -Swift 语言相对较小，这是由于 Swift 代码中在各种地方出现的常见的类型、函数以及运算符都已经在 Swift 标准库中定义了。虽然这些类型、函数和运算符并不是 Swift 语言自身的一部分，但是它们被广泛应用于本书的讨论和代码范例中。 +Swift 语言相对较小，这是由于 Swift 代码中常用的类型、函数以及运算符都已经在 Swift 标准库中定义了。虽然这些类型、函数和运算符并不是 Swift 语言自身的一部分，但是它们被广泛应用于本书的讨论和代码范例中。 - -## 如何阅读语法 +## 如何阅读语法 {#how-to-read-the-grammar} 用来描述 Swift 编程语言形式语法的符号遵循下面几个约定： @@ -35,11 +19,14 @@ Swift 语言相对较小，这是由于 Swift 代码中在各种地方出现的 > getter-setter 方法块语法 > -> *getter-setter 方法块* → { [*getter 子句*](05_Declarations.html#getter-clause) [*setter 子句*](05_Declarations.html#setter-clause)可选 } | { [*setter 子句*](05_Declarations.html#setter-clause) [*getter 子句*](05_Declarations.html#getter-clause) } +> *getter-setter 方法块* → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06_Declarations.md#setter-clause)可选 } | { [*setter 子句*](./06_Declarations.md#setter-clause) [*getter 子句*](./06_Declarations.md#getter-clause) } +> 这个定义表明，一个 getter-setter 方法块可以由一个 getter 分句后跟一个可选的 setter 分句构成，然后用大括号括起来，或者由一个 setter 分句后跟一个 getter 分句构成，然后用大括号括起来。上述的语法产式等价于下面的两个语法产式, ： > getter-setter 方法块语法 > -> getter-setter 方法块 → { [*getter 子句*](05_Declarations.html#getter-clause) [*setter 子句*](05_Declarations.html#setter-clause)可选 } -> getter-setter 方法块 → { [*setter 子句*](05_Declarations.html#setter-clause) [*getter 子句*](05_Declarations.html#getter-clause) } +> getter-setter 方法块 → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06_Declarations.md#setter-clause)可选 } +> +> getter-setter 方法块 → { [*setter 子句*](./06_Declarations.md#setter-clause) [*getter 子句*](./06_Declarations.md#getter-clause) } +> diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md index 776a17fc..f9a3e2a4 100755 --- a/source/chapter3/02_Lexical_Structure.md +++ b/source/chapter3/02_Lexical_Structure.md @@ -1,72 +1,70 @@ # 词法结构（Lexical Structure） ------------------ - -> 1.0 -> 翻译：[superkam](https://github.com/superkam) -> 校对：[numbbbbb](https://github.com/numbbbbb) - -> 2.0 -> 翻译+校对：[buginux](https://github.com/buginux) - -> 2.1 -> 翻译：[mmoaay](https://github.com/mmoaay) - -> 2.2 -> 翻译+校对：[星夜暮晨](https://github.com/semperidem) - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -本页包含内容： - -- [空白与注释](#whitespace_and_comments) -- [标识符](#identifiers) -- [关键字和标点符号](#keywords) -- [字面量](#literals) - - [整数字面量](#integer_literals) - - [浮点数字面量](#floating_point_literals) - - [字符串字面量](#string_literals) -- [运算符](#operators) Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言中有效符号（token）的字符序列。这些合法符号组成了语言中最底层的构建基块，并在之后的章节中用于描述语言的其他部分。一个合法符号由一个标识符（identifier）、关键字（keyword）、标点符号（punctuation）、字面量（literal）或运算符（operator）组成。 通常情况下，通过考虑输入文本当中可能的最长子串，并且在随后将介绍的语法约束之下，根据随后将介绍的语法约束生成的，根据 Swift 源文件当中的字符来生成相应的“符号”。这种方法称为*“最长匹配（longest match）”*，或者*“最大适合（maximal munch）”*。 - -## 空白与注释 +## 空白与注释 {#whitespace} 空白（whitespace）有两个用途：分隔源文件中的符号以及帮助区分运算符属于前缀还是后缀（参见 [运算符](#operators)），在其他情况下空白则会被忽略。以下的字符会被当作空白：空格（U+0020）、换行符（U+000A）、回车符（U+000D）、水平制表符（U+0009）、垂直制表符（U+000B）、换页符（U+000C）以及空字符（U+0000）。 注释被编译器当作空白处理。单行注释由 `//` 开始直至遇到换行符（U+000A）或者回车符（U+000D）。多行注释由 `/*` 开始，以 `*/` 结束。注释允许嵌套，但注释标记必须匹配。 > 空白语法 - - +> > *空白* → [*空白项*](#whitespace-item) [*空白*](#whitespace)可选 +> +#### whitespace-item {#whitespace-item} +> > *空白项* → [*断行符*](#line-break) +> > *空白项* → [*注释*](#comment) +> > *空白项* → [*多行注释*](#multiline-comment) +> > *空白项* → U+0000，U+0009，U+000B，U+000C 或者 U+0020 - - +> +> +#### line-break {#line-break} +> > *断行符* → U+000A +> > *断行符* → U+000D +> > *断行符* → U+000D 接着是 U+000A - - -> *注释* → // [*注释内容 断行*](#comment-text line-break) +> +> +#### comment {#comment} +> +> *注释* → // [*注释内容*](#comment-text) [断行符*](#line-break) +> +> +#### multiline-comment {#multiline-comment} +> > *多行注释* → `/*` [*多行注释内容*](#multiline-commnet-text) `*/` +> +> +#### comment-text {#comment-text} +> > *注释内容* → [*注释内容项*](#comment-text-item) [*注释内容*](#comment-text)可选 +> +> +#### comment-text-item {#comment-text-item} +> > *注释内容项* → 任何 Unicode 标量值， 除了 U+000A 或者 U+000D +> +> +#### multiline-commnet-text {#multiline-commnet-text} +> > *多行注释内容* → [*多行注释内容项*](#multiline-comment-text-item) [*多行注释内容*](#multiline-comment-text)可选 +> > *多行注释内容项* → [*多行注释*](#multiline-comment). +> > *多行注释内容项* → [*注释内容项*](#comment-text-item) +> > *多行注释内容项* → 任何 Unicode 标量值， 除了 `/*` 或者 `*/` -注释可以包含额外的格式和标记，正如 [*Markup Formatting Reference*](https://developer.apple.com/library/prerelease/ios/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html#//apple_ref/doc/uid/TP40016497) 所述。 - - -## 标识符 +## 标识符 {#identifiers} *标识符（identifier）* 可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线（`_`）、基本多文种平面（Basic Multilingual Plane）中非字符数字组合的 Unicode 字符以及基本多文种平面以外的非个人专用区字符。在首字符之后，允许使用数字和组合 Unicode 字符。 @@ -75,59 +73,83 @@ Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言 闭包中如果没有明确指定参数名称，参数将被隐式命名为 `$0`、`$1`、`$2` 等等。这些命名在闭包作用域范围内是合法的标识符。 > 标识符语法 - - +> > *标识符* → [*头部标识符*](#identifier-head) [*标识符字符组*](#identifier-characters)可选 +> > *标识符* → \`[*头部标识符*](#identifier-head) [*标识符字符组*](#identifier-characters)可选\` +> > *标识符* → [*隐式参数名*](#implicit-parameter-name) - - -> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier-list) - - +> +> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier) +> +> +#### identifier-head {#identifier-head} +> > *头部标识符* → 大写或小写字母 A - Z +> > *头部标识符* → _ +> > *头部标识符* → U+00A8，U+00AA，U+00AD，U+00AF，U+00B2–U+00B5，或者 U+00B7–U+00BA +> > *头部标识符* → U+00BC–U+00BE，U+00C0–U+00D6，U+00D8–U+00F6，或者 U+00F8–U+00FF +> > *头部标识符* → U+0100–U+02FF，U+0370–U+167F，U+1681–U+180D，或者 U+180F–U+1DBF +> > *头部标识符* → U+1E00–U+1FFF +> > *头部标识符* → U+200B–U+200D，U+202A–U+202E，U+203F–U+2040，U+2054，或者 U+2060–U+206F +> > *头部标识符* → U+2070–U+20CF，U+2100–U+218F，U+2460–U+24FF，或者 U+2776–U+2793 +> > *头部标识符* → U+2C00–U+2DFF 或者 U+2E80–U+2FFF +> > *头部标识符* → U+3004–U+3007，U+3021–U+302F，U+3031–U+303F，或者 U+3040–U+D7FF +> > *头部标识符* → U+F900–U+FD3D，U+FD40–U+FDCF，U+FDF0–U+FE1F，或者 U+FE30–U+FE44 +> > *头部标识符* → U+FE47–U+FFFD +> > *头部标识符* → U+10000–U+1FFFD，U+20000–U+2FFFD，U+30000–U+3FFFD，或者 U+40000–U+4FFFD +> > *头部标识符* → U+50000–U+5FFFD，U+60000–U+6FFFD，U+70000–U+7FFFD，或者 U+80000–U+8FFFD +> > *头部标识符* → U+90000–U+9FFFD，U+A0000–U+AFFFD，U+B0000–U+BFFFD，或者 U+C0000–U+CFFFD +> > *头部标识符* → U+D0000–U+DFFFD 或者 U+E0000–U+EFFFD - - +> > *标识符字符* → 数值 0 - 9 +> +> +#### identifier-character {#identifier-character} +> > *标识符字符* → U+0300–U+036F，U+1DC0–U+1DFF，U+20D0–U+20FF，或者 U+FE20–U+FE2F +> > *标识符字符* → [*头部标识符*](#identifier-head) -> +> +> +#### identifier-characters {#identifier-characters} +> > *标识符字符组* → [*标识符字符*](#identifier-character) [*标识符字符组*](#identifier-characters)可选 +> +> +#### implicit-parameter-name {#implicit-parameter-name} +> +> *隐式参数名* → **$** [*十进制数字列表*](#decimal-digit) - -> *隐式参数名* → **$** [*十进制数字列表*](#decimal-digits) +## 关键字和标点符号 {#keywords-and-punctuation} - -## 关键字和标点符号 +下面这些被保留的关键字不允许用作标识符，除非使用反引号转义，具体描述请参考 [标识符](#identifiers)。除了 `inout`、`var` 以及 `let` 之外的关键字可以用作某个函数声明或者函数调用当中的外部参数名，无需添加反引号转义。当一个成员与一个关键字具有相同的名称时，不需要使用反引号来转义对该成员的引用，除非在引用该成员和使用该关键字之间存在歧义 - 例如，`self`，`Type` 和 `Protocol` 在显式的成员表达式中具有特殊的含义，因此它们必须在该上下文中使用反引号进行转义。 -下面这些被保留的关键字不允许用作标识符，除非使用反引号转义，具体描述请参考 [标识符](#identifiers)。除了 `inout`、`var` 以及 `let` 之外的关键字可以用作某个函数声明或者函数调用当中的外部参数名，不用添加反引号转义。 - -* 用在声明中的关键字： `associatedtype`、`class`、`deinit`、`enum`、`extension`、`func`、`import`、`init`、`inout`、`internal`、`let`、`operator`、`private`、`protocol`、`public`、`static`、`struct`、`subscript`、`typealias` 以及 `var`。 +* 用在声明中的关键字： `associatedtype`、`class`、`deinit`、`enum`、`extension`、`fileprivate `、`func`、`import`、`init`、`inout`、`internal`、`let`、`open`、`operator`、`private`、`protocol`、`public`、`static`、`struct`、`subscript`、`typealias` 以及 `var`。 * 用在语句中的关键字：`break`、`case`、`continue`、`default`、`defer`、`do`、`else`、`fallthrough`、`for`、`guard`、`if`、`in`、`repeat`、`return`、`switch`、`where` 以及 `while`。 -* 用在表达式和类型中的关键字：`as`、`catch`、`dynamicType`、`false`、`is`、`nil`、`rethrows`、`super`、`self`、`Self`、`throw`、`throws`、`true`、`try`、`#column`、`#file`、`#function` 以及 `#line`。 +* 用在表达式和类型中的关键字：`as`、`Any`、`catch`、`false`、`is`、`nil`、`rethrows`、`super`、`self`、`Self`、`throw`、`throws`、`true` 以及 `try `。 * 用在模式中的关键字：`_`。 -* 以井字号（`#`）开头的关键字：`#available`、`#column`、`#else#elseif`、`#endif`、`#file`、`#function`、`#if`、`#line` 以及 `#selector`。 +* 以井字号（`#`）开头的关键字：`#available`、`#colorLiteral`、`#column`、`#else`、`#elseif`、`#endif`、`#error`、`#file`、`#fileLiteral`、`#function`、`#if`、`#imageLiteral `、`#line`、`#selector`、`#sourceLocation`以及 `#warning`。 * 特定上下文中被保留的关键字： `associativity`、`convenience`、`dynamic`、`didSet`、`final`、`get`、`infix`、`indirect`、`lazy`、`left`、`mutating`、`none`、`nonmutating`、`optional`、`override`、`postfix`、`precedence`、`prefix`、`Protocol`、`required`、`right`、`set`、`Type`、`unowned`、`weak` 以及 `willSet`。这些关键字在特定上下文之外可以被用做标识符。 以下符号被当作保留符号，不能用于自定义运算符： `(`、`)`、`{`、`}`、`[`、`]`、`.`、`,`、`:`、`;`、`=`、`@`、`#`、`&`（作为前缀运算符）、`->`、`` ` ``、`?`、`!`（作为后缀运算符）。 - -## 字面量 +## 字面量 {#literal} *字面量（literal）* 用来表示源码中某种特定类型的值，比如一个数字或字符串。 @@ -146,17 +168,16 @@ true // 布尔值字面量 > 字面量语法 > -> *字面量* → [*数值字面量*](#numeric-literal) | [*字符串字面量*](#string-literal) | [*布尔值字面量*](#boolean-literal) | [*nil 字面量*](#nil-literal) - - +> *字面量* → [*数值字面量*](#integer-literal) | [*字符串字面量*](#string-literal) | [*布尔值字面量*](#integer-literal) | [*nil 字面量*](#integer-literal) +> > *数值字面量* → **-**可选 [*整数字面量*](#integer-literal) | **-**可选 [*浮点数字面量*](#floating-point-literal) -> +> > *布尔值字面量* → **true** | **false** -> +> > *nil 字面量* → **nil** - -### 整数字面量 + +### 整数字面量{#integer-literal} *整数字面量（Integer Literals）* 表示未指定精度整数的值。整数字面量默认用十进制表示，可以加前缀来指定其他的进制。二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 @@ -166,56 +187,92 @@ true // 布尔值字面量 整型字面面可以使用下划线（`_`）来增加数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，这同样也会被系统所忽略，并不会影响字面量的值。 -除非特别指定，整数字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数](../chapter2/01_The_Basics.html#integers)。 +除非特别指定，整数字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数](../chapter2/01_The_Basics.md#integers)。 > 整数字面量语法 > - +> +#### integer-literal {#integer-literal} +> > *整数字面量* → [*二进制字面量*](#binary-literal) +> > *整数字面量* → [*八进制字面量*](#octal-literal) +> > *整数字面量* → [*十进制字面量*](#decimal-literal) +> > *整数字面量* → [*十六进制字面量*](#hexadecimal-literal) - - +> +> +#### binary-literal {#binary-literal} +> > *二进制字面量* → **0b** [*二进制数字*](#binary-digit) [*二进制字面量字符组*](#binary-literal-characters)可选 -> +> +> +#### binary-digit {#binary-digit} +> > *二进制数字* → 数值 0 到 1 -> +> > *二进制字面量字符* → [*二进制数字*](#binary-digit) | _ -> +> +> +#### binary-literal-characters {#binary-literal-characters} +> > *二进制字面量字符组* → [*二进制字面量字符*](#binary-literal-character) [*二进制字面量字符组*](#binary-literal-characters)可选 - - +> +> +#### octal-literal {#octal-literal} +> > *八进制字面量* → **0o** [*八进字数字*](#octal-digit) [*八进制字符组*](#octal-literal-characters)可选 -> +> +> +#### octal-digit {#octal-digit} +> > *八进字数字* → 数值 0 到 7 -> +> > *八进制字符* → [*八进字数字*](#octal-digit) | _ -> +> +> +#### octal-literal-characters {#octal-literal-characters} +> > *八进制字符组* → [*八进制字符*](#octal-literal-character) [*八进制字符组*](#octal-literal-characters)可选 - - +> +> +#### decimal-literal {#decimal-literal} +> > *十进制字面量* → [*十进制数字*](#decimal-digit) [*十进制字符组*](#decimal-literal-characters)可选 -> +> +> +#### decimal-digit {#decimal-digit} +> > *十进制数字* → 数值 0 到 9 -> -> *十进制数字组* → [*十进制数字*](#decimal-digit) [*十进制数字组*](#decimal-digits)可选 -> +> +> +#### decimal-literal-characters {#decimal-literal-characters} +> +> *十进制数字组* → [*十进制数字*](#decimal-digit) [*十进制数字组*](#decimal-literal-characters)可选 +> > *十进制字符* → [*十进制数字*](#decimal-digit) | _ -> -> *十进制字符组* → [*十进制字符*](#decimal-literal-character) [*十进制字符组*](#decimal-literal-characters)可选 - - +> +> *十进制字符组* → [*十进制字符*](#decimal-literal-characters) [*十进制字符组*](#decimal-literal-characters)可选 +> +> +#### hexadecimal-literal {#hexadecimal-literal} +> > *十六进制字面量* → **0x** [*十六进制数字*](#hexadecimal-digit) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 -> +> +> +#### hexadecimal-digit {#hexadecimal-digit} +> > *十六进制数字* → 数值 0 到 9, 字母 a 到 f, 或 A 到 F -> +> > *十六进制字符* → [*十六进制数字*](#hexadecimal-digit) | _ -> -> *十六进制字面量字符组* → [*十六进制字符*](#hexadecimal-literal-character) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 +> +> +#### hexadecimal-literal-characters {#hexadecimal-literal-characters} +> +> *十六进制字面量字符组* → [*十六进制字符*](#hexadecimal-literal-characters) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 - -### 浮点数字面量 +### 浮点数字面量{#floating-point-literal} *浮点数字面量（Floating-point literals）* 表示未指定精度浮点数的值。 @@ -233,29 +290,49 @@ true // 布尔值字面量 > 浮点数字面量语法 > - +> +#### floating-point-literal {#floating-point-literal} +> > *浮点数字面量* → [*十进制字面量*](#decimal-literal) [*十进制分数*](#decimal-fraction)可选 [*十进制指数*](#decimal-exponent)可选 +> > *浮点数字面量* → [*十六进制字面量*](#hexadecimal-literal) [*十六进制分数*](#hexadecimal-fraction)可选 [*十六进制指数*](#hexadecimal-exponent) - - +> +> +#### decimal-fraction {#decimal-fraction} +> > *十进制分数* → **.** [*十进制字面量*](#decimal-literal) -> +> +> +#### decimal-exponent {#decimal-exponent} +> > *十进制指数* → [*十进制指数 e*](#floating-point-e) [*正负号*](#sign)可选 [*十进制字面量*](#decimal-literal) - - +> +> +#### hexadecimal-fraction {#hexadecimal-fraction} +> > *十六进制分数* → **.** [*十六进制数字*](#hexadecimal-digit) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 -> +> +> +#### hexadecimal-exponent {#hexadecimal-exponent} +> > *十六进制指数* → [*十六进制指数 p*](#floating-point-p) [*正负号*](#sign)可选 [*十进制字面量*](#decimal-literal) - - +> +> +#### floating-point-e {#floating-point-e} +> > *十进制指数 e* → **e** | **E** -> +> +> +#### floating-point-p {#floating-point-p} +> > *十六进制指数 p* → **p** | **P** -> +> +> +#### sign {#sign} +> > *正负号* → **+** | **-** - -### 字符串字面量 +### 字符串字面量 {#string-literal} 字符串字面量是被引号包括的一串字符组成。 单行字符串字面量被包在双引号中的一串字符组成，形式如下： @@ -268,7 +345,7 @@ true // 布尔值字面量 > `字符` > """ -与单行字符串字面量不同的是，多行字符串字面量可以包含不转义的双引号（"），回车以及换行。它不能包含三个非转义的连续双引号。 +与单行字符串字面量不同的是，多行字符串字面量可以包含不转义的双引号（"），回车以及换行。它不能包含三个未转义的连续双引号。 """ 之后的回车或者换行开始多行字符串字面量，不是字符串的一部分。 """ 之前回车或者换行结束字面量，也不是字符串的一部分。要让多行字符串字面量的开始或结束带有换行，就在第一行或者最后一行写一个空行。 @@ -301,7 +378,41 @@ true // 布尔值字面量 let x = 3; "1 2 \(x)" ``` -字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../chapter2/03_Strings_and_Characters.html) 以及 [*字符串结构参考*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_String_Structure/index.html#//apple_ref/doc/uid/TP40015181)。 +可以使用一对或多对扩展分隔符(#)包裹字符串进行分隔，被分隔的字符串的形式如下所示： + +> \#"`characters`"# +> +> \#""" +> +> `characters` +> +> """# + +特殊字符在被分隔符分隔的结果字符串中会展示为普通字符，而不是特殊字符。你可以使用扩展分隔符来创建一些具有特殊效果的字符串。例如，生成字符串插值，启动或终止转义序列(字符串)。 + +以下所示，由字符串字面量和扩展分隔符所创建的字符串是等价的: + +```swift +let string = #"\(x) \ " \u{2603}"# +let escaped = "\\(x) \\ \" \\u{2603}" +print(string) +// Prints "\(x) \ " \u{2603}" +print(string == escaped) +// Prints "true" + +``` + +如果在一个字符串中使用多对扩展分隔符，请不要在分隔符之间使用空格。 + +```swift +print(###"Line 1\###nLine 2"###) // OK +print(# # #"Line 1\# # #nLine 2"# # #) // Error + +``` + +使用扩展分隔符创建的多行字符串字面量与普通多行字符串字面量具有相同的缩进要求。 + +字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../chapter2/03_Strings_and_Characters.md) 以及 [*字符串结构参考*](https://developer.apple.com/documentation/swift/string)。 用 `＋` 操作符连接的字符型字面量是在编译时进行连接的。比如下面的 `textA` 和 `textB` 是完全一样的，`textA` 没有任何运行时的连接操作。 @@ -312,34 +423,104 @@ let textB = "Hello world" > 字符串字面量语法 > - > *字符串字面量* → [*静态字符串字面量*](#static-string-literal) | [*插值字符串字面量*](#interpolated-string-literal) - - -> *静态字符串字面量* → **"**[*引用文本*](#quoted-text)可选**"** -> +> +> *字符串开分隔定界符* → [*字符串扩展分隔符*](#extended-string-literal-delimiter) **"** +> +> *字符串闭分隔定界符* → **"** [*字符串扩展分隔符*](#extended-string-literal-delimiter)可选 +> +> +#### static-string-literal {#static-string-literal} +> +> *静态字符串字面量* → [*字符串开分隔定界符*](#extended-string-literal-delimiter) [*引用文本*](#quoted-text)可选 [*字符串闭分隔定界符*](#extended-string-literal-delimiter) +> +> *静态字符串字面量* → [*多行字符串开分隔定界符*](#extended-string-literal-delimiter) [*多行引用文本*](#multiline-quoted-text)可选 [*多行字符串闭分隔定界符*](#extended-string-literal-delimiter) +> +> *多行字符串开分隔定界符* → [*字符串扩展分隔符*](#extended-string-literal-delimiter) **"""** +> +> *多行字符串闭分隔定界符* → **"""** [*字符串扩展分隔符*](#extended-string-literal-delimiter) +> +> +#### extended-string-literal-delimiter {#extended-string-literal-delimiter} +> +> *字符串扩展分隔符* → **#** [*字符串扩展分隔符*](#extended-string-literal-delimiter)可选 +> +> +#### quoted-text {#quoted-text} +> > *引用文本* → [*引用文本项*](#quoted-text-item) [*引用文本*](#quoted-text)可选 -> +> +> +#### quoted-text-item {#quoted-text-item} +> > *引用文本项* → [*转义字符*](#escaped-character) +> > *引用文本项* → 除了 **"**、**\\**、U+000A、U+000D 以外的所有 Unicode 字符 - - -> *插值字符串字面量* → **"**[*插值文本*](#interpolated-text)可选**"** -> +> +> +#### multiline-quoted-text {#multiline-quoted-text} +> +> *多行引用文本* → [*多行引用文本项*](#multiline-quoted-text-item) [*多行引用文本*](#multiline-quoted-text)可选 +> +> +#### multiline-quoted-text-item {#multiline-quoted-text-item} +> +> *多行引用文本项* [*转义字符*](#escaped-character)可选 +> +> +#### multiline-quoted-text {#multiline-quoted-text} +> +> *多行引用文本* → 除了 **\** 以外的任何Unicode标量值 +> +> *多行引用文本* → [*转义换行*](#escaped-newline) +> +> +#### interpolated-string-literal {#interpolated-string-literal} +> +> *插值字符串字面量* → [*字符串开分隔定界符*](#extended-string-literal-delimiter) [*插值文本*](#interpolated-text)可选 [*字符串闭分隔定界符*](#extended-string-literal-delimiter) +> +> *插值字符串字面量* → [*多行字符串开分隔定界符*](#extended-string-literal-delimiter) [*插值文本*](#interpolated-text)可选 [*多行字符串闭分隔定界符*](#extended-string-literal-delimiter) +> +> +#### interpolated-text {#interpolated-text} +> > *插值文本* → [*插值文本项*](#interpolated-text-item) [*插值文本*](#interpolated-text)可选 -> -> *插值文本项* → **\\****(**[*表达式*](./04_Expressions.html)**)** | [*引用文本项*](#quoted-text-item) - - -> *转义字符* → **\\****0** | **\\****\\** | **\t** | **\n** | **\r** | **\\"** | **\\'** -> *转义字符* → **\u {** [*unicode 标量数字*](#unicode-scalar-digits) **}** -> +> +> +#### interpolated-text-item {#interpolated-text-item} +> +> *插值文本项* → **\\****(**[*表达式*](./04_Expressions.md)**)** | [*引用文本项*](#quoted-text-item) +> +> *多行插值文本* → [*多行插值文本项*](#multiline-quoted-text-item) [*多行插值文本*](#multiline-quoted-text)可选 +> +> *多行插值文本项* → **\\(** [表达式](./04_Expressions.md) **)** | [多行引用文本项](#multiline-quoted-text-item) +> +> +#### escape-sequence {#escape-sequence} +> +> *转义序列* → **\\** [字符串扩展分隔符](#extended-string-literal-delimiter) +> +> +#### escaped-character {#escaped-character} +> +> *转义字符* → [*转义序列*](#escape-sequence) **0** | [*转义序列*](#escape-sequence) **\\** | [*转义序列*](#escape-sequence) **t** | [*转义序列*](#escape-sequence) **n** | [*转义序列*](#escape-sequence) **r** | [*转义序列*](#escape-sequence) **\"** | [*转义序列*](#escape-sequence) **'** +> +> *转义字符* → [*转义序列*](#escape-sequence) **u {** [*unicode 标量数字*](#unicode-scalar-digits) **}** +> +> +#### unicode-scalar-digits {#unicode-scalar-digits} +> > *unicode 标量数字* → 一到八位的十六进制数字 +> +> +#### escaped-newline {#escaped-newline} +> +> *转义换行符* → [*转义序列*](#escape-sequence) [*空白*](#whitespace)可选 [*断行符*](#line-break) - -## 运算符 -Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/25_Advanced_Operators.html) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 +## 运算符 {#operator} + +Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号（Miscellaneous Symbols）* 以及印刷符号（Dingbats）之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。 @@ -364,52 +545,86 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 在某些特定的设计中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号，剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary-> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*] (02_Lexical_Structure.html#identifier) **(** [*参数名称*](#argument-names) **)** > - + +#### explicit-member-expression {#explicit-member-expression} +> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*] (02_Lexical_Structure.md#decimal-digit) +> +> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选
+> +> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*] (02_Lexical_Structure.md#identifier) **(** [*参数名称*](#argument-names) **)** +> + +#### argument-names {#argument-names} > *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)可选
- -> *参数名* → [*标识符*](02_Lexical_Structure.html#identifier) **:** +> - -### 后缀 self 表达式 +#### argument-name {#argument-name} +> *参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) **:** +> +### 后缀 self 表达式 {#postfix-self-expression} 后缀 `self` 表达式由某个表达式或类型名紧跟 `.self` 组成，其形式如下： > `表达式`.self +> > `类型`.self +> 第一种形式返回表达式的值。例如：`x.self` 返回 `x`。 @@ -796,32 +1152,34 @@ let x = [10, 3, 20, 15, 4] > 后缀 self 表达式语法 > - + +#### postfix-self-expression {#postfix-self-expression} > *后缀 self 表达式* → [*后缀表达式*](#postfix-expression) **.** **self** +> - -### 下标表达式 - +### 下标表达式 {#subscript-expression} 可通过*下标表达式*访问相应的下标，形式如下： > `表达式`[`索引表达式`] +> 要获取下标表达式的值，可将索引表达式作为下标表达式的参数来调用下标 getter。下标 setter 的调用方式与之一样。 -关于下标的声明，请参阅 [协议下标声明](05_Declarations.html#protocol_subscript_declaration)。 +关于下标的声明，请参阅 [协议下标声明](./06_Declarations.md#protocol_subscript_declaration)。 > 下标表达式语法 > - + +#### subscript-expression {#subscript-expression} > *下标表达式* → [*后缀表达式*](#postfix-expression) **[** [*表达式列表*](#expression-list) **]** +> - -### 强制取值表达式 - +### 强制取值表达式 {#forced-Value-expression} 当你确定可选值不是 `nil` 时，可以使用*强制取值表达式*来强制解包，形式如下： > `表达式`! +> 如果该表达式的值不是 `nil`，则返回解包后的值。否则，抛出运行时错误。 @@ -839,15 +1197,16 @@ someDictionary["a"]![0] = 100 > 强制取值语法 > - + +#### forced-value-expression {#forced-value-expression} > *强制取值表达式* → [*后缀表达式*](#postfix-expression) **!** +> - -### 可选链表达式 - +### 可选链表达式 {#optional-chaining-expression} *可选链表达式*提供了一种使用可选值的便捷方法，形式如下： > `表达式`? +> 后缀 `?` 运算符会根据表达式生成可选链表达式而不会改变表达式的值。 @@ -873,6 +1232,7 @@ if let unwrappedC = c { ```swift func someFunctionWithSideEffects() -> Int { +> // 译者注：为了能看出此函数是否被执行，加上了一句打印 print("someFunctionWithSideEffects") return 42 @@ -890,5 +1250,7 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects() > 可选链表达式语法 > - + +#### optional-chaining-expression {#optional-chaining-expression} > *可选链表达式* → [*后缀表达式*](#postfix-expression) **?** +> diff --git a/source/chapter3/05_Statements.md b/source/chapter3/05_Statements.md index 9164a274..2576b1a6 100755 --- a/source/chapter3/05_Statements.md +++ b/source/chapter3/05_Statements.md @@ -1,46 +1,4 @@ - -# 语句（Statements） ------------------ - -> 1.0 -> 翻译：[coverxit](https://github.com/coverxit) -> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai) - -> 2.0 -> 翻译+校对：[littledogboy](https://github.com/littledogboy) - -> 2.2 -> 翻译：[chenmingbiao](https://github.com/chenmingbiao) - -> 3.0 -> 翻译：[chenmingjia](https://github.com/chenmingjia) - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -本页包含内容： - -- [循环语句](#loop_statements) - - [For-In 语句](#for-in_statements) - - [While 语句](#while_statements) - - [Repeat-While 语句](#repeat-while_statements) -- [分支语句](#branch_statements) - - [If 语句](#if_statements) - - [Guard 语句](#guard_statements) - - [Switch 语句](#switch_statements) -- [带标签的语句](#labeled_statements) -- [控制转移语句](#control_transfer_statements) - - [Break 语句](#break_statement) - - [Continue 语句](#continue_statement) - - [Fallthrough 语句](#fallthrough_statements) - - [Return 语句](#return_statements) - - [Throw 语句](#throw_statements) -- [Defer 语句](#defer_statements) -- [Do 语句](#do_statements) -- [编译器控制语句](#compiler_control_statements) - - [编译配置语句](#build_config_statements) - - [行控制语句](#line_control_statements) -- [可用性条件](#availability_condition) +# 语句（Statements）{#statement-statements} 在 Swift 中，有三种类型的语句：简单语句、编译器控制语句和控制流语句。简单语句是最常见的，用于构造表达式或者声明。编译器控制语句允许程序改变编译器的行为，包含编译配置语句和行控制语句。 @@ -49,37 +7,48 @@ 是否将分号（`;`）添加到语句的末尾是可选的。但若要在同一行内写多条独立语句，则必须使用分号。 > 语句语法 - -> *语句* → [*表达式*](04_Expressions.md#expression) **;**可选 -> *语句* → [*声明*](05_Declarations.md#declaration) **;**可选 +> +> *语句* → [*表达式*](./04_Expressions.md#expression) **;**可选 +> +> *语句* → [*声明*](./06_Declarations.md#declaration) **;**可选 +> > *语句* → [*循环语句*](#loop-statement) **;**可选 +> > *语句* → [*分支语句*](#branch-statement) **;**可选 +> > *语句* → [*带标签的语句*](#labeled-statement) **;**可选 +> > *语句* → [*控制转移语句*](#control-transfer-statement) **;**可选 +> > *语句* → [*defer 语句*](#defer-statement) **;**可选 +> > *语句* → [*do 语句*](#do-statement) **:**可选 +> > *语句* → [*编译器控制语句*](#compiler-control-statement) - +> > *多条语句* → [*语句*](#statement) [*多条语句*](#statements)可选 +> - -## 循环语句 - +## 循环语句 {#loop-statements} 循环语句会根据特定的循环条件来重复执行代码块。Swift 提供三种类型的循环语句：`for-in` 语句、`while` 语句和 `repeat-while` 语句。 通过 `break` 语句和 `continue` 语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement) 和 [Continue 语句](#continue_statement)。 > 循环语句语法 > - +> + +#### loop-statement {#loop-statement} > *循环语句* → [*for-in 语句*](#for-in-statement) +> > *循环语句* → [*while 语句*](#while-statement) +> > *循环语句* → [*repeat-while 语句*](#repeat-while-statement) +> - -### For-In 语句 +### For-In 语句 {#for-in-statements} -`for-in` 语句会为集合（或实现了 `SequenceType` 协议的任意类型）中的每一项执行一次代码块。 +`for-in` 语句会为集合（或实现了 [Sequence](https://developer.apple.com/documentation/swift/sequence) 协议的任意类型）中的每一项执行一次代码块。 `for-in` 语句的形式如下： @@ -89,16 +58,17 @@ for item in collection { } ``` -`for-in` 语句在循环开始前会调用集合表达式的 `generate()` 方法来获取一个实现了 `GeneratorType` 协议的类型的值。接下来循环开始，反复调用该值的 `next()` 方法。如果其返回值不是 `None`，它将会被赋给“项”，然后执行循环体语句，执行完毕后回到循环开始处，继续重复这一过程；否则，既不会赋值也不会执行循环体语句，`for-in` 语句至此执行完毕。 +`for-in` 语句在循环开始前会调用集合表达式（`collection expression`）的 `makeIterator()` 方法来获取一个实现了 [IteratorProtocol](https://developer.apple.com/documentation/swift/iteratorprotocol) 协议的迭代器类型。接下来循环开始，反复调用该迭代器的 `next()` 方法。如果其返回值不是 `nil`，它将会被赋给 `item`，然后执行循环体语句，执行完毕后回到循环开始处，继续重复这一过程；否则，既不会赋值也不会执行循环体语句，`for-in` 语句至此执行完毕。 > for-in 语句语法 > - -> *for-in 语句* → **for** **case**可选 [*模式*](07_Patterns.md#pattern) **in** [*表达式*](04_Expressions.md#expression) [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.md#code-block) +> - -### While 语句 +#### for-in-statement {#for-in-statement} +> *for-in 语句* → **for** **case**可选 [*模式*](./08_Patterns.md#pattern) **in** [*表达式*](./04_Expressions.md#expression) [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.md#code-block) +> +### While 语句 {#while-statements} 只要循环条件为真，`while` 语句就会重复执行代码块。 `while` 语句的形式如下： @@ -111,7 +81,7 @@ while condition { `while` 语句的执行流程如下： -1. 判断条件的值。如果为 `true`，转到第 2 步；如果为 `false`，`while` 语句至此执行完毕。 +1. 判断条件（`condition`）的值。如果为 `true`，转到第 2 步；如果为 `false`，`while` 语句至此执行完毕。 2. 执行循环体中的语句，然后重复第 1 步。 由于会在执行循环体中的语句前判断条件的值，因此循环体中的语句可能会被执行若干次，也可能一次也不会被执行。 @@ -120,22 +90,31 @@ while condition { > while 语句语法 > - -> *while 语句* → **while** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block) +> - -> *条件子句* → [*表达式*](04_Expressions.md#expression) | [*表达式*](04_Expressions.md#expression) **,** [*条件列表*](#condition-list) - -> *条件* → [*表达式*](04_Expressions.md#expression) |[*可用性条件*](#availability-condition) | [*case 条件*](#case-condition) | [*可选绑定条件*](#optional-binding-condition) +#### while-statement {#while-statement} +> *while 语句* → **while** [*条件子句*](#condition-clause) [*代码块*](./05_Declarations.md#code-block) > - -> *case 条件* → **case** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) - -> *可选绑定条件* → **let** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) | **var** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) - -### Repeat-While 语句 +#### condition-clause {#condition-clause} +> *条件子句* → [*表达式*](./04_Expressions.md#expression) | [*表达式*](./04_Expressions.md#expression) **,** [*条件列表*](#condition-list) +> + +#### condition {#condition} +> *条件* → [*表达式*](./04_Expressions.md#expression) |[*可用性条件*](#availability-condition) | [*case 条件*](#case-condition) | [*可选绑定条件*](#optional-binding-condition) +> +> + +#### case-condition {#case-condition} +> *case 条件* → **case** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) +> + +#### optional-binding-condition {#optional-binding-condition} +> *可选绑定条件* → **let** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) | **var** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) +> + +### Repeat-While 语句 {#repeat-while-statements} `repeat-while` 语句至少执行一次代码块，之后只要循环条件为真，就会重复执行代码块。 `repeat-while` 语句的形式如下： @@ -157,26 +136,30 @@ repeat { > repeat-while 语句语法 > - -> *repeat-while 语句* → **repeat** [*代码块*](05_Declarations.md#code-block) **while** [*表达式*](04_Expressions.md#expression) +> - -## 分支语句 +#### repeat-while-statement {#repeat-while-statement} +> *repeat-while 语句* → **repeat** [*代码块*](./06_Declarations.md#code-block) **while** [*表达式*](./04_Expressions.md#expression) +> -分支语句会根据一个或者多个条件来执行指定部分的代码。分支语句中的条件将会决定程序如何分支以及执行哪部分代码。Swift 提供两种类型的分支语句：`if` 语句和 `switch` 语句。 +## 分支语句 {#branch-statements} +分支语句会根据一个或者多个条件来执行指定部分的代码。分支语句中的条件将会决定程序如何分支以及执行哪部分代码。Swift 提供三种类型的分支语句：`if` 语句、 `guard` 语句和 `switch` 语句。 `if` 语句和 `switch` 语句中的控制流可以用 `break` 语句改变，请参阅 [Break 语句](#break_statement)。 > 分支语句语法 > - +> + +#### branch-statement {#branch-statement} > *分支语句* → [*if 语句*](#if-statement) +> > *分支语句* → [*guard 语句*](#guard-statement) +> > *分支语句* → [*switch 语句*](#switch-statement) +> - -### If 语句 - +### If 语句 {#if-statements} `if` 语句会根据一个或多个条件来决定执行哪一块代码。 `if` 语句有两种基本形式，无论哪种形式，都必须有花括号。 @@ -189,17 +172,17 @@ if condition { } ``` -第二种形式是在第一种形式的基础上添加 `else` 语句，当只有一个 `else` 语句时，像下面这样： +第二种形式是在第一种形式的基础上添加 `else` 语句（通过引入 `else` 关键字），并且用于：当条件为真时执行一部分代码，当这同一个条件为假的时候执行另一部分代码。当只有一个 `else` 语句时，`if` 语句具有以下的形式： ```swift -if ondition { +if condition { statements to execute if condition is true } else { statements to execute if condition is false } ``` -`else` 语句也可包含 `if` 语句，从而形成一条链来测试更多的条件，像下面这样： +`if` 语句的 `else` 语句也可包含另一个 `if` 语句，从而形成一条链来测试更多的条件，像下面这样： ```swift if condition 1 { @@ -215,15 +198,18 @@ if condition 1 { > if 语句语法 > - +> + +#### if-statement {#if-statement} > *if 语句* → **if** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block) [*else 子句*](#else-clause)可选 - -> *else 子句* → **else** [*代码块*](05_Declarations.md#code-block) | **else** [*if 语句*](#if-statement) +> - -### Guard 语句 +#### else-clause {#else-clause} +> *else 子句* → **else** [*代码块*](./06_Declarations.md#code-block) | **else** [*if 语句*](#if-statement) +> -如果一个或者多个条件不成立，可用 `guard` 语句用来退出当前作用域。 +### Guard 语句 {#guard-statements} +如果一个或者多个条件不成立，可用 `guard` 语句来退出当前作用域。 `guard` 语句的格式如下： @@ -233,11 +219,11 @@ guard condition else { } ``` -`guard` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件也可以是一条可选绑定，请参阅 [可选绑定](../chapter2/01_The_Basics.html#optional_binding)。 +`guard` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件也可以是一条可选绑定，请参阅 [可选绑定](../chapter2/01_The_Basics.md#optional_binding)。 -在 `guard` 语句中进行可选绑定的常量或者变量，其可用范围从声明开始直到作用域结束。 +在 `guard` 语句中进行可选绑定的任何常量或者变量，其可用范围从声明开始直到作用域结束。 -`guard` 语句必须有 `else` 子句，而且必须在该子句中调用 `Never` 返回类型的函数，或者使用下面的语句退出当前作用域： +`guard` 语句必须有 `else` 子句，而且必须在该子句中调用返回类型是 `Never` 的函数，或者使用下面的语句退出当前作用域： * `return` * `break` @@ -248,12 +234,13 @@ guard condition else { > guard 语句语法 > - -> *guard 语句* → **guard** [*条件子句*](#condition-clause) **else** [*代码块*] (05_Declarations.html#code-block) +> - -### Switch 语句 +#### guard-statement {#guard-statement} +> *guard 语句* → **guard** [*条件子句*](#condition-clause) **else** [*代码块*] (05_Declarations.md#code-block) +> +### Switch 语句 {#switch-statements} `switch` 语句会根据控制表达式的值来决定执行哪部分代码。 `switch` 语句的形式如下： @@ -272,9 +259,9 @@ default: } ``` -`switch` 语句会先计算*控制表达式*的值，然后与每一个 `case` 的模式进行匹配。如果匹配成功，程序将会执行对应的 `case` 中的语句。另外，每一个 `case` 都不能为空，也就是说在每一个 `case` 中必须至少有一条语句。如果你不想在匹配到的 `case` 中执行代码，只需在该 `case` 中写一条 `break` 语句即可。 +`switch` 语句会先计算*控制表达式*的值，然后与每一个 `case` 的模式进行匹配。如果匹配成功，程序将会执行对应的 `case` 中的语句。另外，每一个 `case` 的作用域都不能为空，也就是说在每一个 `case` 的冒号（`:`）后面必须至少有一条语句。如果你不想在匹配到的 `case` 中执行代码，只需在该 `case` 中写一条 `break` 语句即可。 -可以用作控制表达式的值是十分灵活的。除了标量类型外，如 `Int`、`Character`，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类型的实例和可选类型。控制表达式的值还可以用来匹配枚举类型中的成员值或是检查该值是否包含在指定的 `Range` 中。关于如何在 `switch` 语句中使用这些类型，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章中的 [Switch](../chapter2/05_Control_Flow.html#switch)。 +可以用作控制表达式的值是十分灵活的。除了标量类型外，如 `Int`、`Character`，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类型的实例和可选类型。控制表达式的值还可以用来匹配枚举类型中的成员值或是检查该值是否包含在指定的 `Range` 中。关于如何在 `switch` 语句中使用这些类型，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章中的 [Switch](../chapter2/05_Control_Flow.md#switch)。 每个 `case` 的模式后面可以有一个 `where` 子句。`where` 子句由 `where` 关键字紧跟一个提供额外条件的表达式组成。因此，当且仅当控制表达式匹配一个 `case` 的模式且 `where` 子句的表达式为真时，`case` 中的语句才会被执行。在下面的例子中，控制表达式只会匹配包含两个相等元素的元组，例如 `(1, 1)`： @@ -288,77 +275,150 @@ case let (x, y) where x == y: `switch` 语句中 `case` 的匹配顺序和源代码中的书写顺序保持一致。因此，当多个模式都能匹配控制表达式时，只有第一个匹配的 `case` 中的代码会被执行。 -#### Switch 语句不能有遗漏 +#### Switch 语句必须是详尽的 在 Swift 中，`switch` 语句中控制表达式的每一个可能的值都必须至少有一个 `case` 与之对应。在某些无法面面俱到的情况下（例如，表达式的类型是 `Int`），你可以使用 `default` 分支满足该要求。 +#### 对未来枚举的 `case` 进行 `switch` {#future-case} +非冻结枚举（`nonfronzen enumeration`）是一种特殊的枚举类型，它可能在未来会增加新的枚举 `case`，即使这时候你已经编译并且发布了你的应用，所以在 switch 非冻结枚举前需要深思熟虑。当一个库的作者们把一个枚举标记为非冻结的，这意味着他们保留了增加新的枚举 `case` 的权利，并且任何和这个枚举交互的代码都要在不需要重新编译的条件下能够处理那些未来可能新加入的 `case` 。只有那些标准库，比如用 Swift 实现的苹果的一些框架，C 以及 Objective-C 代码才能够声明非冻结枚举。你在 Swift 中声明的枚举不能是非冻结的。 + +当你对未来枚举进行 switch 时，你总是需要有一个 `default case`，即使每种枚举类型都已经有对应的 `case` 了。你可以在 default 前标注 `@unknown`，意思是这个 `case` 应该只匹配未来加入的枚举 `case`。如果你的 `default case` 中匹配了任何在编译时就能确定的枚举 `case`，Swift 会抛出一个警告。这可以很好地提醒你库的作者已经新增了一种 `case`，并且你还没有去处理。 + +以下就是一个例子，我们对标准库的 [Mirror.AncestorRepresentation](https://developer.apple.com/documentation/swift/mirror/ancestorrepresentation) 枚举进行 switch 操作。每当有新的 `case` 加入，我们会得到一个警告，提示我们要去处理它。 + +```swift +let representation: Mirror.AncestorRepresentation = .generated +switch representation { +case .customized: + print("Use the nearest ancestor’s implementation.") +case .generated: + print("Generate a default mirror for all ancestor classes.") +case .suppressed: + print("Suppress the representation of all ancestor classes.") +@unknown default: + print("Use a representation that was unknown when this code was compiled.") +} +// Prints "Generate a default mirror for all ancestor classes." +``` + #### 不存在隐式落入 当匹配到的 `case` 中的代码执行完毕后，`switch` 语句会直接退出，而不会继续执行下一个 `case` 。这就意味着，如果你想执行下一个 `case`，需要显式地在当前 `case` 中使用 `fallthrough` 语句。关于 `fallthrough` 语句的更多信息，请参阅 [Fallthrough 语句](#fallthrough_statements)。 > switch 语句语法 > - -> *switch 语句* → **switch** [*表达式*](04_Expressions.html#expression) **{** [*switch-case 列表*](#switch-cases)可选 **}** - -> *switch case 列表* → [*switch-case*](#switch-case) [*switch-case 列表*](#switch-cases)可选 - -> *switch case* → [*case 标签*](#case-label) [*多条语句*](#statements) | [*default 标签*](#default-label) [*多条语句*](#statements) +> - -> *case 标签* → **case** [*case 项列表*](#case-item-list) **:** - -> *case 项列表* → [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 | [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 **,** [*case 项列表*](#case-item-list) - -> *default 标签* → **default** **:** +#### switch-statement {#switch-statement} +> *switch 语句* → **switch** [*表达式*](./04_Expressions.md#expression) **{** [*switch-case 列表*](#switch-cases)可选 **}** > - + +#### switch-cases {#switch-cases} +> *switch case 列表* → [*switch-case*](#switch-case) [*switch-case 列表*](#switch-cases)可选 +> + +#### switch-case {#switch-case} +> *switch case* → [*case 标签*](#case-label) [*多条语句*](#statements) | [*default 标签*](#default-label) [*多条语句*](#statements) | [*conditional-switch-case*](#conditional-switch-case-label) +> + + +#### case-label {#case-label} +> *case 标签* → [*属性*](#switch-case-attributes-label)可选 **case** [*case 项列表*](#case-item-list) **:** +> + +#### case-item-list {#case-item-list} +> *case 项列表* → [*模式*](./08_Patterns.md#pattern) [*where 子句*](#where-clause)可选 | [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 **,** [*case 项列表*](#case-item-list) +> + +#### default-label {#default-label} +> *default 标签* → [*属性*](#switch-case-attributes-label)可选 **default** **:** +> +> + +#### where-clause {#where-clause} > *where-clause* → **where** [*where 表达式*](#where-expression) - -> *where-expression* → [*表达式*](04_Expressions.md#expression) +> - -## 带标签的语句 +#### where-expression {#where-expression} +> *where-expression* → [*表达式*](./04_Expressions.md#expression) +> +> +#### grammar_conditional-switch-case {#grammar-conditional-switch-case} +> *conditional-switch-case* → [*switch-if-directive-clause*](#switch-case-attributes-label) [*switch-elseif-directive-clauses*](#switch-case-attributes-label) 可选 [*switch-else-directive-clause*](#switch-case-attributes-label) 可选 [*endif-directive*](#switch-case-attributes-label) +> + +#### grammar_switch-if-directive-clause {#grammar-switch-if-directive-clause} +> *switch-if-directive 语句* → [*if-directive*](#switch-case-attributes-label) [*compilation-condition*](#switch-case-attributes-label) [*switch-cases*](#switch-case-attributes-label) 可选 +> + +#### grammar_switch-elseif-directive-clauses {#grammar-switch-elseif-directive-clauses} +> *switch-elseif-directive 语句（复数）* → [*elseif-directive-clause*](#switch-case-attributes-label) [*switch-elseif-directive-clauses*](#switch-case-attributes-label)可选 +> + +#### grammar_switch-elseif-directive-clause {#grammar-switch-elseif-directive-clause} +> *switch-elseif-directive 语句* → [*elseif-directive*](#switch-case-attributes-label) [*compilation-condition*](#switch-case-attributes-label) [*switch-cases*](#switch-case-attributes-label)可选 +> + +#### grammar_switch-else-directive-clause {#grammar-switch-else-directive-clause} +> *switch-else-directive 语句* → [*else-directive*](#switch-case-attributes-label) [*switch-cases*](#switch-case-attributes-label) 可选 +> + +## 带标签的语句 {#labeled-statements} 你可以在循环语句或 `switch` 语句前面加上标签，它由标签名和紧随其后的冒号（`:`）组成。在 `break` 和 `continue` 后面跟上标签名可以显式地在循环语句或 `switch` 语句中改变相应的控制流。关于这两条语句用法，请参阅 [Break 语句](#break_statement) 和 [Continue 语句](#continue_statement)。 标签的作用域在该标签所标记的语句内。可以嵌套使用带标签的语句，但标签名必须唯一。 -关于使用带标签的语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章中的 [带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 +关于使用带标签的语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章中的 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 > 带标签的语句语法 > - -> *带标签的语句* → [*语句标签*](#statement-label) [*循环语句*](#loop-statement) +> + +#### labeled-statement {#labeled-statement} +> *带标签的语句* → [*语句标签*](#statement-label) [*循环语句*](#grammar_loop-statement) +> > *带标签的语句* → [*语句标签*](#statement-label) [*if 语句*](#if-statement) +> > *带标签的语句* → [*语句标签*](#statement-label) [*switch 语句*](#switch-statement) +> > > *带标签的语句* → [*语句标签*](#statement-label) [*do 语句*](#sdo-statement) - +> + +#### statement-label {#statement-label} > *语句标签* → [*标签名称*](#label-name) **:** - -> *标签名称* → [*标识符*](02_Lexical_Structure.md#identifier) +> - -## 控制转移语句 +#### label-name {#label-name} +> *标签名称* → [*标识符*](./02_Lexical_Structure.md#identifier) +> +## 控制转移语句 {#control-transfer-statements} 控制转移语句能够无条件地把控制权从一片代码转移到另一片代码，从而改变代码执行的顺序。Swift 提供五种类型的控制转移语句：`break` 语句、`continue` 语句、`fallthrough` 语句、`return` 语句和 `throw` 语句。 > 控制转移语句语法 > - +> + +#### control-transfer-statement {#control-transfer-statement} > *控制转移语句* → [*break 语句*](#break-statement) +> > *控制转移语句* → [*continue 语句*](#continue-statement) +> > *控制转移语句* → [*fallthrough 语句*](#fallthrough-statement) +> > *控制转移语句* → [*return 语句*](#return-statement) +> > *控制转移语句* → [*throw 语句*](#throw-statement) +> - -### Break 语句 - +### Break 语句 {#break-statement} `break` 语句用于终止循环语句、`if` 语句或 `switch` 语句的执行。使用 `break` 语句时，可以只写 `break` 这个关键词，也可以在 `break` 后面跟上标签名，像下面这样： > break +> > break `label name` +> 当 `break` 语句后面带标签名时，可用于终止由这个标签标记的循环语句、`if` 语句或 `switch` 语句的执行。 @@ -366,20 +426,23 @@ case let (x, y) where x == y: 无论哪种情况，控制权都会被转移给被终止的控制流语句后面的第一行语句。 -关于使用 `break` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章的 [Break](../chapter2/05_Control_Flow.html#break) 和 [带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 +关于使用 `break` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [Break](../chapter2/05_Control_Flow.md#break) 和 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 > break 语句语法 > - +> + +#### break-statement {#break-statement} > *break 语句* → **break** [*标签名称*](#label-name)可选 +> - -### Continue 语句 - +### Continue 语句 {#continue-statement} `continue` 语句用于终止循环中当前迭代的执行，但不会终止该循环的执行。使用 `continue` 语句时，可以只写 `continue` 这个关键词，也可以在 `continue` 后面跟上标签名，像下面这样： > continue +> > continue `label name` +> 当 `continue` 语句后面带标签名时，可用于终止由这个标签标记的循环中当前迭代的执行。 @@ -389,53 +452,61 @@ case let (x, y) where x == y: 在 `for` 语句中，`continue` 语句执行后，增量表达式还是会被计算，这是因为每次循环体执行完毕后，增量表达式都会被计算。 -关于使用 `continue` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章的 [Continue](../chapter2/05_Control_Flow.html#continue) 和 [带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 +关于使用 `continue` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [Continue](../chapter2/05_Control_Flow.md#continue) 和 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 > continue 语句语法 > - +> + +#### continue-statement {#continue-statement} > *continue 语句* → **continue** [*标签名称*](#label-name)可选 +> - -### Fallthrough 语句 - +### Fallthrough 语句 {#fallthrough-statements} `fallthrough` 语句用于在 `switch` 语句中转移控制权。`fallthrough` 语句会把控制权从 `switch` 语句中的一个 `case` 转移到下一个 `case`。这种控制权转移是无条件的，即使下一个 `case` 的模式与 `switch` 语句的控制表达式的值不匹配。 `fallthrough` 语句可出现在 `switch` 语句中的任意 `case` 中，但不能出现在最后一个 `case` 中。同时，`fallthrough` 语句也不能把控制权转移到使用了值绑定的 `case`。 -关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章的 [控制转移语句](../chapter2/05_Control_Flow.html#control_transfer_statements)。 +关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [控制转移语句](../chapter2/05_Control_Flow.md#control_transfer_statements)。 > fallthrough 语句语法 > - +> + +#### fallthrough-statement {#fallthrough-statement} > *fallthrough 语句* → **fallthrough** +> - -### Return 语句 - +### Return 语句 {#return-statements} `return` 语句用于在函数或方法的实现中将控制权转移到调用函数或方法，接着程序将会从调用位置继续向下执行。 使用 `return` 语句时，可以只写 `return` 这个关键词，也可以在 `return` 后面跟上表达式，像下面这样： > return +> > return `expression` +> 当 `return` 语句后面带表达式时，表达式的值将会返回给调用函数或方法。如果表达式的值的类型与函数或者方法声明的返回类型不匹配，Swift 则会在返回表达式的值之前将表达式的值的类型转换为返回类型。 > 注意 > -> 正如 [可失败构造器](05_Declarations.html#failable_initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。 +> +> 正如 [可失败构造器](./06_Declarations.md#failable_initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。 +> 而只写 `return` 时，仅仅是从该函数或方法中返回，而不返回任何值（也就是说，函数或方法的返回类型为 `Void` 或者说 `()`）。 > return 语句语法 > - -> *return 语句* → **return** [*表达式*](04_Expressions.html#expression)可选 +> - -### Throw 语句 +#### return-statement {#return-statement} +> *return 语句* → **return** [*表达式*](./04_Expressions.html#expression)可选 +### Throw 语句 {#throw-statements} + +### Throw 语句 {#throw-statements} `throw` 语句出现在抛出函数或者抛出方法体内，或者类型被 `throws` 关键字标记的闭包表达式体内。 `throw` 语句使程序在当前作用域结束执行，并向外围作用域传播错误。抛出的错误会一直传递，直到被 `do` 语句的 `catch` 子句处理掉。 @@ -443,19 +514,21 @@ case let (x, y) where x == y: `throw` 语句由 `throw` 关键字紧跟一个表达式组成，如下所示： > throw `expression` +> 表达式的结果必须符合 `ErrorType` 协议。 -关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.html) 一章的 [用 throwing 函数传递错误](../chapter2/18_Error_Handling.html#propagating_errors_using_throwing_functions)。 +关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../chapter2/17_Error_Handling.md#propagating_errors_using_throwing_functions)。 > throw 语句语法 > - -> *throw 语句* → **throw** [*表达式*](04_Expressions.html#expression) +> - -## Defer 语句 +#### throw-statement {#throw-statement} +> *throw 语句* → **throw** [*表达式*](./04_Expressions.md#expression) +> +## Defer 语句 {#defer-statements} `defer` 语句用于在退出当前作用域之前执行代码。 `defer` 语句形式如下： @@ -477,21 +550,22 @@ func f() { defer { print("Third") } } f() -// 打印 “Third” -// 打印 “Second” -// 打印 “First” +// 打印“Third” +// 打印“Second” +// 打印“First” ``` `defer` 语句中的语句无法将控制权转移到 `defer` 语句外部。 > defer 语句语法 > - -> *延迟语句* → **defer** [*代码块*](05_Declarations.html#code-block) +> - -## Do 语句 +#### defer-statement {#defer-statement} +> *延迟语句* → **defer** [*代码块*](./06_Declarations.md#code-block) +> +## Do 语句 {#do-statements} `do` 语句用于引入一个新的作用域，该作用域中可以含有一个或多个 `catch` 子句，`catch` 子句中定义了一些匹配错误条件的模式。`do` 语句作用域内定义的常量和变量只能在 `do` 语句作用域内使用。 Swift 中的 `do` 语句与 C 中限定代码块界限的大括号（`{}`）很相似，也并不会降低程序运行时的性能。 @@ -511,36 +585,45 @@ do { 如同 `switch` 语句，编译器会判断 `catch` 子句是否有遗漏。如果 `catch` 子句没有遗漏，则认为错误已被处理。否则，错误会自动传递到外围作用域，被某个 `catch` 子句处理掉或者被用 `throws` 关键字声明的抛出函数继续向外抛出。 -为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](07_Patterns.html)。 +为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](./08_Patterns.md)。 -关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.html#handling_errors)。 +关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md#handling_errors)。 > do 语句语法 > - -> *do 语句* → **do** [*代码块*](05_Declarations.html#code-block) [*多条 catch 子句*](#catch-clauses)可选 - +> + +#### do-statement {#do-statement} +> *do 语句* → **do** [*代码块*](./06_Declarations.md#code-block) [*多条 catch 子句*](#catch-clauses)可选 +> + +#### catch-clauses {#catch-clauses} > *多条 catch 子句* → [*catch 子句*](#catch-clause) [*多条 catch 子句*](#catch-clauses)可选 - -> *catch 子句* → **catch** [*模式*](07_Patterns.html#pattern)可选 [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.html#code-block) +> - -## 编译器控制语句 +#### catch-clause {#catch-clause} +> *catch 子句* → **catch** [*模式*](./08_Patterns.md#pattern)可选 [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.md#code-block) +> -编译器控制语句允许程序改变编译器的行为。Swift 有两种编译器控制语句：编译配置语句和线路控制语句。 +## 编译器控制语句 {#compiler-control-statements} +编译器控制语句允许程序改变编译器的行为。Swift 有三种编译器控制语句：条件编译语句、线路控制语句和编译时诊断语句。 > 编译器控制语句语法 > - -> *编译器控制语句* → [*编译配置语句*](#build-config-statement) +> + +#### compiler-control-statement {#compiler-control-statement} +> *编译器控制语句* → [*条件编译语句*](#grammar_conditional-compilation-block) +> > *编译器控制语句* → [*线路控制语句*](#line-control-statement) +> +> *编译器控制语句* → [*诊断语句*](#grammar_diagnostic-statement) +> - -### 条件性编译块 +### 条件编译代码块 {#Conditional-Compilation-Block} +条件编译代码块可以根据一个或多个配置来有条件地编译代码。 -条件性编译块可以根据一个或多个配置来有条件地编译代码。 - -每一个条件性编译块都以 `#if` 开始，`#endif` 结束。如下是一个简单的条件性编译块： +每一个条件编译代码块都以 `#if` 开始，`#endif` 结束。如下： ```swift #if compilation condition @@ -556,13 +639,37 @@ statements | --- | --- | | `os()` | `OSX`, `iOS`, `watchOS`, `tvOS`, `Linux` | | `arch()` | `i386`, `x86_64`, `arm`, `arm64` | -| `swift()` | `>=` 后跟版本号 | +| `swift()` | `>=` 或 `<` 后跟版本号 | +| `compiler()` | `>=` 或 `<` 后跟版本号 | +| `canImport()` | 模块名 | +| `targetEnvironment()` | 模拟器 | -`swift()`（语言版本检测函数）的版本号参数主要由主版本号和次版本号组成并且使用点号（`.`）分隔开，`>=` 和版本号之间不能有空格。 +在 `swift()` 和 `compiler()` 之后的版本号包含有主版本号，可选副版本号，可选补丁版本号类似，并且用（`.`）来分隔。在比较符和版本号之间不能有空格，版本号与前面的函数相对应，比如 `compiler()` 对应的就是这个编译器的版本号，`swift()` 对应的就是你要编译的 `Swift` 语言的版本号。举个简单的例子，如果你在使用 `Swift 5` 的编译器，想编译 `Swift 4.2` ，可以看下面的例子： + +```swift +#if compiler(>=5) +print("Compiled with the Swift 5 compiler or later") +#endif +#if swift(>=4.2) +print("Compiled in Swift 4.2 mode or later") +#endif +#if compiler(>=5) && swift(<5) +print("Compiled with the Swift 5 compiler or later in a Swift mode earlier than 5") +#endif +// 打印 "Compiled with the Swift 5 compiler or later" +// 打印 "Compiled in Swift 4.2 mode or later" +// 打印 "Compiled with the Swift 5 compiler or later in a Swift mode earlier than 5" +``` + +`canImport()` 后面跟的变量是模块的名字，这里这个模块可能并不是每个平台上都存在的。使用它来检测是否可以导入这个模块，如果模块存在就返回 `true` 否则返回 `false` 。 + +`targetEnvironment()` 当为模拟器编译时返回 `true`，否则返回 `false` 。 > 注意 > +> > `arch(arm)` 平台检测函数在 ARM 64 位设备上不会返回 `true`。如果代码在 32 位的 iOS 模拟器上编译，`arch(i386)` 平台检测函数会返回 `true`。 +> 你可以使用逻辑操作符 `&&`、`||` 和 `!` 来组合多个编译配置，还可以使用圆括号来进行分组。 @@ -580,70 +687,171 @@ statements to compile if both compilation conditions are false > 注意 > +> > 即使没有被编译，编译配置中的语句仍然会被解析。然而，唯一的例外是编译配置语句中包含语言版本检测函数：仅当 `Swift` 编译器版本和语言版本检测函数中指定的版本号匹配时，语句才会被解析。这种设定能确保旧的编译器不会尝试去解析新 Swift 版本的语法。 - - -> 编译配置语句语法 > - -> *单个编译配置语句* → **if** [*编译配置*](#build-configuration) [*语句*](#statements)可选 [*多个编译配置 elseif 子句*](#build-configuration-elseif-clauses)可选 **-** [*单个编译配置 else 子句*](#build-configuration-else-clause)可选 **#endif** - -> *多个编译配置 elseif 子句* → [*单个编译配置 elseif 子句*](#build-configuration-elseif-clause) [*多个编译配置 elseif 子句*](build-configuration-elseif-clauses)可选 - -> *单个编译配置 elseif 子句* → **#elseif** [*编译配置*](#build-configuration) [*语句*](#statements)可选 - -> *单个编译配置 else 子句* → **#else** [*语句*](#statements)可选 - -> *编译配置* → [*平台检测函数*](#platform-testing-function) -> *编译配置* → [*语言版本检测函数*](#language-version-testing-function) -> *编译配置* → [*标识符*](02_Lexical_Structure.md#identifier) -> *编译配置* → [*布尔值字面量*](02_Lexical_Structure.md#boolean-literal) -> *编译配置* → **(** [*编译配置*](#build-configuration) **)** -> *编译配置* → **!** [*编译配置*](#build-configuration) -> *编译配置* → [*编译配置*](#build-configuration) **&&** [*编译配置*](#build-configuration) -> *编译配置* → [*编译配置*](#build-configuration) **||** [*编译配置*](#build-configuration) - -> *平台检测函数* → **os** **(** [*操作系统*](#operating-system) **)** -> *平台检测函数* → **arch** **(** [*架构*](#architecture) **)** - -> *语言版本检测函数* → **swift** **(** **>=** [*swift 版本*](#swift-version) **)** - -> *操作系统* → **OSX** | **iOS** | **watchOS** | **tvOS** - +#### build-config-statement {#build-config-statement} +> 条件编译代码块语法 +> +> + +#### grammar_conditional-compilation-block {#grammar-conditional-compilation-block} +> *条件编译代码块* → [*if-directive 语句*](#grammar_if-directive-clause) [*elseif-directive 语句（复数）*](#grammar_elseif-directive-clauses)可选 [*else-directive 语句*](#grammar_else-directive-clause)可选 [*endif-directive*](#grammar_endif-directive) +> + +#### grammar_if-directive-clause {#grammar-if-directive-clause} +> *if-directive 语句* → [*if-directive*](#grammar_if-directive) [*编译条件*](#compilation-condition) [*语句（复数）*](#statements)可选 +> + +#### grammar_elseif-directive-clauses {#grammar-elseif-directive-clauses} +> *elseif-directive 语句（复数）* → [*elseif-directive 语句*](#grammar_elseif-directive-clause) [*elseif-directive 语句（复数）*](#grammar_elseif-directive-clauses) +> + +#### grammar_elseif-directive-clauses {#grammar-elseif-directive-clauses} +> *elseif-directive 语句* → [*elseif-directive*](#grammar_elseif-directive) [*编译条件*](#compilation-condition) [*语句（复数）*](#statements)可选 +> + +#### grammar_else-directive-clause {#grammar-else-directive-clause} +> *else-directive 语句* → [*else-directive*](#grammar_else-directive) [*语句（复数）*](#statements)可选 +> + + +> *if-directive* → **#if** +> +> *elseif-directive* → **#elseif** +> +> *else-directive* → **#else** +> +> *endif-directive* → **#endif** +> + + +#### compilation-condition {#compilation-condition} +> *编译条件* → [*平台条件*](#grammar_platform-condition) +> +> *编译条件* → [*标识符*](./02_Lexical_Structure.md#identifier) +> +> *编译条件* → [*布尔值字面量*](./02_Lexical_Structure.md#boolean-literal) +> +> *编译条件* → **(** [*编译条件*](#compilation-condition) **)** +> +> *编译条件* → **!** [*编译条件*](#compilation-condition) +> +> *编译条件* → [*编译条件*](#compilation-condition) **&&** [*编译条件*](#compilation-condition) +> +> *编译条件* → [*编译条件*](#compilation-condition) **||** [*编译条件*](#compilation-condition) +> + + +#### grammar_platform-condition {#grammar-platform-condition} + +#### grammar_platform-condition-os {#grammar-platform-condition-os} +> *平台条件* → **os ( [*操作系统*](#operating-system) )** +> + +#### grammar_platform-condition-arch {#grammar-platform-condition-arch} +> *平台条件* → **arch ( [*架构*](#architecture) )** +> + +#### grammar_platform-condition-swift {#grammar-platform-condition-swift} +> *平台条件* → **swift ( >= [*swift 版本*](#swift-version) )** | **swift ( < [*swift 版本*](#swift-version) )** +> + +#### grammar_platform-condition-compiler {#grammar-platform-condition-compiler} +> *平台条件* → **compiler ( >= [*swift 版本*](#swift-version) )** | **compiler ( < [*swift 版本*](#swift-version) )** +> + +#### grammar_platform-condition-canImport {#grammar-platform-condition-canImport} +> *平台条件* → **canImport ( [*模块名*](#grammar_module-name) )** +> + +#### grammar_platform-condition-targetEnvironment {#grammar-platform-condition-targetEnvironment} +> *平台条件* → **targetEnvironment ( [*环境*](#grammar_environment) )** +> + +#### operating-system {#operating-system} +> *操作系统* → **macOS** | **iOS** | **watchOS** | **tvOS** +> + +#### architecture {#architecture} > *架构* → **i386** | **x86_64** | **arm** | **arm64** - -> *swift 版本* → [*十进制数字*](02_Lexical_Structure.md#decimal-digit) **.** [*十进制数字*](02_Lexical_Structure.md#decimal-digit) +> - -### 行控制语句 +#### swift-version {#swift-version} +> *swift 版本* → [*十进制数字*](./02_Lexical_Structure.md#decimal-digit) **.** [*swift 版本延续*](#grammar_swift-version-continuation) 可选 +> +#### grammar_swift-version-continuation {#grammar-swift-version-continuation} +> *swift 版本延续* → **.** [*十进制数字*](./02_Lexical_Structure.md#decimal-digit) [*swift 版本延续*](#grammar_swift-version-continuation) 可选 +> + +#### grammar_module-name {#grammar-module-name} +> *模块名* → [*identifier*](./02_Lexical_Structure.md#identifier) +> + +#### grammar_environment {#grammar-environment} +> *环境* → **模拟器** +> + +### 行控制语句 {#line-control-statements} 行控制语句可以为被编译的源代码指定行号和文件名，从而改变源代码的定位信息，以便进行分析和调试。 行控制语句形式如下： > \#sourceLocation(file: `filename` , line:`line number`) +> > \#sourceLocation() +> 第一种的行控制语句会改变该语句之后的代码中的字面量表达式 `#line` 和 `#file` 所表示的值。`行号` 是一个大于 0 的整形字面量，会改变 `#line` 表达式的值。`文件名` 是一个字符串字面量，会改变 `#file` 表达式的值。 第二种的行控制语句，`#sourceLocation()`，会将源代码的定位信息重置回默认的行号和文件名。 - + +#### line-control-statement {#line-control-statement} > 行控制语句语法 > +> > *行控制语句* → **#sourceLocation(file:[*文件名*](#file-name),line:[*行号*](#line-number))** +> > *行控制语句* → **#sourceLocation()** - +> + +#### line-number {#line-number} > *行号* → 大于 0 的十进制整数 - -> *文件名* → [*静态字符串字面量*](02_Lexical_Structure.md#static-string-literal) +> - -### 可用性条件 +#### file-name {#file-name} +> *文件名* → [*静态字符串字面量*](./02_Lexical_Structure.md#static-string-literal) +> +### 编译时诊断语句 {#compile-time-diagnostic-statement} + +编译时诊断语句允许编译器在编译的时候可以发出错误或者警告。语句形式如下： + +```swift +#error("error message") +#warning("warning message") +``` + +第一句会抛出错误信息并终止编译，第二句会发出警告信息但是编译会继续进行。你可以通过静态字符串字面量来书写诊断信息，静态字符串字面量不能使用字符串 `interpolation` 或者 `concatenation`，但可以使用多行的形式。 + +> 编译时诊断语句语法 +> +> + +#### grammar_compile-time-diagnostic-statement {#grammar-compile-time-diagnostic-statement} +> *诊断语句* → **#error** **(** [*diagnostic-message*](#grammar_diagnostic-message) **)** +> +> *诊断语句* → **#warning** **(** [*diagnostic-message*](#grammar_diagnostic-message) **)** +> +> *诊断语句* → [*静态字符串字面量*](./02_Lexical_Structure.md#static-string-literal) +> + +## 可用性条件 {#availability-condition} 可用性条件可作为 `if`，`while`，`guard` 语句的条件，可以在运行时基于特定的平台参数来查询 API 的可用性。 可用性条件的形式如下： @@ -664,20 +872,37 @@ if #available(platform name version, ..., *) { > 可用性条件语法 > - +> + +#### availability-condition {#availability-condition} > *可用性条件* → **#available** **(** [*可用性参数列表*](#availability-arguments) **)** - +> + +#### availability-arguments {#availability-arguments} > *可用性参数列表* → [*可用性参数*](#availability-argument) | [*可用性参数*](#availability-argument) **,** [*可用性参数列表*](#availability-arguments) - +> + +#### availability-argument {#availability-argument} > *可用性参数* → [平台名称](#platform-name) [平台版本](#platform-version) +> > *可用性条件* → __*__ > - +> + +#### platform-name {#platform-name} > *平台名称* → **iOS** | **iOSApplicationExtension** +> > *平台名称* → **OSX** | **macOSApplicationExtension** +> > *平台名称* → **watchOS** +> > *平台名称* → **tvOS** - -> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) -> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) -> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) +> + +#### platform-version {#platform-version} +> *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) +> +> *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02_Lexical_Structure.md#decimal-digits) +> +> *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02_Lexical_Structure.md#decimal-digits) +> diff --git a/source/chapter3/06_Declarations.md b/source/chapter3/06_Declarations.md index 6efcd365..d3ebee4f 100755 --- a/source/chapter3/06_Declarations.md +++ b/source/chapter3/06_Declarations.md @@ -1,105 +1,58 @@ - -# 声明（Declarations） ------------------ +# 声明（Declarations） {#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) +*声明（declaration）* 用以向程序里引入新的名字或者结构。举例来说，可以使用声明来引入函数和方法，变量和常量，或者定义新的具有命名的枚举、结构体、类和协议类型。还可以使用声明来扩展一个既有的具有命名的类型的行为，或者在程序里引入在其它地方声明的符号。 -> 2.0 -> 翻译+校对：[Lenhoon](https://github.com/Lenhoon), -> [BridgeQ](https://github.com/WXGBridgeQ) - -> 2.1 -> 翻译：[mmoaay](https://github.com/mmoaay), [shanks](http://codebuild.me) -> 校对：[shanks](http://codebuild.me) - -> 2.2 -> 翻译：[星夜暮晨](https://github.com/SemperIdem) - -> 3.0 -> 翻译：[chenmingjia](https://github.com/chenmingjia) - -> 4.1 -> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) - -本页包含内容： - -- [顶级代码](#top-level_code) -- [代码块](#code_blocks) -- [导入声明](#import_declaration) -- [常量声明](#constant_declaration) -- [变量声明](#variable_declaration) - - [存储型变量和存储型变量属性](#stored_variables_and_stored_variable_properties) - - [计算型变量和计算型属性](#computed_variables_and_computed_properties) - - [存储型变量和属性的观察器](#stored_variable_observers_and_property_observers) - - [类型变量属性](#type_variable_properties) -- [类型别名声明](#type_alias_declaration) -- [函数声明](#function_declaration) - - [参数名](#parameter_names) - - [输入输出参数](#in-out_parameters) - - [特殊参数](#special_kinds_of_parameters) - - [特殊方法](#special_kinds_of_methods) - - [抛出错误的函数和方法](#throwing_functions_and_methods) - - [重抛错误的函数和方法](#rethrowing_functions_and_methods) -- [枚举声明](#enumeration_declaration) - - [任意类型的枚举用例](#enumerations_with_cases_of_any_type) - - [递归枚举](#enumerations_with_indirection) - - [拥有原始值的枚举用例](#enumerations_with_cases_of_a_raw-value_type) - - [访问枚举用例](#accessing_enumeration_cases) -- [结构体声明](#structure_declaration) -- [类声明](#class_declaration) -- [协议声明](#protocol_declaration) - - [协议属性声明](#protocol_property_declaration) - - [协议方法声明](#protocol_method_declaration) - - [协议构造器声明](#protocol_initializer_declaration) - - [协议下标声明](#protocol_subscript_declaration) - - [协议关联类型声明](#protocol_associated_type_declaration) -- [构造器声明](#initializer_declaration) - - [可失败构造器](#failable_initializers) -- [析构器声明](#deinitializer_declaration) -- [扩展声明](#extension_declaration) -- [下标声明](#subscript_declaration) -- [运算符声明](#operator_declaration) -- [声明修饰符](#declaration_modifiers) - - [访问控制级别](#access_control_levels) - -*声明（declaration）* 用以向程序里引入新的名字或者结构。举例来说，可以使用声明来引入函数和方法，变量和常量，或者定义新的具有命名的枚举、结构、类和协议类型。还可以使用声明来扩展一个既有的具有命名的类型的行为，或者在程序里引入在其它地方声明的符号。 - -在 Swift 中，大多数声明在某种意义上讲也是定义，因为声明往往伴随着实现或初始化。由于协议并不提供实现，大多数协议成员仅仅只是声明而已。为了方便起见，也是因为这些区别在 Swift 中并不是很重要，“声明”这个术语同时包含了声明和定义两种含义。 +在 Swift 中，大多数声明在某种意义上讲也是定义，因为它们在声明时往往伴随着实现或初始化。由于协议并不提供实现，大多数协议成员仅仅只是声明而已。为了方便起见，也是因为这些区别在 Swift 中并不是很重要，“声明”这个术语同时包含了声明和定义两种含义。 > 声明语法 -> +> +> +#### declaration {#declaration} +> > *声明* → [*导入声明*](#import-declaration) +> > *声明* → [*常量声明*](#constant-declaration) +> > *声明* → [*变量声明*](#variable-declaration) +> > *声明* → [*类型别名声明*](#typealias-declaration) +> > *声明* → [*函数声明*](#function-declaration) +> > *声明* → [*枚举声明*](#enum-declaration) +> > *声明* → [*结构体声明*](#struct-declaration) +> > *声明* → [*类声明*](#class-declaration) +> > *声明* → [*协议声明*](#protocol-declaration) +> > *声明* → [*构造器声明*](#initializer-declaration) +> > *声明* → [*析构器声明*](#deinitializer-declaration) +> > *声明* → [*扩展声明*](#extension-declaration) +> > *声明* → [*下标声明*](#subscript-declaration) +> > *声明* → [*运算符声明*](#operator-declaration) -> +> +> +#### declarations {#declarations} +> > *多条声明* → [*声明*](#declaration) [*多条声明*](#declarations)可选 +> - -## 顶级代码 - +## 顶级代码 {#top-level-code} Swift 的源文件中的顶级代码（top-level code）由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access_control_levels)。 > 顶级声明语法 > -> *顶级声明* → [*多条语句*](10_Statements.html#statements)可选 +> *顶级声明* → [*多条语句*](./05_Statements.md#statements)可选 +> - -## 代码块 - -*代码块（code block）* 可以将一些声明和控制结构组织在一起。它有如下的形式： +## 代码块 {#code-blocks} +*代码块（code block）* 可以将一些声明和控制结构体组织在一起。它有如下的形式： ```swift { @@ -111,12 +64,13 @@ Swift 的源文件中的顶级代码（top-level code）由零个或多个语句 > 代码块语法 > -> -> *代码块* → **{** [*多条语句*](10_Statements.html#statements)可选 **}** - - -## 导入声明 +> +#### code-block {#code-block} +> +> *代码块* → **{** [*多条语句*](./05_Statements.md#statements)可选 **}** +> +## 导入声明 {#import-declaration} *导入声明（import declaration）* 让你可以使用在其他文件中声明的内容。导入语句的基本形式是导入整个模块，它由 `import` 关键字和紧随其后的模块名组成： ```swift @@ -130,22 +84,32 @@ import 导入类型 模块.符号名 import 模块.子模块 ``` - + +#### grammer_of_an_import_declaration {#grammer-of-an-import-declaration} > 导入声明语法 > -> -> *导入声明* → [*特性列表*](06_Attributes.html#attributes)可选 **import** [*导入类型*](#import-kind)可选 [*导入路径*](#import-path) > -> +#### import-declaration {#import-declaration} +> +> *导入声明* → [*特性列表*](./07_Attributes.md#attributes)可选 **import** [*导入类型*](#import-kind)可选 [*导入路径*](#import-path) +> +> +#### import-kind {#import-kind} +> > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **let** | **var** | **func** -> +> +> +#### import-path {#import-path} +> > *导入路径* → [*导入路径标识符*](#import-path-identifier) | [*导入路径标识符*](#import-path-identifier) **.** [*导入路径*](#import-path) -> -> *导入路径标识符* → [*标识符*](02_Lexical_Structure.html#identifier) | [*运算符*](02_Lexical_Structure.html#operator) - - -## 常量声明 +> +> +#### import-path-identifier {#import-path-identifier} +> +> *导入路径标识符* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator) +> +## 常量声明 {#constant-declaration} *常量声明（constant declaration）* 可以在程序中引入一个具有命名的常量。常量以关键字 `let` 来声明，遵循如下格式： ```swift @@ -154,7 +118,7 @@ let 常量名称: 类型 = 表达式 常量声明在“常量名称”和用于初始化的“表达式”的值之间定义了一种不可变的绑定关系；当常量的值被设定之后，它就无法被更改。这意味着，如果常量以类对象来初始化，对象本身的内容是可以改变的，但是常量和该对象之间的绑定关系是不能改变的。 -当一个常量被声明为全局常量时，它必须拥有一个初始值。在类或者结构中声明一个常量时，它将作为*常量属性（constant property）*。常量声明不能是计算型属性，因此也没有存取方法。 +当一个常量被声明为全局常量时，它必须拥有一个初始值。在函数或者方法中声明一个常量时，它并不需要拥有一个初始值，只需要保证在第一次对其进行读操作之前为其设置一个值。在类或者结构体中声明一个常量时，它将作为*常量属性（constant property）*。常量声明不能是计算型属性，因此也没有存取方法。 如果常量名称是元组形式，元组中每一项的名称都会和初始化表达式中对应的值进行绑定。 @@ -166,32 +130,43 @@ let (firstNumber, secondNumber) = (10, 42) ```swift print("The first number is \(firstNumber).") -// 打印 “The first number is 10.” +// 打印“The first number is 10.” print("The second number is \(secondNumber).") -// 打印 “The second number is 42.” +// 打印“The second number is 42.” ``` -当常量名称的类型（`:` 类型）可以被推断出时，类型标注在常量声明中是可选的，正如 [类型推断](03_Types.html#type_inference) 中所描述的。 +当常量名称的类型（`:` 类型）可以被推断出时，类型标注在常量声明中是可选的，正如 [类型推断](./03_Types.md#type_inference) 中所描述的。 -声明一个常量类型属性要使用 `static` 声明修饰符。类型属性在 [类型属性](../chapter2/10_Properties.html#type_properties)中有介绍。 +声明一个常量类型属性要使用 `static` 声明修饰符。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties)中有介绍。 -如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../chapter2/01_The_Basics.html#constants_and_variables) 和 [存储属性](../chapter2/10_Properties.html#stored_properties)。 +如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../chapter2/01_The_Basics.md#constants_and_variables) 和 [存储属性](../chapter2/10_Properties.md#stored_properties)。 - + +#### grammer_of_a_constant_declaration {#grammer-of-a-constant-declaration} > 常量声明语法 > -> -> *常量声明* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **let** [*模式构造器列表*](pattern-initializer-list) -> +> +#### constant-declaration {#constant-declaration} +> +> *常量声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **let** [*模式构造器列表*](pattern-initializer-list) +> +> +#### pattern-initializer-list {#pattern-initializer-list} +> > *模式构造器列表* → [*模式构造器*](#pattern-initializer) | [*模式构造器*](#pattern-initializer) **,** [*模式构造器列表*](#pattern-initializer-list) -> -> *模式构造器* → [*模式*](07_Patterns.html#pattern) [*构造器*](#initializer)可选 -> -> *构造器* → **=** [*表达式*](04_Expressions.html#expression) - - -## 变量声明 +> +> +#### pattern-initializer {#pattern-initializer} +> +> *模式构造器* → [*模式*](./08_Patterns.md#pattern) [*构造器*](#initializer)可选 +> +> +#### initializer {#initializer} +> +> *构造器* → **=** [*表达式*](./04_Expressions.md#expression) +> +## 变量声明 {#variable-declaration} *变量声明（variable declaration）* 可以在程序中引入一个具有命名的变量，它以关键字 `var` 来声明。 变量声明有几种不同的形式，可以声明不同种类的命名值和可变值，如存储型和计算型变量和属性，属性观察器，以及静态变量属性。所使用的声明形式取决于变量声明的适用范围和打算声明的变量类型。 @@ -199,19 +174,18 @@ print("The second number is \(secondNumber).") > 注意 > > 也可以在协议声明中声明属性，详情请参阅 [协议属性声明](#protocol_property_declaration)。 +> -可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../chapter2/13_Inheritance.html#overriding)。 - - -### 存储型变量和存储型变量属性 +可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../chapter2/13_Inheritance.md#overriding)。 +### 存储型变量和存储型变量属性 {#stored-variables-and-stored-variable-properties} 使用如下形式声明一个存储型变量或存储型变量属性： ```swift var 变量名称: 类型 = 表达式 ``` -可以在全局范围，函数内部，或者在类和结构的声明中使用这种形式来声明一个变量。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个存储型变量。当它在类或者结构中被声明时，它代表一个*存储型变量属性（stored variable property）*。 +可以在全局范围，函数内部，或者在类和结构体的声明中使用这种形式来声明一个变量。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个存储型变量。当它在类或者结构体中被声明时，它代表一个*存储型变量属性（stored variable property）*。 用于初始化的表达式不可以在协议的声明中出现，在其他情况下，该表达式是可选的。如果没有初始化表达式，那么变量声明必须包含类型标注（`:` *type*）。 @@ -219,9 +193,7 @@ var 变量名称: 类型 = 表达式 正如名字所示，存储型变量和存储型变量属性的值会存储在内存中。 - -### 计算型变量和计算型属性 - +### 计算型变量和计算型属性 {#computed-variables-and-computed-properties} 使用如下形式声明一个计算型变量或计算型属性： ```swift @@ -235,19 +207,17 @@ var 变量名称: 类型 { } ``` -可以在全局范围、函数内部，以及类、结构、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性（computed property）*。 +可以在全局范围、函数内部，以及类、结构体、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构体、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性（computed property）*。 -getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../chapter2/10_Properties.html#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 +getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../chapter2/10_Properties.md#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 -setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../chapter2/10_Properties.html#shorthand_setter_declaration) 中描述的那样。 +setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../chapter2/10_Properties.md#shorthand_setter_declaration) 中描述的那样。 与存储型变量和存储型属性不同，计算型变量和计算型属性的值不存储在内存中。 -要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../chapter2/10_Properties.html#computed_properties)。 - - -### 存储型变量和属性的观察器 +要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../chapter2/10_Properties.md#computed_properties)。 +### 存储型变量和属性的观察器 {#stored-variable-observers-and-property-observers} 可以在声明存储型变量或属性时提供 `willSet` 和 `didSet` 观察器。一个包含观察器的存储型变量或属性以如下形式声明： ```swift @@ -261,10 +231,10 @@ var 变量名称: 类型 = 表达式 { } ``` -可以在全局范围、函数内部，或者类、结构的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，观察器表示一个存储型变量观察器。当它在类和结构的声明中被声明时，观察器表示一个属性观察器。 +可以在全局范围、函数内部，或者类、结构体的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，观察器表示一个存储型变量观察器。当它在类和结构体的声明中被声明时，观察器表示一个属性观察器。 可以为任何存储型属性添加观察器。也可以通过重写父类属性的方式为任何继承的属性（无论是存储型还是计算型的）添加观察器 -，正如 [重写属性观察器](../chapter2/13_Inheritance.html#overriding_property_observers) 中所描述的。 +，正如 [重写属性观察器](../chapter2/13_Inheritance.md#overriding_property_observers) 中所描述的。 用于初始化的表达式在类或者结构的声明中是可选的，但是在其他声明中则是必须的。如果可以从初始化表达式中推断出类型信息，那么可以不提供类型标注。 @@ -276,63 +246,104 @@ var 变量名称: 类型 = 表达式 { 提供了 `willSet` 时，`didSet` 是可选的。同样的，提供了 `didSet` 时，`willSet` 则是可选的。 -要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../chapter2/10_Properties.html#property_observers)。 +要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../chapter2/10_Properties.md#property_observers)。 - -### 类型变量属性 - -要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.html#type_properties) 章节有详细讨论。 +### 类型变量属性 {#type-variable-properties} +要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties) 章节有详细讨论。 > 注意 > > 在一个类声明中，使用关键字 `static` 与同时使用 `class` 和 `final` 去标记一个声明的效果相同。 +> - + +#### grammer_of_a_variable_declaration {#grammer-of-a-variable-declaration} > 变量声明语法 > - + +#### variable-declaration {#variable-declaration} > *变量声明* → [*变量声明头*](#variable-declaration-head) [*模式构造器列表*](#pattern-initializer-list) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*代码块*](#code-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*getter-setter 代码块*](#getter-setter-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*代码块*](#code-block) +> +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 代码块*](#getter-setter-block) +> +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> > *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*构造器*](#initializer) [*willSet-didSet 代码块*](#willSet-didSet-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*构造器*](#initializer)可选 [*willSet-didSet 代码块*](#willSet-didSet-block) +> +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*构造器*](#initializer)可选 [*willSet-didSet 代码块*](#willSet-didSet-block) +> - -> *变量声明头* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **var** -> -> *变量名称* → [*标识符*](02_Lexical_Structure.html#identifier) - +#### variable-declaration-head {#variable-declaration-head} +> *变量声明头* → [*特性列表*](./07_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **var** +> +> +#### variable-name {#variable-name} +> +> *变量名称* → [*标识符*](./02_Lexical_Structure.md#identifier) +> + + +#### getter-setter-block {#getter-setter-block} > *getter-setter 代码块* → [*代码块*](#code-block) +> > *getter-setter 代码块* → **{** [*getter 子句*](#getter-clause) [*setter 子句*](#setter-clause)可选 **}** +> > *getter-setter 代码块* → **{** [*setter 子句*](#setter-clause) [*getter 子句*](#getter-clause) **}** -> -> *getter 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **get** [*代码块*](#code-block) -> -> *setter 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **set** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) -> -> *setter 名称* → **(** [*标识符*](02_Lexical_Structure.html#identifier) **)** +> +> +#### getter-clause {#getter-clause} +> +> *getter 子句* → [*特性列表*](./07_Attributes.md#attributes)可选 **get** [*代码块*](#code-block) +> +> +#### setter-clause {#setter-clause} +> +> *setter 子句* → [*特性列表*](./07_Attributes.md#attributes)可选 **set** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) +> +> +#### setter-name {#setter-name} +> +> *setter 名称* → **(** [*标识符*](./02_Lexical_Structure.md#identifier) **)** +> - + +#### getter-setter-keyword-block {#getter-setter-keyword-block} > *getter-setter 关键字代码块* → **{** [*getter 关键字子句*](#getter-keyword-clause) [*setter 关键字子句*](#setter-keyword-clause)可选 **}** +> > *getter-setter 关键字代码块* → **{** [*setter 关键字子句*](#setter-keyword-clause) [*getter 关键字子句*](#getter-keyword-clause) **}** -> -> *getter 关键字子句* → [*特性列表*](06_Attributes.html#attributes)可选 **get** -> -> *setter 关键字子句* → [*特性列表*](06_Attributes.html#attributes)可选 **set** +> +> +#### getter-keyword-clause {#getter-keyword-clause} +> +> *getter 关键字子句* → [*特性列表*](./07_Attributes.md#attributes)可选 **get** +> +> +#### setter-keyword-clause {#setter-keyword-clause} +> +> *setter 关键字子句* → [*特性列表*](./07_Attributes.md#attributes)可选 **set** +> - + +#### willSet-didSet-block {#willSet-didSet-block} > *willSet-didSet 代码块* → **{** [*willSet 子句*](#willSet-clause) [*didSet 子句*](#didSet-clause)可选 **}** +> > *willSet-didSet 代码块* → **{** [*didSet 子句*](#didSet-clause) [*willSet 子句*](#willSet-clause)可选 **}** -> -> *willSet 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **willSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) -> -> *didSet 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **didSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) - - -## 类型别名声明 +> +> +#### willSet-clause {#willSet-clause} +> +> *willSet 子句* → [*特性列表*](./07_Attributes.md#attributes)可选 **willSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) +> +> +#### didSet-clause {#didSet-clause} +> +> *didSet 子句* → [*特性列表*](./07_Attributes.md#attributes)可选 **didSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) +> +## 类型别名声明 {#type-alias-declaration} *类型别名（type alias）* 声明可以在程序中为一个既有类型声明一个别名。类型别名声明语句使用关键字 `typealias` 声明，遵循如下的形式： ```swift @@ -340,23 +351,35 @@ typealias 类型别名 = 现存类型 ``` 当声明一个类型的别名后，可以在程序的任何地方使用“别名”来代替现有类型。现有类型可以是具有命名的类型或者混合类型。类型别名不产生新的类型，它只是使用别名来引用现有类型。 + 类型别名声明可以通过泛型参数来给一个现有泛型类型提供名称。类型别名为现有类型的一部分或者全部泛型参数提供具体类型。例如: ```swift typealias StringDictionary
+> +> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符] (02_Lexical_Structure.md#identifier) **(** [参数名称](./04_Expressions.md#argument-names) **)** +> +> *参数名称* → [参数名](./04_Expressions.md#argument-name) [参数名称](./04_Expressions.md#argument-names)可选
+> +> *参数名* → [标识符](./02_Lexical_Structure.md#identifier) **:** +> + + + +> 后缀 self 表达式语法 +> +> *后缀 self 表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** **self** +> + + + +> 下标表达式语法 +> +> *下标表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **[** [表达式列表](./04_Expressions.md#expression-list) **]** +> + + + +> 强制取值表达式语法 +> *强制取值表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **!** +> + + + + +> 可选链式表达式语法 +> *可选链表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **?** +> + +## 语句 {#statements} > 语句语法 -> -> *语句* → [*表达式*](../chapter3/04_Expressions.html#expression) **;** _可选_ -> *语句* → [*声明*](../chapter3/05_Declarations.html#declaration) **;** _可选_ -> *语句* → [*循环语句*](../chapter3/10_Statements.html#loop_statement) **;** _可选_ -> *语句* → [*分支语句*](../chapter3/10_Statements.html#branch_statement) **;** _可选_ -> *语句* → [*标记语句（Labeled Statement）*](../chapter3/10_Statements.html#labeled_statement) -> *语句* → [*控制转移语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_ -> *语句* → [*延迟语句*](TODO) **;** _可选_ - -> *语句* → [*执行语句*](TODO) **;** _可选_ - -> *多条语句（Statements）* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) _可选_ +> +> *语句* → [表达式](./04_Expressions.md#expression) **;**可选 +> +> *语句* → [声明](./06_Declarations.md#declaration) **;**可选 +> +> *语句* → [循环语句](./05_Statements.md#loop_statement) **;**可选 +> +> *语句* → [分支语句](./05_Statements.md#branch_statement) **;**可选 +> +> *语句* → [标签语句](./05_Statements.md#labeled_statement) **;**可选 +> +> *语句* → [控制转移语句](./05_Statements.md#control_transfer_statement) **;**可选 +> +> *语句* → [延迟语句](./05_Statements.md#defer_statement) **;**可选 +> +> *语句* → [执行语句](./05_Statements.md#do_statement) **;**可选 +> +> *语句* → [编译控制语句](./05_Statements.md#compiler_control_statement) +> +> *语句集* → [语句](./05_Statements.md#statement) [语句集](./05_Statements.md#statements)可选 +> > 循环语句语法 -> -> *循环语句* → [*for 语句*](../chapter3/10_Statements.html#for_statement) -> *循环语句* → [*for-in 语句*](../chapter3/10_Statements.html#for_in_statement) -> *循环语句* → [*while 语句*](../chapter3/10_Statements.html#wheetatype 类型 ile_statement) -> *循环语句* → [*repeat-while 语句*](../chapter3/10_Statements.html#do_while_statement) - - - -> For 循环语法 -> -> *for 语句* → **for** [*for 初始条件*](../chapter3/10_Statements.html#for_init) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) -> *for 语句* → **for** **(** [*for 初始条件*](../chapter3/10_Statements.html#for_init) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **)** [*代码块*](../chapter3/05_Declarations.html#code_block) -> *for 初始条件* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration) | [*表达式集*](../chapter3/04_Expressions.html#expression_list) +> +> *循环语句* → [for-in 语句](./05_Statements.md#for_in_statement) +> +> *循环语句* → [while 语句](./05_Statements.md#wheetatype 类型 ile_statement) +> +> *循环语句* → [repeat-while 语句](./05_Statements.md#do_while_statement) +> > For-In 循环语法 -> -> *for-in 语句* → **for case** _可选_ [*模式*](../chapter3/07_Patterns.html#pattern) **in** [*表达式*](../chapter3/04_Expressions.html#expression) [*代码块*](../chapter3/05_Declarations.html#code_block) [*where 从句*](TODO) _可选_ +> +> *for-in 语句* → **for case**可选 [模式](./08_Patterns.md#pattern) **in** [表达式](./04_Expressions.md#expression) [where 子句](./05_Statements.md#where_clause)可选 [代码块](./06_Declarations.md#code_block) +> > While 循环语法 -> -> *while 语句* → **while** [*条件从句*](../chapter3/10_Statements.html#while_condition) [*代码块*](../chapter3/05_Declarations.html#code_block) -> *条件从句* → [*表达式*](TODO) -> *条件从句* → [*表达式*](TODO) *,* [*表达式集*]() -> *条件从句* → [*表达式集*](TODO) -> *条件从句* → [*可用条件（availability-condition*）](TODO) *|* [*表达式集*]() -> *条件集* → [*条件*](TODO) *|* [*条件*](TODO) *,* [*条件集*]() -> *条件* → [*可用条件（availability-condition）*](TODO) *|* [*个例条件（case-condition）*](TODO) *|* [*可选绑定条件（optional-binding-condition）*](TODO) -> *个例条件（case-condition）* → **case** [*模式*](TODO) [*构造器*](TODO) [*where 从句*](TODO)_可选_ -> *可选绑定条件（optional-binding-condition）* → [*可选绑定头（optional-binding-head）*](TODO) [*可选绑定连续集（optional-binding-continuation-list）*](TODO) _可选_ [*where 从句*](TODO) _可选_ -> *可选绑定头（optional-binding-head）* → **let** [*模式 构造器*](TODO) *|* **var** [*模式 构造器*](TODO) -> *可选绑定连续集（optional-binding-contiuation-list）* → [*可选绑定连续（optional-binding-contiuation）*](TODO) *|* [*可选绑定连续（optional-binding-contiuation）*](TODO) *，* [*可选绑定连续集（optional-binding-contiuation-list）*](TODO) -> *可选绑定连续（optional-binding-continuation）* → [*模式 构造器*](TODO) *|* [*可选绑定头（optional-binding-head）*](TODO) +> +> *while 语句* → **while** [条件集](./05_Statements.md#condition_list) [代码块](./06_Declarations.md#code_block) +> +> *条件集* → [条件](./05_Statements.md#condition) | [条件](./05_Statements.md#condition) **,** [条件集](./05_Statements.md#condition_list) +> *条件* → [表达式](./04_Expressions.md#expression) | [可用性条件](./05_Statements.md#availability_condition) | [case 条件](./05_Statements.md#case_condition) | [可选绑定条件](./05_Statements.md#optional_binding_condition) +> +> *case 条件* → **case** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) +> +> *可选绑定条件* → **let** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) | **var** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) +> > Repeat-While 语句语法 -> -*repeat-while-statement* → **repeat** [*代码块*](TODO) **while** [*表达式*](TODO) +> +*repeat-while-statement* → **repeat** [代码块](./06_Declarations.md#code_block) **while** [表达式](./04_Expressions.md#expression) > 分支语句语法 -> -> *分支语句* → [*if 语句*](../chapter3/10_Statements.html#if_statement) -> *分支语句* → [*guard 语句*](TODO) -> *分支语句* → [*switch 语句*](../chapter3/10_Statements.html#switch_statement) +> +> *分支语句* → [if 语句](./05_Statements.md#if_statement) +> +> *分支语句* → [guard 语句](./05_Statements.md#guard_statement) +> +> *分支语句* → [switch 语句](./05_Statements.md#switch_statement) +> > If 语句语法 -> -> *if 语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else 从句（Clause）*](TODO) _可选_ -> *else 从句（Clause）* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if 语句*](../chapter3/10_Statements.html#if_statement) +> +> *if 语句* → **if** [条件集](./05_Statements.md#condition_list) [代码块](./06_Declarations.md#code_block) [else 子句](./05_Statements.md#else_clause)可选 +> +> *else 子句* → **else** [代码块](./06_Declarations.md#code_block) | **else** [if 语句](./05_Statements.md#if_statement) +> > Guard 语句语法 -> -> *guard 语句* → **guard** [*条件从句*](TODO) **else** [*代码块*](TODO) +> +> *guard 语句* → **guard** [条件集](./05_Statements.md#condition_list) **else** [代码块](./06_Declarations.md#code_block) +> > Switch 语句语法 -> -> *switch 语句* → **switch** [*表达式*](../chapter3/04_Expressions.html#expression) **{** [*SwitchCase*](../chapter3/10_Statements.html#switch_cases) _可选_ **}** -> *SwitchCase 集* → [*SwitchCase*](../chapter3/10_Statements.html#switch_case) [*SwitchCase 集*](../chapter3/10_Statements.html#switch_cases) _可选_ -> *SwitchCase* → [*case 标签*](../chapter3/10_Statements.html#case_label) [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) | [*default 标签*](../chapter3/10_Statements.html#default_label) [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) -> *SwitchCase* → [*case 标签*](../chapter3/10_Statements.html#case_label) **;** | [*default 标签*](../chapter3/10_Statements.html#default_label) **;** -> *case 标签* → **case** [*case 项集*](../chapter3/10_Statements.html#case_item_list) **:** -> *case 项集* → [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ | [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ **,** [*case 项集*](../chapter3/10_Statements.html#case_item_list) -> *default 标签* → **default** **:** -> *where 从句* → **where** [*where 表达式*](TODO) -> *where 表达式* → [*表达式*](TODO) +> +> *switch 语句* → **switch** [表达式](./04_Expressions.md#expression) **{** [switch-case集](./05_Statements.md#switch_cases)可选 **}** +> +> *switch-case集* → [switch-case](./05_Statements.md#switch_case) [switch-case集](./05_Statements.md#switch_cases)可选 +> +> *switch-case* → [case 标签](./05_Statements.md#case_label) [语句集](./05_Statements.md#statements) +> +> *switch-case* → [default 标签](./05_Statements.md#default_label) [语句集](./05_Statements.md#statements) +> +> *switch-case* → [条件 switch-case](./05_Statements.md#conditional_switch_case) +> +> *case 标签* → [特性](./07_Attributes.md#attributes)可选 **case** [case 项集](./05_Statements.md#case_item_list) **:** +> +> *case 项集* → [模式](./08_Patterns.md#pattern) [where 子句](./05_Statements.md#where_clause)可选 | [模式](./08_Patterns.md#pattern) [where 子句](./05_Statements.md#guard_clause)可选 **,** [case 项集](./05_Statements.md#case_item_list) +> +> *default 标签* → [特性](./07_Attributes.md#attributes)可选 **default** **:** +> +> *where 子句* → **where** [where 表达式](./05_Statements.md#where_expression) +> +> *where 表达式* → [表达式](./04_Expressions.md#expression) +> +> *条件 switch-case* → [switch if 指令子句](./05_Statements.md#switch_if_directive_clause) [switch elseif 指令子句集](./05_Statements.md#switch_elseif_directive_clauses)可选 [switch else 指令子句](./05_Statements.md#switch_else_directive_clause)可选 [endif 指令](./05_Statements.md#endif_directive) +> +> *switch if 指令子句* → [if 指令](./05_Statements.md#if_directive) [编译条件](./05_Statements.md#compilation_condition) [switch-case集](./05_Statements.md#switch_cases)可选 +> +> *switch elseif 指令子句集* → [elseif 指令子句](./05_Statements.md#else_if_directive_clause) [switch elseif 指令子句集](./05_Statements.md#switch_elseif_directive_clauses)可选 +> +> *switch elseif 指令子句* → [elseif 指令](./05_Statements.md#elseif_directive) [编译条件](./05_Statements.md#compilation_condition) [switch-case集](./05_Statements.md#switch_cases)可选 +> +> *switch else 指令子句* → [else 指令](./05_Statements.md#else_directive) [switch-case集](./05_Statements.md#switch_cases)可选 +> -> 标记语句语法 -> -> *标记语句（Labeled Statement）* → [*语句标签*](../chapter3/10_Statements.html#statement_label) [*循环语句*](../chapter3/10_Statements.html#loop_statement) | [*语句标签*](../chapter3/10_Statements.html#statement_label) [*if 语句*](../chapter3/10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch 语句*](TODY) -> *语句标签* → [*标签名称*](../chapter3/10_Statements.html#label_name) **:** -> *标签名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> 标签语句语法 +> +> *标签语句* → [语句标签](./05_Statements.md#statement_label) [循环语句](./05_Statements.md#loop_statement) +> +> *标签语句* → [语句标签](./05_Statements.md#statement_label) [if 语句](./05_Statements.md#if_statement) +> +> *标签语句* → [语句标签](./05_Statements.md#statement_label) [switch 语句](./05_Statements.md#switch_statement) +> +> *标签语句* → [语句标签](./05_Statements.md#statement_label) [do 语句](./05_Statements.md#do_statement) +> +> *语句标签* → [标签名称](./05_Statements.md#label_name) **:** +> +> *标签名称* → [标识符](./02_Lexical_Structure.md#identifier) +> -> 控制传递语句（Control Transfer Statement）语法 -> -> *控制传递语句* → [*break 语句*](../chapter3/10_Statements.html#break_statement) -> *控制传递语句* → [*continue 语句*](../chapter3/10_Statements.html#continue_statement) -> *控制传递语句* → [*fallthrough 语句*](../chapter3/10_Statements.html#fallthrough_statement) -> *控制传递语句* → [*return 语句*](../chapter3/10_Statements.html#return_statement) -> *控制传递语句* → [*throw 语句*](TODO) +> 控制转移语句语法 +> +> *控制转移语句* → [break 语句](./05_Statements.md#break_statement) +> +> *控制转移语句* → [continue 语句](./05_Statements.md#continue_statement) +> +> *控制转移语句* → [fallthrough 语句](./05_Statements.md#fallthrough_statement) +> +> *控制转移语句* → [return 语句](./05_Statements.md#return_statement) +> +> *控制转移语句* → [throw 语句](./05_Statements.md#throw_statement) +> > Break 语句语法 -> -> *break 语句* → **break** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_ +> +> *break 语句* → **break** [标签名称](./05_Statements.md#label_name)可选 +> > Continue 语句语法 -> -> *continue 语句* → **continue** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_ +> +> *continue 语句* → **continue** [标签名称](./05_Statements.md#label_name)可选 +> > Fallthrough 语句语法 -> +> > *fallthrough 语句* → **fallthrough** +> > Return 语句语法 -> -> *return 语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ - - -> 可用条件（Availability Condition）语法 -> -> *可用条件（availability-condition）* → **#available** **(** [*多可用参数*(availability-arguments)](TODO) **)** -> *多可用参数（availability- arguments）* → [*可用参数（availability-argument）*](TODO)|[*可用参数（availability-argument）*](TODO) , [多可用参数（availability-arguments）](TODO) -> *可用参数（availability- argument）* → [*平台名（platform-name）*](TODO) [*平台版本（platform-version）*](TODO) -> *可用参数（availability- argument）* → * -> -> *平台名* → **iOS** | **iOSApplicationExtension** -> *平台名* → **OSX** | **macOSApplicationExtension** -> *平台名* → **watchOS** -> *平台名* → **tvOS** -> *平台版本* → [*十进制数（decimal-digits）*](TODO) -> *平台版本* → [*十进制数（decimal-digits）*](TODO) . [*十进制数（decimal-digits）*](TODO) -> *平台版本* → [*十进制数（decimal-digits）*](TODO) **.** [*十进制数（decimal-digits）*](TODO) **.** [*十进制数（decimal-digits)*](TODO)) - - -> 抛出语句（Throw Statement）语法 -> -> *抛出语句（throw-statement）* → **throw** [*表达式（expression）*](TODO) - - -> 延迟语句（defer-statement）语法 -> -> *延迟语句（defer-statement）* → **defer** [*代码块*](TODO) - - -> 执行语句（do-statement）语法 -> -> *执行语句（do-statement）* → **do** [*代码块*](TODO) [*catch-clauses*](TODO) _可选_ -> *catch-clauses* → [*catch-clause*](TODO) [*catch-clauses*](TODO) _可选_ -> *catch-clauses* → **catch** [*模式（pattern）*](TODO) _可选_ [*where-clause*](TODO) _可选_ [*代码块（code-block）*](TODO) _可选_ - - -## 泛型参数 - -> 泛型形参从句（Generic Parameter Clause）语法 > -> *泛型参数从句* → **<** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list) [*约束从句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>** -> *泛型参数集* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list) -> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) -> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier) -> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type) -> *约束从句* → **where** [*约束集*](GenericParametersAndArguments.html#requirement_list) -> *约束集* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束集*](GenericParametersAndArguments.html#requirement_list) -> *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement) -> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier) -> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type) -> *同类型约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **==** [*类型*](../chapter3/03_Types.html#type_identifier) +> *return 语句* → **return** [表达式](./04_Expressions.md#expression)可选 +> -> 泛型实参从句语法 -> -> *(泛型参数从句 Generic Argument Clause)* → **<** [*泛型参数集*](GenericParametersAndArguments.html#generic_argument_list) **>** -> *泛型参数集* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数集*](GenericParametersAndArguments.html#generic_argument_list) -> *泛型参数* → [*类型*](../chapter3/03_Types.html#type) +> Throw 语句语法 +> +> *throw 语句* → **throw** [表达式](./04_Expressions.md#expression) +> - -## 声明（Declarations） + + +> Defer 语句语法 +> +> *defer 语句* → **defer** [代码块](./06_Declarations.md#code_block) +> + + +> Do 语句语法 +> +> *do 语句* → **do** [代码块](./06_Declarations.md#code_block) [catch 子句集](./05_Statements.md#catch_clauses)可选 +> +> *catch 子句集* → [catch 子句](./05_Statements.md#catch_clause) [catch 子句集](05_Statements.md#catch_clauses)可选 +> +> *catch 子句* → **catch** [模式](./08_Patterns.md#pattern)可选 [where 子句](./05_Statements.md#where_clause)可选 [代码块](./06_Declarations.md#code_block)可选 +> + + +> 编译控制语句 +> +> *编译控制语句* → [条件编译块](./05_Statements.md#conditional_complation_block) +> +> *编译控制语句* → [行控制语句](./05_Statements.md#line_control_statement) +> +> *编译控制语句* → [诊断语句](./05_Statements.md#diagnostic_statement) +> + + +> 条件编译块语法 +> +> *条件编译块* → [if 指令子句](./05_Statements.md#if_directive_clause) [elseif 指令子句集](./05_Statements.md#elseif_directive_clauses)可选 [else 指令子句](./05_Statements.md#else_directive_clause)可选 [endif 指令](./05_Statements.md#endif_directive) +> +> *if 指令子句* → [if 指令](./05_Statements.md#if_directive) [编译条件](./05_Statements.md#compilation_condition) [语句集](./05_Statements.md#statements)可选 +> +> *elseif 指令子句集* → [elseif 指令子句](./05_Statements.md#else_if_directive_clause) [elseif 指令子句集](./05_Statements.md#elseif_directive_clauses)可选 +> +> *elseif 指令子句* → [elseif 指令](./05_Statements.md#elseif_directive) [编译条件](./05_Statements.md#compilation_condition) [语句集](./05_Statements.md#statements)可选 +> +> *else 指令子句* → [else 指令](./05_Statements.md#else_directive) [语句集](./05_Statements.md#statements)可选 +> +> *if 指令* → **#if** +> +> *elseif 指令* → **#elseif** +> +> *else 指令* → **#else** +> +> *endif 指令* → **#endif** +> +> *编译条件* → [平台条件](./05_Statements.md#platform_condition) +> +> *编译条件* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *编译条件* → [布尔字面量](./02_Lexical_Structure.md#boolean_literal) +> +> *编译条件* → **(** [编译条件](./05_Statements.md#compilation_condition) **)** +> +> *编译条件* → **!** [编译条件](./05_Statements.md#compilation_condition) +> +> *编译条件* → [编译条件](./05_Statements.md#compilation_condition) **&&** [编译条件](./05_Statements.md#compilation_condition) +> +> *编译条件* → [编译条件](./05_Statements.md#compilation_condition) **||** [编译条件](./05_Statements.md#compilation_condition) +> +> *平台条件* → **os** **(** [操作系统](./05_Statements.md#operating_system) **)** +> +> *平台条件* → **arch** **(** [架构](./05_Statements.md#architecture) **)** +> +> *平台条件* → **swift** **(** **>=** [swift 版本](./05_Statements.md#swift_version) **)** | **swift** **(** **<** [swift 版本](./05_Statements.md#swift_version) **)** +> +> *平台条件* → **compiler** **(** **>=** [swift 版本](./05_Statements.md#swift_version) **)** | **compiler** **(** **<** [swift 版本](./05_Statements.md#swift_version) **)** +> +> *平台条件* → **canImport** **(** [模块名](./05_Statements.md#module_name) **)** +> +> *平台条件* → **targetEnvironment** **(** [环境](./05_Statements.md#environment) **)** +> +> *操作系统* → **macOS** | **iOS** | **watchOS** | **tvOS** +> +> *架构* → **i386** | **x86_64** | **arm** | **arm64** +> +> *swift 版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) [swift 版本后缀](./05_Statements.md#swift_version_continuation)可选 +> +> *swift 版本后缀* → **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) [swift 版本集](./05_Statements.md#swift_version_continuation)可选 +> +> *模块名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *环境* → **simulator** +> + + +> 行控制语句语法 +> +> *行控制语句* → **#sourceLocation** **(** **file:** [文件名](./05_Statements.md#file_name) **,** **line:** [行号](./05_Statements.md#line_number) **)** +> +> *行控制语句* → **#sourceLocation** **(** **)** +> +> *行号* → 一个大于 0 的十进制数字 +> +> *文件名* → [静态字符串字面量](./02_Lexical_Structure.md#static_string_literal) +> + + +> 编译期诊断语句语法 +> +> *诊断语句* → **#error** **(** [诊断信息](./05_Statements.md#diagnostic_message) **)** +> +> *诊断语句* → **#warning** **(** [诊断信息](./05_Statements.md#diagnostic_message) **)** +> +> *诊断信息* → [静态字符串字面量](./02_Lexical_Structure.md#static_string_literal) +> + + +> 可用性条件语法 +> +> *可用性条件* → **#available** **(** [可用性参数集](./05_Statements.md#availability_arguments) **)** +> +> *可用性参数集* → [可用性参数](./05_Statements.md#availability_argument) | [可用性参数](./05_Statements.md#availability_argument) , [可用性参数集）](./05_Statements.md#availability_arguments) +> +> *可用性参数* → [平台名](./05_Statements.md#platform_name) [平台版本](./05_Statements.md#platform_version) +> +> *可用性参数* → **\*** +> +> *平台名* → **iOS** | **iOSApplicationExtension** +> +> *平台名* → **macOS** | **macOSApplicationExtension** +> +> *平台名* → **watchOS** +> +> *平台名* → **tvOS** +> +> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) +> +> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) +> +> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) +> + +## 声明 {#declarations} > 声明语法 -> -> *声明* → [*导入声明*](../chapter3/05_Declarations.html#import_declaration) -> *声明* → [*常量声明*](../chapter3/05_Declarations.html#constant_declaration) -> *声明* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration) -> *声明* → [*类型别名声明*](../chapter3/05_Declarations.html#typealias_declaration) -> *声明* → [*函数声明*](../chapter3/05_Declarations.html#function_declaration) -> *声明* → [*枚举声明*](../chapter3/05_Declarations.html#enum_declaration) -> *声明* → [*结构体声明*](../chapter3/05_Declarations.html#struct_declaration) -> *声明* → [*类声明*](../chapter3/05_Declarations.html#class_declaration) -> *声明* → [*协议声明*](../chapter3/05_Declarations.html#protocol_declaration) -> *声明* → [*构造器声明*](../chapter3/05_Declarations.html#initializer_declaration) -> *声明* → [*析构器声明*](../chapter3/05_Declarations.html#deinitializer_declaration) -> *声明* → [*扩展声明*](../chapter3/05_Declarations.html#extension_declaration) -> *声明* → [*下标声明*](../chapter3/05_Declarations.html#subscript_declaration) -> *声明* → [*运算符声明*](../chapter3/05_Declarations.html#operator_declaration) -> *声明（Declarations）集* → [*声明*](../chapter3/05_Declarations.html#declaration) [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ +> +> *声明* → [导入声明](./06_Declarations.md#import_declaration) +> +> *声明* → [常量声明](./06_Declarations.md#constant_declaration) +> +> *声明* → [变量声明](./06_Declarations.md#variable_declaration) +> +> *声明* → [类型别名声明](./06_Declarations.md#typealias_declaration) +> +> *声明* → [函数声明](./06_Declarations.md#function_declaration) +> +> *声明* → [枚举声明](./06_Declarations.md#enum_declaration) +> +> *声明* → [结构体声明](./06_Declarations.md#struct_declaration) +> +> *声明* → [类声明](./06_Declarations.md#class_declaration) +> +> *声明* → [协议声明](./06_Declarations.md#protocol_declaration) +> +> *声明* → [构造器声明](./06_Declarations.md#initializer_declaration) +> +> *声明* → [析构器声明](./06_Declarations.md#deinitializer_declaration) +> +> *声明* → [扩展声明](./06_Declarations.md#extension_declaration) +> +> *声明* → [下标声明](./06_Declarations.md#subscript_declaration) +> +> *声明* → [运算符声明](./06_Declarations.md#operator_declaration) +> +> *声明* → [优先级组声明](./06_Declarations.md#precedence_group_declaration) +> +> *声明集* → [声明](./06_Declarations.md#declaration) [声明集](./06_Declarations.md#declarations)可选 +> -> 顶级（Top Level）声明语法 -> -> *顶级声明* → [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) _可选_ +> 顶级声明语法 +> +> *顶级声明* → [多条语句](./05_Statements.md#statements)可选 +> > 代码块语法 -> -> *代码块* → **{** [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) _可选_ **}** +> +> *代码块* → **{** [多条语句](./05_Statements.md#statements)可选 **}** +> -> 导入（Import）声明语法 -> -> *导入声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **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#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator) +> 导入声明语法 +> +> *导入声明* → [特性](./07_Attributes.md#attributes)可选 **import** [导入类型](./06_Declarations.md#import_kind)可选 [导入路径](./06_Declarations.md#import_path) +> +> *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **let** | **var** | **func** +> +> *导入路径* → [导入路径标识符](./06_Declarations.md#import_path_identifier) | [导入路径标识符](./06_Declarations.md#import_path_identifier) **.** [导入路径](./06_Declarations.md#import_path) +> +> *导入路径标识符* → [标识符](./02_Lexical_Structure.md#identifier) | [运算符](./02_Lexical_Structure.md#operator) +> > 常数声明语法 -> -> *常量声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符（Modifiers）集*](../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) +> +> *常量声明* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_specifiers)可选 **let** [模式构造器集](./06_Declarations.md#pattern_initializer_list) +> +> *模式构造器集* → [模式构造器](./06_Declarations.md#pattern_initializer) | [模式构造器](./06_Declarations.md#pattern_initializer) **,** [模式构造器集](./06_Declarations.md#pattern_initializer_list) +> +> *模式构造器* → [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)可选 +> +> *构造器* → **=** [表达式](./04_Expressions.md#expression) +> > 变量声明语法 -> -> *变量声明* → [*变量声明头（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/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) _可选_ [*声明修改符（Modifers）集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var** -> *变量名称* → [*标识符*](../chapter3/02_Lexical_Structure.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 名称* → **(** [*标识符*](../chapter3/02_Lexical_Structure.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) +> +> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [模式构造器集](./06_Declarations.md#pattern_initializer_list) +> +> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [代码块](./06_Declarations.md#code_block) +> +> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [getter-setter 块](./06_Declarations.md#getter_setter_block) +> +> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> +> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [构造器](./06_Declarations.md#initializer)可选 [willSet-didSet 代码块](./06_Declarations.md#willSet_didSet_block) +> +> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [构造器](./06_Declarations.md#initializer)可选 [willSet-didSet 代码块](./06_Declarations.md#willSet_didSet_block) +> +> *变量声明头* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_specifiers)可选 **var** +> +> *变量名称* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *getter-setter 块* → [代码块](./06_Declarations.md#code_block) +> +> *getter-setter 块* → **{** [getter 子句](./06_Declarations.md#getter_keyword_clause) [setter 子句](./06_Declarations.md#setter_keyword_clause)可选 **}** +> +> *getter-setter 块* → **{** [setter 子句](./06_Declarations.md#setter_keyword_clause) [getter 子句](./06_Declarations.md#getter_keyword_clause) **}** +> +> *getter 子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **get** [代码块](./06_Declarations.md#code_block) +> +> *setter 子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **set** [setter 名称](./06_Declarations.md#setter_name)可选 [代码块](./06_Declarations.md#code_block) +> +> *setter 名称* → **(** [标识符](./02_Lexical_Structure.md#identifier) **)** +> +> *getter-setter 关键字（Keyword）块* → **{** [getter 关键字子句](./06_Declarations.md#getter_keyword_clause) [setter 关键字子句](./06_Declarations.md#setter_keyword_clause)可选 **}** +> +> *getter-setter 关键字（Keyword）块* → **{** [setter 关键字子句](./06_Declarations.md#setter_keyword_clause) [getter 关键字子句](./06_Declarations.md#getter_keyword_clause) **}** +> +> *getter 关键字（Keyword）子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **get** +> +> *setter 关键字（Keyword）子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **set** +> +> *willSet-didSet 代码块* → **{** [willSet 子句](./06_Declarations.md#willSet_clause) [didSet 子句](./06_Declarations.md#didSet_clause)可选 **}** +> +> *willSet-didSet 代码块* → **{** [didSet 子句](./06_Declarations.md#didSet_clause) [willSet 子句](./06_Declarations.md#willSet_clause)可选 **}** +> +> *willSet 子句* → [特性](./07_Attributes.md#attributes)可选 **willSet** [setter 名称](./06_Declarations.md#setter_name)可选 [代码块](./06_Declarations.md#code_block) +> +> *didSet 子句* → [特性](./07_Attributes.md#attributes)可选 +> + **didSet** [setter 名称](./06_Declarations.md#setter_name)可选 [代码块](./06_Declarations.md#code_block) > 类型别名声明语法 -> -> *类型别名声明* → [*类型别名头（Head）*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) -> *类型别名头（Head）* → [*属性*](TODO) _可选_ [*访问级别修改符（access-level-modifier）*](TODO) **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name) -> *类型别名名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type) +> +> *类型别名声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier) **typealias** [类型别名名称](./06_Declarations.md#typealias_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型别名赋值](./06_Declarations.md#typealias_assignment) +> +> *类型别名名称* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *类型别名赋值* → **=** [类型](./03_Types.md#type) +> > 函数声明语法 -> -> *函数声明* → [*函数头*](../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** -> *函数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> *函数签名（Signature）* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** _可选_ [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ +> +> *函数声明* → [函数头](./06_Declarations.md#function_head) [函数名](./06_Declarations.md#function_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [函数签名](./06_Declarations.md#function_signature) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [函数体](./06_Declarations.md#function_body)可选 +> +> *函数头* → [特性](./07_Attributes.md#attributes)可选 [声明描述符集](./06_Declarations.md#declaration_specifiers)可选 **func** +> +> *函数名* → [标识符](./02_Lexical_Structure.md#identifier) | [运算符](./02_Lexical_Structure.md#operator) +> +> *函数签名* → [参数子句](./06_Declarations.md#parameter_clause) **throws**可选 [函数结果](./06_Declarations.md#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) -> *参数从句* → [*参数从句*](../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) -> *外部参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** -> *本地参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** -> *默认参数从句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression) +> *函数签名* → [参数子句](./06_Declarations.md#parameter_clause) **rethrows** [函数结果](./06_Declarations.md#function_result)可选 +> +> *函数结果* → **->** [特性](./07_Attributes.md#attributes)可选 [类型](./03_Types.md#type) +> +> *函数体* → [代码块](./06_Declarations.md#code_block) +> +> *参数子句* → **(** **)** | **(** [参数集](./06_Declarations.md#parameter_list) **)** +> +> *参数集* → [参数](./06_Declarations.md#parameter) | [参数](./06_Declarations.md#parameter) **,** [参数集](./06_Declarations.md#parameter_list) +> +> *参数* → [外部参数名](./06_Declarations.md#parameter_name)可选 [本地参数名](./06_Declarations.md#local_parameter_name) [类型注解](./03_Types.md#type_annotation) [默认参数子句](./06_Declarations.md#default_argument_clause)可选 +> +> *参数* → [外部参数名](./06_Declarations.md#parameter_name)可选 [本地参数名](./06_Declarations.md#local_parameter_name) [类型注解](./03_Types.md#type_annotation) +> +> *参数* → [外部参数名](./06_Declarations.md#parameter_name)可选 [本地参数名](./06_Declarations.md#local_parameter_name) [类型注解](./03_Types.md#type_annotation) **...** +> +> *外部参数名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *本地参数名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *默认参数子句* → **=** [表达式](./04_Expressions.md#expression) +> > 枚举声明语法 -> -> *枚举声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ [*联合式枚举*](../chapter3/05_Declarations.html#union_style_enum) -> *枚举声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ [*原始值式枚举（raw-value-style-enum）*](TODO) -> *联合式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句（type-inheritance-clause）*](TODO) _可选_ **{** [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}** -> *联合样式枚举成员* → [*union-style-enum-member*](../chapter3/05_Declarations.html#union_style_enum_member) [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ -> *联合样式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*联合式（Union Style）的枚举 case 从句*](../chapter3/05_Declarations.html#union_style_enum_case_clause) -> *联合式（Union Style）的枚举 case 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*联合式（Union Style）的枚举 case 集*](../chapter3/05_Declarations.html#union_style_enum_case_list) -> *联合式（Union Style）的枚举 case 集* → [*联合式（Union Style）的 case*](../chapter3/05_Declarations.html#union_style_enum_case) | [*联合式（Union Style）的 case*](../chapter3/05_Declarations.html#union_style_enum_case) **,** [*联合式（Union Style）的枚举 case 集*](../chapter3/05_Declarations.html#union_style_enum_case_list) -> *联合式（Union Style）的枚举 case* → [*枚举的 case 名*](../chapter3/05_Declarations.html#enum_case_name) [*元组类型*](../chapter3/03_Types.html#tuple_type) _可选_ -> *枚举名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *枚举的 case 名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *原始值式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](../chapter3/03_Types.html#type_identifier) **{** [*原始值式枚举成员集*](../chapter3/05_Declarations.html#raw_value_style_enum_members) _可选_ **}** -> *原始值式枚举成员集* → [*原始值式枚举成员*](../chapter3/05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员集*](../chapter3/05_Declarations.html#raw_value_style_enum_members) _可选_ -> *原始值式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*原始值式枚举 case 从句*](../chapter3/05_Declarations.html#raw_value_style_enum_case_clause) -> *原始值式枚举 case 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举 case 集*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list) -> *原始值式枚举 case 集* → [*原始值式枚举 case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举 case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举 case 集*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list) -> *原始值式枚举 case* → [*枚举的 case 名*](../chapter3/05_Declarations.html#enum_case_name) [*原始值赋值*](../chapter3/05_Declarations.html#raw_value_assignment) _可选_ -> *原始值赋值* → **=** [*字面量*](../chapter3/02_Lexical_Structure.html#literal) -> *原始值字面量（raw-value-literal）* → [*数值字面量*](TODO) | [*字符串字面量*](TODO) | [*布尔字面量*](TODO) +> +> *枚举声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 [联合式枚举](./06_Declarations.md#union_style_enum) +> +> *枚举声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 [原始值式枚举](./06_Declarations.md#raw-value-style-enum) +> +> *联合式枚举* → **indirect**可选 **enum** [枚举名](./06_Declarations.md#enum_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type-inheritance-clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 **{** [联合式枚举成员](./06_Declarations.md#union_style_enum_members)可选 **}** +> +> *联合式枚举成员集* → [联合式枚举成员](./06_Declarations.md#union_style_enum_member) [联合样式枚举成员集](./06_Declarations.md#union_style_enum_members)可选 +> +> *联合样式枚举成员* → [声明](./06_Declarations.md#declaration) | [联合式枚举 case 子句](./06_Declarations.md#union_style_enum_case_clause) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> +> *联合式枚举 case 子句* → [特性](./07_Attributes.md#attributes)可选 **indirect**可选 **case** [联合式枚举 case 集](./06_Declarations.md#union_style_enum_case_list) +> +> *联合式枚举 case 集* → [联合式枚举 case](./06_Declarations.md#union_style_enum_case) | [联合式枚举 case](./06_Declarations.md#union_style_enum_case) **,** [联合式枚举 case 集](./06_Declarations.md#union_style_enum_case_list) +> +> *联合式枚举 case* → [枚举的 case 名](./06_Declarations.md#enum_case_name) [元组类型](./03_Types.md#tuple_type)可选 +> +> *枚举名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *枚举的 case 名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *原始值式枚举* → **enum** [枚举名](./06_Declarations.md#enum_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type-inheritance-clause) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 **{** [原始值式枚举成员集](./06_Declarations.md#raw_value_style_enum_members) **}** +> +> *原始值式枚举成员集* → [原始值式枚举成员](./06_Declarations.md#raw_value_style_enum_member) [原始值式枚举成员集](./06_Declarations.md#raw_value_style_enum_members)可选 +> +> *原始值式枚举成员* → [声明](./06_Declarations.md#declaration) | [原始值式枚举 case 子句](./06_Declarations.md#raw_value_style_enum_case_clause) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> +> *原始值式枚举 case 子句* → [特性](./07_Attributes.md#attributes)可选 **case** [原始值式枚举 case 集](./06_Declarations.md#raw_value_style_enum_case_list) +> +> *原始值式枚举 case 集* → [原始值式枚举 case](./06_Declarations.md#raw_value_style_enum_case) | [原始值式枚举 case](./06_Declarations.md#raw_value_style_enum_case) **,** [原始值式枚举 case 集](./06_Declarations.md#raw_value_style_enum_case_list) +> +> *原始值式枚举 case* → [枚举的 case 名](./06_Declarations.md#enum_case_name) [原始值赋值](./06_Declarations.md#raw_value_assignment)可选 +> +> *原始值赋值* → **=** [原始值字面量](./02_Lexical_Structure.md#literal) +> +> *原始值字面量（raw-value-literal）* → [数值字面量](./02_Lexical_Structure.md#literal) | [静态字符串字面量](./02_Lexical_Structure.md#literal) | [布尔字面量](./02_Lexical_Structure.md#literal) +> > 结构体声明语法 -> -> *结构体声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ **struct** [*结构体名称*](../chapter3/05_Declarations.html#struct_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](../chapter3/05_Declarations.html#struct_body) -> *结构体名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *结构体主体* → **{** [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> +> *结构体声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **struct** [结构体名称](./06_Declarations.md#struct_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [结构体主体](./06_Declarations.md#struct_body) +> +> *结构体名称* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *结构体主体* → **{** [结构体成员集](./06_Declarations.md#declarations)可选 **}** +> +> *结构体成员集* → [结构体成员](./06_Declarations.md#declarations) [结构体成员集](./06_Declarations.md#declarations)可选 +> +> *结构体成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> > 类声明语法 -> -> *类声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) **class** [*类名*](../chapter3/05_Declarations.html#class_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类主体*](../chapter3/05_Declarations.html#class_body) -> *类名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *类主体* → **{** [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> +> *类声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **final**可选 **class** [类名](./06_Declarations.md#class_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type_inheritance_clause) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [类主体](./06_Declarations.md#class_body) +> +> *类声明* → [特性](./07_Attributes.md#attributes)可选 **final** [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **class** [类名](./06_Declarations.md#class_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type_inheritance_clause) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [类主体](./06_Declarations.md#class_body) +> +> *类名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *类主体* → **{** [类成员集](./06_Declarations.md#declarations)可选 **}** +> +> *类成员集* → [类成员](./06_Declarations.md#declarations) [类成员集](./06_Declarations.md#declarations)可选 +> +> *类成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> -> 协议（Protocol）声明语法 -> -> *协议声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_[*访问级别修改器（access-level-modifier）*](TODO) **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body) -> *协议名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *协议主体* → **{** [*协议成员声明（Declarations）集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ **}** -> *协议成员声明* → [*协议属性声明*](../chapter3/05_Declarations.html#protocol_property_declaration) -> *协议成员声明* → [*协议方法声明*](../chapter3/05_Declarations.html#protocol_method_declaration) -> *协议成员声明* → [*协议构造器声明*](../chapter3/05_Declarations.html#protocol_initializer_declaration) -> *协议成员声明* → [*协议下标声明*](../chapter3/05_Declarations.html#protocol_subscript_declaration) -> *协议成员声明* → [*协议关联类型声明*](../chapter3/05_Declarations.html#protocol_associated_type_declaration) -> *协议成员声明（Declarations）集* → [*协议成员声明*](../chapter3/05_Declarations.html#protocol_member_declaration) [*协议成员声明（Declarations）集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ +> 协议声明语法 +> +> *协议声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **protocol** [协议名](./06_Declarations.md#protocol_name) [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [协议主体](./06_Declarations.md#protocol_body) +> +> *协议名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *协议主体* → **{** [协议成员集](./06_Declarations.md#protocol_member_declarations)可选 **}** +> +> *协议成员集* → [协议成员](./06_Declarations.md#declarations) [协议成员集](./06_Declarations.md#declarations)可选 +> +> *协议成员* → [协议成员声明](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> +> *协议成员声明* → [协议属性声明](./06_Declarations.md#protocol_property_declaration) +> +> *协议成员声明* → [协议方法声明](./06_Declarations.md#protocol_method_declaration) +> +> *协议成员声明* → [协议构造器声明](./06_Declarations.md#protocol_initializer_declaration) +> +> *协议成员声明* → [协议下标声明](./06_Declarations.md#protocol_subscript_declaration) +> +> *协议成员声明* → [协议关联类型声明](./06_Declarations.md#protocol_associated_type_declaration) +> +> *协议成员声明* → [类型别名声明](./06_Declarations.md#typealias_declaration) +> > 协议属性声明语法 -> -> *协议属性声明* → [*变量声明头（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) +> +> *协议属性声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> > 协议方法声明语法 -> -> *协议方法声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名（Signature）*](../chapter3/05_Declarations.html#function_signature) +> +> *协议方法声明* → [函数头](./06_Declarations.md#function_head) [函数名](./06_Declarations.md#function_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [函数签名](./06_Declarations.md#function_signature) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> > 协议构造器声明语法 -> -> *协议构造器声明* → [*构造器头（Head）*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) +> +> *协议构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **throws**可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> +> *协议构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **rethrows** [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> > 协议下标声明语法 -> -> *协议下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 关键字（Keyword）块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) +> +> *协议下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> > 协议关联类型声明语法 -> -> *协议关联类型声明* → [*类型别名头（Head）*](../chapter3/05_Declarations.html#typealias_head) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) _可选_ +> +> *协议关联类型声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **associatedtype** [类型别名](./06_Declarations.md#typealias_name) [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [类型别名赋值](./06_Declarations.md#typealias_assignment)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> > 构造器声明语法 -> -> *构造器声明* → [*构造器头（Head）*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*构造器主体*](../chapter3/05_Declarations.html#initializer_body) -> *构造器头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init** -> *构造器头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init ?** -> *构造器头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init !** -> *构造器主体* → [*代码块*](../chapter3/05_Declarations.html#code_block) +> +> *构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **throws**可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [构造器主体](./06_Declarations.md#initializer_body) +> +> *构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **rethrows** [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [构造器主体](./06_Declarations.md#initializer_body) +> +> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **init** +> +> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **init ?** +> +> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **init !** +> +> *构造器主体* → [代码块](./06_Declarations.md#code_block) +> > 析构器声明语法 -> -> *析构器声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](../chapter3/05_Declarations.html#code_block) +> +> *析构器声明* → [特性](./07_Attributes.md#attributes)可选 **deinit** [代码块](./06_Declarations.md#code_block) +> -> 扩展（Extension）声明语法 -> -> *扩展声明* → [*访问级别修改器*](TODO) _可选_ **extension** [*类型标识*](../chapter3/03_Types.html#type_identifier) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](../chapter3/05_Declarations.html#extension_body) -> *extension-body* → **{** [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> 扩展声明语法 +> +> *扩展声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **extension** [类型标识](./03_Types.md#type_identifier) [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [扩展主体](./06_Declarations.md#extension_body) +> +> *扩展主体* → **{** [扩展成员集](./06_Declarations.md#declarations)可选 **}** +> +> *扩展成员集* → [扩展成员](./06_Declarations.md#declarations) [扩展成员集](./06_Declarations.md#declarations)可选 +> +> *扩展成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> > 下标声明语法 -> -> *下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*代码块*](../chapter3/05_Declarations.html#code_block) -> *下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 块*](../chapter3/05_Declarations.html#getter_setter_block) -> *下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 关键字（Keyword）块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) -> *下标头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器（declaration-modifiers）*](TODO) _可选_ **subscript** [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) -> *下标结果（Result）* → **->** [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) +> +> *下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [代码块](./06_Declarations.md#code_block) +> +> *下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [getter-setter 块](./06_Declarations.md#getter_setter_block) +> +> *下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> +> *下标头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **subscript** [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) +> +> *下标结果（Result）* → **->** [特性](./07_Attributes.md#attributes)可选 [类型](./03_Types.md#type) +> > 运算符声明语法 -> -> *运算符声明* → [*前置运算符声明*](../chapter3/05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](../chapter3/05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](../chapter3/05_Declarations.html#infix_operator_declaration) -> *前置运算符声明* → **prefix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}** -> *后置运算符声明* → **postfix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}** -> *中置运算符声明* → **infix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** [*中置运算符属性集*](../chapter3/05_Declarations.html#infix_operator_attributes) _可选_ **}** -> *中置运算符属性集* → [*优先级从句*](../chapter3/05_Declarations.html#precedence_clause) _可选_ [*结和性从句*](../chapter3/05_Declarations.html#associativity_clause) _可选_ -> *优先级从句* → **precedence** [*优先级水平*](../chapter3/05_Declarations.html#precedence_level) -> *优先级水平* → 数值 0 到 255，首末项包括在内 -> *结和性从句* → **associativity** [*结和性*](../chapter3/05_Declarations.html#associativity) -> *结和性* → **left** | **right** | **none** +> +> *运算符声明* → [前置运算符声明](./06_Declarations.md#prefix_operator_declaration) | [后置运算符声明](./06_Declarations.md#postfix_operator_declaration) | [中置运算符声明](./06_Declarations.md#infix_operator_declaration) +> +> *前置运算符声明* → **prefix** **operator** [运算符](./02_Lexical_Structure.md#operator) +> +> *后置运算符声明* → **postfix** **operator** [运算符](./02_Lexical_Structure.md#operator) +> +> *中置运算符声明* → **infix** **operator** [运算符](./02_Lexical_Structure.md#operator) [中置运算符特性](./06_Declarations.md#infix_operator_attributes)可选 +> +> *中置运算符特性* → [优先级组名](./06_Declarations.md#precedence_group_name) +> + +> 优先级组声明语法 +> +> *优先级组声明* → **precedencegroup** [优先级组名](./06_Declarations.md#precedence_group_name) **{** [优先级组特性](./06_Declarations.md#precedence_group_attributes)可选 **}** +> +> *优先级组特性* → [优先级组属性](./06_Declarations.md#declarations) [优先级组特性](./06_Declarations.md#declarations)可选 +> +> *优先级组属性* → [优先级组关系](./06_Declarations.md#declarations) +> +> *优先级组属性* → [优先级组赋值](./06_Declarations.md#declarations) +> +> *优先级组属性* → [优先级组结合](./06_Declarations.md#declarations) +> +> *优先级组关系* → **higherThan :** [优先级组名集](./06_Declarations.md#declarations) +> +> *优先级组关系* → **lowerThan :** [优先级组名集](./06_Declarations.md#declarations) +> +> *优先级组赋值* → **assignment :** [布尔字面量](./02_Lexical_Structure.md#string_literal) +> +> *优先级组结合* → **associativity : left** +> +> *优先级组结合* → **associativity : right** +> +> *优先级组结合* → **associativity : none** +> +> *优先级组名集* → [优先级组名](./06_Declarations.md#declarations) | [优先级组名](./06_Declarations.md#declarations) **,** [优先级组名集](./06_Declarations.md#declarations) +> +> *优先级组名* → [标识符](./02_Lexical_Structure.md#identifier) +> -> 声明修改器语法 -> -> *声明修改器* → **类** | **便捷（convenience）** | **动态（dynamic）** | **final** | **中置（infix）** | **lazy** | **可变（mutating）** | **不可变（nonmutating）** | **可选（optional）** | **改写（override）** | **后置** | **前置** | **required** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **弱（weak）** -> *声明修改器* → [*访问级别声明器（access-level-modifier）*](TODO) -> *声明修改集* → [*声明修改器*](TODO) [*声明修改器集*](TODO) _可选_ -> *访问级别修改器* → **内部的** | **内部的（set）** -> *访问级别修改器* → **私有的** | **私有的（set）** -> *访问级别修改器* → **公共的** -| **公共的（set）** -> *访问级别修改器集* →[*访问级别修改器*](TODO) [*访问级别修改器集*](TODO) _可选_ +> 声明修饰符语法 +> +> *声明修饰符* → **class** | **convenience** | **dynamic** | **final** | **infix** | **lazy** | **optional** | **override** | **postfix** | **prefix** | **required** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **weak** +> +> *声明修饰符* → [访问级别修饰符](./07_Attributes.md#access-level-modifier) +> +> *声明修饰符* → [可变性修饰符](./07_Attributes.md#mutation-modifier) +> +> *声明修饰符集* → [声明修饰符](./06_Declarations.md#declaration_modifier) [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 +> +> *访问级别修饰符* → **private** | **private(set)** +> +> *访问级别修饰符* → **fileprivate** | **fileprivate(set)** +> +> *访问级别修饰符* → **internal** | **internal(set)** +> +> *访问级别修饰符* → **public** | **public(set)** +> +> *访问级别修饰符* → **open** | **open(set)** +> +> *可变性修饰符* → **mutating** | **nonmutating** +> - -## 模式 +## 属性 {#attributes} -> 模式（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 Bindingon ) _可选_ -> *模式* → [*值绑定模式*](../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) -> *模式* → [*可选模式*](TODO) -> *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern) -> *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern) +> 属性语法 +> +> *属性* → **@** [属性名](./07_Attributes.md#attribute_name) [属性参数子句](./07_Attributes.md#attribute_argument_clause)可选 +> +> *属性名* → [标识符](./02_Lexical_Structure.md#identifier) +> +> *属性参数子句* → **{** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **}** +> +> *属性（Attributes）集* → [属性](./07_Attributes.md#attribute) [特性](./07_Attributes.md#attributes)可选 +> +> *平衡令牌集* → [平衡令牌](./07_Attributes.md#balanced_token) [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 +> +> *平衡令牌* → **(** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **)** +> +> *平衡令牌* → **[** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **]** +> +> *平衡令牌* → **{** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **}** +> +> *平衡令牌* → 任意标识符、关键字、字面量或运算符 +> +> *平衡令牌* → 除 **(** 、**)**、**[**、**]**、**{**、**}** 外的任意标点符号 +> +> + +## 模式 {#patterns} + +> 模式语法 +> +> *模式* → [通配符模式](./08_Patterns.md#wildcard_pattern) [类型注解](./03_Types.md#type_annotation)可选 +> +> *模式* → [标识符模式](./08_Patterns.md#identifier_pattern) [类型注解](./03_Types.md#type_annotati Value Bindingon )可选 +> +> *模式* → [值绑定模式](./08_Patterns.md#value_binding_pattern) +> +> *模式* → [元组模式](./08_Patterns.md#tuple_pattern) [类型注解](./03_Types.md#type_annotation)可选 +> +> *模式* → [枚举 case 模式](./08_Patterns.md#enum_case_pattern) +> +> *模式* → [可选模式](./08_Patterns.md#optional_pattern) +> +> *模式* → [类型转换模式](./08_Patterns.md#type_casting_pattern) +> +> *模式* → [表达式模式](./08_Patterns.md#expression_pattern) +> > 通配符模式语法 -> +> > *通配符模式* → **_** +> > 标识符模式语法 -> -> *标识符模式* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> +> *标识符模式* → [标识符](./02_Lexical_Structure.md#identifier) +> -> 值绑定（Value Binding）模式语法 -> -> *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../chapter3/07_Patterns.html#pattern) +> 值绑定模式语法 +> +> *值绑定模式* → **var** [模式](./08_Patterns.md#pattern) | **let** [模式](./08_Patterns.md#pattern) +> > 元组模式语法 -> -> *元组模式* → **(** [*元组模式元素集*](../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) +> +> *元组模式* → **(** [元组模式元素集](./08_Patterns.md#tuple_pattern_element_list)可选 **)** +> +> *元组模式元素集* → [元组模式元素](./08_Patterns.md#tuple_pattern_element) | [元组模式元素](./08_Patterns.md#tuple_pattern_element) **,** [元组模式元素集](./08_Patterns.md#tuple_pattern_element_list) +> +> *元组模式元素* → [模式](./08_Patterns.md#pattern) | [标识符](./02_Lexical_Structure.md#identifier) **:** [模式](./08_Patterns.md#pattern) +> -> 枚举用例模式语法 -> -> *enum-case-pattern* → [*类型标识*](../chapter3/03_Types.html#type_identifier) _可选_ **.** [*枚举的 case 名*](../chapter3/05_Declarations.html#enum_case_name) [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) _可选_ +> 枚举 case 模式语法 +> +> *enum-case-pattern* → [类型标识](./03_Types.md#type_identifier)可选 **.** [枚举 case 名](./06_Declarations.md#enum_case_name) [元组模式](./08_Patterns.md#tuple_pattern)可选 +> > 可选模式语法 -> -> *可选模式* → [*识别符模式*](TODO) **?** +> +> *可选模式* → [标识符模式](./02_Lexical_Structure.md#identifier) **?** +> > 类型转换模式语法 -> -> *类型转换模式（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 模式](./08_Patterns.md#is_pattern) | [as 模式](./08_Patterns.md#as_pattern) +> +> *is 模式* → **is** [类型](./03_Types.md#type) +> +> *as 模式* → [模式](./08_Patterns.md#pattern) **as** [类型](./03_Types.md#type) +> > 表达式模式语法 -> -> *表达式模式* → [*表达式*](../chapter3/04_Expressions.html#expression) - - -## 属性 - -> 属性语法 -> -> *属性* → **@** [*属性名*](../chapter3/06_Attributes.html#attribute_name) [*属性参数从句*](../chapter3/06_Attributes.html#attribute_argument_clause) _可选_ -> *属性名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *属性参数从句* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** -> *属性（Attributes）集* → [*属性*](../chapter3/06_Attributes.html#attribute) [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ -> *平衡令牌集* → [*平衡令牌*](../chapter3/06_Attributes.html#balanced_token) [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ -> *平衡令牌* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** -> *平衡令牌* → **[** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **]** -> *平衡令牌* → **{** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **}** -> *平衡令牌* → **任意标识符、关键字、字面量或运算符** -> *平衡令牌* → **任意标点除了(、)、[、]、{ 或 }** - - -## 表达式 - -> 表达式语法 -> -> *表达式* → [*try-operator*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) [*二元表达式集*](../chapter3/04_Expressions.html#binary_expressions) _可选_ -> *表达式集* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*表达式*](../chapter3/04_Expressions.html#expression) **,** [*表达式集*](../chapter3/04_Expressions.html#expression_list) - - - -> 前置表达式语法 -> -> *前置表达式* → [*前置运算符*](../chapter3/02_Lexical_Structure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) -> *前置表达式* → [*写入写出（in-out）表达式*](../chapter3/04_Expressions.html#in_out_expression) -> *写入写出（in-out）表达式* → **&** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) - - -> try 表达式语法 -> -> *try-operator* → **try** | **try !** - - - -> 二元表达式语法 -> -> *二元表达式* → [*二元运算符*](../chapter3/02_Lexical_Structure.html#binary_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*赋值运算符*](../chapter3/04_Expressions.html#assignment_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*条件运算符*](../chapter3/04_Expressions.html#conditional_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*类型转换运算符*](../chapter3/04_Expressions.html#type_casting_operator) -> *二元表达式集* → [*二元表达式*](../chapter3/04_Expressions.html#binary_expression) [*二元表达式集*](../chapter3/04_Expressions.html#binary_expressions) _可选_ - - - -> 赋值运算符语法 -> -> *赋值运算符* → **=** - - - -> 三元条件运算符语法 -> -> *三元条件运算符* → **?** [*表达式*](../chapter3/04_Expressions.html#expression) **:** - - - -> 类型转换运算符语法 -> -> *类型转换运算符* → **is** [*类型*](../chapter3/03_Types.html#type) -> *类型转换运算符* → **as** [*类型*](../chapter3/03_Types.html#type) -> *类型转换运算符* → **as ?** [*类型*](../chapter3/03_Types.html#type) -> *类型转换运算符* → **as !** [*类型*](../chapter3/03_Types.html#type) - - - -> 主表达式语法 -> -> *主表达式* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ -> *主表达式* → [*字面量表达式*](../chapter3/04_Expressions.html#literal_expression) -> *主表达式* → [*self 表达式*](../chapter3/04_Expressions.html#self_expression) -> *主表达式* → [*超类表达式*](../chapter3/04_Expressions.html#superclass_expression) -> *主表达式* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression) -> *主表达式* → [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) -> *主表达式* → [*隐式成员表达式*](../chapter3/04_Expressions.html#implicit_member_expression) -> *主表达式* → [*通配符表达式*](../chapter3/04_Expressions.html#wildcard_expression) - - - -> 字面量表达式语法 -> -> *字面量表达式* → [*字面量*](../chapter3/02_Lexical_Structure.html#literal) -> *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal) -> *字面量表达式* → **__FILE__** | **__LINE__** | **__COLUMN__** | **__FUNCTION__** -> *数组字面量* → **[** [*数组字面量项集*](../chapter3/04_Expressions.html#array_literal_items) _可选_ **]** -> *数组字面量项集* → [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** [*数组字面量项集*](../chapter3/04_Expressions.html#array_literal_items) -> *数组字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression) -> *字典字面量* → **[** [*字典字面量项集*](../chapter3/04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]** -> *字典字面量项集* → [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项集*](../chapter3/04_Expressions.html#dictionary_literal_items) -> *字典字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression) **:** [*表达式*](../chapter3/04_Expressions.html#expression) - - - -> Self 表达式语法 -> -> *self 表达式* → **self** -> *self 表达式* → **self** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *self 表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** -> *self 表达式* → **self** **.** **init** - - - -> 超类表达式语法 -> -> *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression) -> *超类方法表达式* → **super** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** -> *超类构造器表达式* → **super** **.** **init** - - - -> 闭包表达式语法 -> -> *闭包表达式* → **{** [*闭包签名（Signational）*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) **}** -> *闭包签名（Signational）* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名（Signational）* → [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名（Signational）* → [*捕获（Capature）集*](../chapter3/04_Expressions.html#capture_list) [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名（Signational）* → [*捕获（Capature）集*](../chapter3/04_Expressions.html#capture_list) [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名（Signational）* → [*捕获（Capature）集*](../chapter3/04_Expressions.html#capture_list) **in** -> *捕获（Capature）集* → **[** [*捕获（Capature）说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]** -> *捕获（Capature）说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** - - - -> 隐式成员表达式语法 -> -> *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) - - - -> 圆括号表达式（Parenthesized Expression）语法 -> -> *圆括号表达式* → **(** [*表达式元素集*](../chapter3/04_Expressions.html#expression_element_list) _可选_ **)** -> *表达式元素集* → [*表达式元素*](../chapter3/04_Expressions.html#expression_element) | [*表达式元素*](../chapter3/04_Expressions.html#expression_element) **,** [*表达式元素集*](../chapter3/04_Expressions.html#expression_element_list) -> *表达式元素* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **:** [*表达式*](../chapter3/04_Expressions.html#expression) - - - -> 通配符表达式语法 -> -> *通配符表达式* → **_** - - - -> 后置表达式语法 -> -> *后置表达式* → [*主表达式*](../chapter3/04_Expressions.html#primary_expression) -> *后置表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*后置运算符*](../chapter3/02_Lexical_Structure.html#postfix_operator) -> *后置表达式* → [*函数调用表达式*](../chapter3/04_Expressions.html#function_call_expression) -> *后置表达式* → [*构造器表达式*](../chapter3/04_Expressions.html#initializer_expression) -> *后置表达式* → [*显示成员表达式*](../chapter3/04_Expressions.html#explicit_member_expression) -> *后置表达式* → [*后置 self 表达式*](../chapter3/04_Expressions.html#postfix_self_expression) -> *后置表达式* → [*动态类型表达式*](../chapter3/04_Expressions.html#dynamic_type_expression) -> *后置表达式* → [*下标表达式*](../chapter3/04_Expressions.html#subscript_expression) -> *后置表达式* → [*强制取值（Forced Value）表达式*](../chapter3/04_Expressions.html#forced_value_expression) -> *后置表达式* → [*可选链（Optional Chaining）表达式*](../chapter3/04_Expressions.html#optional_chaining_expression) - - - -> 函数调用表达式语法 -> -> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) -> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包（Trailing Closure）*](../chapter3/04_Expressions.html#trailing_closure) -> *后置闭包（Trailing Closure）* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression) - - - -> 构造器表达式语法 -> -> *构造器表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init** - - - -> 显式成员表达式语法 -> -> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) -> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ - - - -> 后置 Self 表达式语法 -> -> *后置 self 表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self** - - - -> 动态类型表达式语法 -> -> *动态类型表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType** - - - -> 附属脚本表达式语法 -> -> *附属脚本表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式集*](../chapter3/04_Expressions.html#expression_list) **]** - - - -> 强制取值（Forced Value）语法 -> -> *强制取值（Forced Value）表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!** - - - -> 可选链表达式语法 -> -> *可选链表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **?** - - -## 词法结构 - -> 标识符语法 -> -> *标识符* → [*标识符头（Head）*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ -> *标识符* → [*标识符头（Head）*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ -> *标识符* → [*隐式参数名*](../chapter3/02_Lexical_Structure.html#implicit_parameter_name) -> *标识符集* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **,** [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) -> *标识符头（Head）* → Upper- or lowercase letter A through Z -> *标识符头（Head）* → _ -> *标识符头（Head）* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA -> *标识符头（Head）* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF -> *标识符头（Head）* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF -> *标识符头（Head）* → U+1E00–U+1FFF -> *标识符头（Head）* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F -> *标识符头（Head）* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793 -> *标识符头（Head）* → U+2C00–U+2DFF or U+2E80–U+2FFF -> *标识符头（Head）* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF -> *标识符头（Head）* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44 -> *标识符头（Head）* → U+FE47–U+FFFD -> *标识符头（Head）* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD -> *标识符头（Head）* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD -> *标识符头（Head）* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD -> *标识符头（Head）* → U+D0000–U+DFFFD or U+E0000–U+EFFFD -> *标识符字符* → 数值 0 到 9 -> *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F -> *标识符字符* → [*标识符头（Head）*](../chapter3/02_Lexical_Structure.html#identifier_head) -> *标识符字符集* → [*标识符字符*](../chapter3/02_Lexical_Structure.html#identifier_character) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ -> *隐式参数名* → **$** [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits) - - - -> 字面量语法 -> -> *字面量* → [*数值型字面量*](../chapter3/02_Lexical_Structure.html#integer_literal) | [*字符串字面量*](../chapter3/02_Lexical_Structure.html#floating_point_literal) | [*布尔字面量*](../chapter3/02_Lexical_Structure.html#string_literal) | [*空字面量*](TODO) -> *数值型字面量* → **-** _可选_ [*整形字面量*](TODO) | **-** _可选_ [*浮点型字面量*](TODO) -> *布尔字面量* → **true** | **false** -> *空字面量* → **nil** - - - -> 整型字面量语法 -> -> *整型字面量* → [*二进制字面量*](../chapter3/02_Lexical_Structure.html#binary_literal) -> *整型字面量* → [*八进制字面量*](../chapter3/02_Lexical_Structure.html#octal_literal) -> *整型字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) -> *整型字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) -> *二进制字面量* → **0b** [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_ -> *二进制数字* → 数值 0 到 1 -> *二进制字面量字符* → [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) | **_** -> *二进制字面量字符集* → [*二进制字面量字符*](../chapter3/02_Lexical_Structure.html#binary_literal_character) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_ -> *八进制字面量* → **0o** [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_ -> *八进字数字* → 数值 0 到 7 -> *八进制字符* → [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) | **_** -> *八进制字符集* → [*八进制字符*](../chapter3/02_Lexical_Structure.html#octal_literal_character) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_ -> *十进制字面量* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_ -> *十进制数字* → 数值 0 到 9 -> *十进制数字集* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits) _可选_ -> *十进制字面量字符* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) | **_** -> *十进制字面量字符集* → [*十进制字面量字符*](../chapter3/02_Lexical_Structure.html#decimal_literal_character) [*十进制字面量字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_ -> *十六进制字面量* → **0x** [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_ -> *十六进制数字* → 数值 0 到 9, a through f, or A through F -> *十六进制字符* → [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) | **_** -> *十六进制字面量字符集* → [*十六进制字符*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_character) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_ - - - -> 浮点型字面量语法 -> -> *浮点数字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) [*十进制分数*](../chapter3/02_Lexical_Structure.html#decimal_fraction) _可选_ [*十进制指数*](../chapter3/02_Lexical_Structure.html#decimal_exponent) _可选_ -> *浮点数字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) [*十六进制分数*](../chapter3/02_Lexical_Structure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](../chapter3/02_Lexical_Structure.html#hexadecimal_exponent) -> *十进制分数* → **.** [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) -> *十进制指数* → [*浮点数 e*](../chapter3/02_Lexical_Structure.html#floating_point_e) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) -> *十六进制分数* → **.** [*十六进制数*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) - [*十六进制字面量字符集*](TODO)_可选_ -> *十六进制指数* → [*浮点数 p*](../chapter3/02_Lexical_Structure.html#floating_point_p) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) -> *浮点数 e* → **e** | **E** -> *浮点数 p* → **p** | **P** -> *正负号* → **+** | **-** - - - -> 字符串型字面量语法 -> -> *字符串字面量* → **"** [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) **"** -> *引用文本* → [*引用文本条目*](../chapter3/02_Lexical_Structure.html#quoted_text_item) [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) _可选_ -> *引用文本条目* → [*转义字符*](../chapter3/02_Lexical_Structure.html#escaped_character) -> *引用文本条目* → **(** [*表达式*](../chapter3/04_Expressions.html#expression) **)** -> *引用文本条目* → 除了", \, U+000A, or U+000D 的所有 Unicode 的字符 -> *转义字符* → **/0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'** -> *转义字符* → **\u** **{** [*十六进制标量数字集*](TODO) **}** -> *unicode 标量数字集* → Between one and eight hexadecimal digits - - - -> 运算符语法语法 -> -> *运算符* → [*运算符头*](../chapter3/02_Lexical_Structure.html#operator_character) [*运算符字符集*](../chapter3/02_Lexical_Structure.html#operator) _可选_ -> *运算符* → [*点运算符头*](TODO) [*点运算符字符集*](TODO) _可选_ -> *运算符字符* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **?** -> *运算符头* → U+00A1–U+00A7 -> *运算符头* → U+00A9 or U+00AB -> *运算符头* → U+00AC or U+00AE -> *运算符头* → U+00B0–U+00B1, U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7 -> *运算符头* → U+2016–U+2017 or U+2020–U+2027 -> *运算符头* → U+2030–U+203E -> *运算符头* → U+2041–U+2053 -> *运算符头* → U+2055–U+205E -> *运算符头* → U+2190–U+23FF -> *运算符头* → U+2500–U+2775 -> *运算符头* → U+2794–U+2BFF -> *运算符头* → U+2E00–U+2E7F -> *运算符头* → U+3001–U+3003 -> *运算符头* → U+3008–U+3030 -> *运算符字符* → [*运算符头*](TODO) -> *运算符字符* → U+0300–U+036F -> *运算符字符* → U+1DC0–U+1DFF -> *运算符字符* → U+20D0–U+20FF -> *运算符字符* → U+FE00–U+FE0F -> *运算符字符* → U+FE20–U+FE2F -> *运算符字符* → U+E0100–U+E01EF -> *运算符字符集* → [*运算符字符*](TODO) [*运算符字符集*](TODO)_可选_ -> *点运算符头* → **..** -> *点运算符字符* → **.** | [*运算符字符*](TODO) -> *点运算符字符集* → [*点运算符字符*](TODO) [*点运算符字符集*](TODO) _可选_ -> *二元运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> *前置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> *后置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) - - -## 类型 - -> 类型语法 -> -> *类型* → [*数组类型*](../chapter3/03_Types.html#array_type) | [*字典类型*](TODO) | [*函数类型*](../chapter3/03_Types.html#function_type) | [*类型标识符*](../chapter3/03_Types.html#type_identifier) | [*元组类型*](../chapter3/03_Types.html#tuple_type) | [*可选类型*](../chapter3/03_Types.html#optional_type) | [*隐式解析可选类型*](../chapter3/03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type) | [*元型类型*](../chapter3/03_Types.html#metatype_type) - - - -> 类型注解语法 -> -> *类型注解* → **:** [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) - - - -> 类型标识语法 -> -> *类型标识* → [*类型名称*](../chapter3/03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](../chapter3/03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识符*](../chapter3/03_Types.html#type_identifier) -> *类型名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) - - - -> 元组类型语法 -> -> *元组类型* → **(** [*元组类型主体*](../chapter3/03_Types.html#tuple_type_body) _可选_ **)** -> *元组类型主体* → [*元组类型的元素集*](../chapter3/03_Types.html#tuple_type_element_list) **...** _可选_ -> *元组类型的元素集* → [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) | [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) **,** [*元组类型的元素集*](../chapter3/03_Types.html#tuple_type_element_list) -> *元组类型的元素* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](../chapter3/03_Types.html#type) | **inout** _可选_ [*元素名*](../chapter3/03_Types.html#element_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) -> *元素名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) - - - -> 函数类型语法 -> -> *函数类型* → [*类型*](../chapter3/03_Types.html#type) **throws** _可选_ **->** [*类型*](../chapter3/03_Types.html#type) -> *函数类型* → [*类型*](TODO) **rethrows** **->** [*类型*](TODO) - - - -> 数组类型语法 -> -> *数组类型* → **[** [*类型*](../chapter3/03_Types.html#array_type) **]** - - -> 字典类型语法 -> -> *字典类型* → **[** [*类型 **:** 类型*](TODO) **]** - - - -> 可选类型语法 -> -> *可选类型* → [*类型*](../chapter3/03_Types.html#type) **?** - - - -> 隐式解析可选类型（Implicitly Unwrapped Optional Type）语法 -> -> *隐式解析可选类型* → [*类型*](../chapter3/03_Types.html#type) **!** - - - -> 协议合成类型语法 -> -> *协议合成类型* → **protocol** **<** [*协议标识符集*](../chapter3/03_Types.html#protocol_identifier_list) _可选_ **>** -> *协议标识符集* → [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) | [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) **,** [*协议标识符集*](../chapter3/03_Types.html#protocol_identifier_list) -> *协议标识符* → [*类型标识符*](../chapter3/03_Types.html#type_identifier) - - - -> 元（Metatype）类型语法 -> -> *元类型* → [*类型*](../chapter3/03_Types.html#type) **.** **Type** | [*类型*](../chapter3/03_Types.html#type) **.** **Protocol** - - - -> 类型继承从句语法 -> -> *类型继承从句* → **:** [*类条件（class-requirement）)*](TODO) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) -> *类型继承从句* → **:** [*类条件（class-requirement）)*](TODO) -> *类型继承从句* → **:** [*类型继承集*](TODO) -> *类型继承集* → [*类型标识符*](../chapter3/03_Types.html#type_identifier) | [*类型标识符*](../chapter3/03_Types.html#type_identifier) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) -> *类条件* → **class** +> +> *表达式模式* → [表达式](./04_Expressions.md#expression) +> + +## 泛型参数 {#generic-parameters-and-arguments} + +> 泛型形参子句语法 +> +> +> *泛型参数子句* → **<** [泛型参数集](./09_Generic_Parameters_and_Arguments.md#generic_parameter_list) **>** +> +> *泛型参数集* → [泛型参数](./09_Generic_Parameters_and_Arguments.md#generic_parameter) | [泛形参数](./09_Generic_Parameters_and_Arguments.md#generic_parameter) **,** [泛型参数集](./09_Generic_Parameters_and_Arguments.md#generic_parameter_list) +> +> *泛形参数* → [类型名称](./03_Types.md#type_name) +> +> *泛形参数* → [类型名称](./03_Types.md#type_name) **:** [类型标识](./03_Types.md#type_identifier) +> +> *泛形参数* → [类型名称](./03_Types.md#type_name) **:** [协议合成类型](./03_Types.md#protocol_composition_type) +> +> *泛型 where 子句* → **where** [约束集](./09_Generic_Parameters_and_Arguments.md#requirement_list) +> +> *约束集* → [约束](./09_Generic_Parameters_and_Arguments.md#requirement) | [约束](./09_Generic_Parameters_and_Arguments.md#requirement) **,** [约束集](./09_Generic_Parameters_and_Arguments.md#requirement_list) +> +> *约束* → [一致性约束](./09_Generic_Parameters_and_Arguments.md#conformance_requirement) | [同类型约束](./09_Generic_Parameters_and_Arguments.md#same_type_requirement) +> +> *一致性约束* → [类型标识](./03_Types.md#type_identifier) **:** [类型标识](./03_Types.md#type_identifier) +> +> *一致性约束* → [类型标识](./03_Types.md#type_identifier) **:** [协议合成类型](./03_Types.md#protocol_composition_type) +> +> *同类型约束* → [类型标识](./03_Types.md#type_identifier) **==** [类型](./03_Types.md#type_identifier) +> +> 泛型实参子句语法 +> +> *泛型实参子句* → **<** [泛型实参集](./09_Generic_Parameters_and_Arguments.md#generic-argument-list) **>** +> +> *泛型实参集* → [泛型实参](./09_Generic_Parameters_and_Arguments.md#generic_argument) | [泛形实参](./09_Generic_Parameters_and_Arguments.md#generic_argument) **,** [泛型实参集](./09_Generic_Parameters_and_Arguments.md#generic-argument-list) +> +> *泛形实参* → [类型](./03_Types.md#type) \ No newline at end of file diff --git a/source/chapter4/02_Type_Custom.md b/source/chapter4/02_Type_Custom.md index 9ae1c210..dc1888c7 100644 --- a/source/chapter4/02_Type_Custom.md +++ b/source/chapter4/02_Type_Custom.md @@ -15,8 +15,7 @@ 小伙伴们，Swift 中的 Bool 类型有着非常重要的语法功能，并支撑起了整个 Swift 体系中的逻辑判断体系，经过老码的研究和学习， Bool 类型本身其实是对基础 Boolean 类型封装，小伙伴们可能咬着手指头问老码，怎么一会 Bool 类型，一会 Boolean 类型，其区别在于，前者是基于枚举的组合类型，而后者则是基本类型，只有两种 true 和 false。 - -####自定义原型 +####自定义原型 {#prefix-expressions} 接下老码根据 Bool 的思想来创建一个 OCBool 类型，来让小伙伴们了解一下 Swift 中到底是怎么玩儿的。 来我们先看一下 OCBool 的定义。 @@ -35,8 +34,7 @@ case ocFalse - 代码中第2行和第3行，可以合并到一行写，如苹果官方 Blog 所写的一样 - 代码中命名需要注意：OCBool 是类型名，所以首字母必须大写，而 case 中的 ocTrue 和 ocFalse 是小类型则需要首字母小写。 - -####实现默认值 +####实现默认值 {#imp-default} 行，我们给了一个漂亮的定义，不过按照传统语言的经验，Bool 值默认情况下是假， 所以我们的 OCBool 也应该如此，我们使用类型扩展技术增加这个默认特性： @@ -61,8 +59,7 @@ var result:OCBool = OCBool() var result1:OCBool = .ocTrue ``` - -####支持基本布尔型初始化 +####支持基本布尔型初始化 {#init-by-bool} 正如上述代码所述，我们只能通过类型或者枚举项目赋值，这是组合类型的用法，但是编码的日子里，我们总是希望和 true，false 直接打交道，也就是说，我们希望这么做， 代码示例如下： @@ -113,8 +110,7 @@ protocol BooleanLiteralConvertible { - 这个定义中有个类方法 convertFromBooleanLiteral，它的参数为 BooleanLiteralType 类型，也就是我传入的 Bool 类型， 且返回值为实现这个协议的类型本身，在我们的 OCBool 类型中，其返回值就是 OCBool 本身。经过这个定义，我们可以直接对 OCBool 类型直接进行布尔字面量初始化了。 - -####支持 Bool 类型判断 +####支持 Bool 类型判断 {#condition-by-bool} 小伙伴们不安分， 肯定想着我怎么用它实现逻辑判断，所以如果你这么写， @@ -188,9 +184,7 @@ Program ended with exit code: 0 - 如果小伙伴们现在用的是 Beta 版的 Xcode，注意苹果官方 Blog 中，在代码第17行如果在 Xcode Beta4下是错误的，这里的协议是，LogicValue 而不是 BooleanVue，所以记得看错误提示才是好习惯。 - 注意代码第34行，完美支持 if 判断，且输出结果为“老码请你吃火锅”，老码也是说说而已，请不要当真。 - - -####支持兼容各们各派的类型 +####支持兼容各们各派的类型 {#support-all-type} 小伙伴们，江湖风险，门派众多，老码有自己的 OCBool 类型，可能嵩山少林有自己的 SSBool 类型，甚至连郭美美都可能有自己的 MMBool 类型，所以 OCBool 必须能够识别这些类型，这些各门各派的类型，只要支持 LogicValue 协议，就应该可以被识别，看老码怎么做， @@ -232,8 +226,7 @@ Program ended with exit code: 0 - 代码中第2行：“_”下横杠的用法，这是一个功能强大的小强，在此的目的是屏蔽外部参数名，所以小伙伴们可以直接：var ocResult:OCBool = OCBool(mmResult)而不是：var ocResult:OCBool = OCBool(v: mmResult)，小伙伴们惊呆了！这个 init 函数中本来就没有外部参数名啊，还记得老码在书里说过没，Swift 的初始化函数会默认使用内部参数名，作为外部参数名。 - -####完善 OCBool 的布尔基因体系： +####完善 OCBool 的布尔基因体系： {#make-up-type} 小伙伴们，bool 类型的价值就是在于各种判断，诸如==，!=, &，|,^,!，以及各种组合逻辑运算，我们 OCBool 也要具备这些功能，否则就会基因缺陷，且看老码如何实现： diff --git a/source/chapter4/05_Value_and_Reference_Types.md b/source/chapter4/05_Value_and_Reference_Types.md index 25d5c473..df24e210 100644 --- a/source/chapter4/05_Value_and_Reference_Types.md +++ b/source/chapter4/05_Value_and_Reference_Types.md @@ -17,8 +17,7 @@ 在这篇博文里面，我们会介绍两种类型各自的优点，以及应该怎么选择使用。 - -#### 值类型与引用类型的区别 +#### 值类型与引用类型的区别 {#difference-two} 值类型和引用类型最基本的分别在复制之后的结果。当一个值类型被复制的时候，相当于创造了一个完全独立的实例，这个实例保有属于自己的独有数据，数据不会受到其他实例的数据变化影响： @@ -44,8 +43,7 @@ println("\(x.data), \(y.data)") // 输出结果 "42, 42" ``` - -#### Mutation（修改）在安全中扮演的角色 +#### Mutation（修改）在安全中扮演的角色 {#act-in=mutation} 值类型较引用类型来说，会让你更容易在大量代码中理清状况。如果你总是得到一个独立的拷贝出来的实例，你就可以放心它不会被你 app 里面的其他部分代码默默地修改。这在多线程的环境里面是尤为重要的，因为另外一个线程可能会在暗地里修改你的数据。因此可能会造成严重的程序错误，这在调试过程中非常难以排除。 @@ -53,8 +51,7 @@ 你可能在想，有的时候我可能也需要一个完全不变的类。这样使用 `Cocoa NSObject` 对象的时候会比较容易，又可以保留值语义的好处。在今天，你可以通过只使用不可变的存储属性，和避开任何可以修改状态的 API，用 Swift 写出一个不可变类 `（immutable class）`。实际上，很多基本的 Cocoa 类，例如 `NSURL`，都是设计成不可变类的。然而，Swift 语言目前只强制 `struct` 和 `enum` 这种值类型的不可变性，对类这种引用类型则没有。（例如还不支持强制将子类的限制为不可变类） - -#### 如何选择类型？ +#### 如何选择类型？ {#how-to-choose} 所以当我们想要建立一个新的类型的时候，怎么决定用值类型还是引用类型呢？当你使用 Cocoa 框架的时候，很多 API 都要通过 NSObject 的子类使用，所以这时候必须要用到引用类型 class。在其他情况下，有下面几个准则： diff --git a/source/chapter4/07_Optional_Case_Study.md b/source/chapter4/07_Optional_Case_Study.md index 4a38ee93..d54a68db 100644 --- a/source/chapter4/07_Optional_Case_Study.md +++ b/source/chapter4/07_Optional_Case_Study.md @@ -13,10 +13,10 @@ 可选类型是 Swift 中新引入的，功能很强大。在这篇博文里讨论的，是在 Swift 里，如何通过可选类型来保证强类型的安全性。作为例子，我们来创建一个 Objective-C API 的 Swift 版本，但实际上 Swift 本身并不需要这样的 API。 - -#### 为 Dictionary 增加 objectsForKeys 函数 +#### 为 Dictionary 增加 objectsForKeys 函数 {#add-function} -在 Objective-C 中，`NSDictionary` 有一个方法 `-objectsForKeys:NoFoundMarker:`, 这个方法需要一个 `NSArray` 数组作为键值参数，然后返回一个包含相关值的数组。文档里写到：“返回数组中的第 N 个值，和输入数组中的第 N 个值相对应”，那如果有某个键值在字典里不存在呢？于是就有了 `notFoundMarker` 作为返回提示。比如第三个键值没有找到，那么在返回数组中第三个值就是这个 `notFoundMarker`，而不是字典中的第三个值，但是这个值只是用来提醒原字典中没有找到对应值，但在返回数组中该元素存在，且用 `notFoundMarker` 作为占位符，因为这个对象不能直接使用，所以在 Foundation 框架中有个专门的类处理这个情况：`NSNull`。 +在 Objective-C 中，`NSDictionary` 有一个方法 `-objectsForKeys:NoFoundMarker:`, 这个方法需要一个 `NSArray` 数组作为键值参数，然后返回一个包含相关值的数组。文档里写到：“返回数组中的第 N 个值， +和输入数组中的第 N 个值相对应”，那如果有某个键值在字典里不存在呢？于是就有了 `notFoundMarker` 作为返回提示。比如第三个键值没有找到，那么在返回数组中第三个值就是这个 `notFoundMarker`，而不是字典中的第三个值，但是这个值只是用来提醒原字典中没有找到对应值，但在返回数组中该元素存在，且用 `notFoundMarker` 作为占位符，因为这个对象不能直接使用，所以在 Foundation 框架中有个专门的类处理这个情况：`NSNull`。 在 Swift 中，`Dictionary` 类没有类似 `objectsForKeys` 的函数，为了说明问题，我们动手加一个，并且使其成为操作字典值的通用方法。我们可以用 `extension` 来实现： @@ -43,8 +43,7 @@ extension Dictionary{ } ``` - -#### Swift 中更简便的方法 +#### Swift 中更简便的方法 {#easy-function} 小伙伴们可能会问，为什么 Swift 中不需要实现这么一个 API 呢？其实其有更简单的实现，如下面代码所示： @@ -73,8 +72,7 @@ t = dic.valuesForKeys([]) //结果为：[] ``` - -#### 内嵌可选类型 +#### 内嵌可选类型 {#nested-optional} 现在，如果我们为每一个结果调用 `last` 方法，看下结果如何？ @@ -114,8 +112,7 @@ var last:T? { get } 不管是 Swift 版本还是 Objective-C 版本，返回值为 `nil` 都意味数组是空的，所以它就没有最后一个元素。 但是如果返回是 `Optional(nil)` 或者 Objective-C 中的 `NSNull` 都表示数组中的最后一个元素存在，但是元素的内容是空的。在 Objective-C 中只能借助 `NSNull` 作为占位符来达到这个目的，但是 Swift 却可以语言系统类型的角度的实现。 - -#### 提供一个默认值 +#### 提供一个默认值 {#provide-default} 进一步封装，如果我字典中的某个或某些元素不存在，我们想提供一个默认值怎么办呢？实现方法很简单： diff --git a/source/contributors.md b/source/contributors.md new file mode 100755 index 00000000..6f8ef80b --- /dev/null +++ b/source/contributors.md @@ -0,0 +1,146 @@ +# 文档翻译 & 校对工作记录 + +Swift 官方文档中文翻译由 [numbbbbb](https://github.com/numbbbbb) 发起并主导，本项目已经得到了苹果官方的 [认可](https://swift.org/documentation/)（Translations 部分）。下面是各个版本官方文档翻译和校对工作的主要贡献者，排名不分先后。 + +## Swift 5.x 主要贡献者 + +- [Adolf-L](https://github.com/Adolf-L) +- [BigNerdCoding](https://github.com/bignerdcoding) +- [bqlin](https://github.com/bqlin) +- [Byelaney](https://github.com/Byelaney) +- [CMB](https://github.com/chenmingbiao) +- [DarrenChen123](https://github.com/DarrenChen123) +- [dzyding](https://github.com/dzyding) +- [Hale](https://github.com/wuqiuhao) +- [jojotov](https://github.com/jojotov) +- [Khala-wan](https://github.com/Khala-wan) +- [Nemocdz](https://github.com/Nemocdz) +- [numbbbbb](https://github.com/numbbbbb) +- [WAMaker](https://github.com/WAMaker) +- [Yousanflics](https://github.com/Yousanflics) + +## Swift 4.x 主要贡献者 + +- [Adolf-L](https://github.com/Adolf-L) +- [BigNerdCoding](https://github.com/bignerdcoding) +- [bqlin](https://github.com/bqlin) +- [Cee](https://github.com/Cee) +- [CMB](https://github.com/chenmingbiao) +- [Damonwong](https://github.com/Damonvvong) +- [Desgard](https://github.com/Desgard) +- [dzyding](https://github.com/dzyding) +- [EyreFree](https://www.eyrefree.org/) +- [Forelas](https://github.com/ForelaxX) +- [Hale](https://github.com/wuqiuhao) +- [kemchenj](https://kemchenj.github.io) +- [jojotov](https://github.com/jojotov) +- [Meler](https://github.com/pmtao) +- [mobilefellow](https://github.com/mobilefellow) +- [muhlenXi](https://github.com/muhlenxi) +- [mylittleswift](https://github.com/mylittleswift) +- [Nemocdz](https://github.com/Nemocdz) +- [numbbbbb](https://github.com/numbbbbb) +- [rain2540](https://github.com/rain2540) +- [Rsenjoyer](https://github.com/Rsenjoyer) +- [WAMaker](https://github.com/WAMaker) +- [YiYiZheng](https://github.com/YiYiZheng) +- [ZhangChi](https://github.com/zhangchi25806) + +## Swift 3.x 主要贡献者 + +- [bqlin](https://github.com/bqlin) +- [chenmingjia](https://github.com/chenmingjia) +- [CMB](https://github.com/chenmingbiao) +- [crayygy](https://github.com/crayygy) +- [kemchenj](https://kemchenj.github.io) +- [Lanford](https://github.com/LanfordCai) +- [mmoaay](https://github.com/mmoaay) +- [mylittleswift](https://github.com/mylittleswift) +- [qhd](https://github.com/qhd) +- [shanks](https://github.com/shanksyang) + +## Swift 2.x 主要贡献者 + +- [100mango](https://github.com/100mango) +- [175](https://github.com/Brian175) +- [BridgeQ](https://github.com/WXGBridgeQ) +- [buginux](https://github.com/buginux) +- [Cee](https://github.com/Cee) +- [Channe](https://github.com/Channe) +- [CMB](https://github.com/chenmingbiao) +- [DianQK](https://github.com/DianQK) +- [dreamkidd](https://github.com/dreamkidd) +- [EudeMorgen](https://github.com/EudeMorgen) +- [futantan](https://github.com/futantan) +- [JackAlan](https://github.com/AlanMelody) +- [KYawn](https://github.com/KYawn) +- [Lanford](https://github.com/LanfordCai) +- [Lenhoon](https://github.com/Lenhoon) +- [littledogboy](https://github.com/littledogboy) +- [LinusLing](https://github.com/linusling) +- [lyojo](https://github.com/lyojo) +- [miaosiqi](https://github.com/miaosiqi) +- [mmoaay](https://github.com/mmoaay) +- [overtrue](https://github.com/overtrue) +- [pmst](https://github.com/colourful987) +- [Prayer](https://github.com/futantan) +- [qhd](https://github.com/qhd) +- [ray16897188](https://github.com/ray16897188) +- [Realank](https://github.com/realank) +- [saitjr](https://github.com/saitjr) +- [SergioChan](https://github.com/SergioChan) +- [shanks](https://github.com/shanksyang) +- [SketchK](https://github.com/SketchK) +- [SkyJean](https://github.com/SkyJean) +- [wardenNScaiyi](https:github.com/wardenNScaiyi) +- [xtymichael](https://github.com/xtymichael) +- [yangsiy](https://github.com/yangsiy) +- [星夜暮晨](https://github.com/semperidem) +- [小铁匠 Linus](https://github.com/kevin833752) + +## Swift 1.x 主要贡献者 + +- [bruce0505](https://github.com/bruce0505) +- [changkun](http://changkun.us/about/) +- [ChildhoodAndy](http://childhood.logdown.com) +- [coverxit](https://github.com/coverxit) +- [dabing1022](https://github.com/dabing1022) +- [EvilCome](https://github.com/Evilcome) +- [feiin](https://github.com/feiin) +- [fd5788](https://github.com/fd5788) +- [geek5nan](https://github.com/geek5nan) +- [happyming](https://github.com/happyming) +- [Hawstein](https://github.com/Hawstein) +- [honghaoz](https://github.com/honghaoz) +- [JaceFu](http://www.devtalking.com/) +- [Jasonbroker](https://github.com/Jasonbroker) +- [JaySurplus](https://github.com/JaySurplus) +- [Lenhoon](https://github.com/marsprince) +- [lifedim](https://github.com/lifedim) +- [Lin-H](https://github.com/Lin-H) +- [lslxdx](https://github.com/lslxdx) +- [LunaticM](https://github.com/LunaticM) +- [lyuka](https://github.com/lyuka) +- [marsprince](https://github.com/marsprince) +- [menlongsheng](https://github.com/menlongsheng) +- [NicePiao](https://github.com/NicePiao) +- [numbbbbb](https://github.com/numbbbbb) +- [pp-prog](https://github.com/pp-prog) +- [sg552](https://github.com/sg552) +- [stanzhai](https://github.com/stanzhai) +- [shinyzhu](https://github.com/shinyzhu) +- [superkam](https://github.com/superkam) +- [takalard](https://github.com/takalard) +- [TimothyYe](https://github.com/TimothyYe) +- [vclwei](https://github.com/vclwei) +- [wh1100717](https://github.com/wh1100717) +- [xiehurricane](https://github.com/xiehurricane) +- [XieLingWang](https://github.com/xielingwang) +- [yangsiy](https://github.com/yangsiy) +- [yankuangshi](https://github.com/yankuangshi) +- [yeahdongcn](https://github.com/yeahdongcn) +- [yangsiy](https://github.com/yangsiy) +- [zqp](https://github.com/zqp) +- [成都老码团队翻译组-Arya](http://weibo.com/littlekok/) +- [成都老码团队翻译组-Oberyn](http://weibo.com/u/5241713117) +