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

replace all _ with -

Browse Source
This commit is contained in:
Jie Liang
2019-04-02 09:47:36 -05:00
parent 5d3bf7bbcf
commit 3201f23a17
37 changed files with 488 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
source/chapter3/06_Declarations.md
View File

@@ -42,7 +42,7 @@
> *多条声明* → [*声明*](#declaration) [*多条声明*](#declarations)<sub>可选</sub>
>
## 顶级代码 {#top-level_code}
## 顶级代码 {#top-level-code}
Swift 的源文件中的顶级代码（top-level code）由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access_control_levels)。
> 顶级声明语法
@@ -50,7 +50,7 @@ Swift 的源文件中的顶级代码（top-level code）由零个或多个语句
> *顶级声明* → [*多条语句*](./05_Statements.md#statements)<sub>可选</sub>
>
## 代码块 {#code_blocks}
## 代码块 {#code-blocks}
*代码块（code block）* 可以将一些声明和控制结构体组织在一起。它有如下的形式：
```swift
@@ -69,7 +69,7 @@ Swift 的源文件中的顶级代码（top-level code）由零个或多个语句
> *代码块* → **{** [*多条语句*](./05_Statements.md#statements)<sub>可选</sub> **}**
>
## 导入声明 {#import_declaration}
## 导入声明 {#import-declaration}
*导入声明（import declaration）* 让你可以使用在其他文件中声明的内容。导入语句的基本形式是导入整个模块，它由 `import` 关键字和紧随其后的模块名组成：
```swift
@@ -84,7 +84,7 @@ import 模块.子模块
```
#### grammer_of_an_import_declaration {#grammer_of_an_import_declaration}
#### grammer_of_an_import_declaration {#grammer-of-an-import-declaration}
> 导入声明语法
>
>
@@ -108,7 +108,7 @@ import 模块.子模块
> *导入路径标识符* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator)
>
## 常量声明 {#constant_declaration}
## 常量声明 {#constant-declaration}
*常量声明（constant declaration）* 可以在程序中引入一个具有命名的常量。常量以关键字 `let` 来声明，遵循如下格式：
```swift
@@ -141,7 +141,7 @@ print("The second number is \(secondNumber).")
如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../chapter2/01_The_Basics.md#constants_and_variables) 和 [存储属性](../chapter2/10_Properties.md#stored_properties)。
#### grammer_of_a_constant_declaration {#grammer_of_a_constant_declaration}
#### grammer_of_a_constant_declaration {#grammer-of-a-constant-declaration}
> 常量声明语法
>
>
@@ -165,7 +165,7 @@ print("The second number is \(secondNumber).")
> *构造器* → **=** [*表达式*](./04_Expressions.md#expression)
>
## 变量声明 {#variable_declaration}
## 变量声明 {#variable-declaration}
*变量声明（variable declaration）* 可以在程序中引入一个具有命名的变量，它以关键字 `var` 来声明。
变量声明有几种不同的形式，可以声明不同种类的命名值和可变值，如存储型和计算型变量和属性，属性观察器，以及静态变量属性。所使用的声明形式取决于变量声明的适用范围和打算声明的变量类型。
@@ -177,7 +177,7 @@ print("The second number is \(secondNumber).")
可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../chapter2/13_Inheritance.md#overriding)。
### 存储型变量和存储型变量属性 {#stored_variables_and_stored_variable_properties}
### 存储型变量和存储型变量属性 {#stored-variables-and-stored-variable-properties}
使用如下形式声明一个存储型变量或存储型变量属性：
```swift
@@ -192,7 +192,7 @@ var 变量名称: 类型 = 表达式
正如名字所示，存储型变量和存储型变量属性的值会存储在内存中。
### 计算型变量和计算型属性 {#computed_variables_and_computed_properties}
### 计算型变量和计算型属性 {#computed-variables-and-computed-properties}
使用如下形式声明一个计算型变量或计算型属性：
```swift
@@ -216,7 +216,7 @@ setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名
要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../chapter2/10_Properties.md#computed_properties)。
### 存储型变量和属性的观察器 {#stored_variable_observers_and_property_observers}
### 存储型变量和属性的观察器 {#stored-variable-observers-and-property-observers}
可以在声明存储型变量或属性时提供 `willSet` 和 `didSet` 观察器。一个包含观察器的存储型变量或属性以如下形式声明：
```swift
@@ -247,7 +247,7 @@ var 变量名称: 类型 = 表达式 {
要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../chapter2/10_Properties.md#property_observers)。
### 类型变量属性 {#type_variable_properties}
### 类型变量属性 {#type-variable-properties}
要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties) 章节有详细讨论。
> 注意
@@ -256,7 +256,7 @@ var 变量名称: 类型 = 表达式 {
>
#### grammer_of_a_variable_declaration {#grammer_of_a_variable_declaration}
#### grammer_of_a_variable_declaration {#grammer-of-a-variable-declaration}
> 变量声明语法
>
@@ -342,7 +342,7 @@ var 变量名称: 类型 = 表达式 {
> *didSet 子句* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **didSet** [*setter 名称*](#setter-name)<sub>可选</sub> [*代码块*](#code-block)
>
## 类型别名声明 {#type_alias_declaration}
## 类型别名声明 {#type-alias-declaration}
*类型别名（type alias）* 声明可以在程序中为一个既有类型声明一个别名。类型别名声明语句使用关键字 `typealias` 声明，遵循如下的形式：
```swift
@@ -398,7 +398,7 @@ func sum<T: Sequence>(_ sequence: T) -> Int where T.Element == Int {
另请参阅 [协议关联类型声明](#protocol_associated_type_declaration)。
#### grammer_of_a_type_alias_declaration {#grammer_of_a_type_alias_declaration}
#### grammer_of_a_type_alias_declaration {#grammer-of-a-type-alias-declaration}
> 类型别名声明语法
>
>
@@ -418,7 +418,7 @@ func sum<T: Sequence>(_ sequence: T) -> Int where T.Element == Int {
> *类型别名赋值* → **=** [*类型*](./03_Types.md#type)
>
## 函数声明 {#function_declaration}
## 函数声明 {#function-declaration}
使用*函数声明（function declaration）* 在程序中引入新的函数或者方法。在类、结构体、枚举，或者协议中声明的函数会作为方法。函数声明使用关键字 `func`，遵循如下的形式：
```swift
@@ -446,7 +446,7 @@ func 函数名称(参数列表) {
更多关于嵌套函数的讨论，请参阅 [嵌套函数](../chapter2/06_Functions.md#Nested_Functions)。
### 参数名 {#parameter_names}
### 参数名 {#parameter-names}
函数的参数列表由一个或多个函数参数组成，参数间以逗号分隔。函数调用时的参数顺序必须和函数声明时的参数顺序一致。最简单的参数列表有着如下的形式：
`参数名称`: `参数类型`
@@ -473,7 +473,7 @@ func repeatGreeting(_ greeting: String, count n: Int) { /* Greet n times */ }
repeatGreeting("Hello, world!", count: 2) // count 有标签, greeting 没有
```
### 输入输出参数 {#in-out_parameters}
### 输入输出参数 {#in-out-parameters}
输入输出参数被传递时遵循如下规则：
1. 函数调用时，参数的值被拷贝。
@@ -517,7 +517,7 @@ func multithreadedFunction(queue: DispatchQueue, x: inout Int) {
关于输入输出参数的详细讨论，请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。
### 特殊参数 {#special_kinds_of_parameters}
### 特殊参数 {#special-kinds-of-parameters}
参数可以被忽略，数量可以不固定，还可以为其提供默认值，使用形式如下：
```swift
@@ -540,14 +540,14 @@ f(7) // 有效，提供了值
f(x: 7) // 无效，该参数没有外部名称
```
### 特殊方法 {#special_kinds_of_methods}
### 特殊方法 {#special-kinds-of-methods}
枚举或结构体的方法如果会修改 `self`，则必须以 `mutating` 声明修饰符标记。
子类重写超类中的方法必须以 `override` 声明修饰符标记。重写方法时不使用 `override` 修饰符，或者被 `override` 修饰符修饰的方法并未对超类方法构成重写，都会导致编译错误。
枚举或者结构体中的类型方法，要以 `static` 声明修饰符标记，而对于类中的类型方法，除了使用 `static`，还可使用 `class` 声明修饰符标记。类中使用 `class` 声明修饰的方法可以被子类实现重写；类中使用 `static` 声明修饰的方法不可被重写。
### 抛出错误的函数和方法 {#throwing_functions_and_methods}
### 抛出错误的函数和方法 {#throwing-functions-and-methods}
可以抛出错误的函数或方法必须使用 `throws` 关键字标记。这类函数和方法被称为抛出函数和抛出方法。它们有着下面的形式:
```swift
@@ -565,7 +565,7 @@ func 函数名称(参数列表) throws -> 返回类型 {
抛出方法不能重写非抛出方法，而且抛出方法不能满足协议对于非抛出方法的要求。也就是说，非抛出方法可以重写抛出方法，而且非抛出方法可以满足协议对于抛出方法的要求。
### 重抛错误的函数和方法 {#rethrowing_functions_and_methods}
### 重抛错误的函数和方法 {#rethrowing-functions-and-methods}
函数或方法可以使用 `rethrows` 关键字来声明，从而表明仅当该函数或方法的一个函数类型的参数抛出错误时，该函数或方法才抛出错误。这类函数和方法被称为重抛函数和重抛方法。重新抛出错误的函数或方法必须至少有一个参数的类型为抛出函数。
```swift
@@ -594,7 +594,7 @@ func someFunction(callback: () throws -> Void) rethrows {
抛出方法不能重写重抛方法，而且抛出方法不能满足协议对于重抛方法的要求。也就是说，重抛方法可以重写抛出方法，而且重抛方法可以满足协议对于抛出方法的要求。
### 永不返回的函数 {#functions_that_never_return}
### 永不返回的函数 {#functions-that-never-return}
Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它的调用者。`Never` 返回类型的函数或方法可以称为不归，不归函数、方法要么引发不可恢复的错误，要么永远不停地运作，这会使调用后本应执行得代码就不再执行了。但即使是不归函数、方法，抛错函数和重抛出函数也可以将程序控制转移到合适的 `catch` 代码块。
不归函数、方法可以在 guard 语句的 else 字句中调用，具体讨论在[*Guard 语句*](./05_Statements.md#guard_statements)。
@@ -602,7 +602,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它
你可以重写一个不归方法，但是新的方法必须保持原有的返回类型和没有返回的行为。
#### grammer_of_a_function_declaration {#grammer_of_a_function_declaration}
#### grammer_of_a_function_declaration {#grammer-of-a-function-declaration}
> 函数声明语法
>
@@ -674,7 +674,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它
> *默认参数子句* → **=** [*表达式*](./04_Expressions.md#expression)
>
## 枚举声明 {#enumeration_declaration}
## 枚举声明 {#enumeration-declaration}
在程序中使用*枚举声明（enumeration declaration）* 来引入一个枚举类型。
枚举声明有两种基本形式，使用关键字 `enum` 来声明。枚举声明体包含零个或多个值，称为枚举用例，还可包含任意数量的声明，包括计算型属性、实例方法、类型方法、构造器、类型别名，甚至其他枚举、结构体和类。枚举声明不能包含析构器或者协议声明。
@@ -687,7 +687,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它
可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。
### 任意类型的枚举用例 {#enumerations_with_cases_of_any_type}
### 任意类型的枚举用例 {#enumerations-with-cases-of-any-type}
如下的形式声明了一个包含任意类型枚举用例的枚举变量：
```swift
@@ -719,7 +719,7 @@ let evenInts: [Number] = [0, 2, 4, 6].map(f)
要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../chapter2/08_Enumerations.md#associated_values)。
#### 递归枚举 {#enumerations_with_indirection}
#### 递归枚举 {#enumerations-with-indirection}
枚举类型可以具有递归结构，就是说，枚举用例的关联值类型可以是枚举类型自身。然而，枚举类型的实例具有值语义，这意味着它们在内存中有固定布局。为了支持递归，编译器必须插入一个间接层。
要让某个枚举用例支持递归，使用 `indirect` 声明修饰符标记该用例。
@@ -736,7 +736,7 @@ enum Tree<T> {
被 `indirect` 修饰符标记的枚举用例必须有一个关联值。使用 `indirect` 修饰符标记的枚举类型可以既包含有关联值的用例，同时还可包含没有关联值的用例。但是，它不能再单独使用 `indirect` 修饰符来标记某个用例。
### 拥有原始值的枚举用例 {#enumerations_with_cases_of_a_raw-value_type}
### 拥有原始值的枚举用例 {#enumerations-with-cases-of-a-raw-value-type}
以下形式声明了一种枚举类型，其中各个枚举用例的类型均为同一种基本类型：
```swift
@@ -770,13 +770,13 @@ enum GamePlayMode: String {
枚举用例具有原始值的枚举类型隐式地符合定义在 Swift 标准库中的 `RawRepresentable` 协议。所以，它们拥有一个 `rawValue` 属性和一个可失败构造器 `init?(rawValue: RawValue)`。可以使用 `rawValue` 属性去获取枚举用例的原始值，例如 `ExampleEnum.b.rawValue`。还可以根据原始值来创建一个相对应的枚举用例，只需调用枚举的可失败构造器，例如 `ExampleEnum(rawValue: 5)`，这个可失败构造器返回一个可选类型的用例。要获得更多关于具有原始值的枚举用例的信息和例子，请参阅 [原始值](../chapter2/08_Enumerations.md#raw_values)。
### 访问枚举用例 {#accessing_enumeration_cases}
### 访问枚举用例 {#accessing-enumeration-cases}
使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.enumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../chapter2/08_Enumerations.md#enumeration_syntax) 和 [显式成员表达式](./04_Expressions.md#explicit_member_expression) 所述。
可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../chapter2/08_Enumerations.md#matching_enumeration_values_with_a_switch_statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](./08_Patterns.md#enumeration_case_pattern) 所述。
#### grammer_of_an_enumeration_declaration {#grammer_of_an_enumeration_declaration}
#### grammer_of_an_enumeration_declaration {#grammer-of-an-enumeration-declaration}
> 枚举声明语法
>
>
@@ -867,7 +867,7 @@ enum GamePlayMode: String {
> *原始值字面量* → [数字型字面量](./02_Lexical_Structure.md#numeric-literal) | [字符串型字面量](./02_Lexical_Structure.md#static-string-literal) | [布尔型字面量](./02_Lexical_Structure.md#boolean-literal)
>
## 结构体声明 {#structure_declaration}
## 结构体声明 {#structure-declaration}
使用*结构体声明（structure declaration）* 可以在程序中引入一个结构体类型。结构体声明使用 `struct` 关键字，遵循如下的形式：
```swift
@@ -898,7 +898,7 @@ struct 结构体名称: 采纳的协议 {
可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension_declaration)。
#### grammer_of_a_structure_declaration {#grammer_of_a_structure_declaration}
#### grammer_of_a_structure_declaration {#grammer-of-a-structure-declaration}
> 结构体声明语法
>
>
@@ -929,7 +929,7 @@ struct 结构体名称: 采纳的协议 {
> *结构体成员* → [*声明*](#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
>
## 类声明 {#class_declaration}
## 类声明 {#class-declaration}
可以在程序中使用*类声明（class declaration）* 来引入一个类。类声明使用关键字 `class`，遵循如下的形式：
```swift
@@ -963,7 +963,7 @@ class 类名: 超类, 采纳的协议 {
可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension_declaration)。
#### grammer_of_a_class_declaration {#grammer_of_a_class_declaration}
#### grammer_of_a_class_declaration {#grammer-of-a-class-declaration}
> 类声明语法
>
>
@@ -993,7 +993,7 @@ class 类名: 超类, 采纳的协议 {
> *类成员* → [*声明*](#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
>
## 协议声明 {#protocol_declaration}
## 协议声明 {#protocol-declaration}
*协议声明（protocol declaration）* 可以为程序引入一个命名的协议类型。协议声明只能在全局区域使用 `protocol` 关键字来进行声明，并遵循如下形式：
```swift
@@ -1035,7 +1035,7 @@ protocol SomeProtocol: AnyObject {
可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托（代理）模式](../chapter2/21_Protocols.md#delegation) 中所述。
#### grammer_of_a_protocol_declaration {#grammer_of_a_protocol_declaration}
#### grammer_of_a_protocol_declaration {#grammer-of-a-protocol-declaration}
> 协议声明语法
>
>
@@ -1082,7 +1082,7 @@ protocol SomeProtocol: AnyObject {
> *协议成员声明列表* → [*协议成员声明*](#protocol-member-declaration) [*协议成员声明列表*](#protocol-member-declarations)<sub>可选</sub>
>
### 协议属性声明 {#protocol_property_declaration}
### 协议属性声明 {#protocol-property-declaration}
协议可以通过在协议声明主体中引入一个协议属性声明，来声明符合的类型必须实现的属性。协议属性声明有一种特殊的变量声明形式：
```swift
@@ -1096,7 +1096,7 @@ var 属性名: 类型 { get set }
另请参阅 [变量声明](#variable_declaration)。
#### grammer_of_an_import_declaration {#grammer_of_an_import_declaration}
#### grammer_of_an_import_declaration {#grammer-of-an-import-declaration}
> 协议属性声明语法
>
>
@@ -1105,7 +1105,7 @@ var 属性名: 类型 { get set }
> *协议属性声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block)
>
### 协议方法声明 {#protocol_method_declaration}
### 协议方法声明 {#protocol-method-declaration}
协议可以通过在协议声明主体中引入一个协议方法声明，来声明符合的类型必须实现的方法。协议方法声明和函数方法声明有着相同的形式，但有两项例外：它们不包括函数体，也不能包含默认参数。关于如何实现协议中的方法要求的例子，请参阅 [方法要求](../chapter2/21_Protocols.md#method_requirements)。
使用 `static` 声明修饰符可以在协议声明中声明一个类型方法。类在实现这些方法时使用 `class` 声明修饰符。结构体实现这些方法时必须使用 `static` 声明修饰符。通过扩展实现时亦是如此（类的扩展中使用 `class` 声明修饰符，结构体的扩展中使用 `static` 声明修饰符）。
@@ -1113,7 +1113,7 @@ var 属性名: 类型 { get set }
另请参阅 [函数声明](#function_declaration)。
#### grammer_of_a_protocol_declaration {#grammer_of_a_protocol_declaration}
#### grammer_of_a_protocol_declaration {#grammer-of-a-protocol-declaration}
> 协议方法声明语法
>
>
@@ -1122,7 +1122,7 @@ var 属性名: 类型 { get set }
> *协议方法声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*函数签名*](#function-signature) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub>
>
### 协议构造器声明 {#protocol_initializer_declaration}
### 协议构造器声明 {#protocol-initializer-declaration}
协议可以通过在协议声明主体中引入一个协议构造器声明，来声明符合的类型必须实现的构造器。协议构造器声明
除了不包含实现主体外，和构造器声明有着相同的形式。
@@ -1133,7 +1133,7 @@ var 属性名: 类型 { get set }
另请参阅 [构造器声明](#initializer_declaration)。
#### grammer_of_a_protocol_initializer_declaration {#grammer_of_a_protocol_initializer_declaration}
#### grammer_of_a_protocol_initializer_declaration {#grammer-of-a-protocol-initializer-declaration}
> 协议构造器声明语法
>
>
@@ -1144,7 +1144,7 @@ var 属性名: 类型 { get set }
> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)<sub>可选</sub> [*参数子句*](#parameter-clause) **rethrows** [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub>
>
### 协议下标声明 {#protocol_subscript_declaration}
### 协议下标声明 {#protocol-subscript-declaration}
协议可以通过在协议声明主体中引入一个协议下标声明，来声明符合的类型必须实现的下标。协议下标声明有一个特殊的下标声明形式：
```swift
@@ -1157,7 +1157,7 @@ subscript (参数列表) -> 返回类型 { get set }
另请参阅 [下标声明](#subscript_declaration)。
#### grammer_of_a_protocol_subscript_declaration {#grammer_of_a_protocol_subscript_declaration}
#### grammer_of_a_protocol_subscript_declaration {#grammer-of-a-protocol-subscript-declaration}
> 协议下标声明语法
>
>
@@ -1166,7 +1166,7 @@ subscript (参数列表) -> 返回类型 { get set }
> *协议下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub> [*getter-setter 关键字代码块*](#getter-setter-keyword-block)
>
### 协议关联类型声明 {#protocol_associated_type_declaration}
### 协议关联类型声明 {#protocol-associated-type-declaration}
使用关键字 `associatedtype` 来声明协议关联类型。关联类型为作为协议声明的一部分，为某种类型提供了一个别名。关联类型和泛型参数子句中的类型参数很相似，但是它们和 `Self` 一样，用于协议中。`Self` 指代采纳协议的类型。要获得更多信息和例子，请参阅 [关联类型](../chapter2/22_Generics.md#associated_types)。
在协议声明中使用泛型 `where` 子句来为继承的协议关联类型添加约束，且不需要重新声明关联类型。例如下面代码中的 `SubProtocol` 声明。
@@ -1190,7 +1190,7 @@ protocol SubProtocolB: SomeProtocol where SomeType: Equatable { }
另请参阅 [类型别名声明](#type_alias_declaration)。
#### grammer_of_a_protocol_associated_type_declaration {#grammer_of_a_protocol_associated_type_declaration}
#### grammer_of_a_protocol_associated_type_declaration {#grammer-of-a-protocol-associated-type-declaration}
> 协议关联类型声明语法
>
>
@@ -1199,7 +1199,7 @@ protocol SubProtocolB: SomeProtocol where SomeType: Equatable { }
> *协议关联类型声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*访问级别修饰符*](#access-level-modifier)<sub>可选</sub> **associatedtype** [*类型别名头*](#typealias-head) [*类型继承子句*](03_Types.md#type-inheritance-clause)<sub>可选</sub> [*类型别名赋值*](#typealias-assignment)<sub>可选</sub> [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)<sub>可选</sub>
>
## 构造器声明 {#initializer_declaration}
## 构造器声明 {#initializer-declaration}
构造器声明会为程序中的类、结构体或枚举引入构造器。构造器使用关键字 `init` 来声明，有两种基本形式。
结构体、枚举、类可以有任意数量的构造器，但是类的构造器具有不同的规则和行为。不同于结构体和枚举，类有两种构造器，即指定构造器和便利构造器，请参阅 [构造过程](../chapter2/14_Initialization.md)。
@@ -1243,7 +1243,7 @@ convenience init(参数列表) {
关于在不同类型中声明构造器的例子，请参阅 [构造过程](../chapter2/14_Initialization.md)。
### 可失败构造器 {#failable_initializers}
### 可失败构造器 {#failable-initializers}
可失败构造器可以生成所属类型的可选实例或者隐式解包可选实例，因此，这种构造器通过返回 `nil` 来指明构造过程失败。
声明生成可选实例的可失败构造器时，在构造器声明的 `init` 关键字后加追加一个问号（`init?`）。声明生成隐式解包可选实例的可失败构造器时，在构造器声明后追加一个叹号（`init!`）。使用 `init?` 可失败构造器生成结构体的一个可选实例的例子如下。
@@ -1283,7 +1283,7 @@ if let actualInstance = SomeStruct(input: "Hello") {
更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../chapter2/14_Initialization.md#failable_initializers)。
#### grammer_of_an_initializer_declaration {#grammer_of_an_initializer_declaration}
#### grammer_of_an_initializer_declaration {#grammer-of-an-initializer-declaration}
> 构造器声明语法
>
>
@@ -1308,7 +1308,7 @@ if let actualInstance = SomeStruct(input: "Hello") {
> *构造器主体* → [*代码块*](#code-block)
>
## 析构器声明 {#deinitializer_declaration}
## 析构器声明 {#deinitializer-declaration}
*析构器声明（deinitializer declaration）* 可以为类声明一个析构器。析构器没有参数，遵循如下格式：
```swift
@@ -1326,7 +1326,7 @@ deinit {
关于如何在类声明中使用析构器的例子，请参阅 [析构过程](../chapter2/15_Deinitialization.md)。
#### grammer_of_a_deinitializer_declaration {#grammer_of_a_deinitializer_declaration}
#### grammer_of_a_deinitializer_declaration {#grammer-of-a-deinitializer-declaration}
> 析构器声明语法
>
>
@@ -1335,7 +1335,7 @@ deinit {
> *析构器声明* → [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> **deinit** [*代码块*](#code-block)
>
## 扩展声明 {#extension_declaration}
## 扩展声明 {#extension-declaration}
*扩展声明（extension declaration）* 可以扩展一个现存的类型的行为。扩展声明使用关键字 `extension`，遵循如下格式：
```swift
@@ -1364,10 +1364,10 @@ extension 类型名称: 采纳的协议 where 约束条件 {
协议声明不能为现有的类添加类的继承关系，因此你只能在 “类型名称” 的冒号后面添加一系列协议。
### 条件遵循 {#conditional_conformance}
### 条件遵循 {#conditional-conformance}
你可以扩展一个泛型类型并使其有条件地遵循某协议，此后此类型的实例只有在特定的限制条件满足时才遵循此协议。在扩展声明中加入限制条件来为协议添加条件遵循。
## 已重写的限制条件会在某些泛型上下文中失效 {#overridden_requirements_aren't_Used_in_some_generic_contexts}
## 已重写的限制条件会在某些泛型上下文中失效 {#overridden-requirements-aren't-Used-in-some-generic-contexts}
对于一些通过条件遵循获得了特定行为的类型，在某些泛型上下文中，并不能够确保能够使用协议限制中的特定实现。为了说明这个行为，下面的例子中定义了两个协议以及一个有条件地遵循两个协议的泛型类型。
```swift
@@ -1431,10 +1431,10 @@ doSomething(with: oneAndTwo)
当传入 `doSomething(_:)` 的实例调用 `log()` 时，打印结果省略了自定义标题。
### 协议遵循决不能冗余 {#protocol_conformance_must_not_be_redundant}
### 协议遵循决不能冗余 {#protocol-conformance-must-not-be-redundant}
一个具体的类型只能够遵循某特定协议一次。Swift 会把冗余的协议遵循标记为错误。你会在两种场景中遇到这种错误。第一种场景是，使用不同的限制条件来多次显式地遵循同一协议。第二种场景是，多次隐式地继承同一协议。以上两种场景会在下面章节中讨论。
## 解决显式冗余 {#resolving_explicit_redundancy}
## 解决显式冗余 {#resolving-explicit-redundancy}
对同一具体类型的多个扩展不能遵循同一协议，即便这些扩展有不同的显式限制条件。这个限制的具体示例在下面的例子中。两个扩展声明都试图添加对 `Serializable` 的条件遵循，一个为 `Int` 类型元素的数组，另一个为 `String` 类型元素的数组。
```swift
@@ -1473,7 +1473,7 @@ extension Array: Serializable where Element: SerializableInArray {
}
```
## 解决隐式冗余 {#resolving_implicit_redundancy}
## 解决隐式冗余 {#resolving-implicit-redundancy}
当一个具体类型有条件地遵循某协议，此类型会隐式地使用相同的条件遵循任一父协议。
如果你需要让一个类型有条件地遵循两个继承自同一父协议的协议，请显式地声明对父协议的遵循。这可以避免使用不同的限制条件隐式遵循同一父协议两次。
@@ -1511,7 +1511,7 @@ extension Array: Loggable where Element: MarkedLoggable { }
```
#### grammer_of_an_extension_declaration {#grammer_of_an_extension_declaration}
#### grammer_of_an_extension_declaration {#grammer-of-an-extension-declaration}
> 扩展声明语法
>
>
@@ -1530,7 +1530,7 @@ extension Array: Loggable where Element: MarkedLoggable { }
> *单条声明* → [声明语句](#declarations) | [*编译控制流语句*](05_Statements.md#compiler-control-statement)
>
## 下标声明 {#subscript_declaration}
## 下标声明 {#subscript-declaration}
*下标声明（subscript declaration）* 用于为特定类型的对象添加下标支持，通常也用于为访问集合、列表和序列中的元素提供语法便利。下标声明使用关键字 `subscript`，形式如下：
```swift
@@ -1562,7 +1562,7 @@ subscript (参数列表) -> 返回类型 {
更多关于下标的信息和例子，请参阅 [下标](../chapter2/12_Subscripts.md)。
#### grammer_of_a_subscript_declaration {#grammer_of_a_subscript_declaration}
#### grammer_of_a_subscript_declaration {#grammer-of-a-subscript-declaration}
> 下标声明语法
>
>
@@ -1586,7 +1586,7 @@ subscript (参数列表) -> 返回类型 {
> *下标结果* → **->** [*特性列表*](./07_Attributes.md#attributes)<sub>可选</sub> [*类型*](./03_Types.md#type)
>
## 运算符声明 {#operator_declaration}
## 运算符声明 {#operator-declaration}
*运算符声明（operator declaration）* 会向程序中引入中缀、前缀或后缀运算符，使用关键字 `operator` 来声明。
可以声明三种不同的缀性：中缀、前缀和后缀。运算符的缀性指定了运算符与其运算对象的相对位置。
@@ -1626,7 +1626,7 @@ postfix operator 运算符名称 {}
声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../chapter2/26_Advanced_Operators.md#custom_operators)。
#### grammer_of_an_operator_declaration {#grammer_of_an_operator_declaration}
#### grammer_of_an_operator_declaration {#grammer-of-an-operator-declaration}
> 运算符声明语法
>
@@ -1652,7 +1652,7 @@ postfix operator 运算符名称 {}
> *中缀运算符组* → [*优先级组名称*](#precedence-group-name)
>
## 优先级组声明 {#precedence_group_declaration_modifiers}
## 优先级组声明 {#precedence-group-declaration-modifiers}
*优先级组声明（A precedence group declaration）* 会向程序的中缀运算符引入一个全新的优先级组。当没有用圆括号分组时，运算符优先级反应了运算符与它的操作数的关系的紧密程度。
优先级组的声明如下所示:
@@ -1679,7 +1679,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用，
优先级组的赋值性表示在包含可选链操作时的运算符优先级。当设为 true 时，与优先级组对应的运算符在可选链操作中使用和标准库中赋值运算符同样的分组规则，当设为 false 或者不设置，该优先级组的运算符与不赋值的运算符遵循同样的可选链规则。
#### grammer_of_a_precedence_group_declaration {#grammer_of_a_precedence_group_declaration}
#### grammer_of_a_precedence_group_declaration {#grammer-of-a-precedence-group-declaration}
> 优先级组声明语法
>
@@ -1727,7 +1727,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用，
> *优先级组名称* →[*标识符*](./02_Lexical_Structure.md#identifier)
>
## 声明修饰符 {#Declaration_Modifiers}
## 声明修饰符 {#Declaration-Modifiers}
声明修饰符都是关键字或上下文相关的关键字，可以修改一个声明的行为或者含义。可以在声明的特性（如果存在）和引入该声明的关键字之间，利用声明修饰符的关键字或上下文相关的关键字指定一个声明修饰符。
`dynamic`
@@ -1770,7 +1770,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用，
该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../chapter2/23_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。
### 访问控制级别 {#access_control_levels}
### 访问控制级别 {#access-control-levels}
Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../chapter2/25_Access_Control.md) 中有详细讨论。
`public`
@@ -1788,7 +1788,7 @@ Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`
以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../chapter2/25_Access_Control.md#getters_and_setters) 中所讨论的。
#### grammer_of_a_declaration_modifier {#grammer_of_a_declaration_modifier}
#### grammer_of_a_declaration_modifier {#grammer-of-a-declaration-modifier}
> 声明修饰符的语法
>