移除行末空格 (#782)

2018-05-06 19:13:01 +08:00
parent a3f0cae500
commit 08a76e561f
29 changed files with 1030 additions and 1030 deletions
--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@ -11,10 +11,10 @@
 > 2.1
 > 翻译：[mmoaay](https://github.com/mmoaay)

-> 2.2 
+> 2.2
 > 校对：[175](https://github.com/Brian175)

-> 3.0 
+> 3.0
 > 翻译+校对：[chenmingjia](https://github.com/chenmingjia)

 >  4.1
@ -38,7 +38,7 @@
    - [通配符表达式](#wildcard_expression)
    - [选择器表达式](#selector_expression)
 - [后缀表达式](#postfix_expressions)
-    - [函数调用表达式](#function_call_expression) 
+    - [函数调用表达式](#function_call_expression)
    - [构造器表达式](#initializer_expression)
    - [显式成员表达式](#explicit_member_expression)
    - [后缀 self 表达式](#postfix_self_expression)
@ -51,7 +51,7 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表

 通过前缀表达式和二元表达式可以对简单表达式使用各种运算符。基本表达式从概念上讲是最简单的一种表达式，它是一种访问值的方式。后缀表达式则允许你建立复杂的表达式，例如函数调用和成员访问。每种表达式都在下面有详细论述。

-> 表达式语法 
+> 表达式语法
 > 
 <a name="expression"></a>
 > *表达式* → [*try 运算符*](#try-operator)<sub>可选</sub> [*前缀表达式*](#prefix-expression) [*二元表达式列表*](#binary-expressions)<sub>可选</sub>
@ -60,7 +60,7 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表

 <a name="prefix_expressions"></a>
 ## 前缀表达式
- 
+
 前缀表达式由可选的前缀运算符和表达式组成。前缀运算符只接收一个参数，表达式则紧随其后。

 关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/25_Advanced_Operators.md)。
@ -69,7 +69,7 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表

 除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters)。

-> 前缀表达式语法 
+> 前缀表达式语法
 > 
 <a name="prefix-expression"></a>
 > *前缀表达式* → [*前缀运算符*](02_Lexical_Structure.md#prefix-operator)<sub>可选</sub> [*后缀表达式*](#postfix-expression)
@ -109,7 +109,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
 关于 `try`、`try?` 和 `try!` 的更多信息，以及该如何使用的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.html)。
 > Try 表达式语法
 > 
-<a name="try-operator"></a> 
+<a name="try-operator"></a>
 > *try 运算符* → **try** | **try?** | **try!**

 <a name="binary_expressions"></a>
@ -128,14 +128,14 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
 > 在解析时，一个二元表达式将作为一个扁平列表表示，然后根据运算符的优先级，再进一步进行组合。例如，`2 + 3 * 5` 首先被看作具有五个元素的列表，即 `2`、`+`、`3`、`*`、`5`，随后根据运算符优先级组合为 `(2 + (3 * 5))`。

 <a name="binary-expression"></a>
-> 二元表达式语法 
+> 二元表达式语法
 > 
-> *二元表达式* → [*二元运算符*](02_Lexical_Structure.md#binary-operator) [*前缀表达式*](#prefix-expression).     
-> *二元表达式* → [*赋值运算符*](#assignment-operator) [*try 运算符*](#try-operator)<sub>可选</sub> [*前缀表达式*](#prefix-expression)    
-> *二元表达式* → [*条件运算符*](#conditional-operator) [*try 运算符*](#try-operator)<sub>可选</sub> [*前缀表达式*](#prefix-expression)      
-> *二元表达式* → [*类型转换运算符*](#type-casting-operator)    
+> *二元表达式* → [*二元运算符*](02_Lexical_Structure.md#binary-operator) [*前缀表达式*](#prefix-expression)
+> *二元表达式* → [*赋值运算符*](#assignment-operator) [*try 运算符*](#try-operator)<sub>可选</sub> [*前缀表达式*](#prefix-expression)
+> *二元表达式* → [*条件运算符*](#conditional-operator) [*try 运算符*](#try-operator)<sub>可选</sub> [*前缀表达式*](#prefix-expression)
+> *二元表达式* → [*类型转换运算符*](#type-casting-operator)
 <a name="binary-expressions"></a>
-> *二元表达式列表* → [*二元表达式*](#binary-expression) [*二元表达式列表*](#binary-expressions)<sub>可选</sub>     
+> *二元表达式列表* → [*二元表达式*](#binary-expression) [*二元表达式列表*](#binary-expressions)<sub>可选</sub>

 <a name="assignment_operator"></a>
 ### 赋值表达式
@ -153,7 +153,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try

 赋值运算符不返回任何值。

-> 赋值运算符语法 
+> 赋值运算符语法
 > 
 <a name="assignment-operator"></a>
 > *赋值运算符* → **=**
@ -169,7 +169,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try

 关于使用三元条件运算符的例子，请参阅 [三元条件运算符](../chapter2/02_Basic_Operators.md#ternary_conditional_operator)。

-> 三元条件运算符语法 
+> 三元条件运算符语法
 > 
 <a name="conditional-operator"></a>
 > *三元条件运算符* → **?** [*表达式*](#expression) **:**
@ -197,11 +197,11 @@ func f(int: Int) { print("Function for Int") }
 let x = 10
 f(x)
 // 打印 “Function for Int”
- 
+
 let y: Any = x
 f(y)
 // 打印 “Function for Any”
- 
+
 f(x as Any)
 // 打印 “Function for Any”
 ```
@ -215,12 +215,12 @@ f(x as Any)
 关于类型转换的更多内容和例子，请参阅 [类型转换](../chapter2/19_Type_Casting.md)。

 <a name="type-casting-operator"></a>
-> 类型转换运算符语法 
+> 类型转换运算符语法
 > 
-> *类型转换运算符* → **is** [*类型*](03_Types.md#type)    
-> *类型转换运算符* → **as** [*类型*](03_Types.md#type)   
-> *类型转换运算符* → **as** **?** [*类型*](03_Types.md#type)    
-> *类型转换运算符* → **as** **!** [*类型*](03_Types.md#type)      
+> *类型转换运算符* → **is** [*类型*](03_Types.md#type)
+> *类型转换运算符* → **as** [*类型*](03_Types.md#type)
+> *类型转换运算符* → **as** **?** [*类型*](03_Types.md#type)
+> *类型转换运算符* → **as** **!** [*类型*](03_Types.md#type)

 <a name="primary_expressions"></a>
 ## 基本表达式
@ -230,16 +230,16 @@ f(x as Any)
 > 基本表达式语法
 > 
 <a name="primary-expression"></a>
-> *基本表达式* → [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub>     
-> *基本表达式* → [*字面量表达式*](#literal-expression)     
-> *基本表达式* → [*self 表达式*](#self-expression)    
-> *基本表达式* → [*超类表达式*](#superclass-expression)     
-> *基本表达式* → [*闭包表达式*](#closure-expression)     
-> *基本表达式* → [*圆括号表达式*](#parenthesized-expression)     
-> *基本表达式* → [*隐式成员表达式*](#implicit-member-expression)     
-> *基本表达式* → [*通配符表达式*](#wildcard-expression)    
-> *基本表达式* → [*选择器表达式*](#selector-expression)   
-> *基本表达式* → [*key-path字符串表达式*](#key-patch-string-expression)    
+> *基本表达式* → [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub>
+> *基本表达式* → [*字面量表达式*](#literal-expression)
+> *基本表达式* → [*self 表达式*](#self-expression)
+> *基本表达式* → [*超类表达式*](#superclass-expression)
+> *基本表达式* → [*闭包表达式*](#closure-expression)
+> *基本表达式* → [*圆括号表达式*](#parenthesized-expression)
+> *基本表达式* → [*隐式成员表达式*](#implicit-member-expression)
+> *基本表达式* → [*通配符表达式*](#wildcard-expression)
+> *基本表达式* → [*选择器表达式*](#selector-expression)
+> *基本表达式* → [*key-path字符串表达式*](#key-patch-string-expression)

 <a name="literal_expression"></a>
 ### 字面量表达式
@ -263,7 +263,7 @@ func logFunctionName(string: String = #function) {
    print(string)
 }
 func myFunction() {
-    logFunctionName() 
+    logFunctionName()
 }
 myFunction() // 打印 “myFunction()”
 ```
@ -291,23 +291,23 @@ var emptyDictionary: [String : Double] = [:]
 > 字面量表达式语法
 > 
 <a name="literal-expression"></a>
-> *字面量表达式* → [*字面量*](02_Lexical_Structure.md#literal)    
-> *字面量表达式* → [*数组字面量*](#array-literal) | [*字典字面量*](#dictionary-literal) | [*练习场字面量*](#playground-literal)     
-> *字面量表达式* → **#file** | **#line** | **#column** | **#function**
+> *字面量表达式* → [*字面量*](02_Lexical_Structure.md#literal)
+> *字面量表达式* → [*数组字面量*](#array-literal) | [*字典字面量*](#dictionary-literal) | [*练习场字面量*](#playground-literal)
+> *字面量表达式* → **#file** | **#line** | **#column** | **#function**
 > 
 <a name="array-literal"></a>
-> *数组字面量* → [[*数组字面量项列表*](#array-literal-items)<sub>可选</sub> **]**     
+> *数组字面量* → [[*数组字面量项列表*](#array-literal-items)<sub>可选</sub> **]**
 <a name="array-literal-items"></a>
-> *数组字面量项列表* → [*数组字面量项*](#array-literal-item) **,**<sub>可选</sub> | [*数组字面量项*](#array-literal-item) **,** [*数组字面量项列表*](#array-literal-items)    
+> *数组字面量项列表* → [*数组字面量项*](#array-literal-item) **,**<sub>可选</sub> | [*数组字面量项*](#array-literal-item) **,** [*数组字面量项列表*](#array-literal-items)
 <a name="array-literal-item"></a>
-> *数组字面量项* → [*表达式*](#expression)     
+> *数组字面量项* → [*表达式*](#expression)
 > 
 <a name="dictionary-literal"></a>
-> *字典字面量* → [[*字典字面量项列表*](#dictionary-literal-items) **]** | **[** **:** **]**     
+> *字典字面量* → [[*字典字面量项列表*](#dictionary-literal-items) **]** | **[** **:** **]**
 <a name="dictionary-literal-items"></a>
-> *字典字面量项列表* → [*字典字面量项*](#dictionary-literal-item) **,**<sub>可选</sub> | [*字典字面量项*](#dictionary-literal-item) **,** [*字典字面量项列表*](#dictionary-literal-items)           
+> *字典字面量项列表* → [*字典字面量项*](#dictionary-literal-item) **,**<sub>可选</sub> | [*字典字面量项*](#dictionary-literal-item) **,** [*字典字面量项列表*](#dictionary-literal-items)
 <a name="dictionary-literal-item"></a>
-> *字典字面量项* → [*表达式*](#expression) **:** [*表达式*](#expression)。   
+> *字典字面量项* → [*表达式*](#expression) **:** [*表达式*](#expression)。


 <a name="self_expression"></a>
@ -315,11 +315,11 @@ var emptyDictionary: [String : Double] = [:]

 `self` 表达式是对当前类型或者当前实例的显式引用，它有如下形式：

-> self      
-> self.`成员名称`   
-> self[`下标索引`]   
-> self(`构造器参数`)    
-> self.init(`构造器参数`)    
+> self
+> self.`成员名称`
+> self[`下标索引`]
+> self(`构造器参数`)
+> self.init(`构造器参数`)

 如果在构造器、下标、实例方法中，`self` 引用的是当前类型的实例。在一个类型方法中，`self` 引用的是当前的类型。

@ -345,42 +345,42 @@ struct Point {
 }
 ```

-> Self 表达式语法 
+> Self 表达式语法
 > 
 <a name="self-expression"></a>
-> *self 表达式* → **self**  | [*self 方法表达式*](#self-method-expression) ｜ [*self 下标表达式*](#self-subscript-expression) | [*self 构造器表达式*](#self-initializer-expression)    
+> *self 表达式* → **self**  | [*self 方法表达式*](#self-method-expression) ｜ [*self 下标表达式*](#self-subscript-expression) | [*self 构造器表达式*](#self-initializer-expression)
 >
 <a name="self-method-expression"></a>
-> *self 方法表达式* → **self** **.** [*标识符*](02_Lexical_Structure.md#identifier)     
+> *self 方法表达式* → **self** **.** [*标识符*](02_Lexical_Structure.md#identifier)
 <a name="self-subscript-expression"></a>
-> *self 下标表达式* → **self** [ [*函数调用参数表*](#function-call-argument-list) **]**      
-<a name="self-initializer-expression"></a> 
-> *self 构造器表达式* → **self** **.** **init**   
+> *self 下标表达式* → **self** [ [*函数调用参数表*](#function-call-argument-list) **]**
+<a name="self-initializer-expression"></a>
+> *self 构造器表达式* → **self** **.** **init**

 <a name="superclass_expression"></a>
 ### 父类表达式

 *父类*表达式可以使我们在某个类中访问它的超类，它有如下形式：

-> super.`成员名称`   
-> super[`下标索引`]     
-> super.init(`构造器参数`)    
+> super.`成员名称`
+> super[`下标索引`]
+> super.init(`构造器参数`)

 第一种形式用来访问超类的某个成员，第二种形式用来访问超类的下标，第三种形式用来访问超类的构造器。

 子类可以通过超类表达式在它们的成员、下标和构造器中使用超类中的实现。

-> 父类表达式语法 
+> 父类表达式语法
 > 
 <a name="superclass-expression"></a>
-> *超类表达式* → [*超类方法表达式*](#superclass-method-expression) | [*超类下标表达式*](#superclass-subscript-expression) | [*超类构造器表达式*](#superclass-initializer-expression) 
+> *超类表达式* → [*超类方法表达式*](#superclass-method-expression) | [*超类下标表达式*](#superclass-subscript-expression) | [*超类构造器表达式*](#superclass-initializer-expression)
 > 
 <a name="superclass-method-expression"></a>
-> *超类方法表达式* → **super** **.** [*标识符*](02_Lexical_Structure.md#identifier)     
+> *超类方法表达式* → **super** **.** [*标识符*](02_Lexical_Structure.md#identifier)
 <a name="superclass-subscript-expression"></a>
-> *超类下标表达式* → **super** [[*函数调用参数表*](#function-call-argument-list) **]**     
+> *超类下标表达式* → **super** [[*函数调用参数表*](#function-call-argument-list) **]**
 <a name="superclass-initializer-expression"></a>
-> *超类构造器表达式* → **super** **.** **init**   
+> *超类构造器表达式* → **super** **.** **init**

 <a name="closure_expression"></a>
 ### 闭包表达式
@ -484,24 +484,24 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
 > 闭包表达式语法
 > 
 <a name="closure-expression"></a>
-> *闭包表达式* → **{** [*闭包签名*](#closure-signature)<sub>可选</sub> [*语句*](#statements) **}**   
+> *闭包表达式* → **{** [*闭包签名*](#closure-signature)<sub>可选</sub> [*语句*](#statements) **}**

 <a name="closure-signature"></a>
-> *闭包签名* → [*参数子句*](#parameter-clause) [*函数结果*](05_Declarations.html#function-result)<sub>可选</sub> **in**        
-> *闭包签名* → [*标识符列表*](#identifier-list) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**     
-> *闭包签名* → [*捕获列表*](#capture-list) [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**      
-> *闭包签名* → [*捕获列表*](#capture-list) [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**      
-> *闭包签名* → [*捕获列表*](#capture-list) **in**    
+> *闭包签名* → [*参数子句*](#parameter-clause) [*函数结果*](05_Declarations.html#function-result)<sub>可选</sub> **in**
+> *闭包签名* → [*标识符列表*](#identifier-list) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**
+> *闭包签名* → [*捕获列表*](#capture-list) [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**
+> *闭包签名* → [*捕获列表*](#capture-list) [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**
+> *闭包签名* → [*捕获列表*](#capture-list) **in**

 <a name="capture-list"></a>
-> *捕获列表* → [ [*捕获列表项列表*](#capture-list-items) **]**    
+> *捕获列表* → [ [*捕获列表项列表*](#capture-list-items) **]**
 <a name="capture-list-items"></a>
-> *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items)    
+> *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items)
 <a name="capture-list-item"></a>
-> *捕获列表项* → [*捕获说明符*](#capture-specifier)<sub>可选</sub> [*表达式*](#expression)     
+> *捕获列表项* → [*捕获说明符*](#capture-specifier)<sub>可选</sub> [*表达式*](#expression)
 <a name="capture-specifier"></a>
 > *捕获说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**
-     
+
 <a name="implicit_member_expression"></a>
 ### 隐式成员表达式

@ -516,10 +516,10 @@ var x = MyEnumeration.SomeValue
 x = .AnotherValue
 ```

-> 隐式成员表达式语法 
+> 隐式成员表达式语法
 > 
 <a name="implicit-member-expression"></a>
-> *隐式成员表达式* → **.** [*标识符*](02_Lexical_Structure.md#identifier)   
+> *隐式成员表达式* → **.** [*标识符*](02_Lexical_Structure.md#identifier)

 <a name="parenthesized_expression"></a>
 ### 圆括号表达式
@ -529,7 +529,7 @@ x = .AnotherValue
 > 圆括号表达式语法
 > 
 <a name="parenthesized-expression"></a>
-> *圆括号表达式* → **( [*表达式*](#expression) )**   
+> *圆括号表达式* → **( [*表达式*](#expression) )**

 <a name="Tuple_Expression"></a>
 ### 元组表达式
@ -543,11 +543,11 @@ x = .AnotherValue
 > 元组表达式语法
 > 
 <a name="tuple-expression"></a>
-> *元组表达式* → **( )** | **(**[*元组元素*](#tuple-element)， [*元组元素列表*](#tuple-element-list) **)**   
+> *元组表达式* → **( )** | **(**[*元组元素*](#tuple-element)， [*元组元素列表*](#tuple-element-list) **)**
 <a name="tuple-element-list"></a>
-> *元组元素列表* → [*元组元素*](#tuple-element) | [*元组元素*](#tuple-element) **,** [*元组元素列表*](#tuple-element-list)    
+> *元组元素列表* → [*元组元素*](#tuple-element) | [*元组元素*](#tuple-element) **,** [*元组元素列表*](#tuple-element-list)
 <a name="tuple-element"></a>
-> *元组元素* → [*表达式*](#expression) | [*标识符*](identifier) **:** [*表达式*](#expression)     
+> *元组元素* → [*表达式*](#expression) | [*标识符*](identifier) **:** [*表达式*](#expression)

 <a name="wildcard_expression"></a>
 ### 通配符表达式
@ -559,7 +559,7 @@ x = .AnotherValue
 // x 为 10，20 被忽略
 ```

-> 通配符表达式语法 
+> 通配符表达式语法
 > 
 <a name="wildcard-expression"></a>
 > *通配符表达式* → **_**
@ -626,16 +626,16 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str

 > 后缀表达式语法
 <a name="postfix-expression"></a>
-> *后缀表达式* → [*基本表达式*](#primary-expression)    
-> *后缀表达式* → [*后缀表达式*](#postfix-expression) [*后缀运算符*](02_Lexical_Structure.md#postfix-operator)    
-> *后缀表达式* → [*函数调用表达式*](#function-call-expression)     
-> *后缀表达式* → [*构造器表达式*](#initializer-expression)    
-> *后缀表达式* → [*显式成员表达式*](#explicit-member-expression)     
-> *后缀表达式* → [*后缀 self 表达式*](#postfix-self-expression)     
-> *后缀表达式* → [*dynamicType 表达式*](#dynamic-type-expression)     
-> *后缀表达式* → [*下标表达式*](#subscript-expression)    
-> *后缀表达式* → [*强制取值表达式*](#forced-value-expression)    
-> *后缀表达式* → [*可选链表达式*](#optional-chaining-expression)    
+> *后缀表达式* → [*基本表达式*](#primary-expression)
+> *后缀表达式* → [*后缀表达式*](#postfix-expression) [*后缀运算符*](02_Lexical_Structure.md#postfix-operator)
+> *后缀表达式* → [*函数调用表达式*](#function-call-expression)
+> *后缀表达式* → [*构造器表达式*](#initializer-expression)
+> *后缀表达式* → [*显式成员表达式*](#explicit-member-expression)
+> *后缀表达式* → [*后缀 self 表达式*](#postfix-self-expression)
+> *后缀表达式* → [*dynamicType 表达式*](#dynamic-type-expression)
+> *后缀表达式* → [*下标表达式*](#subscript-expression)
+> *后缀表达式* → [*强制取值表达式*](#forced-value-expression)
+> *后缀表达式* → [*可选链表达式*](#optional-chaining-expression)

 <a name="function_call_expression"></a>
 ### 函数调用表达式
@ -668,10 +668,10 @@ myData.someMethod {$0 == 13}

 > 函数调用表达式语法
 <a name="function-call-expression"></a>
-> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression)   
-> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression)<sub>可选</sub> [*尾随闭包*](#trailing-closure)    
+> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression)
+> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression)<sub>可选</sub> [*尾随闭包*](#trailing-closure)
 <a name="trailing-closure"></a>
-> *尾随闭包* → [*闭包表达式*](#closure-expression)    
+> *尾随闭包* → [*闭包表达式*](#closure-expression)

 <a name="initializer_expression"></a>
 ### 构造器表达式
@ -713,8 +713,8 @@ let s3 = someValue.dynamicType.init(data: 7) // 有效

 > 构造器表达式语法
 <a name="initializer-expression"></a>
-> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init**     
-> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init** **(** [*参数名称*](#argument-names) **)**    
+> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init**
+> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init** **(** [*参数名称*](#argument-names) **)**

 <a name="explicit_member_expression"></a>
 ### 显式成员表达式
@ -773,14 +773,14 @@ let x = [10, 3, 20, 15, 4]

 > 显式成员表达式语法
 <a name="explicit-member-expression"></a>
-> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*]    (02_Lexical_Structure.html#decimal-digit)    
+> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*]    (02_Lexical_Structure.html#decimal-digit)
 > *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.html#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.html#generic-argument-clause)<sub>可选</sub><br/>
-> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*]    (02_Lexical_Structure.html#identifier) **(** [*参数名称*](#argument-names) **)**
->    
+> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*]    (02_Lexical_Structure.html#identifier) **(** [*参数名称*](#argument-names) **)**
+> 
 <a name="argument-names"></a>
 > *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)<sub>可选</sub><br/>
 <a name="argument-name"></a>
-> *参数名* → [*标识符*](02_Lexical_Structure.html#identifier) **:**    
+> *参数名* → [*标识符*](02_Lexical_Structure.html#identifier) **:**

 <a name="postfix_self_expression"></a>
 ### 后缀 self 表达式
@ -794,7 +794,7 @@ let x = [10, 3, 20, 15, 4]

 第二种形式返回相应的类型。我们可以用它来获取某个实例的类型作为一个值来使用。例如，`SomeClass.self` 会返回 `SomeClass` 类型本身，你可以将其传递给相应函数或者方法作为参数。

-> 后缀 self 表达式语法
+> 后缀 self 表达式语法
 > 
 <a name="postfix-self-expression"></a>
 > *后缀 self 表达式* → [*后缀表达式*](#postfix-expression) **.** **self**
@ -811,7 +811,7 @@ let x = [10, 3, 20, 15, 4]

 关于下标的声明，请参阅 [协议下标声明](05_Declarations.html#protocol_subscript_declaration)。

-> 下标表达式语法
+> 下标表达式语法
 > 
 <a name="subscript-expression"></a>
 > *下标表达式* → [*后缀表达式*](#postfix-expression) **[** [*表达式列表*](#expression-list) **]**
@ -831,13 +831,13 @@ let x = [10, 3, 20, 15, 4]
 var x: Int? = 0
 x!++
 // x 现在是 1
- 
+
 var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
 someDictionary["a"]![0] = 100
-// someDictionary 现在是 [b: [10, 20], a: [100, 2, 3]] 
+// someDictionary 现在是 [b: [10, 20], a: [100, 2, 3]]
 ```

-> 强制取值语法
+> 强制取值语法
 > 
 <a name="forced-value-expression"></a>
 > *强制取值表达式* → [*后缀表达式*](#postfix-expression) **!**
@ -874,8 +874,8 @@ if let unwrappedC = c {
 ```swift
 func someFunctionWithSideEffects() -> Int {
    // 译者注：为了能看出此函数是否被执行，加上了一句打印
-    print("someFunctionWithSideEffects") 
-    return 42 
+    print("someFunctionWithSideEffects")
+    return 42
 }
 var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]

@ -888,7 +888,7 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects()
 // someDictionary 现在是 ["b": [10, 20], "a": [42, 2, 3]]
 ```

-> 可选链表达式语法
+> 可选链表达式语法
 > 
 <a name="optional-chaining-expression"></a>
 > *可选链表达式* → [*后缀表达式*](#postfix-expression) **?**