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

fix all anchor format

Browse Source
This commit is contained in:
Jie Liang
2019-03-27 00:14:08 -05:00
parent cd06ac6f52
commit fc86ccb932
39 changed files with 878 additions and 1511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
source/chapter3/04_Expressions.md
View File

@ -6,16 +6,14 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表
> 表达式语法
>
<a name="expression"></a>
expression {#expression}
> *表达式* → [*try 运算符*](#try-operator)<sub>可选</sub> [*前缀表达式*](#prefix-expression) [*二元表达式列表*](#binary-expressions)<sub>可选</sub>
>
<a name="expression-list"></a>
expression-list {#expression-list}
> *表达式列表* → [*表达式*](#expression) | [*表达式*](#expression) **,** [*表达式列表*](#expression-list)
>
<a name="prefix_expressions"></a>
## 前缀表达式
## 前缀表达式 {#prefix_expressions}
前缀表达式由可选的前缀运算符和表达式组成。前缀运算符只接收一个参数，表达式则紧随其后。
关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md)。
@ -26,18 +24,16 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表
> 前缀表达式语法
>
<a name="prefix-expression"></a>
prefix-expression {#prefix-expression}
> *前缀表达式* → [*前缀运算符*](./02_Lexical_Structure.md#prefix-operator)<sub>可选</sub> [*后缀表达式*](#postfix-expression)
>
> *前缀表达式* → [*输入输出表达式*](#in-out-expression)
>
<a name="in-out-expression"></a>
in-out-expression {#in-out-expression}
> *输入输出表达式* → **&** [*标识符*](./02_Lexical_Structure.md#identifier)
>
<a name="try_operator"></a>
### Try 运算符
### Try 运算符 {#try_operator}
try 表达式由 `try` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下：
> try `可抛出错误的表达式`
@ -70,13 +66,11 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
关于 `try`、`try?` 和 `try!` 的更多信息，以及该如何使用的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md)。
> Try 表达式语法
>
<a name="try-operator"></a>
try-operator {#try-operator}
> *try 运算符* → **try** | **try?** | **try!**
>
<a name="binary_expressions"></a>
## 二元表达式
## 二元表达式 {#binary_expressions}
*二元表达式*由中缀运算符和左右参数表达式组成。形式如下：
> `左侧参数` `二元运算符` `右侧参数`
@ -91,7 +85,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
> 在解析时，一个二元表达式将作为一个扁平列表表示，然后根据运算符的优先级，再进一步进行组合。例如，`2 + 3 * 5` 首先被看作具有五个元素的列表，即 `2`、`+`、`3`、`*`、`5`，随后根据运算符优先级组合为 `(2 + (3 * 5))`。
>
<a name="binary-expression"></a>
binary-expression {#binary-expression}
> 二元表达式语法
>
> *二元表达式* → [*二元运算符*](./02_Lexical_Structure.md#binary-operator) [*前缀表达式*](#prefix-expression)
@ -102,13 +96,11 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
>
> *二元表达式* → [*类型转换运算符*](#type-casting-operator)
>
<a name="binary-expressions"></a>
binary-expressions {#binary-expressions}
> *二元表达式列表* → [*二元表达式*](#binary-expression) [*二元表达式列表*](#binary-expressions)<sub>可选</sub>
>
<a name="assignment_operator"></a>
### 赋值表达式
### 赋值表达式 {#assignment_operator}
赋值表达式会为某个给定的表达式赋值，形式如下；
> `表达式` = `值`
@ -125,13 +117,11 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
> 赋值运算符语法
>
<a name="assignment-operator"></a>
assignment-operator {#assignment-operator}
> *赋值运算符* → **=**
>
<a name="ternary_conditional_operator"></a>
### 三元条件运算符
### 三元条件运算符 {#ternary_conditional_operator}
*三元条件运算符*会根据条件来对两个给定表达式中的一个进行求值，形式如下：
> `条件` ? `表达式（条件为真则使用）` : `表达式（条件为假则使用）`
@ -143,13 +133,11 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
> 三元条件运算符语法
>
<a name="conditional-operator"></a>
conditional-operator {#conditional-operator}
> *三元条件运算符* → **?** [*表达式*](#expression) **:**
>
<a name="type-casting_operators"></a>
### 类型转换运算符
### 类型转换运算符 {#type-casting_operators}
有 4 种类型转换运算符：`is`、`as`、`as? ` 和 `as!`。它们有如下的形式：
> `表达式` is `类型`
@ -188,7 +176,7 @@ f(x as Any)
关于类型转换的更多内容和例子，请参阅 [类型转换](../chapter2/18_Type_Casting.md)。
<a name="type-casting-operator"></a>
type-casting-operator {#type-casting-operator}
> 类型转换运算符语法
>
> *类型转换运算符* → **is** [*类型*](./03_Types.md#type)
@ -200,14 +188,12 @@ f(x as Any)
> *类型转换运算符* → **as** **!** [*类型*](./03_Types.md#type)
>
<a name="primary_expressions"></a>
## 基本表达式
## 基本表达式 {#primary_expressions}
*基本表达式*是最基本的表达式。它们可以单独使用，也可以跟前缀表达式、二元表达式、后缀表达式组合使用。
> 基本表达式语法
>
<a name="primary-expression"></a>
primary-expression {#primary-expression}
> *基本表达式* → [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub>
>
> *基本表达式* → [*字面量表达式*](#literal-expression)
@ -229,9 +215,7 @@ f(x as Any)
> *基本表达式* → [*key-path字符串表达式*](#key-patch-string-expression)
>
<a name="literal_expression"></a>
### 字面量表达式
### 字面量表达式 {#literal_expression}
*字面量表达式*可由普通字面量（例如字符串或者数字），字典或者数组字面量，或者下面列表中的特殊字面量组成：
字面量 | 类型 | 值
@ -285,7 +269,7 @@ Xcode 使用 playground 字面量对程序编辑器中的颜色、文件或者
> 字面量表达式语法
>
>
> <a name="literal-expression"></a>
> literal-expression {#literal-expression}
>
> *字面量表达式* → [*字面量*](./02_Lexical_Structure.md#literal)
>
@ -295,38 +279,38 @@ Xcode 使用 playground 字面量对程序编辑器中的颜色、文件或者
>
> <a name="array-literal"></a>
> array-literal {#array-literal}
>
> *数组字面量* → [[*数组字面量项列表*](#array-literal-items)<sub>可选</sub> **]**
>
> <a name="array-literal-items"></a>
> array-literal-items {#array-literal-items}
>
> *数组字面量项列表* → [*数组字面量项*](#array-literal-item) **,**<sub>可选</sub> | [*数组字面量项*](#array-literal-item) **,** [*数组字面量项列表*](#array-literal-items)
>
> <a name="array-literal-item"></a>
> array-literal-item {#array-literal-item}
>
> *数组字面量项* → [*表达式*](#expression)
>
>
> <a name="dictionary-literal"></a>
> dictionary-literal {#dictionary-literal}
>
> *字典字面量* → [[*字典字面量项列表*](#dictionary-literal-items) **]** | **[** **:** **]**
>
> <a name="dictionary-literal-items"></a>
> dictionary-literal-items {#dictionary-literal-items}
>
> *字典字面量项列表* → [*字典字面量项*](#dictionary-literal-item) **,**<sub>可选</sub> | [*字典字面量项*](#dictionary-literal-item) **,** [*字典字面量项列表*](#dictionary-literal-items)
>
> <a name="dictionary-literal-item"></a>
> dictionary-literal-item {#dictionary-literal-item}
>
> *字典字面量项* → [*表达式*](#expression) **:** [*表达式*](#expression)。
>
> <a name="playground-literal"></a>
> playground-literal {#playground-literal}
>
> *playground 字面量* → **#colorLiteral ( red : [*表达式*](#expression) , green :[*表达式*](#expression) [*表达式*](#e[*表达式*](#expression) xpression) , blue :[*表达式*](#expression) , alpha : [*表达式*](#expression) )**
>
> *playground 字面量* → **#fileLiteral ( resourceName : [*表达式*](#expression) )**
>
> playground 字面量* → **#imageLiteral ( resourceName : [*表达式*](#expression) )**<a name="self_expression"></a>
> playground 字面量* → **#imageLiteral ( resourceName : [*表达式*](#expression) )**self_expression {#self_expression}
>
### Self 表达式
@ -370,23 +354,21 @@ struct Point {
> Self 表达式语法
>
<a name="self-expression"></a>
self-expression {#self-expression}
> *self 表达式* → **self** | [*self 方法表达式*](#self-method-expression) ｜ [*self 下标表达式*](#self-subscript-expression) | [*self 构造器表达式*](#self-initializer-expression)
>
>
<a name="self-method-expression"></a>
self-method-expression {#self-method-expression}
> *self 方法表达式* → **self** **.** [*标识符*](./02_Lexical_Structure.md#identifier)
>
<a name="self-subscript-expression"></a>
self-subscript-expression {#self-subscript-expression}
> *self 下标表达式* → **self** **[** [*函数调用参数表*](#function-call-argument-list­) **]**
>
<a name="self-initializer-expression"></a>
self-initializer-expression {#self-initializer-expression}
> *self 构造器表达式* → **self** **.** **init**
>
<a name="superclass_expression"></a>
### 父类表达式
### 父类表达式 {#superclass_expression}
*父类*表达式可以使我们在某个类中访问它的父类，它有如下形式：
> super.`成员名称`
@ -402,22 +384,20 @@ struct Point {
> 父类表达式语法
>
<a name="superclass-expression"></a>
superclass-expression {#superclass-expression}
> *父类表达式* → [*父类方法表达式*](#superclass-method-expression) | [*父类下标表达式*](#superclass-subscript-expression) | [*父类构造器表达式*](#superclass-initializer-expression)
>
<a name="superclass-method-expression"></a>
superclass-method-expression {#superclass-method-expression}
> *父类方法表达式* → **super** **.** [*标识符*](./02_Lexical_Structure.md#identifier)
>
<a name="superclass-subscript-expression"></a>
superclass-subscript-expression {#superclass-subscript-expression}
> *父类下标表达式* → **super** [[*函数调用参数表*](#function-call-argument-list­) **]**
>
<a name="superclass-initializer-expression"></a>
superclass-initializer-expression {#superclass-initializer-expression}
> *父类构造器表达式* → **super** **.** **init**
>
<a name="closure_expression"></a>
### 闭包表达式
### 闭包表达式 {#closure_expression}
*闭包表达式*会创建一个闭包，在其他语言中也叫 *lambda* 或*匿名*函数。跟函数一样，闭包包含了待执行的代码，不同的是闭包还会捕获所在环境中的常量和变量。它的形式如下：
```swift
@ -460,10 +440,7 @@ myFunction { $0 + $1 }
关于逃逸闭包的内容，请参阅[逃逸闭包](./chapter2/07_Closures.md#escaping_closures)
<a name="capture-lists"></a>
## 捕获列表
## 捕获列表 {#capture-lists}
默认情况下，闭包会捕获附近作用域中的常量和变量，并使用强引用指向它们。你可以通过一个*捕获列表*来显式指定它的捕获行为。
捕获列表在参数列表之前，由中括号括起来，里面是由逗号分隔的一系列表达式。一旦使用了捕获列表，就必须使用 `in` 关键字，即使省略了参数名、参数类型和返回类型。
@ -524,12 +501,12 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
> 闭包表达式语法
>
>
> <a name="closure-expression"></a>
> closure-expression {#closure-expression}
>
> *闭包表达式* → **{** [*闭包签名*](#closure-signature)<sub>可选</sub> [*语句*](#statements) **}**
>
>
> <a name="closure-signature"></a>
> closure-signature {#closure-signature}
>
>
> 闭包签名* → [*参数子句*](#parameter-clause) [*函数结果*](05_Declarations.md#function-result)<sub>可选</sub> **in**
@ -543,27 +520,25 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
> *闭包签名* → [*捕获列表*](#capture-list) **in**
>
>
> <a name="capture-list"></a>
> capture-list {#capture-list}
>
>
> 捕获列表* → [ [*捕获列表项列表*](#capture-list-items) **]**
>
> <a name="capture-list-items"></a>
> capture-list-items {#capture-list-items}
>
> *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items)
>
> <a name="capture-list-item"></a>
> capture-list-item {#capture-list-item}
>
> *捕获列表项* → [*捕获说明符*](#capture-specifier)<sub>可选</sub> [*表达式*](#expression)
>
> <a name="capture-specifier"></a>
> capture-specifier {#capture-specifier}
>
> *捕获说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**
>
<a name="implicit_member_expression"></a>
### 隐式成员表达式
### 隐式成员表达式 {#implicit_member_expression}
若类型可被推断出来，可以使用*隐式成员表达式*来访问某个类型的成员（例如某个枚举成员或某个类型方法），形式如下：
> .`成员名称`
@ -578,24 +553,20 @@ x = .AnotherValue
> 隐式成员表达式语法
>
<a name="implicit-member-expression"></a>
implicit-member-expression {#implicit-member-expression}
> *隐式成员表达式* → **.** [*标识符*](./02_Lexical_Structure.md#identifier)
>
<a name="parenthesized_expression"></a>
### 圆括号表达式
### 圆括号表达式 {#parenthesized_expression}
*圆括号表达式*是由圆括号包围的表达式。你可以用圆括号说明成组的表达式的先后操作。成组的圆括号不会改变表达式的类型 - 例如 `(1)` 的类型就是简单的 `Int`。
> 圆括号表达式语法
>
<a name="parenthesized-expression"></a>
parenthesized-expression {#parenthesized-expression}
> *圆括号表达式* → **( [*表达式*](#expression) )**
>
<a name="Tuple_Expression"></a>
### 元组表达式
### 元组表达式 {#Tuple_Expression}
*元组表达式*由圆括号和其中多个逗号分隔的子表达式组成。每个子表达式前面可以有一个标识符，用冒号隔开。元组表达式形式如下：
> (`标识符 1` : `表达式 1`, `标识符 2` : `表达式 2`, `...`)
@ -612,20 +583,17 @@ x = .AnotherValue
> 元组表达式语法
>
<a name="tuple-expression"></a>
tuple-expression {#tuple-expression}
> *元组表达式* → **( )** | **(**[*元组元素*](#tuple-element)， [*元组元素列表*](#tuple-element-list) **)**
>
<a name="tuple-element-list"></a>
tuple-element-list {#tuple-element-list}
> *元组元素列表* → [*元组元素*](#tuple-element) | [*元组元素*](#tuple-element) **,** [*元组元素列表*](#tuple-element-list)
>
<a name="tuple-element"></a>
tuple-element {#tuple-element}
> *元组元素* → [*表达式*](#expression) | [*标识符*](identifier) **:** [*表达式*](#expression)
>
<a name="wildcard_expression"></a>
### 通配符表达式
### 通配符表达式 {#wildcard_expression}
*通配符表达式*可以在赋值过程中显式忽略某个值。例如下面的代码中，`10` 被赋值给 `x`，而 `20` 则被忽略：
```swift
@ -635,14 +603,12 @@ x = .AnotherValue
> 通配符表达式语法
>
<a name="wildcard-expression"></a>
wildcard-expression {#wildcard-expression}
> *通配符表达式* → **_**
>
<a name="key-path_expression"></a>
### Key-path 表达式
### Key-path 表达式 {#key-path_expression}
Key-path 表达式引用一个类型的属性或下标。在动态语言中使场景可以使用 Key-path 表达式，例如观察键值对。格式为：
> **\类型名.路径**
@ -774,31 +740,28 @@ print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count.bitWidth
> key-path 表达式语法
>
>
> <a name="key-path-expression"></a>
> key-path-expression {#key-path-expression}
>
> *key-path 表达式* → **\\** [类型](./03_Types.md#type)<sub>可选</sub> **.** [多个 key-path 组件](#key-path-components)
>
> <a name="key-path-components"></a>
> key-path-components {#key-path-components}
>
> *多个 key-path 组件* → [key-path 组件](#key-path-component) | [key-path 组件](#key-path-component) **.** [多个 key-path 组件](#key-path-components)
>
> <a name="key-path-component"></a>
> key-path-component {#key-path-component}
>
> *key-path 组件* → [标识符](./02_Lexical_Structure.md#identifier) [多个 key-path 后缀](#key-path-postfixes)<sub>可选<sub> | [多个 key-path 后缀](#key-path-postfixes)
>
> <a name="key-path-postfixes"></a>
> key-path-postfixes {#key-path-postfixes}
>
> *多个 key-path 后缀* → [key-path 后缀](#key-path-postfix) [多个 key-path 后缀](#key-path-postfixes)<sub>可选<sub> <a name="key-path-postfixes"></a>
> *多个 key-path 后缀* → [key-path 后缀](#key-path-postfix) [多个 key-path 后缀](#key-path-postfixes)<sub>可选<sub> key-path-postfixes {#key-path-postfixes}
>
> *key-path 后缀* → **?** | **!** | **self** | **\[** [函数调用参数表](#function-call-argument-list) **\]**
>
<a name="selector_expression"></a>
### 选择器表达式
### 选择器表达式 {#selector_expression}
*选择器表达式*可以让你通过选择器来引用在 Objective-C 中方法（method）和属性（property）的 setter 和 getter 方法。
> \#selector(方法名)
@ -846,7 +809,7 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str
> 选择器表达式语法
>
<a name="selector-expression"></a>
selector-expression {#selector-expression}
> *选择器表达式* → __#selector__ **(** [*表达式*](#expression) **)**
>
> *选择器表达式* → __#selector__ **(** [*getter:表达式*](#expression) **)**
@ -854,10 +817,7 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str
> *选择器表达式* → __#selector__ **(** [*setter:表达式*](#expression) **)**
>
<a name="key-path_string_expressions"></a>
## Key-path 字符串表达式
## Key-path 字符串表达式 {#key-path_string_expressions}
key-path 字符串表达式可以访问一个引用 Objective-C 属性的字符串，通常在 key-value 编程和 key-value 观察 APIs 中使用。其格式如下：
> `#keyPath` ( `属性名` )
@ -907,15 +867,12 @@ print(keyPath == c.getSomeKeyPath())
> key-path 字符串表达式语法
>
> <a name="key-path-string-expression"></a>
> key-path-string-expression {#key-path-string-expression}
>
> *key-path 字符串表达式* → **#keyPath (** [表达式](#expression) **)**
>
<a name="postfix_expressions"></a>
## 后缀表达式
## 后缀表达式 {#postfix_expressions}
*后缀表达式*就是在某个表达式的后面运用后缀运算符或其他后缀语法。从语法构成上来看，基本表达式也是后缀表达式。
关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md)。
@ -924,7 +881,7 @@ print(keyPath == c.getSomeKeyPath())
> 后缀表达式语法
>
<a name="postfix-expression"></a>
postfix-expression {#postfix-expression}
> *后缀表达式* → [*基本表达式*](#primary-expression)
>
> *后缀表达式* → [*后缀表达式*](#postfix-expression) [*后缀运算符*](02_Lexical_Structure.md#postfix-operator)
@ -946,9 +903,7 @@ print(keyPath == c.getSomeKeyPath())
> *后缀表达式* → [*可选链表达式*](#optional-chaining-expression)
>
<a name="function_call_expression"></a>
### 函数调用表达式
### 函数调用表达式 {#function_call_expression}
*函数调用表达式*由函数名和参数列表组成，形式如下：
> `函数名`(`参数 1`, `参数 2`)
@ -979,36 +934,34 @@ myData.someMethod {$0 == 13}
> 函数调用表达式语法
>
> <a name="function-call-expression"></a>
> function-call-expression {#function-call-expression}
>
> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*函数调用参数子句*](#function-call-argument-clause)
>
> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*函数调用参数子句*](#function-call-argument-clause)<sub>可选</sub> [*尾随闭包*](#trailing-closure)
>
>
> <a name="function-call-argument-clause"></a>
> function-call-argument-clause {#function-call-argument-clause}
>
> *函数调用参数子句* → **(** **)** | **(** [*函数调用参数表*](#function-call-argument-list) **)**
>
> <a name="function-call-argument-list"></a>
> function-call-argument-list {#function-call-argument-list}
>
> *函数调用参数表* → [函数调用参数](#function-call-argument) | [函数调用参数](#function-call-argument) **,** [*函数调用参数表*](#function-call-argument-list)
>
> <a name="function-call-argument"></a>
> function-call-argument {#function-call-argument}
>
> *函数调用参数* → [表达式](#expression) | [标识符](02_Lexical_Structure.md#identifier) **:** [*表达式*](#expression)
>
> *函数调用参数* → [运算符](./02_Lexical_Structure.md#operator) | [标识符](./02_Lexical_Structure.md#identifier) **:** [*运算符*](./02_Lexical_Structure.md#operator)
>
>
> <a name="trailing-closure"></a>
> trailing-closure {#trailing-closure}
>
> *尾随闭包* → [*闭包表达式*](#closure-expression)
>
<a name="initializer_expression"></a>
### 构造器表达式
### 构造器表达式 {#initializer_expression}
*构造器表达式*用于访问某个类型的构造器，形式如下：
> `表达式`.init(`构造器参数`)
@ -1048,15 +1001,13 @@ let s3 = someValue.dynamicType.init(data: 7) // 有效
> 构造器表达式语法
>
<a name="initializer-expression"></a>
initializer-expression {#initializer-expression}
> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init**
>
> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init** **(** [*参数名称*](#argument-names) **)**
>
<a name="explicit_member_expression"></a>
### 显式成员表达式
### 显式成员表达式 {#explicit_member_expression}
*显式成员表达式*允许我们访问命名类型、元组或者模块的成员，其形式如下：
> `表达式`.`成员名`
@ -1116,23 +1067,21 @@ let x = [10, 3, 20, 15, 4]
> 显式成员表达式语法
>
<a name="explicit-member-expression"></a>
explicit-member-expression {#explicit-member-expression}
> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*] (02_Lexical_Structure.md#decimal-digit)
>
> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub><br/>
>
> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*] (02_Lexical_Structure.md#identifier) **(** [*参数名称*](#argument-names) **)**
>
<a name="argument-names"></a>
argument-names {#argument-names}
> *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)<sub>可选</sub><br/>
>
<a name="argument-name"></a>
argument-name {#argument-name}
> *参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) **:**
>
<a name="postfix_self_expression"></a>
### 后缀 self 表达式
### 后缀 self 表达式 {#postfix_self_expression}
后缀 `self` 表达式由某个表达式或类型名紧跟 `.self` 组成，其形式如下：
> `表达式`.self
@ -1146,14 +1095,12 @@ let x = [10, 3, 20, 15, 4]
> 后缀 self 表达式语法
>
<a name="postfix-self-expression"></a>
postfix-self-expression {#postfix-self-expression}
> *后缀 self 表达式* → [*后缀表达式*](#postfix-expression) **.** **self**
>
<a name="subscript_expression"></a>
### 下标表达式
### 下标表达式 {#subscript_expression}
可通过*下标表达式*访问相应的下标，形式如下：
> `表达式`[`索引表达式`]
@ -1165,13 +1112,11 @@ let x = [10, 3, 20, 15, 4]
> 下标表达式语法
>
<a name="subscript-expression"></a>
subscript-expression {#subscript-expression}
> *下标表达式* → [*后缀表达式*](#postfix-expression) **[** [*表达式列表*](#expression-list) **]**
>
<a name="forced-Value_expression"></a>
### 强制取值表达式
### 强制取值表达式 {#forced-Value_expression}
当你确定可选值不是 `nil` 时，可以使用*强制取值表达式*来强制解包，形式如下：
> `表达式`!
@ -1193,13 +1138,11 @@ someDictionary["a"]![0] = 100
> 强制取值语法
>
<a name="forced-value-expression"></a>
forced-value-expression {#forced-value-expression}
> *强制取值表达式* → [*后缀表达式*](#postfix-expression) **!**
>
<a name="optional-chaining_expression"></a>
### 可选链表达式
### 可选链表达式 {#optional-chaining_expression}
*可选链表达式*提供了一种使用可选值的便捷方法，形式如下：
> `表达式`?
@ -1247,6 +1190,6 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects()
> 可选链表达式语法
>
<a name="optional-chaining-expression"></a>
optional-chaining-expression {#optional-chaining-expression}
> *可选链表达式* → [*后缀表达式*](#postfix-expression) **?**
>