andre/the-swift-programming-language-in-chinese
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

finally adjust

Browse Source
This commit is contained in:
梁杰
2015-08-02 22:12:05 +08:00
parent 15321c7a74
commit 2044f4667f
37 changed files with 1923 additions and 1668 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
source/chapter1/01_swift.md
View File

@ -1,5 +1,10 @@
> 1.0
> 翻译：[numbbbbb](https://github.com/numbbbbb) > 翻译：[numbbbbb](https://github.com/numbbbbb)
> 校对：[yeahdongcn](https://github.com/yeahdongcn), [xtymichael](https://github.com/xtymichael) > 校对：[yeahdongcn](https://github.com/yeahdongcn)
> 2.0
> 翻译+校对：[xtymichael](https://github.com/xtymichael)
# 关于 Swift # 关于 Swift
----------------- -----------------

8
source/chapter1/02_a_swift_tour.md
View File

@ -1,6 +1,10 @@
> 翻译：[numbbbbb](https://github.com/numbbbbb), [xtymichael](https://github.com/xtymichael) > 1.0
> 翻译：[numbbbbb](https://github.com/numbbbbb)
> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai) > 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[xtymichael](https://github.com/xtymichael)
# Swift 初见 # Swift 初见
--- ---
@ -27,7 +31,7 @@ print("Hello, world")
> 注意： > 注意：
> 为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。 > 为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。
> <a href="https://github.com/numbbbbb/the-swift-programming-language-in-chinese/raw/gh-pages/source/chapter1/GuidedTour.playground.zip">下载Playground</a> > <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GuidedTour.playground.zip">下载Playground</a>
<a name="simple_values"></a> <a name="simple_values"></a>
## 简单值 ## 简单值

32
source/chapter2/01_The_Basics.md
View File

@ -1,6 +1,10 @@
> 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus), [xtymichael](https://github.com/xtymichael) > 1.0
> 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus)
> 校对：[lslxdx](https://github.com/lslxdx) > 校对：[lslxdx](https://github.com/lslxdx)
> 2.0
> [xtymichael](https://github.com/xtymichael)
# 基础部分 # 基础部分
----------------- -----------------
@ -99,6 +103,12 @@ var welcomeMessage: String
welcomeMessage = "Hello" welcomeMessage = "Hello"
``` ```
你可以在一行中定义多个同样类型的变量，用逗号分割，并在最后一个变量名之后添加类型标注：
```swift
var red, green, blue: Double
```
> 注意： > 注意：
一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考[类型安全和类型推断](#type_safety_and_type_inference)。在上面的例子中，没有给`welcomeMessage`赋初始值，所以变量`welcomeMessage`的类型是通过一个类型标注指定的，而不是通过初始值推断的。 一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考[类型安全和类型推断](#type_safety_and_type_inference)。在上面的例子中，没有给`welcomeMessage`赋初始值，所以变量`welcomeMessage`的类型是通过一个类型标注指定的，而不是通过初始值推断的。
@ -165,7 +175,7 @@ print("The current value of friendlyWelcome is \(friendlyWelcome)")
``` ```
> 注意： > 注意：
字符串插值所有可用的选项，请参考[字符串插值](03_Strings_and_Characters.html#string_interpolation)。 字符串插值所有可用的选项，请参考[字符串插值](./03_Strings_and_Characters.html#string_interpolation)。
<a name="comments"></a> <a name="comments"></a>
## 注释 ## 注释
@ -369,7 +379,7 @@ let twoThousandAndOne = twoThousand + UInt16(one)
现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推断为`UInt16`，因为它是两个`UInt16`值的和。 现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推断为`UInt16`，因为它是两个`UInt16`值的和。
`SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考[扩展](20_Extensions.html)。 `SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考[扩展](./20_Extensions.html)。
<a name="integer_and_floating_point_conversion"></a> <a name="integer_and_floating_point_conversion"></a>
### 整数和浮点数转换 ### 整数和浮点数转换
@ -440,7 +450,7 @@ if turnipsAreDelicious {
// 输出 "Eww, turnips are horrible." // 输出 "Eww, turnips are horrible."
``` ```
条件语句，例如`if`，请参考[控制流](05_Control_Flow.html)。 条件语句，例如`if`，请参考[控制流](./05_Control_Flow.html)。
如果你在需要使用`Bool`类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误： 如果你在需要使用`Bool`类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：
@ -460,7 +470,7 @@ if i == 1 {
} }
``` ```
`i == 1`的比较结果是`Bool`类型，所以第二个例子可以通过类型检查。类似`i == 1`这样的比较，请参考[基本操作符](05_Control_Flow.html)。 `i == 1`的比较结果是`Bool`类型，所以第二个例子可以通过类型检查。类似`i == 1`这样的比较，请参考[基本操作符](./05_Control_Flow.html)。
和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的意图总是清晰的。 和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的意图总是清晰的。
@ -522,10 +532,10 @@ print("The status message is \(http200Status.description)")
// 输出 "The status message is OK" // 输出 "The status message is OK"
``` ```
作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个`(Int, String)`元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考[函数参数与返回值](06_Functions.html#Function_Parameters_and_Return_Values)。 作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个`(Int, String)`元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考[函数参数与返回值](./06_Functions.html#Function_Parameters_and_Return_Values)。
> 注意： > 注意：
元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考[类和结构体](09_Classes_and_Structures.html)。 元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考[类和结构体](./09_Classes_and_Structures.html)。
<a name="optionals"></a> <a name="optionals"></a>
## 可选类型 ## 可选类型
@ -608,7 +618,7 @@ if convertedNumber != nil {
<a name="optional_binding"></a> <a name="optional_binding"></a>
### 可选绑定 ### 可选绑定
使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句，请参考[控制流](05_Control_Flow.html)。 使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句，请参考[控制流](./05_Control_Flow.html)。
像下面这样在`if`语句中写一个可选绑定： 像下面这样在`if`语句中写一个可选绑定：
@ -654,7 +664,7 @@ if let constantName = someOptional, anotherConstantName = someOtherOptional {
这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选类型。 这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选类型。
当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考[类实例之间的循环强引用](16_Automatic_Reference_Counting.html#strong_reference_cycles_between_class_instances)。 当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考[无主引用以及隐式解析可选属性](./16_Automatic_Reference_Counting.html#unowned_references_and_implicitly_unwrapped_optional_properties)。
一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型`String`和隐式解析可选类型`String`之间的区别： 一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型`String`和隐式解析可选类型`String`之间的区别：
@ -740,7 +750,7 @@ do {
如果没有错误被抛出, `eatASandwich()`函数会被调用。如果一个符合`Error.OutOfCleanDishes`的错误被抛出,`washDishes`函数会被调用。如果一个符合`Error.MissingIngredients`的错误被抛出，`buyGroceries(_:)`函数会被调用并传递相关被`catch`所捕捉到的`[String]`值。 如果没有错误被抛出, `eatASandwich()`函数会被调用。如果一个符合`Error.OutOfCleanDishes`的错误被抛出,`washDishes`函数会被调用。如果一个符合`Error.MissingIngredients`的错误被抛出，`buyGroceries(_:)`函数会被调用并传递相关被`catch`所捕捉到的`[String]`值。
抛出，捕捉，传递错误会在[错误处理](../chapter2/18_Error_Handling.html)章节详细说明。 抛出，捕捉，传递错误会在[错误处理](./18_Error_Handling.html)章节详细说明。
<a name="assertions"></a> <a name="assertions"></a>
## 断言 ## 断言
@ -777,7 +787,7 @@ assert(age >= 0)
* 需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。 * 需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
* 一个可选值现在是`nil`，但是后面的代码运行需要一个非`nil`值。 * 一个可选值现在是`nil`，但是后面的代码运行需要一个非`nil`值。
请参考[下标脚本](12_Subscripts.html)和[函数](06_Functions.html)。 请参考[下标脚本](./12_Subscripts.html)和[函数](./06_Functions.html)。
> 注意： > 注意：
断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。 断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。

21
source/chapter2/02_Basic_Operators.md
View File

@ -1,6 +1,9 @@
> 1.0
> 翻译：[XieLingWang](https://github.com/xielingwang)
> 校对：[EvilCome](https://github.com/Evilcome)
> 翻译：[XieLingWang](https://github.com/xielingwang), [JackAlan](https://github.com/AlanMelody) > 2.0
> 校对：[EvilCome](https://github.com/Evilcome), [JackAlan](https://github.com/AlanMelody) > 翻译+校对：[JackAlan](https://github.com/AlanMelody)
# 基本运算符 # 基本运算符
----------------- -----------------
@ -19,11 +22,11 @@
运算符是检查、改变、合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。更复杂的运算例子包括逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），或让 i 值加1的便捷自增运算符`++i`等。 运算符是检查、改变、合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。更复杂的运算例子包括逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），或让 i 值加1的便捷自增运算符`++i`等。
Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如：赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。算术运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](24_Advanced_Operators.html#overflow_operators)。 Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如：赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。算术运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](./24_Advanced_Operators.html#overflow_operators)。
区别于 C 语言，在 Swift 中你可以对浮点数进行取余运算（`%`），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符（`a..<b`和`a...b`），这方便我们表达一个区间内的数值。 区别于 C 语言，在 Swift 中你可以对浮点数进行取余运算（`%`），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符（`a..<b`和`a...b`），这方便我们表达一个区间内的数值。
本章节只描述了 Swift 中的基本运算符，[高级运算符](24_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。 本章节只描述了 Swift 中的基本运算符，[高级运算符](./24_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
<a name="terminology"></a> <a name="terminology"></a>
## 术语 ## 术语
@ -77,7 +80,7 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
与 C 语言和 Objective-C 不同的是，Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算（如`a &+ b`）。详情参见[溢出运算符](24_Advanced_Operators.html#overflow_operators)。 与 C 语言和 Objective-C 不同的是，Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算（如`a &+ b`）。详情参见[溢出运算符](./24_Advanced_Operators.html#overflow_operators)。
加法运算符也可用于`String`的拼接： 加法运算符也可用于`String`的拼接：
@ -215,7 +218,7 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
- 小于等于（`a <= b`） - 小于等于（`a <= b`）
> 注意： > 注意：
Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](09_Classes_and_Structures.html)。 Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](./09_Classes_and_Structures.html)。
每个比较运算都返回了一个标识表达式是否成立的布尔值： 每个比较运算都返回了一个标识表达式是否成立的布尔值：
@ -240,7 +243,7 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
// 输出 "hello, world", 因为 `name` 就是等于 "world" // 输出 "hello, world", 因为 `name` 就是等于 "world"
关于`if`语句，请看[控制流](05_Control_Flow.html)。 关于`if`语句，请看[控制流](./05_Control_Flow.html)。
<a name="ternary_conditional_operator"></a> <a name="ternary_conditional_operator"></a>
## 三目运算符(Ternary Conditional Operator) ## 三目运算符(Ternary Conditional Operator)
@ -335,7 +338,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
// 5 * 5 = 25 // 5 * 5 = 25
关于`for-in`，请看[控制流](05_Control_Flow.html)。 关于`for-in`，请看[控制流](./05_Control_Flow.html)。
### 半开区间运算符 ### 半开区间运算符
@ -356,7 +359,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
// 第 4 个人叫 Jack // 第 4 个人叫 Jack
数组有4个元素，但`0..<count`只数到3(最后一个元素的下标)，因为它是半开区间。关于数组，请查阅[数组](04_Collection_Types.html#arrays)。 数组有4个元素，但`0..<count`只数到3(最后一个元素的下标)，因为它是半开区间。关于数组，请查阅[数组](./04_Collection_Types.html#arrays)。
<a name="logical_operators"></a> <a name="logical_operators"></a>
## 逻辑运算 ## 逻辑运算

12
source/chapter2/03_Strings_and_Characters.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[wh1100717](https://github.com/wh1100717) > 翻译：[wh1100717](https://github.com/wh1100717)
> 校对：[Hawstein](https://github.com/Hawstein) > 校对：[Hawstein](https://github.com/Hawstein)
> 2.0
> 翻译+校对：[DianQK](https://github.com/DianQK)
# 字符串和字符（Strings and Characters） # 字符串和字符（Strings and Characters）
--- ---
@ -30,7 +34,7 @@ Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode
你也可以在常量、变量、字面量和表达式中进行字符串插值操作，这可以帮助你轻松创建用于展示、存储和打印的自定义字符串。 你也可以在常量、变量、字面量和表达式中进行字符串插值操作，这可以帮助你轻松创建用于展示、存储和打印的自定义字符串。
> 注意： > 注意：
> Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。就像 [AnyObject](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TypeCasting.html#//apple_ref/doc/uid/TP40014097-CH22-ID343) 中提到的一样，在使用 Cocoa 中的 Foundation 框架时，您可以将创建的任何字符串的值转换成`NSString`，并调用任意的`NSString` API。您也可以在任意要求传入`NSString`实例作为参数的 API 中用`String`类型的值代替。 > Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。就像 [`AnyObject`类型](./20_Type_Casting.html#anyobject) 中提到的一样，在使用 Cocoa 中的 Foundation 框架时，您可以将创建的任何字符串的值转换成`NSString`，并调用任意的`NSString` API。您也可以在任意要求传入`NSString`实例作为参数的 API 中用`String`类型的值代替。
> 更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 *[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)*。 > 更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 *[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)*。
@ -88,7 +92,7 @@ constantString += " and another Highlander"
Swift 的`String`类型是值类型。 Swift 的`String`类型是值类型。
如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。
任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。
值类型在 [结构体和枚举是值类型](09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了详细描述。 值类型在 [结构体和枚举是值类型](./09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了详细描述。
> 注意： > 注意：
> 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。 > 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
@ -115,7 +119,7 @@ for character in "Dog!🐶".characters {
// 🐶 // 🐶
``` ```
for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细描述。 for-in 循环在 [For Loops](./05_Control_Flow.html#for_loops) 中进行了详细描述。
另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量： 另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量：
@ -370,7 +374,7 @@ Swift 提供了三种方式来比较文本值：字符串字符相等、前缀
<a name="string_and_character_equality"></a> <a name="string_and_character_equality"></a>
### 字符串/字符相等 (String and Character Equality) ### 字符串/字符相等 (String and Character Equality)
字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在 [Comparison Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-ID70)： 字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在[比较运算符](./02_Basic_Operators.html#comparison_operators)：
```swift ```swift
let quotation = "We're a lot alike, you and I." let quotation = "We're a lot alike, you and I."

24
source/chapter2/04_Collection_Types.md
View File

@ -1,5 +1,9 @@
> 翻译：[zqp](https://github.com/zqp), [JackAlan](https://github.com/AlanMelody) > 1.0
> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin), [JackAlan](https://github.com/AlanMelody) > 翻译：[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)
# 集合类型 (Collection Types) # 集合类型 (Collection Types)
----------------- -----------------
@ -18,7 +22,7 @@ Swift 语言提供`Arrays`、`Sets`和`Dictionaries`三种基本的集合类型
Swift 语言中的`Arrays`、`Sets`和`Dictionaries`中存储的数据值类型必须明确。这意味着我们不能把不正确的数据类型插入其中。同时这也说明我们完全可以对取回值的类型非常自信。 Swift 语言中的`Arrays`、`Sets`和`Dictionaries`中存储的数据值类型必须明确。这意味着我们不能把不正确的数据类型插入其中。同时这也说明我们完全可以对取回值的类型非常自信。
> 注意： > 注意：
Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更多关于泛型类型和集合，参见 [泛型](23_Generics.html)章节。 Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更多关于泛型类型和集合，参见 [泛型](./23_Generics.html)章节。
<a name="mutability_of_collections"></a> <a name="mutability_of_collections"></a>
## 集合的可变性 ## 集合的可变性
@ -35,7 +39,7 @@ Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更
> 注意: > 注意:
Swift 的`Array`类型被桥接到`Foundation`中的`NSArray`类。 Swift 的`Array`类型被桥接到`Foundation`中的`NSArray`类。
更多关于在`Foundation`和`Cocoa`中使用`Array`的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。 更多关于在`Foundation`和`Cocoa`中使用`Array`的信息，参见 [*Using Swift with Cocoa and Obejective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 一书。
<a name="array_type_shorthand_syntax"></a> <a name="array_type_shorthand_syntax"></a>
### 数组的简单语法 ### 数组的简单语法
@ -255,14 +259,14 @@ for (index, value) in shoppingList.enumerate() {
> 注意： > 注意：
> Swift的`Set`类型被桥接到`Fundation`中的`NSSet`类。 > Swift的`Set`类型被桥接到`Fundation`中的`NSSet`类。
> 关于使用`Fundation`和`Cocoa`中`Set`的知识，请看 *Using Swift with Cocoa and Objective-C*。 > 关于使用`Fundation`和`Cocoa`中`Set`的知识，请看 [*Using Swift with Cocoa and Objective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
<a name="hash_values_for_set_types"></a> <a name="hash_values_for_set_types"></a>
#### Set类型的哈希值 #### Set类型的哈希值
为了存储在集合中，该类型必须是可哈希化的-也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是```Int```类型的，它和其他的对象相同，其被用来比较相等与否，比如```a==b```,它遵循的是```a.hashValue == b.hashValue```。 为了存储在集合中，该类型必须是可哈希化的-也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是```Int```类型的，它和其他的对象相同，其被用来比较相等与否，比如```a==b```,它遵循的是```a.hashValue == b.hashValue```。
Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool```)默认都是可哈希化的，它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在[枚举部分](08_Enumerations.html)有讲述)默认也是可哈希化的。 Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool```)默认都是可哈希化的，它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在[枚举](./08_Enumerations.html)有讲述)默认也是可哈希化的。
> 注意： > 注意：
> 你可以使用你自定义的类型作为集合的值或者是字典的键值类型，但你需要使你的自定义类型服从Swift标准库中的`Hashable`协议。服从`Hashable`协议的类型需要提供一个类型为`Int`的取值访问器属性`hashValue`。这个由类型的`hashValue`返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。 > 你可以使用你自定义的类型作为集合的值或者是字典的键值类型，但你需要使你的自定义类型服从Swift标准库中的`Hashable`协议。服从`Hashable`协议的类型需要提供一个类型为`Int`的取值访问器属性`hashValue`。这个由类型的`hashValue`返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。
@ -272,7 +276,7 @@ Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool`
* ```a==b```意味着```b==a```(对称性) * ```a==b```意味着```b==a```(对称性)
* ```a==b&&b==c```意味着```a==c```(传递性) * ```a==b&&b==c```意味着```a==c```(传递性)
关于协议遵循的更多信息，请看[协议](22_Protocols.html) 关于协议遵循的更多信息，请看[协议](./22_Protocols.html)
<a name="set_type_syntax"></a> <a name="set_type_syntax"></a>
### Set类型语法 ### Set类型语法
@ -393,7 +397,7 @@ for genre in favoriteGenres {
// Hip hop // Hip hop
``` ```
更多关于`for-in`循环信息，参见[For循环](05_Control_Flow.html#for_loops)。 更多关于`for-in`循环信息，参见[For循环](./05_Control_Flow.html#for_loops)。
Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中值可以使用`sort()`方法，它将根据提供的序列返回一个排序的集合. Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中值可以使用`sort()`方法，它将根据提供的序列返回一个排序的集合.
@ -471,7 +475,7 @@ farmAnimals.isDisjointWith(cityAnimals)
> 注意： > 注意：
> Swiftly 的`Dictionary` 类型被桥接到Foundation的`NSDictionary`类。 > Swiftly 的`Dictionary` 类型被桥接到Foundation的`NSDictionary`类。
> 更多关于在`Foundation`和`Cocoa`中使用`Dictionary`类型的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。 > 更多关于在`Foundation`和`Cocoa`中使用`Dictionary`类型的信息，参见 [*Using Swift with Cocoa and Obejective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 一书。
<a name="dictionary_type_shorthand_syntax"></a> <a name="dictionary_type_shorthand_syntax"></a>
## 字典类型快捷语法 ## 字典类型快捷语法
@ -640,7 +644,7 @@ for (airportCode, airportName) in airports {
// LHR: London Heathrow // LHR: London Heathrow
``` ```
更多关于`for-in`循环的信息，参见[For 循环](05_Control_Flow.html#for_loops)。 更多关于`for-in`循环的信息，参见[For 循环](./05_Control_Flow.html#for_loops)。
通过访问`keys`或者`values`属性，我们也可以遍历字典的键或者值。 通过访问`keys`或者`values`属性，我们也可以遍历字典的键或者值。

13
source/chapter2/05_Control_Flow.md
View File

@ -1,5 +1,9 @@
> 翻译：[vclwei](https://github.com/vclwei), [coverxit](https://github.com/coverxit), [NicePiao](https://github.com/NicePiao), [JackAlan](https://github.com/AlanMelody) > 1.0
> 校对：[coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai), [JackAlan](https://github.com/AlanMelody) > 翻译：[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)
# 控制流 # 控制流
----------------- -----------------
@ -87,7 +91,7 @@ for (animalName, legCount) in numberOfLegs {
// spiders have 8 legs // spiders have 8 legs
``` ```
字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见[集合类型](04_Collection_Types.html)。 字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见[集合类型](./04_Collection_Types.html)。
<a name="for"></a> <a name="for"></a>
@ -529,8 +533,9 @@ case let (x, y):
- `break` - `break`
- `fallthrough` - `fallthrough`
- `return` - `return`
- `throw`
我们将会在下面讨论`continue`、`break`和`fallthrough`语句。`return`语句将会在[函数](06_Functions.html)章节讨论。 我们将会在下面讨论`continue`、`break`和`fallthrough`语句。`return`语句将会在[函数](./06_Functions.html)章节讨论，`throw`语句会在[错误抛出](./18_Error_Handling.html#throwing_errors)
<a name="continue"></a> <a name="continue"></a>
### Continue ### Continue

7
source/chapter2/06_Functions.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[honghaoz](https://github.com/honghaoz) > 翻译：[honghaoz](https://github.com/honghaoz)
> 校对：[LunaticM](https://github.com/LunaticM) > 校对：[LunaticM](https://github.com/LunaticM)
> 2.0
> 翻译+校对：[dreamkidd](https://github.com/dreamkidd)
# 函数（Functions） # 函数（Functions）
----------------- -----------------
@ -116,6 +120,7 @@ print(sayHello("Tim", alreadyGreeted: true))
当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记,函数参数命名在[函数参数名称（Function Parameter Names）](#Function_Parameter_Names)有更详细的描述. 当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记,函数参数命名在[函数参数名称（Function Parameter Names）](#Function_Parameter_Names)有更详细的描述.
<a name="functions_without_return_values"></a>
### 无返回值函数（Functions Without Return Values） ### 无返回值函数（Functions Without Return Values）
函数可以没有返回值。下面是 `sayHello(_:)` 函数的另一个版本，叫 `sayGoodbye(_:)`，这个函数直接输出 `String` 值，而不是返回它： 函数可以没有返回值。下面是 `sayHello(_:)` 函数的另一个版本，叫 `sayGoodbye(_:)`，这个函数直接输出 `String` 值，而不是返回它：
@ -242,6 +247,7 @@ someFunction(1, secondParameterName: 2)
一般情况下,第一个参数省略其外部参数名,第二个以后的参数使用其本地参数名作为自己的外部参数名.所有参数需要有不同的本地参数名,但可以共享相同的外部参数名. 一般情况下,第一个参数省略其外部参数名,第二个以后的参数使用其本地参数名作为自己的外部参数名.所有参数需要有不同的本地参数名,但可以共享相同的外部参数名.
<a name="specifying_external_parameter_names"></a>
### 指定外部参数名(Specifying External Parameter Names) ### 指定外部参数名(Specifying External Parameter Names)
你可以在本地参数名前指定外部参数名,中间以逗号分隔. 你可以在本地参数名前指定外部参数名,中间以逗号分隔.
@ -373,6 +379,7 @@ let paddedString = alignRight(originalString, totalLength: 10, pad: "-")
> 注意： > 注意：
> 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。 > 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。
<a name="in_out_parameters"></a>
### 输入输出参数（In-Out Parameters） ### 输入输出参数（In-Out Parameters）
变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。 变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。

16
source/chapter2/07_Closures.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[wh1100717](https://github.com/wh1100717) > 翻译：[wh1100717](https://github.com/wh1100717)
> 校对：[lyuka](https://github.com/lyuka) > 校对：[lyuka](https://github.com/lyuka)
> 2.0
> 翻译+校对：[100mango](https://github.com/100mango)
# 闭包（Closures） # 闭包（Closures）
----------------- -----------------
@ -20,7 +24,7 @@ Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他
> 注意： > 注意：
> 如果您不熟悉捕获（capturing）这个概念也不用担心，您可以在 [值捕获](#capturing_values) 章节对其进行详细了解。 > 如果您不熟悉捕获（capturing）这个概念也不用担心，您可以在 [值捕获](#capturing_values) 章节对其进行详细了解。
在[函数](../chapter2/06_Functions.html) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一： 在[函数](./06_Functions.html) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
* 全局函数是一个有名字但不会捕获任何值的闭包 * 全局函数是一个有名字但不会捕获任何值的闭包
* 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包 * 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
@ -37,7 +41,7 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
## 闭包表达式（Closure Expressions） ## 闭包表达式（Closure Expressions）
[嵌套函数](../chapter2/06_Functions.html#nested_function) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。 [嵌套函数](./06_Functions.html#nested_function) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
闭包表达式是一种利用简洁语法构建内联闭包的方式。 闭包表达式是一种利用简洁语法构建内联闭包的方式。
闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。 闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
@ -172,7 +176,7 @@ Swift 的`String`类型定义了关于大于号 (`>`) 的字符串实现，其
reversed = names.sort(>) reversed = names.sort(>)
``` ```
更多关于运算符表达式的内容请查看 [运算符函数](../chapter2/24_Advanced_Operators.html#operator_functions)。 更多关于运算符表达式的内容请查看 [运算符函数](./24_Advanced_Operators.html#operator_functions)。
<a name="trailing_closures"></a> <a name="trailing_closures"></a>
## 尾随闭包（Trailing Closures） ## 尾随闭包（Trailing Closures）
@ -246,7 +250,7 @@ let strings = numbers.map {
`map`在数组中为每一个元素调用了闭包表达式。 `map`在数组中为每一个元素调用了闭包表达式。
您不需要指定闭包的输入参数`number`的类型，因为可以通过要映射的数组类型进行推断。 您不需要指定闭包的输入参数`number`的类型，因为可以通过要映射的数组类型进行推断。
闭包`number`参数被声明为一个变量参数（变量的具体描述请参看[常量参数和变量参数](../chapter2/06_Functions.html#constant_and_variable_parameters)），因此可以在闭包函数体内对其进行修改。闭包表达式制定了返回类型为`String`，以表明存储映射值的新数组类型为`String`。 闭包`number`参数被声明为一个变量参数（变量的具体描述请参看[常量参数和变量参数](./06_Functions.html#constant_and_variable_parameters)），因此可以在闭包函数体内对其进行修改。闭包表达式制定了返回类型为`String`，以表明存储映射值的新数组类型为`String`。
闭包表达式在每次被调用的时候创建了一个字符串并返回。 闭包表达式在每次被调用的时候创建了一个字符串并返回。
其使用求余运算符 (number % 10) 计算最后一位数字并利用`digitNames`字典获取所映射的字符串。 其使用求余运算符 (number % 10) 计算最后一位数字并利用`digitNames`字典获取所映射的字符串。
@ -296,7 +300,7 @@ func makeIncrementor(forIncrement amount: Int) -> () -> Int {
`makeIncrementor`返回类型为`() -> Int`。 `makeIncrementor`返回类型为`() -> Int`。
这意味着其返回的是一个函数，而不是一个简单类型值。 这意味着其返回的是一个函数，而不是一个简单类型值。
该函数在每次调用时不接受参数只返回一个`Int`类型的值。 该函数在每次调用时不接受参数只返回一个`Int`类型的值。
关于函数返回其他函数的内容，请查看[函数类型作为返回类型](../chapter2/06_Functions.html#function_types_as_return_types)。 关于函数返回其他函数的内容，请查看[函数类型作为返回类型](./06_Functions.html#function_types_as_return_types)。
`makeIncrementor`函数定义了一个整型变量`runningTotal`(初始为0) 用来存储当前跑步总数。 `makeIncrementor`函数定义了一个整型变量`runningTotal`(初始为0) 用来存储当前跑步总数。
该值通过`incrementor`返回。 该值通过`incrementor`返回。
@ -352,7 +356,7 @@ incrementByTen()
> 注意： > 注意：
> 如果您将闭包赋值给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。 > 如果您将闭包赋值给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [闭包引起的循环强引用](../chapter2/16_Automatic_Reference_Counting.html#strong_reference_cycles_for_closures)。 > Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [闭包引起的循环强引用](./16_Automatic_Reference_Counting.html#strong_reference_cycles_for_closures)。
<a name="closures_are_reference_types"></a> <a name="closures_are_reference_types"></a>
## 闭包是引用类型（Closures Are Reference Types） ## 闭包是引用类型（Closures Are Reference Types）

14
source/chapter2/08_Enumerations.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[yankuangshi](https://github.com/yankuangshi) > 翻译：[yankuangshi](https://github.com/yankuangshi)
> 校对：[shinyzhu](https://github.com/shinyzhu) > 校对：[shinyzhu](https://github.com/shinyzhu)
> 2.0
> 翻译+校对：[futantan](https://github.com/futantan)
# 枚举（Enumerations） # 枚举（Enumerations）
--- ---
@ -20,7 +24,7 @@
在 Swift 中，枚举类型是一等公民（first-class）。它们采用了很多传统上只被类（class）所支持的特征，例如计算型属性（computed properties），用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。 在 Swift 中，枚举类型是一等公民（first-class）。它们采用了很多传统上只被类（class）所支持的特征，例如计算型属性（computed properties），用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。
欲了解更多相关信息，请参见[属性（Properties）](10_Properties.html)，[方法（Methods）](11_Methods.html)，[构造过程（Initialization）](14_Initialization.html)，[扩展（Extensions）](20_Extensions.html)和[协议（Protocols）](21_Protocols.html)。 欲了解更多相关信息，请参见[属性（Properties）](./10_Properties.html)，[方法（Methods）](./11_Methods.html)，[构造过程（Initialization）](./14_Initialization.html)，[扩展（Extensions）](./20_Extensions.html)和[协议（Protocols）](./21_Protocols.html)。
<a name="enumeration_syntax"></a> <a name="enumeration_syntax"></a>
## 枚举语法 ## 枚举语法
@ -97,7 +101,7 @@ case .West:
等等以此类推。 等等以此类推。
正如在[控制流（Control Flow）](05_Control_Flow.html)中介绍的那样，在判断一个枚举类型的值时，`switch`语句必须穷举所有情况。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。强制性全部穷举的要求确保了枚举成员不会被意外遗漏。 正如在[控制流（Control Flow）](./05_Control_Flow.html)中介绍的那样，在判断一个枚举类型的值时，`switch`语句必须穷举所有情况。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。强制性全部穷举的要求确保了枚举成员不会被意外遗漏。
当不需要匹配每个枚举成员的时候，你可以提供一个默认`default`分支来涵盖所有未明确被提出的枚举成员： 当不需要匹配每个枚举成员的时候，你可以提供一个默认`default`分支来涵盖所有未明确被提出的枚举成员：
@ -187,7 +191,7 @@ case let .QRCode(productCode):
<a name="raw_values"></a> <a name="raw_values"></a>
## 原始值（Raw Values） ## 原始值（Raw Values）
在[Associated Values](#raw_values)小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的相关值。作为相关值的另一种选择，枚举成员可以被默认值（称为原始值）赋值，其中这些原始值具有相同的类型。 在[相关值](#raw_values)小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的相关值。作为相关值的另一种选择，枚举成员可以被默认值（称为原始值）赋值，其中这些原始值具有相同的类型。
这里是一个枚举成员存储 ASCII 码的例子： 这里是一个枚举成员存储 ASCII 码的例子：
@ -199,7 +203,7 @@ enum ASCIIControlCharacter: Character {
} }
``` ```
在这里，`ASCIIControlCharacter`的枚举类型的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符[`Strings and Characters`](03_Strings_and_Characters.html)部分。 在这里，`ASCIIControlCharacter`的枚举类型的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见[字符串和字符](./03_Strings_and_Characters.html)部分。
原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。 原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。
@ -261,7 +265,7 @@ let possiblePlanet = Planet(rawValue: 7)
<!-- TODO 连接 --> <!-- TODO 连接 -->
>注意： >注意：
>原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[Failableinitializers](http://) >原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[可失败构造器](../chapter3/05_Declarations#failable_initializers)
如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`： 如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`：

18
source/chapter2/09_Classes_and_Structures.md
View File

@ -1,5 +1,9 @@
> 翻译：[JaySurplus](https://github.com/JaySurplus),[SkyJean](https://github.com/SkyJean) > 1.0
> 校对：[sg552](https://github.com/sg552),[SkyJean](https://github.com/SkyJean) > 翻译：[JaySurplus](https://github.com/JaySurplus)
> 校对：[sg552](https://github.com/sg552)
> 2.0
> 翻译+校对：[SkyJean](https://github.com/SkyJean)
# 类和结构体 # 类和结构体
@ -31,7 +35,7 @@ Swift 中类和结构体有很多共同点。共同处在于：
* 通过扩展以增加默认实现的功能 * 通过扩展以增加默认实现的功能
* 实现协议以提供某种标准功能 * 实现协议以提供某种标准功能
更多信息请参见 [属性](10_Properties.html)，[方法](11_Methods.html)，[下标脚本](12_Subscripts.html)，[初始过程](14_Initialization.html)，[扩展](20_Extensions.html)，和[协议](21_Protocols.html)。 更多信息请参见 [属性](./10_Properties.html)，[方法](./11_Methods.html)，[下标脚本](./12_Subscripts.html)，[初始过程](./14_Initialization.html)，[扩展](./20_Extensions.html)，和[协议](./21_Protocols.html)。
与结构体相比，类还有如下的附加功能： 与结构体相比，类还有如下的附加功能：
@ -40,7 +44,7 @@ Swift 中类和结构体有很多共同点。共同处在于：
* 解构器允许一个类实例释放任何其所被分配的资源 * 解构器允许一个类实例释放任何其所被分配的资源
* 引用计数允许对一个类的多次引用 * 引用计数允许对一个类的多次引用
更多信息请参见[继承](13_Inheritance.html)，[类型转换](20_Type_Casting.html)，[析构过程](15_Deinitialization)，和[自动引用计数](16_Automatic_Reference_Counting)。 更多信息请参见[继承](./13_Inheritance.html)，[类型转换](./20_Type_Casting.html)，[析构过程](./15_Deinitialization)，和[自动引用计数](./16_Automatic_Reference_Counting)。
> 注意： > 注意：
结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。 结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
@ -91,7 +95,7 @@ let someResolution = Resolution()
let someVideoMode = VideoMode() let someVideoMode = VideoMode()
``` ```
结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。 结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](./14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
### 属性访问 ### 属性访问
@ -130,7 +134,7 @@ print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
let vga = Resolution(width:640, height: 480) let vga = Resolution(width:640, height: 480)
``` ```
与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](14_Initialization.html)章节会对构造器进行更详细的讨论。 与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](./14_Initialization.html)章节会对构造器进行更详细的讨论。
<a name="structures_and_enumerations_are_value_types"></a> <a name="structures_and_enumerations_are_value_types"></a>
## 结构体和枚举是值类型 ## 结构体和枚举是值类型
@ -249,7 +253,7 @@ if tenEighty === alsoTenEighty {
* “等价于”表示两个类类型（class type）的常量或者变量引用同一个类实例。 * “等价于”表示两个类类型（class type）的常量或者变量引用同一个类实例。
* “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。 * “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[运算符函数(Operator Functions)](24_Advanced_Operators.html#operator_functions)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。 当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[等价操作符](./24_Advanced_Operators.html#equivalence_operators)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
### 指针 ### 指针

10
source/chapter2/10_Properties.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[shinyzhu](https://github.com/shinyzhu) > 翻译：[shinyzhu](https://github.com/shinyzhu)
> 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy) > 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
> 2.0
> 翻译+校对：[yangsiy](https://github.com/yangsiy)
# 属性 (Properties) # 属性 (Properties)
--- ---
@ -23,7 +27,7 @@
简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。 简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
可以在定义存储属性的时候指定默认值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[默认属性值](../chapter2/14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[在初始化阶段修改常量存储属性](../chapter2/14_Initialization.html#modifying_constant_properties_during_initialization)一节。 可以在定义存储属性的时候指定默认值，请参考[默认属性值](./14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[在初始化阶段修改常量存储属性](./14_Initialization.html#assigning_constant_properties_during_initialization)一节。
下面的例子定义了一个名为`FixedLengthRange`的结构体，它描述了一个在创建后无法修改值域宽度的区间： 下面的例子定义了一个名为`FixedLengthRange`的结构体，它描述了一个在创建后无法修改值域宽度的区间：
@ -219,7 +223,7 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
*属性观察器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。 *属性观察器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。
可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。属性重载请参考[继承](chapter/13_Inheritance.html)一章的[重载](chapter/13_Inheritance.html#overriding)。 可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。属性重载请参考[重载](./13_Inheritance.html#overriding)。
> 注意： > 注意：
> 不需要为非重载的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。 > 不需要为非重载的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。
@ -235,7 +239,7 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
> 注意： > 注意：
> 父类的属性在子类的构造器中被赋值时，它在父类中的`willSet`和`didSet`观察器会被调用。 > 父类的属性在子类的构造器中被赋值时，它在父类中的`willSet`和`didSet`观察器会被调用。
> 有关构造器代理的更多信息，请参考[值类型的构造器代理](chapter/14_Initialization.html#initializer_delegation_for_value_types)和[构造器链](chapter/14_Initialization.html#initialization_chain)。 > 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)和[类的构造器代理规则](./14_Initialization.html#initializer_delegation_for_class_types)。
这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。 这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。

10
source/chapter2/11_Methods.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[pp-prog](https://github.com/pp-prog) > 翻译：[pp-prog](https://github.com/pp-prog)
> 校对：[zqp](https://github.com/zqp) > 校对：[zqp](https://github.com/zqp)
> 2.0
> 翻译+校对：[DianQK](https://github.com/DianQK)
# 方法（Methods） # 方法（Methods）
----------------- -----------------
@ -16,7 +20,7 @@
<a name="instance_methods"></a> <a name="instance_methods"></a>
## 实例方法 (Instance Methods) ## 实例方法 (Instance Methods)
**实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](../charpter2/06_Functions.md)。 **实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](./06_Functions.md)。
实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。 实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。
@ -60,7 +64,7 @@ class Counter {
<a name="local_and_external_parameter"></a> <a name="local_and_external_parameter"></a>
### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods) ### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)
函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。 函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[指定外部参数名](./06_Functions.html#specifying_external_parameter_names)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。
Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy(_:)`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。 Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy(_:)`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。
@ -157,7 +161,7 @@ print("The point is now at (\(somePoint.x), \(somePoint.y))")
上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX(_:y:)`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字，这才让方法可以修改值类型的属性。 上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX(_:y:)`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字，这才让方法可以修改值类型的属性。
注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量](10_Properties.html#global_and_local_variables)： 注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量](./10_Properties.html#global_and_local_variables)：
```swift ```swift
let fixedPoint = Point(x: 3.0, y: 3.0) let fixedPoint = Point(x: 3.0, y: 3.0)

8
source/chapter2/12_Subscripts.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[siemenliu](https://github.com/siemenliu) > 翻译：[siemenliu](https://github.com/siemenliu)
> 校对：[zq54zquan](https://github.com/zq54zquan) > 校对：[zq54zquan](https://github.com/zq54zquan)
> 2.0
> 翻译+校对：[shanksyang](https://github.com/shanksyang)
# 下标脚本（Subscripts） # 下标脚本（Subscripts）
----------------- -----------------
@ -79,7 +83,7 @@ numberOfLegs["bird"] = 2
上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`[String:Int]`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。 上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`[String:Int]`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](../chapter2/04_Collection_Types.html) 更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](./04_Collection_Types.html#accessing_and_modifying_a_dictionary)
> 注意： > 注意：
> Swift 中字典的附属脚本实现中，在`get`部分返回值是`Int?`，上例中的`numberOfLegs`字典通过附属脚本返回的是一个`Int?`或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。 > Swift 中字典的附属脚本实现中，在`get`部分返回值是`Int?`，上例中的`numberOfLegs`字典通过附属脚本返回的是一个`Int?`或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。
@ -118,7 +122,7 @@ struct Matrix {
} }
``` ```
`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。通过传入数组长度和初始值0.0到数组的一个构造器，将`Matrix`中每个元素初始值0.0。关于数组的构造方法和析构方法请参考[创建并且构造一个数组](../chapter2/04_Collection_Types.html)。 `Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。通过传入数组长度和初始值0.0到数组的一个构造器，将`Matrix`中每个元素初始值0.0。关于数组的构造方法和析构方法请参考[创建一个空数组](./04_Collection_Types.html#creating_an_empty_array)。
你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例： 你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例：

4
source/chapter2/13_Inheritance.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[Hawstein](https://github.com/Hawstein) > 翻译：[Hawstein](https://github.com/Hawstein)
> 校对：[menlongsheng](https://github.com/menlongsheng) > 校对：[menlongsheng](https://github.com/menlongsheng)
> 2.0
> 翻译+校对：[shanksyang](https://github.com/shanksyang)
# 继承（Inheritance） # 继承（Inheritance）
------------------- -------------------

23
source/chapter2/14_Initialization.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[lifedim](https://github.com/lifedim) > 翻译：[lifedim](https://github.com/lifedim)
> 校对：[lifedim](https://github.com/lifedim)，[chenmingbiao](https://github.com/chenmingbiao) > 校对：[lifedim](https://github.com/lifedim)
> 2.0
> 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
# 构造过程（Initialization） # 构造过程（Initialization）
@ -21,7 +25,7 @@
构造过程是通过定义构造器（`Initializers`）来实现的，这些构造器可以看做是用来创建特定类型实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。 构造过程是通过定义构造器（`Initializers`）来实现的，这些构造器可以看做是用来创建特定类型实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。
类的实例也可以通过定义析构器（`deinitializer`）在实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](15_Deinitialization.html)。 类的实例也可以通过定义析构器（`deinitializer`）在实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](./15_Deinitialization.html)。
<a name="setting_initial_values_for_stored_properties"></a> <a name="setting_initial_values_for_stored_properties"></a>
## 存储型属性的初始赋值 ## 存储型属性的初始赋值
@ -193,6 +197,7 @@ cheeseQuestion.response = "Yes, I do like cheese."
调查问题在问题提出之后，我们才能得到回答。所以我们将属性回答`response`声明为`String?`类型，或者说是可选字符串类型`optional String`。当`SurveyQuestion`实例化时，它将自动赋值为空`nil`，表明暂时还不存在此字符串。 调查问题在问题提出之后，我们才能得到回答。所以我们将属性回答`response`声明为`String?`类型，或者说是可选字符串类型`optional String`。当`SurveyQuestion`实例化时，它将自动赋值为空`nil`，表明暂时还不存在此字符串。
<a name="assigning_constant_properties_during_initialization"></a>
### 构造过程中常量属性的修改 ### 构造过程中常量属性的修改
只要在构造过程结束前常量的值能确定，你可以在构造过程中的任意时间点修改常量属性的值。 只要在构造过程结束前常量的值能确定，你可以在构造过程中的任意时间点修改常量属性的值。
@ -237,6 +242,7 @@ var item = ShoppingListItem()
由于`ShoppingListItem`类中的所有属性都有默认值，且它是没有父类的基类，它将自动获得一个可以为所有属性设置默认值的默认构造器（尽管代码中没有显式为`name`属性设置默认值，但由于`name`是可选字符串类型，它将默认设置为`nil`）。上面例子中使用默认构造器创造了一个`ShoppingListItem`类的实例（使用`ShoppingListItem()`形式的构造器语法），并将其赋值给变量`item`。 由于`ShoppingListItem`类中的所有属性都有默认值，且它是没有父类的基类，它将自动获得一个可以为所有属性设置默认值的默认构造器（尽管代码中没有显式为`name`属性设置默认值，但由于`name`是可选字符串类型，它将默认设置为`nil`）。上面例子中使用默认构造器创造了一个`ShoppingListItem`类的实例（使用`ShoppingListItem()`形式的构造器语法），并将其赋值给变量`item`。
<a name="memberwise_initializers_for_structure_types"></a>
### 结构体的逐一成员构造器 ### 结构体的逐一成员构造器
除上面提到的默认构造器，如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。 除上面提到的默认构造器，如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。
@ -259,14 +265,14 @@ let twoByTwo = Size(width: 2.0, height: 2.0)
构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。 构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。
构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。 构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](./13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
对于值类型，你可以使用`self.init`在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用`self.init`。 对于值类型，你可以使用`self.init`在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用`self.init`。
如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。 如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。
>注意： >注意：
假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](20_Extensions.html)章节。 假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](./20_Extensions.html)章节。
下面例子将定义一个结构体`Rect`，用来代表几何矩形。这个例子需要两个辅助的结构体`Size`和`Point`，它们各自为其所有的属性提供了初始值`0.0`。 下面例子将定义一个结构体`Rect`，用来代表几何矩形。这个例子需要两个辅助的结构体`Size`和`Point`，它们各自为其所有的属性提供了初始值`0.0`。
@ -324,7 +330,7 @@ let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
构造器`init(center:size:)`可以自己将`origin`和`size`的新值赋值到对应的属性中。然而尽量利用现有的构造器和它所提供的功能来实现`init(center:size:)`的功能，是更方便、更清晰和更直观的方法。 构造器`init(center:size:)`可以自己将`origin`和`size`的新值赋值到对应的属性中。然而尽量利用现有的构造器和它所提供的功能来实现`init(center:size:)`的功能，是更方便、更清晰和更直观的方法。
>注意： >注意：
如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](20_Extensions.html)。 如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](./20_Extensions.html)。
<a name="class_inheritance_and_initialization"></a> <a name="class_inheritance_and_initialization"></a>
## 类的继承和构造过程 ## 类的继承和构造过程
@ -361,8 +367,8 @@ convenience init(parameters) {
} }
``` ```
<a name="initialization_chain"></a> <a name="initializer_delegation_for_class_types"></a>
### 构造器链 ### 类的构造器代理规则
为了简化指定构造器和便利构造器之间的调用关系，Swift 采用以下三条规则来限制构造器之间的代理调用： 为了简化指定构造器和便利构造器之间的调用关系，Swift 采用以下三条规则来限制构造器之间的代理调用：
@ -465,6 +471,7 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造
最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。 最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。
<a name="initializer_inheritance_and_overriding"></a>
### 构造器的继承和重载 ### 构造器的继承和重载
跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。 跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。
@ -609,7 +616,7 @@ class RecipeIngredient: Food {
`RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。 `RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。
注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识。 注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识（参见[构造器的继承和重载](#initializer_inheritance_and_overriding)）。
在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。 在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。

8
source/chapter2/15_Deinitialization.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[bruce0505](https://github.com/bruce0505) > 翻译：[bruce0505](https://github.com/bruce0505)
> 校对：[fd5788](https://github.com/fd5788)，[chenmingbiao](https://github.com/chenmingbiao) > 校对：[fd5788](https://github.com/fd5788)
> 2.0
> 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
# 析构过程（Deinitialization） # 析构过程（Deinitialization）
--------------------------- ---------------------------
@ -14,7 +18,7 @@
<a name="how_deinitialization_works"></a> <a name="how_deinitialization_works"></a>
##析构过程原理 ##析构过程原理
Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](16_Automatic_Reference_Counting.html)章节中所讲述，Swift 通过`自动引用计数（ARC）`处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。 Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](./16_Automatic_Reference_Counting.html)章节中所讲述，Swift 通过`自动引用计数（ARC）`处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。
在类的定义中，每个类最多只能有一个析构器，而且析构器不带任何参数，如下所示： 在类的定义中，每个类最多只能有一个析构器，而且析构器不带任何参数，如下所示：

12
source/chapter2/16_Automatic_Reference_Counting.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[TimothyYe](https://github.com/TimothyYe) > 翻译：[TimothyYe](https://github.com/TimothyYe)
> 校对：[Hawstein](https://github.com/Hawstein) > 校对：[Hawstein](https://github.com/Hawstein)
> 2.0
> 翻译+校对：[Channe](https://github.com/Channe)
# 自动引用计数 # 自动引用计数
----------------- -----------------
@ -335,6 +339,8 @@ john = nil
最后的代码展示了在`john`变量被设为`nil`后`Customer`实例和`CreditCard`实例的构造函数都打印出了“销毁”的信息。 最后的代码展示了在`john`变量被设为`nil`后`Customer`实例和`CreditCard`实例的构造函数都打印出了“销毁”的信息。
<a name="unowned_references_and_implicitly_unwrapped_optional_properties"></a>
###无主引用以及隐式解析可选属性 ###无主引用以及隐式解析可选属性
上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。 上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。
@ -373,9 +379,9 @@ class City {
为了建立两个类的依赖关系，`City`的构造函数有一个`Country`实例的参数，并且将实例保存为`country`属性。 为了建立两个类的依赖关系，`City`的构造函数有一个`Country`实例的参数，并且将实例保存为`country`属性。
`Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化完后，`Country`的构造函数才能把`self`传给`City`的构造函数。（[在两段式构造过程中有具体描述](14_Initialization.html)） `Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化完后，`Country`的构造函数才能把`self`传给`City`的构造函数。（在[两段式构造过程](./14_Initialization.html#two_phase_initialization)中有具体描述）
为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（[在隐式解析可选类型中有描述](01_The_Basics.html)） 为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（在[隐式解析可选类型](./01_The_Basics.html#implicityly_unwrapped_optionals)中有描述）
由于`capitalCity`默认值为`nil`，一旦`Country`的实例在构造函数中给`name`属性赋值后，整个初始化过程就完成了。这代表一旦`name`属性被赋值后，`Country`的构造函数就能引用并传递隐式的`self`。`Country`的构造函数在赋值`capitalCity`时，就能将`self`作为参数传递给`City`的构造函数。 由于`capitalCity`默认值为`nil`，一旦`Country`的实例在构造函数中给`name`属性赋值后，整个初始化过程就完成了。这代表一旦`name`属性被赋值后，`Country`的构造函数就能引用并传递隐式的`self`。`Country`的构造函数在赋值`capitalCity`时，就能将`self`作为参数传递给`City`的构造函数。
@ -456,7 +462,7 @@ print(paragraph!.asHTML())
![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/closureReferenceCycle01_2x.png) ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/closureReferenceCycle01_2x.png)
实例的`asHTML`属性持有闭包的强引用。但是，闭包在其闭包体内使用了`self`（引用了`self.name`和`self.text`），因此闭包捕获了`self`，这意味着闭包又反过来持有了`HTMLElement`实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考[值捕获](07_Closures.html)）。 实例的`asHTML`属性持有闭包的强引用。但是，闭包在其闭包体内使用了`self`（引用了`self.name`和`self.text`），因此闭包捕获了`self`，这意味着闭包又反过来持有了`HTMLElement`实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考[值捕获](./07_Closures.html#capturing_values)）。
>注意: >注意:
虽然闭包多次使用了`self`，它只捕获`HTMLElement`实例的一个强引用。 虽然闭包多次使用了`self`，它只捕获`HTMLElement`实例的一个强引用。

157
source/chapter2/17_Optional_Chaining.md
View File

@ -1,8 +1,12 @@
# Optional Chaining # 可空链式调用
> 1.0
> 翻译：[Jasonbroker](https://github.com/Jasonbroker) > 翻译：[Jasonbroker](https://github.com/Jasonbroker)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[lyojo](https://github.com/lyojo)
----------------- -----------------
可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。 可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。
@ -10,74 +14,94 @@
注意： 注意：
Swift 的可空链式调用和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且能够检查调用是否成功。 Swift 的可空链式调用和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且能够检查调用是否成功。
##可空链式调用作为强制展开的另一个方案 <a name="optional_chaining_as_an_alternative_to_forced_unwrapping"></a>
##使用可空链式调用来强制展开
通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，然而强制展开将会触发运行时错误。 通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，然而强制展开将会触发运行时错误。
为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回nil则说明调用失败。 为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回`nil`则说明调用失败。
特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回Int的类型的结果将会返回Int?类型。 特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回`Int`的类型的结果将会返回`Int?`类型。
下面几段代码将解释可空链式调用和强制展开的不同。 下面几段代码将解释可空链式调用和强制展开的不同。
首先定义两个类Person和Residence。 首先定义两个类`Person`和`Residence`。
```swift
class Person { class Person {
var residence: Residence? var residence: Residence?
} }
class Residence { class Residence {
var numberOfRooms = 1 var numberOfRooms = 1
} }
```
Residence有一个Int类型的属性numberOfRooms，其默认值为1。Person具有一个可空的residence属性，其类型为Residence？。 `Residence`有一个`Int`类型的属性`numberOfRooms`，其默认值为1。`Person`具有一个可空的`residence`属性，其类型为`Residence?`。
如果创建一个新的Person实例，因为它的residence属性是可空的，john属性将初始化为nil： 如果创建一个新的`Person`实例，因为它的`residence`属性是可空的，`john`属性将初始化为`nil`：
```swift
let john = Person() let john = Person()
```
如果使用叹号（！）强制展开获得这个john的residence属性中的numberOfRooms值，会触发运行时错误，因为这时没有可以展开的residence： 如果使用叹号（！）强制展开获得这个`john`的`residence`属性中的`numberOfRooms`值，会触发运行时错误，因为这时没有可以展开的`residence`：
```swift
let roomCount = john.residence!.numberOfRooms let roomCount = john.residence!.numberOfRooms
// this triggers a runtime error // this triggers a runtime error
```
john.residence非空的时候，上面的调用成功，并且把roomCount设置为Int类型的房间数量。正如上面说到的，当residence为空的时候上面这段代码会触发运行时错误。 `john.residence`非空的时候，上面的调用成功，并且把`roomCount`设置为`Int`类型的房间数量。正如上面说到的，当`residence`为空的时候上面这段代码会触发运行时错误。
可空链式调用提供了一种另一种访问numberOfRooms的方法，使用问号（？）来代替原来叹号（！）的位置： 可空链式调用提供了一种另一种访问`numberOfRooms`的方法，使用问号（？）来代替原来叹号（！）的位置：
```swift
if let roomCount = john.residence?.numberOfRooms { if let roomCount = john.residence?.numberOfRooms {
print("John's residence has \(roomCount) room(s).") print("John's residence has \(roomCount) room(s).")
} else { } else {
print("Unable to retrieve the number of rooms.") print("Unable to retrieve the number of rooms.")
} }
// prints "Unable to retrieve the number of rooms." // prints "Unable to retrieve the number of rooms."
```
在residence后面添加问号之后，Swift就会在residence不为空的情况下访问numberOfRooms。 在`residence`后面添加问号之后，Swift就会在`residence`不为空的情况下访问`numberOfRooms`。
因为访问numberOfRooms有可能失败，可空链式调用会返回Int?类型，或称为“可空的Int”。如上例所示，当residence为nil的时候，可空的Int将会为nil，表明无法访问numberOfRooms。 因为访问`numberOfRooms`有可能失败，可空链式调用会返回`Int?`类型，或称为“可空的Int”。如上例所示，当`residence`为`nil`的时候，可空的`Int`将会为`nil`，表明无法访问`numberOfRooms`。
要注意的是，即使numberOfRooms是不可空的Int时，这一点也成立。只要是通过可空链式调用就意味着最后numberOfRooms返回一个Int？而不是Int。 要注意的是，即使`numberOfRooms`是不可空的`Int`时，这一点也成立。只要是通过可空链式调用就意味着最后`numberOfRooms`返回一个`Int?`而不是`Int`。
通过赋给john.residence一个Residence的实例变量： 通过赋给`john.residence`一个`Residence`的实例变量：
```swift
john.residence = Residence() john.residence = Residence()
这样john.residence不为nil了。现在就可以正常访问john.residence.numberOfRooms，其值为默认的1，类型为Int?： ```
这样`john.residence`不为`nil`了。现在就可以正常访问`john.residence.numberOfRooms`，其值为默认的1，类型为`Int?`：
```swift
if let roomCount = john.residence?.numberOfRooms { if let roomCount = john.residence?.numberOfRooms {
print("John's residence has \(roomCount) room(s).") print("John's residence has \(roomCount) room(s).")
} else { } else {
print("Unable to retrieve the number of rooms.") print("Unable to retrieve the number of rooms.")
} }
// prints "John's residence has 1 room(s)." // prints "John's residence has 1 room(s)."
```
##为可空链式调用定义模型类 ##为可空链式调用定义模型类
通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。并且判断能否访问子属性的属性，方法或下标。 通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。并且判断能否访问子属性的属性，方法或下标。
下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在Person和Residence的基础上增加了Room和Address，以及相关的属性，方法以及下标。 下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在`Person`和`Residence`的基础上增加了`Room`和`Address`，以及相关的属性，方法以及下标。
Person类定义基本保持不变： Person类定义基本保持不变：
```swift
class Person { class Person {
var residence: Residence? var residence: Residence?
} }
Residence类比之前复杂些，增加了一个Room类型的空数组room： ```
`Residence`类比之前复杂些，增加了一个`Room`类型的空数组`room`：
```swift
class Residence { class Residence {
var rooms = [Room]() var rooms = [Room]()
var numberOfRooms: Int { var numberOfRooms: Int {
@ -96,17 +120,22 @@ Residence类比之前复杂些，增加了一个Room类型的空数组room：
} }
var address: Address? var address: Address?
} }
```
现在Residence有了一个存储Room类型的数组，numberOfRooms属性需要计算，而不是作为单纯的变量。计算后的numberOfRooms返回rooms数组的count属性值。现在的Residence还提供访问rooms数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供printNumberOfRooms方法，这个方法的作用就是输出这个房子中房间的数量。最后，Residence定义了一个可空属性address，其类型为Address?。Address类的定义在下面会说明。 现在`Residence`有了一个存储`Room`类型的数组，`numberOfRooms`属性需要计算，而不是作为单纯的变量。计算后的`numberOfRooms`返回`rooms`数组的`count`属性值。现在的`Residence`还提供访问`rooms`数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供`printNumberOfRooms`方法，这个方法的作用就是输出这个房子中房间的数量。最后，`Residence`定义了一个可空属性`address`，其类型为`Address?`。`Address`类的定义在下面会说明。
类Room是一个简单类，只包含一个属性name，以及一个初始化函数： 类`Room`是一个简单类，只包含一个属性`name`，以及一个初始化函数：
```swift
class Room { class Room {
let name: String let name: String
init(name: String) { self.name = name } init(name: String) { self.name = name }
} }
最后一个类是Address，这个类有三个String?类型的可空属性。buildingName以及buildingNumber属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称： ```
最后一个类是`Address`，这个类有三个`String?`类型的可空属性。`buildingName`以及`buildingNumber`属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称：
```swift
class Address { class Address {
var buildingName: String? var buildingName: String?
var buildingNumber: String? var buildingNumber: String?
@ -121,13 +150,16 @@ Residence类比之前复杂些，增加了一个Room类型的空数组room：
} }
} }
} }
类Address提供buildingIdentifier()方法，返回值为String?。 如果buildingName不为空则返回buildingName， 如果buildingNumber不为空则返回buildingNumber。如果这两个属性都为空则返回nil。 ```
类`Address`提供`buildingIdentifier()`方法，返回值为`String?`。 如果`buildingName`不为空则返回`buildingName`， 如果`buildingNumber`不为空则返回`buildingNumber`。如果这两个属性都为空则返回`nil`。
##通过可空链式调用访问属性 ##通过可空链式调用访问属性
正如[可空链式调用作为强制展开的另一个方案]中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。 正如[使用可空链式调用来强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping)中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。
下面的代码创建了一个Person实例，然后访问numberOfRooms属性： 下面的代码创建了一个`Person`实例，然后访问`numberOfRooms`属性：
```swift
let john = Person() let john = Person()
if let roomCount = john.residence?.numberOfRooms { if let roomCount = john.residence?.numberOfRooms {
print("John's residence has \(roomCount) room(s).") print("John's residence has \(roomCount) room(s).")
@ -135,41 +167,55 @@ Residence类比之前复杂些，增加了一个Room类型的空数组room：
print("Unable to retrieve the number of rooms.") print("Unable to retrieve the number of rooms.")
} }
// prints "Unable to retrieve the number of rooms." // prints "Unable to retrieve the number of rooms."
因为john.residence为nil，所以毫无疑问这个可空链式调用失败。 ```
因为`john.residence`为`nil`，所以毫无疑问这个可空链式调用失败。
通过可空链式调用来设定属性值： 通过可空链式调用来设定属性值：
```swift
let someAddress = Address() let someAddress = Address()
someAddress.buildingNumber = "29" someAddress.buildingNumber = "29"
someAddress.street = "Acacia Road" someAddress.street = "Acacia Road"
john.residence?.address = someAddress john.residence?.address = someAddress
在这个例子中，通过john.residence来设定address属性也是不行的，因为john.residence为nil。 ```
在这个例子中，通过`john.residence`来设定`address`属性也是不行的，因为`john.residence`为`nil`。
##通过可空链式调用来调用方法 ##通过可空链式调用来调用方法
可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。 可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值： `Residence`中的`printNumberOfRooms()`方法输出当前的`numberOfRooms`值：
```swift
func printNumberOfRooms() { func printNumberOfRooms() {
print("The number of rooms is \(numberOfRooms)") print("The number of rooms is \(numberOfRooms)")
} }
这个方法没有返回值。但是没有返回值的方法隐式返回Void类型，如[无返回值函数](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID163)中所述。这意味着没有返回值的方法也会返回()或者空的元组。 ```
如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为Void?，而不是Void，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用if语句来判断能否成功调用printNumberOfRooms()方法，即使方法本身没有定义返回值。通过返回值是否为nil可以判断调用是否成功： 这个方法没有返回值。但是没有返回值的方法隐式返回`Void`类型，如[无返回值函数](./06_Functions.html#functions_without_return_values)中所述。这意味着没有返回值的方法也会返回()或者空的元组。
如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为`Void?`，而不是`Void`，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用`if`语句来判断能否成功调用`printNumberOfRooms()`方法，即使方法本身没有定义返回值。通过返回值是否为`nil`可以判断调用是否成功：
```swift
if john.residence?.printNumberOfRooms() != nil { if john.residence?.printNumberOfRooms() != nil {
print("It was possible to print the number of rooms.") print("It was possible to print the number of rooms.")
} else { } else {
print("It was not possible to print the number of rooms.") print("It was not possible to print the number of rooms.")
} }
// prints "It was not possible to print the number of rooms." // prints "It was not possible to print the number of rooms."
同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给john.residence中的address属性赋值，即使residence为nil。通过可空链式调用给属性赋值会返回Void?，通过判断返回值是否为nil可以知道赋值是否成功： ```
同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给`john.residence`中的`address`属性赋值，即使`residence`为`nil`。通过可空链式调用给属性赋值会返回`Void?`，通过判断返回值是否为`nil`可以知道赋值是否成功：
```swift
if (john.residence?.address = someAddress) != nil { if (john.residence?.address = someAddress) != nil {
print("It was possible to set the address.") print("It was possible to set the address.")
} else { } else {
print("It was not possible to set the address.") print("It was not possible to set the address.")
} }
// prints "It was not possible to set the address." // prints "It was not possible to set the address."
```
##通过可空链式调用来访问下标 ##通过可空链式调用来访问下标
通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。 通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。
@ -177,44 +223,57 @@ Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值：
注意： 注意：
当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。可空链式调用的问号一般直接跟在可空表达式的后面。 当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。可空链式调用的问号一般直接跟在可空表达式的后面。
下面这个例子用下标访问john.residence中rooms数组中第一个房间的名称，因为john.residence为nil，所以下标调用毫无疑问失败了： 下面这个例子用下标访问`john.residence`中`rooms`数组中第一个房间的名称，因为`john.residence`为`nil`，所以下标调用毫无疑问失败了：
```swift
if let firstRoomName = john.residence?[0].name { if let firstRoomName = john.residence?[0].name {
print("The first room name is \(firstRoomName).") print("The first room name is \(firstRoomName).")
} else { } else {
print("Unable to retrieve the first room name.") print("Unable to retrieve the first room name.")
} }
// prints "Unable to retrieve the first room name." // prints "Unable to retrieve the first room name."
在这个例子中，问号直接放在john.residence的后面，并且在方括号的前面，因为john.residence是可空值。 ```
在这个例子中，问号直接放在`john.residence`的后面，并且在方括号的前面，因为`john.residence`是可空值。
类似的，可以通过下标，用可空链式调用来赋值： 类似的，可以通过下标，用可空链式调用来赋值：
```swift
john.residence?[0] = Room(name: "Bathroom") john.residence?[0] = Room(name: "Bathroom")
```
这次赋值同样会失败，因为`residence`目前是`nil`。 这次赋值同样会失败，因为`residence`目前是`nil`。
如果你创建一个Residence实例，添加一些Room实例并赋值给john.residence，那就可以通过可选链和下标来访问数组中的元素： 如果你创建一个`Residence`实例，添加一些`Room`实例并赋值给`john.residence`，那就可以通过可选链和下标来访问数组中的元素：
```swift
let johnsHouse = Residence() let johnsHouse = Residence()
johnsHouse.rooms.append(Room(name: "Living Room")) johnsHouse.rooms.append(Room(name: "Living Room"))
johnsHouse.rooms.append(Room(name: "Kitchen")) johnsHouse.rooms.append(Room(name: "Kitchen"))
john.residence = johnsHouse john.residence = johnsHouse
if let firstRoomName = john.residence?[0].name { if let firstRoomName = john.residence?[0].name {
print("The first room name is \(firstRoomName).") print("The first room name is \(firstRoomName).")
} else { } else {
print("Unable to retrieve the first room name.") print("Unable to retrieve the first room name.")
} }
// prints "The first room name is Living Room." // prints "The first room name is Living Room."
```
##访问可空类型的下标： ##访问可空类型的下标：
如果下标返回可空类型值，比如Swift中Dictionary的key下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值： 如果下标返回可空类型值，比如Swift中`Dictionary`的`key`下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值：
```swift
var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]] var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
testScores["Dave"]?[0] = 91 testScores["Dave"]?[0] = 91
testScores["Bev"]?[0]++ testScores["Bev"]?[0]++
testScores["Brian"]?[0] = 72 testScores["Brian"]?[0] = 72
// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81] // the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]
上面的例子中定义了一个testScores数组，包含了两个键值对， 把String类型的key映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个key存在。但是key“Brian”在字典中不存在，所以第三个调用失败。 ```
上面的例子中定义了一个`testScores`数组，包含了两个键值对， 把`String`类型的`key`映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个`key`存在。但是key“Brian”在字典中不存在，所以第三个调用失败。
##多层链接 ##多层链接
可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。 可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。
@ -226,24 +285,27 @@ john.residence?[0] = Room(name: "Bathroom")
因此： 因此：
+ 通过可空链式调用访问一个Int值，将会返回Int？，不过进行了多少次可空链式调用。 + 通过可空链式调用访问一个`Int`值，将会返回`Int?`，不过进行了多少次可空链式调用。
+ 类似的，通过可空链式调用访问Int?值，并不会变得更加可空。 + 类似的，通过可空链式调用访问`Int?`值，并不会变得更加可空。
下面的例子访问john中的residence中的address中的street属性。这里使用了两层可空链式调用，residence以及address，这两个都是可空值。 下面的例子访问`john`中的`residence`中的`address`中的`street`属性。这里使用了两层可空链式调用，`residence`以及`address`，这两个都是可空值。
```swift
if let johnsStreet = john.residence?.address?.street { if let johnsStreet = john.residence?.address?.street {
print("John's street name is \(johnsStreet).") print("John's street name is \(johnsStreet).")
} else { } else {
print("Unable to retrieve the address.") print("Unable to retrieve the address.")
} }
// prints "Unable to retrieve the address." // prints "Unable to retrieve the address."
```
john.residence包含Residence实例，但是john.residence.address为nil。因此，不能访问john.residence?.address?.street。 `john.residence`包含`Residence`实例，但是`john.residence.address`为`nil`。因此，不能访问`john.residence?.address?.street`。
需要注意的是，上面的例子中，street的属性为String?。john.residence?.address?.street的返回值也依然是String?，即使已经进行了两次可空的链式调用。 需要注意的是，上面的例子中，`street`的属性为`String?`。`john.residence?.address?.street`的返回值也依然是`String?`，即使已经进行了两次可空的链式调用。
如果把john.residence.address指向一个实例，并且为address中的street属性赋值，我们就能过通过可空链式调用来访问street属性。 如果把`john.residence.address`指向一个实例，并且为`address`中的`street`属性赋值，我们就能过通过可空链式调用来访问`street`属性。
```swift
let johnsAddress = Address() let johnsAddress = Address()
johnsAddress.buildingName = "The Larches" johnsAddress.buildingName = "The Larches"
johnsAddress.street = "Laurel Street" johnsAddress.street = "Laurel Street"
@ -255,20 +317,25 @@ john.residence包含Residence实例，但是john.residence.address为nil。因
print("Unable to retrieve the address.") print("Unable to retrieve the address.")
} }
// prints "John's street name is Laurel Street." // prints "John's street name is Laurel Street."
在上面的例子中，因为john.residence是一个可用的Residence实例，所以对john.residence的address属性赋值成功。 ```
在上面的例子中，因为`john.residence`是一个可用的`Residence`实例，所以对`john.residence`的`address`属性赋值成功。
##对返回可空值的函数进行链接 ##对返回可空值的函数进行链接
上面的例子说明了如何通过可空链式调用来获取可空属性值。我们还可以通过可空链式调用来调用返回可空值的方法，并且可以继续对可空值进行链接。 上面的例子说明了如何通过可空链式调用来获取可空属性值。我们还可以通过可空链式调用来调用返回可空值的方法，并且可以继续对可空值进行链接。
在下面的例子中，通过可空链式调用来调用Address的buildingIdentifier()方法。这个方法返回String?类型。正如上面所说，通过可空链式调用的方法的最终返回值还是String?： 在下面的例子中，通过可空链式调用来调用`Address`的`buildingIdentifier()`方法。这个方法返回`String?`类型。正如上面所说，通过可空链式调用的方法的最终返回值还是`String?`：
```swift
if let buildingIdentifier = john.residence?.address?.buildingIdentifier() { if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
print("John's building identifier is \(buildingIdentifier).") print("John's building identifier is \(buildingIdentifier).")
} }
// prints "John's building identifier is The Larches." // prints "John's building identifier is The Larches."
```
如果要进一步对方法的返回值进行可空链式调用，在方法buildingIdentifier()的圆括号后面加上问号： 如果要进一步对方法的返回值进行可空链式调用，在方法`buildingIdentifier()`的圆括号后面加上问号：
```swift
if let beginsWithThe = if let beginsWithThe =
john.residence?.address?.buildingIdentifier()?.hasPrefix("The") { john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
if beginsWithThe { if beginsWithThe {
@ -278,6 +345,8 @@ john.residence包含Residence实例，但是john.residence.address为nil。因
} }
} }
// prints "John's building identifier begins with "The"." // prints "John's building identifier begins with "The"."
```
> >
注意： 注意：
在上面的例子中在，在方法的圆括号后面加上问号是因为buildingIdentifier()的返回值是可空值，而不是方法本身是可空的。 在上面的例子中在，在方法的圆括号后面加上问号是因为`buildingIdentifier()`的返回值是可空值，而不是方法本身是可空的。

76
source/chapter2/18_Error_Handling.md
View File

@ -1,3 +1,6 @@
> 2.0
> 翻译+校对：[lyojo](https://github.com/lyojo)
# 错误处理 # 错误处理
----------------- -----------------
错误处理是响应错误以及从错误中返回的过程。swift提供第一类错误支持，包括在运行时抛出，捕获，传送和控制可回收错误。 错误处理是响应错误以及从错误中返回的过程。swift提供第一类错误支持，包括在运行时抛出，捕获，传送和控制可回收错误。
@ -7,50 +10,62 @@
举个例子，考虑到一个从磁盘上的一个文件读取以及处理数据的任务，有几种情况可能会导致这个任务失败，包括指定路径的文件不存在，文件不具有可读属性，或者文件没有被编码成合适的格式。区分这些错误可以让程序解决并且修复这些错误，并且，如果可能的话，把这些错误报告给用户。 举个例子，考虑到一个从磁盘上的一个文件读取以及处理数据的任务，有几种情况可能会导致这个任务失败，包括指定路径的文件不存在，文件不具有可读属性，或者文件没有被编码成合适的格式。区分这些错误可以让程序解决并且修复这些错误，并且，如果可能的话，把这些错误报告给用户。
> >
NOTE： 注意：
Swift中的错误处理涉及到错误处理样式，这会用到Cocoa中的NSError和Objective-C。更多信息请参见：[Error Handling](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)中的[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。 Swift中的错误处理涉及到错误处理样式，这会用到Cocoa中的NSError和Objective-C。更多信息请参见：[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)中的[错误处理](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)。
###错误的表示： ###错误的表示：
在Swift中，错误用符合ErrorType协议的值表示。 在Swift中，错误用符合`ErrorType`协议的值表示。
Swift枚举特别适合把一系列相关的错误组合在一起，同时可以把一些相关的值和错误关联在一起。因此编译器会为实现ErrorType协议的Swift枚举类型自动实现相应合成。 Swift枚举特别适合把一系列相关的错误组合在一起，同时可以把一些相关的值和错误关联在一起。因此编译器会为实现`ErrorType`协议的Swift枚举类型自动实现相应合成。
比如说，你可以这样表示操作自动贩卖机会出现的错误： 比如说，你可以这样表示操作自动贩卖机会出现的错误：
```swift
enum VendingMachineError: ErrorType { enum VendingMachineError: ErrorType {
case InvalidSelection case InvalidSelection
case InsufficientFunds(required: Double) case InsufficientFunds(required: Double)
case OutOfStock case OutOfStock
} }
```
在这种情况下，自动贩卖机可能会因为以下原因失败： 在这种情况下，自动贩卖机可能会因为以下原因失败：
请求的物品不存在，用InvalidSelection表示。 请求的物品不存在，用`InvalidSelection`表示。
请求的物品的价格高于已投入金额，用InsufficientFunds表示。相关的双精度值表示还需要多少钱来完成此次交易。 请求的物品的价格高于已投入金额，用`InsufficientFunds`表示。相关的双精度值表示还需要多少钱来完成此次交易。
请求的物品已经卖完了，用OutOfStock表示。 请求的物品已经卖完了，用`OutOfStock`表示。
<a name="throwing_errors"></a>
错误抛出 错误抛出
通过在函数或方法声明的参数后面加上throws关键字，表明这个函数或方法可以抛出错误。如果指定一个返回值，可以把throws关键字放在返回箭头(->)的前面。除非明确地指出，一个函数，方法或者就闭包不能抛出错误。 通过在函数或方法声明的参数后面加上`throws`关键字，表明这个函数或方法可以抛出错误。如果指定一个返回值，可以把`throws`关键字放在返回箭头(->)的前面。除非明确地指出，一个函数，方法或者就闭包不能抛出错误。
```swift
func canThrowErrors() throws -> String func canThrowErrors() throws -> String
func cannotThrowErrors() -> String func cannotThrowErrors() -> String
```
在抛出函数体的任意一个地方，可以通过throw语句抛出错误。在下面的例子中，如果请求的物品不存在，或者卖完了，或者超出投入金额，vend(itemNamed:)函数会抛出一个错误： 在抛出函数体的任意一个地方，可以通过`throw`语句抛出错误。在下面的例子中，如果请求的物品不存在，或者卖完了，或者超出投入金额，`vend(itemNamed:)`函数会抛出一个错误：
```swift
struct Item { struct Item {
var price: Double var price: Double
var count: Int var count: Int
} }
var inventory = [ var inventory = [
"Candy Bar": Item(price: 1.25, count: 7), "Candy Bar": Item(price: 1.25, count: 7),
"Chips": Item(price: 1.00, count: 4), "Chips": Item(price: 1.00, count: 4),
"Pretzels": Item(price: 0.75, count: 11) "Pretzels": Item(price: 0.75, count: 11)
] ]
var amountDeposited = 1.00 var amountDeposited = 1.00
func vend(itemNamed name: String) throws { func vend(itemNamed name: String) throws {
guard var item = inventory[name] else { guard var item = inventory[name] else {
throw VendingMachineError.InvalidSelection throw VendingMachineError.InvalidSelection
} }
guard item.count > 0 else { guard item.count > 0 else {
throw VendingMachineError.OutOfStock throw VendingMachineError.OutOfStock
} }
if amountDeposited >= item.price { if amountDeposited >= item.price {
// Dispense the snack // Dispense the snack
amountDeposited -= item.price amountDeposited -= item.price
@ -61,10 +76,13 @@ Swift枚举特别适合把一系列相关的错误组合在一起，同时可以
throw VendingMachineError.InsufficientFunds(required: amountRequired) throw VendingMachineError.InsufficientFunds(required: amountRequired)
} }
} }
首先，guard语句用来把绑定item常量和count变量到在库存中对应的值。如果物品不在库存中，将会抛出InvalidSelection错误。然后，物品是否可获取有物品的剩余数量决定。如果count小于等于0，将会抛出OutOfStock错误。最后，把请求物品的价格和已经投入的金额进行比较，如果如果投入的金额大于物品的价格，将会从投入的金额从减去物品的价格，然后库存中该物品的数量减1，然后返回请求的物品。否则，将会计算还需要多少钱，然后把这个值作为InsufficientFunds错误的关联值。因为throw语句会马上改变程序流程，当所有的购买条件（物品存在，库存足够以及投入金额足够）都满足的时候，物品才会出售。 ```
当调用一个抛出函数的时候，在调用前面加上try。这个关键字表明函数可以抛出错误，而且在try后面代码将不会执行。 首先，`guard`语句用来把绑定`item`常量和`count`变量到在库存中对应的值。如果物品不在库存中，将会抛出`InvalidSelection`错误。然后，物品是否可获取有物品的剩余数量决定。如果`count`小于等于0，将会抛出`OutOfStock`错误。最后，把请求物品的价格和已经投入的金额进行比较，如果如果投入的金额大于物品的价格，将会从投入的金额从减去物品的价格，然后库存中该物品的数量减1，然后返回请求的物品。否则，将会计算还需要多少钱，然后把这个值作为`InsufficientFunds`错误的关联值。因为`throw`语句会马上改变程序流程，当所有的购买条件（物品存在，库存足够以及投入金额足够）都满足的时候，物品才会出售。
当调用一个抛出函数的时候，在调用前面加上`try`。这个关键字表明函数可以抛出错误，而且在`try`后面代码将不会执行。
```swift
let favoriteSnacks = [ let favoriteSnacks = [
"Alice": "Chips", "Alice": "Chips",
"Bob": "Licorice", "Bob": "Licorice",
@ -74,11 +92,14 @@ Swift枚举特别适合把一系列相关的错误组合在一起，同时可以
let snackName = favoriteSnacks[person] ?? "Candy Bar" let snackName = favoriteSnacks[person] ?? "Candy Bar"
try vend(itemNamed: snackName) try vend(itemNamed: snackName)
} }
buyFavoriteSnack(_:) 函数查找某个人的最喜欢的零食，然后尝试买给他。如果这个人在列表中没有喜欢的零食，就会购买Candy Bar。这个函数会调用vend函数，vend函数可能会抛出错误，所以在vend前面加上了try关键字。因为buyFavoriteSnack函数也是一个抛出函数，所以vend函数抛出的任何错误都会向上传递到buyFavoriteSnack被调用的地方。 ```
`buyFavoriteSnack(_:)` 函数查找某个人的最喜欢的零食，然后尝试买给他。如果这个人在列表中没有喜欢的零食，就会购买`Candy Bar`。这个函数会调用`vend`函数，`vend`函数可能会抛出错误，所以在`vend`前面加上了`try`关键字。因为`buyFavoriteSnack`函数也是一个抛出函数，所以`vend`函数抛出的任何错误都会向上传递到`buyFavoriteSnack`被调用的地方。
###捕捉和处理错误 ###捕捉和处理错误
使用do-catch语句来就捕获和处理错误 使用do-catch语句来就捕获和处理错误
```swift
do { do {
try function that throws try function that throws
@ -90,10 +111,13 @@ buyFavoriteSnack(_:) 函数查找某个人的最喜欢的零食，然后尝试
statements statements
} }
如果一个错误被抛出了，这个错误会被传递到外部域，直到被一个catch分句处理。一个catch分句包含一个catch关键字，跟着一个pattern来匹配错误和相应的执行语句。 ```
类似switch语句，编译器会检查catch分句是否能够处理全部错误。如果能够处理所有错误情况，就认为这个错误被完全处理。否者，包含这个抛出函数的所在域就要处理这个错误，或者包含这个抛出函数的函数也用throws声明。为了保证错误被处理，用一个带pattern的catch分句来匹配所有错误。如果一个catch分句没有指定样式，这个分句会匹配并且绑定任何错误到一个本地error常量。更多关于pattern的信息，参见[Patterns](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/doc/uid/TP40014097-CH36-ID419)。 如果一个错误被抛出了，这个错误会被传递到外部域，直到被一个`catch`分句处理。一个`catch`分句包含一个`catch`关键字，跟着一个`pattern`来匹配错误和相应的执行语句。
类似`switch`语句，编译器会检查`catch`分句是否能够处理全部错误。如果能够处理所有错误情况，就认为这个错误被完全处理。否者，包含这个抛出函数的所在域就要处理这个错误，或者包含这个抛出函数的函数也用`throws`声明。为了保证错误被处理，用一个带`pattern`的`catch`分句来匹配所有错误。如果一个`catch`分句没有指定样式，这个分句会匹配并且绑定任何错误到一个本地`error`常量。更多关于`pattern`的信息，参见[模式](../chapter3/07_Patterns.html)。
```swift
do { do {
try vend(itemNamed: "Candy Bar") try vend(itemNamed: "Candy Bar")
// Enjoy delicious snack // Enjoy delicious snack
@ -104,29 +128,37 @@ buyFavoriteSnack(_:) 函数查找某个人的最喜欢的零食，然后尝试
} catch VendingMachineError.InsufficientFunds(let amountRequired) { } catch VendingMachineError.InsufficientFunds(let amountRequired) {
print("Insufficient funds. Please insert an additional $\(amountRequired).") print("Insufficient funds. Please insert an additional $\(amountRequired).")
} }
```
在上面的例子中，vend(itemNamed:) 函数在try表达式中被调用，因为这个函数会抛出错误。如果抛出了错误，程序执行流程马上转到catch分句，在catch分句中确定错误传递是否继续传送。如果没有抛出错误，将会执行在do语句中剩余的语句。 在上面的例子中，`vend(itemNamed:)` 函数在`try`表达式中被调用，因为这个函数会抛出错误。如果抛出了错误，程序执行流程马上转到`catch`分句，在`catch`分句中确定错误传递是否继续传送。如果没有抛出错误，将会执行在`do`语句中剩余的语句。
###禁止错误传送 > 注意：Swift中的错误处理和其他语言中的异常处理很像，使用了`try`、`catch`和`throw`关键字。但是和这些语言——包括Objective-C——不同的是，Swift不会展开调用堆栈，那会带来很大的性能损耗。因此，在Swift中`throw`语句的性能可以做到几乎和`return`语句一样。
在运行时，有几种情况抛出函数事实上是不会抛出错误的。在这几种情况下，你可以用forced-try表达式来调用抛出函数或方法，即使用try!来代替try。
通过try!来调用抛出函数或方法禁止了错误传送，并且把调用包装在运行时断言，这样就不会抛出错误。如果错误真的抛出了，会触发运行时错误。 ###禁止错误传播
在运行时，有几种情况抛出函数事实上是不会抛出错误的。在这几种情况下，你可以用`forced-try`表达式来调用抛出函数或方法，即使用`try!`来代替`try`。
通过`try!`来调用抛出函数或方法禁止了错误传送，并且把调用包装在运行时断言，这样就不会抛出错误。如果错误真的抛出了，会触发运行时错误。
```swift
func willOnlyThrowIfTrue(value: Bool) throws { func willOnlyThrowIfTrue(value: Bool) throws {
if value { throw someError } if value { throw someError }
} }
do { do {
try willOnlyThrowIfTrue(false) try willOnlyThrowIfTrue(false)
} catch { } catch {
// Handle Error // Handle Error
} }
try! willOnlyThrowIfTrue(false) try! willOnlyThrowIfTrue(false)
```
###收尾操作 ###收尾操作
使用defer语句来在执行一系列的语句。这样不管有没有错误发生，都可以执行一些必要的收尾操作。包括关闭打开的文件描述符以及释放所有手动分配的内存。 使用defer语句来在执行一系列的语句。这样不管有没有错误发生，都可以执行一些必要的收尾操作。包括关闭打开的文件描述符以及释放所有手动分配的内存。
defer语句把执行推迟到退出当前域的时候。defer语句包括defer关键字以及后面要执行的语句。被推迟的语句可能不包含任何将执行流程转移到外部的代码，比如break或者return语句，或者通过抛出一个错误。被推迟的操作的执行的顺序和他们定义的顺序相反，也就是说，在第一个defer语句中的代码在第二个defer语句中的代码之后执行。 `defer`语句把执行推迟到退出当前域的时候。`defer`语句包括`defer`关键字以及后面要执行的语句。被推迟的语句可能不包含任何将执行流程转移到外部的代码，比如`break`或者`return`语句，或者通过抛出一个错误。被推迟的操作的执行的顺序和他们定义的顺序相反，也就是说，在第一个`defer`语句中的代码在第二个`defer`语句中的代码之后执行。
```swift
func processFile(filename: String) throws { func processFile(filename: String) throws {
if exists(filename) { if exists(filename) {
let file = open(filename) let file = open(filename)
@ -134,9 +166,11 @@ defer语句把执行推迟到退出当前域的时候。defer语句包括defer
close(file) close(file)
} }
while let line = try file.readline() { while let line = try file.readline() {
/* Work with the file. */ // Work with the file.
} }
// close(file) is called here, at the end of the scope. // close(file) is called here, at the end of the scope.
} }
} }
上面这个例子使用了defer语句来保证open有对应的close。这个调用不管是否有抛出都会执行。 ```
上面这个例子使用了`defer`语句来保证`open`有对应的`close`。这个调用不管是否有抛出都会执行。

6
source/chapter2/19_Nested_Types.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[Lin-H](https://github.com/Lin-H) > 翻译：[Lin-H](https://github.com/Lin-H)
> 校对：[shinyzhu](https://github.com/shinyzhu) > 校对：[shinyzhu](https://github.com/shinyzhu)
> 2.0
> 翻译+校对：[SergioChan](https://github.com/SergioChan)
# 嵌套类型 # 嵌套类型
----------------- -----------------
@ -72,7 +76,7 @@ struct BlackjackCard {
`BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。 `BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。
因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[Memberwise Initializers for Structure Types](https://github.com/CocoaChina-editors/Welcome-to-Swift/blob/master/The%20Swift%20Programming%20Language/02Language%20Guide/14Initialization.md)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`: 因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[结构体的逐一成员构造器](./14_Initialization.html#memberwise_initializers_for_structure_types)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`:
```swift ```swift
let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades) let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades)

9
source/chapter2/20_Type_Casting.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[xiehurricane](https://github.com/xiehurricane) > 翻译：[xiehurricane](https://github.com/xiehurricane)
> 校对：[happyming](https://github.com/happyming) [yangsiy](https://github.com/yangsiy) > 校对：[happyming](https://github.com/happyming)
> 2.0
> 翻译+校对：[yangsiy](https://github.com/yangsiy)
# 类型转换（Type Casting） # 类型转换（Type Casting）
----------------- -----------------
@ -16,7 +20,7 @@ _类型转换_可以判断实例的类型，也可以将实例看做是其父类
类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。 类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
你也可以用它来检查一个类是否实现了某个协议，就像在 [Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。 你也可以用它来检查一个类是否实现了某个协议，就像在 [检验协议的一致性](./22_Protocols.html#checking_for_protocol_conformance)部分讲述的一样。
<a name="defining_a_class_hierarchy_for_type_casting"></a> <a name="defining_a_class_hierarchy_for_type_casting"></a>
## 定义一个类层次作为例子 ## 定义一个类层次作为例子
@ -155,6 +159,7 @@ Swift为不确定类型提供了两种特殊类型别名：
> 注意： > 注意：
> 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。 > 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
<a name="anyobject"></a>
### `AnyObject`类型 ### `AnyObject`类型
当在工作中使用 Cocoa APIs，我们一般会接收一个`[AnyObject]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以从 API 提供的信息中清晰地确定数组中对象的类型。 当在工作中使用 Cocoa APIs，我们一般会接收一个`[AnyObject]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以从 API 提供的信息中清晰地确定数组中对象的类型。

12
source/chapter2/21_Extensions.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[lyuka](https://github.com/lyuka) > 翻译：[lyuka](https://github.com/lyuka)
> 校对：[Hawstein](https://github.com/Hawstein) > 校对：[Hawstein](https://github.com/Hawstein)
> 2.0
> 翻译+校对：[shanksyang](https://github.com/shanksyang)
#扩展（Extensions） #扩展（Extensions）
---- ----
@ -25,7 +29,7 @@ Swift 中的扩展可以：
- 使一个已有类型符合某个协议 - 使一个已有类型符合某个协议
TODO： TODO：
在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](#)获取更多的细节。 在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./Protocols.html#protocol_extensions)获取更多的细节。
>注意： >注意：
扩展可以对一个类型添加新的功能，但是不能重写已有的功能。 扩展可以对一个类型添加新的功能，但是不能重写已有的功能。
@ -48,7 +52,7 @@ extension SomeType: SomeProtocol, AnotherProctocol {
} }
``` ```
按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](21_Protocols.html#adding_protocol_conformance_with_an_extension) 按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](./21_Protocols.html#adding_protocol_conformance_with_an_extension)
>注意： >注意：
如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。 如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
@ -101,7 +105,7 @@ print("A marathon is \(aMarathon) meters long")
> 注意： > 注意：
如果你使用扩展向一个值类型添加一个构造器，在该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers）时，你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。 如果你使用扩展向一个值类型添加一个构造器，在该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers）时，你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
> >
正如在[值类型的构造器代理](14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。 正如在[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值： 下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值：
@ -117,7 +121,7 @@ struct Rect {
var size = Size() var size = Size()
} }
``` ```
因为结构体`Rect`提供了其所有属性的默认值，所以正如[默认构造器](14_Initialization.html#default_initializers)中描述的，它可以自动接受一个默认构造器和一个逐一成员构造器。这些构造器可以用于构造新的`Rect`实例： 因为结构体`Rect`提供了其所有属性的默认值，所以正如[默认构造器](./14_Initialization.html#default_initializers)中描述的，它可以自动接受一个默认构造器和一个逐一成员构造器。这些构造器可以用于构造新的`Rect`实例：
```swift ```swift
let defaultRect = Rect() let defaultRect = Rect()

26
source/chapter2/22_Protocols.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[geek5nan](https://github.com/geek5nan) > 翻译：[geek5nan](https://github.com/geek5nan)
> 校对：[dabing1022](https://github.com/dabing1022) > 校对：[dabing1022](https://github.com/dabing1022)
> 2.0
> 翻译+校对：[futantan](https://github.com/futantan)
# 协议 # 协议
----------------- -----------------
@ -170,7 +174,7 @@ print("And another one: \(generator.random())")
<a name="mutating_method_requirements"></a> <a name="mutating_method_requirements"></a>
## 对Mutating方法的规定 ## 对Mutating方法的规定
有时需要在方法中改变它的实例。例如，值类型(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改它所属的实例及其实例属性的值。这一过程在[Modifyting Value Types from Within Instance Methods](TODO)章节中有详细描述。 有时需要在方法中改变它的实例。例如，值类型(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改它所属的实例及其实例属性的值。这一过程在[在实例方法中修改值类型](./11_Methods.html#modifying_value_types_from_within_instance_methods)章节中有详细描述。
如果你在协议中定义了一个方法旨在改变遵循该协议的实例，那么在协议定义时需要在方法前加`mutating`关键字。这使得结构和枚举遵循协议并满足此方法要求。 如果你在协议中定义了一个方法旨在改变遵循该协议的实例，那么在协议定义时需要在方法前加`mutating`关键字。这使得结构和枚举遵循协议并满足此方法要求。
@ -234,12 +238,10 @@ class SomeClass: SomeProtocol {
使用`required`修饰符可以保证：所有的遵循该协议的子类，同样能为构造器规定提供一个显式的实现或继承实现。 使用`required`修饰符可以保证：所有的遵循该协议的子类，同样能为构造器规定提供一个显式的实现或继承实现。
<!--TODO 参考链接--> 关于`required`构造器的更多内容，请参考[必要构造器](./14_Initialization.html#required_initializers)。
关于`required`构造器的更多内容，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_454">`Required`构造器 </a>
<!--TODO 参考链接-->
>注意 >注意
>如果类已经被标记为`final`，那么不需要在协议构造器的实现中使用`required`修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_339">防止重写</a> >如果类已经被标记为`final`，那么不需要在协议构造器的实现中使用`required`修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见[防止重写](./13_Inheritance.html#preventing_overrides)。
如果一个子类重写了父类的指定构造器，并且该构造器遵循了某个协议的规定，那么该构造器的实现需要被同时标示`required`和`override`修饰符 如果一个子类重写了父类的指定构造器，并且该构造器遵循了某个协议的规定，那么该构造器的实现需要被同时标示`required`和`override`修饰符
@ -266,7 +268,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
### 可失败构造器的规定 ### 可失败构造器的规定
可以通过给协议`Protocols`中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。 可以通过给协议`Protocols`中添加[可失败构造器](./14_Initialization.html#failable_initializers)来使遵循该协议的类型必须实现该可失败构造器。
如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。 如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。
@ -346,7 +348,7 @@ protocol DiceGameDelegate {
`DiceGame`协议可以在任意含有骰子的游戏中实现。`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程 `DiceGame`协议可以在任意含有骰子的游戏中实现。`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
如下所示，`SnakesAndLadders`是`Snakes and Ladders`(译者注:[Control Flow](2)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程: 如下所示，`SnakesAndLadders`是`Snakes and Ladders`([Control Flow](./05_Control_Flow.html)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程:
```swift ```swift
class SnakesAndLadders: DiceGame { class SnakesAndLadders: DiceGame {
@ -438,7 +440,7 @@ game.play()
<a name="adding_protocol_conformance_with_an_extension"></a> <a name="adding_protocol_conformance_with_an_extension"></a>
## 在扩展中添加协议成员 ## 在扩展中添加协议成员
即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(*译者注: 类，结构体，枚举等*)。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。详情请在[扩展](4)章节中查看。 即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(*译者注: 类，结构体，枚举等*)。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。详情请在[扩展](./21_Extensions.html)章节中查看。
> 注意 > 注意
> 通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法 > 通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法
@ -602,7 +604,7 @@ protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
<!--TODO 链接--> <!--TODO 链接-->
>注意 >注意
>当协议想要定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。关于引用语义，值语义的更多内容，请查看<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_145">结构体和枚举是值类型</a>和<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_146">类是引用类型</a> >当协议想要定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。关于引用语义，值语义的更多内容，请查看[结构体和枚举是值类型](./09_Classes_and_Structures.html#structures_and_enumerations_are_value_types)和[类是引用类型](./09_Classes_and_Structures.html#classes_are_reference_types)。
<a name="protocol_composition"></a> <a name="protocol_composition"></a>
@ -644,7 +646,7 @@ wishHappyBirthday(birthdayPerson)
## 检验协议的一致性 ## 检验协议的一致性
<!--TODO 链接--> <!--TODO 链接-->
你可以使用`is`和`as`操作符来检查是否遵循某一协议或强制转化为某一类型。检查和转化的语法和之前相同(*详情查看[Typy Casting章节](5)*): 你可以使用`is`和`as`操作符来检查是否遵循某一协议或强制转化为某一类型。检查和转化的语法和之前相同(*详情查看[类型转换](./20_Type_Casting.html)*):
* `is`操作符用来检查实例是否`遵循`了某个`协议` * `is`操作符用来检查实例是否`遵循`了某个`协议`
* `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil` * `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil`
@ -721,7 +723,7 @@ for object in objects {
协议可以含有可选成员，其`遵循者`可以选择是否实现这些成员。在协议中使用`optional`关键字作为前缀来定义可选成员。 协议可以含有可选成员，其`遵循者`可以选择是否实现这些成员。在协议中使用`optional`关键字作为前缀来定义可选成员。
<!--TODO 链接--> <!--TODO 链接-->
可选协议在调用时使用`可选链`，因为协议的遵循者可能没有实现可选内容，详细内容在[Optional Chaning](7)章节中查看。 可选协议在调用时使用`可选链`，因为协议的遵循者可能没有实现可选内容，详细内容在[可空链式调用](./17_Optional_Chaining.html)章节中查看。
像`someOptionalMethod?(someArgument)`这样，你可以在可选方法名称后加上`?`来检查该方法是否被实现。可选方法和可选属性都会返回一个`可选值(optional value)`，当其不可访问时，`?`之后语句不会执行，并整体返回`nil` 像`someOptionalMethod?(someArgument)`这样，你可以在可选方法名称后加上`?`来检查该方法是否被实现。可选方法和可选属性都会返回一个`可选值(optional value)`，当其不可访问时，`?`之后语句不会执行，并整体返回`nil`
@ -876,7 +878,7 @@ extension PrettyTextRepresentable {
### 为协议扩展添加限制条件 ### 为协议扩展添加限制条件
在扩展协议的时候，可以指定一些限制，只有满足这些限制的协议遵循者，才能获得协议扩展提供的属性和方法。这些限制写在协议名之后，使用`where`关键字来描述限制情况。([Where 子句](TODO))。: 在扩展协议的时候，可以指定一些限制，只有满足这些限制的协议遵循者，才能获得协议扩展提供的属性和方法。这些限制写在协议名之后，使用`where`关键字来描述限制情况。([Where语句](./23_Generics.html#where_clauses))。:
例如，你可以扩展`CollectionType`协议，但是只适用于元素遵循`TextRepresentable`的情况: 例如，你可以扩展`CollectionType`协议，但是只适用于元素遵循`TextRepresentable`的情况:

15
source/chapter2/23_Generics.md
View File

@ -1,7 +1,10 @@
> 1.0
> 翻译：[takalard](https://github.com/takalard) [SergioChan](https://github.com/SergioChan) > 翻译：[takalard](https://github.com/takalard)
> 校对：[lifedim](https://github.com/lifedim) > 校对：[lifedim](https://github.com/lifedim)
> 2.0
> 翻译+校对： [SergioChan](https://github.com/SergioChan)
# 泛型 # 泛型
------ ------
@ -35,7 +38,7 @@ func swapTwoInts(inout a: Int, inout _ b: Int) {
} }
``` ```
这个函数使用写入读出（in-out）参数来交换`a`和`b`的值，请参考[写入读出参数](../chapter2/06_Functions.html)。 这个函数使用写入读出（in-out）参数来交换`a`和`b`的值，请参考[输入输出参数](./06_Functions.html#in_out_parameters)。
`swapTwoInts(_:_:)`函数可以交换`b`的原始值到`a`，也可以交换a的原始值到`b`，你可以调用这个函数交换两个`Int`变量值： `swapTwoInts(_:_:)`函数可以交换`b`的原始值到`a`，也可以交换a的原始值到`b`，你可以调用这个函数交换两个`Int`变量值：
@ -260,7 +263,7 @@ if let topItem = stackOfStrings.topItem {
`swapTwoValues(_:_:)`函数和`Stack`类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。 `swapTwoValues(_:_:)`函数和`Stack`类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
例如，Swift 的`Dictionary`类型对作用于其键的类型做了些限制。在[字典](../chapter2/04_Collection_Types.html)的描述中，字典的键类型必须是*可哈希*，也就是说，必须有一种方法可以使其被唯一的表示。`Dictionary`之所以需要其键是可哈希是为了以便于其检查其是否已经包含某个特定键的值。如无此需求，`Dictionary`既不会告诉是否插入或者替换了某个特定键的值，也不能查找到已经存储在字典里面的给定键值。 例如，Swift 的`Dictionary`类型对作用于其键的类型做了些限制。在[字典](./04_Collection_Types.html#dictionaries)的描述中，字典的键类型必须是*可哈希*，也就是说，必须有一种方法可以使其被唯一的表示。`Dictionary`之所以需要其键是可哈希是为了以便于其检查其是否已经包含某个特定键的值。如无此需求，`Dictionary`既不会告诉是否插入或者替换了某个特定键的值，也不能查找到已经存储在字典里面的给定键值。
这个需求强制加上一个类型约束作用于`Dictionary`的键上，当然其键类型必须遵循`Hashable`协议（Swift 标准库中定义的一个特定协议）。所有的 Swift 基本类型（如`String`，`Int`， `Double`和 `Bool`）默认都是可哈希。 这个需求强制加上一个类型约束作用于`Dictionary`的键上，当然其键类型必须遵循`Hashable`协议（Swift 标准库中定义的一个特定协议）。所有的 Swift 基本类型（如`String`，`Int`， `Double`和 `Bool`）默认都是可哈希。
@ -443,9 +446,9 @@ struct Stack<T>: Container {
### 扩展一个存在的类型为一指定关联类型 ### 扩展一个存在的类型为一指定关联类型
在[使用扩展来添加协议兼容性](../chapter2/21_Protocols.html)中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。 在[在扩展中添加协议成员](./21_Protocols.html#adding_protocol_conformance_with_an_extension)中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
Swift的`Array`已经提供`append(_:)`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[使用扩展来声明协议的采纳](../chapter2/21_Protocols.html)中有描述这样一个实现一个空扩展的行为： Swift的`Array`已经提供`append(_:)`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[通过扩展补充协议声明](./21_Protocols.html#declaring_protocol_adoption_with_an_extension)中有描述这样一个实现一个空扩展的行为：
```swift ```swift
extension Array: Container {} extension Array: Container {}

8
source/chapter2/24_Access_Control.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[JaceFu](http://www.devtalking.com/) > 翻译：[JaceFu](http://www.devtalking.com/)
> 校对：[ChildhoodAndy](http://childhood.logdown.com) > 校对：[ChildhoodAndy](http://childhood.logdown.com)
> 2.0
> 翻译+校对：[mmoaay](https://github.com/mmoaay)
# 访问控制 # 访问控制
------------------ ------------------
@ -288,13 +292,13 @@ public struct TrackedString {
<a name="initializers"></a> <a name="initializers"></a>
## 初始化 ## 初始化
我们可以给自定义的初始化方法申明访问级别，但是要不高于它所属类的访问级别。但[必要构造器](TODO)例外，它的访问级别必须和所属类的访问级别相同。 我们可以给自定义的初始化方法申明访问级别，但是要不高于它所属类的访问级别。但[必要构造器](./14_Initialization.html#required_initializers)例外，它的访问级别必须和所属类的访问级别相同。
如同函数或方法参数，初始化方法参数的访问级别也不能低于初始化方法的访问级别。 如同函数或方法参数，初始化方法参数的访问级别也不能低于初始化方法的访问级别。
<a name="default_initializers"></a> <a name="default_initializers"></a>
### 默认初始化方法 ### 默认初始化方法
Swift为结构体、类都提供了一个默认的无参初始化方法，用于给它们的所有属性提供赋值操作，但不会给出具体值。默认初始化方法可以参阅[Default Initializers](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_336)。默认初始化方法的访问级别与所属类型的访问级别相同。 Swift为结构体、类都提供了一个默认的无参初始化方法，用于给它们的所有属性提供赋值操作，但不会给出具体值。默认初始化方法可以参阅[默认构造器](./14_Initialization.html#default_initializers)。默认初始化方法的访问级别与所属类型的访问级别相同。
> 注意：如果一个类型被申明为`public`级别，那么默认的初始化方法的访问级别为`internal`。如果你想让无参的初始化方法在其他模块中可以被使用，那么你必须提供一个具有`public`访问级别的无参初始化方法。 > 注意：如果一个类型被申明为`public`级别，那么默认的初始化方法的访问级别为`internal`。如果你想让无参的初始化方法在其他模块中可以被使用，那么你必须提供一个具有`public`访问级别的无参初始化方法。

10
source/chapter2/25_Advanced_Operators.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[xielingwang](https://github.com/xielingwang) > 翻译：[xielingwang](https://github.com/xielingwang)
> 校对：[numbbbbb](https://github.com/numbbbbb) > 校对：[numbbbbb](https://github.com/numbbbbb)
> 2.0
> 翻译+校对：[buginux](https://github.com/buginux)
# 高级运算符 # 高级运算符
----------------- -----------------
@ -12,7 +16,7 @@
- [运算符函数(Operator Functions)](#operator_functions) - [运算符函数(Operator Functions)](#operator_functions)
- [自定义运算符](#custom_operators) - [自定义运算符](#custom_operators)
除了在之前介绍过的[基本运算符](02_Basic_Operators.html)，Swift 中还有许多可以对数值进行复杂操作的高级运算符。这些高级运算符包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。 除了在之前介绍过的[基本运算符](./02_Basic_Operators.html)，Swift 中还有许多可以对数值进行复杂操作的高级运算符。这些高级运算符包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。
与C语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符(`&+`)。所有的这些溢出运算符都是以 `&` 开头的。 与C语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符(`&+`)。所有的这些溢出运算符都是以 `&` 开头的。
@ -393,7 +397,8 @@ let afterIncrement = ++toIncrement
> 注意： > 注意：
> 不能对默认的赋值运算符(`=`)进行重载。只有组合赋值符可以被重载。同样地，也无法对三目条件运算符 `a ? b : c` 进行重载。 > 不能对默认的赋值运算符(`=`)进行重载。只有组合赋值符可以被重载。同样地，也无法对三目条件运算符 `a ? b : c` 进行重载。
### 等价运算符 <a name="equivalence_operators"></a>
### 等价操作符
自定义的类和结构体没有对等价操作符(`equivalence operators`)进行默认实现，等价操作符通常被称为“相等”操作符(`==`)与“不等”操作符(`!=`)。对于自定义类型，Swift 无法判断其是否“相等”，因为“相等”的含义取决于这些自定义类型在你的代码中所扮演的角色。 自定义的类和结构体没有对等价操作符(`equivalence operators`)进行默认实现，等价操作符通常被称为“相等”操作符(`==`)与“不等”操作符(`!=`)。对于自定义类型，Swift 无法判断其是否“相等”，因为“相等”的含义取决于这些自定义类型在你的代码中所扮演的角色。
@ -421,6 +426,7 @@ if twoThree == anotherTwoThree {
// prints "These two vectors are equivalent." // prints "These two vectors are equivalent."
``` ```
<a name="custom_operators"></a>
### 自定义运算符 ### 自定义运算符
除了实现标准运算符，在 Swift 当中还可以声明和实现自定义运算符(`custom operators`)。可以用来自定义运算符的字符列表请参考[操作符](../chapter3/02_Lexical_Structure.html#operators) 除了实现标准运算符，在 Swift 当中还可以声明和实现自定义运算符(`custom operators`)。可以用来自定义运算符的字符列表请参考[操作符](../chapter3/02_Lexical_Structure.html#operators)

6
source/chapter3/01_About_the_Language_Reference.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[dabing1022](https://github.com/dabing1022) > 翻译：[dabing1022](https://github.com/dabing1022)
> 校对：[numbbbbb](https://github.com/numbbbbb), [KYawn](https://github.com/KYawn) > 校对：[numbbbbb](https://github.com/numbbbbb)
> 2.0
> 翻译+校对：[KYawn](https://github.com/KYawn)
# 关于语言附注 # 关于语言附注

12
source/chapter3/02_Lexical_Structure.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[superkam](https://github.com/superkam) > 翻译：[superkam](https://github.com/superkam)
> 校对：[numbbbbb](https://github.com/numbbbbb) > 校对：[numbbbbb](https://github.com/numbbbbb)
> 2.0
> 翻译+校对：[buginux]([KYawn](https://github.com/buginux)
# 词法结构 # 词法结构
----------------- -----------------
@ -202,14 +206,14 @@ true // 布尔型字面量
let x = 3; "1 2 \(x)" let x = 3; "1 2 \(x)"
``` ```
字符串字面量的默认推导类型为 `String`。组成字符串的字符默认推导类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368)。 字符串字面量的默认推导类型为 `String`。组成字符串的字符默认推导类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](../chapter2/03_Strings_and_Characters.html)。
> 字符型字面量语法 > 字符型字面量语法
> *字符串字面量* → **"** [*引用文本*](#quoted_text)<sub>可选</sub> **"** > *字符串字面量* → **"** [*引用文本*](#quoted_text)<sub>可选</sub> **"**
<a id="quoted_text"></a> <a id="quoted_text"></a>
> *引用文本* → [*引用文本条目*](#quoted_text_item) [*引用文本*](#quoted_text) <sub>可选</sub> > *引用文本* → [*引用文本条目*](#quoted_text_item) [*引用文本*](#quoted_text) <sub>可选</sub>
> *引用文本条目* → [*转义字符*](#escaped_character) > *引用文本条目* → [*转义字符*](#escaped_character)
> *引用文本条目* → **\(** [*表达式*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/doc/uid/TP40014097-CH32-ID383) **)** > *引用文本条目* → **\(** [*表达式*](./04_Expressions.html) **)**
> *引用文本条目* → **除了"­, \­, U+000A, 或者 U+000D的所有Unicode的字符** > *引用文本条目* → **除了"­, \­, U+000A, 或者 U+000D的所有Unicode的字符**
> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'** > *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**
> *转义字符* → **\u {** [*unicode标量数字*](#unicode_scalar_digits) **}** > *转义字符* → **\u {** [*unicode标量数字*](#unicode_scalar_digits) **}**
@ -218,7 +222,7 @@ let x = 3; "1 2 \(x)"
<a id="operators"></a> <a id="operators"></a>
## 运算符 ## 运算符
Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-XID_70) 和 [高级运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_28) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/25_Advanced_Operators.html) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。
自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、 `-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`, 或者后面语法中规定的任一个 Unicode 字符开始。在第一个字符之后，允许使用组合型 Unicode 字符。也可以使用两个或者多个的点号来自定义运算符（比如, `....`）。虽然可以自定义包含问号`?`的运算符，但是这个运算符不能只包含单独的一个问号。 自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、 `-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`, 或者后面语法中规定的任一个 Unicode 字符开始。在第一个字符之后，允许使用组合型 Unicode 字符。也可以使用两个或者多个的点号来自定义运算符（比如, `....`）。虽然可以自定义包含问号`?`的运算符，但是这个运算符不能只包含单独的一个问号。
@ -238,7 +242,7 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基
在某些特定的构造中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的标记，因而不会被误解析为 `>>` 运算符的一部分。 在某些特定的构造中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的标记，因而不会被误解析为 `>>` 运算符的一部分。
要学习如何自定义运算符，请参考 [自定义操作符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48) 和 [运算符声明](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644)。要学习如何重载运算符，请参考 [运算符方法](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43)。 要学习如何自定义运算符，请参考 [自定义操作符](../chapter2/25_Advanced_Operators.html#custom_operators) 和 [运算符声明](./05_Declarations.html#operator_declaration)。要学习如何重载运算符，请参考 [运算符方法](../chapter2/25_Advanced_Operators.html#operator_functions)。
> 运算符语法语法 > 运算符语法语法
> *运算符* → [*头部运算符*](#operator_head) [*运算符字符组*](#operator_characters)<sub>可选</sub> > *运算符* → [*头部运算符*](#operator_head) [*运算符字符组*](#operator_characters)<sub>可选</sub>

46
source/chapter3/03_Types.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[lyuka](https://github.com/lyuka) > 翻译：[lyuka](https://github.com/lyuka)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[EudeMorgen](https://github.com/EudeMorgen)
# 类型（Types） # 类型（Types）
----------------- -----------------
@ -27,7 +31,7 @@ Swift 语言存在两种类型：命名型类型和复合型类型。命名型
本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。 本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。
> 类型语法 > 类型语法
> *类型* → [*数组类型*](#array_type) | [*字典类型*](..\chapter3\03_Types.html#dictionary_type) | [*函数类型*](..\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) > *类型* → [*数组类型*](#array_type) | [*字典类型*](../chapter3/03_Types.html#dictionary_type) | [*函数类型*](../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)
<a name="type_annotation"></a> <a name="type_annotation"></a>
##类型注解 ##类型注解
@ -43,7 +47,7 @@ func someFunction(a: Int){ /* ... */ }
类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。 类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。
> 类型注解语法 > 类型注解语法
> *类型注解* → **:** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type) > *类型注解* → **:** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)
<a name="type_identifier"></a> <a name="type_identifier"></a>
##类型标识符 ##类型标识符
@ -66,7 +70,7 @@ var someValue: ExampleModule.MyType
``` ```
> 类型标识语法 > 类型标识语法
> *类型标识* → [*类型名称*](..\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/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)
> *类名* → [*标识符*](LexicalStructure.html#identifier) > *类名* → [*标识符*](LexicalStructure.html#identifier)
<a name="tuple_type"></a> <a name="tuple_type"></a>
@ -79,10 +83,10 @@ var someValue: ExampleModule.MyType
`void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含的元素个数在两个及以上时才可以命名元组元素。 `void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含的元素个数在两个及以上时才可以命名元组元素。
> 元组类型语法 > 元组类型语法
> *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)** > *元组类型* → **(** [*元组类型主体*](../chapter3/03_Types.html#tuple_type_body) _可选_ **)**
> *元组类型主体* → [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_ > *元组类型主体* → [*元组类型的元素列表*](../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) > *元组类型的元素列表* → [*元组类型的元素*](../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) > *元组类型的元素* → [*特性(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)
> *元素名* → [*标识符*](LexicalStructure.html#identifier) > *元素名* → [*标识符*](LexicalStructure.html#identifier)
<a name="function_type"></a> <a name="function_type"></a>
@ -115,8 +119,8 @@ simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.")
函数类型若要抛出错误就必须使用`throws`关键字来标记，若要重抛错误则必须使用`rethrows`关键字来标记。`throws`关键字是函数类型的一部分，不抛出函数（nonthrowing function）是抛出函数（throwing function）函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。对于柯里化函数，`throws`关键字只应用于最里层的函数。抛出和重抛函数（rethrowing function）的相关描述见章节抛出函数与方法和重抛函数与方法。 函数类型若要抛出错误就必须使用`throws`关键字来标记，若要重抛错误则必须使用`rethrows`关键字来标记。`throws`关键字是函数类型的一部分，不抛出函数（nonthrowing function）是抛出函数（throwing function）函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。对于柯里化函数，`throws`关键字只应用于最里层的函数。抛出和重抛函数（rethrowing function）的相关描述见章节抛出函数与方法和重抛函数与方法。
> 函数类型语法 > 函数类型语法
> *函数类型* → [*类型*](..\chapter3\03_Types.html#type) _抛出_ _可选_ **->** [*类型*](..\chapter3\03_Types.html#type) > *函数类型* → [*类型*](../chapter3/03_Types.html#type) _抛出_ _可选_ **->** [*类型*](../chapter3/03_Types.html#type)
> *函数类型* → [*类型*](..\chapter3\03_Types.html#type)_重抛_ **->** [*类型*](..\chapter3\03_Types.html#type) > *函数类型* → [*类型*](../chapter3/03_Types.html#type)_重抛_ **->** [*类型*](../chapter3/03_Types.html#type)
<a name="array_type"></a> <a name="array_type"></a>
##数组类型 ##数组类型
@ -140,7 +144,7 @@ var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
关于Swift标准库中`Array`类型的细节讨论，见章节Arrays。 关于Swift标准库中`Array`类型的细节讨论，见章节Arrays。
> 数组类型语法 > 数组类型语法
> *数组类型* → [*类型*](..\chapter3\03_Types.html#type) > *数组类型* → [*类型*](../chapter3/03_Types.html#type)
<a name="dictionary_type"></a> <a name="dictionary_type"></a>
##字典类型 ##字典类型
@ -161,7 +165,7 @@ let someDictionary: Dictionary<String, Int> = ["Alex": 31, "Paul": 39]
关于Swift标准库中`Dictionary`类型的更多细节可查看章节Dictionaries。 关于Swift标准库中`Dictionary`类型的更多细节可查看章节Dictionaries。
> 字典类型语法 > 字典类型语法
> *字典类型* → **[**[*类型*](..\chapter3\03_Types.html#type) **:** [*类型*](..\chapter3\03_Types.html#type) **]** > *字典类型* → **[**[*类型*](../chapter3/03_Types.html#type) **:** [*类型*](../chapter3/03_Types.html#type) **]**
<a name="optional_type"></a> <a name="optional_type"></a>
##可选类型 ##可选类型
@ -191,7 +195,7 @@ optionalInteger! // 42
更多细节以及更多如何使用可选类型的例子，见章节Optionals。 更多细节以及更多如何使用可选类型的例子，见章节Optionals。
> 可选类型语法 > 可选类型语法
> *可选类型* → [*类型*](..\chapter3\03_Types.html#type) **?** > *可选类型* → [*类型*](../chapter3/03_Types.html#type) **?**
<a name="implicitly_unwrapped_optional_type"></a> <a name="implicitly_unwrapped_optional_type"></a>
##隐式解析可选类型 ##隐式解析可选类型
@ -215,7 +219,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
关于隐式解析可选的更多细节，见章节Implicitly Unwrapped Optionals。 关于隐式解析可选的更多细节，见章节Implicitly Unwrapped Optionals。
> 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法 > 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法
> *隐式解析可选类型* → [*类型*](..\chapter3\03_Types.html#type) **!** > *隐式解析可选类型* → [*类型*](../chapter3/03_Types.html#type) **!**
<a name="protocol_composition_type"></a> <a name="protocol_composition_type"></a>
##协议合成类型 ##协议合成类型
@ -233,9 +237,9 @@ protocol<Protocol 1, Procotol 2>
协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能遵循。 协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能遵循。
> 协议合成类型语法 > 协议合成类型语法
> *协议合成类型* → **protocol** **<** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>** > *协议合成类型* → **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#protocol_identifier) | [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) **,** [*协议标识符列表*](../chapter3/03_Types.html#protocol_identifier_list)
> *协议标识符* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *协议标识符* → [*类型标识*](../chapter3/03_Types.html#type_identifier)
<a name="metatype_type"></a> <a name="metatype_type"></a>
##元类型 ##元类型
@ -268,7 +272,7 @@ someInstance.dynamicType.printClassName()
> 元(Metatype)类型语法 > 元(Metatype)类型语法
> *元类型* → [*类型*](..\chapter3\03_Types.html#type) **.** **Type** | [*类型*](..\chapter3\03_Types.html#type) **.** **Protocol** > *元类型* → [*类型*](../chapter3/03_Types.html#type) **.** **Type** | [*类型*](../chapter3/03_Types.html#type) **.** **Protocol**
<a name="type_inheritance_clause"></a> <a name="type_inheritance_clause"></a>
##类型继承子句 ##类型继承子句
@ -282,10 +286,10 @@ someInstance.dynamicType.printClassName()
枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举——一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节Raw Values。 枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举——一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节Raw Values。
> 类型继承子句语法 > 类型继承子句语法
> *类型继承子句* → **:** [*类需求*](..\chapter3\03_Types.html#class_requirement) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list) > *类型继承子句* → **:** [*类需求*](../chapter3/03_Types.html#class_requirement) **,** [*类型继承列表*](../chapter3/03_Types.html#type_inheritance_list)
> *类型继承子句* → **:** [*类需求*](..\chapter3\03_Types.html#class_requirement) > *类型继承子句* → **:** [*类需求*](../chapter3/03_Types.html#class_requirement)
> *类型继承子句* → **:** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list) > *类型继承子句* → **:** [*类型继承列表*](../chapter3/03_Types.html#type_inheritance_list)
> *类型继承列表* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list) > *类型继承列表* → [*类型标识*](../chapter3/03_Types.html#type_identifier) | [*类型标识*](../chapter3/03_Types.html#type_identifier) **,** [*类型继承列表*](../chapter3/03_Types.html#type_inheritance_list)
> *类需求* → **类** > *类需求* → **类**
<a name="type_inference"></a> <a name="type_inference"></a>

207
source/chapter3/04_Expressions.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[sg552](https://github.com/sg552) > 翻译：[sg552](https://github.com/sg552)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[EudeMorgen](https://github.com/EudeMorgen)
# 表达式（Expressions） # 表达式（Expressions）
----------------- -----------------
@ -19,8 +23,8 @@ Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary
前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述。 前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述。
> 表达式语法 > 表达式语法
> *表达式* → [*试算子(try operator)*](..\chapter3\04_Expressions.html#*) _可选_ | [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) | [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_ > *表达式* → [*试算子(try operator)*](../chapter3/04_Expressions.html#*) _可选_ | [*前置表达式*](../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/04_Expressions.html#expression) | [*表达式*](../chapter3/04_Expressions.html#expression) **,** [*表达式列表*](../chapter3/04_Expressions.html#expression_list)
<a name="prefix_expressions"></a> <a name="prefix_expressions"></a>
## 前缀表达式（Prefix Expressions） ## 前缀表达式（Prefix Expressions）
@ -32,8 +36,8 @@ Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary
作为对上面标准库运算符的补充，你也可以对 某个函数的参数使用 '&'运算符。 更多信息，请参见： "In-Out parameters". 作为对上面标准库运算符的补充，你也可以对 某个函数的参数使用 '&'运算符。 更多信息，请参见： "In-Out parameters".
> 前置表达式语法 > 前置表达式语法
> *前置表达式* → [*前置运算符*](LexicalStructure.html#prefix_operator) _可选_ [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) > *前置表达式* → [*前置运算符*](LexicalStructure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression)
> *前置表达式* → [*写入写出(in-out)表达式*](..\chapter3\04_Expressions.html#in_out_expression) > *前置表达式* → [*写入写出(in-out)表达式*](../chapter3/04_Expressions.html#in_out_expression)
> *写入写出(in-out)表达式* → **&** [*标识符*](LexicalStructure.html#identifier) > *写入写出(in-out)表达式* → **&** [*标识符*](LexicalStructure.html#identifier)
<a name="try_operator"></a> <a name="try_operator"></a>
@ -59,11 +63,11 @@ try表达式由紧跟在可能会出错的表达式后面的`try`操作符组成
> 在解析时, 一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 * 5 首先被认为是： 2, + , `` 3``, *, 5. 随后它被转换成 tree （2 + （3 * 5）） > 在解析时, 一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 * 5 首先被认为是： 2, + , `` 3``, *, 5. 随后它被转换成 tree （2 + （3 * 5））
> 二元表达式语法 > 二元表达式语法
> *二元表达式* → [*二元运算符*](LexicalStructure.html#binary_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) > *二元表达式* → [*二元运算符*](LexicalStructure.html#binary_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)
> *二元表达式* → [*赋值运算符*](..\chapter3\04_Expressions.html#assignment_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) > *二元表达式* → [*赋值运算符*](../chapter3/04_Expressions.html#assignment_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)
> *二元表达式* → [*条件运算符*](..\chapter3\04_Expressions.html#conditional_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) > *二元表达式* → [*条件运算符*](../chapter3/04_Expressions.html#conditional_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)
> *二元表达式* → [*类型转换运算符*](..\chapter3\04_Expressions.html#type_casting_operator) > *二元表达式* → [*类型转换运算符*](../chapter3/04_Expressions.html#type_casting_operator)
> *二元表达式列表* → [*二元表达式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_ > *二元表达式列表* → [*二元表达式*](../chapter3/04_Expressions.html#binary_expression) [*二元表达式列表*](../chapter3/04_Expressions.html#binary_expressions) _可选_
> *赋值操作符* > *赋值操作符*
@ -98,7 +102,7 @@ try表达式由紧跟在可能会出错的表达式后面的`try`操作符组成
想看三元条件运算符的例子，请参见： Ternary Conditional Operator. 想看三元条件运算符的例子，请参见： Ternary Conditional Operator.
> 三元条件运算符语法 > 三元条件运算符语法
> *三元条件运算符* → **?** [*表达式*](..\chapter3\04_Expressions.html#expression) **:** > *三元条件运算符* → **?** [*表达式*](../chapter3/04_Expressions.html#expression) **:**
<a name="type-casting_operators"></a> <a name="type-casting_operators"></a>
## 类型转换运算符（Type-Casting Operators） ## 类型转换运算符（Type-Casting Operators）
@ -136,10 +140,10 @@ f(x as Any)
关于类型转换的更多内容和例子，请参见： Type Casting. 关于类型转换的更多内容和例子，请参见： Type Casting.
> 类型转换运算符(type-casting-operator)语法 > 类型转换运算符(type-casting-operator)语法
> *类型转换运算符* → **is** [*类型*](..\chapter3\03_Types.html#type) > *类型转换运算符* → **is** [*类型*](../chapter3/03_Types.html#type)
> *类型转换运算符* → **as** [*类型*](..\chapter3\03_Types.html#type) > *类型转换运算符* → **as** [*类型*](../chapter3/03_Types.html#type)
> *类型转换运算符* → **is** **?** [*类型*](..\chapter3\03_Types.html#type) > *类型转换运算符* → **is** **?** [*类型*](../chapter3/03_Types.html#type)
> *类型转换运算符* → **as** **!** [*类型*](..\chapter3\03_Types.html#type) > *类型转换运算符* → **as** **!** [*类型*](../chapter3/03_Types.html#type)
<a name="primary_expressions"></a> <a name="primary_expressions"></a>
## 主表达式（Primary Expressions） ## 主表达式（Primary Expressions）
@ -148,13 +152,13 @@ f(x as Any)
> 主表达式语法 > 主表达式语法
> *主表达式* → [*标识符*](LexicalStructure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ > *主表达式* → [*标识符*](LexicalStructure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_
> *主表达式* → [*字符型表达式*](..\chapter3\04_Expressions.html#literal_expression) > *主表达式* → [*字符型表达式*](../chapter3/04_Expressions.html#literal_expression)
> *主表达式* → [*self表达式*](..\chapter3\04_Expressions.html#self_expression) > *主表达式* → [*self表达式*](../chapter3/04_Expressions.html#self_expression)
> *主表达式* → [*超类表达式*](..\chapter3\04_Expressions.html#superclass_expression) > *主表达式* → [*超类表达式*](../chapter3/04_Expressions.html#superclass_expression)
> *主表达式* → [*闭包表达式*](..\chapter3\04_Expressions.html#closure_expression) > *主表达式* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression)
> *主表达式* → [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_expression) > *主表达式* → [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression)
> *主表达式* → [*隐式成员表达式*](..\chapter3\04_Expressions.html#implicit_member_expression) > *主表达式* → [*隐式成员表达式*](../chapter3/04_Expressions.html#implicit_member_expression)
> *主表达式* → [*通配符表达式*](..\chapter3\04_Expressions.html#wildcard_expression) > *主表达式* → [*通配符表达式*](../chapter3/04_Expressions.html#wildcard_expression)
### 字符型表达式（Literal Expression） ### 字符型表达式（Literal Expression）
@ -162,10 +166,10 @@ f(x as Any)
字符（Literal） | 类型（Type） | 值（Value） 字符（Literal） | 类型（Type） | 值（Value）
------------- | ---------- | ---------- ------------- | ---------- | ----------
\__FILE__ | String | 所在的文件名 /__FILE__ | String | 所在的文件名
\__LINE__ | Int | 所在的行数 /__LINE__ | Int | 所在的行数
\__COLUMN__ | Int | 所在的列数 /__COLUMN__ | Int | 所在的列数
\__FUNCTION__ | String | 所在的function 的名字 /__FUNCTION__ | String | 所在的function 的名字
在某个函数（function）中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在特殊的成员如init/subscript中 会返回这个关键字的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。 在某个函数（function）中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在特殊的成员如init/subscript中 会返回这个关键字的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。
@ -201,14 +205,14 @@ var emptyDictionary: [String: Double]=[:]
``` ```
> 字面量表达式语法 > 字面量表达式语法
> *字面量表达式* → [*字面量*](LexicalStructure.html#literal) > *字面量表达式* → [*字面量*](LexicalStructure.html#literal)
> *字面量表达式* → [*数组字面量*](..\chapter3\04_Expressions.html#array_literal) | [*字典字面量*](..\chapter3\04_Expressions.html#dictionary_literal) > *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal)
> *字面量表达式* → **&#95;&#95;FILE&#95;&#95;** | **&#95;&#95;LINE&#95;&#95;** | **&#95;&#95;COLUMN&#95;&#95;** | **&#95;&#95;FUNCTION&#95;&#95;** > *字面量表达式* → **&#95;&#95;FILE&#95;&#95;** | **&#95;&#95;LINE&#95;&#95;** | **&#95;&#95;COLUMN&#95;&#95;** | **&#95;&#95;FUNCTION&#95;&#95;**
> *数组字面量* → **[** [*数组字面量项列表*](..\chapter3\04_Expressions.html#array_literal_items) _可选_ **]** > *数组字面量* → **[** [*数组字面量项列表*](../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#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#expression)
> *字典字面量* → **[** [*字典字面量项列表*](..\chapter3\04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]** > *字典字面量* → **[** [*字典字面量项列表*](../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#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) > *字典字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression) **:** [*表达式*](../chapter3/04_Expressions.html#expression)
### self表达式（Self Expression） ### self表达式（Self Expression）
@ -217,8 +221,8 @@ self表达式是对 当前type 或者当前instance的引用。它的形式如
> self > self
> self.`member name` > self.`member name`
> self[`subscript index`] > self[`subscript index`]
> self（`initializer arguments`） > self(`initializer arguments`)
> self.init（`initializer arguments`） > self.init(`initializer arguments`)
如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法（static method）, 类方法（class method）中， self等同于当前的type. 如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法（static method）, 类方法（class method）中， self等同于当前的type.
@ -228,7 +232,7 @@ self表达式是对 当前type 或者当前instance的引用。它的形式如
```swift ```swift
class SomeClass { class SomeClass {
var greeting: String var greeting: String
init（greeting: String） { init(greeting: String) {
self.greeting = greeting self.greeting = greeting
} }
} }
@ -239,8 +243,8 @@ class SomeClass {
```swift ```swift
struct Point { struct Point {
var x = 0.0, y = 0.0 var x = 0.0, y = 0.0
mutating func moveByX（deltaX: Double, y deltaY: Double） { mutating func moveByX(deltaX: Double, y deltaY: Double) {
self = Point（x: x + deltaX, y: y + deltaY） self = Point(x: x + deltaX, y: y + deltaY)
} }
} }
``` ```
@ -248,7 +252,7 @@ struct Point {
> Self 表达式语法 > Self 表达式语法
> *self表达式* → **self** > *self表达式* → **self**
> *self表达式* → **self** **.** [*标识符*](LexicalStructure.html#identifier) > *self表达式* → **self** **.** [*标识符*](LexicalStructure.html#identifier)
> *self表达式* → **self** **[** [*表达式*](..\chapter3\04_Expressions.html#expression) **]** > *self表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**
> *self表达式* → **self** **.** **init** > *self表达式* → **self** **.** **init**
### 超类表达式（Superclass Expression） ### 超类表达式（Superclass Expression）
@ -257,16 +261,16 @@ struct Point {
> super.`member name` > super.`member name`
> super[`subscript index`] > super[`subscript index`]
> super.init（`initializer arguments`） > super.init(`initializer arguments`)
形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer. 形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.
子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。 子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。
> 超类(superclass)表达式语法 > 超类(superclass)表达式语法
> *超类表达式* → [*超类方法表达式*](..\chapter3\04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](..\chapter3\04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](..\chapter3\04_Expressions.html#superclass_initializer_expression) > *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression)
> *超类方法表达式* → **super** **.** [*标识符*](LexicalStructure.html#identifier) > *超类方法表达式* → **super** **.** [*标识符*](LexicalStructure.html#identifier)
> *超类下标表达式* → **super** **[** [*表达式*](..\chapter3\04_Expressions.html#expression) **]** > *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**
> *超类构造器表达式* → **super** **.** **init** > *超类构造器表达式* → **super** **.** **init**
### 闭包表达式（Closure Expression） ### 闭包表达式（Closure Expression）
@ -274,7 +278,7 @@ struct Point {
闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下： 闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下：
```swift ```swift
{ （parameters） -> return type in { (parameters) -> return type in
statements statements
} }
``` ```
@ -291,12 +295,12 @@ struct Point {
```swift ```swift
myFunction { myFunction {
（x: Int, y: Int） -> Int in (x: Int, y: Int) -> Int in
return x + y return x + y
} }
myFunction { myFunction {
（x, y） in (x, y) in
return x + y return x + y
} }
@ -312,28 +316,28 @@ myFunction { $0 + $1 }
在闭包的参数列表（ capture list）中， 参数可以声明为 'weak' 或者 'unowned' . 在闭包的参数列表（ capture list）中， 参数可以声明为 'weak' 或者 'unowned' .
```swift ```swift
myFunction { print（self.title） } // strong capture myFunction { print(self.title) } // strong capture
myFunction { [weak self] in print（self!.title） } // weak capture myFunction { [weak self] in print(self!.title) } // weak capture
myFunction { [unowned self] in print（self.title） } // unowned capture myFunction { [unowned self] in print(self.title) } // unowned capture
``` ```
在参数列表中，也可以使用任意表达式来赋值. 该表达式会在 闭包被执行时赋值，然后按照不同的力度来获取（这句话请慎重理解）。（captured with the specified strength. ） 例如： 在参数列表中，也可以使用任意表达式来赋值. 该表达式会在 闭包被执行时赋值，然后按照不同的力度来获取（这句话请慎重理解）。（captured with the specified strength. ） 例如：
```swift ```swift
// Weak capture of "self.parent" as "parent" // Weak capture of "self.parent" as "parent"
myFunction { [weak parent = self.parent] in print（parent!.title） } myFunction { [weak parent = self.parent] in print(parent!.title) }
``` ```
关于闭包表达式的更多信息和例子，请参见： Closure Expressions. 关于闭包表达式的更多信息和例子，请参见： Closure Expressions.
> 闭包表达式语法 > 闭包表达式语法
> *闭包表达式* → **{** [*闭包签名(Signational)*](..\chapter3\04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) **}** > *闭包表达式* → **{** [*闭包签名(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/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**
> *闭包签名(Signational)* → [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in** > *闭包签名(Signational)* → [*标识符列表*](LexicalStructure.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/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**
> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in** > *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**
> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) **in** > *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) **in**
> *捕获(Capature)列表* → **[** [*捕获(Capature)说明符*](..\chapter3\04_Expressions.html#capture_specifier) [*表达式*](..\chapter3\04_Expressions.html#expression) **]** > *捕获(Capature)列表* → **[** [*捕获(Capature)说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]**
> *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** > *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**
### 隐式成员表达式（Implicit Member Expression） ### 隐式成员表达式（Implicit Member Expression）
@ -350,7 +354,7 @@ x = .AnotherValue
``` ```
> 隐式成员表达式语法 > 隐式成员表达式语法
> *隐式成员表达式* → **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) > *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)
### 圆括号表达式（Parenthesized Expression） ### 圆括号表达式（Parenthesized Expression）
@ -361,16 +365,16 @@ x = .AnotherValue
圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int） 圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int）
> 圆括号表达式(Parenthesized Expression)语法 > 圆括号表达式(Parenthesized Expression)语法
> *圆括号表达式* → **(** [*表达式元素列表*](..\chapter3\04_Expressions.html#expression_element_list) _可选_ **)** > *圆括号表达式* → **(** [*表达式元素列表*](../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_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#expression) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **:** [*表达式*](../chapter3/04_Expressions.html#expression)
### 通配符表达式（Wildcard Expression） ### 通配符表达式（Wildcard Expression）
通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。） 通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。）
```swift ```swift
（x, _） = （10, 20） (x, _) = (10, 20)
// x is 10, 20 is ignored // x is 10, 20 is ignored
``` ```
@ -390,56 +394,53 @@ Swift 标准库提供了下列后缀表达式：
对于这些操作符的使用，请参见： Basic Operators and Advanced Operators 对于这些操作符的使用，请参见： Basic Operators and Advanced Operators
> 后置表达式语法 > 后置表达式语法
> *后置表达式* → [*主表达式*](..\chapter3\04_Expressions.html#primary_expression) > *后置表达式* → [*主表达式*](../chapter3/04_Expressions.html#primary_expression)
> *后置表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*后置运算符*](..\chapter3\02_Lexical_Structure.html#postfix_operator) > *后置表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*后置运算符*](../chapter3/02_Lexical_Structure.html#postfix_operator)
> *后置表达式* → [*函数调用表达式*](..\chapter3\04_Expressions.html#function_call_expression) > *后置表达式* → [*函数调用表达式*](../chapter3/04_Expressions.html#function_call_expression)
> *后置表达式* → [*构造器表达式*](..\chapter3\04_Expressions.html#initializer_expression) > *后置表达式* → [*构造器表达式*](../chapter3/04_Expressions.html#initializer_expression)
> *后置表达式* → [*显示成员表达式*](..\chapter3\04_Expressions.html#explicit_member_expression) > *后置表达式* → [*显示成员表达式*](../chapter3/04_Expressions.html#explicit_member_expression)
> *后置表达式* → [*后置self表达式*](..\chapter3\04_Expressions.html#postfix_self_expression) > *后置表达式* → [*后置self表达式*](../chapter3/04_Expressions.html#postfix_self_expression)
> *后置表达式* → [*动态类型表达式*](..\chapter3\04_Expressions.html#dynamic_type_expression) > *后置表达式* → [*动态类型表达式*](../chapter3/04_Expressions.html#dynamic_type_expression)
> *后置表达式* → [*下标表达式*](..\chapter3\04_Expressions.html#subscript_expression) > *后置表达式* → [*下标表达式*](../chapter3/04_Expressions.html#subscript_expression)
> *后置表达式* → [*强制取值(Forced Value)表达式*](..\chapter3\04_Expressions.html#forced_value_expression) > *后置表达式* → [*强制取值(Forced Value)表达式*](../chapter3/04_Expressions.html#forced_value_expression)
> *后置表达式* → [*可选链(Optional Chaining)表达式*](..\chapter3\04_Expressions.html#optional_chaining_expression) > *后置表达式* → [*可选链(Optional Chaining)表达式*](../chapter3/04_Expressions.html#optional_chaining_expression)
### 函数调用表达式（Function Call Expression） ### 函数调用表达式（Function Call Expression）
函数调用表达式由函数名和参数列表组成。它的形式如下： 函数调用表达式由函数名和参数列表组成。它的形式如下：
> `function name`（`argument value 1`, `argument value 2`） > `function name`(`argument value 1`, `argument value 2`)
The function name can be any expression whose value is of a function type.
（不用翻译了, 太罗嗦）
如果该function 的声明中指定了参数的名字，那么在调用的时候也必须得写出来. 例如： 如果该function 的声明中指定了参数的名字，那么在调用的时候也必须得写出来. 例如：
> `function name`（`argument name 1`: `argument value 1`, `argument name 2`: `argument value 2`） > `function name`(`argument name 1`: `argument value 1`, `argument name 2`: `argument value 2`)
可以在 函数调用表达式的尾部（最后一个参数之后）加上 一个闭包（closure） ， 该闭包会被目标函数理解并执行。它具有如下两种写法： 可以在 函数调用表达式的尾部（最后一个参数之后）加上 一个闭包（closure） ， 该闭包会被目标函数理解并执行。它具有如下两种写法：
```swift ```swift
// someFunction takes an integer and a closure as its arguments // someFunction takes an integer and a closure as its arguments
someFunction（x, {$0 == 13}） someFunction(x, {$0 == 13}+
someFunction（x） {$0 == 13} someFunction(x) {$0 == 13}
``` ```
如果闭包是该函数的唯一参数，那么圆括号可以省略。 如果闭包是该函数的唯一参数，那么圆括号可以省略。
```swift ```swift
// someFunction takes a closure as its only argument // someFunction takes a closure as its only argument
myData.someMethod（） {$0 == 13} myData.someMethod() {$0 == 13}
myData.someMethod {$0 == 13} myData.someMethod {$0 == 13}
``` ```
> 函数调用表达式语法 > 函数调用表达式语法
> *函数调用表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_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) > *函数调用表达式* → [*后置表达式*](../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) > *后置闭包(Trailing Closure)* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression)
### 初始化函数表达式（Initializer Expression） ### 初始化函数表达式（Initializer Expression）
Initializer表达式用来给某个Type初始化。 它的形式如下： Initializer表达式用来给某个Type初始化。 它的形式如下：
> `expression`.init（`initializer arguments`） > `expression`.init(`initializer arguments`)
（Initializer表达式用来给某个Type初始化。） 跟函数（function）不同， initializer 不能返回值。 （Initializer表达式用来给某个Type初始化。） 跟函数（function）不同， initializer 不能返回值。
@ -452,15 +453,15 @@ var y = SomeClass.init // error
```swift ```swift
class SomeSubClass: SomeSuperClass { class SomeSubClass: SomeSuperClass {
init（） { init() {
// subclass initialization goes here // subclass initialization goes here
super.init（） super.init()
} }
} }
``` ```
> 构造器表达式语法 > 构造器表达式语法
> *构造器表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **init** > *构造器表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init**
### 显式成员表达式（Explicit Member Expression） ### 显式成员表达式（Explicit Member Expression）
@ -474,23 +475,23 @@ class SomeSubClass: SomeSuperClass {
class SomeClass { class SomeClass {
var someProperty = 42 var someProperty = 42
} }
let c = SomeClass（） let c = SomeClass()
let y = c.someProperty // Member access let y = c.someProperty // Member access
``` ```
对于tuple, 要根据它们出现的顺序（0, 1, 2...）来使用: 对于tuple, 要根据它们出现的顺序（0, 1, 2...）来使用:
```swift ```swift
var t = （10, 20, 30） var t = (10, 20, 30)
t.0 = t.1 t.0 = t.1
// Now t is （20, 20, 30） // Now t is (20, 20, 30)
``` ```
对于某个module的member的调用，只能调用在top-level声明中的member. 对于某个module的member的调用，只能调用在top-level声明中的member.
> 显式成员表达式语法 > 显式成员表达式语法
> *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) > *显示成员表达式* → [*后置表达式*](../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) _可选_ > *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_
### 后缀self表达式（Postfix Self Expression） ### 后缀self表达式（Postfix Self Expression）
@ -504,7 +505,7 @@ t.0 = t.1
形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。 形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。
> 后置Self 表达式语法 > 后置Self 表达式语法
> *后置self表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **self** > *后置self表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self**
### dynamic表达式（Dynamic Type Expression） ### dynamic表达式（Dynamic Type Expression）
@ -518,25 +519,25 @@ dynamicType 表达式由 某个表达式 + '.dynamicType' 组成。
```swift ```swift
class SomeBaseClass { class SomeBaseClass {
class func printClassName（） { class func printClassName() {
println（"SomeBaseClass"） println("SomeBaseClass")
} }
} }
class SomeSubClass: SomeBaseClass { class SomeSubClass: SomeBaseClass {
override class func printClassName（） { override class func printClassName() {
println（"SomeSubClass"） println("SomeSubClass")
} }
} }
let someInstance: SomeBaseClass = SomeSubClass（） let someInstance: SomeBaseClass = SomeSubClass()
// someInstance is of type SomeBaseClass at compile time, but // someInstance is of type SomeBaseClass at compile time, but
// someInstance is of type SomeSubClass at runtime // someInstance is of type SomeSubClass at runtime
someInstance.dynamicType.printClassName（） someInstance.dynamicType.printClassName()
// prints "SomeSubClass" // prints "SomeSubClass"
``` ```
> 动态类型表达式语法 > 动态类型表达式语法
> *动态类型表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **dynamicType** > *动态类型表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType**
### 下标脚本表达式（Subscript Expression） ### 下标脚本表达式（Subscript Expression）
@ -549,7 +550,7 @@ someInstance.dynamicType.printClassName（）
关于subscript的声明，请参见： Protocol Subscript Declaration. 关于subscript的声明，请参见： Protocol Subscript Declaration.
> 附属脚本表达式语法 > 附属脚本表达式语法
> *附属脚本表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **[** [*表达式列表*](..\chapter3\04_Expressions.html#expression_list) **]** > *附属脚本表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式列表*](../chapter3/04_Expressions.html#expression_list) **]**
### 强制取值表达式（Forced-Value Expression） ### 强制取值表达式（Forced-Value Expression）
@ -570,7 +571,7 @@ someDictionary["a"]![0] = 100
``` ```
> 强制取值(Forced Value)语法 > 强制取值(Forced Value)语法
> *强制取值(Forced Value)表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **!** > *强制取值(Forced Value)表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!**
### 可选链表达式（Optional-Chaining Expression） ### 可选链表达式（Optional-Chaining Expression）
@ -586,14 +587,14 @@ someDictionary["a"]![0] = 100
```swift ```swift
var c: SomeClass? var c: SomeClass?
var result: Bool? = c?.property.performAction（） var result: Bool? = c?.property.performAction()
``` ```
如果不使用可选链表达式，那么 上面例子的代码跟下面例子等价： 如果不使用可选链表达式，那么 上面例子的代码跟下面例子等价：
```swift ```swift
if let unwrappedC = c { if let unwrappedC = c {
result = unwrappedC.property.performAction（） result = unwrappedC.property.performAction()
} }
``` ```
后缀'?' 返回目标表达式的值可能会被修改，可能是由于出现了赋值，也有可能是出现异常而产生的修改。如果可选链表达式为`nil`，则表达式右边的复制操作不会被执行。比如： 后缀'?' 返回目标表达式的值可能会被修改，可能是由于出现了赋值，也有可能是出现异常而产生的修改。如果可选链表达式为`nil`，则表达式右边的复制操作不会被执行。比如：
@ -614,4 +615,4 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects()
> 可选链表达式语法 > 可选链表达式语法
> *可选链表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **?** > *可选链表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **?**

188
source/chapter3/05_Declarations.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon) > 翻译：[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) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[Lenhoon](https://github.com/Lenhoon)
<a name="declarations"></a> <a name="declarations"></a>
# 声明 # 声明
----------------- -----------------
@ -84,9 +88,9 @@ Swift的源文件中的顶级代码由零个或多个语句，声明和表达式
<a name="grammer_of_an_import_declaration"></a> <a name="grammer_of_an_import_declaration"></a>
> 导入(Import)声明语法 > 导入(Import)声明语法
> *导入声明* → [*特性(attributes)列表*](TODO) _可选_ **import** [*导入类型*](..\chapter3\05_Declarations.html#import_kind) _可选_ [*导入路径*](..\chapter3\05_Declarations.html#import_path) > *导入声明* → [*特性(attributes)列表*](TODO) _可选_ **import** [*导入类型*](../chapter3/05_Declarations.html#import_kind) _可选_ [*导入路径*](../chapter3/05_Declarations.html#import_path)
> *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func** > *导入类型* → **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/05_Declarations.html#import_path_identifier) | [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) **.** [*导入路径*](../chapter3/05_Declarations.html#import_path)
> *导入路径标识符* → [*标识符*](TODO) | [*运算符*](TODO) > *导入路径标识符* → [*标识符*](TODO) | [*运算符*](TODO)
<a name="constant_declaration"></a> <a name="constant_declaration"></a>
@ -111,9 +115,9 @@ let (firstNumber, secondNumber) = (10, 42)
在上例中，`firstNumber`是一个值为`10`的常量，`secnodeName`是一个值为`42`的常量。所有常量都可以独立的使用： 在上例中，`firstNumber`是一个值为`10`的常量，`secnodeName`是一个值为`42`的常量。所有常量都可以独立的使用：
```swift ```swift
println("The first number is \(firstNumber).") println("The first number is /(firstNumber).")
// prints "The first number is 10." // prints "The first number is 10."
println("The second number is \(secondNumber).") println("The second number is /(secondNumber).")
// prints "The second number is 42." // prints "The second number is 42."
``` ```
@ -125,10 +129,10 @@ println("The second number is \(secondNumber).")
<a name="grammer_of_a_constant_declaration"></a> <a name="grammer_of_a_constant_declaration"></a>
> 常数声明语法 > 常数声明语法
> *常量声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list) > *常量声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list)
> *模式构造器列表* → [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list) > *模式构造器列表* → [*模式构造器*](../chapter3/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/07_Patterns.html#pattern) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_
> *构造器* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression) > *构造器* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)
<a name="variable_declaration"></a> <a name="variable_declaration"></a>
##变量声明 ##变量声明
@ -228,27 +232,27 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
<a name="grammer_of_a_variable_declaration"></a> <a name="grammer_of_a_variable_declaration"></a>
> 变量声明语法 > 变量声明语法
> *变量声明* → [*变量声明头(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#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) [*代码块*](../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块*](../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) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)
> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*构造器*](..\chapter3\05_Declarations.html#initializer) [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block) > *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*构造器*](../chapter3/05_Declarations.html#initializer) [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block)
> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block) > *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block)
> *变量声明头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var** > *变量声明头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var**
> *变量名称* → [*标识符*](LexicalStructure.html#identifier) > *变量名称* → [*标识符*](LexicalStructure.html#identifier)
> *getter-setter块* → **{** [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) _可选_ **}** > *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-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) > *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子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)
> *setter名称* → **(** [*标识符*](LexicalStructure.html#identifier) **)** > *setter名称* → **(** [*标识符*](LexicalStructure.html#identifier) **)**
> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可选_ **}** > *getter-setter关键字(Keyword)块* → **{** [*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-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** > *getter关键字(Keyword)子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get**
> *setter关键字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **set** > *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代码块* → **{** [*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-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) > *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) > *didSet子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)
<a name="type_alias_declaration"></a> <a name="type_alias_declaration"></a>
##类型的别名声明 ##类型的别名声明
@ -263,10 +267,10 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
<a name="grammer_of_a_type_alias_declaration"></a> <a name="grammer_of_a_type_alias_declaration"></a>
> 类型别名声明语法 > 类型别名声明语法
> *类型别名声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment) > *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment)
> *类型别名头(Head)* → [*属性列表*](todo) _可选_ [*访问级别修饰符*]((TODO) _可选_ **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name) > *类型别名头(Head)* → [*属性列表*](todo) _可选_ [*访问级别修饰符*]((TODO) _可选_ **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name)
> *类型别名名称* → [*标识符*](LexicalStructure.html#identifier) > *类型别名名称* → [*标识符*](LexicalStructure.html#identifier)
> *类型别名赋值* → **=** [*类型*](..\chapter3\03_Types.html#type) > *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type)
<a name="function_declaration"></a> <a name="function_declaration"></a>
##函数声明 ##函数声明
@ -447,22 +451,22 @@ plusOne(10)
<a name="grammer_of_a_function_declaration"></a> <a name="grammer_of_a_function_declaration"></a>
> 函数声明语法 > 函数声明语法
> *函数声明* → [*函数头*](..\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) > *函数声明* → [*函数头*](../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** > *函数头* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **func**
> *函数名* → [*标识符*](LexicalStructure.html#identifier) | [*运算符*](LexicalStructure.html#operator) > *函数名* → [*标识符*](LexicalStructure.html#identifier) | [*运算符*](LexicalStructure.html#operator)
> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **throws** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ > *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_
> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ > *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_
> *函数结果* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type) > *函数结果* → **->** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)
> *函数体* → [*代码块*](..\chapter3\05_Declarations.html#code_block) > *函数体* → [*代码块*](../chapter3/05_Declarations.html#code_block)
> *parameter-clauses* → [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可选_ > *parameter-clauses* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) _可选_
> *参数子句* → **(** **)** | **(** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list) **...** _可选_ **)** > *参数子句* → **(** **)** | **(** [*参数列表*](../chapter3/05_Declarations.html#parameter_list) **...** _可选_ **)**
> *参数列表* → [*参数*](..\chapter3\05_Declarations.html#parameter) | [*参数*](..\chapter3\05_Declarations.html#parameter) **,** [*参数列表*](..\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** _可选_ **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) _可选_ > *参数* → **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) > *参数* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)
> *参数名* → [*标识符*](LexicalStructure.html#identifier) | **_** > *参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**
> *内部参数名* → [*标识符*](LexicalStructure.html#identifier) | **_** > *内部参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**
> *默认参数子句* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression) > *默认参数子句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)
<a name="enumeration_declaration"></a> <a name="enumeration_declaration"></a>
##枚举声明 ##枚举声明
@ -550,22 +554,22 @@ num ExampleEnum: Int {
<a name="grammer_of_an_enumeration_declaration"></a> <a name="grammer_of_an_enumeration_declaration"></a>
> 枚举声明语法 > 枚举声明语法
> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO) > *枚举声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO)
> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*原始值式枚举*](..\chapter3\05_Declarations.html#raw_value_style_enum) > *枚举声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*原始值式枚举*](../chapter3/05_Declarations.html#raw_value_style_enum)
> *联合式枚举* → **indirect** _可选_ **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [类型继承子句](TODO)_可选_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}** > *联合式枚举* → **indirect** _可选_ **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [类型继承子句](TODO)_可选_ **{** [*union-style-enum-members*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}**
> *union-style-enum-members* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ > *union-style-enum-members* → [*union-style-enum-member*](../chapter3/05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_
> *union-style-enum-member* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case子句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause) > *union-style-enum-member* → [*声明*](../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) _可选_ **indirect** _可选_ **case** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list) > *联合式(Union Style)的枚举case子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **indirect** _可选_ **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列表* → [*联合式(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) _可选_ > *联合式(Union Style)的case* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组类型*](../chapter3/03_Types.html#tuple_type) _可选_
> *枚举名* → [*标识符*](LexicalStructure.html#identifier) > *枚举名* → [*标识符*](LexicalStructure.html#identifier)
> *枚举的case名* → [*标识符*](LexicalStructure.html#identifier) > *枚举的case名* → [*标识符*](LexicalStructure.html#identifier)
> *原始值式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](TODO) **{** [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) **}** > *原始值式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](TODO) **{** [*原始值式枚举成员列表*](../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#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) > *原始值式枚举成员* → [*声明*](../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子句* → [*特性(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#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) _可选_ > *原始值式枚举case* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*原始值赋值*](../chapter3/05_Declarations.html#raw_value_assignment) _可选_
> *原始值赋值* → **=** [*原始值字面量*](TODO) > *原始值赋值* → **=** [*原始值字面量*](TODO)
> *原始值字面量* → [数字型字面量](TODO)|[字符串型字面量](TODO)|[布尔型字面量](TODO) > *原始值字面量* → [数字型字面量](TODO)|[字符串型字面量](TODO)|[布尔型字面量](TODO)
@ -601,9 +605,9 @@ num ExampleEnum: Int {
<a name="grammer_of_a_structure_declaration"></a> <a name="grammer_of_a_structure_declaration"></a>
> 结构体声明语法 > 结构体声明语法
> *结构体声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [访问级别修饰符](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) > *结构体声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [访问级别修饰符](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)
> *结构体名称* → [*标识符*](LexicalStructure.html#identifier) > *结构体名称* → [*标识符*](LexicalStructure.html#identifier)
> *结构体主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}** > *结构体主体* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**
<a name="class_declaration"></a> <a name="class_declaration"></a>
##类声明 ##类声明
@ -640,9 +644,9 @@ num ExampleEnum: Int {
<a name="grammer_of_a_class_declaration"></a> <a name="grammer_of_a_class_declaration"></a>
> 类声明语法 > 类声明语法
> *类声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [访问级别修饰符](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) > *类声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [访问级别修饰符](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)
> *类名* → [*标识符*](LexicalStructure.html#identifier) > *类名* → [*标识符*](LexicalStructure.html#identifier)
> *类主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}** > *类主体* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**
<a name="protocol_declaration"></a> <a name="protocol_declaration"></a>
##协议声明(translated by 小一) ##协议声明(translated by 小一)
@ -683,15 +687,15 @@ protocol SomeProtocol:class{
<a name="grammer_of_a_protocol_declaration"></a> <a name="grammer_of_a_protocol_declaration"></a>
> 协议(Protocol)声明语法 > 协议(Protocol)声明语法
> *协议声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ **protocol** [*协议名*](..\chapter3\05_Declarations.html#protocol_name) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](..\chapter3\05_Declarations.html#protocol_body) > *协议声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承子句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body)
> *协议名* → [*标识符*](LexicalStructure.html#identifier) > *协议名* → [*标识符*](LexicalStructure.html#identifier)
> *协议主体* → **{** [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_ **}** > *协议主体* → **{** [*协议成员声明(Declarations)列表*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ **}**
> *协议成员声明* → [*协议属性声明*](..\chapter3\05_Declarations.html#protocol_property_declaration) > *协议成员声明* → [*协议属性声明*](../chapter3/05_Declarations.html#protocol_property_declaration)
> *协议成员声明* → [*协议方法声明*](..\chapter3\05_Declarations.html#protocol_method_declaration) > *协议成员声明* → [*协议方法声明*](../chapter3/05_Declarations.html#protocol_method_declaration)
> *协议成员声明* → [*协议构造器声明*](..\chapter3\05_Declarations.html#protocol_initializer_declaration) > *协议成员声明* → [*协议构造器声明*](../chapter3/05_Declarations.html#protocol_initializer_declaration)
> *协议成员声明* → [*协议附属脚本声明*](..\chapter3\05_Declarations.html#protocol_subscript_declaration) > *协议成员声明* → [*协议附属脚本声明*](../chapter3/05_Declarations.html#protocol_subscript_declaration)
> *协议成员声明* → [*协议关联类型声明*](..\chapter3\05_Declarations.html#protocol_associated_type_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) _可选_ > *协议成员声明(Declarations)列表* → [*协议成员声明*](../chapter3/05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)列表*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_
<a name="protocol_property_declaration"></a> <a name="protocol_property_declaration"></a>
###协议属性声明 ###协议属性声明
@ -708,7 +712,7 @@ protocol SomeProtocol:class{
<a name="grammer_of_an_import_declaration"></a> <a name="grammer_of_an_import_declaration"></a>
> 协议属性声明语法 > 协议属性声明语法
> *协议属性声明* → [*变量声明头(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) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)
<a name="protocol_method_declaration"></a> <a name="protocol_method_declaration"></a>
###协议方法声明 ###协议方法声明
@ -721,7 +725,7 @@ protocol SomeProtocol:class{
<a name="grammer_of_a_protocol_declaration"></a> <a name="grammer_of_a_protocol_declaration"></a>
> 协议方法声明语法 > 协议方法声明语法
> *协议方法声明* → [*函数头*](..\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_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature)
<a name="protocol_initializer_declaration"></a> <a name="protocol_initializer_declaration"></a>
###协议构造器声明 ###协议构造器声明
@ -737,7 +741,7 @@ protocol SomeProtocol:class{
<a name="grammer_of_a_protocol_initializer_declaration"></a> <a name="grammer_of_a_protocol_initializer_declaration"></a>
> 协议构造器声明语法 > 协议构造器声明语法
> *协议构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) > *协议构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](../chapter3/05_Declarations.html#parameter_clause)
<a name="protocol_subscript_declaration"></a> <a name="protocol_subscript_declaration"></a>
###协议下标脚本声明 ###协议下标脚本声明
@ -752,7 +756,7 @@ protocol SomeProtocol:class{
<a name="grammer_of_a_protocol_subscript_declaration"></a> <a name="grammer_of_a_protocol_subscript_declaration"></a>
> 协议附属脚本声明语法 > 协议附属脚本声明语法
> *协议附属脚本声明* → [*附属脚本头(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)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)
<a name="protocol_associated_type_declaration"></a> <a name="protocol_associated_type_declaration"></a>
###协议相关类型声明 ###协议相关类型声明
@ -761,7 +765,7 @@ protocol SomeProtocol:class{
<a name="grammer_of_a_protocol_associated_type_declaration"></a> <a name="grammer_of_a_protocol_associated_type_declaration"></a>
> 协议关联类型声明语法 > 协议关联类型声明语法
> *协议关联类型声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment) _可选_ > *协议关联类型声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型继承子句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) _可选_
<a name="initializer_declaration"></a> <a name="initializer_declaration"></a>
##构造器声明 ##构造器声明
@ -844,11 +848,11 @@ if let actualInstance = SomeStruct(input: "Hello") {
<a name="grammer_of_an_initializer_declaration"></a> <a name="grammer_of_an_initializer_declaration"></a>
> 构造器声明语法 > 构造器声明语法
> *构造器声明* → [*构造器头(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)*](../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) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init** > *构造器头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init**
> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init ?** > *构造器头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init ?**
> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init !** > *构造器头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init !**
> *构造器主体* → [*代码块*](..\chapter3\05_Declarations.html#code_block) > *构造器主体* → [*代码块*](../chapter3/05_Declarations.html#code_block)
<a name="deinitializer_declaration"></a> <a name="deinitializer_declaration"></a>
##析构声明 ##析构声明
@ -870,7 +874,7 @@ if let actualInstance = SomeStruct(input: "Hello") {
<a name="grammer_of_a_deinitializer_declaration"></a> <a name="grammer_of_a_deinitializer_declaration"></a>
> 析构器声明语法 > 析构器声明语法
> *析构器声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](..\chapter3\05_Declarations.html#code_block) > *析构器声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](../chapter3/05_Declarations.html#code_block)
<a name="extension_declaration"></a> <a name="extension_declaration"></a>
##扩展声明 ##扩展声明
@ -892,8 +896,8 @@ if let actualInstance = SomeStruct(input: "Hello") {
<a name="grammer_of_an_extension_declaration"></a> <a name="grammer_of_an_extension_declaration"></a>
> 扩展(Extension)声明语法 > 扩展(Extension)声明语法
> *扩展声明* → [访问级别修饰符](TODO) _可选_ **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body) > *扩展声明* → [访问级别修饰符](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) _可选_ **}** > *extension-body* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**
<a name="subscript_declaration"></a> <a name="subscript_declaration"></a>
##下标脚本声明 ##下标脚本声明
@ -925,11 +929,11 @@ if let actualInstance = SomeStruct(input: "Hello") {
<a name="grammer_of_a_subscript_declaration"></a> <a name="grammer_of_a_subscript_declaration"></a>
> 附属脚本声明语法 > 附属脚本声明语法
> *附属脚本声明* → [*附属脚本头(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) [*代码块*](../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块*](../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)*](../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) > *附属脚本头(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) > *附属脚本结果(Result)* → **->** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)
<a name="operator_declaration"></a> <a name="operator_declaration"></a>
##运算符声明(translated by 林) ##运算符声明(translated by 林)
@ -976,14 +980,14 @@ if let actualInstance = SomeStruct(input: "Hello") {
<a name="grammer_of_an_operator_declaration"></a> <a name="grammer_of_an_operator_declaration"></a>
> 运算符声明语法 > 运算符声明语法
> *运算符声明* → [*前置运算符声明*](..\chapter3\05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](..\chapter3\05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](..\chapter3\05_Declarations.html#infix_operator_declaration) > *运算符声明* → [*前置运算符声明*](../chapter3/05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](../chapter3/05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](../chapter3/05_Declarations.html#infix_operator_declaration)
> *前置运算符声明* → **prefix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}** > *前置运算符声明* → **prefix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}**
> *后置运算符声明* → **postfix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}** > *后置运算符声明* → **postfix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}**
> *中置运算符声明* → **infix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}** > *中置运算符声明* → **infix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](../chapter3/05_Declarations.html#infix_operator_attributes) _可选_ **}**
> *中置运算符属性* → [*优先级子句*](..\chapter3\05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](..\chapter3\05_Declarations.html#associativity_clause) _可选_ > *中置运算符属性* → [*优先级子句*](../chapter3/05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](../chapter3/05_Declarations.html#associativity_clause) _可选_
> *优先级子句* → **precedence** [*优先级水平*](..\chapter3\05_Declarations.html#precedence_level) > *优先级子句* → **precedence** [*优先级水平*](../chapter3/05_Declarations.html#precedence_level)
> *优先级水平* → 十进制整数 0 到 255 > *优先级水平* → 十进制整数 0 到 255
> *结和性子句* → **associativity** [*结和性*](..\chapter3\05_Declarations.html#associativity) > *结和性子句* → **associativity** [*结和性*](../chapter3/05_Declarations.html#associativity)
> *结和性* → **left** | **right** | **none** > *结和性* → **left** | **right** | **none**

8
source/chapter3/06_Attributes.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[Hawstein](https://github.com/Hawstein) > 翻译：[Hawstein](https://github.com/Hawstein)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai), [KYawn](https://github.com/KYawn) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[KYawn](https://github.com/KYawn)
# 特性 # 特性
----------------- -----------------
@ -25,7 +29,7 @@
`autoclosure` `autoclosure`
这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以声明返回表达式自身类型的没有参数的方法类型，也可以用于函数参数的声明。含有`autoclosure`特性的声明同时也具有`noescape`的特性，除非传递可选参数`escaping`.关于怎样使用`autoclosure`特性的例子，参见[函数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/doc/uid/TP40014097-CH31-ID449). 这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以声明返回表达式自身类型的没有参数的方法类型，也可以用于函数参数的声明。含有`autoclosure`特性的声明同时也具有`noescape`的特性，除非传递可选参数`escaping`.关于怎样使用`autoclosure`特性的例子，参见[函数类型](./03_Types.html#function_type).
`available` `available`

42
source/chapter3/07_Patterns.md
View File

@ -1,6 +1,10 @@
> 翻译：[honghaoz](https://github.com/honghaoz), [ray16897188](https://github.com/ray16897188) > 1.0
> 翻译：[honghaoz](https://github.com/honghaoz)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai) > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[ray16897188](https://github.com/ray16897188)
# 模式（Patterns） # 模式（Patterns）
----------------- -----------------
@ -24,14 +28,14 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类
第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式（enumeration case patterns），可选模式（optional patterns），表达式模式（expression patterns）和类型转换模式（type-casting patterns）。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式（enumeration case patterns），可选模式（optional patterns），表达式模式（expression patterns）和类型转换模式（type-casting patterns）。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
> 模式(Patterns) 语法 > 模式(Patterns) 语法
> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_ > *模式* → [*通配符模式*](../chapter3/07_Patterns.html#wildcard_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_
> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_ > *模式* → [*标识符模式*](../chapter3/07_Patterns.html#identifier_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotati(Value Binding)on) _可选_
> *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern) > *模式* → [*值绑定模式*](../chapter3/07_Patterns.html#value_binding_pattern)
> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_ > *模式* → [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_
> *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern) > *模式* → [*枚举用例模式*](../chapter3/07_Patterns.html#enum_case_pattern)
> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) > *模式* → [*可选模式*](../chapter3/07_Patterns.html#optional_pattern)
> *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern) > *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern)
> *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern) > *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern)
<a name="wildcard_pattern"></a> <a name="wildcard_pattern"></a>
## 通配符模式（Wildcard Pattern） ## 通配符模式（Wildcard Pattern）
@ -83,7 +87,7 @@ case let (x, y):
在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。正是由于这么做，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配到的值是一样的。 在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。正是由于这么做，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配到的值是一样的。
> 值绑定(Value Binding)模式语法 > 值绑定(Value Binding)模式语法
> *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern) > *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../chapter3/07_Patterns.html#pattern)
<a name="tuple_pattern"></a> <a name="tuple_pattern"></a>
## 元组模式（Tuple Pattern） ## 元组模式（Tuple Pattern）
@ -111,9 +115,9 @@ let (a): Int = 2 // a: Int = 2
``` ```
> 元组模式语法 > 元组模式语法
> *元组模式* → **(** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可选_ **)** > *元组模式* → **(** [*元组模式元素列表*](../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#tuple_pattern_element) | [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](../chapter3/07_Patterns.html#tuple_pattern_element_list)
> *元组模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern) > *元组模式元素* → [*模式*](../chapter3/07_Patterns.html#pattern)
<a name="enumeration_case_pattern"></a> <a name="enumeration_case_pattern"></a>
## 枚举用例模式（Enumeration Case Pattern） ## 枚举用例模式（Enumeration Case Pattern）
@ -123,7 +127,7 @@ let (a): Int = 2 // a: Int = 2
如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`. 如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`.
> 枚举用例模式语法 > 枚举用例模式语法
> *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_ > *enum-case-pattern* → [*类型标识*](../chapter3/03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) _可选_
<a name="optional_pattern"></a> <a name="optional_pattern"></a>
## 可选模式（Optional Pattern） ## 可选模式（Optional Pattern）
@ -158,7 +162,7 @@ for case let number? in arrayOfOptinalInts {
``` ```
> 可选模式语法 > 可选模式语法
> *可选模式* → [*标识符模式*](..\chapter3\03_Types.html#type_identifier) ? > *可选模式* → [*标识符模式*](../chapter3/03_Types.html#type_identifier) ?
<a name="type-casting_patterns"></a> <a name="type-casting_patterns"></a>
## 类型转换模式（Type-Casting Patterns） ## 类型转换模式（Type-Casting Patterns）
@ -175,9 +179,9 @@ for case let number? in arrayOfOptinalInts {
关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。 关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。
> 类型转换模式语法 > 类型转换模式语法
> *type-casting-pattern* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern) > *type-casting-pattern* → [*is模式*](../chapter3/07_Patterns.html#is_pattern) | [*as模式*](../chapter3/07_Patterns.html#as_pattern)
> *is模式* → **is** [*类型*](..\chapter3\03_Types.html#type) > *is模式* → **is** [*类型*](../chapter3/03_Types.html#type)
> *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*类型*](..\chapter3\03_Types.html#type) > *as模式* → [*模式*](../chapter3/07_Patterns.html#pattern) **as** [*类型*](../chapter3/03_Types.html#type)
<a name="expression_pattern"></a> <a name="expression_pattern"></a>
## 表达式模式（Expression Pattern） ## 表达式模式（Expression Pattern）
@ -216,4 +220,4 @@ default:
``` ```
> 表达式模式语法 > 表达式模式语法
> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression) > *表达式模式* → [*表达式*](../chapter3/04_Expressions.html#expression)

20
source/chapter3/08_Generic_Parameters_and_Arguments.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[fd5788](https://github.com/fd5788) > 翻译：[fd5788](https://github.com/fd5788)
> 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai), [wardenNScaiyi](https:github.com/wardenNScaiyi) > 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[wardenNScaiyi](https:github.com/wardenNScaiyi)
# 泛型参数 # 泛型参数
--------- ---------
@ -67,15 +71,15 @@ simpleMax(3.14159, 2.71828) // T被推断出为Double类型
> 泛型形参子句语法 > 泛型形参子句语法
> *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>** > *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**
> *泛型参数列表* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) > *泛型参数列表* → [*泛形参数*](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_name) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *泛形参数* → [*类型名称*](../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) > *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)
> *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list) > *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list)
> *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list) > *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list)
> *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement) > *约束* → [*一致性约束*](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#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#protocol_composition_type)
> *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型标识*](..\chapter3\03_Types.html#type_identifier) > *同类型约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **==** [*类型标识*](../chapter3/03_Types.html#type_identifier)
<a name="generic_argument"></a> <a name="generic_argument"></a>
@ -109,4 +113,4 @@ let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
> 泛型实参子句语法 > 泛型实参子句语法
> *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>** > *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>**
> *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) > *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list)
> *泛型参数* → [*类型*](..\chapter3\03_Types.html#type) > *泛型参数* → [*类型*](../chapter3/03_Types.html#type)

636
source/chapter3/09_Summary_of_the_Grammar.md
View File

File diff suppressed because it is too large Load Diff

112
source/chapter3/10_Statements.md
View File

@ -1,5 +1,9 @@
> 翻译：[coverxit](https://github.com/coverxit),[littledogboy](https://github.com/littledogboy) > 1.0
> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),[littledogboy](https://github.com/littledogboy) > 翻译：[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)
<a name="statement_statements"></a> <a name="statement_statements"></a>
# 语句 # 语句
@ -19,14 +23,14 @@
是否将分号（`;`）添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句，请务必使用分号。 是否将分号（`;`）添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句，请务必使用分号。
> 语句语法 > 语句语法
> *语句* → [*表达式*](..\chapter3\04_Expressions.html#expression) **;** _可选_ > *语句* → [*表达式*](../chapter3/04_Expressions.html#expression) **;** _可选_
> *语句* → [*声明*](..\chapter3\05_Declarations.html#declaration) **;** _可选_ > *语句* → [*声明*](../chapter3/05_Declarations.html#declaration) **;** _可选_
> *语句* → [*循环语句*](..\chapter3\10_Statements.html#loop_statement) **;** _可选_ > *语句* → [*循环语句*](../chapter3/10_Statements.html#loop_statement) **;** _可选_
> *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_ > *语句* → [*分支语句*](../chapter3/10_Statements.html#branch_statement) **;** _可选_
> *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement) > *语句* → [*标记语句(Labeled Statement)*](../chapter3/10_Statements.html#labeled_statement)
> *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_ > *语句* → [*控制转移语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_
> *语句* → [*XXX语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_ > *语句* → [*XXX语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_
> *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_ > *多条语句(Statements)* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_
<a name="loop_statements"></a> <a name="loop_statements"></a>
## 循环语句 ## 循环语句
@ -36,10 +40,10 @@
通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。 通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
> 循环语句语法 > 循环语句语法
> *循环语句* → [*for语句*](..\chapter3\10_Statements.html#for_statement) > *循环语句* → [*for语句*](../chapter3/10_Statements.html#for_statement)
> *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement) > *循环语句* → [*for-in语句*](../chapter3/10_Statements.html#for_in_statement)
> *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement) > *循环语句* → [*while语句*](../chapter3/10_Statements.html#wheetatype类型ile_statement)
> *循环语句* → [*do-while语句*](..\chapter3\10_Statements.html#do_while_statement) > *循环语句* → [*do-while语句*](../chapter3/10_Statements.html#do_while_statement)
<a name="for_statements"></a> <a name="for_statements"></a>
### For 语句 ### For 语句
@ -64,9 +68,9 @@
在 *initialzation* 中定义的变量仅在`for`循环的作用域内有效。*condition* 表达式的值的类型必须遵循`BooleanType `协议。 在 *initialzation* 中定义的变量仅在`for`循环的作用域内有效。*condition* 表达式的值的类型必须遵循`BooleanType `协议。
> For 循环语法 > 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语句* → **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初始条件* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration) | [*表达式列表*](../chapter3/04_Expressions.html#expression_list)
<a name="for-in_statements"></a> <a name="for-in_statements"></a>
@ -83,7 +87,7 @@
`for-in`语句在循环开始前会调用 *collection* 表达式的`generate`方法来获取一个生成器类型（这是一个遵循`Generator`协议的类型）的值。接下来循环开始，调用 *collection* 表达式的`next`方法。如果其返回值不是`None`，它将会被赋给 *item*，然后执行 *statements*，执行完毕后回到循环开始处；否则，将不会赋值给 *item* 也不会执行 *statements*，`for-in`至此执行完毕。 `for-in`语句在循环开始前会调用 *collection* 表达式的`generate`方法来获取一个生成器类型（这是一个遵循`Generator`协议的类型）的值。接下来循环开始，调用 *collection* 表达式的`next`方法。如果其返回值不是`None`，它将会被赋给 *item*，然后执行 *statements*，执行完毕后回到循环开始处；否则，将不会赋值给 *item* 也不会执行 *statements*，`for-in`至此执行完毕。
> For-In 循环语法 > For-In 循环语法
> *for-in语句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block) > *for-in语句* → **for** [*模式*](../chapter3/07_Patterns.html#pattern) **in** [*表达式*](../chapter3/04_Expressions.html#expression) [*代码块*](../chapter3/05_Declarations.html#code_block)
<a name="while_statements"></a> <a name="while_statements"></a>
@ -108,17 +112,17 @@
*condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。 *condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> While 循环语法 > While 循环语法
> *while语句* → **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) > *while语句* → **while** [*while条件*](../chapter3/10_Statements.html#while_condition) [*代码块*](../chapter3/05_Declarations.html#code_block)
> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration) > *条件* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*声明*](../chapter3/05_Declarations.html#declaration)
> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) > *条件* → [*表达式*](../chapter3/04_Expressions.html#expression)
> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*条件列表*](TODO) > *条件* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*条件列表*](TODO)
> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [*表达式*](..\chapter3\04_Expressions.html#expression) > *条件* → [*可用条件*](../chapter3/10_Statement.html#availability) [*表达式*](../chapter3/04_Expressions.html#expression)
> *条件列表* → [*条件条件*](TODO) [*条件列表*](TODO) > *条件列表* → [*条件条件*](TODO) [*条件列表*](TODO)
> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [可选绑定条件](../chapter2/01_The_Basics.html#optional_binding) > *条件* → [*可用条件*](../chapter3/10_Statement.html#availability) [可选绑定条件](../chapter2/01_The_Basics.html#optional_binding)
> *case条件* → **case** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO) [where](DOTO) > *case条件* → **case** [*模式*](../chapter3/07_Patterns.html#pattern) [构造器](TODO) [where](DOTO)
> *可选绑定条件* → [可选绑定头](TODO) [持续可选绑定](TODO) [持续可选绑定列表](TODO) > *可选绑定条件* → [可选绑定头](TODO) [持续可选绑定](TODO) [持续可选绑定列表](TODO)
> *可选绑定头* → **let** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO) **var** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO) > *可选绑定头* → **let** [*模式*](../chapter3/07_Patterns.html#pattern) [构造器](TODO) **var** [*模式*](../chapter3/07_Patterns.html#pattern) [构造器](TODO)
> *可持续绑定列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) | [构造器](TODO) [可选绑定头](TODO) > *可持续绑定列表* → [*模式*](../chapter3/07_Patterns.html#pattern) | [构造器](TODO) [可选绑定头](TODO)
> >
@ -145,7 +149,7 @@
*condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。 *condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> Repeat-While 循环语法 > Repeat-While 循环语法
> * repeat-while语句* → **repeat** [*代码块*](..\chapter3\05_Declarations.html#code_block) **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) > * repeat-while语句* → **repeat** [*代码块*](../chapter3/05_Declarations.html#code_block) **while** [*while条件*](../chapter3/10_Statements.html#while_condition)
<a name="branch_statements"></a> <a name="branch_statements"></a>
## 分支语句 ## 分支语句
@ -155,8 +159,8 @@
`switch`语句中的控制流可以用`break`语句修改，详情请见[Break 语句](#break_statement)。 `switch`语句中的控制流可以用`break`语句修改，详情请见[Break 语句](#break_statement)。
> 分支语句语法 > 分支语句语法
> *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement) > *分支语句* → [*if语句*](../chapter3/10_Statements.html#if_statement)
> *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement) > *分支语句* → [*switch语句*](../chapter3/10_Statements.html#switch_statement)
<a name="if_statements"></a> <a name="if_statements"></a>
@ -194,9 +198,9 @@
`if`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。 `if`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> If语句语法 > If语句语法
> *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_ > *if语句* → **if** [*if条件*](../chapter3/10_Statements.html#if_condition) [*代码块*](../chapter3/05_Declarations.html#code_block) [*else(Clause)*](../chapter3/10_Statements.html#else_clause) _可选_
> *if条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration) > *if条件* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*声明*](../chapter3/05_Declarations.html#declaration)
> *else(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement) > *else(Clause)* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if语句*](../chapter3/10_Statements.html#if_statement)
<a name="guard_statements"></a> <a name="guard_statements"></a>
@ -266,15 +270,15 @@ case let (x, y) where x == y:
当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这就意味着，如果你想执行下一个 case 分支，需要显式地在你需要的 case 分支里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，详情参见 [Fallthrough 语句](#fallthrough_statement)。 当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这就意味着，如果你想执行下一个 case 分支，需要显式地在你需要的 case 分支里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，详情参见 [Fallthrough 语句](#fallthrough_statement)。
> Switch语句语法 > Switch语句语法
> *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}** > *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列表* → [*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) [*多条语句(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) **;** > *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标签* → **case** [*case项列表*](../chapter3/10_Statements.html#case_item_list) **:**
> *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) > *case项列表* → [*模式*](../chapter3/07_Patterns.html#pattern) [*guard-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ | [*模式*](../chapter3/07_Patterns.html#pattern) [*guard-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](../chapter3/10_Statements.html#case_item_list)
> *default标签* → **default** **:** > *default标签* → **default** **:**
> *where-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard) > *where-clause* → **where** [*guard-expression*](../chapter3/10_Statements.html#guard)
> *where-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression) > *where-expression* → [*表达式*](../chapter3/04_Expressions.html#expression)
<a name="labeled_statements"></a> <a name="labeled_statements"></a>
<a name="control_transfer_statements"></a> <a name="control_transfer_statements"></a>
@ -287,9 +291,9 @@ case let (x, y) where x == y:
关于使用带标签的语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 关于使用带标签的语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
> 标记语句语法 > 标记语句语法
> *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*switch语句*](..\chapter3\10_Statements.html#switch_statement) > *标记语句(Labeled Statement)* → [*语句标签*](../chapter3/10_Statements.html#statement_label) [*循环语句*](../chapter3/10_Statements.html#loop_statement) | [*语句标签*](../chapter3/10_Statements.html#statement_label) [*switch语句*](../chapter3/10_Statements.html#switch_statement)
> *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:** > *语句标签* → [*标签名称*](../chapter3/10_Statements.html#label_name) **:**
> *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) > *标签名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)
<a name="control_transfer_statements"></a> <a name="control_transfer_statements"></a>
## 控制传递语句 ## 控制传递语句
@ -297,11 +301,11 @@ case let (x, y) where x == y:
通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。 通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。
> 控制传递语句(Control Transfer Statement) 语法 > 控制传递语句(Control Transfer Statement) 语法
> *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement) > *控制传递语句* → [*break语句*](../chapter3/10_Statements.html#break_statement)
> *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement) > *控制传递语句* → [*continue语句*](../chapter3/10_Statements.html#continue_statement)
> *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement) > *控制传递语句* → [*fallthrough语句*](../chapter3/10_Statements.html#fallthrough_statement)
> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement) > *控制传递语句* → [*return语句*](../chapter3/10_Statements.html#return_statement)
> *控制传递语句* → [*throw语句*](..\chapter3\10_Statements.html#throw_statement) > *控制传递语句* → [*throw语句*](../chapter3/10_Statements.html#throw_statement)
<a name="break_statements"></a> <a name="break_statements"></a>
### Break 语句 ### Break 语句
@ -320,7 +324,7 @@ 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.html)一章的 [Break](../chapter2/05_Control_Flow.html#break) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
> Break 语句语法 > Break 语句语法
> *break语句* → **break** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_ > *break语句* → **break** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_
<a name="continue_statements"></a> <a name="continue_statements"></a>
### Continue 语句 ### Continue 语句
@ -341,7 +345,7 @@ case let (x, y) where x == y:
关于使用`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.html)一章的 [Continue](../chapter2/05_Control_Flow.html#continue) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
> Continue 语句语法 > Continue 语句语法
> *continue语句* → **continue** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_ > *continue语句* → **continue** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_
<a name="fallthrough_statements"></a> <a name="fallthrough_statements"></a>
### Fallthrough 语句 ### Fallthrough 语句
@ -370,7 +374,7 @@ case let (x, y) where x == y:
而当只写`return`时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为`Void`或`()`） 而当只写`return`时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为`Void`或`()`）
> Return 语句语法 > Return 语句语法
> *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ > *return语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_
<a name="availability_statements"></a> <a name="availability_statements"></a>
### Availability 语句 ### Availability 语句
@ -472,9 +476,9 @@ swift 中的 do 语句与C 中限定代码块界限的大括号 （{}）很相
关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。 关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。
> do 语句语法 → **do** *[*代码块*](..\chapter3\05_Declarations.html#code_block) [catch](TODO)* > do 语句语法 → **do** *[*代码块*](../chapter3/05_Declarations.html#code_block) [catch](TODO)*
> catch → *[catch子句](TODO) [catch子句](TODO)* > catch → *[catch子句](TODO) [catch子句](TODO)*
> catch → **catch** *[*模式*](..\chapter3\07_Patterns.html#pattern)** *可选的* [*where*]() *可选的* [*代码块*](..\chapter3\05_Declarations.html#code_block) > catch → **catch** *[*模式*](../chapter3/07_Patterns.html#pattern)** *可选的* [*where*]() *可选的* [*代码块*](../chapter3/05_Declarations.html#code_block)