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

6
source/chapter3/01_About_the_Language_Reference.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[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)
> 校对：[numbbbbb](https://github.com/numbbbbb)
> 2.0
> 翻译+校对：[buginux]([KYawn](https://github.com/buginux)
# 词法结构
-----------------
@ -202,14 +206,14 @@ true // 布尔型字面量
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> **"**
<a id="quoted_text"></a>
> *引用文本* → [*引用文本条目*](#quoted_text_item) [*引用文本*](#quoted_text) <sub>可选</sub>
> *引用文本条目* → [*转义字符*](#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的字符**
> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**
> *转义字符* → **\u {** [*unicode标量数字*](#unicode_scalar_digits) **}**
@ -218,7 +222,7 @@ let x = 3; "1 2 \(x)"
<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 字符。也可以使用两个或者多个的点号来自定义运算符（比如, `....`）。虽然可以自定义包含问号`?`的运算符，但是这个运算符不能只包含单独的一个问号。
@ -238,7 +242,7 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基
在某些特定的构造中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `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>

46
source/chapter3/03_Types.md
View File

@ -1,6 +1,10 @@
> 1.0
> 翻译：[lyuka](https://github.com/lyuka)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[EudeMorgen](https://github.com/EudeMorgen)
# 类型（Types）
-----------------
@ -27,7 +31,7 @@ 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>
##类型注解
@ -43,7 +47,7 @@ func someFunction(a: Int){ /* ... */ }
类型注解可以在类型之前包含一个类型特性（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>
##类型标识符
@ -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)
<a name="tuple_type"></a>
@ -79,10 +83,10 @@ var someValue: ExampleModule.MyType
`void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含的元素个数在两个及以上时才可以命名元组元素。
> 元组类型语法
> *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)**
> *元组类型主体* → [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_
> *元组类型的元素列表* → [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list)
> *元组类型的元素* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](..\chapter3\03_Types.html#type) | **inout** _可选_ [*元素名*](..\chapter3\03_Types.html#element_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation)
> *元组类型* → **(** [*元组类型主体*](../chapter3/03_Types.html#tuple_type_body) _可选_ **)**
> *元组类型主体* → [*元组类型的元素列表*](../chapter3/03_Types.html#tuple_type_element_list) **...** _可选_
> *元组类型的元素列表* → [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) | [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) **,** [*元组类型的元素列表*](../chapter3/03_Types.html#tuple_type_element_list)
> *元组类型的元素* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](../chapter3/03_Types.html#type) | **inout** _可选_ [*元素名*](../chapter3/03_Types.html#element_name) [*类型注解*](../chapter3/03_Types.html#type_annotation)
> *元素名* → [*标识符*](LexicalStructure.html#identifier)
<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）的相关描述见章节抛出函数与方法和重抛函数与方法。
> 函数类型语法
> *函数类型* → [*类型*](..\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>
##数组类型
@ -140,7 +144,7 @@ var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
关于Swift标准库中`Array`类型的细节讨论，见章节Arrays。
> 数组类型语法
> *数组类型* → [*类型*](..\chapter3\03_Types.html#type)
> *数组类型* → [*类型*](../chapter3/03_Types.html#type)
<a name="dictionary_type"></a>
##字典类型
@ -161,7 +165,7 @@ let someDictionary: Dictionary<String, Int> = ["Alex": 31, "Paul": 39]
关于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>
##可选类型
@ -191,7 +195,7 @@ optionalInteger! // 42
更多细节以及更多如何使用可选类型的例子，见章节Optionals。
> 可选类型语法
> *可选类型* → [*类型*](..\chapter3\03_Types.html#type) **?**
> *可选类型* → [*类型*](../chapter3/03_Types.html#type) **?**
<a name="implicitly_unwrapped_optional_type"></a>
##隐式解析可选类型
@ -215,7 +219,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
关于隐式解析可选的更多细节，见章节Implicitly Unwrapped Optionals。
> 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法
> *隐式解析可选类型* → [*类型*](..\chapter3\03_Types.html#type) **!**
> *隐式解析可选类型* → [*类型*](../chapter3/03_Types.html#type) **!**
<a name="protocol_composition_type"></a>
##协议合成类型
@ -233,9 +237,9 @@ protocol<Protocol 1, Procotol 2>
协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能遵循。
> 协议合成类型语法
> *协议合成类型* → **protocol** **<** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>**
> *协议标识符列表* → [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) | [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list)
> *协议标识符* → [*类型标识*](..\chapter3\03_Types.html#type_identifier)
> *协议合成类型* → **protocol** **<** [*协议标识符列表*](../chapter3/03_Types.html#protocol_identifier_list) _可选_ **>**
> *协议标识符列表* → [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) | [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) **,** [*协议标识符列表*](../chapter3/03_Types.html#protocol_identifier_list)
> *协议标识符* → [*类型标识*](../chapter3/03_Types.html#type_identifier)
<a name="metatype_type"></a>
##元类型
@ -268,7 +272,7 @@ someInstance.dynamicType.printClassName()
> 元(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>
##类型继承子句
@ -282,10 +286,10 @@ someInstance.dynamicType.printClassName()
枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举——一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节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#type_identifier) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承列表*](..\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#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>

207
source/chapter3/04_Expressions.md
View File

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

568
source/chapter3/05_Declarations.md
View File

@ -1,8 +1,12 @@
> 1.0
> 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
> 2.0
> 翻译+校对：[Lenhoon](https://github.com/Lenhoon)
<a name="declarations"></a>
# 声明
# 声明
-----------------
本页包含内容：
@ -84,9 +88,9 @@ Swift的源文件中的顶级代码由零个或多个语句，声明和表达式
<a name="grammer_of_an_import_declaration"></a>
> 导入(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**
> *导入路径* → [*导入路径标识符*](..\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)
<a name="constant_declaration"></a>
@ -96,9 +100,9 @@ Swift的源文件中的顶级代码由零个或多个语句，声明和表达式
> let `constant name`: `type` = `expression`
当常量的值被给定后，常量就将*常量名称(constant name)*和*表达式(expression)*初始值不变的结合在了一起，而且不能更改。
当常量的值被给定后，常量就将*常量名称(constant name)*和*表达式(expression)*初始值不变的结合在了一起，而且不能更改。
这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，它被认为是一个*常量属性(constant property)*。常量并不是可计算的属性，因此不包含getters和setters。
@ -111,9 +115,9 @@ let (firstNumber, secondNumber) = (10, 42)
在上例中，`firstNumber`是一个值为`10`的常量，`secnodeName`是一个值为`42`的常量。所有常量都可以独立的使用：
```swift
println("The first number is \(firstNumber).")
println("The first number is /(firstNumber).")
// prints "The first number is 10."
println("The second number is \(secondNumber).")
println("The second number is /(secondNumber).")
// prints "The second number is 42."
```
@ -122,26 +126,26 @@ println("The second number is \(secondNumber).")
声明一个常量类型属性要使用关键字`static`声明修饰符。类型属性在[类型属性(Type Properties)](TODO)中有介绍。
如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看[常量和变量(Constants and Variables)](TODO)和[存储属性(Stored Properties)](TODO)等节。
<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)
> *模式构造器列表* → [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)
> *模式构造器* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_
> *构造器* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)
> *常量声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list)
> *模式构造器列表* → [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) | [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list)
> *模式构造器* → [*模式*](../chapter3/07_Patterns.html#pattern) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_
> *构造器* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)
<a name="variable_declaration"></a>
##变量声明
*变量声明(variable declaration)*可以在程序里声明一个变量，它以关键字`var`来声明。
*变量声明(variable declaration)*可以在程序里声明一个变量，它以关键字`var`来声明。
变量声明有几种不同的形式声明不同种类的命名值和计算型值，如存储和计算变量和属性，存储变量和属性监视，和静态变量属性。所使用的声明形式取决于变量所声明的范围和打算声明的变量类型。
>注意：
>也可以在协议声明的上下文声明属性，详情参见[协议属性声明(Protocal Property Declaration)](TODO)。
>也可以在协议声明的上下文声明属性，详情参见[协议属性声明(Protocal Property Declaration)](TODO)。
可以重载一个子类中的属性，通过使用'override'声明修饰符来标记子类的属性声明，[重写(Overriding)](TODO)中有所介绍。
<a name="stored_variables_and_stored_variable_properties"></a>
###存储型变量和存储型属性
@ -157,7 +161,7 @@ println("The second number is \(secondNumber).")
对于常量的定义，如果*变量名字（variable name）*是一个元组（tuple），元组中每一项的名称都要和初始化*表达式(expression)*中的相应值一致。
正如名字一样，存储型变量的值或存储型变量属性存储在内存中。
<a name="computed_variables_and_computed_properties"></a>
###计算型变量和计算型属性
@ -182,7 +186,7 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
不像存储型变量和存储型属性那样，计算型属性和计算型变量的值不存储在内存中。
获得更多信息，查看更多关于计算型属性的例子，请查看[计算型属性(Computed Properties)](TODO)一节。
<a name="stored_variable_observers_and_property_observers"></a>
###存储型变量监视器和属性监视器
@ -215,8 +219,8 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
当提供一个`willset`语句时，`didset`语句是可选的。同样的，在提供了一个`didset`语句时，`willset`语句是可选的。
获得更多信息，查看如何使用属性监视器的例子，请查看[属性监视器(Property Observers)](TODO)一节。
声明修饰符
声明修饰符
<a name="type_variable_properties"></a>
###类型变量属性
@ -225,30 +229,30 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
>>注意
>>
>在一个类声明中，关键字`static`与用声明修饰符`class`和`final`去标记一个声明的效果相同
<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#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)
> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*构造器*](..\chapter3\05_Declarations.html#initializer) [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)
> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)
> *变量声明头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var**
> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list)
> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*代码块*](../chapter3/05_Declarations.html#code_block)
> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*getter-setter块*](../chapter3/05_Declarations.html#getter_setter_block)
> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)
> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*构造器*](../chapter3/05_Declarations.html#initializer) [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block)
> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block)
> *变量声明头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var**
> *变量名称* → [*标识符*](LexicalStructure.html#identifier)
> *getter-setter块* → **{** [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) _可选_ **}**
> *getter-setter块* → **{** [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) **}**
> *getter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **get** [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *setter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **set** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *getter-setter块* → **{** [*getter子句*](../chapter3/05_Declarations.html#getter_clause) [*setter子句*](../chapter3/05_Declarations.html#setter_clause) _可选_ **}**
> *getter-setter块* → **{** [*setter子句*](../chapter3/05_Declarations.html#setter_clause) [*getter子句*](../chapter3/05_Declarations.html#getter_clause) **}**
> *getter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block)
> *setter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)
> *setter名称* → **(** [*标识符*](LexicalStructure.html#identifier) **)**
> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可选_ **}**
> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) **}**
> *getter关键字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **get**
> *setter关键字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **set**
> *willSet-didSet代码块* → **{** [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) _可选_ **}**
> *willSet-didSet代码块* → **{** [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) **}**
> *willSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *didSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) _可选_ **}**
> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) **}**
> *getter关键字(Keyword)子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get**
> *setter关键字(Keyword)子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set**
> *willSet-didSet代码块* → **{** [*willSet子句*](../chapter3/05_Declarations.html#willSet_clause) [*didSet子句*](../chapter3/05_Declarations.html#didSet_clause) _可选_ **}**
> *willSet-didSet代码块* → **{** [*didSet子句*](../chapter3/05_Declarations.html#didSet_clause) [*willSet子句*](../chapter3/05_Declarations.html#willSet_clause) **}**
> *willSet子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)
> *didSet子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)
<a name="type_alias_declaration"></a>
##类型的别名声明
@ -260,13 +264,13 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
当声明一个类型的别名后，可以在程序的任何地方使用别*名(name)*来代替*已存在的类型(existing type)*。已存在的类型可以是已经被命名的类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。
查看更多[协议关联类型声明(Protocol Associated Type Declaration)](TODO).
<a name="grammer_of_a_type_alias_declaration"></a>
> 类型别名声明语法
> *类型别名声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment)
> *类型别名头(Head)* → [*属性列表*](todo) _可选_ [*访问级别修饰符*]((TODO) _可选_ **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name)
> *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment)
> *类型别名头(Head)* → [*属性列表*](todo) _可选_ [*访问级别修饰符*]((TODO) _可选_ **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name)
> *类型别名名称* → [*标识符*](LexicalStructure.html#identifier)
> *类型别名赋值* → **=** [*类型*](..\chapter3\03_Types.html#type)
> *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type)
<a name="function_declaration"></a>
##函数声明
@ -289,7 +293,7 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
函数可以使用元组类型作为返回值来返回多个变量。
函数定义可以出现在另一个函数声明内。这种函数被称作nested函数。更多关于*嵌套函数(Nested Functions)*的讨论，参见[嵌套函数(Nested Functions)](TODO)。
<a name="parameter_names"></a>
###参数名
@ -301,7 +305,7 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
一个参数有一个内部名称，这个内部名称可以在函数体内被使用。同样也可以作为外部名称，当调用方法时这个外部名称被作为实参的标签来使用。默认情况下，第一个参数的外部名称省略不写，第二个和其之后的参数使用它们的内部名称作为它们的外部名称。
```swift
func f(x: Int, y: Int) -> Int{ return x + y}
func f(x: Int, y: Int) -> Int{ return x + y}
f(1, y: 2) // y是有标记的，x没有
```
@ -309,17 +313,17 @@ f(1, y: 2) // y是有标记的，x没有
> `external parameter name` `local parameter name`: `parameter type`
> _ `local parameter name`: `parameter type`
在内部参数名前的名称赋予这个参数一个外部名称，这个名称可以和内部参数的名称不同。外部参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有外部名 。
内部参数名前的强调字符下划线(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
```swift
func f(x x: Int, withY y: Int, _z: Int) -> Int{
return x + y + z }
f(x: 1, withY: 2, 3) // x和y是有标记的，z没有
内部参数名前的强调字符下划线(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
```swift
func f(x x: Int, withY y: Int, _z: Int) -> Int{
return x + y + z }
f(x: 1, withY: 2, 3) // x和y是有标记的，z没有
```
<a name="special_kinds_of_parameters"></a>
###特殊类型的参数
@ -333,13 +337,13 @@ f(x: 1, withY: 2, 3) // x和y是有标记的，z没有
一个以基础类型名的参数，如果紧跟着三个点(`...`)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数`Int...`被看做是`[Int]`。查看可变参数的使用例子，详见[可变参数(Variadic Parameters)](TODO)一节。
在参数的类型后面有一个以等号(`=`)连接的表达式，这样的参数被看做有着给定表达式的初始值。当函数被调用时，给定的表达式被求值。如果参数在函数调用时被省略了，就会使用初始值。
```swift
func f(x: Int = 42) -> Int { return x}
f() // 有效的，使用默认值
f(7) // 有效的，提供了值，没有提供值的名称
f(x: 7) //无效的，值和值的名称都提供了
在参数的类型后面有一个以等号(`=`)连接的表达式，这样的参数被看做有着给定表达式的初始值。当函数被调用时，给定的表达式被求值。如果参数在函数调用时被省略了，就会使用初始值。
```swift
func f(x: Int = 42) -> Int { return x}
f() // 有效的，使用默认值
f(7) // 有效的，提供了值，没有提供值的名称
f(x: 7) //无效的，值和值的名称都提供了
```
<a name="special_kinds_of_methods"></a>
###特殊方法
@ -347,9 +351,9 @@ f(x: 7) //无效的，值和值的名称都提供了
枚举或结构体的方法来修改`self`属性，必须以`mutating`声明修饰符标记。
子类方法重写超类中的方法必须以`override`声明修饰符标记。重写一个方法不使用`override`修饰符，或者使用了`override`修饰符却并没有重写超类方法都会产生一个编译时错误。
枚举或者结构体中的类型方法而不是实例方法，要以`static`声明修饰符标记，而对于类中的类型方法，要使用`class`声明修饰符标记。
<a name="curried_functions"></a>
###柯里化函数(Curried Functions)
@ -383,7 +387,7 @@ func addTwoIntsCurried(a a: Int)(b: Int) -> Int {
return a + b
}
func addTwoIntsCurried(a a: Int) -> (Int -> Int)
func addTwoIntsCurried(a a: Int) -> (Int -> Int)
{
func addTheOtherInt(b: Int) -> Int {
return a + b
@ -413,64 +417,64 @@ let plusOne = addTwoIntsCurried(a: 1)
```swift
plusOne(10)
// 返回值为11
```
<a name="throwing_functions_and_methods"></a>
###抛出异常函数和抛出异常方法(Throwing Functions and Methods)
可以抛出一个错误的函数或方法必需使用`throws`关键字标记。这些函数和方法被称为*抛出异常函数(throwing functions)*和*抛出异常方法(throwing methods)*。它们有着下面的形式:
> func `function name`(`parameters`) throws ->
> `return type` {
> `statements`
> }
调用一个抛出异常函数或抛出异常方法必需用一个`try`或者`try!`表达式来封装（也就是说，在一个范围内使用一个`try`或者`try!`运算符）。
`throws`关键字是函数的类型的一部分，不抛出异常的函数是抛出异常函数的一个子类型。所以，可以在使用抛出异常函数的地方使用不抛出异常函数。对于柯里化函数，`throws`关键字仅运用于最内层的函数。
不能重写一个仅基于是否能抛出错误的函数。也就是说，可以重载一个基于函数*参数(parameter)*能否抛出一个错误的函数。
一个抛出异常的方法不能重写一个不能抛出异常的方法，而且一个异常抛出方法不能满足一个协议对于不抛出异常方法的需求。也就是说，一个不抛出异常的方法可以重写一个抛出异常的方法，而且一个不抛出异常的方法可以满足一个协议对于抛出异常的需求。
<a name="rethrowing_functions_and_methods"></a>
###重抛出异常函数和重抛出异常方法(Rethrowing Functions and Methods)
一个函数或方法可以使用`rethrows`关键字来声明，从而表明仅当这个函数或方法的一个函数参数抛出错误时这个函数或方法才抛出错误。这些函数和方法被称为*重抛出异常函数(rethrowing functions)*和*重抛出异常方法(rethrowing methods)*。重抛出异常函数或方法必需有至少一个抛出异常函数参数。
```
func functionWithCallback(callback: () throws -> Int) rethrows {
try callback()
}
```
一个抛出异常函数方法不能重写一个重抛出异常函数方法，一个抛出异常方法不能满足一个协议对于重抛出异常方法的需求。也就是说，一个重抛出异常方法可以重写一个抛出异常方法，而且一个重抛出异常方法可以满足一个协议对于抛出异常方法的需求。
```
<a name="throwing_functions_and_methods"></a>
###抛出异常函数和抛出异常方法(Throwing Functions and Methods)
可以抛出一个错误的函数或方法必需使用`throws`关键字标记。这些函数和方法被称为*抛出异常函数(throwing functions)*和*抛出异常方法(throwing methods)*。它们有着下面的形式:
> func `function name`(`parameters`) throws ->
> `return type` {
> `statements`
> }
调用一个抛出异常函数或抛出异常方法必需用一个`try`或者`try!`表达式来封装（也就是说，在一个范围内使用一个`try`或者`try!`运算符）。
`throws`关键字是函数的类型的一部分，不抛出异常的函数是抛出异常函数的一个子类型。所以，可以在使用抛出异常函数的地方使用不抛出异常函数。对于柯里化函数，`throws`关键字仅运用于最内层的函数。
不能重写一个仅基于是否能抛出错误的函数。也就是说，可以重载一个基于函数*参数(parameter)*能否抛出一个错误的函数。
一个抛出异常的方法不能重写一个不能抛出异常的方法，而且一个异常抛出方法不能满足一个协议对于不抛出异常方法的需求。也就是说，一个不抛出异常的方法可以重写一个抛出异常的方法，而且一个不抛出异常的方法可以满足一个协议对于抛出异常的需求。
<a name="rethrowing_functions_and_methods"></a>
###重抛出异常函数和重抛出异常方法(Rethrowing Functions and Methods)
一个函数或方法可以使用`rethrows`关键字来声明，从而表明仅当这个函数或方法的一个函数参数抛出错误时这个函数或方法才抛出错误。这些函数和方法被称为*重抛出异常函数(rethrowing functions)*和*重抛出异常方法(rethrowing methods)*。重抛出异常函数或方法必需有至少一个抛出异常函数参数。
```
func functionWithCallback(callback: () throws -> Int) rethrows {
try callback()
}
```
一个抛出异常函数方法不能重写一个重抛出异常函数方法，一个抛出异常方法不能满足一个协议对于重抛出异常方法的需求。也就是说，一个重抛出异常方法可以重写一个抛出异常方法，而且一个重抛出异常方法可以满足一个协议对于抛出异常方法的需求。
<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)
> *函数头* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **func**
> *函数声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature) [*函数体*](../chapter3/05_Declarations.html#function_body)
> *函数头* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **func**
> *函数名* → [*标识符*](LexicalStructure.html#identifier) | [*运算符*](LexicalStructure.html#operator)
> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **throws** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_
> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_
> *函数结果* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)
> *函数体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *parameter-clauses* → [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可选_
> *参数子句* → **(** **)** | **(** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list) **...** _可选_ **)**
> *参数列表* → [*参数*](..\chapter3\05_Declarations.html#parameter) | [*参数*](..\chapter3\05_Declarations.html#parameter) **,** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list)
> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name)_可选_ [*内部参数名*](..\chapter3\05_Declarations.html#local_parameter_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_
> *参数* → **inout** _可选_ **var** [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name) [*内部参数名*](..\chapter3\05_Declarations.html#local_parameter_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_
> *参数* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)
> *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_
> *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_
> *函数结果* → **->** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)
> *函数体* → [*代码块*](../chapter3/05_Declarations.html#code_block)
> *parameter-clauses* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) _可选_
> *参数子句* → **(** **)** | **(** [*参数列表*](../chapter3/05_Declarations.html#parameter_list) **...** _可选_ **)**
> *参数列表* → [*参数*](../chapter3/05_Declarations.html#parameter) | [*参数*](../chapter3/05_Declarations.html#parameter) **,** [*参数列表*](../chapter3/05_Declarations.html#parameter_list)
> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](../chapter3/05_Declarations.html#parameter_name)_可选_ [*内部参数名*](../chapter3/05_Declarations.html#local_parameter_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*默认参数子句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_
> *参数* → **inout** _可选_ **var** [*外部参数名*](../chapter3/05_Declarations.html#parameter_name) [*内部参数名*](../chapter3/05_Declarations.html#local_parameter_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*默认参数子句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_
> *参数* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)
> *参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**
> *内部参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**
> *默认参数子句* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)
> *默认参数子句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)
<a name="enumeration_declaration"></a>
##枚举声明
在程序里使用*枚举声明(enumeration)*来引入一个枚举类型。
枚举声明有两种基本的形式，使用关键字`enum`来声明。枚举声明体使用从零开始的变量——叫做*枚举事件(enumeration cases)*，和任意数量的声明，包括计算型属性，实例方法，类型方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能包含析构器或者协议声明。
枚举声明有两种基本的形式，使用关键字`enum`来声明。枚举声明体使用从零开始的变量——叫做*枚举事件(enumeration cases)*，和任意数量的声明，包括计算型属性，实例方法，类型方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能包含析构器或者协议声明。
枚举类型可以采用任何数量的协议，但是这些协议不能从类，结构体和其他的枚举继承。
不像类或者结构体。枚举类型并不提供隐式的初始构造器，所有构造器必须显式的声明。构造器可以委托枚举中的其他构造器，但是构造过程仅当构造器将一个枚事件指定给`self`才全部完成。
@ -479,7 +483,7 @@ plusOne(10)
更多关于值类型的信息，参见结构体和枚举都是[值类型(Structures and Enumerations Are Value Types)](TODO)一节。
可以扩展枚举类型，正如在[扩展声明(Extension Declaration)](TODO)中讨论的一样。
<a name="enumerations_with_cases_of_any_type"></a>
###任意事件类型的枚举
@ -494,21 +498,21 @@ plusOne(10)
这种形式中，每一个事件块由关键字`case`开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在*关联值类型(associated values types)*的元组里被指定，立即书写在事件
名后。获得更多关于关联值类型的信息和例子，请查看[关联值(Associated Values)](TODO)一节。
枚举有一个递归结构，就是说，枚举有着枚举类型自身实例的关联值的事件。然而，枚举类型的实例有值语义，意味着它们在内存中有着固定的位置。为了支持递归，编译器必需插入一个间接层。
为间接使用特殊的枚举事件，使用`indirect`声明修饰符标记。
> enum Tree<T> {
> case Empty
> indirect case Node(value: T, left: Tree, right:Tree)
> }
为了间接的使用一个枚举的所有事件，使用`indirect`修饰符标记整个枚举-当枚举有许多事件且每个事件都需要使用`indirect`修饰符标记的时候这将非常便利。
一个被`indirect`修饰符标记的枚举事件必需有一个关联值。一个使用`indirect`修饰符标记的枚举包含有着关联值的事件和没有关联值的事件的混合。就是说，它不能包含任何也使用`indirect`修饰符标记的事件。
枚举有一个递归结构，就是说，枚举有着枚举类型自身实例的关联值的事件。然而，枚举类型的实例有值语义，意味着它们在内存中有着固定的位置。为了支持递归，编译器必需插入一个间接层。
为间接使用特殊的枚举事件，使用`indirect`声明修饰符标记。
> enum Tree<T> {
> case Empty
> indirect case Node(value: T, left: Tree, right:Tree)
> }
为了间接的使用一个枚举的所有事件，使用`indirect`修饰符标记整个枚举-当枚举有许多事件且每个事件都需要使用`indirect`修饰符标记的时候这将非常便利。
一个被`indirect`修饰符标记的枚举事件必需有一个关联值。一个使用`indirect`修饰符标记的枚举包含有着关联值的事件和没有关联值的事件的混合。就是说，它不能包含任何也使用`indirect`修饰符标记的事件。
<a name="enumerations_with_cases_of_a_raw-value_type"></a>
###使用原始值类型事件的枚举(Enumerations with Cases of a Raw-Value Type)
@ -519,8 +523,8 @@ plusOne(10)
> case `enumeration case 2` = `raw value 2`
> }
在这种形式中，每一个事件块由`case`关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做*原始值(raw value)*。这些值的类型在*原始值类型(raw-value type)*中被指定，必须表示一个整数，浮点数，字符串，或者一个字符。特别是*原始值类型(raw-value type)*必需遵守`Equatable`类型的协议和下列形式中的一种字面量构造协议(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮点行字面量有`FloatingPointLiteralConvertible`，包含任意数量字符的字符串型字面量有`StringLiteralConvertible`，仅包含一个单一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。每一个事件必须有唯一的名字，必须有一个唯一的初始值。
在这种形式中，每一个事件块由`case`关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做*原始值(raw value)*。这些值的类型在*原始值类型(raw-value type)*中被指定，必须表示一个整数，浮点数，字符串，或者一个字符。特别是*原始值类型(raw-value type)*必需遵守`Equatable`类型的协议和下列形式中的一种字面量构造协议(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮点行字面量有`FloatingPointLiteralConvertible`，包含任意数量字符的字符串型字面量有`StringLiteralConvertible`，仅包含一个单一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。每一个事件必须有唯一的名字，必须有一个唯一的初始值。
如果初始值类型被指定为`Int`，则不必为事件显式的指定值，它们会隐式的被标为值`0,1,2`等。每一个没有被赋值的`Int`类型时间会隐式的赋予一个初始值，它们是自动递增的。
```Swift
@ -529,44 +533,44 @@ num ExampleEnum: Int {
}
```
在上面的例子中，`ExampleEnum.A`的值是`0`，`ExampleEnum.B`的值是`1`。因为`ExampleEnum.C`的值被显式的设定为`5`，因此`ExampleEnum.D`的值会自动增长为`6`。
如果原始值类型被指定为`String`类型，你不用明确的为事件指定值，每一个没有指定的事件会隐式地用与事件名字相同的字符串指定。
> enum WeekendDay: String {
> case Saturday, Sunday
> }
在上面这个例子中，`WeekendDay.Saturday`的原始值是`"Saturday"`,`WeekendDay.Sunday`的原始值是`"Sunday"`。
在上面的例子中，`ExampleEnum.A`的值是`0`，`ExampleEnum.B`的值是`1`。因为`ExampleEnum.C`的值被显式的设定为`5`，因此`ExampleEnum.D`的值会自动增长为`6`。
如果原始值类型被指定为`String`类型，你不用明确的为事件指定值，每一个没有指定的事件会隐式地用与事件名字相同的字符串指定。
> enum WeekendDay: String {
> case Saturday, Sunday
> }
在上面这个例子中，`WeekendDay.Saturday`的原始值是`"Saturday"`,`WeekendDay.Sunday`的原始值是`"Sunday"`。
拥有多种事件的原始值类型的枚举含蓄地遵循定义在Swift标准库中的`RawRepresentable`协议。所以，它们拥有一个原始值(`rawValue`)属性和一个有着`init?(rawValue: RawValue)`签名的可失败构造器(a failable initializer)。可以使用原始值属性去取的枚举事件的原始值，就像在`ExampleEnum.B.rawValue`中一样。如果有一个事件符合，也可以使用原始值去找到一个符合的事件，通过调用枚举的可失败构造器，如`ExampleEnum(rawValue: 5)`,这个可失败构造器返回一个可选的事件。想得到更多的信息和关于原始值类型查看更多信息和获取初始值类型事件的信息，参阅初始值[原始值(Raw Values)](TODO)。
<a name="accessing_enumeration_cases"></a>
###获得枚举事件
使用点(.)来引用枚举类型的事件，如`EnumerationType.EnumerationCase`。当枚举类型可以上下文推断出时，可以省略它(.仍然需要)，参照枚举语法[(Enumeration Syntax)](TODO)和[显式成员表达(Implicit Member Expression)](TODO)。
使用`switch`语句来检验枚举事件的值，正如使用[switch语句匹配枚举值（Matching Enumeration Values with a Switch Statement)](TODO)一节描述的那样。枚举类型是模式匹配(pattern-matched)的，和其相反的是`switch`语句case块中枚举事件匹配，在[枚举事件类型(Enumeration Case Pattern)](TODO)中有描述。
<a name="grammer_of_an_enumeration_declaration"></a>
> 枚举声明语法
> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO)
> *枚举声明* → [*特性(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) _可选_ **}**
> *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)的枚举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* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组类型*](..\chapter3\03_Types.html#tuple_type) _可选_
> 枚举声明语法
> *枚举声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO)
> *枚举声明* → [*特性(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) _可选_ **}**
> *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)的枚举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* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组类型*](../chapter3/03_Types.html#tuple_type) _可选_
> *枚举名* → [*标识符*](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) **}**
> *原始值式枚举成员列表* → [*原始值式枚举成员*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_
> *原始值式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚举case子句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)
> *原始值式枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)
> *原始值式枚举case列表* → [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)
> *原始值式枚举case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*原始值赋值*](..\chapter3\05_Declarations.html#raw_value_assignment) _可选_
> *原始值赋值* → **=** [*原始值字面量*](TODO)
> *原始值式枚举* → **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#declaration) | [*原始值式枚举case子句*](../chapter3/05_Declarations.html#raw_value_style_enum_case_clause)
> *原始值式枚举case子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case列表*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list)
> *原始值式枚举case列表* → [*原始值式枚举case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case列表*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list)
> *原始值式枚举case* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*原始值赋值*](../chapter3/05_Declarations.html#raw_value_assignment) _可选_
> *原始值赋值* → **=** [*原始值字面量*](TODO)
> *原始值字面量* → [数字型字面量](TODO)|[字符串型字面量](TODO)|[布尔型字面量](TODO)
<a name="structure_declaration"></a>
@ -598,12 +602,12 @@ num ExampleEnum: Int {
[结构体和枚举是值类型(Structures and Enumerations Are Value Types)](TODO)一节。
可以使用扩展声明来扩展结构体类型的行为，参见[扩展声明(Extension Declaration)](TODO)。
<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)
> *结构体主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**
> *结构体主体* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**
<a name="class_declaration"></a>
##类声明
@ -620,8 +624,8 @@ num ExampleEnum: Int {
正如在[初始化声明(Initializer Declaration)](TODO)谈及的那样，类可以有指定构造器和方便构造器。类的指定构造器必须初始化类所有的已声明的属性，它必须在超类构造器调用前被执行。
类可以重写属性，方法，下表脚本和它的超类构造器。重写的属性，方法，下标脚本，和指定构造器必须以`override`声明修饰符标记。
类可以重写属性，方法，下表脚本和它的超类构造器。重写的属性，方法，下标脚本，和指定构造器必须以`override`声明修饰符标记。
为了要求子类去实现超类的构造器，使用`required`声明修饰符去标记超类的构造器。在子类实现父类构造器时也必须使用`required`声明修饰符去标记。
虽然*超类(superclass)*的属性和方法声明可以被当前类继承，但是*超类(superclass)*声明的指定构造器却不能。这意味着，如果当前类重写了超类的所有指定构造器，它就继承了超类的方便构造器。Swift的类并不是继承自一个全局基础类。
@ -629,7 +633,7 @@ num ExampleEnum: Int {
有两种方法来创建已声明的类的实例：
* 调用类的一个构造器，参见[构造器(Initializers)](TODO)。
* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见[默认构造器(Default Initializers)](TODO)。
类实例属性可以用点(.)来获得，详情参见[获得属性(Accessing Properties)](TODO)一节。
@ -637,12 +641,12 @@ num ExampleEnum: Int {
类是引用类型；当被赋予常量或变量，函数调用时，类的实例是被引用，而不是复制。获得更多关于引用类型的信息，[结构体和枚举都是值类型(Structures and Enumerations Are Value Types)](TODO)一节。
可以使用扩展声明来扩展类的行为，参见[扩展声明(Extension Declaration)](TODO)。
<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)
> *类主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**
> *类主体* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**
<a name="protocol_declaration"></a>
##协议声明(translated by 小一)
@ -664,14 +668,14 @@ num ExampleEnum: Int {
默认地，符合某一个协议的类型必须实现所有声明在协议中的属性、方法和下标脚本。也就是说，可以用`optional`声明修饰符标注这些协议成员声明以指定它们的一致性类型实现是可选的。`optional`修饰符仅仅可以用于使用`objc`属性标记过的协议。这样的结果就是仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用`optional`属性的信息及如何访问可选协议成员的指导——比如当不能肯定是否一致性的类型实现了它们——参见[可选协议要求(Optional Protocol Requirements)](../chapter2/21_Protocols.html#optional_protocol_requirements)
为了限制协议的采用仅仅针对类类型，需要强制使用`class`来标记协议，通过将`class`关键在写在冒号后面的*继承协议列表(inherited protocols)*的第一个位置。例如，下面的协议形式只能被类类型采用：
```swift
protocol SomeProtocol:class{
/* Protocol member go here */
}
```
为了限制协议的采用仅仅针对类类型，需要强制使用`class`来标记协议，通过将`class`关键在写在冒号后面的*继承协议列表(inherited protocols)*的第一个位置。例如，下面的协议形式只能被类类型采用：
```swift
protocol SomeProtocol:class{
/* Protocol member go here */
}
```
任意继承自需要标记有`class`协议的协议都可以智能地仅能被类类型采用。
>注意：
@ -680,18 +684,18 @@ protocol SomeProtocol:class{
协议是命名的类型，因此它们可以以另一个命名类型出现在代码的所有地方，就像[协议类型(Protocol as Types)](../chapter2/21_Protocols.html#protocols_as_types)里讨论的那样。然而不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。
可以使用协议来声明一个类的代理的方法或者应该实现的结构，就像[委托(代理)模式(Delegation)](../chapter2/21_Protocols.html#delegation)描述的那样。
<a name="grammer_of_a_protocol_declaration"></a>
> 协议(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)
> *协议主体* → **{** [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_ **}**
> *协议成员声明* → [*协议属性声明*](..\chapter3\05_Declarations.html#protocol_property_declaration)
> *协议成员声明* → [*协议方法声明*](..\chapter3\05_Declarations.html#protocol_method_declaration)
> *协议成员声明* → [*协议构造器声明*](..\chapter3\05_Declarations.html#protocol_initializer_declaration)
> *协议成员声明* → [*协议附属脚本声明*](..\chapter3\05_Declarations.html#protocol_subscript_declaration)
> *协议成员声明* → [*协议关联类型声明*](..\chapter3\05_Declarations.html#protocol_associated_type_declaration)
> *协议成员声明(Declarations)列表* → [*协议成员声明*](..\chapter3\05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_
> *协议主体* → **{** [*协议成员声明(Declarations)列表*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ **}**
> *协议成员声明* → [*协议属性声明*](../chapter3/05_Declarations.html#protocol_property_declaration)
> *协议成员声明* → [*协议方法声明*](../chapter3/05_Declarations.html#protocol_method_declaration)
> *协议成员声明* → [*协议构造器声明*](../chapter3/05_Declarations.html#protocol_initializer_declaration)
> *协议成员声明* → [*协议附属脚本声明*](../chapter3/05_Declarations.html#protocol_subscript_declaration)
> *协议成员声明* → [*协议关联类型声明*](../chapter3/05_Declarations.html#protocol_associated_type_declaration)
> *协议成员声明(Declarations)列表* → [*协议成员声明*](../chapter3/05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)列表*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_
<a name="protocol_property_declaration"></a>
###协议属性声明
@ -705,11 +709,11 @@ protocol SomeProtocol:class{
`getter`和`setter`要求可以通过一致性类型以各种方式满足。如果属性声明包含`get`和`set`关键词，一致性类型就可以用可读写（实现了`getter`和`setter`）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含`get`关键词的话，它可以作为任意类型的属性被实现。比如说实现了协议的属性要求的一致性类型，参见[属性要求(Property Requirements)](../chapter2/21_Protocols.html#property_requirements)
更多参见[变量声明(Variabel Declaration)](../chapter3/05_Declarations.html#variable_declaration)
<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>
###协议方法声明
@ -718,27 +722,27 @@ protocol SomeProtocol:class{
使用`static`声明修饰符可以在协议声明中声明一个类或必需的静态方法。执行这些方法的类用修饰符`class`声明。相反的，执行这些方法的结构体必须以`static`声明修饰符声明。如果想使用扩展方法，在扩展类时使用`class`修饰符，在扩展结构体时使用`static`修饰符。
更多请参阅[函数声明(Function Declaration)](TODO)。
<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>
###协议构造器声明
协议声明了一致性类型必须在协议声明的主体里通过引入一个协议构造器声明来实现一个构造器。协议构造器声明
除了不包含构造器体外，和构造器声明有着相同的形式。
一个一致性类型可以通过实现一个非可失败构造器或者`init!`可失败构造器去满足一个非可失败协议构造器的需求。一个一致性类型通过实现任意类型的构造器可以满足一个可失败协议构造器的需求。
当一个类去实现一个构造器去满足一个协议的构造器的需求，如果这个类还没有用`final`声明修饰符标记，这个构造器必需使用`required`声明修饰符去标记。
除了不包含构造器体外，和构造器声明有着相同的形式。
一个一致性类型可以通过实现一个非可失败构造器或者`init!`可失败构造器去满足一个非可失败协议构造器的需求。一个一致性类型通过实现任意类型的构造器可以满足一个可失败协议构造器的需求。
当一个类去实现一个构造器去满足一个协议的构造器的需求，如果这个类还没有用`final`声明修饰符标记，这个构造器必需使用`required`声明修饰符去标记。
更多请参阅[构造器声明(Initializer Declaration)](TODO)。
<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>
###协议下标脚本声明
@ -749,19 +753,19 @@ protocol SomeProtocol:class{
下标脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果下标脚本申明包含get和set关键字，一致的类型也必须有一个getter和setter语句。如果下标脚本声明值包含get关键字，一致的类型必须*至少(at least)*包含一个getter语句，可以选择是否包含setter语句。
更多参阅[下标脚本声明(Subscript Declaration)](TODO)。
<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>
###协议相关类型声明
协议声明相关类型使用关键字`typealias`。相关类型为作为协议声明的一部分的类型提供了一个别名。相关类型和参数语句中的类型参数很相似，但是它们在声明的协议中包含`self`关键字。在这些语句中，`self`指代和协议一致的可能的类型。获得更多信息和例子，查看[关联类型(Associated Types)](TODO)一节或[类型别名声明(Type Alias Declaration)](TODO)一节。
<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>
##构造器声明
@ -791,64 +795,64 @@ protocol SomeProtocol:class{
便利构造器可以将初始化过程委托给另一个便利构造器或类的一个指定构造器。这意味着，类的初始化过程必须
以一个将所有类属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。
可以使用required声明修饰符，将便利构造器和指定构造器标记为每个子类的构造器都必须实现的。一个子类的关于这个构造器的实现也必须使用`required`声明修饰符标记。
默认情况下，声明在超类的构造器没有被子类继承。也就是说，如果一个子类使用默认的值去构造它所有的存储属性，而且没有定义任何自己的构造器，它将继承超类的构造器。如果子类重写所有超类的指定构造器，子类继承超类的便利构造器。
和方法，属性和下表脚本一样，需要使用`override`声明修饰符标记重写了的制定构造器。
>注意
可以使用required声明修饰符，将便利构造器和指定构造器标记为每个子类的构造器都必须实现的。一个子类的关于这个构造器的实现也必须使用`required`声明修饰符标记。
默认情况下，声明在超类的构造器没有被子类继承。也就是说，如果一个子类使用默认的值去构造它所有的存储属性，而且没有定义任何自己的构造器，它将继承超类的构造器。如果子类重写所有超类的指定构造器，子类继承超类的便利构造器。
和方法，属性和下表脚本一样，需要使用`override`声明修饰符标记重写了的制定构造器。
>注意
>如果使用`required`声明修饰符去标记一个构造器，当在子类中重写必要构造器时，也不要用`override`修饰符去标记构造器。
查看更多关于不同声明方法的构造器的例子，参阅[构造过程(Initialization)](TODO)一节。
<a name="failable_initializers"></a>
###可失败构造器(Failable Initializers)
*可失败构造器*是一种可以生成可选实例或者是一类构造器声明的隐式解析可选实例(an implicitly unwrapped optional instance)类型。所以，构造区通过返回`nil`来指明构造过程失败。
声明可以生成可选实例的可失败构造器，在构造器声明的`init`关键字后加追加一个问号(`init?`)。声明可生成隐式解析可选实例的可失败构造器，在构造器声明后追加一个叹号(`init!`)。使用`init?`可失败构造器生成结构体的一个可选实例的例子如下。
```swift
struct SomeStruct {
let string: String
//生成一个'SomeStruct'的可选实例
init?(input: String) {
if input.isEmpty {
// 弃用'self' 返回 'nil'
}
string = input
}
}
```
除非必需处理结果的可选性，可以使用调用非可失败构造器的方式调用`init?`可失败构造器。
```swift
if let actualInstance = SomeStruct(input: "Hello") {
//'SomeStruct'实例相关
} else {
//'SomeStruct'实例构造过程失败，构造器返回'nil'
}
```
查看更多关于不同声明方法的构造器的例子，参阅[构造过程(Initialization)](TODO)一节。
<a name="failable_initializers"></a>
###可失败构造器(Failable Initializers)
*可失败构造器*是一种可以生成可选实例或者是一类构造器声明的隐式解析可选实例(an implicitly unwrapped optional instance)类型。所以，构造区通过返回`nil`来指明构造过程失败。
声明可以生成可选实例的可失败构造器，在构造器声明的`init`关键字后加追加一个问号(`init?`)。声明可生成隐式解析可选实例的可失败构造器，在构造器声明后追加一个叹号(`init!`)。使用`init?`可失败构造器生成结构体的一个可选实例的例子如下。
```swift
struct SomeStruct {
let string: String
//生成一个'SomeStruct'的可选实例
init?(input: String) {
if input.isEmpty {
// 弃用'self' 返回 'nil'
}
string = input
}
}
```
除非必需处理结果的可选性，可以使用调用非可失败构造器的方式调用`init?`可失败构造器。
```swift
if let actualInstance = SomeStruct(input: "Hello") {
//'SomeStruct'实例相关
} else {
//'SomeStruct'实例构造过程失败，构造器返回'nil'
}
```
在实现构造体的任何时间，结构体或者枚举的可失败构造器可以返回`nil`。然而，类的可失败构造器，仅在类的所有存储属性被构造之后且`self.init`或`super.init`被调用之后才返回`nil`（就是说，构造器的委托被执行）。
可失败构造器可以委托任何种类的构造器。非可失败可以委托其它非可失败构造器或者`init!`可失败构造器。
构造过程的失败由构造器的委托产生。特别的，如果可失败构造器代理一个构造器失败且返回`nil`，那么之后被委托的构造器也会失败且隐式的返回`nil`。如果非可失败构造器代理`init!`可失败构造器失败了且返回`nil`，那么后出现一个运行时错误（如同使用`!`操作符去解析一个有着`nil`值的可选项）。
可失败指定构造器可以在子类中任何一种指定构造器重写。非可失败指定构造器在子类中仅能通过非可失败构造器被重写。
得到更多的信息并且了解更多关于可失败构造器的例子，请参阅[可失败构造器(Failable Initializer)](TODO)
在实现构造体的任何时间，结构体或者枚举的可失败构造器可以返回`nil`。然而，类的可失败构造器，仅在类的所有存储属性被构造之后且`self.init`或`super.init`被调用之后才返回`nil`（就是说，构造器的委托被执行）。
可失败构造器可以委托任何种类的构造器。非可失败可以委托其它非可失败构造器或者`init!`可失败构造器。
构造过程的失败由构造器的委托产生。特别的，如果可失败构造器代理一个构造器失败且返回`nil`，那么之后被委托的构造器也会失败且隐式的返回`nil`。如果非可失败构造器代理`init!`可失败构造器失败了且返回`nil`，那么后出现一个运行时错误（如同使用`!`操作符去解析一个有着`nil`值的可选项）。
可失败指定构造器可以在子类中任何一种指定构造器重写。非可失败指定构造器在子类中仅能通过非可失败构造器被重写。
得到更多的信息并且了解更多关于可失败构造器的例子，请参阅[可失败构造器(Failable Initializer)](TODO)
<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)* → [*特性(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)
> *构造器声明* → [*构造器头(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 !**
> *构造器主体* → [*代码块*](../chapter3/05_Declarations.html#code_block)
<a name="deinitializer_declaration"></a>
##析构声明
@ -867,10 +871,10 @@ if let actualInstance = SomeStruct(input: "Hello") {
析构器不会被直接调用。
查看例子和如何在类的声明中使用析构器，参见[析构过程Deinitialization](TODO)一节。
<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>
##扩展声明
@ -889,15 +893,15 @@ if let actualInstance = SomeStruct(input: "Hello") {
扩展声明可以包含构造器声明，这意味着，如果扩展的类型在其他模块中定义，构造器声明必须委托另一个在
那个模块里声明的构造器来恰当的初始化。
<a name="grammer_of_an_extension_declaration"></a>
> 扩展(Extension)声明语法
> *扩展声明* → [访问级别修饰符](TODO) _可选_ **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)
> *extension-body* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**
> *扩展声明* → [访问级别修饰符](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) _可选_ **}**
<a name="subscript_declaration"></a>
##下标脚本声明
*下标脚本(subscript)*声明用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字`subscript`，声明形式如下：
> subscript (`parameter`) -> (return type){
@ -922,22 +926,22 @@ if let actualInstance = SomeStruct(input: "Hello") {
同样可以在协议声明的上下文中声明下标脚本，[协议下标脚本声明(Protocol Subscript Declaration)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_619)中有所描述。
更多关于下标脚本和下标脚本声明的例子，请参考[下标脚本(Subscripts)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Subscripts.html#//apple_ref/doc/uid/TP40014097-CH16-XID_393)。
<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) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)
> *附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
> *附属脚本头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)
> *附属脚本结果(Result)* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)
> *附属脚本声明* → [*附属脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*代码块*](../chapter3/05_Declarations.html#code_block)
> *附属脚本声明* → [*附属脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter块*](../chapter3/05_Declarations.html#getter_setter_block)
> *附属脚本声明* → [*附属脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)
> *附属脚本头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数子句*](../chapter3/05_Declarations.html#parameter_clause)
> *附属脚本结果(Result)* → **->** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)
<a name="operator_declaration"></a>
##运算符声明(translated by 林)
*运算符声明(operator declaration)*会向程序中引入中缀、前缀或后缀运算符，它使用关键字`operator`声明。
可以声明三种不同的缀性：中缀、前缀和后缀。操作符的*缀性(fixity)*描述了操作符与它的操作数的相对位置。
运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在`operator`关键字之前添加声明修饰符`infix`，`prefix`或`postfix`来指定。每种形式中，运算符的名字只能包含[运算符(Operators)](TODO)中定义的运算符字符。
下面的这种形式声明了一个新的中缀运算符：
@ -973,17 +977,17 @@ if let actualInstance = SomeStruct(input: "Hello") {
和前缀运算符一样，后缀运算符的声明中不指定优先级。后缀运算符是非结合的。
声明了一个新的运算符以后，需要声明一个跟这个运算符同名的函数来实现这个运算符。如果在实现一个前缀或者后缀操作符，也必须使用相符的`prefix`或者`postfix`声明修饰符标记函数声明。如果实现中缀操作符，不需要使用`infix`声明修饰符标记函数声明。如何实现一个新的运算符，请参考[Custom Operators](TODO)。
<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) **{** **}**
> *后置运算符声明* → **postfix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}**
> *中置运算符声明* → **infix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}**
> *中置运算符属性* → [*优先级子句*](..\chapter3\05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](..\chapter3\05_Declarations.html#associativity_clause) _可选_
> *优先级子句* → **precedence** [*优先级水平*](..\chapter3\05_Declarations.html#precedence_level)
> *中置运算符声明* → **infix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](../chapter3/05_Declarations.html#infix_operator_attributes) _可选_ **}**
> *中置运算符属性* → [*优先级子句*](../chapter3/05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](../chapter3/05_Declarations.html#associativity_clause) _可选_
> *优先级子句* → **precedence** [*优先级水平*](../chapter3/05_Declarations.html#precedence_level)
> *优先级水平* → 十进制整数 0 到 255
> *结和性子句* → **associativity** [*结和性*](..\chapter3\05_Declarations.html#associativity)
> *结和性子句* → **associativity** [*结和性*](../chapter3/05_Declarations.html#associativity)
> *结和性* → **left** | **right** | **none**
@ -1017,7 +1021,7 @@ if let actualInstance = SomeStruct(input: "Hello") {
`weak`
`weak`修饰符用于修饰一个变量或一个存储型变量属性，表示该变量或属性通过一个弱引用指向存储其值的对象。该变量或属性的类型必须是一个可选类类型。通过`weak`修饰符可避免强引用循环。关于`weak`修饰符的例子和更多信息，可以参见[弱引用(Weak References)](TODO)一章
<a name="access_control_levels"></a>
### 访问控制级别
@ -1038,7 +1042,7 @@ Swift提供了三个级别的权限控制：`public`, `internal`, 和 `private`
以上的任意一个权限级别修饰符都可以有选择的带上一个参数，该参数由关键字`set`和一对括号组成（比如，`private(set)`）。当想要指明一个变量或下标脚注的setter的访问级别要低于或等于该变量或下标脚注的实际访问级别时，使用这种格式的权限级别修饰符，就像[Getters and Setters](TODO)一章中讨论的一样。
<a name="grammer_of_a_declaration_modifier"></a>
>声明修饰符的语法
@ -1050,7 +1054,7 @@ Swift提供了三个级别的权限控制：`public`, `internal`, 和 `private`
>
>访问级别修饰符 → **private­** | **private­(­set­)­**
>
>访问级别修饰符 → **public­** | **public­(­set­)­**
>
>访问级别修饰符 → **public­** | **public­(­set­)­**
>
>访问级别修饰符 → [访问级别修饰符(access-level-modeifier)](TODO) [访问级别修饰符列表(access-level-modeifiers)](TODO) _可选_
­

8
source/chapter3/06_Attributes.md
View File

@ -1,5 +1,9 @@
> 1.0
> 翻译：[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`特性的声明同时也具有`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`

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)
> 2.0
> 翻译+校对：[ray16897188](https://github.com/ray16897188)
# 模式（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条件句中使用这类模式。
> 模式(Patterns) 语法
> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_
> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_
> *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)
> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_
> *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern)
> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern)
> *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern)
> *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)
> *模式* → [*通配符模式*](../chapter3/07_Patterns.html#wildcard_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_
> *模式* → [*标识符模式*](../chapter3/07_Patterns.html#identifier_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotati(Value Binding)on) _可选_
> *模式* → [*值绑定模式*](../chapter3/07_Patterns.html#value_binding_pattern)
> *模式* → [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_
> *模式* → [*枚举用例模式*](../chapter3/07_Patterns.html#enum_case_pattern)
> *模式* → [*可选模式*](../chapter3/07_Patterns.html#optional_pattern)
> *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern)
> *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern)
<a name="wildcard_pattern"></a>
## 通配符模式（Wildcard Pattern）
@ -83,7 +87,7 @@ case let (x, y):
在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。正是由于这么做，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配到的值是一样的。
> 值绑定(Value Binding)模式语法
> *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern)
> *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../chapter3/07_Patterns.html#pattern)
<a name="tuple_pattern"></a>
## 元组模式（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) | [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)
> *元组模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern)
> *元组模式* → **(** [*元组模式元素列表*](../chapter3/07_Patterns.html#tuple_pattern_element_list) _可选_ **)**
> *元组模式元素列表* → [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](../chapter3/07_Patterns.html#tuple_pattern_element_list)
> *元组模式元素* → [*模式*](../chapter3/07_Patterns.html#pattern)
<a name="enumeration_case_pattern"></a>
## 枚举用例模式（Enumeration Case Pattern）
@ -123,7 +127,7 @@ let (a): Int = 2 // a: Int = 2
如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`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>
## 可选模式（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>
## 类型转换模式（Type-Casting Patterns）
@ -175,9 +179,9 @@ for case let number? in arrayOfOptinalInts {
关于使用`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)
> *is模式* → **is** [*类型*](..\chapter3\03_Types.html#type)
> *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*类型*](..\chapter3\03_Types.html#type)
> *type-casting-pattern* → [*is模式*](../chapter3/07_Patterns.html#is_pattern) | [*as模式*](../chapter3/07_Patterns.html#as_pattern)
> *is模式* → **is** [*类型*](../chapter3/03_Types.html#type)
> *as模式* → [*模式*](../chapter3/07_Patterns.html#pattern) **as** [*类型*](../chapter3/03_Types.html#type)
<a name="expression_pattern"></a>
## 表达式模式（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)
> 校对：[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) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list)
> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name)
> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)
> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)
> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name)
> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)
> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)
> *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list)
> *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list)
> *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement)
> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)
> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)
> *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型标识*](..\chapter3\03_Types.html#type_identifier)
> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)
> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)
> *同类型约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **==** [*类型标识*](../chapter3/03_Types.html#type_identifier)
<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) **>**
> *泛型参数列表* → [*泛型参数*](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

432
source/chapter3/10_Statements.md
View File

@ -1,6 +1,10 @@
> 翻译：[coverxit](https://github.com/coverxit),[littledogboy](https://github.com/littledogboy)
> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),[littledogboy](https://github.com/littledogboy)
> 1.0
> 翻译：[coverxit](https://github.com/coverxit)
> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),
> 2.0
> 翻译+校对：[littledogboy](https://github.com/littledogboy)
<a name="statement_statements"></a>
# 语句
-----------------
@ -19,14 +23,14 @@
是否将分号（`;`）添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句，请务必使用分号。
> 语句语法
> *语句* → [*表达式*](..\chapter3\04_Expressions.html#expression) **;** _可选_
> *语句* → [*声明*](..\chapter3\05_Declarations.html#declaration) **;** _可选_
> *语句* → [*循环语句*](..\chapter3\10_Statements.html#loop_statement) **;** _可选_
> *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_
> *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)
> *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_
> *语句* → [*XXX语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_
> *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_
> *语句* → [*表达式*](../chapter3/04_Expressions.html#expression) **;** _可选_
> *语句* → [*声明*](../chapter3/05_Declarations.html#declaration) **;** _可选_
> *语句* → [*循环语句*](../chapter3/10_Statements.html#loop_statement) **;** _可选_
> *语句* → [*分支语句*](../chapter3/10_Statements.html#branch_statement) **;** _可选_
> *语句* → [*标记语句(Labeled Statement)*](../chapter3/10_Statements.html#labeled_statement)
> *语句* → [*控制转移语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_
> *语句* → [*XXX语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_
> *多条语句(Statements)* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_
<a name="loop_statements"></a>
## 循环语句
@ -36,11 +40,11 @@
通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
> 循环语句语法
> *循环语句* → [*for语句*](..\chapter3\10_Statements.html#for_statement)
> *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement)
> *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement)
> *循环语句* → [*do-while语句*](..\chapter3\10_Statements.html#do_while_statement)
> *循环语句* → [*for语句*](../chapter3/10_Statements.html#for_statement)
> *循环语句* → [*for-in语句*](../chapter3/10_Statements.html#for_in_statement)
> *循环语句* → [*while语句*](../chapter3/10_Statements.html#wheetatype类型ile_statement)
> *循环语句* → [*do-while语句*](../chapter3/10_Statements.html#do_while_statement)
<a name="for_statements"></a>
### For 语句
@ -64,11 +68,11 @@
在 *initialzation* 中定义的变量仅在`for`循环的作用域内有效。*condition* 表达式的值的类型必须遵循`BooleanType `协议。
> For 循环语法
> *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *for语句* → **for** **(** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **)** [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)
> *for语句* → **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)
<a name="for-in_statements"></a>
### For-In 语句
@ -83,9 +87,9 @@
`for-in`语句在循环开始前会调用 *collection* 表达式的`generate`方法来获取一个生成器类型（这是一个遵循`Generator`协议的类型）的值。接下来循环开始，调用 *collection* 表达式的`next`方法。如果其返回值不是`None`，它将会被赋给 *item*，然后执行 *statements*，执行完毕后回到循环开始处；否则，将不会赋值给 *item* 也不会执行 *statements*，`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>
### While 语句
@ -108,21 +112,21 @@
*condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> While 循环语法
> *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\04_Expressions.html#expression) | [*条件列表*](TODO)
> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [*表达式*](..\chapter3\04_Expressions.html#expression)
> *条件列表* → [*条件条件*](TODO) [*条件列表*](TODO)
> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [可选绑定条件](../chapter2/01_The_Basics.html#optional_binding)
> *case条件* → **case** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO) [where](DOTO)
> *可选绑定条件* → [可选绑定头](TODO) [持续可选绑定](TODO) [持续可选绑定列表](TODO)
> *可选绑定头* → **let** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO) **var** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO)
> *可持续绑定列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) | [构造器](TODO) [可选绑定头](TODO)
>
> *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/04_Expressions.html#expression) | [*条件列表*](TODO)
> *条件* → [*可用条件*](../chapter3/10_Statement.html#availability) [*表达式*](../chapter3/04_Expressions.html#expression)
> *条件列表* → [*条件条件*](TODO) [*条件列表*](TODO)
> *条件* → [*可用条件*](../chapter3/10_Statement.html#availability) [可选绑定条件](../chapter2/01_The_Basics.html#optional_binding)
> *case条件* → **case** [*模式*](../chapter3/07_Patterns.html#pattern) [构造器](TODO) [where](DOTO)
> *可选绑定条件* → [可选绑定头](TODO) [持续可选绑定](TODO) [持续可选绑定列表](TODO)
> *可选绑定头* → **let** [*模式*](../chapter3/07_Patterns.html#pattern) [构造器](TODO) **var** [*模式*](../chapter3/07_Patterns.html#pattern) [构造器](TODO)
> *可持续绑定列表* → [*模式*](../chapter3/07_Patterns.html#pattern) | [构造器](TODO) [可选绑定头](TODO)
>
<a name="while-while_statements"></a>
### Repeat-While 语句
@ -145,7 +149,7 @@
*condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> 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>
## 分支语句
@ -155,10 +159,10 @@
`switch`语句中的控制流可以用`break`语句修改，详情请见[Break 语句](#break_statement)。
> 分支语句语法
> *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement)
> *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement)
> *分支语句* → [*if语句*](../chapter3/10_Statements.html#if_statement)
> *分支语句* → [*switch语句*](../chapter3/10_Statements.html#switch_statement)
<a name="if_statements"></a>
### If 语句
@ -194,34 +198,34 @@
`if`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
> 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条件* → [*表达式*](..\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)
<a name="guard_statements"></a>
### Guard 语句
`guard` 语句用来转移程序控制出其作用域，如果一个或者多个条件不成立。
`guard` 语句的格式如下：
> guard `condition` else {
`statements`
>}
`guard`语句中条件值的类型必须遵循`LogicValue`协议。且条件可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
在`guard`语句中声明的常量或者变量，可用范围从声明开始到作用域结束,常量和变量的值从可选绑定声明中分配。
`guard`语句需要有`else`子句，并且必须调用被`noreturn`属性标记的函数,或者使用下面的语句把程序执行转移到guard语句的作用域外。
* `return`
* `break`
* `continue`
* `throw`
执行转移语句详情参见[控制传递语句](TODO)
> *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)
> *else(Clause)* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if语句*](../chapter3/10_Statements.html#if_statement)
<a name="guard_statements"></a>
### Guard 语句
`guard` 语句用来转移程序控制出其作用域，如果一个或者多个条件不成立。
`guard` 语句的格式如下：
> guard `condition` else {
`statements`
>}
`guard`语句中条件值的类型必须遵循`LogicValue`协议。且条件可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
在`guard`语句中声明的常量或者变量，可用范围从声明开始到作用域结束,常量和变量的值从可选绑定声明中分配。
`guard`语句需要有`else`子句，并且必须调用被`noreturn`属性标记的函数,或者使用下面的语句把程序执行转移到guard语句的作用域外。
* `return`
* `break`
* `continue`
* `throw`
执行转移语句详情参见[控制传递语句](TODO)
<a name="switch_statements"></a>
### Switch 语句
@ -266,18 +270,18 @@ case let (x, y) where x == y:
当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这就意味着，如果你想执行下一个 case 分支，需要显式地在你需要的 case 分支里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，详情参见 [Fallthrough 语句](#fallthrough_statement)。
> Switch语句语法
> *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}**
> *SwitchCase列表* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_
> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default标签*](..\chapter3\10_Statements.html#default_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements)
> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) **;** | [*default标签*](..\chapter3\10_Statements.html#default_label) **;**
> *case标签* → **case** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) **:**
> *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*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)
> *switch语句* → **switch** [*表达式*](../chapter3/04_Expressions.html#expression) **{** [*SwitchCase列表*](../chapter3/10_Statements.html#switch_cases) _可选_ **}**
> *SwitchCase列表* → [*SwitchCase*](../chapter3/10_Statements.html#switch_case) [*SwitchCase列表*](../chapter3/10_Statements.html#switch_cases) _可选_
> *SwitchCase* → [*case标签*](../chapter3/10_Statements.html#case_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) | [*default标签*](../chapter3/10_Statements.html#default_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements)
> *SwitchCase* → [*case标签*](../chapter3/10_Statements.html#case_label) **;** | [*default标签*](../chapter3/10_Statements.html#default_label) **;**
> *case标签* → **case** [*case项列表*](../chapter3/10_Statements.html#case_item_list) **:**
> *case项列表* → [*模式*](../chapter3/07_Patterns.html#pattern) [*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** **:**
> *where-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard)
> *where-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression)
> *where-clause* → **where** [*guard-expression*](../chapter3/10_Statements.html#guard)
> *where-expression* → [*表达式*](../chapter3/04_Expressions.html#expression)
<a name="labeled_statements"></a>
<a name="control_transfer_statements"></a>
<a name="control_transfer_statements"></a>
## 带标签的语句
你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
@ -287,21 +291,21 @@ case let (x, y) where x == y:
关于使用带标签的语句的例子，详情参见[控制流](../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)
> *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:**
> *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)
> *标记语句(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/02_Lexical_Structure.html#identifier)
<a name="control_transfer_statements"></a>
## 控制传递语句
通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。
> 控制传递语句(Control Transfer Statement) 语法
> *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement)
> *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement)
> *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement)
> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement)
> *控制传递语句* → [*throw语句*](..\chapter3\10_Statements.html#throw_statement)
> *控制传递语句* → [*break语句*](../chapter3/10_Statements.html#break_statement)
> *控制传递语句* → [*continue语句*](../chapter3/10_Statements.html#continue_statement)
> *控制传递语句* → [*fallthrough语句*](../chapter3/10_Statements.html#fallthrough_statement)
> *控制传递语句* → [*return语句*](../chapter3/10_Statements.html#return_statement)
> *控制传递语句* → [*throw语句*](../chapter3/10_Statements.html#throw_statement)
<a name="break_statements"></a>
### 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 语句语法
> *break语句* → **break** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_
> *break语句* → **break** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_
<a name="continue_statements"></a>
### 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 语句语法
> *continue语句* → **continue** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_
> *continue语句* → **continue** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_
<a name="fallthrough_statements"></a>
### Fallthrough 语句
@ -353,7 +357,7 @@ case let (x, y) where x == y:
关于在`switch`语句中使用`fallthrough`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[控制传递语句](../chapter2/05_Control_Flow.html#control_transfer_statements)。
> Fallthrough 语句语法
> *fallthrough语句* → **fallthrough**
> *fallthrough语句* → **fallthrough**
<a name="return_statements"></a>
### Return 语句
@ -370,125 +374,125 @@ case let (x, y) where x == y:
而当只写`return`时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为`Void`或`()`）
> Return 语句语法
> *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_
<a name="availability_statements"></a>
### Availability 语句
可用性条件，被当做`if` ，`while` 语句的条件，并且 `guard` 语句在运行时会基于特定的语法格式查询接口的可用性。
avaliability 语句的形式如下：
> if #available(`platform name version`,` ...`, *) {
> `statements to execute if the APIs are available`
> } else {
> `fallback statements to execute if the APIs are unavailable`
> }
可用性条件执行一个代码块时，取决于在运行时想要使用的接口是否可用。
当编译器检查到代码块中的接口是可用的，则从可用性条件中获取相应信息。
可用性条件使用逗号分隔平台名称和版本列表。使用`iOS`，`OSX`，以及`watchOS`为平台名称，包括相应的版本号。*参数是必需的。在任何平台上代码块主体都被可用性条件保护起来，由满足最低部署条件的目标设备运行。
与布尔类型条件不同，不能用逻辑运算符 **&&** 和 **||** 合并可用性条件。
> 可用性条件语法
> *可用性条件* → **#available** ( [availability-arguments­](TODO) )
> *可用性条件* → [availability-argument­](TODO) | [availability-argument](TODO)­ ,­ [availability-arguments­](TODO)
> *可用性条件* → [平台名称](TODO) [版本号](TODO)
> *可用性条件* → **\***
> *平台名称* → **iOS** | **iOSApplicationExtension**
> *平台名称* → **OSX** | **OSXApplicationExtension­**
> *平台名称* → **watchOS**
> *版本号* → [十进制数字](TODO)
> *版本号* → [十进制数字](TODO) **.** [十进制数字](TODO)
> *版本号* → [十进制数字](TODO) **.** [十进制数字](TODO) **.** [十进制数字](TODO)
<a name="throw_statements"></a>
### Throw 语句
`throw`语句出现在抛出函数或者抛出方法体内，或者类型被`throws`关键字标记的表达式体内。
`throw`语句使程序结束执行当前的作用域，并在封闭作用域中传播错误。抛出的错误会一直传播，直到被`do`语句的`catch`子句处理掉。
`throw`语句由`throw`关键字 跟一个表达式组成 ，如下所示。
> throw `expression`
表达式值的类型必须遵循 `LogicValue`协议
关于如何使用`throw`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。
> throw 语句语法
> *抛出语句* → **throw** *[表达式­](TODO)*
<a name="defer_statements"></a>
### Defer 语句
`defer` 语句用于转移程序控制出延迟语句作用域之前执行代码。
在 `defer` 语句中的语句无论程序控制如何转移都会执行。这意味着 `defer` 语句可以被使用在以下这些情况，像手动得执行资源管理，关闭文件描述，或者即使抛出了错误也需要去实现执行一些动作。
如果多个 `defer` 语句出现在同一范围内，那么它们执行的顺序与出现的顺序相反。给定作用域中的第一个`defer` 语句，会在最后执行，这意味着最后执行的延迟语句中的语句涉及的资源可以被其他 `defer`语句清理掉。
> 1 func f( ) {
> 2 defer { print("First") }
> 3 defer { print("Second") }
> 4 defer { print("Third") }
> 5 }
> 6 f()
> 7 // prints "Third"
> 8 // prints "Second"
> 9 // prints "First"
`defer` 语句中的语句无法转移程序控制出延迟语句。
> defer 语句语法
> *延迟语句* → **defer** *[代码块](TODO)*
<a name="do_statements"></a>
### Do 语句
`do` 语句用于引入一个新的作用域,该作用域中可以含有一个或多个`catch`子句,catch子句中定义了一些匹配错误情况的模式。`do` 语句作用域内定义的常量和变量，只能在do语句作用域内访问。
swift 中的 do 语句与C 中限定代码块界限的大括号 （{}）很相似，并且在程序运行的时候并不会造成系统开销。
> do {
> try `expression`
> `statements`
> } catch `pattern 1` {
`statements`
> } catch `pattern 2` where condition {
`statements`
> }
如同`switch`语句,编译器会判断`catch`子句是否被遗漏。如果catch没有被遗漏，则认为错误被处理。否则，错误会自动传播出包含作用域,被一个封闭的`catch`语句或抛出函数处理掉，包含函数必须以`throws`关键字声明。
为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，`catch`子句会匹配和约束任何局部变量命名的`error`。有关在`catch`子句中使用模式的更多信息，详见[模式](TODO)。
关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。
> do 语句语法 → **do** *[*代码块*](..\chapter3\05_Declarations.html#code_block) [catch](TODO)*
> catch → *[catch子句](TODO) [catch子句](TODO)*
> catch → **catch** *[*模式*](..\chapter3\07_Patterns.html#pattern)** *可选的* [*where*]() *可选的* [*代码块*](..\chapter3\05_Declarations.html#code_block)
> *return语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_
<a name="availability_statements"></a>
### Availability 语句
可用性条件，被当做`if` ，`while` 语句的条件，并且 `guard` 语句在运行时会基于特定的语法格式查询接口的可用性。
avaliability 语句的形式如下：
> if #available(`platform name version`,` ...`, *) {
> `statements to execute if the APIs are available`
> } else {
> `fallback statements to execute if the APIs are unavailable`
> }
可用性条件执行一个代码块时，取决于在运行时想要使用的接口是否可用。
当编译器检查到代码块中的接口是可用的，则从可用性条件中获取相应信息。
可用性条件使用逗号分隔平台名称和版本列表。使用`iOS`，`OSX`，以及`watchOS`为平台名称，包括相应的版本号。*参数是必需的。在任何平台上代码块主体都被可用性条件保护起来，由满足最低部署条件的目标设备运行。
与布尔类型条件不同，不能用逻辑运算符 **&&** 和 **||** 合并可用性条件。
> 可用性条件语法
> *可用性条件* → **#available** ( [availability-arguments­](TODO) )
> *可用性条件* → [availability-argument­](TODO) | [availability-argument](TODO)­ ,­ [availability-arguments­](TODO)
> *可用性条件* → [平台名称](TODO) [版本号](TODO)
> *可用性条件* → **\***
> *平台名称* → **iOS** | **iOSApplicationExtension**
> *平台名称* → **OSX** | **OSXApplicationExtension­**
> *平台名称* → **watchOS**
> *版本号* → [十进制数字](TODO)
> *版本号* → [十进制数字](TODO) **.** [十进制数字](TODO)
> *版本号* → [十进制数字](TODO) **.** [十进制数字](TODO) **.** [十进制数字](TODO)
<a name="throw_statements"></a>
### Throw 语句
`throw`语句出现在抛出函数或者抛出方法体内，或者类型被`throws`关键字标记的表达式体内。
`throw`语句使程序结束执行当前的作用域，并在封闭作用域中传播错误。抛出的错误会一直传播，直到被`do`语句的`catch`子句处理掉。
`throw`语句由`throw`关键字 跟一个表达式组成 ，如下所示。
> throw `expression`
表达式值的类型必须遵循 `LogicValue`协议
关于如何使用`throw`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。
> throw 语句语法
> *抛出语句* → **throw** *[表达式­](TODO)*
<a name="defer_statements"></a>
### Defer 语句
`defer` 语句用于转移程序控制出延迟语句作用域之前执行代码。
在 `defer` 语句中的语句无论程序控制如何转移都会执行。这意味着 `defer` 语句可以被使用在以下这些情况，像手动得执行资源管理，关闭文件描述，或者即使抛出了错误也需要去实现执行一些动作。
如果多个 `defer` 语句出现在同一范围内，那么它们执行的顺序与出现的顺序相反。给定作用域中的第一个`defer` 语句，会在最后执行，这意味着最后执行的延迟语句中的语句涉及的资源可以被其他 `defer`语句清理掉。
> 1 func f( ) {
> 2 defer { print("First") }
> 3 defer { print("Second") }
> 4 defer { print("Third") }
> 5 }
> 6 f()
> 7 // prints "Third"
> 8 // prints "Second"
> 9 // prints "First"
`defer` 语句中的语句无法转移程序控制出延迟语句。
> defer 语句语法
> *延迟语句* → **defer** *[代码块](TODO)*
<a name="do_statements"></a>
### Do 语句
`do` 语句用于引入一个新的作用域,该作用域中可以含有一个或多个`catch`子句,catch子句中定义了一些匹配错误情况的模式。`do` 语句作用域内定义的常量和变量，只能在do语句作用域内访问。
swift 中的 do 语句与C 中限定代码块界限的大括号 （{}）很相似，并且在程序运行的时候并不会造成系统开销。
> do {
> try `expression`
> `statements`
> } catch `pattern 1` {
`statements`
> } catch `pattern 2` where condition {
`statements`
> }
如同`switch`语句,编译器会判断`catch`子句是否被遗漏。如果catch没有被遗漏，则认为错误被处理。否则，错误会自动传播出包含作用域,被一个封闭的`catch`语句或抛出函数处理掉，包含函数必须以`throws`关键字声明。
为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，`catch`子句会匹配和约束任何局部变量命名的`error`。有关在`catch`子句中使用模式的更多信息，详见[模式](TODO)。
关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。
> do 语句语法 → **do** *[*代码块*](../chapter3/05_Declarations.html#code_block) [catch](TODO)*
> catch → *[catch子句](TODO) [catch子句](TODO)*
> catch → **catch** *[*模式*](../chapter3/07_Patterns.html#pattern)** *可选的* [*where*]() *可选的* [*代码块*](../chapter3/05_Declarations.html#code_block)