From a3f0cae50012d7ae099bd6884cb18bd60303b5d2 Mon Sep 17 00:00:00 2001 From: mylittleswift Date: Sat, 14 Apr 2018 20:03:49 -0700 Subject: [PATCH] update chapter 3 parts 04-10 for Swift 4.1 (#781) --- source/chapter3/04_Expressions.md | 257 +- source/chapter3/05_Statements.md | 196 +- source/chapter3/06_Declarations.md | 2702 +++++++++-------- source/chapter3/07_Attributes.md | 39 +- source/chapter3/08_Patterns.md | 90 +- .../09_Generic_Parameters_and_Arguments.md | 46 +- source/chapter3/10_Summary_of_the_Grammar.md | 1166 +++---- source/chapter3/chapter3.md | 3 + 8 files changed, 2269 insertions(+), 2230 deletions(-) diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md index 6d63f762..5b18a0e0 100644 --- a/source/chapter3/04_Expressions.md +++ b/source/chapter3/04_Expressions.md @@ -115,11 +115,11 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try ## 二元表达式 -二元表达式由中缀运算符和左右参数表达式组成。形式如下： +*二元表达式*由中缀运算符和左右参数表达式组成。形式如下： > `左侧参数` `二元运算符` `右侧参数` -关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/25_Advanced_Operators.md)。 +关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/26_Advanced_Operators.html)。 关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Swift Standard Library Operators Reference*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_StandardLibrary_Operators/index.html#//apple_ref/doc/uid/TP40016054)。 @@ -130,12 +130,12 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try > 二元表达式语法 > -> *二元表达式* → [*二元运算符*](02_Lexical_Structure.md#binary-operator) [*前缀表达式*](#prefix-expression) -> *二元表达式* → [*赋值运算符*](#assignment-operator) [*try 运算符*](#try-operator)可选 [*前缀表达式*](#prefix-expression) -> *二元表达式* → [*条件运算符*](#conditional-operator) [*try 运算符*](#try-operator)可选 [*前缀表达式*](#prefix-expression) -> *二元表达式* → [*类型转换运算符*](#type-casting-operator) +> *二元表达式* → [*二元运算符*](02_Lexical_Structure.md#binary-operator) [*前缀表达式*](#prefix-expression). +> *二元表达式* → [*赋值运算符*](#assignment-operator) [*try 运算符*](#try-operator)可选 [*前缀表达式*](#prefix-expression) +> *二元表达式* → [*条件运算符*](#conditional-operator) [*try 运算符*](#try-operator)可选 [*前缀表达式*](#prefix-expression) +> *二元表达式* → [*类型转换运算符*](#type-casting-operator) -> *二元表达式列表* → [*二元表达式*](#binary-expression) [*二元表达式列表*](#binary-expressions)可选 +> *二元表达式列表* → [*二元表达式*](#binary-expression) [*二元表达式列表*](#binary-expressions)可选 ### 赋值表达式 @@ -161,7 +161,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try ### 三元条件运算符 -三元条件运算符会根据条件来对两个给定表达式中的一个进行求值，形式如下： +*三元条件运算符*会根据条件来对两个给定表达式中的一个进行求值，形式如下： > `条件` ? `表达式（条件为真则使用）` : `表达式（条件为假则使用）` @@ -172,7 +172,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try > 三元条件运算符语法 > -> *三元条件运算符* → **?** [try 运算符](#try-operator)可选 [*表达式*](#expression) **:** +> *三元条件运算符* → **?** [*表达式*](#expression) **:** ### 类型转换运算符 @@ -206,7 +206,7 @@ f(x as Any) // 打印 “Function for Any” ``` -桥接可将 Swift 标准库中的类型（例如 `String`）作为一个与之相关的 Foundation 类型（例如 `NSString`）来使用，而不需要新建一个实例。关于桥接的更多信息，请参阅 [*Using Swift with Cocoa and Objective-C (Swift2.2)*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中的 [Working with Cocoa Data Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/WorkingWithCocoaDataTypes.html#//apple_ref/doc/uid/TP40014216-CH6)。 +桥接可将 Swift 标准库中的类型（例如 `String`）作为一个与之相关的 Foundation 类型（例如 `NSString`）来使用，而不需要新建一个实例。关于桥接的更多信息，请参阅 [*Using Swift with Cocoa and Objective-C (Swift4.1)*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中的 [Working with Cocoa Data Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/WorkingWithCocoaDataTypes.html#//apple_ref/doc/uid/TP40014216-CH6)。 `as?` 运算符有条件地执行类型转换，返回目标类型的可选值。在运行时，如果转换成功，返回的可选值将包含转换后的值，否则返回 `nil`。如果在编译时就能确定转换一定会成功或是失败，则会导致编译报错。 @@ -217,33 +217,34 @@ f(x as Any) > 类型转换运算符语法 > -> *类型转换运算符* → **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) ## 基本表达式 -基本表达式是最基本的表达式。它们可以单独使用，也可以跟前缀表达式、二元表达式、后缀表达式组合使用。 +*基本表达式*是最基本的表达式。它们可以单独使用，也可以跟前缀表达式、二元表达式、后缀表达式组合使用。 > 基本表达式语法 > -> *基本表达式* → [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选 -> *基本表达式* → [*字面量表达式*](#literal-expression) -> *基本表达式* → [*self 表达式*](#self-expression) -> *基本表达式* → [*超类表达式*](#superclass-expression) -> *基本表达式* → [*闭包表达式*](#closure-expression) -> *基本表达式* → [*圆括号表达式*](#parenthesized-expression) -> *基本表达式* → [*隐式成员表达式*](#implicit-member-expression) -> *基本表达式* → [*通配符表达式*](#wildcard-expression) -> *基本表达式* → [*选择器表达式*](#selector-expression) +> *基本表达式* → [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选 +> *基本表达式* → [*字面量表达式*](#literal-expression) +> *基本表达式* → [*self 表达式*](#self-expression) +> *基本表达式* → [*超类表达式*](#superclass-expression) +> *基本表达式* → [*闭包表达式*](#closure-expression) +> *基本表达式* → [*圆括号表达式*](#parenthesized-expression) +> *基本表达式* → [*隐式成员表达式*](#implicit-member-expression) +> *基本表达式* → [*通配符表达式*](#wildcard-expression) +> *基本表达式* → [*选择器表达式*](#selector-expression) +> *基本表达式* → [*key-path字符串表达式*](#key-patch-string-expression) ### 字面量表达式 -字面量表达式可由普通字面量（例如字符串或者数字），字典或者数组字面量，或者下面列表中的特殊字面量组成： +*字面量表达式*可由普通字面量（例如字符串或者数字），字典或者数组字面量，或者下面列表中的特殊字面量组成： 字面量 | 类型 | 值 :------------- | :---------- | :---------- @@ -252,11 +253,10 @@ f(x as Any) `#column` | `Int` | 所在的列数 `#function` | `String` | 所在的声明的名字 -`#line` 除了上述含义外，还有另一种含义。当它出现在单独一行时，会被理解成行控制语句，请参阅[线路控制语句](../chapter3/10_Statements.md#线路控制语句)。 对于 `＃function`，在函数中会返回当前函数的名字，在方法中会返回当前方法的名字，在属性的存取器中会返回属性的名字，在特殊的成员如 `init` 或 `subscript` 中会返回这个关键字的名字，在某个文件中会返回当前模块的名字。 -`#function` 作为函数或者方法的默认参数值时，该字面量的值取决于函数或方法的调用环境。 +当其作为函数或者方法的默认参数值时，该字面量的值取决于函数或方法的调用环境。 ```swift func logFunctionName(string: String = #function) { @@ -291,34 +291,35 @@ var emptyDictionary: [String : Double] = [:] > 字面量表达式语法 > -> *字面量表达式* → [*字面量*](02_Lexical_Structure.md#literal) -> *字面量表达式* → [*数组字面量*](#array-literal) | [*字典字面量*](#dictionary-literal) -> *字面量表达式* → **#file** | **#line** | **#column** | **#function** - +> *字面量表达式* → [*字面量*](02_Lexical_Structure.md#literal) +> *字面量表达式* → [*数组字面量*](#array-literal) | [*字典字面量*](#dictionary-literal) | [*练习场字面量*](#playground-literal) +> *字面量表达式* → **#file** | **#line** | **#column** | **#function** +> -> *数组字面量* → **[** [*数组字面量项列表*](#array-literal-items)可选 **]** +> *数组字面量* → [[*数组字面量项列表*](#array-literal-items)可选 **]** -> *数组字面量项列表* → [*数组字面量项*](#array-literal-item) **,**可选 | [*数组字面量项*](#array-literal-item) **,** [*数组字面量项列表*](#array-literal-items) +> *数组字面量项列表* → [*数组字面量项*](#array-literal-item) **,**可选 | [*数组字面量项*](#array-literal-item) **,** [*数组字面量项列表*](#array-literal-items) -> *数组字面量项* → [*表达式*](#expression) - +> *数组字面量项* → [*表达式*](#expression) +> -> *字典字面量* → **[** [*字典字面量项列表*](#dictionary-literal-items) **]** | **[** **:** **]** +> *字典字面量* → [[*字典字面量项列表*](#dictionary-literal-items) **]** | **[** **:** **]** -> *字典字面量项列表* → [*字典字面量项*](#dictionary-literal-item) **,**可选 | [*字典字面量项*](#dictionary-literal-item) **,** [*字典字面量项列表*](#dictionary-literal-items) +> *字典字面量项列表* → [*字典字面量项*](#dictionary-literal-item) **,**可选 | [*字典字面量项*](#dictionary-literal-item) **,** [*字典字面量项列表*](#dictionary-literal-items) -> *字典字面量项* → [*表达式*](#expression) **:** [*表达式*](#expression) +> *字典字面量项* → [*表达式*](#expression) **:** [*表达式*](#expression)。 + ### Self 表达式 `self` 表达式是对当前类型或者当前实例的显式引用，它有如下形式： -> self -> self.`成员名称` -> self[`下标索引`] -> self(`构造器参数`) -> self.init(`构造器参数`) +> self +> self.`成员名称` +> self[`下标索引`] +> self(`构造器参数`) +> self.init(`构造器参数`) 如果在构造器、下标、实例方法中，`self` 引用的是当前类型的实例。在一个类型方法中，`self` 引用的是当前的类型。 @@ -347,23 +348,23 @@ struct Point { > Self 表达式语法 > -> *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) > -> *self 方法表达式* → **self** **.** [*标识符*](02_Lexical_Structure.md#identifier) +> *self 方法表达式* → **self** **.** [*标识符*](02_Lexical_Structure.md#identifier) -> *self 下标表达式* → **self** **[** [*表达式*](#expression) **]** +> *self 下标表达式* → **self** [ [*函数调用参数表*](#function-call-argument-list­) **]** -> *self 构造器表达式* → **self** **.** **init** +> *self 构造器表达式* → **self** **.** **init** ### 父类表达式 *父类*表达式可以使我们在某个类中访问它的超类，它有如下形式： -> super.`成员名称` -> super[`下标索引`] -> super.init(`构造器参数`) +> super.`成员名称` +> super[`下标索引`] +> super.init(`构造器参数`) 第一种形式用来访问超类的某个成员，第二种形式用来访问超类的下标，第三种形式用来访问超类的构造器。 @@ -375,16 +376,16 @@ struct Point { > *超类表达式* → [*超类方法表达式*](#superclass-method-expression) | [*超类下标表达式*](#superclass-subscript-expression) | [*超类构造器表达式*](#superclass-initializer-expression) > -> *超类方法表达式* → **super** **.** [*标识符*](02_Lexical_Structure.md#identifier) +> *超类方法表达式* → **super** **.** [*标识符*](02_Lexical_Structure.md#identifier) -> *超类下标表达式* → **super** **[** [*表达式*](#expression) **]** +> *超类下标表达式* → **super** [[*函数调用参数表*](#function-call-argument-list­) **]** -> *超类构造器表达式* → **super** **.** **init** +> *超类构造器表达式* → **super** **.** **init** ### 闭包表达式 -闭包表达式会创建一个闭包，在其他语言中也叫 *lambda* 或*匿名*函数。跟函数一样，闭包包含了待执行的代码，不同的是闭包还会捕获所在环境中的常量和变量。它的形式如下： +*闭包表达式*会创建一个闭包，在其他语言中也叫 *lambda* 或*匿名*函数。跟函数一样，闭包包含了待执行的代码，不同的是闭包还会捕获所在环境中的常量和变量。它的形式如下： ```swift { (parameters) -> return type in @@ -392,7 +393,7 @@ struct Point { } ``` -闭包的参数声明形式跟函数一样，请参阅 [函数声明](05_Declarations.md#function_declaration)。 +闭包的参数声明形式跟函数一样，请参阅 [函数声明](05_Declarations.html#function_declaration)。 闭包还有几种特殊的形式，能让闭包使用起来更加简洁： @@ -420,11 +421,11 @@ myFunction { $0 + $1 } 关于如何将闭包作为参数来传递的内容，请参阅 [函数调用表达式](#function_call_expression)。 -关于逃逸闭包的内容，请参阅[逃逸闭包](./chapter2/07_Closures.md#escaping_closures) +关于逃逸闭包的内容，请参阅[逃逸闭包](./chapter2/07_Closures.html#escaping_closures) #### 捕获列表 -默认情况下，闭包会捕获附近作用域中的常量和变量，并使用强引用指向它们。你可以通过一个捕获列表来显式指定它的捕获行为。 +默认情况下，闭包会捕获附近作用域中的常量和变量，并使用强引用指向它们。你可以通过一个*捕获列表*来显式指定它的捕获行为。 捕获列表在参数列表之前，由中括号括起来，里面是由逗号分隔的一系列表达式。一旦使用了捕获列表，就必须使用 `in` 关键字，即使省略了参数名、参数类型和返回类型。 @@ -478,33 +479,33 @@ myFunction { [unowned self] in print(self.title) } // 以无主引用捕获 myFunction { [weak parent = self.parent] in print(parent!.title) } ``` -关于闭包表达式的更多信息和例子，请参阅 [闭包表达式](../chapter2/07_Closures.md#closure_expressions)。关于捕获列表的更多信息和例子，请参阅 [解决闭包引起的循环强引用](../chapter2/16_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_for_closures)。 +关于闭包表达式的更多信息和例子，请参阅 [闭包表达式](../chapter2/07_Closures.html#closure_expressions)。关于捕获列表的更多信息和例子，请参阅 [解决闭包引起的循环强引用](../chapter2/23_Automatic_Reference_Counting.html#resolving_strong_reference_cycles_for_closures)。 > 闭包表达式语法 > -> *闭包表达式* → **{** [*闭包签名*](#closure-signature)可选 [*语句*](10_Statements.md#statements) **}** +> *闭包表达式* → **{** [*闭包签名*](#closure-signature)可选 [*语句*](#statements) **}** -> *闭包签名* → [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](05_Declarations.md#function-result)可选 **in** -> *闭包签名* → [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](05_Declarations.md#function-result)可选 **in** -> *闭包签名* → [*捕获列表*](#capture-list) [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](05_Declarations.md#function-result)可选 **in** -> *闭包签名* → [*捕获列表*](#capture-list) [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](05_Declarations.md#function-result)可选 **in** -> *闭包签名* → [*捕获列表*](#capture-list) **in** +> *闭包签名* → [*参数子句*](#parameter-clause) [*函数结果*](05_Declarations.html#function-result)可选 **in** +> *闭包签名* → [*标识符列表*](#identifier-list) [*函数结果*](05_Declarations.md#function-result)可选 **in** +> *闭包签名* → [*捕获列表*](#capture-list) [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](05_Declarations.md#function-result)可选 **in** +> *闭包签名* → [*捕获列表*](#capture-list) [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](05_Declarations.md#function-result)可选 **in** +> *闭包签名* → [*捕获列表*](#capture-list) **in** -> *捕获列表* → **[** [*捕获列表项列表*](#capture-list-items) **]** +> *捕获列表* → [ [*捕获列表项列表*](#capture-list-items) **]** -> *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items) +> *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items) -> *捕获列表项* → [*捕获说明符*](#capture-specifier)可选 [*表达式*](#expression) +> *捕获列表项* → [*捕获说明符*](#capture-specifier)可选 [*表达式*](#expression) > *捕获说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** - + ### 隐式成员表达式 -若类型可被推断出来，可以使用隐式成员表达式来访问某个类型的成员（例如某个枚举成员或某个类型方法），形式如下： +若类型可被推断出来，可以使用*隐式成员表达式*来访问某个类型的成员（例如某个枚举成员或某个类型方法），形式如下： > .`成员名称` @@ -518,7 +519,7 @@ x = .AnotherValue > 隐式成员表达式语法 > -> *隐式成员表达式* → **.** [*标识符*](02_Lexical_Structure.md#identifier) +> *隐式成员表达式* → **.** [*标识符*](02_Lexical_Structure.md#identifier) ### 圆括号表达式 @@ -528,12 +529,12 @@ x = .AnotherValue > 圆括号表达式语法 > -> *圆括号表达式* → **( [*表达式*](#expression) )** +> *圆括号表达式* → **( [*表达式*](#expression) )** ### 元组表达式 -元组表达式由圆括号和其中多个逗号分隔的子表达式组成。每个子表达式前面可以有一个标识符，用冒号隔开。元组表达式形式如下： +*元组表达式*由圆括号和其中多个逗号分隔的子表达式组成。每个子表达式前面可以有一个标识符，用冒号隔开。元组表达式形式如下： > (`标识符 1` : `表达式 1`, `标识符 2` : `表达式 2`, `...`) @@ -542,16 +543,16 @@ x = .AnotherValue > 元组表达式语法 > -> *元组表达式* → **( )** | **(**[*元组元素*](#tuple-element)， [*元组元素列表*](#tuple-element-list) **)** +> *元组表达式* → **( )** | **(**[*元组元素*](#tuple-element)， [*元组元素列表*](#tuple-element-list) **)** -> *元组元素列表* → [*元组元素*](#tuple-element) | [*元组元素*](#tuple-element) **,** [*元组元素列表*](#tuple-element-list) +> *元组元素列表* → [*元组元素*](#tuple-element) | [*元组元素*](#tuple-element) **,** [*元组元素列表*](#tuple-element-list) -> *元组元素* → [*表达式*](#expression) | [*标识符*](identifier) **:** [*表达式*](#expression) +> *元组元素* → [*表达式*](#expression) | [*标识符*](identifier) **:** [*表达式*](#expression) ### 通配符表达式 -通配符表达式可以在赋值过程中显式忽略某个值。例如下面的代码中，`10` 被赋值给 `x`，而 `20` 则被忽略： +*通配符表达式*可以在赋值过程中显式忽略某个值。例如下面的代码中，`10` 被赋值给 `x`，而 `20` 则被忽略： ```swift (x, _) = (10, 20) @@ -566,7 +567,7 @@ x = .AnotherValue ### 选择器表达式 -选择器表达式可以让你通过选择器来引用在 Objective-C 中方法(method)和属性(property)的 setter 和 getter 方法。 +*选择器表达式*可以让你通过选择器来引用在 Objective-C 中方法(method)和属性(property)的 setter 和 getter 方法。 > \#selector(方法名) \#selector(getter: 属性名) @@ -606,7 +607,7 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str > > 虽然方法名或者属性名是个表达式，但是它不会被求值。 -更多关于如何在 Swift 代码中使用选择器来与 Objective-C API 进行交互的信息，请参阅 [Using Swift with Cocoa and Objective-C (Swift 3)](https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中[Objective-C Selectors](https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-ID59)部分。 +更多关于如何在 Swift 代码中使用选择器来与 Objective-C API 进行交互的信息，请参阅 [Using Swift with Cocoa and Objective-C (Swift 4.1)](https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中[Objective-C Selectors](https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-ID59)部分。 > 选择器表达式语法 @@ -617,29 +618,29 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str ## 后缀表达式 -后缀表达式就是在某个表达式的后面运用后缀运算符或其他后缀语法。从语法构成上来看，基本表达式也是后缀表达式。 +*后缀表达式*就是在某个表达式的后面运用后缀运算符或其他后缀语法。从语法构成上来看，基本表达式也是后缀表达式。 -关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/25_Advanced_Operators.md)。 +关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/26_Advanced_Operators.html)。 关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Swift Standard Library Operators Reference*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_StandardLibrary_Operators/index.html#//apple_ref/doc/uid/TP40016054)。 > 后缀表达式语法 -> *后缀表达式* → [*基本表达式*](#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) ### 函数调用表达式 -函数调用表达式由函数名和参数列表组成，形式如下： +*函数调用表达式*由函数名和参数列表组成，形式如下： > `函数名`(`参数 1`, `参数 2`) @@ -667,15 +668,15 @@ myData.someMethod {$0 == 13} > 函数调用表达式语法 -> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression) -> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression)可选 [*尾随闭包*](#trailing-closure) +> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression) +> *函数调用表达式* → [*后缀表达式*](#postfix-expression) [*圆括号表达式*](#parenthesized-expression)可选 [*尾随闭包*](#trailing-closure) -> *尾随闭包* → [*闭包表达式*](#closure-expression) +> *尾随闭包* → [*闭包表达式*](#closure-expression) ### 构造器表达式 -构造器表达式用于访问某个类型的构造器，形式如下： +*构造器表达式*用于访问某个类型的构造器，形式如下： > `表达式`.init(`构造器参数`) @@ -712,13 +713,13 @@ let s3 = someValue.dynamicType.init(data: 7) // 有效 > 构造器表达式语法 -> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init** -> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init** **(** [*参数名称*](#argument-names) **)** +> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init** +> *构造器表达式* → [*后缀表达式*](#postfix-expression) **.** **init** **(** [*参数名称*](#argument-names) **)** ### 显式成员表达式 -显式成员表达式允许我们访问命名类型、元组或者模块的成员，其形式如下： +*显式成员表达式*允许我们访问命名类型、元组或者模块的成员，其形式如下： > `表达式`.`成员名` @@ -772,14 +773,14 @@ let x = [10, 3, 20, 15, 4] > 显式成员表达式语法 -> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*](02_Lexical_Structure.md#decimal-digit) -> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选
-> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) **(** [*参数名称*](#argument-names) **)** -> +> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*] (02_Lexical_Structure.html#decimal-digit) +> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.html#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.html#generic-argument-clause)可选
+> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*] (02_Lexical_Structure.html#identifier) **(** [*参数名称*](#argument-names) **)** +> > *参数名称* → [*参数名*](#argument-name) [*参数名称*](#argument-names)可选
-> *参数名* → [*标识符*](02_Lexical_Structure.md#identifier) **:** +> *参数名* → [*标识符*](02_Lexical_Structure.html#identifier) **:** ### 后缀 self 表达式 @@ -793,60 +794,32 @@ let x = [10, 3, 20, 15, 4] 第二种形式返回相应的类型。我们可以用它来获取某个实例的类型作为一个值来使用。例如，`SomeClass.self` 会返回 `SomeClass` 类型本身，你可以将其传递给相应函数或者方法作为参数。 -> 后缀 self 表达式语法 +> 后缀 self 表达式语法 +> > *后缀 self 表达式* → [*后缀表达式*](#postfix-expression) **.** **self** - -### dynamicType 表达式 - -dynamicType 表达式由类似[函数调用表达式(Function Call Expression)](#function-call-expression)的特殊语法表达式组成，形式如下: - -> type(of:`表达式`) - -上述形式中的表达式不能是类型名。type(of:) 表达式会返回某个实例在运行时的类型，具体请看下面的例子： - -```swift -class SomeBaseClass { - class func printClassName() { - print("SomeBaseClass") - } -} -class SomeSubClass: SomeBaseClass { - override class func printClassName() { - print("SomeSubClass") - } -} -let someInstance: SomeBaseClass = SomeSubClass() -// someInstance 在编译时的静态类型为 SomeBaseClass， -// 在运行时的动态类型为 SomeSubClass -type(of: someInstance).printClassName() -// 打印 “SomeSubClass” -``` - -> 动态类型表达式语法 - -> *动态类型表达式* → type(of:表达式) **.** **dynamicType** ### 下标表达式 -可通过下标表达式访问相应的下标，形式如下： +可通过*下标表达式*访问相应的下标，形式如下： > `表达式`[`索引表达式`] 要获取下标表达式的值，可将索引表达式作为下标表达式的参数来调用下标 getter。下标 setter 的调用方式与之一样。 -关于下标的声明，请参阅 [协议下标声明](05_Declarations.md#protocol_subscript_declaration)。 +关于下标的声明，请参阅 [协议下标声明](05_Declarations.html#protocol_subscript_declaration)。 -> 下标表达式语法 +> 下标表达式语法 +> > *下标表达式* → [*后缀表达式*](#postfix-expression) **[** [*表达式列表*](#expression-list) **]** ### 强制取值表达式 -当你确定可选值不是 `nil` 时，可以使用强制取值表达式来强制解包，形式如下： +当你确定可选值不是 `nil` 时，可以使用*强制取值表达式*来强制解包，形式如下： > `表达式`! @@ -864,14 +837,15 @@ someDictionary["a"]![0] = 100 // someDictionary 现在是 [b: [10, 20], a: [100, 2, 3]] ``` -> 强制取值语法 +> 强制取值语法 +> > *强制取值表达式* → [*后缀表达式*](#postfix-expression) **!** ### 可选链表达式 -可选链表达式提供了一种使用可选值的便捷方法，形式如下： +*可选链表达式*提供了一种使用可选值的便捷方法，形式如下： > `表达式`? @@ -914,6 +888,7 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects() // someDictionary 现在是 ["b": [10, 20], "a": [42, 2, 3]] ``` -> 可选链表达式语法 +> 可选链表达式语法 +> > *可选链表达式* → [*后缀表达式*](#postfix-expression) **?** diff --git a/source/chapter3/05_Statements.md b/source/chapter3/05_Statements.md index f7753d7a..8b498341 100755 --- a/source/chapter3/05_Statements.md +++ b/source/chapter3/05_Statements.md @@ -50,17 +50,17 @@ > 语句语法 -> *语句* → [*表达式*](04_Expressions.md#expression) **;**可选 -> *语句* → [*声明*](05_Declarations.md#declaration) **;**可选 -> *语句* → [*循环语句*](#loop-statement) **;**可选 -> *语句* → [*分支语句*](#branch-statement) **;**可选 -> *语句* → [*带标签的语句*](#labeled-statement) **;**可选 -> *语句* → [*控制转移语句*](#control-transfer-statement) **;**可选 -> *语句* → [*defer 语句*](#defer-statement) **;**可选 -> *语句* → [*do 语句*](#do-statement) **:**可选 -> *语句* → [*编译器控制语句*](#compiler-control-statement) +> *语句* → [*表达式*](04_Expressions.md#expression) **;**可选 +> *语句* → [*声明*](05_Declarations.md#declaration) **;**可选 +> *语句* → [*循环语句*](#loop-statement) **;**可选 +> *语句* → [*分支语句*](#branch-statement) **;**可选 +> *语句* → [*带标签的语句*](#labeled-statement) **;**可选 +> *语句* → [*控制转移语句*](#control-transfer-statement) **;**可选 +> *语句* → [*defer 语句*](#defer-statement) **;**可选 +> *语句* → [*do 语句*](#do-statement) **:**可选 +> *语句* → [*编译器控制语句*](#compiler-control-statement) -> *多条语句* → [*语句*](#statement) [*多条语句*](#statements)可选 +> *多条语句* → [*语句*](#statement) [*多条语句*](#statements)可选 ## 循环语句 @@ -69,11 +69,12 @@ 通过 `break` 语句和 `continue` 语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement) 和 [Continue 语句](#continue_statement)。 -> 循环语句语法 +> 循环语句语法 +> -> *循环语句* → [*for-in 语句*](#for-in-statement) -> *循环语句* → [*while 语句*](#while-statement) -> *循环语句* → [*repeat-while 语句*](#repeat-while-statement) +> *循环语句* → [*for-in 语句*](#for-in-statement) +> *循环语句* → [*while 语句*](#while-statement) +> *循环语句* → [*repeat-while 语句*](#repeat-while-statement) ### For-In 语句 @@ -123,13 +124,14 @@ while condition { > *while 语句* → **while** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block) -> *条件子句* → [*表达式*](04_Expressions.md#expression) | [*表达式*](04_Expressions.md#expression) **,** [*条件列表*](#condition-list) +> *条件子句* → [*表达式*](04_Expressions.md#expression) | [*表达式*](04_Expressions.md#expression) **,** [*条件列表*](#condition-list) -> *条件* → [*表达式*](04_Expressions.md#expression) |[*可用性条件*](#availability-condition) | [*case 条件*](#case-condition) | [*可选绑定条件*](#optional-binding-condition) +> *条件* → [*表达式*](04_Expressions.md#expression) |[*可用性条件*](#availability-condition) | [*case 条件*](#case-condition) | [*可选绑定条件*](#optional-binding-condition) +> -> *case 条件* → **case** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) +> *case 条件* → **case** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) -> *可选绑定条件* → **let** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) | **var** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) +> *可选绑定条件* → **let** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) | **var** [*模式*](07_Patterns.md#pattern) [*构造器*](05_Declarations.md#initializer) ### Repeat-While 语句 @@ -156,7 +158,7 @@ repeat { > repeat-while 语句语法 > -> *repeat-while 语句* → **repeat** [*代码块*](05_Declarations.md#code-block) **while** [*表达式*](04_Expressions.md#expression) +> *repeat-while 语句* → **repeat** [*代码块*](05_Declarations.md#code-block) **while** [*表达式*](04_Expressions.md#expression) ## 分支语句 @@ -168,9 +170,9 @@ repeat { > 分支语句语法 > -> *分支语句* → [*if 语句*](#if-statement) -> *分支语句* → [*guard 语句*](#guard-statement) -> *分支语句* → [*switch 语句*](#switch-statement) +> *分支语句* → [*if 语句*](#if-statement) +> *分支语句* → [*guard 语句*](#guard-statement) +> *分支语句* → [*switch 语句*](#switch-statement) ### If 语句 @@ -214,9 +216,9 @@ if condition 1 { > if 语句语法 > -> *if 语句* → **if** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block) [*else 子句*](#else-clause)可选 +> *if 语句* → **if** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block) [*else 子句*](#else-clause)可选 -> *else 子句* → **else** [*代码块*](05_Declarations.md#code-block) | **else** [*if 语句*](#if-statement) +> *else 子句* → **else** [*代码块*](05_Declarations.md#code-block) | **else** [*if 语句*](#if-statement) ### Guard 语句 @@ -247,8 +249,8 @@ guard condition else { > guard 语句语法 > -> *guard 语句* → **guard** [*条件子句*](#condition-clause) **else** [*代码块*](05_Declarations.html#code-block) - +> *guard 语句* → **guard** [*条件子句*](#condition-clause) **else** [*代码块*] (05_Declarations.html#code-block) + ### Switch 语句 @@ -272,7 +274,7 @@ default: `switch` 语句会先计算*控制表达式*的值，然后与每一个 `case` 的模式进行匹配。如果匹配成功，程序将会执行对应的 `case` 中的语句。另外，每一个 `case` 都不能为空，也就是说在每一个 `case` 中必须至少有一条语句。如果你不想在匹配到的 `case` 中执行代码，只需在该 `case` 中写一条 `break` 语句即可。 -可以用作控制表达式的值是十分灵活的。除了标量类型外，如 `Int`、`Character`，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类型的实例和可选类型。控制表达式的值还可以用来匹配枚举类型中的成员值或是检查该值是否包含在指定的 `Range` 中。关于如何在 `switch` 语句中使用这些类型，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章中的 [Switch](../chapter2/05_Control_Flow.html#switch)。 +可以用作控制表达式的值是十分灵活的。除了标量类型外，如 `Int`、`Character`，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类型的实例和可选类型。控制表达式的值还可以用来匹配枚举类型中的成员值或是检查该值是否包含在指定的 `Range` 中。关于如何在 `switch` 语句中使用这些类型，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章中的 [Switch](../chapter2/05_Control_Flow.html#switch)。 每个 `case` 的模式后面可以有一个 `where` 子句。`where` 子句由 `where` 关键字紧跟一个提供额外条件的表达式组成。因此，当且仅当控制表达式匹配一个 `case` 的模式且 `where` 子句的表达式为真时，`case` 中的语句才会被执行。在下面的例子中，控制表达式只会匹配包含两个相等元素的元组，例如 `(1, 1)`： @@ -297,21 +299,21 @@ case let (x, y) where x == y: > switch 语句语法 > -> *switch 语句* → **switch** [*表达式*](04_Expressions.md#expression) **{** [*switch-case 列表*](#switch-cases)可选 **}** +> *switch 语句* → **switch** [*表达式*](04_Expressions.html#expression) **{** [*switch-case 列表*](#switch-cases)可选 **}** -> *switch case 列表* → [*switch-case*](#switch-case) [*switch-case 列表*](#switch-cases)可选 +> *switch case 列表* → [*switch-case*](#switch-case) [*switch-case 列表*](#switch-cases)可选 -> *switch case* → [*case 标签*](#case-label) [*多条语句*](#statements) | [*default 标签*](#default-label) [*多条语句*](#statements) +> *switch case* → [*case 标签*](#case-label) [*多条语句*](#statements) | [*default 标签*](#default-label) [*多条语句*](#statements) -> *case 标签* → **case** [*case 项列表*](#case-item-list) **:** +> *case 标签* → **case** [*case 项列表*](#case-item-list) **:** -> *case 项列表* → [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 | [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 **,** [*case 项列表*](#case-item-list) +> *case 项列表* → [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 | [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 **,** [*case 项列表*](#case-item-list) -> *default 标签* → **default** **:** - +> *default 标签* → **default** **:** +> -> *where-clause* → **where** [*where 表达式*](#where-expression) +> *where-clause* → **where** [*where 表达式*](#where-expression) > *where-expression* → [*表达式*](04_Expressions.md#expression) @@ -322,16 +324,19 @@ case let (x, y) where x == y: 标签的作用域在该标签所标记的语句内。可以嵌套使用带标签的语句，但标签名必须唯一。 -关于使用带标签的语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章中的 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 +关于使用带标签的语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章中的 [带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 > 带标签的语句语法 > -> *带标签的语句* → [*语句标签*](#statement-label) [*循环语句*](#loop-statement) | [*语句标签*](#statement-label) [*if 语句*](#if-statement) | [*语句标签*](#statement-label) [*switch 语句*](#switch-statement) +> *带标签的语句* → [*语句标签*](#statement-label) [*循环语句*](#loop-statement) +> *带标签的语句* → [*语句标签*](#statement-label) [*if 语句*](#if-statement) +> *带标签的语句* → [*语句标签*](#statement-label) [*switch 语句*](#switch-statement) +> > *带标签的语句* → [*语句标签*](#statement-label) [*do 语句*](#sdo-statement) -> *语句标签* → [*标签名称*](#label-name) **:** +> *语句标签* → [*标签名称*](#label-name) **:** -> *标签名称* → [*标识符*](02_Lexical_Structure.md#identifier) +> *标签名称* → [*标识符*](02_Lexical_Structure.md#identifier) ## 控制转移语句 @@ -341,11 +346,11 @@ case let (x, y) where x == y: > 控制转移语句语法 > -> *控制转移语句* → [*break 语句*](#break-statement) -> *控制转移语句* → [*continue 语句*](#continue-statement) -> *控制转移语句* → [*fallthrough 语句*](#fallthrough-statement) -> *控制转移语句* → [*return 语句*](#return-statement) -> *控制转移语句* → [*throw 语句*](#throw-statement) +> *控制转移语句* → [*break 语句*](#break-statement) +> *控制转移语句* → [*continue 语句*](#continue-statement) +> *控制转移语句* → [*fallthrough 语句*](#fallthrough-statement) +> *控制转移语句* → [*return 语句*](#return-statement) +> *控制转移语句* → [*throw 语句*](#throw-statement) ### Break 语句 @@ -361,12 +366,12 @@ case let (x, y) where x == y: 无论哪种情况，控制权都会被转移给被终止的控制流语句后面的第一行语句。 -关于使用 `break` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [Break](../chapter2/05_Control_Flow.md#break) 和 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 +关于使用 `break` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章的 [Break](../chapter2/05_Control_Flow.html#break) 和 [带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 > break 语句语法 > -> *break 语句* → **break** [*标签名称*](#label-name)可选 +> *break 语句* → **break** [*标签名称*](#label-name)可选 ### Continue 语句 @@ -384,7 +389,7 @@ case let (x, y) where x == y: 在 `for` 语句中，`continue` 语句执行后，增量表达式还是会被计算，这是因为每次循环体执行完毕后，增量表达式都会被计算。 -关于使用 `continue` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [Continue](../chapter2/05_Control_Flow.md#continue) 和 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 +关于使用 `continue` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章的 [Continue](../chapter2/05_Control_Flow.html#continue) 和 [带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。 > continue 语句语法 > @@ -398,7 +403,7 @@ case let (x, y) where x == y: `fallthrough` 语句可出现在 `switch` 语句中的任意 `case` 中，但不能出现在最后一个 `case` 中。同时，`fallthrough` 语句也不能把控制权转移到使用了值绑定的 `case`。 -关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [控制转移语句](../chapter2/05_Control_Flow.md#control_transfer_statements)。 +关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.html) 一章的 [控制转移语句](../chapter2/05_Control_Flow.html#control_transfer_statements)。 > fallthrough 语句语法 > @@ -419,7 +424,7 @@ case let (x, y) where x == y: > 注意 > -> 正如 [可失败构造器](05_Declarations.md#failable_initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。 +> 正如 [可失败构造器](05_Declarations.html#failable_initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。 而只写 `return` 时，仅仅是从该函数或方法中返回，而不返回任何值（也就是说，函数或方法的返回类型为 `Void` 或者说 `()`）。 @@ -441,12 +446,12 @@ case let (x, y) where x == y: 表达式的结果必须符合 `ErrorType` 协议。 -关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../chapter2/18_Error_Handling.md#propagating_errors_using_throwing_functions)。 +关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.html) 一章的 [用 throwing 函数传递错误](../chapter2/18_Error_Handling.html#propagating_errors_using_throwing_functions)。 > throw 语句语法 > -> *throw 语句* → **throw** [*表达式*](04_Expressions.md#expression) +> *throw 语句* → **throw** [*表达式*](04_Expressions.html#expression) ## Defer 语句 @@ -482,7 +487,7 @@ f() > defer 语句语法 > -> *延迟语句* → **defer** [*代码块*](05_Declarations.md#code-block) +> *延迟语句* → **defer** [*代码块*](05_Declarations.html#code-block) ## Do 语句 @@ -506,18 +511,18 @@ do { 如同 `switch` 语句，编译器会判断 `catch` 子句是否有遗漏。如果 `catch` 子句没有遗漏，则认为错误已被处理。否则，错误会自动传递到外围作用域，被某个 `catch` 子句处理掉或者被用 `throws` 关键字声明的抛出函数继续向外抛出。 -为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](07_Patterns.md)。 +为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](07_Patterns.html)。 -关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.md#handling_errors)。 +关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.html#handling_errors)。 > do 语句语法 > -> *do 语句* → **do** [*代码块*](05_Declarations.md#code-block) [*多条 catch 子句*](#catch-clauses)可选 +> *do 语句* → **do** [*代码块*](05_Declarations.html#code-block) [*多条 catch 子句*](#catch-clauses)可选 -> *多条 catch 子句* → [*catch 子句*](#catch-clause) [*多条 catch 子句*](#catch-clauses)可选 +> *多条 catch 子句* → [*catch 子句*](#catch-clause) [*多条 catch 子句*](#catch-clauses)可选 -> *catch 子句* → **catch** [*模式*](07_Patterns.md#pattern)可选 [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.md#code-block) +> *catch 子句* → **catch** [*模式*](07_Patterns.html#pattern)可选 [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.html#code-block) ## 编译器控制语句 @@ -527,15 +532,15 @@ do { > 编译器控制语句语法 > -> *编译器控制语句* → [*编译配置语句*](#build-config-statement) +> *编译器控制语句* → [*编译配置语句*](#build-config-statement) > *编译器控制语句* → [*线路控制语句*](#line-control-statement) - -### 编译配置语句 + +### 条件性编译块 -编译配置语句可以根据一个或多个配置来有条件地编译代码。 +条件性编译块可以根据一个或多个配置来有条件地编译代码。 -每一个编译配置语句都以 `#if` 开始，`#endif` 结束。如下是一个简单的编译配置语句： +每一个条件性编译块都以 `#if` 开始，`#endif` 结束。如下是一个简单的条件性编译块： ```swift #if compilation condition @@ -581,35 +586,35 @@ statements to compile if both compilation conditions are false > 编译配置语句语法 > -> *单个编译配置语句* → **#if** [*编译配置*](#build-configuration) [*语句*](#statements)可选 [*多个编译配置 elseif 子句*](#build-configuration-elseif-clauses)可选 **-** [*单个编译配置 else 子句*](#build-configuration-else-clause)可选 **#endif** +> *单个编译配置语句* → **if** [*编译配置*](#build-configuration) [*语句*](#statements)可选 [*多个编译配置 elseif 子句*](#build-configuration-elseif-clauses)可选 **-** [*单个编译配置 else 子句*](#build-configuration-else-clause)可选 **#endif** -> *多个编译配置 elseif 子句* → [*单个编译配置 elseif 子句*](#build-configuration-elseif-clause) [*多个编译配置 elseif 子句*](build-configuration-elseif-clauses)可选 +> *多个编译配置 elseif 子句* → [*单个编译配置 elseif 子句*](#build-configuration-elseif-clause) [*多个编译配置 elseif 子句*](build-configuration-elseif-clauses)可选 -> *单个编译配置 elseif 子句* → **#elseif** [*编译配置*](#build-configuration) [*语句*](#statements)可选 +> *单个编译配置 elseif 子句* → **#elseif** [*编译配置*](#build-configuration) [*语句*](#statements)可选 -> *单个编译配置 else 子句* → **#else** [*语句*](#statements)可选 +> *单个编译配置 else 子句* → **#else** [*语句*](#statements)可选 -> *编译配置* → [*平台检测函数*](#platform-testing-function) -> *编译配置* → [*语言版本检测函数*](#language-version-testing-function) -> *编译配置* → [*标识符*](02_Lexical_Structure.md#identifier) -> *编译配置* → [*布尔值字面量*](02_Lexical_Structure.md#boolean-literal) -> *编译配置* → **(** [*编译配置*](#build-configuration) **)** -> *编译配置* → **!** [*编译配置*](#build-configuration) -> *编译配置* → [*编译配置*](#build-configuration) **&&** [*编译配置*](#build-configuration) -> *编译配置* → [*编译配置*](#build-configuration) **||** [*编译配置*](#build-configuration) +> *编译配置* → [*平台检测函数*](#platform-testing-function) +> *编译配置* → [*语言版本检测函数*](#language-version-testing-function) +> *编译配置* → [*标识符*](02_Lexical_Structure.md#identifier) +> *编译配置* → [*布尔值字面量*](02_Lexical_Structure.md#boolean-literal) +> *编译配置* → **(** [*编译配置*](#build-configuration) **)** +> *编译配置* → **!** [*编译配置*](#build-configuration) +> *编译配置* → [*编译配置*](#build-configuration) **&&** [*编译配置*](#build-configuration) +> *编译配置* → [*编译配置*](#build-configuration) **||** [*编译配置*](#build-configuration) -> *平台检测函数* → **os** **(** [*操作系统*](#operating-system) **)** -> *平台检测函数* → **arch** **(** [*架构*](#architecture) **)** +> *平台检测函数* → **os** **(** [*操作系统*](#operating-system) **)** +> *平台检测函数* → **arch** **(** [*架构*](#architecture) **)** -> *语言版本检测函数* → **swift** **(** **>=** [*swift 版本*](#swift-version) **)** +> *语言版本检测函数* → **swift** **(** **>=** [*swift 版本*](#swift-version) **)** -> *操作系统* → **OSX** | **iOS** | **watchOS** | **tvOS** +> *操作系统* → **OSX** | **iOS** | **watchOS** | **tvOS** -> *架构* → **i386** | **x86_64** | **arm** | **arm64** +> *架构* → **i386** | **x86_64** | **arm** | **arm64** -> *swift 版本* → [*十进制数字*](02_Lexical_Structure.md#decimal-digit) ­**.** ­[*十进制数字*](02_Lexical_Structure.md#decimal-digit) +> *swift 版本* → [*十进制数字*](02_Lexical_Structure.md#decimal-digit) ­**.** ­[*十进制数字*](02_Lexical_Structure.md#decimal-digit) ### 行控制语句 @@ -629,12 +634,12 @@ statements to compile if both compilation conditions are false > 行控制语句语法 > -> *行控制语句* → **#sourceLocation(file:[*文件名*](#file-name),line:[*行号*](#line-number))** -> *行控制语句* → **#sourceLocation()** +> *行控制语句* → **#sourceLocation(file:[*文件名*](#file-name),line:[*行号*](#line-number))** +> *行控制语句* → **#sourceLocation()** -> *行号* → 大于 0 的十进制整数 +> *行号* → 大于 0 的十进制整数 -> *文件名* → [*静态字符串字面量*](02_Lexical_Structure.md#static-string-literal) +> *文件名* → [*静态字符串字面量*](02_Lexical_Structure.md#static-string-literal) ### 可用性条件 @@ -660,18 +665,19 @@ if #available(platform name version, ..., *) { > 可用性条件语法 > -> *可用性条件* → **#available** **(** [*可用性参数列表*](#availability-arguments) **)** +> *可用性条件* → **#available** **(** [*可用性参数列表*](#availability-arguments) **)** -> *可用性参数列表* → [*可用性参数*](#availability-argument) | [*可用性参数*](#availability-argument) **,** [*可用性参数列表*](#availability-arguments) +> *可用性参数列表* → [*可用性参数*](#availability-argument) | [*可用性参数*](#availability-argument) **,** [*可用性参数列表*](#availability-arguments) -> *可用性参数* → [平台名称](#platform-name) [平台版本](#platform-version) -> *可用性条件* → __*__ - +> *可用性参数* → [平台名称](#platform-name) [平台版本](#platform-version) +> *可用性条件* → __*__ +> -> *平台名称* → **iOS** | **iOSApplicationExtension** -> *平台名称* → **OSX** | **OSXApplicationExtension** -> *平台名称* → **watchOS** +> *平台名称* → **iOS** | **iOSApplicationExtension** +> *平台名称* → **OSX** | **macOSApplicationExtension** +> *平台名称* → **watchOS** +> *平台名称* → **tvOS** -> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) -> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) -> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) +> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) +> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) +> *平台版本* → [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](02_Lexical_Structure.md#decimal-digits) diff --git a/source/chapter3/06_Declarations.md b/source/chapter3/06_Declarations.md index f621654c..6856184c 100755 --- a/source/chapter3/06_Declarations.md +++ b/source/chapter3/06_Declarations.md @@ -1,1341 +1,1361 @@ - -# 声明（Declarations） ------------------ - -> 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) - -> 2.0 -> 翻译+校对：[Lenhoon](https://github.com/Lenhoon), -> [BridgeQ](https://github.com/WXGBridgeQ) - -> 2.1 -> 翻译：[mmoaay](https://github.com/mmoaay), [shanks](http://codebuild.me) -> 校对：[shanks](http://codebuild.me) - -> 2.2 -> 翻译：[星夜暮晨](https://github.com/SemperIdem) - -> 3.0 -> 翻译：[chenmingjia](https://github.com/chenmingjia) - -本页包含内容： - -- [顶级代码](#top-level_code) -- [代码块](#code_blocks) -- [导入声明](#import_declaration) -- [常量声明](#constant_declaration) -- [变量声明](#variable_declaration) - - [存储型变量和存储型变量属性](#stored_variables_and_stored_variable_properties) - - [计算型变量和计算型属性](#computed_variables_and_computed_properties) - - [存储型变量和属性的观察器](#stored_variable_observers_and_property_observers) - - [类型变量属性](#type_variable_properties) -- [类型别名声明](#type_alias_declaration) -- [函数声明](#function_declaration) - - [参数名](#parameter_names) - - [输入输出参数](#in-out_parameters) - - [特殊参数](#special_kinds_of_parameters) - - [特殊方法](#special_kinds_of_methods) - - [抛出错误的函数和方法](#throwing_functions_and_methods) - - [重抛错误的函数和方法](#rethrowing_functions_and_methods) -- [枚举声明](#enumeration_declaration) - - [任意类型的枚举用例](#enumerations_with_cases_of_any_type) - - [递归枚举](#enumerations_with_indirection) - - [拥有原始值的枚举用例](#enumerations_with_cases_of_a_raw-value_type) - - [访问枚举用例](#accessing_enumeration_cases) -- [结构体声明](#structure_declaration) -- [类声明](#class_declaration) -- [协议声明](#protocol_declaration) - - [协议属性声明](#protocol_property_declaration) - - [协议方法声明](#protocol_method_declaration) - - [协议构造器声明](#protocol_initializer_declaration) - - [协议下标声明](#protocol_subscript_declaration) - - [协议关联类型声明](#protocol_associated_type_declaration) -- [构造器声明](#initializer_declaration) - - [可失败构造器](#failable_initializers) -- [析构器声明](#deinitializer_declaration) -- [扩展声明](#extension_declaration) -- [下标声明](#subscript_declaration) -- [运算符声明](#operator_declaration) -- [声明修饰符](#declaration_modifiers) - - [访问控制级别](#access_control_levels) - -*声明 (declaration)* 用以向程序里引入新的名字或者结构。举例来说，可以使用声明来引入函数和方法，变量和常量，或者定义新的具有命名的枚举、结构、类和协议类型。还可以使用声明来扩展一个既有的具有命名的类型的行为，或者在程序里引入在其它地方声明的符号。 - -在 Swift 中，大多数声明在某种意义上讲也是定义，因为声明往往伴随着实现或初始化。由于协议并不提供实现，大多数协议成员仅仅只是声明而已。为了方便起见，也是因为这些区别在 Swift 中并不是很重要，“声明”这个术语同时包含了声明和定义两种含义。 - -> 声明语法 -> -> *声明* → [*导入声明*](#import-declaration) -> *声明* → [*常量声明*](#constant-declaration) -> *声明* → [*变量声明*](#variable-declaration) -> *声明* → [*类型别名声明*](#typealias-declaration) -> *声明* → [*函数声明*](#function-declaration) -> *声明* → [*枚举声明*](#enum-declaration) -> *声明* → [*结构体声明*](#struct-declaration) -> *声明* → [*类声明*](#class-declaration) -> *声明* → [*协议声明*](#protocol-declaration) -> *声明* → [*构造器声明*](#initializer-declaration) -> *声明* → [*析构器声明*](#deinitializer-declaration) -> *声明* → [*扩展声明*](#extension-declaration) -> *声明* → [*下标声明*](#subscript-declaration) -> *声明* → [*运算符声明*](#operator-declaration) -> -> *多条声明* → [*声明*](#declaration) [*多条声明*](#declarations)可选 - - -## 顶级代码 - -Swift 的源文件中的顶级代码 (top-level code) 由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access_control_levels)。 - -> 顶级声明语法 -> *顶级声明* → [*多条语句*](10_Statements.md#statements)可选 - - -## 代码块 - -*代码块 (code block)* 可以将一些声明和控制结构组织在一起。它有如下的形式： - -```swift -{ - 语句 -} -``` - -代码块中的“语句”包括声明、表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。 - -> 代码块语法 -> -> *代码块* → **{** [*多条语句*](10_Statements.md#statements)可选 **}** - - -## 导入声明 - -*导入声明 (import declaration)* 让你可以使用在其他文件中声明的内容。导入语句的基本形式是导入整个模块，它由 `import` 关键字和紧随其后的模块名组成： - -```swift -import 模块 -``` - -可以对导入操作提供更细致的控制，如指定一个特殊的子模块或者指定一个模块或子模块中的某个声明。提供了这些限制后，在当前作用域中，只有被导入的符号是可用的，而不是整个模块中的所有声明。 - -```swift -import 导入类型 模块.符号名 -import 模块.子模块 -``` - - -> 导入声明语法 -> -> *导入声明* → [*特性列表*](06_Attributes.md#attributes)可选 **import** [*导入类型*](#import-kind)可选 [*导入路径*](#import-path) -> -> *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func** -> -> *导入路径* → [*导入路径标识符*](#import-path-identifier) | [*导入路径标识符*](#import-path-identifier) **.** [*导入路径*](#import-path) -> -> *导入路径标识符* → [*标识符*](02_Lexical_Structure.md#identifier) | [*运算符*](02_Lexical_Structure.md#operator) - - -## 常量声明 - -*常量声明 (constant declaration)* 可以在程序中引入一个具有命名的常量。常量以关键字 `let` 来声明，遵循如下格式： - -```swift -let 常量名称: 类型 = 表达式 -``` - -常量声明在“常量名称”和用于初始化的“表达式”的值之间定义了一种不可变的绑定关系；当常量的值被设定之后，它就无法被更改。这意味着，如果常量以类对象来初始化，对象本身的内容是可以改变的，但是常量和该对象之间的绑定关系是不能改变的。 - -当一个常量被声明为全局常量时，它必须拥有一个初始值。在类或者结构中声明一个常量时，它将作为*常量属性 (constant property)*。常量声明不能是计算型属性，因此也没有存取方法。 - -如果常量名称是元组形式，元组中每一项的名称都会和初始化表达式中对应的值进行绑定。 - -```swift -let (firstNumber, secondNumber) = (10, 42) -``` - -在上例中，`firstNumber` 是一个值为 `10` 的常量，`secnodeName` 是一个值为 `42` 的常量。所有常量都可以独立地使用： - -```swift -print("The first number is \(firstNumber).") -// 打印 “The first number is 10.” -print("The second number is \(secondNumber).") -// 打印 “The second number is 42.” -``` - -当常量名称的类型 (`:` 类型) 可以被推断出时，类型标注在常量声明中是可选的，正如 [类型推断](03_Types.md#type_inference) 中所描述的。 - -声明一个常量类型属性要使用 `static` 声明修饰符。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties)中有介绍。 - -如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../chapter2/01_The_Basics.md#constants_and_variables) 和 [存储属性](../chapter2/10_Properties.md#stored_properties)。 - - -> 常量声明语法 -> -> *常量声明* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **let** [*模式构造器列表*](pattern-initializer-list) -> -> *模式构造器列表* → [*模式构造器*](#pattern-initializer) | [*模式构造器*](#pattern-initializer) **,** [*模式构造器列表*](#pattern-initializer-list) -> -> *模式构造器* → [*模式*](07_Patterns.md#pattern) [*构造器*](#initializer)可选 -> -> *构造器* → **=** [*表达式*](04_Expressions.md#expression) - - -## 变量声明 - -*变量声明 (variable declaration)* 可以在程序中引入一个具有命名的变量，它以关键字 `var` 来声明。 - -变量声明有几种不同的形式，可以声明不同种类的命名值和可变值，如存储型和计算型变量和属性，属性观察器，以及静态变量属性。所使用的声明形式取决于变量声明的适用范围和打算声明的变量类型。 - -> 注意 -> -> 也可以在协议声明中声明属性，详情请参阅 [协议属性声明](#protocol_property_declaration)。 - -可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../chapter2/13_Inheritance.md#overriding)。 - - -### 存储型变量和存储型变量属性 - -使用如下形式声明一个存储型变量或存储型变量属性： - -```swift -var 变量名称: 类型 = 表达式 -``` - -可以在全局范围，函数内部，或者在类和结构的声明中使用这种形式来声明一个变量。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个存储型变量。当它在类或者结构中被声明时，它代表一个*存储型变量属性 (stored variable property)*。 - -用于初始化的表达式不可以在协议的声明中出现，在其他情况下，该表达式是可选的。如果没有初始化表达式，那么变量声明必须包含类型标注 (`:` *type*)。 - -如同常量声明，如果变量名称是元组形式，元组中每一项的名称都会和初始化表达式中对应的值进行绑定。 - -正如名字所示，存储型变量和存储型变量属性的值会存储在内存中。 - - -### 计算型变量和计算型属性 - -使用如下形式声明一个计算型变量或计算型属性： - -```swift -var 变量名称: 类型 { - get { - 语句 - } - set(setter 名称) { - 语句 - } -} -``` - -可以在全局范围、函数内部，以及类、结构、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性 (computed property)*。 - -getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../chapter2/10_Properties.md#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 - -setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../chapter2/10_Properties.md#shorthand_setter_declaration) 中描述的那样。 - -与存储型变量和存储型属性不同，计算型变量和计算型属性的值不存储在内存中。 - -要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../chapter2/10_Properties.md#computed_properties)。 - - -### 存储型变量和属性的观察器 - -可以在声明存储型变量或属性时提供 `willSet` 和 `didSet` 观察器。一个包含观察器的存储型变量或属性以如下形式声明： - -```swift -var 变量名称: 类型 = 表达式 { - willSet(setter 名称) { - 语句 - } - didSet(setter 名称) { - 语句 - } -} -``` - -可以在全局范围、函数内部，或者类、结构的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，观察器表示一个存储型变量观察器。当它在类和结构的声明中被声明时，观察器表示一个属性观察器。 - -可以为任何存储型属性添加观察器。也可以通过重写父类属性的方式为任何继承的属性（无论是存储型还是计算型的）添加观察器 -，正如 [重写属性观察器](../chapter2/13_Inheritance.md#overriding_property_observers) 中所描述的。 - -用于初始化的表达式在类或者结构的声明中是可选的，但是在其他声明中则是必须的。如果可以从初始化表达式中推断出类型信息，那么可以不提供类型标注。 - -当变量或属性的值被改变时，`willSet` 和 `didSet` 观察器提供了一种观察方法。观察器会在变量的值被改变时调用，但不会在初始化时被调用。 - -`willSet` 观察器只在变量或属性的值被改变之前调用。新的值作为一个常量传入 `willSet` 观察器，因此不可以在 `willSet` 中改变它。`didSet` 观察器在变量或属性的值被改变后立即调用。和 `willSet` 观察器相反，为了方便获取旧值，旧值会传入 `didSet` 观察器。这意味着，如果在变量或属性的 `didiset` 观察器中设置值，设置的新值会取代刚刚在 `willSet` 观察器中传入的那个值。 - -在 `willSet` 和 `didSet` 中，圆括号以及其中的 setter 名称是可选的。如果提供了一个 setter 名称，它就会作为 `willSet` 和 `didSet` 的参数被使用。如果不提供 setter 名称，`willSet` 观察器的默认参数名为 `newValue`，`didSet` 观察器的默认参数名为 `oldValue`。 - -提供了 `willSet` 时，`didSet` 是可选的。同样的，提供了 `didSet` 时，`willSet` 则是可选的。 - -要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../chapter2/10_Properties.md#property_observers)。 - - -### 类型变量属性 - -要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties) 章节有详细讨论。 - -> 注意 -> -> 在一个类声明中，使用关键字 `static` 与同时使用 `class` 和 `final` 去标记一个声明的效果相同。 - - -> 变量声明语法 - - -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*模式构造器列表*](#pattern-initializer-list) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*代码块*](#code-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 代码块*](#getter-setter-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*构造器*](#initializer) [*willSet-didSet 代码块*](#willSet-didSet-block) -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*构造器*](#initializer)可选 [*willSet-didSet 代码块*](#willSet-didSet-block) - - -> *变量声明头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **var** -> -> *变量名称* → [*标识符*](02_Lexical_Structure.md#identifier) - - -> *getter-setter 代码块* → [*代码块*](#code-block) -> *getter-setter 代码块* → **{** [*getter 子句*](#getter-clause) [*setter 子句*](#setter-clause)可选 **}** -> *getter-setter 代码块* → **{** [*setter 子句*](#setter-clause) [*getter 子句*](#getter-clause) **}** -> -> *getter 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **get** [*代码块*](#code-block) -> -> *setter 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **set** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) -> -> *setter 名称* → **(** [*标识符*](02_Lexical_Structure.md#identifier) **)** - - -> *getter-setter 关键字代码块* → **{** [*getter 关键字子句*](#getter-keyword-clause) [*setter 关键字子句*](#setter-keyword-clause)可选 **}** -> *getter-setter 关键字代码块* → **{** [*setter 关键字子句*](#setter-keyword-clause) [*getter 关键字子句*](#getter-keyword-clause) **}** -> -> *getter 关键字子句* → [*特性列表*](06_Attributes.md#attributes)可选 **get** -> -> *setter 关键字子句* → [*特性列表*](06_Attributes.md#attributes)可选 **set** - - -> *willSet-didSet 代码块* → **{** [*willSet 子句*](#willSet-clause) [*didSet 子句*](#didSet-clause)可选 **}** -> *willSet-didSet 代码块* → **{** [*didSet 子句*](#didSet-clause) [*willSet 子句*](#willSet-clause)可选 **}** -> -> *willSet 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **willSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) -> -> *didSet 子句* → [*特性列表*](06_Attributes.md#attributes)可选 **didSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) - - -## 类型别名声明 - -*类型别名 (type alias)* 声明可以在程序中为一个既有类型声明一个别名。类型别名声明语句使用关键字 `typealias` 声明，遵循如下的形式： - -```swift -typealias 类型别名 = 现存类型 -``` - -当声明一个类型的别名后，可以在程序的任何地方使用“别名”来代替现有类型。现有类型可以是具有命名的类型或者混合类型。类型别名不产生新的类型，它只是使用别名来引用现有类型。 -类型别名声明可以通过泛型参数来给一个现有泛型类型提供名称。类型别名为现有类型的一部分或者全部泛型参数提供具体类型。例如: - -```swift -typealias StringDictionary = Dictionary - -// 下列两个字典拥有同样的类型 -var dictionary1: StringDictionary = [:] -var dictionary2: Dictionary = [:] -``` - -当一个类型别名带着泛型参数一起被声明时，这些参数的约束必须与现有参数的约束完全匹配。例如: - -```swift -typealias DictionaryOfInts = Dictionary -``` - -因为类型别名可以和现有类型相互交换使用，类型别名不可以引入额外的类型约束。 -在协议声明中，类型别名可以为那些经常使用的类型提供一个更短更方便的名称，例如: - -```swift -protocol Sequence { - associatedtype Iterator: IteratorProtocol - typealias Element = Iterator.Element -} - -func sum(_ sequence: T) -> Int where T.Element == Int { - // ... -} -``` - -假如没有类型别名，sum 函数将必须引用关联类型通过 T.Iterator.Element 的形式来替代 T.Element。 - -另请参阅 [协议关联类型声明](#protocol_associated_type_declaration)。 - - -> 类型别名声明语法 -> -> *类型别名声明* → [*类型别名头*](#typealias-head) [*类型别名赋值*](#typealias-assignment) -> -> *类型别名头* → [*特性列表*](06_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 **typealias** [*类型别名名称*](#typealias-name) -> -> *类型别名名称* → [*标识符*](02_Lexical_Structure.md#identifier) -> -> *类型别名赋值* → **=** [*类型*](03_Types.md#type) - - -## 函数声明 - -使用*函数声明 (function declaration)* 在程序中引入新的函数或者方法。在类、结构体、枚举，或者协议中声明的函数会作为方法。函数声明使用关键字 `func`，遵循如下的形式： - -```swift -func 函数名称(参数列表) -> 返回类型 { - 语句 -} -``` - -如果函数返回 `Void` 类型，返回类型可以省略，如下所示： - -```swift -func 函数名称(参数列表) { - 语句 -} -``` - -每个参数的类型都要标明，因为它们不能被推断出来。如果您在某个参数类型前面加上了 `inout`，那么这个参数就可以在这个函数作用域当中被修改。更多关于 `inout` 参数的讨论，请参阅 [输入输出参数](#in-out_parameters)。 - -函数可以使用元组类型作为返回类型来返回多个值。 - -函数定义可以出现在另一个函数声明内。这种函数被称作*嵌套函数 (nested function)*。更多关于嵌套函数的讨论，请参阅 [嵌套函数](../chapter2/06_Functions.md#Nested_Functions)。 - - -### 参数名 - -函数的参数列表由一个或多个函数参数组成，参数间以逗号分隔。函数调用时的参数顺序必须和函数声明时的参数顺序一致。最简单的参数列表有着如下的形式： - -`参数名称`: `参数类型` - -一个参数有一个内部名称，这个内部名称可以在函数体内被使用。还有一个外部名称，当调用函数时这个外部名称被作为实参的标签来使用。默认情况下，第一个参数的外部名称会被省略，第二个和之后的参数使用它们的内部名称作为它们的外部名称。例如： - -```swift -func f(x: Int, y: Int) -> Int { return x + y } -f(1, y: 2) // 参数 y 有标签，参数 x 则没有 -``` - -可以按照如下两种形式之一，重写参数名称的默认行为： - -`外部参数名称` `内部参数名称`: `参数类型` -_ `内部参数名称`: `参数类型` - -在内部参数名称前的名称会作为这个参数的外部名称，这个名称可以和内部参数的名称不同。外部参数名称在函数被调用时必须被使用，即对应的参数在方法或函数被调用时必须有外部名。 - -内部参数名称前的下划线（`_`）可使该参数在函数被调用时没有名称。在函数或方法调用时，对应的参数必须没有名字。 - -```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 则没有 -``` - - -### 输入输出参数 - -输入输出参数被传递时遵循如下规则： - -1. 函数调用时，参数的值被拷贝。 -2. 函数体内部，拷贝后的值被修改。 -3. 函数返回后，拷贝后的值被赋值给原参数。 - -这种行为被称为*拷入拷出 (copy-in copy-out)* 或*值结果调用 (call by value result)*。例如，当一个计算型属性或者一个具有属性观察器的属性被用作函数的输入输出参数时，其 getter 会在函数调用时被调用，而其 setter 会在函数返回时被调用。 - -作为一种优化手段，当参数值存储在内存中的物理地址时，在函数体内部和外部均会使用同一内存位置。这种优化行为被称为*引用调用 (call by reference)*，它满足了拷入拷出模式的所有要求，且消除了复制带来的开销。在代码中，要规范使用拷入拷出模式，不要依赖于引用调用。 - -不要使用传递给输入输出参数的值，即使原始值在当前作用域中依然可用。当函数返回时，你对原始值所做的更改会被拷贝的值所覆盖。不要依赖于引用调用的优化机制来试图避免这种覆盖。 - -不能将同一个值传递给多个输入输出参数，因为这种情况下的拷贝与覆盖行为的顺序是不确定的，因此原始值的最终值也将无法确定。例如： - -```swift -var x = 10 -func f(inout a: Int, inout _ b: Int) { - a += 1 - b += 10 -} -f(&x, &x) // 编译报错 error: inout arguments are not allowed to alias each other -``` - -如果嵌套函数在外层函数返回后才调用，嵌套函数对输入输出参数造成的任何改变将不会影响到原始值。例如： - -```swift -func outer(inout a: Int) -> () -> Void { - func inner() { - a += 1 - } - return inner -} - -var x = 10 -let f = outer(&x) -f() -print(x) -// 打印 “10” -``` - -调用嵌套函数 `inner()` 对 `a` 递增后，`x` 的值并未发生改变，因为 `inner()` 在外层函数 `outer()` 返回后才被调用。若要改变 `x` 的值，必须在 `outer()` 返回前调用 `inner()`。 - -关于输入输出参数的详细讨论，请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 - - -### 特殊参数 - -参数可以被忽略，数量可以不固定，还可以为其提供默认值，使用形式如下： - -```swift -_ : 参数类型 -参数名称: 参数类型... -参数名称: 参数类型 = 默认参数值 -``` - -以下划线（`_`）命名的参数会被显式忽略，无法在函数体内使用。 - -一个参数的基本类型名称如果紧跟着三个点（`...`），会被视为可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数会作为包含该参数类型元素的数组处理。举例来讲，可变参数 `Int...` 会作为 `[Int]` 来处理。关于使用可变参数的例子，请参阅 [可变参数](../chapter2/06_Functions.md#variadic_parameters)。 - -如果在参数类型后面有一个以等号（`=`）连接的表达式，该参数会拥有默认值，即给定表达式的值。当函数被调用时，给定的表达式会被求值。如果参数在函数调用时被省略了，就会使用其默认值。 - -```swift -func f(x: Int = 42) -> Int { return x } -f() // 有效，使用默认值 -f(7) // 有效，提供了值 -f(x: 7) // 无效，该参数没有外部名称 -``` - - -### 特殊方法 - -枚举或结构体的方法如果会修改 `self`，则必须以 `mutating` 声明修饰符标记。 - -子类重写超类中的方法必须以 `override` 声明修饰符标记。重写方法时不使用 `override` 修饰符，或者被 `override` 修饰符修饰的方法并未对超类方法构成重写，都会导致编译错误。 - -枚举或者结构体中的类型方法，要以 `static` 声明修饰符标记，而对于类中的类型方法，除了使用 `static`，还可使用 `class` 声明修饰符标记。 - - -### 抛出错误的函数和方法 - -可以抛出错误的函数或方法必须使用 `throws` 关键字标记。这类函数和方法被称为抛出函数和抛出方法。它们有着下面的形式: - -```swift -func 函数名称(参数列表) throws -> 返回类型 { - 语句 -} -``` - -抛出函数或抛出方法的调用必须包裹在 `try` 或者 `try!` 表达式中（也就是说，在作用域内使用 `try` 或者 `try!` 运算符）。 - -`throws` 关键字是函数的类型的一部分，非抛出函数是抛出函数的子类型。所以，可以在使用抛出函数的地方使用非抛出函数。 - -不能仅基于函数能否抛出错误来进行函数重载。也就是说，可以基于函数的函数类型的参数能否抛出错误来进行函数重载。 - -抛出方法不能重写非抛出方法，而且抛出方法不能满足协议对于非抛出方法的要求。也就是说，非抛出方法可以重写抛出方法，而且非抛出方法可以满足协议对于抛出方法的要求。 - - -### 重抛错误的函数和方法 - -函数或方法可以使用 `rethrows` 关键字来声明，从而表明仅当该函数或方法的一个函数类型的参数抛出错误时，该函数或方法才抛出错误。这类函数和方法被称为重抛函数和重抛方法。重新抛出错误的函数或方法必须至少有一个参数的类型为抛出函数。 - -```swift -func someFunction(callback: () throws -> Void) rethrows { - try callback() -} -``` - -重抛函数或者方法不能够从自身直接抛出任何错误，这意味着它不能够包含 `throw` 语句。它只能够传递作为参数的抛出函数所抛出的错误。例如，在 `do-catch` 代码块中调用抛出函数，并在 `catch` 子句中抛出其它错误都是不允许的。 - -抛出方法不能重写重抛方法，而且抛出方法不能满足协议对于重抛方法的要求。也就是说，重抛方法可以重写抛出方法，而且重抛方法可以满足协议对于抛出方法的要求。 - - -### 永不返回的函数 - -Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它的调用者。`Never` 返回类型的函数或方法可以称为不归，不归函数、方法要么引发不可恢复的错误，要么永远不停地运作，这会使调用后本应执行得代码就不再执行了。但即使是不归函数、方法，抛错函数和重抛出函数也可以将程序控制转移到合适的 `catch` 代码块。 - -不归函数、方法可以在 guard 语句的 else 字句中调用，具体讨论在[*Guard 语句*](10_Statements.md#guard_statements)。 -你可以重载一个不归方法，但是新的方法必须保持原有的返回类型和没有返回的行为。 - - -> 函数声明语法 - - -> *函数声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*函数签名*](#function-signature) [*函数体*](#function-body)可选 - - -> *函数头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **func** -> -> *函数名* → [*标识符*](02_Lexical_Structure.md#identifier) | [*运算符*](02_Lexical_Structure.md#operator) - - -> *函数签名* → [*参数子句列表*](#parameter-clauses) **throws**可选 [*函数结果*](#function-result)可选 -> *函数签名* → [*参数子句列表*](#parameter-clauses) **rethrows** [*函数结果*](#function-result)可选 -> -> *函数结果* → **->** [*特性列表*](06_Attributes.md#attributes)可选 [*类型*](03_Types.md#type) -> -> *函数体* → [*代码块*](#code-block) - - -> *参数子句列表* → [*参数子句*](#parameter-clause) [*参数子句列表*](#parameter-clauses)可选 -> -> *参数子句* → **(** **)** | **(** [*参数列表*](#parameter-list) **)** -> -> *参数列表* → [*参数*](#parameter) | [*参数*](#parameter) **,** [*参数列表*](#parameter-list) -> -> *参数* → **let**可选 [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) [*默认参数子句*](#default-argument-clause)可选 -> *参数* → **inout** [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) -> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.md#type-annotation) **...** -> -> *外部参数名* → [*标识符*](02_Lexical_Structure.md#identifier) | **_** -> -> *内部参数名* → [*标识符*](02_Lexical_Structure.md#identifier) | **_** -> -> *默认参数子句* → **=** [*表达式*](04_Expressions.md#expression) - - -## 枚举声明 - -在程序中使用*枚举声明 (enumeration declaration)* 来引入一个枚举类型。 - -枚举声明有两种基本形式，使用关键字 `enum` 来声明。枚举声明体包含零个或多个值，称为枚举用例，还可包含任意数量的声明，包括计算型属性、实例方法、类型方法、构造器、类型别名，甚至其他枚举、结构体和类。枚举声明不能包含析构器或者协议声明。 - -枚举类型可以采纳任意数量的协议，但是枚举不能从类、结构体和其他枚举继承。 - -不同于类或者结构体，枚举类型并不隐式提供默认构造器，所有构造器必须显式声明。一个构造器可以委托给枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例赋值给 `self` 后才算完成。 - -和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.md#structures_and_enumerations_are_value_types)。 - -可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。 - - -### 任意类型的枚举用例 - -如下的形式声明了一个包含任意类型枚举用例的枚举变量： - -```swift -enum 枚举名称: 采纳的协议 { - case 枚举用例1 - case 枚举用例2(关联值类型) -} -``` - -这种形式的枚举声明在其他语言中有时被叫做可识别联合。 - -在这种形式中，每个用例块由关键字 `case` 开始，后面紧接一个或多个以逗号分隔的枚举用例。每个用例名必须是独一无二的。每个用例也可以指定它所存储的指定类型的值，这些类型在关联值类型的元组中被指定，紧跟用例名之后。 - -具有关联值的枚举用例可以像函数一样使用，通过指定的关联值创建枚举实例。和真正的函数一样，你可以获取枚举用例的引用，然后在后续代码中调用它。 - -```swift -enum Number { - case Integer(Int) - case Real(Double) -} - -// f 的类型为 (Int) -> Number -let f = Number.Integer - -// 利用 f 把一个整数数组转成 Number 数组 -let evenInts: [Number] = [0, 2, 4, 6].map(f) -``` - -要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../chapter2/08_Enumerations.md#associated_values)。 - - -#### 递归枚举 - -枚举类型可以具有递归结构，就是说，枚举用例的关联值类型可以是枚举类型自身。然而，枚举类型的实例具有值语义，这意味着它们在内存中有固定布局。为了支持递归，编译器必须插入一个间接层。 - -要让某个枚举用例支持递归，使用 `indirect` 声明修饰符标记该用例。 - -```swift -enum Tree { - case Empty - indirect case Node(value: T, left: Tree, right:Tree) -} -``` - -要让一个枚举类型的所有用例都支持递归，使用 `indirect` 修饰符标记整个枚举类型，当枚举有多个用例且每个用例都需要使用 `indirect` 修饰符标记的时候这将非常便利。 - -被 `indirect` 修饰符标记的枚举用例必须有一个关联值。使用 `indirect` 修饰符标记的枚举类型可以既包含有关联值的用例，同时还可包含没有关联值的用例。但是，它不能再单独使用 `indirect` 修饰符来标记某个用例。 - - -### 拥有原始值的枚举用例 - -以下形式声明了一种枚举类型，其中各个枚举用例的类型均为同一种基本类型： - -```swift -enum 枚举名称: 原始值类型, 采纳的协议 { - case 枚举用例1 = 原始值1 - case 枚举用例2 = 原始值2 -} -``` - -在这种形式中，每一个用例块由 `case` 关键字开始，后面紧跟一个或多个以逗号分隔的枚举用例。和第一种形式的枚举用例不同，这种形式的枚举用例包含一个基础值，叫做原始值，各个枚举用例的原始值的类型必须相同。这些原始值的类型通过原始值类型指定，必须表示一个整数、浮点数、字符串或者字符。原始值类型必须符合 `Equatable` 协议和下列字面量转换协议中的一种：整型字面量需符合 `IntergerLiteralConvertible` 协议，浮点型字面量需符合 `FloatingPointLiteralConvertible` 协议，包含任意数量字符的字符串型字面量需符合 `StringLiteralConvertible` 协议，仅包含一个单一字符的字符串型字面量需符合 `ExtendedGraphemeClusterLiteralConvertible` 协议。每一个用例的名字和原始值必须唯一。 - -如果原始值类型被指定为 `Int`，则不必为用例显式地指定原始值，它们会隐式地被赋值 `0`、`1`、`2` 等。每个未被赋值的 `Int` 类型的用例会被隐式地赋值，其值为上一个用例的原始值加 `1`。 - -```Swift -enum ExampleEnum: Int { - case A, B, C = 5, D -} -``` - -在上面的例子中，`ExampleEnum.A` 的原始值是 `0`，`ExampleEnum.B` 的原始值是 `1`。因为 `ExampleEnum.C` 的原始值被显式地设定为 `5`，因此 `ExampleEnum.D` 的原始值会自动增长为 `6`。 - -如果原始值类型被指定为 `String` 类型，你不用明确地为用例指定原始值，每个没有指定原始值的用例会隐式地将用例名字作为原始值。 - -```swift -enum WeekendDay: String { - case Saturday, Sunday -} -``` - -在上面这个例子中，`WeekendDay.Saturday` 的原始值是 `"Saturday"`，`WeekendDay.Sunday` 的原始值是 `"Sunday"`。 - -枚举用例具有原始值的枚举类型隐式地符合定义在 Swift 标准库中的 `RawRepresentable` 协议。所以，它们拥有一个 `rawValue` 属性和一个可失败构造器 `init?(rawValue: RawValue)`。可以使用 `rawValue` 属性去获取枚举用例的原始值，例如 `ExampleEnum.B.rawValue`。还可以根据原始值来创建一个相对应的枚举用例，只需调用枚举的可失败构造器，例如 `ExampleEnum(rawValue: 5)`，这个可失败构造器返回一个可选类型的用例。要获得更多关于具有原始值的枚举用例的信息和例子，请参阅 [原始值](../chapter2/08_Enumerations.md#raw_values)。 - - -### 访问枚举用例 - -使用点语法（`.`）来引用枚举类型的枚举用例，例如 `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` 块中的枚举用例模式，正如 [枚举用例模式](07_Patterns.md#enumeration_case_pattern) 所述。 - - -> 枚举声明语法 - - -> *枚举声明* → [*特性列表*](06_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 [*联合风格枚举*](#union-style-enum) -> *枚举声明* → [*特性列表*](06_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier) 可选 [*原始值风格枚举*](#raw-value-style-enum) - - -> *联合风格枚举* → **indirect**可选 **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [类型继承子句](03_Types.md#type-inheritance-clause)可选 **{** [*多个联合风格枚举成员*](#union-style-enum-members)可选 **}** -> -> *多个联合风格枚举成员* → [*联合风格枚举成员*](#union-style-enum-member) [*多个联合风格枚举成员*](#union-style-enum-members)可选 -> -> *联合风格枚举成员* → [*声明*](#declaration) | [*联合风格枚举用例子句*](#union-style-enum-case-clause) -> -> *联合风格枚举用例子句* → [*特性列表*](06_Attributes.md#attributes)可选 **indirect**可选 **case** [*联合风格枚举用例列表*](#union-style-enum-case-list) -> -> *联合风格枚举用例列表* → [*联合风格枚举用例*](#union-style-enum-case) | [*联合风格枚举用例*](#union-style-enum-case) **,** [*联合风格枚举用例列表*](#union-style-enum-case-list) -> -> *联合风格枚举用例* → [*枚举用例名称*](#enum-case-name) [*元组类型*](03_Types.md#tuple-type)可选 -> -> *枚举名称* → [*标识符*](02_Lexical_Structure.md#identifier) -> -> *枚举用例名称* → [*标识符*](02_Lexical_Structure.md#identifier) - - -> *原始值风格枚举* → **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [类型继承子句](03_Types.md#type-inheritance-clause) **{** [*多个原始值风格枚举成员*](#raw-value-style-enum-members) **}** -> -> *多个原始值风格枚举成员* → [*原始值风格枚举成员*](#raw-value-style-enum-member) [*多个原始值风格枚举成员*](#raw-value-style-enum-members)可选 -> -> *原始值风格枚举成员* → [*声明*](#declaration) | [*原始值风格枚举用例子句*](#raw-value-style-enum-case-clause) -> -> *原始值风格枚举用例子句* → [*特性列表*](06_Attributes.md#attributes)可选 **case** [*原始值风格枚举用例列表*](#raw-value-style-enum-case-list) -> -> *原始值风格枚举用例列表* → [*原始值风格枚举用例*](#raw-value-style-enum-case) | [*原始值风格枚举用例*](#raw-value-style-enum-case) **,** [*原始值风格枚举用例列表*](#raw-value-style-enum-case-list) -> -> *原始值风格枚举用例* → [*枚举用例名称*](#enum-case-name) [*原始值赋值*](#raw-value-assignment)可选 -> -> *原始值赋值* → **=** [*原始值字面量*](#raw-value-literal) -> -> *原始值字面量* → [数字型字面量](02_Lexical_Structure.md#numeric-literal) | [字符串型字面量](02_Lexical_Structure.md#static-string-literal) | [布尔型字面量](02_Lexical_Structure.md#boolean-literal) - - -## 结构体声明 - -使用*结构体声明 (structure declaration)* 可以在程序中引入一个结构体类型。结构体声明使用 `struct` 关键字，遵循如下的形式： - -```swift -struct 结构体名称: 采纳的协议 { - 多条声明 -} -``` - -结构体内可包含零个或多个声明。这些声明可以包括存储型和计算型属性、类型属性、实例方法、类型方法、构造器、下标、类型别名，甚至其他结构体、类、和枚举声明。结构体声明不能包含析构器或者协议声明。关于结构体的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Classes_and_Structures.md)。 - -结构体可以采纳任意数量的协议，但是不能继承自类、枚举或者其他结构体。 - -有三种方法可以创建一个已声明的结构体实例： - -* 调用结构体内声明的构造器，正如 [构造器](../chapter2/14_Initialization.md#initializers) 所述。 - -* 如果没有声明构造器，调用结构体的成员逐一构造器，正如 [结构体类型的成员逐一构造器](../chapter2/14_Initialization.md#memberwise_initializers_for_structure_types) 所述。 - -* 如果没有声明构造器，而且结构体的所有属性都有初始值，调用结构体的默认构造器，正如 [默认构造器](../chapter2/14_Initialization.md#default_initializers) 所述。 - -结构体的构造过程请参阅 [构造过程](../chapter2/14_Initialization.md)。 - -结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../chapter2/09_Classes_and_Structures.md#accessing_properties) 所述。 - -结构体是值类型。结构体的实例在被赋予变量或常量，或传递给函数作为参数时会被复制。关于值类型的更多信息，请参阅 -[结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.md#structures_and_enumerations_are_value_types)。 - -可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension_declaration)。 - - -> 结构体声明语法 -> -> *结构体声明* → [*特性列表*](06_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier) 可选 **struct** [*结构体名称*](#struct-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [类型继承子句](03_Types.md#type-inheritance-clause)可选 [*结构体主体*](#struct-body) -> -> *结构体名称* → [*标识符*](02_Lexical_Structure.md#identifier) -> -> *结构体主体* → **{** [*多条声明*](#declarations)可选 **}** - - -## 类声明 - -可以在程序中使用*类声明 (class declaration)* 来引入一个类。类声明使用关键字 `class`，遵循如下的形式： - -```swift -class 类名: 超类, 采纳的协议 { - 多条声明 -} -``` - -类内可以包含零个或多个声明。这些声明可以包括存储型和计算型属性、实例方法、类型方法、构造器、唯一的析构器、下标、类型别名，甚至其他结构体、类和枚举声明。类声明不能包含协议声明。关于类的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Classes_and_Structures.md)。 - -一个类只能继承自一个超类，但是可以采纳任意数量的协议。超类紧跟在类名和冒号后面，其后跟着采纳的协议。泛型类可以继承自其它泛型类和非泛型类，但是非泛型类只能继承自其它非泛型类。当在冒号后面写泛型超类的名称时，必须写上泛型类的全名，包括它的泛型形参子句。 - -正如 [构造器声明](#initializer_declaration) 所讨论的，类可以有指定构造器和便利构造器。类的指定构造器必须初始化类中声明的所有属性，并且必须在调用超类构造器之前。 - -类可以重写属性、方法、下标以及构造器。重写的属性、方法、下标和指定构造器必须以 `override` 声明修饰符标记。 - -为了要求子类去实现超类的构造器，使用 `required` 声明修饰符标记超类的构造器。子类实现超类构造器时也必须使用 `required` 声明修饰符。 - -虽然超类属性和方法声明可以被当前类继承，但是超类声明的指定构造器却不能。即便如此，如果当前类重写了超类的所有指定构造器，它就会继承超类的所有便利构造器。Swift 的类并不继承自一个通用基础类。 - -有两种方法来创建已声明的类的实例： - -* 调用类中声明的构造器，请参阅 [构造器](../chapter2/14_Initialization.md#initializers)。 - -* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../chapter2/14_Initialization.md#default_initializers)。 - -类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../chapter2/09_Classes_and_Structures.md#accessing_properties)。 - -类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.md#structures_and_enumerations_are_value_types)。 - -可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension_declaration)。 - - -> 类声明语法 -> -> *类声明* → [*特性列表*](06_Attributes.md#attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](03_Types.md#type-inheritance-clause)可选 [*类主体*](#class-body) -> -> *类名* → [*标识符*](02_Lexical_Structure.md#identifier) -> -> *类主体* → **{** [*多条声明*](#declarations)可选 **}** - - -## 协议声明 - -*协议声明 (protocol declaration)* 可以为程序引入一个命名的协议类型。协议声明只能在全局区域使用 `protocol` 关键字来进行声明，并遵循如下形式： - -```swift -protocol 协议名称: 继承的协议 { - 协议成员声明 -} -``` - -协议的主体包含零个或多个协议成员声明，这些成员描述了任何采纳该协议的类型必须满足的一致性要求。一个协议可以声明采纳者必须实现的某些属性、方法、构造器以及下标。协议也可以声明各种各样的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议声明不能包括类、结构体、枚举或者其它协议的声明。协议成员声明会在后面进行讨论。 - -协议类型可以继承自任意数量的其它协议。当一个协议类型继承自其它协议的时候，来自其它协议的所有要求会聚合在一起，而且采纳当前协议的类型必须符合所有的这些要求。关于如何使用协议继承的例子，请参阅 [协议继承](../chapter2/22_Protocols.md#protocol_inheritance)。 - -> 注意 -> -> 也可以使用协议合成类型来聚合多个协议的一致性要求，请参阅 [协议合成类型](03_Types.md#protocol_composition_type) 和 [协议合成](../chapter2/22_Protocols.md#protocol_composition)。 - -可以通过类型的扩展声明来采纳协议，从而为之前声明的类型添加协议一致性。在扩展中，必须实现所有采纳协议的要求。如果该类型已经实现了所有的要求，可以让这个扩展声明的主体留空。 - -默认地，符合某个协议的类型必须实现所有在协议中声明的属性、方法和下标。即便如此，可以用 `optional` 声明修饰符标注协议成员声明，以指定它们的实现是可选的。`optional` 修饰符仅仅可以用于使用 `objc` 特性标记过的协议。因此，仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用 `optional` 声明修饰符的信息，以及如何访问可选协议成员的指导——例如不能确定采纳协议的类型是否实现了它们时——请参阅 [可选协议要求](../chapter2/22_Protocols.md#optional_protocol_requirements) - -为了限制协议只能被类类型采纳，需要使用 `class` 关键字来标记协议，将 `class` 关键在写在冒号后面的继承的协议列表的首位。例如，下面的协议只能被类类型采纳： - -```swift -protocol SomeProtocol: class { - /* 这里是协议成员 */ -} -``` - -任何继承自标记有 `class` 关键字的协议的协议也仅能被类类型采纳。 - -> 注意 -> -> 如果协议已经用 `objc` 特性标记了，`class` 要求就隐式地应用于该协议，无需显式使用 `class` 关键字。 - -协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../chapter2/22_Protocols.md#protocols_as_types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。 - -可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托(代理)模式](../chapter2/22_Protocols.md#delegation) 中所述。 - - -> 协议声明语法 - - -> *协议声明* → [*特性列表*](06_Attributes.md#attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **protocol** [*协议名称*](#protocol-name) [*类型继承子句*](03_Types.html#type-inheritance-clause)可选 [*协议主体*](#protocol-body) -> -> *协议名称* → [*标识符*](02_Lexical_Structure.md#identifier) -> -> *协议主体* → **{** [*协议成员声明列表*](#protocol-member-declarations)可选 **}** - - -> *协议成员声明* → [*协议属性声明*](#protocol-property-declaration) -> *协议成员声明* → [*协议方法声明*](#protocol-method-declaration) -> *协议成员声明* → [*协议构造器声明*](#protocol-initializer-declaration) -> *协议成员声明* → [*协议下标声明*](#protocol-subscript-declaration) -> *协议成员声明* → [*协议关联类型声明*](#protocol-associated-type-declaration) -> -> *协议成员声明列表* → [*协议成员声明*](#protocol-member-declaration) [*协议成员声明列表*](#protocol-member-declarations)可选 - - -### 协议属性声明 - -协议可以通过在协议声明主体中引入一个协议属性声明，来声明符合的类型必须实现的属性。协议属性声明有一种特殊的变量声明形式： - -```swift -var 属性名: 类型 { get set } -``` - -同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了 getter 和 setter 要求，你不能在协议中直接实现 getter 和 setter。 - -符合类型可以通过多种方式满足 getter 和 setter 要求。如果属性声明包含 `get` 和 `set` 关键字，符合类型就可以用存储型变量属性或可读可写的计算型属性来满足此要求，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含 `get` 关键字的话，它可以作为任意类型的属性被实现。关于如何实现协议中的属性要求的例子，请参阅 [属性要求](../chapter2/22_Protocols.md#property_requirements) - -另请参阅 [变量声明](#variable_declaration)。 - - -> 协议属性声明语法 -> -> *协议属性声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) - - -### 协议方法声明 - -协议可以通过在协议声明主体中引入一个协议方法声明，来声明符合的类型必须实现的方法。协议方法声明和函数方法声明有着相同的形式，但有两项例外：它们不包括函数体，也不能包含默认参数。关于如何实现协议中的方法要求的例子，请参阅 [方法要求](../chapter2/22_Protocols.md#method_requirements)。 - -使用 `static` 声明修饰符可以在协议声明中声明一个类型方法。结构体实现这些方法时使用 `static` 声明修饰符，类在实现这些方法时，除了使用 `static` 声明修饰符，还可以选择使用 `class` 声明修饰符。通过扩展实现时亦是如此。 - -另请参阅 [函数声明](#function_declaration)。 - - -> 协议方法声明语法 -> -> *协议方法声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*函数签名*](#function-signature) - - -### 协议构造器声明 - -协议可以通过在协议声明主体中引入一个协议构造器声明，来声明符合的类型必须实现的构造器。协议构造器声明 -除了不包含实现主体外，和构造器声明有着相同的形式。 - -符合类型可以通过实现一个非可失败构造器或者 `init!` 可失败构造器来满足一个非可失败协议构造器的要求，可以通过实现任意类型的构造器来满足一个可失败协议构造器的要求。 - -类在实现一个构造器去满足一个协议的构造器要求时，如果这个类还没有用 `final` 声明修饰符标记，这个构造器必须用 `required` 声明修饰符标记。 - -另请参阅 [构造器声明](#initializer_declaration)。 - - -> 协议构造器声明语法 -> -> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 -> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows** - - -### 协议下标声明 - -协议可以通过在协议声明主体中引入一个协议下标声明，来声明符合的类型必须实现的下标。协议下标声明有一个特殊的下标声明形式： - -```swift -subscript (参数列表) -> 返回类型 { get set } -``` - -下标声明只为符合类型声明了 getter 和 setter 要求。如果下标声明包含 `get` 和 `set` 关键字，符合类型也必须实现 getter 和 setter 子句。如果下标声明只包含 `get` 关键字，符合类型必须实现 getter 子句，可以选择是否实现 setter 子句。 - -另请参阅 [下标声明](#subscript_declaration)。 - - -> 协议下标声明语法 -> -> *协议下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) - - -### 协议关联类型声明 - -使用关键字 `associatedtype` 来声明协议关联类型。关联类型为作为协议声明的一部分，为某种类型提供了一个别名。关联类型和泛型参数子句中的类型参数很相似，但是它们和 `Self` 一样，用于协议中。`Self` 指代采纳协议的类型。要获得更多信息和例子，请参阅 [关联类型](../chapter2/23_Generics.md#associated_types)。 - -另请参阅 [类型别名声明](#type_alias_declaration)。 - - -> 协议关联类型声明语法 -> -> *协议关联类型声明* → [*类型别名头*](#typealias-head) [*类型继承子句*](03_Types.md#type-inheritance-clause)可选 [*类型别名赋值*](#typealias-assignment)可选 - - -## 构造器声明 - -构造器声明会为程序中的类、结构体或枚举引入构造器。构造器使用关键字 `init` 来声明，有两种基本形式。 - -结构体、枚举、类可以有任意数量的构造器，但是类的构造器具有不同的规则和行为。不同于结构体和枚举，类有两种构造器，即指定构造器和便利构造器，请参阅 [构造过程](../chapter2/14_Initialization.md)。 - -采用如下形式声明结构体和枚举的构造器，以及类的指定构造器： - -```swift -init(参数列表) { - 构造语句 -} -``` - -类的指定构造器直接将类的所有属性初始化。它不能调用类中的其他构造器，如果类有超类，则必须调用超类的一个指定构造器。如果该类从它的超类继承了属性，必须在调用超类的指定构造器后才能修改这些属性。 - -指定构造器只能在类声明中声明，不能在扩展声明中声明。 - -结构体和枚举的构造器可以调用其他已声明的构造器，从而委托其他构造器来进行部分或者全部构造过程。 - -要为类声明一个便利构造器，用 `convenience` 声明修饰符来标记构造器声明： - -```swift -convenience init(参数列表) { - 构造语句 -} -``` - -便利构造器可以将构造过程委托给另一个便利构造器或一个指定构造器。但是，类的构造过程必须以一个将类中所有属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。 - -可以使用 `required` 声明修饰符，将便利构造器和指定构造器标记为每个子类都必须实现的构造器。这种构造器的子类实现也必须使用 `required` 声明修饰符标记。 - -默认情况下，超类中的构造器不会被子类继承。但是，如果子类的所有存储型属性都有默认值，而且子类自身没有定义任何构造器，它将继承超类的构造器。如果子类重写了超类的所有指定构造器，子类将继承超类的所有便利构造器。 - -和方法、属性和下标一样，需要使用 `override` 声明修饰符标记重写的指定构造器。 - -> 注意 -> -> 如果使用 `required` 声明修饰符标记一个构造器，在子类中重写这种构造器时，无需使用 `override` 修饰符。 - -就像函数和方法，构造器也可以抛出或者重抛错误，你可以在构造器参数列表的圆括号之后使用 `throws` 或 `rethrows` 关键字来表明相应的抛出行为。 - -关于在不同类型中声明构造器的例子，请参阅 [构造过程](../chapter2/14_Initialization.md)。 - - -### 可失败构造器 - -可失败构造器可以生成所属类型的可选实例或者隐式解包可选实例，因此，这种构造器通过返回 `nil` 来指明构造过程失败。 - -声明生成可选实例的可失败构造器时，在构造器声明的 `init` 关键字后加追加一个问号（`init?`）。声明生成隐式解包可选实例的可失败构造器时，在构造器声明后追加一个叹号（`init!`）。使用 `init?` 可失败构造器生成结构体的一个可选实例的例子如下。 - -```swift -struct SomeStruct { - let string: String - //生成一个 SomeStruct 的可选实例 - init?(input: String) { - if input.isEmpty { - // 丢弃 self，并返回 nil - return nil - } - string = input - } -} -``` - -调用 `init?` 可失败构造器和调用非可失败构造器的方式相同，不过你需要处理可选类型的返回值。 - -```swift -if let actualInstance = SomeStruct(input: "Hello") { - // 利用 SomeStruct 实例做些事情 -} else { - // SomeStruct 实例的构造过程失败，构造器返回了 nil -} -``` - -可失败构造器可以在构造器实现中的任意位置返回 `nil`。 - -可失败构造器可以委托任意种类的构造器。非可失败可以委托其它非可失败构造器或者 `init!` 可失败构造器。非可失败构造器可以委托超类的 `init?` 可失败指定构造器，但是需要使用强制解包，例如 `super.init()!`。 - -构造过程失败通过构造器委托来传递。具体来说，如果可失败构造器委托的可失败构造器构造过程失败并返回 `nil`，那么该可失败构造器也会构造失败并隐式地返回 `nil`。如果非可失败构造器委托的 `init!` 可失败构造器构造失败并返回了 `nil`，那么会发生运行时错误（如同使用 `!` 操作符去强制解包一个值为 `nil` 的可选值）。 - -子类可以用任意种类的指定构造器重写超类的可失败指定构造器，但是只能用非可失败指定构造器重写超类的非可失败指定构造器。 - -更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../chapter2/14_Initialization.md#failable_initializers)。 - - -> 构造器声明语法 -> -> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 [*构造器主体*](#initializer-body) -> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows**可选 [*构造器主体*](#initializer-body) -> -> *构造器头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **init** -> *构造器头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **init** **?** -> *构造器头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **init** **!** -> -> *构造器主体* → [*代码块*](#code-block) - - -## 析构器声明 - -*析构器声明 (deinitializer declaration)* 可以为类声明一个析构器。析构器没有参数，遵循如下格式： - -```swift -deinit { - 语句 -} -``` - -当没有任何强引用引用着类的对象，对象即将被释放时，析构器会被自动调用。析构器只能在类主体的声明中声明，不能在类的扩展声明中声明，并且每个类最多只能有一个析构器。 - -子类会继承超类的析构器，并会在子类对象将要被释放时隐式调用。继承链上的所有析构器全部调用完毕后子类对象才会被释放。 - -析构器不能直接调用。 - -关于如何在类声明中使用析构器的例子，请参阅 [析构过程](../chapter2/15_Deinitialization.md)。 - - -> 析构器声明语法 -> -> *析构器声明* → [*特性列表*](06_Attributes.md#attributes)可选 **deinit** [*代码块*](#code-block) - - -## 扩展声明 - -*扩展声明 (extension declaration)* 可以扩展一个现存的类型的行为。扩展声明使用关键字 `extension`，遵循如下格式： - -```swift -extension 类型名称: 采纳的协议 { - 声明语句 -} -``` - -```swift -extension 类型名称 where 要求 { - 声明语句 -} -``` - -扩展声明体可包含零个或多个声明语句。这些声明语句可以包括计算型属性、计算型类型属性、实例方法、类型方法、构造器、下标声明，甚至是类、结构体和枚举声明。扩展声明不能包含析构器、协议声明、存储型属性、属性观察器或其他扩展声明。关于扩展声明的详细讨论，以及各种扩展声明的例子，请参阅 [扩展](../chapter2/21_Extensions.md)。 - -如果类型为类，结构体，或枚举类型，则扩展声明会扩展相应的类型。如果类型为协议类型，则扩展声明会扩展所有遵守这个协议的类型。在扩展的协议体中声明语句不能使用 `final` 标识符。 - -扩展声明可以为现存的类、结构体、枚举添加协议一致性，但是不能为类添加超类，因此在扩展声明的类型名称的冒号后面仅能指定一个协议列表。 - -现存类型的属性、方法、构造器不能在扩展中被重写。 - -扩展声明可以包含构造器声明。这意味着，如果被扩展的类型在其他模块中定义，构造器声明必须委托另一个在那个模块中声明的构造器，以确保该类型能被正确地初始化。 - - -> 扩展声明语法 -> -> *扩展声明* → [特性](06_Attributes.md#type_attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **extension** [*类型标识符*](03_Types.md#type-identifier) [*类型-继承-子句*](03_Types.md#type-inheritance-clause)可选 [*扩展主体*](#extension-body) -> -> *扩展声明* → [特性](06_Attributes.md#type_attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **extension** [*类型标识符*](03_Types.md#type-identifier) [*泛型-where-子句*](03_Types.md#type-inheritance-clause) [*扩展主体*](#extension-body) -> *扩展主体* → **{** [*多条声明*](#declarations)可选 **}** -> *多条声明* → [单条声明](#subscript_declaration) [多条声明](#declarations) 可选 -> *单条声明* → [声明语句](#declarations) | [编译器-控制-语句](10_Statements.md#compiler-control-statement) - - -## 下标声明 - -*下标声明 (subscript declaration)* 用于为特定类型的对象添加下标支持，通常也用于为访问集合、列表和序列中的元素提供语法便利。下标声明使用关键字 `subscript`，形式如下： - -```swift -subscript (参数列表) -> 返回类型 { - get { - 语句 - } - set(setter 名称) { - 语句 - } -} -``` - -下标声明只能出现在类、结构体、枚举、扩展和协议的声明中。 - -参数列表指定一个或多个用于在相关类型的下标表达式中访问元素的索引（例如，表达式 `object[i]` 中的 `i`）。索引可以是任意类型，但是必须包含类型标注。返回类型指定了被访问的元素的类型。 - -和计算型属性一样，下标声明支持对元素的读写操作。getter 用于读取值，setter 用于写入值。setter 子句是可选的，当仅需要一个 getter 子句时，可以将二者都忽略，直接返回请求的值即可。但是，如果提供了 setter 子句，就必须提供 getter 子句。 - -圆括号以及其中的 setter 名称是可选的。如果提供了 setter 名称，它会作为 setter 的参数名称。如果不提供 setter 名称，那么 setter 的参数名称默认是 `value`。setter 名称的类型必须与返回类型相同。 - -可以重载下标，只要参数列表或返回类型不同即可。还可以重写继承自超类的下标，此时必须使用 `override` 声明修饰符声明被重写的下标。 - -同样可以在协议声明中声明下标，正如 [协议下标声明](#protocol_subscript_declaration) 中所述。 - -更多关于下标的信息和例子，请参阅 [下标](../chapter2/12_Subscripts.md)。 - - -> 下标声明语法 -> -> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*代码块*](#code-block) -> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*getter-setter 代码块*](#getter-setter-block) -> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) -> -> *下标头* → [*特性列表*](06_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **subscript** [*参数子句*](#parameter-clause) -> -> *下标结果* → **->** [*特性列表*](06_Attributes.md#attributes)可选 [*类型*](03_Types.md#type) - - -## 运算符声明 - -*运算符声明 (operator declaration)* 会向程序中引入中缀、前缀或后缀运算符，使用关键字 `operator` 来声明。 - -可以声明三种不同的缀性：中缀、前缀和后缀。运算符的缀性指定了运算符与其运算对象的相对位置。 - -运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在 `operator` 关键字之前添加声明修饰符 `infix`，`prefix` 或 `postfix` 来指定。每种形式中，运算符的名字只能包含 [运算符](02_Lexical_Structure.md#operators) 中定义的运算符字符。 - -下面的形式声明了一个新的中缀运算符： - -```swift -infix operator 运算符名称: 优先级组 -``` - -中缀运算符是二元运算符，置于两个运算对象之间，例如加法运算符（`+`）位于表达式 `1 + 2` 的中间。 - -中缀运算符可以选择指定优先级组。如果没有为运算符设置优先级组，Swift 会设置默认优先级组 `DefaultPrecedence`,它的优先级比三目优先级 `TernaryPrecedence` 要高，更多内容参考[*优先级组声明*](#precedence_group_declaration_modifiers) - -下面的形式声明了一个新的前缀运算符： - -```swift -prefix operator 运算符名称 {} -``` - -出现在运算对象前边的前缀运算符是一元运算符，例如表达式 `!a` 中的前缀非运算符（`!`）。 - -前缀运算符的声明中不指定优先级，而且前缀运算符是非结合的。 - -下面的形式声明了一个新的后缀运算符： - -```swift -postfix operator 运算符名称 {} -``` - -紧跟在运算对象后边的后缀运算符是一元运算符，例如表达式 `a!` 中的后缀强制解包运算符（`!`）。 - -和前缀运算符一样，后缀运算符的声明中不指定优先级，而且后缀运算符是非结合的。 - -声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../chapter2/25_Advanced_Operators.md#custom_operators)。 - - -> 运算符声明语法 - - -> *运算符声明* → [*前缀运算符声明*](#prefix-operator-declaration) | [*后缀运算符声明*](#postfix-operator-declaration) | [*中缀运算符声明*](#infix-operator-declaration) - - -> *前缀运算符声明* → **prefix** **运算符** [*运算符*](02_Lexical_Structure.md#operator) **{** **}** -> -> *后缀运算符声明* → **postfix** **运算符** [*运算符*](02_Lexical_Structure.md#operator) **{** **}** -> -> *中缀运算符声明* → **infix** **运算符** [*运算符*](02_Lexical_Structure.md#operator) **{** [*中缀运算符属性*](#infix-operator-attributes)可选 **}** - - -> *中缀运算符组* → [*优先级组名称*](#precedence-group-name) - - - -## 优先级组声明 - -*优先级组声明 (A precedence group declaration)* 会向程序的中缀运算符引入一个全新的优先级组。当没有用圆括号分组时，运算符优先级反应了运算符与它的操作数的关系的紧密程度。 -优先级组的声明如下所示: - -```swift -precedencegroup 优先级组名称{ - higherThan: 较低优先级组的名称 - lowerThan: 较高优先级组的名称 - associativity: 结合性 - assignment: 赋值性 -} -``` - -较低优先级组和较高优先级组的名称说明了新建的优先级组是依赖于现存的优先级组的。`lowerThan` 优先级组的属性只可以引用当前模块外的优先级组。当两个运算符为同一个操作数竞争时，比如表达式 `2 + 3 * 5`,优先级更高的运算符将优先参与运算。 - -> 注意 -> -> 使用较低和较高优先级组相互联系的优先级组必须保持单一层次关系，但它们不必是线性关系。这意味着优先级组也许会有未定义的相关优先级。这些优先级组的运算符在没有用圆括号分组的情况下是不能紧邻着使用的。 - -Swift 定义了大量的优先级组来与标准库的运算符配合使用，例如相加(`+`)和相减(`-`)属于 `AdditionPrecedence` 组，相乘(`*`)和相除(`/`)属于 `MultiplicationPrecedence` 组，详细关于 Swift 标准库中一系列运算符和优先级组内容，参阅[Swift 标准库操作符参考](https://developer.apple.com/reference/swift/1851035-swift_standard_library_operators)。 - -运算符的结合性表示在没有圆括号分组的情况下，同样优先级的一系列运算符是如何被分组的。你可以指定运算符的结合性通过上下文关键字 `left`、`right` 或者 `none`,如果没有指定结合性，默认是 `none` 关键字。左关联性的运算符是从左至右分组的，例如，相减操作符(-)是左关联性的，所以表达式 `4 - 5 - 6` 被分组为 `(4 - 5) - 6`,得出结果-7。右关联性的运算符是从右往左分组的，指定为 `none` 结合性的运算符就没有结合性。同样优先级没有结合性的运算符不能相邻出现，例如 `<` 运算符是 `none` 结合性，那表示 `1 < 2 < 3` 就不是一个有效表达式。 - -优先级组的赋值性表示在包含可选链操作时的运算符优先级。当设为 true 时，与优先级组对应的运算符在可选链操作中使用和标准库中赋值运算符同样的分组规则，当设为 false 或者不设置，该优先级组的运算符与不赋值的运算符遵循同样的可选链规则。 - - -> 优先级组声明语法 - - -> *优先级组声明* → **precedence**[*优先级组名称*](#precedence-group-name){[*多优先级组属性*](#precedence-group-attributes)可选 } - -> *优先级组属性* → [*优先级组属性*](#precedence-group-attribute)[*多优先级组属性*](#precedence-group-attributes)可选 **{** **}** - -> *优先级组属性* → [*优先级组关系*](#precedence-group-relation) -> *优先级组属性* → [*优先级组赋值性*](#precedence-group-assignment) -> *优先级组属性* → [*优先级组相关性*](#precedence-group-associativity) -> -> *优先级组关系* → **higherThan:**[*多优先级组名称*](#precedence-group-names) -> *优先级组关系* → **lowerThan:**[*多优先级组名称*](#precedence-group-names) -> -> *优先级组赋值* → **assignment:**[*布尔字面值*](02_Lexical_Structure.md#boolean-literal) - -> *优先级组结合性* → **associativity:left** -> *优先级组结合性* → **associativity:right** -> *优先级组结合性* → **associativity:none** - -> *多优先级组名称* → [*优先级组名称*](#precedence-group-name) | [*优先级组名称*](#precedence-group-name) | [*优先级组名称*](#precedence-group-name) - -> *优先级组名称* →[*标识符*](02_Lexical_Structure.md#identifier) - -## 声明修饰符 - -声明修饰符都是关键字或上下文相关的关键字，可以修改一个声明的行为或者含义。可以在声明的特性（如果存在）和引入该声明的关键字之间，利用声明修饰符的关键字或上下文相关的关键字指定一个声明修饰符。 - -`dynamic` - -该修饰符用于修饰任何兼容 Objective-C 的类的成员。访问被 `dynamic` 修饰符标记的类成员将总是由 Objective-C 运行时系统进行动态派发，而不会由编译器进行内联或消虚拟化。 - -因为被标记 `dynamic` 修饰符的类成员会由 Objective-C 运行时系统进行动态派发，所以它们会被隐式标记 `objc` 特性。 - -`final` - -该修饰符用于修饰类或类中的属性、方法以及下标。如果用它修饰一个类，那么这个类不能被继承。如果用它修饰类中的属性、方法或下标，那么它们不能在子类中被重写。 - -`lazy` - -该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在它被第一次访问时。关于如何使用 `lazy` 修饰符的例子，请参阅 [惰性存储型属性](../chapter2/10_Properties.md#lazy_stored_properties)。 - -`optional` - -该修饰符用于修饰协议中的属性、方法以及下标成员，表示符合类型可以不实现这些成员要求。 - -只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../chapter2/22_Protocols.md#optional_protocol_requirements)。 - -`required` - -该修饰符用于修饰类的指定构造器或便利构造器，表示该类所有的子类都必须实现该构造器。在子类实现该构造器时，必须同样使用 `required` 修饰符修饰该构造器。 - -`weak` - -该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../chapter2/16_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 - - -### 访问控制级别 - -Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../chapter2/24_Access_Control.md) 中有详细讨论。 - -`public` - -该修饰符表示声明可被同模块的代码访问，只要其他模块导入了声明所在的模块，也可以进行访问。 - -`internal` - -该修饰符表示声明只能被同模块的代码访问。默认情况下，绝大多数声明会被隐式标记 `internal` 访问级别修饰符。 - -`private` - -该修饰符表示声明只能被所在源文件的代码访问。 - -以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../chapter2/24_Access_Control.md#getters_and_setters) 中所讨论的。 - - -> 声明修饰符的语法 - - -> *声明修饰符* → **class** | **convenience**| **dynamic** | **final** | **infix** | **lazy** | **mutating** | **nonmutating** | **optional** | **override** | **postfix** | **prefix** | **required** | **static** | **unowned** | **unowned ( safe )** | **unowned ( unsafe )** | **weak** -> 声明修饰符 → [*访问级别修饰符*](#access-level-modifier) -> -> *声明修饰符列表* → [*声明修饰符*](#declaration-modifier) [*声明修饰符列表*](#declaration-modifiers)可选 - - -> 访问级别修饰符 → **internal** | **internal ( set )** -> 访问级别修饰符 → **private** | **private ( set )** -> 访问级别修饰符 → **public** | **public ( set )** + +# 声明（Declarations） +----------------- + +> 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) + +> 2.0 +> 翻译+校对：[Lenhoon](https://github.com/Lenhoon), +> [BridgeQ](https://github.com/WXGBridgeQ) + +> 2.1 +> 翻译：[mmoaay](https://github.com/mmoaay), [shanks](http://codebuild.me) +> 校对：[shanks](http://codebuild.me) + +> 2.2 +> 翻译：[星夜暮晨](https://github.com/SemperIdem) + +> 3.0 +> 翻译：[chenmingjia](https://github.com/chenmingjia) + +> 4.1 +> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) + +本页包含内容： + +- [顶级代码](#top-level_code) +- [代码块](#code_blocks) +- [导入声明](#import_declaration) +- [常量声明](#constant_declaration) +- [变量声明](#variable_declaration) + - [存储型变量和存储型变量属性](#stored_variables_and_stored_variable_properties) + - [计算型变量和计算型属性](#computed_variables_and_computed_properties) + - [存储型变量和属性的观察器](#stored_variable_observers_and_property_observers) + - [类型变量属性](#type_variable_properties) +- [类型别名声明](#type_alias_declaration) +- [函数声明](#function_declaration) + - [参数名](#parameter_names) + - [输入输出参数](#in-out_parameters) + - [特殊参数](#special_kinds_of_parameters) + - [特殊方法](#special_kinds_of_methods) + - [抛出错误的函数和方法](#throwing_functions_and_methods) + - [重抛错误的函数和方法](#rethrowing_functions_and_methods) +- [枚举声明](#enumeration_declaration) + - [任意类型的枚举用例](#enumerations_with_cases_of_any_type) + - [递归枚举](#enumerations_with_indirection) + - [拥有原始值的枚举用例](#enumerations_with_cases_of_a_raw-value_type) + - [访问枚举用例](#accessing_enumeration_cases) +- [结构体声明](#structure_declaration) +- [类声明](#class_declaration) +- [协议声明](#protocol_declaration) + - [协议属性声明](#protocol_property_declaration) + - [协议方法声明](#protocol_method_declaration) + - [协议构造器声明](#protocol_initializer_declaration) + - [协议下标声明](#protocol_subscript_declaration) + - [协议关联类型声明](#protocol_associated_type_declaration) +- [构造器声明](#initializer_declaration) + - [可失败构造器](#failable_initializers) +- [析构器声明](#deinitializer_declaration) +- [扩展声明](#extension_declaration) +- [下标声明](#subscript_declaration) +- [运算符声明](#operator_declaration) +- [声明修饰符](#declaration_modifiers) + - [访问控制级别](#access_control_levels) + +*声明 (declaration)* 用以向程序里引入新的名字或者结构。举例来说，可以使用声明来引入函数和方法，变量和常量，或者定义新的具有命名的枚举、结构、类和协议类型。还可以使用声明来扩展一个既有的具有命名的类型的行为，或者在程序里引入在其它地方声明的符号。 + +在 Swift 中，大多数声明在某种意义上讲也是定义，因为声明往往伴随着实现或初始化。由于协议并不提供实现，大多数协议成员仅仅只是声明而已。为了方便起见，也是因为这些区别在 Swift 中并不是很重要，“声明”这个术语同时包含了声明和定义两种含义。 + +> 声明语法 +> +> *声明* → [*导入声明*](#import-declaration) +> *声明* → [*常量声明*](#constant-declaration) +> *声明* → [*变量声明*](#variable-declaration) +> *声明* → [*类型别名声明*](#typealias-declaration) +> *声明* → [*函数声明*](#function-declaration) +> *声明* → [*枚举声明*](#enum-declaration) +> *声明* → [*结构体声明*](#struct-declaration) +> *声明* → [*类声明*](#class-declaration) +> *声明* → [*协议声明*](#protocol-declaration) +> *声明* → [*构造器声明*](#initializer-declaration) +> *声明* → [*析构器声明*](#deinitializer-declaration) +> *声明* → [*扩展声明*](#extension-declaration) +> *声明* → [*下标声明*](#subscript-declaration) +> *声明* → [*运算符声明*](#operator-declaration) +> +> *多条声明* → [*声明*](#declaration) [*多条声明*](#declarations)可选 + + +## 顶级代码 + +Swift 的源文件中的顶级代码 (top-level code) 由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access_control_levels)。 + +> 顶级声明语法 +> +> *顶级声明* → [*多条语句*](10_Statements.html#statements)可选 + + +## 代码块 + +*代码块 (code block)* 可以将一些声明和控制结构组织在一起。它有如下的形式： + +```swift +{ + 语句 +} +``` + +代码块中的“语句”包括声明、表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。 + +> 代码块语法 +> +> +> *代码块* → **{** [*多条语句*](10_Statements.html#statements)可选 **}** + + +## 导入声明 + +*导入声明 (import declaration)* 让你可以使用在其他文件中声明的内容。导入语句的基本形式是导入整个模块，它由 `import` 关键字和紧随其后的模块名组成： + +```swift +import 模块 +``` + +可以对导入操作提供更细致的控制，如指定一个特殊的子模块或者指定一个模块或子模块中的某个声明。提供了这些限制后，在当前作用域中，只有被导入的符号是可用的，而不是整个模块中的所有声明。 + +```swift +import 导入类型 模块.符号名 +import 模块.子模块 +``` + + +> 导入声明语法 +> +> +> *导入声明* → [*特性列表*](06_Attributes.html#attributes)可选 **import** [*导入类型*](#import-kind)可选 [*导入路径*](#import-path) +> +> +> *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **let** | **var** | **func** +> +> *导入路径* → [*导入路径标识符*](#import-path-identifier) | [*导入路径标识符*](#import-path-identifier) **.** [*导入路径*](#import-path) +> +> *导入路径标识符* → [*标识符*](02_Lexical_Structure.html#identifier) | [*运算符*](02_Lexical_Structure.html#operator) + + +## 常量声明 + +*常量声明 (constant declaration)* 可以在程序中引入一个具有命名的常量。常量以关键字 `let` 来声明，遵循如下格式： + +```swift +let 常量名称: 类型 = 表达式 +``` + +常量声明在“常量名称”和用于初始化的“表达式”的值之间定义了一种不可变的绑定关系；当常量的值被设定之后，它就无法被更改。这意味着，如果常量以类对象来初始化，对象本身的内容是可以改变的，但是常量和该对象之间的绑定关系是不能改变的。 + +当一个常量被声明为全局常量时，它必须拥有一个初始值。在类或者结构中声明一个常量时，它将作为*常量属性 (constant property)*。常量声明不能是计算型属性，因此也没有存取方法。 + +如果常量名称是元组形式，元组中每一项的名称都会和初始化表达式中对应的值进行绑定。 + +```swift +let (firstNumber, secondNumber) = (10, 42) +``` + +在上例中，`firstNumber` 是一个值为 `10` 的常量，`secnodeName` 是一个值为 `42` 的常量。所有常量都可以独立地使用： + +```swift +print("The first number is \(firstNumber).") +// 打印 “The first number is 10.” +print("The second number is \(secondNumber).") +// 打印 “The second number is 42.” +``` + +当常量名称的类型 (`:` 类型) 可以被推断出时，类型标注在常量声明中是可选的，正如 [类型推断](03_Types.html#type_inference) 中所描述的。 + +声明一个常量类型属性要使用 `static` 声明修饰符。类型属性在 [类型属性](../chapter2/10_Properties.html#type_properties)中有介绍。 + +如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../chapter2/01_The_Basics.html#constants_and_variables) 和 [存储属性](../chapter2/10_Properties.html#stored_properties)。 + + +> 常量声明语法 +> +> +> *常量声明* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **let** [*模式构造器列表*](pattern-initializer-list) +> +> *模式构造器列表* → [*模式构造器*](#pattern-initializer) | [*模式构造器*](#pattern-initializer) **,** [*模式构造器列表*](#pattern-initializer-list) +> +> *模式构造器* → [*模式*](07_Patterns.html#pattern) [*构造器*](#initializer)可选 +> +> *构造器* → **=** [*表达式*](04_Expressions.html#expression) + + +## 变量声明 + +*变量声明 (variable declaration)* 可以在程序中引入一个具有命名的变量，它以关键字 `var` 来声明。 + +变量声明有几种不同的形式，可以声明不同种类的命名值和可变值，如存储型和计算型变量和属性，属性观察器，以及静态变量属性。所使用的声明形式取决于变量声明的适用范围和打算声明的变量类型。 + +> 注意 +> +> 也可以在协议声明中声明属性，详情请参阅 [协议属性声明](#protocol_property_declaration)。 + +可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../chapter2/13_Inheritance.html#overriding)。 + + +### 存储型变量和存储型变量属性 + +使用如下形式声明一个存储型变量或存储型变量属性： + +```swift +var 变量名称: 类型 = 表达式 +``` + +可以在全局范围，函数内部，或者在类和结构的声明中使用这种形式来声明一个变量。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个存储型变量。当它在类或者结构中被声明时，它代表一个*存储型变量属性 (stored variable property)*。 + +用于初始化的表达式不可以在协议的声明中出现，在其他情况下，该表达式是可选的。如果没有初始化表达式，那么变量声明必须包含类型标注 (`:` *type*)。 + +如同常量声明，如果变量名称是元组形式，元组中每一项的名称都会和初始化表达式中对应的值进行绑定。 + +正如名字所示，存储型变量和存储型变量属性的值会存储在内存中。 + + +### 计算型变量和计算型属性 + +使用如下形式声明一个计算型变量或计算型属性： + +```swift +var 变量名称: 类型 { + get { + 语句 + } + set(setter 名称) { + 语句 + } +} +``` + +可以在全局范围、函数内部，以及类、结构、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性 (computed property)*。 + +getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../chapter2/10_Properties.html#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 + +setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../chapter2/10_Properties.html#shorthand_setter_declaration) 中描述的那样。 + +与存储型变量和存储型属性不同，计算型变量和计算型属性的值不存储在内存中。 + +要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../chapter2/10_Properties.html#computed_properties)。 + + +### 存储型变量和属性的观察器 + +可以在声明存储型变量或属性时提供 `willSet` 和 `didSet` 观察器。一个包含观察器的存储型变量或属性以如下形式声明： + +```swift +var 变量名称: 类型 = 表达式 { + willSet(setter 名称) { + 语句 + } + didSet(setter 名称) { + 语句 + } +} +``` + +可以在全局范围、函数内部，或者类、结构的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，观察器表示一个存储型变量观察器。当它在类和结构的声明中被声明时，观察器表示一个属性观察器。 + +可以为任何存储型属性添加观察器。也可以通过重写父类属性的方式为任何继承的属性（无论是存储型还是计算型的）添加观察器 +，正如 [重写属性观察器](../chapter2/13_Inheritance.html#overriding_property_observers) 中所描述的。 + +用于初始化的表达式在类或者结构的声明中是可选的，但是在其他声明中则是必须的。如果可以从初始化表达式中推断出类型信息，那么可以不提供类型标注。 + +当变量或属性的值被改变时，`willSet` 和 `didSet` 观察器提供了一种观察方法。观察器会在变量的值被改变时调用，但不会在初始化时被调用。 + +`willSet` 观察器只在变量或属性的值被改变之前调用。新的值作为一个常量传入 `willSet` 观察器，因此不可以在 `willSet` 中改变它。`didSet` 观察器在变量或属性的值被改变后立即调用。和 `willSet` 观察器相反，为了方便获取旧值，旧值会传入 `didSet` 观察器。这意味着，如果在变量或属性的 `didiset` 观察器中设置值，设置的新值会取代刚刚在 `willSet` 观察器中传入的那个值。 + +在 `willSet` 和 `didSet` 中，圆括号以及其中的 setter 名称是可选的。如果提供了一个 setter 名称，它就会作为 `willSet` 和 `didSet` 的参数被使用。如果不提供 setter 名称，`willSet` 观察器的默认参数名为 `newValue`，`didSet` 观察器的默认参数名为 `oldValue`。 + +提供了 `willSet` 时，`didSet` 是可选的。同样的，提供了 `didSet` 时，`willSet` 则是可选的。 + +要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../chapter2/10_Properties.html#property_observers)。 + + +### 类型变量属性 + +要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.html#type_properties) 章节有详细讨论。 + +> 注意 +> +> 在一个类声明中，使用关键字 `static` 与同时使用 `class` 和 `final` 去标记一个声明的效果相同。 + + +> 变量声明语法 +> + +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*模式构造器列表*](#pattern-initializer-list) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*代码块*](#code-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*getter-setter 代码块*](#getter-setter-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*构造器*](#initializer) [*willSet-didSet 代码块*](#willSet-didSet-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*构造器*](#initializer)可选 [*willSet-didSet 代码块*](#willSet-didSet-block) + + +> *变量声明头* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **var** +> +> *变量名称* → [*标识符*](02_Lexical_Structure.html#identifier) + + +> *getter-setter 代码块* → [*代码块*](#code-block) +> *getter-setter 代码块* → **{** [*getter 子句*](#getter-clause) [*setter 子句*](#setter-clause)可选 **}** +> *getter-setter 代码块* → **{** [*setter 子句*](#setter-clause) [*getter 子句*](#getter-clause) **}** +> +> *getter 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **get** [*代码块*](#code-block) +> +> *setter 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **set** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) +> +> *setter 名称* → **(** [*标识符*](02_Lexical_Structure.html#identifier) **)** + + +> *getter-setter 关键字代码块* → **{** [*getter 关键字子句*](#getter-keyword-clause) [*setter 关键字子句*](#setter-keyword-clause)可选 **}** +> *getter-setter 关键字代码块* → **{** [*setter 关键字子句*](#setter-keyword-clause) [*getter 关键字子句*](#getter-keyword-clause) **}** +> +> *getter 关键字子句* → [*特性列表*](06_Attributes.html#attributes)可选 **get** +> +> *setter 关键字子句* → [*特性列表*](06_Attributes.html#attributes)可选 **set** + + +> *willSet-didSet 代码块* → **{** [*willSet 子句*](#willSet-clause) [*didSet 子句*](#didSet-clause)可选 **}** +> *willSet-didSet 代码块* → **{** [*didSet 子句*](#didSet-clause) [*willSet 子句*](#willSet-clause)可选 **}** +> +> *willSet 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **willSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) +> +> *didSet 子句* → [*特性列表*](06_Attributes.html#attributes)可选 **didSet** [*setter 名称*](#setter-name)可选 [*代码块*](#code-block) + + +## 类型别名声明 + +*类型别名 (type alias)* 声明可以在程序中为一个既有类型声明一个别名。类型别名声明语句使用关键字 `typealias` 声明，遵循如下的形式： + +```swift +typealias 类型别名 = 现存类型 +``` + +当声明一个类型的别名后，可以在程序的任何地方使用“别名”来代替现有类型。现有类型可以是具有命名的类型或者混合类型。类型别名不产生新的类型，它只是使用别名来引用现有类型。 +类型别名声明可以通过泛型参数来给一个现有泛型类型提供名称。类型别名为现有类型的一部分或者全部泛型参数提供具体类型。例如: + +```swift +typealias StringDictionary = Dictionary + +// 下列两个字典拥有同样的类型 +var dictionary1: StringDictionary = [:] +var dictionary2: Dictionary = [:] +``` + +当一个类型别名带着泛型参数一起被声明时，这些参数的约束必须与现有参数的约束完全匹配。例如: + +```swift +typealias DictionaryOfInts = Dictionary +``` + +因为类型别名可以和现有类型相互交换使用，类型别名不可以引入额外的类型约束。 +在协议声明中，类型别名可以为那些经常使用的类型提供一个更短更方便的名称，例如: + +```swift +protocol Sequence { + associatedtype Iterator: IteratorProtocol + typealias Element = Iterator.Element +} + +func sum(_ sequence: T) -> Int where T.Element == Int { + // ... +} +``` + +假如没有类型别名，sum 函数将必须引用关联类型通过 T.Iterator.Element 的形式来替代 T.Element。 + +另请参阅 [协议关联类型声明](#protocol_associated_type_declaration)。 + + +> 类型别名声明语法 +> +> +> *类型别名声明* → [*类型别名头*](#typealias-head) [*类型别名赋值*](#typealias-assignment) +> +> *类型别名头* → [*特性列表*](06_Attributes.html#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 **typealias** [*类型别名名称*](#typealias-name) +> +> *类型别名名称* → [*标识符*](02_Lexical_Structure.html#identifier) +> +> *类型别名赋值* → **=** [*类型*](03_Types.html#type) + + +## 函数声明 + +使用*函数声明 (function declaration)* 在程序中引入新的函数或者方法。在类、结构体、枚举，或者协议中声明的函数会作为方法。函数声明使用关键字 `func`，遵循如下的形式： + +```swift +func 函数名称(参数列表) -> 返回类型 { + 语句 +} +``` + +如果函数返回 `Void` 类型，返回类型可以省略，如下所示： + +```swift +func 函数名称(参数列表) { + 语句 +} +``` + +每个参数的类型都要标明，因为它们不能被推断出来。如果您在某个参数类型前面加上了 `inout`，那么这个参数就可以在这个函数作用域当中被修改。更多关于 `inout` 参数的讨论，请参阅 [输入输出参数](#in-out_parameters)。 + +函数可以使用元组类型作为返回类型来返回多个值。 + +函数定义可以出现在另一个函数声明内。这种函数被称作*嵌套函数 (nested function)*。更多关于嵌套函数的讨论，请参阅 [嵌套函数](../chapter2/06_Functions.html#Nested_Functions)。 + + +### 参数名 + +函数的参数列表由一个或多个函数参数组成，参数间以逗号分隔。函数调用时的参数顺序必须和函数声明时的参数顺序一致。最简单的参数列表有着如下的形式： + +`参数名称`: `参数类型` + +一个参数有一个内部名称，这个内部名称可以在函数体内被使用。还有一个外部名称，当调用函数时这个外部名称被作为实参的标签来使用。默认情况下，第一个参数的外部名称会被省略，第二个和之后的参数使用它们的内部名称作为它们的外部名称。例如： + +```swift +func f(x: Int, y: Int) -> Int { return x + y } +f(1, y: 2) // 参数 y 有标签，参数 x 则没有 +``` + +可以按照如下两种形式之一，重写参数名称的默认行为： + +`外部参数名称` `内部参数名称`: `参数类型` +_ `内部参数名称`: `参数类型` + +在内部参数名称前的名称会作为这个参数的外部名称，这个名称可以和内部参数的名称不同。外部参数名称在函数被调用时必须被使用，即对应的参数在方法或函数被调用时必须有外部名。 + +内部参数名称前的下划线（`_`）可使该参数在函数被调用时没有名称。在函数或方法调用时，对应的参数必须没有名字。 + +```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 则没有 +``` + + +### 输入输出参数 + +输入输出参数被传递时遵循如下规则： + +1. 函数调用时，参数的值被拷贝。 +2. 函数体内部，拷贝后的值被修改。 +3. 函数返回后，拷贝后的值被赋值给原参数。 + +这种行为被称为*拷入拷出 (copy-in copy-out)* 或*值结果调用 (call by value result)*。例如，当一个计算型属性或者一个具有属性观察器的属性被用作函数的输入输出参数时，其 getter 会在函数调用时被调用，而其 setter 会在函数返回时被调用。 + +作为一种优化手段，当参数值存储在内存中的物理地址时，在函数体内部和外部均会使用同一内存位置。这种优化行为被称为*引用调用 (call by reference)*，它满足了拷入拷出模式的所有要求，且消除了复制带来的开销。在代码中，要规范使用拷入拷出模式，不要依赖于引用调用。 + +不要使用传递给输入输出参数的值，即使原始值在当前作用域中依然可用。当函数返回时，你对原始值所做的更改会被拷贝的值所覆盖。不要依赖于引用调用的优化机制来试图避免这种覆盖。 + +不能将同一个值传递给多个输入输出参数，因为这种情况下的拷贝与覆盖行为的顺序是不确定的，因此原始值的最终值也将无法确定。例如： + +```swift +var x = 10 +func f(inout a: Int, inout _ b: Int) { + a += 1 + b += 10 +} +f(&x, &x) // 编译报错 error: inout arguments are not allowed to alias each other +``` + +如果嵌套函数在外层函数返回后才调用，嵌套函数对输入输出参数造成的任何改变将不会影响到原始值。例如： + +```swift +func outer(inout a: Int) -> () -> Void { + func inner() { + a += 1 + } + return inner +} + +var x = 10 +let f = outer(&x) +f() +print(x) +// 打印 “10” +``` + +调用嵌套函数 `inner()` 对 `a` 递增后，`x` 的值并未发生改变，因为 `inner()` 在外层函数 `outer()` 返回后才被调用。若要改变 `x` 的值，必须在 `outer()` 返回前调用 `inner()`。 + +关于输入输出参数的详细讨论，请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters)。 + + +### 特殊参数 + +参数可以被忽略，数量可以不固定，还可以为其提供默认值，使用形式如下： + +```swift +_ : 参数类型 +参数名称: 参数类型... +参数名称: 参数类型 = 默认参数值 +``` + +以下划线（`_`）命名的参数会被显式忽略，无法在函数体内使用。 + +一个参数的基本类型名称如果紧跟着三个点（`...`），会被视为可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数会作为包含该参数类型元素的数组处理。举例来讲，可变参数 `Int...` 会作为 `[Int]` 来处理。关于使用可变参数的例子，请参阅 [可变参数](../chapter2/06_Functions.html#variadic_parameters)。 + +如果在参数类型后面有一个以等号（`=`）连接的表达式，该参数会拥有默认值，即给定表达式的值。当函数被调用时，给定的表达式会被求值。如果参数在函数调用时被省略了，就会使用其默认值。 + +```swift +func f(x: Int = 42) -> Int { return x } +f() // 有效，使用默认值 +f(7) // 有效，提供了值 +f(x: 7) // 无效，该参数没有外部名称 +``` + + +### 特殊方法 + +枚举或结构体的方法如果会修改 `self`，则必须以 `mutating` 声明修饰符标记。 + +子类重写超类中的方法必须以 `override` 声明修饰符标记。重写方法时不使用 `override` 修饰符，或者被 `override` 修饰符修饰的方法并未对超类方法构成重写，都会导致编译错误。 + +枚举或者结构体中的类型方法，要以 `static` 声明修饰符标记，而对于类中的类型方法，除了使用 `static`，还可使用 `class` 声明修饰符标记。 + + +### 抛出错误的函数和方法 + +可以抛出错误的函数或方法必须使用 `throws` 关键字标记。这类函数和方法被称为抛出函数和抛出方法。它们有着下面的形式: + +```swift +func 函数名称(参数列表) throws -> 返回类型 { + 语句 +} +``` + +抛出函数或抛出方法的调用必须包裹在 `try` 或者 `try!` 表达式中（也就是说，在作用域内使用 `try` 或者 `try!` 运算符）。 + +`throws` 关键字是函数的类型的一部分，非抛出函数是抛出函数的子类型。所以，可以在使用抛出函数的地方使用非抛出函数。 + +不能仅基于函数能否抛出错误来进行函数重载。也就是说，可以基于函数的函数类型的参数能否抛出错误来进行函数重载。 + +抛出方法不能重写非抛出方法，而且抛出方法不能满足协议对于非抛出方法的要求。也就是说，非抛出方法可以重写抛出方法，而且非抛出方法可以满足协议对于抛出方法的要求。 + + +### 重抛错误的函数和方法 + +函数或方法可以使用 `rethrows` 关键字来声明，从而表明仅当该函数或方法的一个函数类型的参数抛出错误时，该函数或方法才抛出错误。这类函数和方法被称为重抛函数和重抛方法。重新抛出错误的函数或方法必须至少有一个参数的类型为抛出函数。 + +```swift +func someFunction(callback: () throws -> Void) rethrows { + try callback() +} +``` + +重抛函数或者方法不能够从自身直接抛出任何错误，这意味着它不能够包含 `throw` 语句。它只能够传递作为参数的抛出函数所抛出的错误。例如，在 `do-catch` 代码块中调用抛出函数，并在 `catch` 子句中抛出其它错误都是不允许的。 + +抛出方法不能重写重抛方法，而且抛出方法不能满足协议对于重抛方法的要求。也就是说，重抛方法可以重写抛出方法，而且重抛方法可以满足协议对于抛出方法的要求。 + + +### 永不返回的函数 + +Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它的调用者。`Never` 返回类型的函数或方法可以称为不归，不归函数、方法要么引发不可恢复的错误，要么永远不停地运作，这会使调用后本应执行得代码就不再执行了。但即使是不归函数、方法，抛错函数和重抛出函数也可以将程序控制转移到合适的 `catch` 代码块。 + +不归函数、方法可以在 guard 语句的 else 字句中调用，具体讨论在[*Guard 语句*](10_Statements.html#guard_statements)。 +你可以重载一个不归方法，但是新的方法必须保持原有的返回类型和没有返回的行为。 + + +> 函数声明语法 +> + +> *函数声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [*函数签名*](#function-signature) [*函数体*](#function-body)可选 + + +> *函数头* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **func** +> +> *函数名* → [*标识符*](02_Lexical_Structure.html#identifier) | [*运算符*](02_Lexical_Structure.html#operator) + + +> *函数签名* → [*参数子句列表*](#parameter-clauses) **throws**可选 [*函数结果*](#function-result)可选 +> *函数签名* → [*参数子句列表*](#parameter-clauses) **rethrows** [*函数结果*](#function-result)可选 +> +> *函数结果* → **->** [*特性列表*](06_Attributes.html#attributes)可选 [*类型*](03_Types.html#type) +> +> *函数体* → [*代码块*](#code-block) + + +> *参数子句列表* → [*参数子句*](#parameter-clause) [*参数子句列表*](#parameter-clauses)可选 +> +> *参数子句* → **(** **)** | **(** [*参数列表*](#parameter-list) **)** +> +> *参数列表* → [*参数*](#parameter) | [*参数*](#parameter) **,** [*参数列表*](#parameter-list) +> +> *参数* → **let**可选 [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.html#type-annotation) [*默认参数子句*](#default-argument-clause)可选 +> *参数* → **inout** [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.html#type-annotation) +> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型标注*](03_Types.html#type-annotation) **...** +> +> *外部参数名* → [*标识符*](02_Lexical_Structure.html#identifier) | **_** +> +> *内部参数名* → [*标识符*](02_Lexical_Structure.html#identifier) | **_** +> +> *默认参数子句* → **=** [*表达式*](04_Expressions.html#expression) + + +## 枚举声明 + +在程序中使用*枚举声明 (enumeration declaration)* 来引入一个枚举类型。 + +枚举声明有两种基本形式，使用关键字 `enum` 来声明。枚举声明体包含零个或多个值，称为枚举用例，还可包含任意数量的声明，包括计算型属性、实例方法、类型方法、构造器、类型别名，甚至其他枚举、结构体和类。枚举声明不能包含析构器或者协议声明。 + +枚举类型可以采纳任意数量的协议，但是枚举不能从类、结构体和其他枚举继承。 + +不同于类或者结构体，枚举类型并不隐式提供默认构造器，所有构造器必须显式声明。一个构造器可以委托给枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例赋值给 `self` 后才算完成。 + +和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.html#structures_and_enumerations_are_value_types)。 + +可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。 + + +### 任意类型的枚举用例 + +如下的形式声明了一个包含任意类型枚举用例的枚举变量： + +```swift +enum 枚举名称: 采纳的协议 { + case 枚举用例1 + case 枚举用例2(关联值类型) +} +``` + +这种形式的枚举声明在其他语言中有时被叫做可识别联合。 + +在这种形式中，每个用例块由关键字 `case` 开始，后面紧接一个或多个以逗号分隔的枚举用例。每个用例名必须是独一无二的。每个用例也可以指定它所存储的指定类型的值，这些类型在关联值类型的元组中被指定，紧跟用例名之后。 + +具有关联值的枚举用例可以像函数一样使用，通过指定的关联值创建枚举实例。和真正的函数一样，你可以获取枚举用例的引用，然后在后续代码中调用它。 + +```swift +enum Number { + case Integer(Int) + case Real(Double) +} + +// f 的类型为 (Int) -> Number +let f = Number.Integer + +// 利用 f 把一个整数数组转成 Number 数组 +let evenInts: [Number] = [0, 2, 4, 6].map(f) +``` + +要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../chapter2/08_Enumerations.html#associated_values)。 + + +#### 递归枚举 + +枚举类型可以具有递归结构，就是说，枚举用例的关联值类型可以是枚举类型自身。然而，枚举类型的实例具有值语义，这意味着它们在内存中有固定布局。为了支持递归，编译器必须插入一个间接层。 + +要让某个枚举用例支持递归，使用 `indirect` 声明修饰符标记该用例。 + +```swift +enum Tree { + case Empty + indirect case Node(value: T, left: Tree, right:Tree) +} +``` + +要让一个枚举类型的所有用例都支持递归，使用 `indirect` 修饰符标记整个枚举类型，当枚举有多个用例且每个用例都需要使用 `indirect` 修饰符标记的时候这将非常便利。 + +被 `indirect` 修饰符标记的枚举用例必须有一个关联值。使用 `indirect` 修饰符标记的枚举类型可以既包含有关联值的用例，同时还可包含没有关联值的用例。但是，它不能再单独使用 `indirect` 修饰符来标记某个用例。 + + +### 拥有原始值的枚举用例 + +以下形式声明了一种枚举类型，其中各个枚举用例的类型均为同一种基本类型： + +```swift +enum 枚举名称: 原始值类型, 采纳的协议 { + case 枚举用例1 = 原始值1 + case 枚举用例2 = 原始值2 +} +``` + +在这种形式中，每一个用例块由 `case` 关键字开始，后面紧跟一个或多个以逗号分隔的枚举用例。和第一种形式的枚举用例不同，这种形式的枚举用例包含一个基础值，叫做原始值，各个枚举用例的原始值的类型必须相同。这些原始值的类型通过原始值类型指定，必须表示一个整数、浮点数、字符串或者字符。原始值类型必须符合 `Equatable` 协议和下列字面量转换协议中的一种：整型字面量需符合 `IntergerLiteralConvertible` 协议，浮点型字面量需符合 `FloatingPointLiteralConvertible` 协议，包含任意数量字符的字符串型字面量需符合 `StringLiteralConvertible` 协议，仅包含一个单一字符的字符串型字面量需符合 `ExtendedGraphemeClusterLiteralConvertible` 协议。每一个用例的名字和原始值必须唯一。 + +如果原始值类型被指定为 `Int`，则不必为用例显式地指定原始值，它们会隐式地被赋值 `0`、`1`、`2` 等。每个未被赋值的 `Int` 类型的用例会被隐式地赋值，其值为上一个用例的原始值加 `1`。 + +```Swift +enum ExampleEnum: Int { + case A, B, C = 5, D +} +``` + +在上面的例子中，`ExampleEnum.A` 的原始值是 `0`，`ExampleEnum.B` 的原始值是 `1`。因为 `ExampleEnum.C` 的原始值被显式地设定为 `5`，因此 `ExampleEnum.D` 的原始值会自动增长为 `6`。 + +如果原始值类型被指定为 `String` 类型，你不用明确地为用例指定原始值，每个没有指定原始值的用例会隐式地将用例名字作为原始值。 + +```swift +enum WeekendDay: String { + case Saturday, Sunday +} +``` + +在上面这个例子中，`WeekendDay.Saturday` 的原始值是 `"Saturday"`，`WeekendDay.Sunday` 的原始值是 `"Sunday"`。 + +枚举用例具有原始值的枚举类型隐式地符合定义在 Swift 标准库中的 `RawRepresentable` 协议。所以，它们拥有一个 `rawValue` 属性和一个可失败构造器 `init?(rawValue: RawValue)`。可以使用 `rawValue` 属性去获取枚举用例的原始值，例如 `ExampleEnum.B.rawValue`。还可以根据原始值来创建一个相对应的枚举用例，只需调用枚举的可失败构造器，例如 `ExampleEnum(rawValue: 5)`，这个可失败构造器返回一个可选类型的用例。要获得更多关于具有原始值的枚举用例的信息和例子，请参阅 [原始值](../chapter2/08_Enumerations.html#raw_values)。 + + +### 访问枚举用例 + +使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.EnumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../chapter2/08_Enumerations.html#enumeration_syntax) 和 [显式成员表达式](04_Expressions.html#explicit_member_expression) 所述。 + +可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../chapter2/08_Enumerations.html#matching_enumeration_values_with_a_switch_statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](07_Patterns.html#enumeration_case_pattern) 所述。 + + +> 枚举声明语法 +> + +> *枚举声明* → [*特性列表*](06_Attributes.html#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 [*联合风格枚举*](#union-style-enum) +> *枚举声明* → [*特性列表*](06_Attributes.html#attributes)可选 [*访问级别修饰符*](#access-level-modifier) 可选 [*原始值风格枚举*](#raw-value-style-enum) + + +> *联合风格枚举* → **indirect**可选 **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [类型继承子句](03_Types.html#type-inheritance-clause)可选 **{** [*多个联合风格枚举成员*](#union-style-enum-members)可选 **}** +> +> *多个联合风格枚举成员* → [*联合风格枚举成员*](#union-style-enum-member) [*多个联合风格枚举成员*](#union-style-enum-members)可选 +> +> *联合风格枚举成员* → [*声明*](#declaration) | [*联合风格枚举用例子句*](#union-style-enum-case-clause) +> +> *联合风格枚举用例子句* → [*特性列表*](06_Attributes.html#attributes)可选 **indirect**可选 **case** [*联合风格枚举用例列表*](#union-style-enum-case-list) +> +> *联合风格枚举用例列表* → [*联合风格枚举用例*](#union-style-enum-case) | [*联合风格枚举用例*](#union-style-enum-case) **,** [*联合风格枚举用例列表*](#union-style-enum-case-list) +> +> *联合风格枚举用例* → [*枚举用例名称*](#enum-case-name) [*元组类型*](03_Types.html#tuple-type)可选 +> +> *枚举名称* → [*标识符*](02_Lexical_Structure.html#identifier) +> +> *枚举用例名称* → [*标识符*](02_Lexical_Structure.html#identifier) + + +> *原始值风格枚举* → **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [类型继承子句](03_Types.html#type-inheritance-clause) **{** [*多个原始值风格枚举成员*](#raw-value-style-enum-members) **}** +> +> *多个原始值风格枚举成员* → [*原始值风格枚举成员*](#raw-value-style-enum-member) [*多个原始值风格枚举成员*](#raw-value-style-enum-members)可选 +> +> *原始值风格枚举成员* → [*声明*](#declaration) | [*原始值风格枚举用例子句*](#raw-value-style-enum-case-clause) +> +> *原始值风格枚举用例子句* → [*特性列表*](06_Attributes.html#attributes)可选 **case** [*原始值风格枚举用例列表*](#raw-value-style-enum-case-list) +> +> *原始值风格枚举用例列表* → [*原始值风格枚举用例*](#raw-value-style-enum-case) | [*原始值风格枚举用例*](#raw-value-style-enum-case) **,** [*原始值风格枚举用例列表*](#raw-value-style-enum-case-list) +> +> *原始值风格枚举用例* → [*枚举用例名称*](#enum-case-name) [*原始值赋值*](#raw-value-assignment)可选 +> +> *原始值赋值* → **=** [*原始值字面量*](#raw-value-literal) +> +> *原始值字面量* → [数字型字面量](02_Lexical_Structure.html#numeric-literal) | [字符串型字面量](02_Lexical_Structure.html#static-string-literal) | [布尔型字面量](02_Lexical_Structure.html#boolean-literal) + + +## 结构体声明 + +使用*结构体声明 (structure declaration)* 可以在程序中引入一个结构体类型。结构体声明使用 `struct` 关键字，遵循如下的形式： + +```swift +struct 结构体名称: 采纳的协议 { + 多条声明 +} +``` + +结构体内可包含零个或多个声明。这些声明可以包括存储型和计算型属性、类型属性、实例方法、类型方法、构造器、下标、类型别名，甚至其他结构体、类、和枚举声明。结构体声明不能包含析构器或者协议声明。关于结构体的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Classes_and_Structures.html)。 + +结构体可以采纳任意数量的协议，但是不能继承自类、枚举或者其他结构体。 + +有三种方法可以创建一个已声明的结构体实例： + +* 调用结构体内声明的构造器，正如 [构造器](../chapter2/14_Initialization.html#initializers) 所述。 + +* 如果没有声明构造器，调用结构体的成员逐一构造器，正如 [结构体类型的成员逐一构造器](../chapter2/14_Initialization.html#memberwise_initializers_for_structure_types) 所述。 + +* 如果没有声明构造器，而且结构体的所有属性都有初始值，调用结构体的默认构造器，正如 [默认构造器](../chapter2/14_Initialization.html#default_initializers) 所述。 + +结构体的构造过程请参阅 [构造过程](../chapter2/14_Initialization.html)。 + +结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../chapter2/09_Classes_and_Structures.html#accessing_properties) 所述。 + +结构体是值类型。结构体的实例在被赋予变量或常量，或传递给函数作为参数时会被复制。关于值类型的更多信息，请参阅 +[结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.html#structures_and_enumerations_are_value_types)。 + +可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension_declaration)。 + + +> 结构体声明语法 +> +> +> *结构体声明* → [*特性列表*](06_Attributes.html#attributes)可选 [*访问级别修饰符*](#access-level-modifier) 可选 **struct** [*结构体名称*](#struct-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [类型继承子句](03_Types.html#type-inheritance-clause)可选 [*结构体主体*](#struct-body) +> +> *结构体名称* → [*标识符*](02_Lexical_Structure.html#identifier) +> +> *结构体主体* → **{** [*多条声明*](#declarations)可选 **}** + + +## 类声明 + +可以在程序中使用*类声明 (class declaration)* 来引入一个类。类声明使用关键字 `class`，遵循如下的形式： + +```swift +class 类名: 超类, 采纳的协议 { + 多条声明 +} +``` + +类内可以包含零个或多个声明。这些声明可以包括存储型和计算型属性、实例方法、类型方法、构造器、唯一的析构器、下标、类型别名，甚至其他结构体、类和枚举声明。类声明不能包含协议声明。关于类的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Classes_and_Structures.html)。 + +一个类只能继承自一个超类，但是可以采纳任意数量的协议。超类紧跟在类名和冒号后面，其后跟着采纳的协议。泛型类可以继承自其它泛型类和非泛型类，但是非泛型类只能继承自其它非泛型类。当在冒号后面写泛型超类的名称时，必须写上泛型类的全名，包括它的泛型形参子句。 + +正如 [构造器声明](#initializer_declaration) 所讨论的，类可以有指定构造器和便利构造器。类的指定构造器必须初始化类中声明的所有属性，并且必须在调用超类构造器之前。 + +类可以重写属性、方法、下标以及构造器。重写的属性、方法、下标和指定构造器必须以 `override` 声明修饰符标记。 + +为了要求子类去实现超类的构造器，使用 `required` 声明修饰符标记超类的构造器。子类实现超类构造器时也必须使用 `required` 声明修饰符。 + +虽然超类属性和方法声明可以被当前类继承，但是超类声明的指定构造器却不能。即便如此，如果当前类重写了超类的所有指定构造器，它就会继承超类的所有便利构造器。Swift 的类并不继承自一个通用基础类。 + +有两种方法来创建已声明的类的实例： + +* 调用类中声明的构造器，请参阅 [构造器](../chapter2/14_Initialization.html#initializers)。 + +* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../chapter2/14_Initialization.html#default_initializers)。 + +类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../chapter2/09_Classes_and_Structures.html#accessing_properties)。 + +类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Classes_and_Structures.html#structures_and_enumerations_are_value_types)。 + +可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension_declaration)。 + + +> 类声明语法 +> +> +> *类声明* → [*特性列表*](06_Attributes.html#attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [*类型继承子句*](03_Types.html#type-inheritance-clause)可选 [*类主体*](#class-body) +> +> *类名* → [*标识符*](02_Lexical_Structure.html#identifier) +> +> *类主体* → **{** [*多条声明*](#declarations)可选 **}** + + +## 协议声明 + +*协议声明 (protocol declaration)* 可以为程序引入一个命名的协议类型。协议声明只能在全局区域使用 `protocol` 关键字来进行声明，并遵循如下形式： + +```swift +protocol 协议名称: 继承的协议 { + 协议成员声明 +} +``` + +协议的主体包含零个或多个协议成员声明，这些成员描述了任何采纳该协议的类型必须满足的一致性要求。一个协议可以声明采纳者必须实现的某些属性、方法、构造器以及下标。协议也可以声明各种各样的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议声明不能包括类、结构体、枚举或者其它协议的声明。协议成员声明会在后面进行讨论。 + +协议类型可以继承自任意数量的其它协议。当一个协议类型继承自其它协议的时候，来自其它协议的所有要求会聚合在一起，而且采纳当前协议的类型必须符合所有的这些要求。关于如何使用协议继承的例子，请参阅 [协议继承](../chapter2/21_Protocols.html#protocol_inheritance)。 + +> 注意 +> +> 也可以使用协议合成类型来聚合多个协议的一致性要求，请参阅 [协议合成类型](03_Types.html#protocol_composition_type) 和 [协议合成](../chapter2/21_Protocols.html#protocol_composition)。 + +可以通过类型的扩展声明来采纳协议，从而为之前声明的类型添加协议一致性。在扩展中，必须实现所有采纳协议的要求。如果该类型已经实现了所有的要求，可以让这个扩展声明的主体留空。 + +默认地，符合某个协议的类型必须实现所有在协议中声明的属性、方法和下标。即便如此，可以用 `optional` 声明修饰符标注协议成员声明，以指定它们的实现是可选的。`optional` 修饰符仅仅可以用于使用 `objc` 特性标记过的协议。因此，仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用 `optional` 声明修饰符的信息，以及如何访问可选协议成员的指导——例如不能确定采纳协议的类型是否实现了它们时——请参阅 [可选协议要求](../chapter2/21_Protocols.html#optional_protocol_requirements) + +为了限制协议只能被类类型采纳，需要使用 `class` 关键字来标记协议，将 `class` 关键在写在冒号后面的继承的协议列表的首位。例如，下面的协议只能被类类型采纳： + +```swift +protocol SomeProtocol: class { + /* 这里是协议成员 */ +} +``` + +任何继承自标记有 `class` 关键字的协议的协议也仅能被类类型采纳。 + +> 注意 +> +> 如果协议已经用 `objc` 特性标记了，`class` 要求就隐式地应用于该协议，无需显式使用 `class` 关键字。 + +协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../chapter2/21_Protocols.html#protocols_as_types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。 + +可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托(代理)模式](../chapter2/21_Protocols.html#delegation) 中所述。 + + +> 协议声明语法 +> + +> *协议声明* → [*特性列表*](06_Attributes.html#attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **protocol** [*协议名称*](#protocol-name) [*类型继承子句*](03_Types.html#type-inheritance-clause)可选 [*协议主体*](#protocol-body) +> +> *协议名称* → [*标识符*](02_Lexical_Structure.html#identifier) +> +> *协议主体* → **{** [*协议成员声明列表*](#protocol-member-declarations)可选 **}** +> + +> *协议成员声明* → [*协议属性声明*](#protocol-property-declaration) +> *协议成员声明* → [*协议方法声明*](#protocol-method-declaration) +> *协议成员声明* → [*协议构造器声明*](#protocol-initializer-declaration) +> *协议成员声明* → [*协议下标声明*](#protocol-subscript-declaration) +> *协议成员声明* → [*协议关联类型声明*](#protocol-associated-type-declaration) +> +> *协议成员声明列表* → [*协议成员声明*](#protocol-member-declaration) [*协议成员声明列表*](#protocol-member-declarations)可选 + + +### 协议属性声明 + +协议可以通过在协议声明主体中引入一个协议属性声明，来声明符合的类型必须实现的属性。协议属性声明有一种特殊的变量声明形式： + +```swift +var 属性名: 类型 { get set } +``` + +同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了 getter 和 setter 要求，你不能在协议中直接实现 getter 和 setter。 + +符合类型可以通过多种方式满足 getter 和 setter 要求。如果属性声明包含 `get` 和 `set` 关键字，符合类型就可以用存储型变量属性或可读可写的计算型属性来满足此要求，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含 `get` 关键字的话，它可以作为任意类型的属性被实现。关于如何实现协议中的属性要求的例子，请参阅 [属性要求](../chapter2/21_Protocols.html#property_requirements) + +另请参阅 [变量声明](#variable_declaration)。 + + +> 协议属性声明语法 +> +> +> *协议属性声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型标注*](03_Types.html#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) + + +### 协议方法声明 + +协议可以通过在协议声明主体中引入一个协议方法声明，来声明符合的类型必须实现的方法。协议方法声明和函数方法声明有着相同的形式，但有两项例外：它们不包括函数体，也不能包含默认参数。关于如何实现协议中的方法要求的例子，请参阅 [方法要求](../chapter2/21_Protocols.html#method_requirements)。 + +使用 `static` 声明修饰符可以在协议声明中声明一个类型方法。结构体实现这些方法时使用 `static` 声明修饰符，类在实现这些方法时，除了使用 `static` 声明修饰符，还可以选择使用 `class` 声明修饰符。通过扩展实现时亦是如此。 + +另请参阅 [函数声明](#function_declaration)。 + + +> 协议方法声明语法 +> +> +> *协议方法声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [*函数签名*](#function-signature) + + +### 协议构造器声明 + +协议可以通过在协议声明主体中引入一个协议构造器声明，来声明符合的类型必须实现的构造器。协议构造器声明 +除了不包含实现主体外，和构造器声明有着相同的形式。 + +符合类型可以通过实现一个非可失败构造器或者 `init!` 可失败构造器来满足一个非可失败协议构造器的要求，可以通过实现任意类型的构造器来满足一个可失败协议构造器的要求。 + +类在实现一个构造器去满足一个协议的构造器要求时，如果这个类还没有用 `final` 声明修饰符标记，这个构造器必须用 `required` 声明修饰符标记。 + +另请参阅 [构造器声明](#initializer_declaration)。 + + +> 协议构造器声明语法 +> +> +> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 +> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows** + + +### 协议下标声明 + +协议可以通过在协议声明主体中引入一个协议下标声明，来声明符合的类型必须实现的下标。协议下标声明有一个特殊的下标声明形式： + +```swift +subscript (参数列表) -> 返回类型 { get set } +``` + +下标声明只为符合类型声明了 getter 和 setter 要求。如果下标声明包含 `get` 和 `set` 关键字，符合类型也必须实现 getter 和 setter 子句。如果下标声明只包含 `get` 关键字，符合类型必须实现 getter 子句，可以选择是否实现 setter 子句。 + +另请参阅 [下标声明](#subscript_declaration)。 + + +> 协议下标声明语法 +> +> *协议下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) + + +### 协议关联类型声明 + +使用关键字 `associatedtype` 来声明协议关联类型。关联类型为作为协议声明的一部分，为某种类型提供了一个别名。关联类型和泛型参数子句中的类型参数很相似，但是它们和 `Self` 一样，用于协议中。`Self` 指代采纳协议的类型。要获得更多信息和例子，请参阅 [关联类型](../chapter2/22_Generics.html#associated_types)。 + +另请参阅 [类型别名声明](#type_alias_declaration)。 + + +> 协议关联类型声明语法 +> +> +> *协议关联类型声明* → [*类型别名头*](#typealias-head) [*类型继承子句*](03_Types.html#type-inheritance-clause)可选 [*类型别名赋值*](#typealias-assignment)可选 + + +## 构造器声明 + +构造器声明会为程序中的类、结构体或枚举引入构造器。构造器使用关键字 `init` 来声明，有两种基本形式。 + +结构体、枚举、类可以有任意数量的构造器，但是类的构造器具有不同的规则和行为。不同于结构体和枚举，类有两种构造器，即指定构造器和便利构造器，请参阅 [构造过程](../chapter2/14_Initialization.html)。 + +采用如下形式声明结构体和枚举的构造器，以及类的指定构造器： + +```swift +init(参数列表) { + 构造语句 +} +``` + +类的指定构造器直接将类的所有属性初始化。它不能调用类中的其他构造器，如果类有超类，则必须调用超类的一个指定构造器。如果该类从它的超类继承了属性，必须在调用超类的指定构造器后才能修改这些属性。 + +指定构造器只能在类声明中声明，不能在扩展声明中声明。 + +结构体和枚举的构造器可以调用其他已声明的构造器，从而委托其他构造器来进行部分或者全部构造过程。 + +要为类声明一个便利构造器，用 `convenience` 声明修饰符来标记构造器声明： + +```swift +convenience init(参数列表) { + 构造语句 +} +``` + +便利构造器可以将构造过程委托给另一个便利构造器或一个指定构造器。但是，类的构造过程必须以一个将类中所有属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。 + +可以使用 `required` 声明修饰符，将便利构造器和指定构造器标记为每个子类都必须实现的构造器。这种构造器的子类实现也必须使用 `required` 声明修饰符标记。 + +默认情况下，超类中的构造器不会被子类继承。但是，如果子类的所有存储型属性都有默认值，而且子类自身没有定义任何构造器，它将继承超类的构造器。如果子类重写了超类的所有指定构造器，子类将继承超类的所有便利构造器。 + +和方法、属性和下标一样，需要使用 `override` 声明修饰符标记重写的指定构造器。 + +> 注意 +> +> 如果使用 `required` 声明修饰符标记一个构造器，在子类中重写这种构造器时，无需使用 `override` 修饰符。 + +就像函数和方法，构造器也可以抛出或者重抛错误，你可以在构造器参数列表的圆括号之后使用 `throws` 或 `rethrows` 关键字来表明相应的抛出行为。 + +关于在不同类型中声明构造器的例子，请参阅 [构造过程](../chapter2/14_Initialization.html)。 + + +### 可失败构造器 + +可失败构造器可以生成所属类型的可选实例或者隐式解包可选实例，因此，这种构造器通过返回 `nil` 来指明构造过程失败。 + +声明生成可选实例的可失败构造器时，在构造器声明的 `init` 关键字后加追加一个问号（`init?`）。声明生成隐式解包可选实例的可失败构造器时，在构造器声明后追加一个叹号（`init!`）。使用 `init?` 可失败构造器生成结构体的一个可选实例的例子如下。 + +```swift +struct SomeStruct { + let string: String + //生成一个 SomeStruct 的可选实例 + init?(input: String) { + if input.isEmpty { + // 丢弃 self，并返回 nil + return nil + } + string = input + } +} +``` + +调用 `init?` 可失败构造器和调用非可失败构造器的方式相同，不过你需要处理可选类型的返回值。 + +```swift +if let actualInstance = SomeStruct(input: "Hello") { + // 利用 SomeStruct 实例做些事情 +} else { + // SomeStruct 实例的构造过程失败，构造器返回了 nil +} +``` + +可失败构造器可以在构造器实现中的任意位置返回 `nil`。 + +可失败构造器可以委托任意种类的构造器。非可失败可以委托其它非可失败构造器或者 `init!` 可失败构造器。非可失败构造器可以委托超类的 `init?` 可失败指定构造器，但是需要使用强制解包，例如 `super.init()!`。 + +构造过程失败通过构造器委托来传递。具体来说，如果可失败构造器委托的可失败构造器构造过程失败并返回 `nil`，那么该可失败构造器也会构造失败并隐式地返回 `nil`。如果非可失败构造器委托的 `init!` 可失败构造器构造失败并返回了 `nil`，那么会发生运行时错误（如同使用 `!` 操作符去强制解包一个值为 `nil` 的可选值）。 + +子类可以用任意种类的指定构造器重写超类的可失败指定构造器，但是只能用非可失败指定构造器重写超类的非可失败指定构造器。 + +更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../chapter2/14_Initialization.html#failable_initializers)。 + + +> 构造器声明语法 +> +> +> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 [*构造器主体*](#initializer-body) +> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.html#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows**可选 [*构造器主体*](#initializer-body) +> +> *构造器头* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **init** +> *构造器头* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **init** **?** +> *构造器头* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **init** **!** +> +> *构造器主体* → [*代码块*](#code-block) + + +## 析构器声明 + +*析构器声明 (deinitializer declaration)* 可以为类声明一个析构器。析构器没有参数，遵循如下格式： + +```swift +deinit { + 语句 +} +``` + +当没有任何强引用引用着类的对象，对象即将被释放时，析构器会被自动调用。析构器只能在类主体的声明中声明，不能在类的扩展声明中声明，并且每个类最多只能有一个析构器。 + +子类会继承超类的析构器，并会在子类对象将要被释放时隐式调用。继承链上的所有析构器全部调用完毕后子类对象才会被释放。 + +析构器不能直接调用。 + +关于如何在类声明中使用析构器的例子，请参阅 [析构过程](../chapter2/15_Deinitialization.html)。 + + +> 析构器声明语法 +> +> +> *析构器声明* → [*特性列表*](06_Attributes.html#attributes)可选 **deinit** [*代码块*](#code-block) + + +## 扩展声明 + +*扩展声明 (extension declaration)* 可以扩展一个现存的类型的行为。扩展声明使用关键字 `extension`，遵循如下格式： + +```swift +extension 类型名称: 采纳的协议 { + 声明语句 +} +``` + +```swift +extension 类型名称 where 要求 { + 声明语句 +} +``` + +扩展声明体可包含零个或多个声明语句。这些声明语句可以包括计算型属性、计算型类型属性、实例方法、类型方法、构造器、下标声明，甚至是类、结构体和枚举声明。扩展声明不能包含析构器、协议声明、存储型属性、属性观察器或其他扩展声明。关于扩展声明的详细讨论，以及各种扩展声明的例子，请参阅 [扩展](../chapter2/20_Extensions.html)。 + +如果类型为类，结构体，或枚举类型，则扩展声明会扩展相应的类型。如果类型为协议类型，则扩展声明会扩展所有遵守这个协议的类型。在扩展的协议体中声明语句不能使用 `final` 标识符。 + +扩展声明可以为现存的类、结构体、枚举添加协议一致性，但是不能为类添加超类，因此在扩展声明的类型名称的冒号后面仅能指定一个协议列表。 + +现存类型的属性、方法、构造器不能在扩展中被重写。 + +扩展声明可以包含构造器声明。这意味着，如果被扩展的类型在其他模块中定义，构造器声明必须委托另一个在那个模块中声明的构造器，以确保该类型能被正确地初始化。 + + +> 扩展声明语法 +> +> +> *扩展声明* → [特性](06_Attributes.html#type_attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **extension** [*类型标识符*](03_Types.html#type-identifier) [*类型-继承-子句*](03_Types.html#type-inheritance-clause)可选 [*扩展主体*](#extension-body) +> +> *扩展声明* → [特性](06_Attributes.html#type_attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **extension** [*类型标识符*](03_Types.html#type-identifier) [*泛型-where-子句*](03_Types.html#type-inheritance-clause) [*扩展主体*](#extension-body) +> *扩展主体* → **{** [*多条声明*](#declarations)可选 **}** +> *多条声明* → [单条声明](#subscript_declaration) [多条声明](#declarations) 可选 +> *单条声明* → [声明语句](#declarations) | [编译器-控制-语句](10_Statements.html#compiler-control-statement) + + +## 下标声明 + +*下标声明 (subscript declaration)* 用于为特定类型的对象添加下标支持，通常也用于为访问集合、列表和序列中的元素提供语法便利。下标声明使用关键字 `subscript`，形式如下： + +```swift +subscript (参数列表) -> 返回类型 { + get { + 语句 + } + set(setter 名称) { + 语句 + } +} +``` + +下标声明只能出现在类、结构体、枚举、扩展和协议的声明中。 + +参数列表指定一个或多个用于在相关类型的下标表达式中访问元素的索引（例如，表达式 `object[i]` 中的 `i`）。索引可以是任意类型，但是必须包含类型标注。返回类型指定了被访问的元素的类型。 + +和计算型属性一样，下标声明支持对元素的读写操作。getter 用于读取值，setter 用于写入值。setter 子句是可选的，当仅需要一个 getter 子句时，可以将二者都忽略，直接返回请求的值即可。但是，如果提供了 setter 子句，就必须提供 getter 子句。 + +圆括号以及其中的 setter 名称是可选的。如果提供了 setter 名称，它会作为 setter 的参数名称。如果不提供 setter 名称，那么 setter 的参数名称默认是 `value`。setter 名称的类型必须与返回类型相同。 + +可以重载下标，只要参数列表或返回类型不同即可。还可以重写继承自超类的下标，此时必须使用 `override` 声明修饰符声明被重写的下标。 + +同样可以在协议声明中声明下标，正如 [协议下标声明](#protocol_subscript_declaration) 中所述。 + +更多关于下标的信息和例子，请参阅 [下标](../chapter2/12_Subscripts.html)。 + + +> 下标声明语法 +> +> +> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*代码块*](#code-block) +> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*getter-setter 代码块*](#getter-setter-block) +> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> +> *下标头* → [*特性列表*](06_Attributes.html#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **subscript** [*参数子句*](#parameter-clause) +> +> *下标结果* → **->** [*特性列表*](06_Attributes.html#attributes)可选 [*类型*](03_Types.html#type) + + +## 运算符声明 + +*运算符声明 (operator declaration)* 会向程序中引入中缀、前缀或后缀运算符，使用关键字 `operator` 来声明。 + +可以声明三种不同的缀性：中缀、前缀和后缀。运算符的缀性指定了运算符与其运算对象的相对位置。 + +运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在 `operator` 关键字之前添加声明修饰符 `infix`，`prefix` 或 `postfix` 来指定。每种形式中，运算符的名字只能包含 [运算符](02_Lexical_Structure.html#operators) 中定义的运算符字符。 + +下面的形式声明了一个新的中缀运算符： + +```swift +infix operator 运算符名称: 优先级组 +``` + +中缀运算符是二元运算符，置于两个运算对象之间，例如加法运算符（`+`）位于表达式 `1 + 2` 的中间。 + +中缀运算符可以选择指定优先级组。如果没有为运算符设置优先级组，Swift 会设置默认优先级组 `DefaultPrecedence`,它的优先级比三目优先级 `TernaryPrecedence` 要高，更多内容参考[*优先级组声明*](#precedence_group_declaration_modifiers) + +下面的形式声明了一个新的前缀运算符： + +```swift +prefix operator 运算符名称 {} +``` + +出现在运算对象前边的前缀运算符是一元运算符，例如表达式 `!a` 中的前缀非运算符（`!`）。 + +前缀运算符的声明中不指定优先级，而且前缀运算符是非结合的。 + +下面的形式声明了一个新的后缀运算符： + +```swift +postfix operator 运算符名称 {} +``` + +紧跟在运算对象后边的后缀运算符是一元运算符，例如表达式 `a!` 中的后缀强制解包运算符（`!`）。 + +和前缀运算符一样，后缀运算符的声明中不指定优先级，而且后缀运算符是非结合的。 + +声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../chapter2/25_Advanced_Operators.html#custom_operators)。 + + +> 运算符声明语法 +> + +> *运算符声明* → [*前缀运算符声明*](#prefix-operator-declaration) | [*后缀运算符声明*](#postfix-operator-declaration) | [*中缀运算符声明*](#infix-operator-declaration) +> + +> *前缀运算符声明* → **prefix** **运算符** [*运算符*](02_Lexical_Structure.html#operator) **{** **}** +> +> *后缀运算符声明* → **postfix** **运算符** [*运算符*] (02_Lexical_Structure.html#operator) **{** **}** +> +> *中缀运算符声明* → **infix** **运算符** [*运算符*](02_Lexical_Structure.html#operator) **{** [*中缀运算符属性*](#infix-operator-attributes)可选 **}** +> + +> *中缀运算符组* → [*优先级组名称*](#precedence-group-name) + + +## 优先级组声明 + +*优先级组声明 (A precedence group declaration)* 会向程序的中缀运算符引入一个全新的优先级组。当没有用圆括号分组时，运算符优先级反应了运算符与它的操作数的关系的紧密程度。 +优先级组的声明如下所示: + +```swift +precedencegroup 优先级组名称{ + higherThan: 较低优先级组的名称 + lowerThan: 较高优先级组的名称 + associativity: 结合性 + assignment: 赋值性 +} +``` + +较低优先级组和较高优先级组的名称说明了新建的优先级组是依赖于现存的优先级组的。`lowerThan` 优先级组的属性只可以引用当前模块外的优先级组。当两个运算符为同一个操作数竞争时，比如表达式 `2 + 3 * 5`,优先级更高的运算符将优先参与运算。 + +> 注意 +> +> 使用较低和较高优先级组相互联系的优先级组必须保持单一层次关系，但它们不必是线性关系。这意味着优先级组也许会有未定义的相关优先级。这些优先级组的运算符在没有用圆括号分组的情况下是不能紧邻着使用的。 + +Swift 定义了大量的优先级组来与标准库的运算符配合使用，例如相加(`+`)和相减(`-`)属于 `AdditionPrecedence` 组，相乘(`*`)和相除(`/`)属于 `MultiplicationPrecedence` 组，详细关于 Swift 标准库中一系列运算符和优先级组内容，参阅[Swift 标准库操作符参考](https://developer.apple.com/reference/swift/1851035-swift_standard_library_operators)。 + +运算符的结合性表示在没有圆括号分组的情况下，同样优先级的一系列运算符是如何被分组的。你可以指定运算符的结合性通过上下文关键字 `left`、`right` 或者 `none`,如果没有指定结合性，默认是 `none` 关键字。左关联性的运算符是从左至右分组的，例如，相减操作符(-)是左关联性的，所以表达式 `4 - 5 - 6` 被分组为 `(4 - 5) - 6`,得出结果-7。右关联性的运算符是从右往左分组的，指定为 `none` 结合性的运算符就没有结合性。同样优先级没有结合性的运算符不能相邻出现，例如 `<` 运算符是 `none` 结合性，那表示 `1 < 2 < 3` 就不是一个有效表达式。 + +优先级组的赋值性表示在包含可选链操作时的运算符优先级。当设为 true 时，与优先级组对应的运算符在可选链操作中使用和标准库中赋值运算符同样的分组规则，当设为 false 或者不设置，该优先级组的运算符与不赋值的运算符遵循同样的可选链规则。 + + +> 优先级组声明语法 +> + +> *优先级组声明* → **precedence**[*优先级组名称*](#precedence-group-name){[*多优先级组属性*](#precedence-group-attributes)可选 } + +> *优先级组属性* → [*优先级组属性*](#precedence-group-attribute)[*多优先级组属性*](#precedence-group-attributes)可选 **{** **}** + +> *优先级组属性* → [*优先级组关系*](#precedence-group-relation) +> *优先级组属性* → [*优先级组赋值性*](#precedence-group-assignment) +> *优先级组属性* → [*优先级组相关性*](#precedence-group-associativity) +> +> *优先级组关系* → **higherThan:**[*多优先级组名称*](#precedence-group-names) +> *优先级组关系* → **lowerThan:**[*多优先级组名称*](#precedence-group-names) +> +> *优先级组赋值* → **assignment:**[*布尔字面值*](02_Lexical_Structure.html#boolean-literal) + +> *优先级组结合性* → **associativity:left** +> *优先级组结合性* → **associativity:right** +> *优先级组结合性* → **associativity:none** +> + +> *多优先级组名称* → [*优先级组名称*](#precedence-group-name) | [*优先级组名称*](#precedence-group-name) | [*优先级组名称*](#precedence-group-name) + +> *优先级组名称* →[*标识符*](02_Lexical_Structure.html#identifier) + + +## 声明修饰符 + +声明修饰符都是关键字或上下文相关的关键字，可以修改一个声明的行为或者含义。可以在声明的特性（如果存在）和引入该声明的关键字之间，利用声明修饰符的关键字或上下文相关的关键字指定一个声明修饰符。 + +`dynamic` + +该修饰符用于修饰任何兼容 Objective-C 的类的成员。访问被 `dynamic` 修饰符标记的类成员将总是由 Objective-C 运行时系统进行动态派发，而不会由编译器进行内联或消虚拟化。 + +因为被标记 `dynamic` 修饰符的类成员会由 Objective-C 运行时系统进行动态派发，所以它们会被隐式标记 `objc` 特性。 + +`final` + +该修饰符用于修饰类或类中的属性、方法以及下标。如果用它修饰一个类，那么这个类不能被继承。如果用它修饰类中的属性、方法或下标，那么它们不能在子类中被重写。 + +`lazy` + +该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在它被第一次访问时。关于如何使用 `lazy` 修饰符的例子，请参阅 [惰性存储型属性](../chapter2/10_Properties.html#lazy_stored_properties)。 + +`optional` + +该修饰符用于修饰协议中的属性、方法以及下标成员，表示符合类型可以不实现这些成员要求。 + +只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../chapter2/22_Protocols.html#optional_protocol_requirements)。 + +`required` + +该修饰符用于修饰类的指定构造器或便利构造器，表示该类所有的子类都必须实现该构造器。在子类实现该构造器时，必须同样使用 `required` 修饰符修饰该构造器。 + +`weak` + +该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../chapter2/16_Automatic_Reference_Counting.html#resolving_strong_reference_cycles_between_class_instances)。 + + +### 访问控制级别 + +Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../chapter2/24_Access_Control.html) 中有详细讨论。 + +`public` + +该修饰符表示声明可被同模块的代码访问，只要其他模块导入了声明所在的模块，也可以进行访问。 + +`internal` + +该修饰符表示声明只能被同模块的代码访问。默认情况下，绝大多数声明会被隐式标记 `internal` 访问级别修饰符。 + +`private` + +该修饰符表示声明只能被所在源文件的代码访问。 + +以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../chapter2/24_Access_Control.html#getters_and_setters) 中所讨论的。 + + +> 声明修饰符的语法 +> + +> *声明修饰符* → **class** | **convenience**| **dynamic** | **final** | **infix** | **lazy** | **mutating** | **nonmutating** | **optional** | **override** | **postfix** | **prefix** | **required** | **static** | **unowned** | **unowned ( safe )** | **unowned ( unsafe )** | **weak** +> 声明修饰符 → [*访问级别修饰符*](#access-level-modifier) +> +> *声明修饰符列表* → [*声明修饰符*](#declaration-modifier) [*声明修饰符列表*](#declaration-modifiers)可选 +> + +> 访问级别修饰符 → **internal** | **internal ( set )** +> 访问级别修饰符 → **private** | **private ( set )** +> 访问级别修饰符 → **public** | **public ( set )** diff --git a/source/chapter3/07_Attributes.md b/source/chapter3/07_Attributes.md index 63a0c91b..1ff946b1 100755 --- a/source/chapter3/07_Attributes.md +++ b/source/chapter3/07_Attributes.md @@ -9,7 +9,10 @@ > 翻译+校对：[KYawn](https://github.com/KYawn) > 2.1 -> 翻译：[小铁匠 Linus](https://github.com/kevin833752) +> 翻译：[小铁匠 Linus](https://github.com/kevin833752) + +> 4.1 +> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) 本页内容包括： @@ -215,24 +218,16 @@ convention 特性总是与下面的参数之一一起出现。 `escaping` 在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行，这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 声明特性的函数类型中访问属性和方法时不需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](http://wiki.jikexueyuan.com/project/swift/chapter2/07_Closures.html)。 -> 特性语法 - -> *特性 *→ @ 特性名 特性参数子句可选 - -> *特性名* → 标识符 - -> *特性参数子句* → ( 均衡令牌列表可选 ) - -> *特性列表* → 特性 特性列表可选 - -> *均衡令牌列表* → 均衡令牌 均衡令牌列表可选 - -> *均衡令牌* → ( 均衡令牌列表可选 ) - -> *均衡令牌* → [ 均衡令牌列表可选 ] - -> *均衡令牌* → { 均衡令牌列表可选} - -> *均衡令牌* → 任意标识符，关键字，字面量或运算符 - -> *均衡令牌* → 任意标点除了 (，)，[，]，{，或 } +> 特性语法 +> +> *特性 *→ @ 特性名 特性参数子句可选 +> *特性名* → 标识符 +> *特性参数子句* → ( 均衡令牌列表可选 ) +> *特性列表* → 特性 特性列表可选 +> +> *均衡令牌列表* → 均衡令牌 均衡令牌列表可选 +> *均衡令牌* → ( 均衡令牌列表可选 ) +> *均衡令牌* → [ 均衡令牌列表可选 ] +> *均衡令牌* → { 均衡令牌列表可选} +> *均衡令牌* → 任意标识符，关键字，字面量或运算符 +> *均衡令牌* → 任意标点除了 (，)，[，]，{，或 } diff --git a/source/chapter3/08_Patterns.md b/source/chapter3/08_Patterns.md index fb2251d3..ddc7f16f 100755 --- a/source/chapter3/08_Patterns.md +++ b/source/chapter3/08_Patterns.md @@ -10,6 +10,9 @@ > 2.1 > 翻译：[BridgeQ](https://github.com/WXGBridgeQ) + +> 4.1 +> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) 本页内容包括： @@ -22,7 +25,7 @@ - [类型转换模式（Type-Casting Pattern）](#type-casting_patterns) - [表达式模式（Expression Pattern）](#expression_pattern) -模式代表单个值或者复合值的结构。例如，元组 `(1, 2)` 的结构是由逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以利用模式来匹配各种各样的值。比如，`(x, y)` 可以匹配元组 `(1, 2)`，以及任何含两个元素的元组。除了利用模式匹配一个值以外，你可以从复合值中提取出部分或全部值，然后分别把各个部分的值和一个常量或变量绑定起来。 +*模式*代表单个值或者复合值的结构。例如，元组 `(1, 2)` 的结构是由逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以利用模式来匹配各种各样的值。比如，`(x, y)` 可以匹配元组 `(1, 2)`，以及任何含两个元素的元组。除了利用模式匹配一个值以外，你可以从复合值中提取出部分或全部值，然后分别把各个部分的值和一个常量或变量绑定起来。 Swift 中的模式分为两类：一种能成功匹配任何类型的值，另一种在运行时匹配某个特定值时可能会失败。 @@ -30,21 +33,22 @@ Swift 中的模式分为两类：一种能成功匹配任何类型的值，另 第二类模式用于全模式匹配，这种情况下你试图匹配的值在运行时可能不存在。此类模式包括枚举用例模式、可选模式、表达式模式和类型转换模式。你在 `switch` 语句的 `case` 标签中，`do` 语句的 `catch` 子句中，或者在 `if`、`while`、`guard` 和 `for-in` 语句的 `case` 条件句中使用这类模式。 -> 模式语法 +> 模式语法 +> -> *模式* → [*通配符模式*](#wildcard_pattern) [*类型标注*](03_Types.md#type-annotation)可选 -> *模式* → [*标识符模式*](#identifier_pattern) [*类型标注*](03_Types.md#type-annotation)可选 -> *模式* → [*值绑定模式*](#value-binding-pattern) -> *模式* → [*元组模式*](#tuple-pattern) [*类型标注*](03_Types.md#type-annotation)可选 -> *模式* → [*枚举用例模式*](#enum-case-pattern) -> *模式* → [*可选模式*](#optional-pattern) -> *模式* → [*类型转换模式*](#type-casting-pattern) -> *模式* → [*表达式模式*](#expression-pattern) +> *模式* → [*通配符模式*](#wildcard_pattern) [*类型标注*](03_Types.html#type-annotation)可选 +> *模式* → [*标识符模式*](#identifier_pattern) [*类型标注*](03_Types.html#type-annotation)可选 +> *模式* → [*值绑定模式*](#value-binding-pattern) +> *模式* → [*元组模式*](#tuple-pattern) [*类型标注*](03_Types.html#type-annotation)可选 +> *模式* → [*枚举用例模式*](#enum-case-pattern) +> *模式* → [*可选模式*](#optional-pattern) +> *模式* → [*类型转换模式*](#type-casting-pattern) +> *模式* → [*表达式模式*](#expression-pattern) ## 通配符模式（Wildcard Pattern） -通配符模式由一个下划线（`_`）构成，用于匹配并忽略任何值。当你想忽略被匹配的值时可以使用该模式。例如，下面这段代码在闭区间 `1...3` 中迭代，每次迭代都忽略该区间的当前值： +*通配符模式*由一个下划线（`_`）构成，用于匹配并忽略任何值。当你想忽略被匹配的值时可以使用该模式。例如，下面这段代码在闭区间 `1...3` 中迭代，每次迭代都忽略该区间的当前值： ```swift for _ in 1...3 { @@ -52,14 +56,15 @@ for _ in 1...3 { } ``` -> 通配符模式语法 +> 通配符模式语法 +> -> *通配符模式* → **_** +> *通配符模式* → **_** ## 标识符模式（Identifier Pattern） -标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量声明中，`someValue` 是一个标识符模式，匹配了 `Int` 类型的 `42`： +*标识符模式*匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量声明中，`someValue` 是一个标识符模式，匹配了 `Int` 类型的 `42`： ```swift let someValue = 42 @@ -69,14 +74,15 @@ let someValue = 42 如果一个变量或常量声明的左边是一个标识符模式，那么这个标识符模式是值绑定模式的子模式。 -> 标识符模式语法 +> 标识符模式语法 +> -> *标识符模式* → [*标识符*](02_Lexical_Structure.md#identifier) +> *标识符模式* → [*标识符*](02_Lexical_Structure.html#identifier) ## 值绑定模式（Value-Binding Pattern） -值绑定模式把匹配到的值绑定给一个变量或常量。把匹配到的值绑定给常量时，用关键字 `let`，绑定给变量时，用关键字 `var`。 +*值绑定模式*把匹配到的值绑定给一个变量或常量。把匹配到的值绑定给常量时，用关键字 `let`，绑定给变量时，用关键字 `var`。 在值绑定模式中的标识符模式会把新命名的变量或常量与匹配到的值做绑定。例如，你可以拆开一个元组，然后把每个元素绑定到相应的标识符模式中。 @@ -92,14 +98,15 @@ case let (x, y): 在上面这个例子中，`let` 会分配到元组模式 `(x, y)` 中的各个标识符模式。因此，`switch` 语句中 `case let (x, y):` 和 `case (let x, let y):` 的匹配效果是一样的。 -> 值绑定模式语法 +> 值绑定模式语法 +> -> *值绑定模式* → **var** [*模式*](#pattern) | **let** [*模式*](#pattern) +> *值绑定模式* → **var** [*模式*](#pattern) | **let** [*模式*](#pattern) ## 元组模式 -元组模式是由逗号分隔的，具有零个或多个模式的列表，并由一对圆括号括起来。元组模式匹配相应元组类型的值。 +*元组模式*是由逗号分隔的，具有零个或多个模式的列表，并由一对圆括号括起来。元组模式匹配相应元组类型的值。 你可以使用类型标注去限制一个元组模式能匹配哪种元组类型。例如，在常量声明 `let (x, y): (Int, Int) = (1, 2)` 中的元组模式 `(x, y): (Int, Int)` 只匹配两个元素都是 `Int` 类型的元组。 @@ -121,29 +128,31 @@ let (a) = 2 // a: Int = 2 let (a): Int = 2 // a: Int = 2 ``` -> 元组模式语法 +> 元组模式语法 +> -> *元组模式* → **(** [*元组模式元素列表*](#tuple-pattern-element-list)可选 **)** +> *元组模式* → **(** [*元组模式元素列表*](#tuple-pattern-element-list)可选 **)** -> *元组模式元素列表* → [*元组模式元素*](#tuple-pattern-element) | [*元组模式元素*](#tuple-pattern-element) **,** [*元组模式元素列表*](#tuple-pattern-element-list) +> *元组模式元素列表* → [*元组模式元素*](#tuple-pattern-element) | [*元组模式元素*](#tuple-pattern-element) **,** [*元组模式元素列表*](#tuple-pattern-element-list) -> *元组模式元素* → [*模式*](#pattern) +> *元组模式元素* → [*模式*](#pattern) ## 枚举用例模式（Enumeration Case Pattern） -枚举用例模式匹配现有的某个枚举类型的某个用例。枚举用例模式出现在 `switch` 语句中的 `case` 标签中，以及 `if`、`while`、`guard` 和 `for-in` 语句的 `case` 条件中。 +*枚举用例模式*匹配现有的某个枚举类型的某个用例。枚举用例模式出现在 `switch` 语句中的 `case` 标签中，以及 `if`、`while`、`guard` 和 `for-in` 语句的 `case` 条件中。 -如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../chapter2/08_Enumerations.md#associated_values)。 +如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../chapter2/08_Enumerations.html#associated_values)。 -> 枚举用例模式语法 +> 枚举用例模式语法 +> -> *枚举用例模式* → [*类型标识*](03_Types.md#type-identifier)可选 **.** [*枚举用例名*](05_Declarations.md#enum-case-name) [*元组模式*](#tuple-pattern)可选 +> *枚举用例模式* → [*类型标识*](03_Types.html#type-identifier)可选 **.** [*枚举用例名*](05_Declarations.html#enum-case-name) [*元组模式*](#tuple-pattern)可选 ## 可选模式（Optional Pattern） -可选模式匹配包装在一个 `Optional(Wrapped)` 或者 `ExplicitlyUnwrappedOptional(Wrapped)` 枚举中的 `Some(Wrapped)` 用例中的值。可选模式由一个标识符模式和紧随其后的一个问号组成，可以像枚举用例模式一样使用。 +*可选模式*匹配包装在一个 `Optional(Wrapped)` 或者 `ExplicitlyUnwrappedOptional(Wrapped)` 枚举中的 `Some(Wrapped)` 用例中的值。可选模式由一个标识符模式和紧随其后的一个问号组成，可以像枚举用例模式一样使用。 由于可选模式是 `Optional` 和 `ImplicitlyUnwrappedOptional` 枚举用例模式的语法糖，下面两种写法是等效的： @@ -173,9 +182,10 @@ for case let number? in arrayOfOptinalInts { // Found a 5 ``` -> 可选模式语法 +> 可选模式语法 +> -> *可选模式* → [*标识符模式*](03_Types.md#type-identifier) **?** +> *可选模式* → [*标识符模式*](03_Types.html#type-identifier) **?** ## 类型转换模式（Type-Casting Patterns） @@ -189,20 +199,21 @@ for case let number? in arrayOfOptinalInts { `as` 模式仅当一个值的类型在运行时和 `as` 模式右边的指定类型一致，或者是其子类的情况下，才会匹配这个值。如果匹配成功，被匹配的值的类型被转换成 `as` 模式右边指定的类型。 -关于使用 `switch` 语句配合 `is` 模式和 `as` 模式来匹配值的例子，请参阅 [Any 和 AnyObject 的类型转换](../chapter2/19_Type_Casting.md#type_casting_for_any_and_anyobject)。 +关于使用 `switch` 语句配合 `is` 模式和 `as` 模式来匹配值的例子，请参阅 [Any 和 AnyObject 的类型转换](../chapter2/18_Type_Casting.html#type_casting_for_any_and_anyobject)。 -> 类型转换模式语法 +> 类型转换模式语法 +> -> *类型转换模式* → [*is 模式*](#is-pattern) | [*as 模式*](#as-pattern) +> *类型转换模式* → [*is 模式*](#is-pattern) | [*as 模式*](#as-pattern) -> *is 模式* → **is** [*类型*](03_Types.md#type) +> *is 模式* → **is** [*类型*](03_Types.html#type) -> *as 模式* → [*模式*](#pattern) **as** [*类型*](03_Types.md#type) +> *as 模式* → [*模式*](#pattern) **as** [*类型*](03_Types.html#type) ## 表达式模式（Expression Pattern） -表达式模式代表表达式的值。表达式模式只出现在 `switch` 语句中的 `case` 标签中。 +*表达式模式*代表表达式的值。表达式模式只出现在 `switch` 语句中的 `case` 标签中。 表达式模式代表的表达式会使用 Swift 标准库中的 `~=` 运算符与输入表达式的值进行比较。如果 `~=` 运算符返回 `true`，则匹配成功。默认情况下，`~=` 运算符使用 `==` 运算符来比较两个相同类型的值。它也可以将一个整型数值与一个 `Range` 实例中的一段整数区间做匹配，正如下面这个例子所示： @@ -236,6 +247,7 @@ default: // 打印 “The point is at (1, 2).” ``` -> 表达式模式语法 +> 表达式模式语法 +> -> *表达式模式* → [*表达式*](04_Expressions.md#expression) +> *表达式模式* → [*表达式*](04_Expressions.html#expression) diff --git a/source/chapter3/09_Generic_Parameters_and_Arguments.md b/source/chapter3/09_Generic_Parameters_and_Arguments.md index 2dbaa840..43fad622 100755 --- a/source/chapter3/09_Generic_Parameters_and_Arguments.md +++ b/source/chapter3/09_Generic_Parameters_and_Arguments.md @@ -9,7 +9,10 @@ > 翻译+校对：[wardenNScaiyi](https:github.com/wardenNScaiyi) > 3.0 -> 翻译+校对：[chenmingjia](https:github.com/chenmingjia) +> 翻译+校对：[chenmingjia](https:github.com/chenmingjia) + +> 4.1 +> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) 本页包含内容： @@ -19,12 +22,12 @@ 本节涉及泛型类型、泛型函数以及泛型构造器的参数，包括形参和实参。声明泛型类型、函数或构造器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型构造器时，就用具体的类型实参替代之。 -关于 Swift 语言的泛型概述，请参阅 [泛型](../chapter2/23_Generics.md)。 +关于 Swift 语言的泛型概述，请参阅 [泛型](../chapter2/22_Generics.html)。 ## 泛型形参子句 -泛型形参子句指定泛型类型或函数的类型形参，以及这些参数相关的约束和要求。泛型形参子句用尖括号（`<>`）包住，形式如下： +*泛型形参子句*指定泛型类型或函数的类型形参，以及这些参数相关的约束和要求。泛型形参子句用尖括号（`<>`）包住，形式如下： > <`泛型形参列表`> @@ -67,36 +70,36 @@ simpleMax(3.14159, 2.71828) // T 被推断为 Double 类型 泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会根据这些约束来决定调用哪个重载函数或构造器。 -更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](https://github.com/numbbbbb/the-swift-programming-language-in-chinese/blob/gh-pages/source/chapter2/23_Generics.md#where_clauses) - -> 泛型形参子句语法 +更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](https://github.com/numbbbbb/the-swift-programming-language-in-chinese/blob/gh-pages/source/chapter2/22_Generics.html#where_clauses) +> 泛型形参子句语法 +> -> *泛型形参子句* → **<** [*泛型形参列表*](#generic-parameter-list) [*约束子句*](#requirement-clause)可选 **>** +> *泛型形参子句* → **<** [*泛型形参列表*](#generic-parameter-list) [*约束子句*](#requirement-clause)可选 **>** -> *泛型形参列表* → [*泛形形参*](#generic-parameter) | [*泛形形参*](#generic-parameter) **,** [*泛型形参列表*](#generic-parameter-list) +> *泛型形参列表* → [*泛形形参*](#generic-parameter) | [*泛形形参*](#generic-parameter) **,** [*泛型形参列表*](#generic-parameter-list) -> *泛形形参* → [*类型名称*](03_Types.html#type-name) -> *泛形形参* → [*类型名称*](03_Types.html#type-name) **:** [*类型标识符*](03_Types.html#type-identifier) -> *泛形形参* → [*类型名称*](03_Types.html#type-name) **:** [*协议合成类型*](03_Types.html#protocol-composition-type) +> *泛形形参* → [*类型名称*](03_Types.html#type-name) +> *泛形形参* → [*类型名称*](03_Types.html#type-name) **:** [*类型标识符*](03_Types.html#type-identifier) +> *泛形形参* → [*类型名称*](03_Types.html#type-name) **:** [*协议合成类型*](03_Types.html#protocol-composition-type) -> *约束子句* → **where** [*约束列表*](#requirement-list) +> *约束子句* → **where** [*约束列表*](#requirement-list) -> *约束列表* → [*约束*](#requirement) | [*约束*](#requirement) **,** [*约束列表*](#requirement-list) +> *约束列表* → [*约束*](#requirement) | [*约束*](#requirement) **,** [*约束列表*](#requirement-list) -> *约束* → [*一致性约束*](#conformance-requirement) | [*同类型约束*](#same-type-requirement) +> *约束* → [*一致性约束*](#conformance-requirement) | [*同类型约束*](#same-type-requirement) -> *一致性约束* → [*类型标识符*](03_Types.html#type-identifier) **:** [*类型标识符*](03_Types.html#type-identifier) -> *一致性约束* → [*类型标识符*](03_Types.html#type-identifier) **:** [*协议合成类型*](03_Types.html#protocol-composition-type) +> *一致性约束* → [*类型标识符*](03_Types.html#type-identifier) **:** [*类型标识符*](03_Types.html#type-identifier) +> *一致性约束* → [*类型标识符*](03_Types.html#type-identifier) **:** [*协议合成类型*](03_Types.html#protocol-composition-type) -> *同类型约束* → [*类型标识符*](03_Types.html#type-identifier) **==** [*类型*](03_Types.html#type) +> *同类型约束* → [*类型标识符*](03_Types.html#type-identifier) **==** [*类型*](03_Types.html#type) ## 泛型实参子句 -泛型实参子句指定泛型类型的类型实参。泛型实参子句用尖括号（`<>`）包住，形式如下： +*泛型实参子句*指定泛型类型的类型实参。泛型实参子句用尖括号（`<>`）包住，形式如下： > <`泛型实参列表`> @@ -118,10 +121,11 @@ let arrayOfArrays: Array> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 如 [泛型形参子句](#generic_parameter) 所述，不能用泛型实参子句来指定泛型函数或构造器的类型实参。 -> 泛型实参子句语法 +> 泛型实参子句语法 +> -> *泛型实参子句* → **<** [*泛型实参列表*](#generic-argument-list) **>** +> *泛型实参子句* → **<** [*泛型实参列表*](#generic-argument-list) **>** -> *泛型实参列表* → [*泛型实参*](#generic-argument) | [*泛型实参*](#generic-argument) **,** [*泛型实参列表*](#generic-argument-list) +> *泛型实参列表* → [*泛型实参*](#generic-argument) | [*泛型实参*](#generic-argument) **,** [*泛型实参列表*](#generic-argument-list) > *泛型实参* → [*类型*](03_Types.html#type) diff --git a/source/chapter3/10_Summary_of_the_Grammar.md b/source/chapter3/10_Summary_of_the_Grammar.md index 2565a474..6bee1b31 100755 --- a/source/chapter3/10_Summary_of_the_Grammar.md +++ b/source/chapter3/10_Summary_of_the_Grammar.md @@ -6,7 +6,10 @@ > 校对：[xielingwang](https://github.com/xielingwang) > 2.0 -> 翻译+校对：[miaosiqi](https://github.com/miaosiqi) +> 翻译+校对：[miaosiqi](https://github.com/miaosiqi) + +> 4.1 +> 翻译+校对：[mylittleswift](https://github.com/mylittleswift) 本页包含内容： @@ -22,918 +25,939 @@ ## 语句 -> 语句语法 -> *语句* → [*表达式*](../chapter3/04_Expressions.html#expression) **;** _可选_ -> *语句* → [*声明*](../chapter3/05_Declarations.html#declaration) **;** _可选_ +> 语句语法 +> +> *语句* → [*表达式*](../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) **;** _可选_ -> *语句* → [*延迟语句*](TODO) **;** _可选_ +> *语句* → [*分支语句*](../chapter3/10_Statements.html#branch_statement) **;** _可选_ +> *语句* → [*标记语句(Labeled Statement)*](../chapter3/10_Statements.html#labeled_statement) +> *语句* → [*控制转移语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_ +> *语句* → [*延迟语句*](TODO) **;** _可选_ -> *语句* → [*执行语句*](TODO) **;** _可选_ +> *语句* → [*执行语句*](TODO) **;** _可选_ -> *多条语句(Statements)* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ +> *多条语句(Statements)* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ -> 循环语句语法 -> *循环语句* → [*for 语句*](../chapter3/10_Statements.html#for_statement) -> *循环语句* → [*for-in 语句*](../chapter3/10_Statements.html#for_in_statement) -> *循环语句* → [*while 语句*](../chapter3/10_Statements.html#wheetatype 类型 ile_statement) -> *循环语句* → [*repeat-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) +> *循环语句* → [*repeat-while 语句*](../chapter3/10_Statements.html#do_while_statement) -> 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** [*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-In 循环语法 -> *for-in 语句* → **for case** _可选_ [*模式*](../chapter3/07_Patterns.html#pattern) **in** [*表达式*](../chapter3/04_Expressions.html#expression) [*代码块*](../chapter3/05_Declarations.html#code_block) [*where 从句*](TODO) _可选_ +> For-In 循环语法 +> +> *for-in 语句* → **for case** _可选_ [*模式*](../chapter3/07_Patterns.html#pattern) **in** [*表达式*](../chapter3/04_Expressions.html#expression) [*代码块*](../chapter3/05_Declarations.html#code_block) [*where 从句*](TODO) _可选_ -> While 循环语法 -> *while 语句* → **while** [*条件从句*](../chapter3/10_Statements.html#while_condition) [*代码块*](../chapter3/05_Declarations.html#code_block) -> *条件从句* → [*表达式*](TODO) - -> *条件从句* → [*表达式*](TODO) *,* [*表达式集*]() - -> *条件从句* → [*表达式集*](TODO) - -> *条件从句* → [*可用条件 (availability-condition*)](TODO) *|* [*表达式集*]() - -> *条件集* → [*条件*](TODO) *|* [*条件*](TODO) *,* [*条件集*]() - -> *条件* → [*可用条件(availability-condition)*](TODO) *|* [*个例条件(case-condition)*](TODO) *|* [*可选绑定条件(optional-binding-condition)*](TODO) - -> *个例条件(case-condition)* → **case** [*模式*](TODO) [*构造器*](TODO) [*where 从句*](TODO)_可选_ - -> *可选绑定条件(optional-binding-condition)* → [*可选绑定头(optional-binding-head)*](TODO) [*可选绑定连续集(optional-binding-continuation-list)*](TODO) _可选_ [*where 从句*](TODO) _可选_ - -> *可选绑定头(optional-binding-head)* → **let** [*模式 构造器*](TODO) *|* **var** [*模式 构造器*](TODO) - -> *可选绑定连续集(optional-binding-contiuation-list)* → [*可选绑定连续(optional-binding-contiuation)*](TODO) *|* [*可选绑定连续(optional-binding-contiuation)*](TODO) *，* [*可选绑定连续集(optional-binding-contiuation-list)*](TODO) - -> *可选绑定连续(optional-binding-continuation)* → [*模式 构造器*](TODO) *|* [*可选绑定头(optional-binding-head)*](TODO) +> While 循环语法 +> +> *while 语句* → **while** [*条件从句*](../chapter3/10_Statements.html#while_condition) [*代码块*](../chapter3/05_Declarations.html#code_block) +> *条件从句* → [*表达式*](TODO) +> *条件从句* → [*表达式*](TODO) *,* [*表达式集*]() +> *条件从句* → [*表达式集*](TODO) +> *条件从句* → [*可用条件 (availability-condition*)](TODO) *|* [*表达式集*]() +> *条件集* → [*条件*](TODO) *|* [*条件*](TODO) *,* [*条件集*]() +> *条件* → [*可用条件(availability-condition)*](TODO) *|* [*个例条件(case-condition)*](TODO) *|* [*可选绑定条件(optional-binding-condition)*](TODO) +> *个例条件(case-condition)* → **case** [*模式*](TODO) [*构造器*](TODO) [*where 从句*](TODO)_可选_ +> *可选绑定条件(optional-binding-condition)* → [*可选绑定头(optional-binding-head)*](TODO) [*可选绑定连续集(optional-binding-continuation-list)*](TODO) _可选_ [*where 从句*](TODO) _可选_ +> *可选绑定头(optional-binding-head)* → **let** [*模式 构造器*](TODO) *|* **var** [*模式 构造器*](TODO) +> *可选绑定连续集(optional-binding-contiuation-list)* → [*可选绑定连续(optional-binding-contiuation)*](TODO) *|* [*可选绑定连续(optional-binding-contiuation)*](TODO) *，* [*可选绑定连续集(optional-binding-contiuation-list)*](TODO) +> *可选绑定连续(optional-binding-continuation)* → [*模式 构造器*](TODO) *|* [*可选绑定头(optional-binding-head)*](TODO) -> Repeat-While 语句语法 -*repeat-while-statement* → **repeat** [*代码块*](TODO) **while** [*表达式*](TODO) +> Repeat-While 语句语法 +> +*repeat-while-statement* → **repeat** [*代码块*](TODO) **while** [*表达式*](TODO) -> 分支语句语法 +> 分支语句语法 +> > *分支语句* → [*if 语句*](../chapter3/10_Statements.html#if_statement) - -> *分支语句* → [*guard 语句*](TODO) - -> *分支语句* → [*switch 语句*](../chapter3/10_Statements.html#switch_statement) +> *分支语句* → [*guard 语句*](TODO) +> *分支语句* → [*switch 语句*](../chapter3/10_Statements.html#switch_statement) -> If 语句语法 -> *if 语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else 从句(Clause)*](TODO) _可选_ - -> *else 从句(Clause)* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if 语句*](../chapter3/10_Statements.html#if_statement) +> If 语句语法 +> +> *if 语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else 从句(Clause)*](TODO) _可选_ +> *else 从句(Clause)* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if 语句*](../chapter3/10_Statements.html#if_statement) -> Guard 语句语法 -> *guard 语句* → **guard** [*条件从句*](TODO) **else** [*代码块*](TODO) +> Guard 语句语法 +> +> *guard 语句* → **guard** [*条件从句*](TODO) **else** [*代码块*](TODO) -> 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) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ | [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ **,** [*case 项集*](../chapter3/10_Statements.html#case_item_list) -> *default 标签* → **default** **:** -> *where 从句* → **where** [*where 表达式*](TODO) -> *where 表达式* → [*表达式*](TODO) +> 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) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ | [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ **,** [*case 项集*](../chapter3/10_Statements.html#case_item_list) +> *default 标签* → **default** **:** +> *where 从句* → **where** [*where 表达式*](TODO) +> *where 表达式* → [*表达式*](TODO) -> 标记语句语法 -> *标记语句(Labeled Statement)* → [*语句标签*](../chapter3/10_Statements.html#statement_label) [*循环语句*](../chapter3/10_Statements.html#loop_statement) | [*语句标签*](../chapter3/10_Statements.html#statement_label) [*if 语句*](../chapter3/10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch 语句*](TODY) -> *语句标签* → [*标签名称*](../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) [*if 语句*](../chapter3/10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch 语句*](TODY) +> *语句标签* → [*标签名称*](../chapter3/10_Statements.html#label_name) **:** +> *标签名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> 控制传递语句(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 语句*](TODO) +> 控制传递语句(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 语句*](TODO) -> Break 语句语法 -> *break 语句* → **break** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_ +> Break 语句语法 +> +> *break 语句* → **break** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_ -> Continue 语句语法 -> *continue 语句* → **continue** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_ +> Continue 语句语法 +> +> *continue 语句* → **continue** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_ -> Fallthrough 语句语法 -> *fallthrough 语句* → **fallthrough** +> Fallthrough 语句语法 +> +> *fallthrough 语句* → **fallthrough** -> Return 语句语法 -> *return 语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ +> Return 语句语法 +> +> *return 语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ -> 可用条件(Availability Condition)语法 - -> *可用条件(availability-condition)* → **#available** **(** [*多可用参数*(availability-arguments)](TODO) **)** - -> *多可用参数(availability- arguments)* → [*可用参数(availability-argument)*](TODO)|[*可用参数(availability-argument)*](TODO) , [多可用参数(availability-arguments)](TODO) - -> *可用参数(availability- argument)* → [*平台名(platform-name)*](TODO) [*平台版本(platform-version)*](TODO) - -> *可用参数(availability- argument)* → * - -> *平台名* → **iOS** | **iOSApplicationExtension** - -> *平台名* → **OSX** | **OSXApplicationExtension** - -> *平台名* → **watchOS** - -> *平台版本* → [*十进制数(decimal-digits)*](TODO) - -> *平台版本* → [*十进制数(decimal-digits)*](TODO) . [*十进制数(decimal-digits)*](TODO) - -> *平台版本* → [*十进制数(decimal-digits)*](TODO) **.** [*十进制数(decimal-digits)*](TODO) **.** [*十进制数（decimal-digits)*](TODO)) +> 可用条件(Availability Condition)语法 +> +> *可用条件(availability-condition)* → **#available** **(** [*多可用参数*(availability-arguments)](TODO) **)** +> *多可用参数(availability- arguments)* → [*可用参数(availability-argument)*](TODO)|[*可用参数(availability-argument)*](TODO) , [多可用参数(availability-arguments)](TODO) +> *可用参数(availability- argument)* → [*平台名(platform-name)*](TODO) [*平台版本(platform-version)*](TODO) +> *可用参数(availability- argument)* → * +> +> *平台名* → **iOS** | **iOSApplicationExtension** +> *平台名* → **OSX** | **macOSApplicationExtension** +> *平台名* → **watchOS** +> *平台名* → **tvOS** +> *平台版本* → [*十进制数(decimal-digits)*](TODO) +> *平台版本* → [*十进制数(decimal-digits)*](TODO) . [*十进制数(decimal-digits)*](TODO) +> *平台版本* → [*十进制数(decimal-digits)*](TODO) **.** [*十进制数(decimal-digits)*](TODO) **.** [*十进制数（decimal-digits)*](TODO)) -> 抛出语句(Throw Statement)语法 - -> *抛出语句(throw-statement)* → **throw** [*表达式(expression)*](TODO) +> 抛出语句(Throw Statement)语法 +> +> *抛出语句(throw-statement)* → **throw** [*表达式(expression)*](TODO) -> 延迟语句 (defer-statement)语法 - +> 延迟语句 (defer-statement)语法 +> > *延迟语句(defer-statement)* → **defer** [*代码块*](TODO) -> 执行语句(do-statement)语法 - -> *执行语句(do-statement)* → **do** [*代码块*](TODO) [*catch-clauses*](TODO) _可选_ - -> *catch-clauses* → [*catch-clause*](TODO) [*catch-clauses*](TODO) _可选_ - -> *catch-clauses* → **catch** [*模式(pattern)*](TODO) _可选_ [*where-clause*](TODO) _可选_ [*代码块(code-block)*](TODO) _可选_ +> 执行语句(do-statement)语法 +> +> *执行语句(do-statement)* → **do** [*代码块*](TODO) [*catch-clauses*](TODO) _可选_ +> *catch-clauses* → [*catch-clause*](TODO) [*catch-clauses*](TODO) _可选_ +> *catch-clauses* → **catch** [*模式(pattern)*](TODO) _可选_ [*where-clause*](TODO) _可选_ [*代码块(code-block)*](TODO) _可选_ ## 泛型参数 -> 泛型形参从句(Generic Parameter Clause) 语法 -> *泛型参数从句* → **<** [*泛型参数集*](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) -> *约束从句* → **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) +> 泛型形参从句(Generic Parameter Clause) 语法 +> +> *泛型参数从句* → **<** [*泛型参数集*](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) +> *约束从句* → **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) -> 泛型实参从句语法 -> *(泛型参数从句 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) +> 泛型实参从句语法 +> +> *(泛型参数从句 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) ## 声明 (Declarations) -> 声明语法 -> *声明* → [*导入声明*](../chapter3/05_Declarations.html#import_declaration) -> *声明* → [*常量声明*](../chapter3/05_Declarations.html#constant_declaration) -> *声明* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration) -> *声明* → [*类型别名声明*](../chapter3/05_Declarations.html#typealias_declaration) -> *声明* → [*函数声明*](../chapter3/05_Declarations.html#function_declaration) -> *声明* → [*枚举声明*](../chapter3/05_Declarations.html#enum_declaration) -> *声明* → [*结构体声明*](../chapter3/05_Declarations.html#struct_declaration) -> *声明* → [*类声明*](../chapter3/05_Declarations.html#class_declaration) -> *声明* → [*协议声明*](../chapter3/05_Declarations.html#protocol_declaration) -> *声明* → [*构造器声明*](../chapter3/05_Declarations.html#initializer_declaration) -> *声明* → [*析构器声明*](../chapter3/05_Declarations.html#deinitializer_declaration) -> *声明* → [*扩展声明*](../chapter3/05_Declarations.html#extension_declaration) -> *声明* → [*下标声明*](../chapter3/05_Declarations.html#subscript_declaration) -> *声明* → [*运算符声明*](../chapter3/05_Declarations.html#operator_declaration) -> *声明(Declarations)集* → [*声明*](../chapter3/05_Declarations.html#declaration) [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ +> 声明语法 +> +> *声明* → [*导入声明*](../chapter3/05_Declarations.html#import_declaration) +> *声明* → [*常量声明*](../chapter3/05_Declarations.html#constant_declaration) +> *声明* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration) +> *声明* → [*类型别名声明*](../chapter3/05_Declarations.html#typealias_declaration) +> *声明* → [*函数声明*](../chapter3/05_Declarations.html#function_declaration) +> *声明* → [*枚举声明*](../chapter3/05_Declarations.html#enum_declaration) +> *声明* → [*结构体声明*](../chapter3/05_Declarations.html#struct_declaration) +> *声明* → [*类声明*](../chapter3/05_Declarations.html#class_declaration) +> *声明* → [*协议声明*](../chapter3/05_Declarations.html#protocol_declaration) +> *声明* → [*构造器声明*](../chapter3/05_Declarations.html#initializer_declaration) +> *声明* → [*析构器声明*](../chapter3/05_Declarations.html#deinitializer_declaration) +> *声明* → [*扩展声明*](../chapter3/05_Declarations.html#extension_declaration) +> *声明* → [*下标声明*](../chapter3/05_Declarations.html#subscript_declaration) +> *声明* → [*运算符声明*](../chapter3/05_Declarations.html#operator_declaration) +> *声明(Declarations)集* → [*声明*](../chapter3/05_Declarations.html#declaration) [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ -> 顶级(Top Level) 声明语法 -> *顶级声明* → [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ +> 顶级(Top Level) 声明语法 +> +> *顶级声明* → [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ -> 代码块语法 -> *代码块* → **{** [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ **}** +> 代码块语法 +> +> *代码块* → **{** [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ **}** -> 导入(Import)声明语法 -> *导入声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **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/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator) +> 导入(Import)声明语法 +> +> *导入声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **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/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> 常数声明语法 -> *常量声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符(Modifiers)集*](../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) _可选_ [*声明修改符(Modifiers)集*](../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) -> 变量声明语法 -> *变量声明* → [*变量声明头(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/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) _可选_ [*声明修改符(Modifers)集*](../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/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) _可选_ [*声明修改符(Modifers)集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var** > *变量名称* → [*标识符*](../chapter3/02_Lexical_Structure.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) -> *setter 名称* → **(** [*标识符*](../chapter3/02_Lexical_Structure.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-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 名称* → **(** [*标识符*](../chapter3/02_Lexical_Structure.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) +> *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) -> 类型别名声明语法 -> *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) -> *类型别名头(Head)* → [*属性*](TODO) _可选_ [*访问级别修改符(access-level-modifier)*](TODO) **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name) -> *类型别名名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type) +> 类型别名声明语法 +> +> *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) +> *类型别名头(Head)* → [*属性*](TODO) _可选_ [*访问级别修改符(access-level-modifier)*](TODO) **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name) +> *类型别名名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type) -> 函数声明语法 -> *函数声明* → [*函数头*](../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/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> *函数签名(Signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** _可选_ [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ +> 函数声明语法 +> +> *函数声明* → [*函数头*](../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/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.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) -> *参数从句* → [*参数从句*](../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) -> *外部参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** -> *本地参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** -> *默认参数从句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression) +> *函数签名(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) +> *参数从句* → [*参数从句*](../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) +> *外部参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** +> *本地参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** +> *默认参数从句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression) -> 枚举声明语法 -> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*联合式枚举*](../chapter3/05_Declarations.html#union_style_enum) - -> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*原始值式枚举(raw-value-style-enum)*](TODO) - -> *联合式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句(type-inheritance-clause)*](TODO) _可选_ **{** [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}** - -> *联合样式枚举成员* → [*union-style-enum-member*](../chapter3/05_Declarations.html#union_style_enum_member) [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ - -> *联合样式枚举成员* → [*声明*](../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) _可选_ **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) _可选_ -> *枚举名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *枚举的 case 名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *原始值式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](../chapter3/03_Types.html#type_identifier) **{** [*原始值式枚举成员集*](../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) _可选_ -> *原始值赋值* → **=** [*字面量*](../chapter3/02_Lexical_Structure.html#literal) -> *原始值字面量(raw-value-literal)* → [*数值字面量*](TODO) | [*字符串字面量*](TODO) | [*布尔字面量*](TODO) +> 枚举声明语法 +> +> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*联合式枚举*](../chapter3/05_Declarations.html#union_style_enum) +> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*原始值式枚举(raw-value-style-enum)*](TODO) +> *联合式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句(type-inheritance-clause)*](TODO) _可选_ **{** [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}** +> *联合样式枚举成员* → [*union-style-enum-member*](../chapter3/05_Declarations.html#union_style_enum_member) [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ +> *联合样式枚举成员* → [*声明*](../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) _可选_ **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) _可选_ +> *枚举名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *枚举的 case 名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *原始值式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](../chapter3/03_Types.html#type_identifier) **{** [*原始值式枚举成员集*](../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) _可选_ +> *原始值赋值* → **=** [*字面量*](../chapter3/02_Lexical_Structure.html#literal) +> *原始值字面量(raw-value-literal)* → [*数值字面量*](TODO) | [*字符串字面量*](TODO) | [*布尔字面量*](TODO) -> 结构体声明语法 -> *结构体声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](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) -> *结构体名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *结构体主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> 结构体声明语法 +> +> *结构体声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](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) +> *结构体名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *结构体主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** -> 类声明语法 -> *类声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](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) -> *类名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *类主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> 类声明语法 +> +> *类声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](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) +> *类名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *类主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** -> 协议(Protocol)声明语法 -> *协议声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_[*访问级别修改器(access-level-modifier)*](TODO) **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body) -> *协议名* → [*标识符*](../chapter3/02_Lexical_Structure.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) _可选_ +> 协议(Protocol)声明语法 +> +> *协议声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_[*访问级别修改器(access-level-modifier)*](TODO) **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body) +> *协议名* → [*标识符*](../chapter3/02_Lexical_Structure.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) _可选_ -> 协议属性声明语法 -> *协议属性声明* → [*变量声明头(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) -> 协议方法声明语法 -> *协议方法声明* → [*函数头*](../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) -> 协议构造器声明语法 +> 协议构造器声明语法 +> > *协议构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) -> 协议下标声明语法 +> 协议下标声明语法 +> > *协议下标声明* → [*下标头(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#typealias_head) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) _可选_ -> 构造器声明语法 -> *构造器声明* → [*构造器头(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) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init** -> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init ?** - -> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-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) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init** +> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init ?** +> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init !** +> *构造器主体* → [*代码块*](../chapter3/05_Declarations.html#code_block) -> 析构器声明语法 +> 析构器声明语法 +> > *析构器声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](../chapter3/05_Declarations.html#code_block) -> 扩展(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)声明语法 +> +> *扩展声明* → [*访问级别修改器*](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) _可选_ **}** -> 下标声明语法 -> *下标声明* → [*下标头(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) -> 运算符声明语法 -> *运算符声明* → [*前置运算符声明*](../chapter3/05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](../chapter3/05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](../chapter3/05_Declarations.html#infix_operator_declaration) -> *前置运算符声明* → **prefix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}** -> *后置运算符声明* → **postfix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}** -> *中置运算符声明* → **infix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.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) +> 运算符声明语法 +> +> *运算符声明* → [*前置运算符声明*](../chapter3/05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](../chapter3/05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](../chapter3/05_Declarations.html#infix_operator_declaration) +> *前置运算符声明* → **prefix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}** +> *后置运算符声明* → **postfix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}** +> *中置运算符声明* → **infix** **运算符** [*运算符*](../chapter3/02_Lexical_Structure.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) -> *结和性* → **left** | **right** | **none** +> *结和性从句* → **associativity** [*结和性*](../chapter3/05_Declarations.html#associativity) +> *结和性* → **left** | **right** | **none** -声明修改器语法 -> *声明修改器* → **类** | **便捷(convenience)** | **动态(dynamic)** | **final** | **中置(infix)** | **lazy** | **可变(mutating)** | **不可变(nonmutating)** | **可选(optional)** | **改写(override)** | **后置** | **前置** | **required** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **弱(weak)** - -> *声明修改器* → [*访问级别声明器(access-level-modifier)*](TODO) - -> *声明修改集* → [*声明修改器*](TODO) [*声明修改器集*](TODO) _可选_ - -> *访问级别修改器* → **内部的** | **内部的(set)** - -> *访问级别修改器* → **私有的** | **私有的(set)** - +> 声明修改器语法 +> +> *声明修改器* → **类** | **便捷(convenience)** | **动态(dynamic)** | **final** | **中置(infix)** | **lazy** | **可变(mutating)** | **不可变(nonmutating)** | **可选(optional)** | **改写(override)** | **后置** | **前置** | **required** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **弱(weak)** +> *声明修改器* → [*访问级别声明器(access-level-modifier)*](TODO) +> *声明修改集* → [*声明修改器*](TODO) [*声明修改器集*](TODO) _可选_ +> *访问级别修改器* → **内部的** | **内部的(set)** +> *访问级别修改器* → **私有的** | **私有的(set)** > *访问级别修改器* → **公共的** -| **公共的(set)** - +| **公共的(set)** > *访问级别修改器集* →[*访问级别修改器*](TODO) [*访问级别修改器集*](TODO) _可选_ ## 模式 -> 模式(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 Bindingon ) _可选_ -> *模式* → [*值绑定模式*](../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) -> *模式* → [*可选模式*](TODO) -> *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern) -> *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern) +> 模式(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 Bindingon ) _可选_ +> *模式* → [*值绑定模式*](../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) +> *模式* → [*可选模式*](TODO) +> *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern) +> *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern) -> 通配符模式语法 +> 通配符模式语法 +> > *通配符模式* → **_** -> 标识符模式语法 +> 标识符模式语法 +> > *标识符模式* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> 值绑定(Value Binding)模式语法 +> 值绑定(Value Binding)模式语法 +> > *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../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#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) -> 枚举用例模式语法 +> 枚举用例模式语法 +> > *enum-case-pattern* → [*类型标识*](../chapter3/03_Types.html#type_identifier) _可选_ **.** [*枚举的 case 名*](../chapter3/05_Declarations.html#enum_case_name) [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) _可选_ -> 可选模式语法 +> 可选模式语法 +> > *可选模式* → [*识别符模式*](TODO) **?** -> 类型转换模式语法 -> *类型转换模式(type-casting-pattern)* → [*is 模式*](../chapter3/07_Patterns.html#is_pattern) | [*as 模式*](../chapter3/07_Patterns.html#as_pattern) -> *is 模式* → **is** [*类型*](../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) -> 表达式模式语法 +> 表达式模式语法 +> > *表达式模式* → [*表达式*](../chapter3/04_Expressions.html#expression) ## 属性 -> 属性语法 -> *属性* → **@** [*属性名*](../chapter3/06_Attributes.html#attribute_name) [*属性参数从句*](../chapter3/06_Attributes.html#attribute_argument_clause) _可选_ +> 属性语法 +> +> *属性* → **@** [*属性名*](../chapter3/06_Attributes.html#attribute_name) [*属性参数从句*](../chapter3/06_Attributes.html#attribute_argument_clause) _可选_ > *属性名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *属性参数从句* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** -> *属性(Attributes)集* → [*属性*](../chapter3/06_Attributes.html#attribute) [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ -> *平衡令牌集* → [*平衡令牌*](../chapter3/06_Attributes.html#balanced_token) [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ -> *平衡令牌* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** -> *平衡令牌* → **[** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **]** -> *平衡令牌* → **{** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **}** -> *平衡令牌* → **任意标识符、关键字、字面量或运算符** +> *属性参数从句* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** +> *属性(Attributes)集* → [*属性*](../chapter3/06_Attributes.html#attribute) [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ +> *平衡令牌集* → [*平衡令牌*](../chapter3/06_Attributes.html#balanced_token) [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ +> *平衡令牌* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** +> *平衡令牌* → **[** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **]** +> *平衡令牌* → **{** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **}** +> *平衡令牌* → **任意标识符、关键字、字面量或运算符** > *平衡令牌* → **任意标点除了(, )、[, ]、{, 或 }** ## 表达式 -> 表达式语法 -> *表达式* → [*try-operator*](TODO) _可选_ [*前置表达式*](../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*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) [*二元表达式集*](../chapter3/04_Expressions.html#binary_expressions) _可选_ +> *表达式集* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*表达式*](../chapter3/04_Expressions.html#expression) **,** [*表达式集*](../chapter3/04_Expressions.html#expression_list) -> 前置表达式语法 -> *前置表达式* → [*前置运算符*](../chapter3/02_Lexical_Structure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) -> *前置表达式* → [*写入写出(in-out)表达式*](../chapter3/04_Expressions.html#in_out_expression) +> 前置表达式语法 +> +> *前置表达式* → [*前置运算符*](../chapter3/02_Lexical_Structure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) +> *前置表达式* → [*写入写出(in-out)表达式*](../chapter3/04_Expressions.html#in_out_expression) > *写入写出(in-out)表达式* → **&** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> try 表达式语法 +> try 表达式语法 +> > *try-operator* → **try** | **try !** -> 二元表达式语法 -> *二元表达式* → [*二元运算符*](../chapter3/02_Lexical_Structure.html#binary_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*赋值运算符*](../chapter3/04_Expressions.html#assignment_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*条件运算符*](../chapter3/04_Expressions.html#conditional_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*类型转换运算符*](../chapter3/04_Expressions.html#type_casting_operator) +> 二元表达式语法 +> +> *二元表达式* → [*二元运算符*](../chapter3/02_Lexical_Structure.html#binary_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) +> *二元表达式* → [*赋值运算符*](../chapter3/04_Expressions.html#assignment_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) +> *二元表达式* → [*条件运算符*](../chapter3/04_Expressions.html#conditional_operator) [*try 运算符*](TODO) _可选_ [*前置表达式*](../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) _可选_ -> 赋值运算符语法 +> 赋值运算符语法 +> > *赋值运算符* → **=** -> 三元条件运算符语法 +> 三元条件运算符语法 +> > *三元条件运算符* → **?** [*表达式*](../chapter3/04_Expressions.html#expression) **:** -> 类型转换运算符语法 -> *类型转换运算符* → **is** [*类型*](../chapter3/03_Types.html#type) - -> *类型转换运算符* → **as** [*类型*](../chapter3/03_Types.html#type) - -> *类型转换运算符* → **as ?** [*类型*](../chapter3/03_Types.html#type) - +> 类型转换运算符语法 +> +> *类型转换运算符* → **is** [*类型*](../chapter3/03_Types.html#type) +> *类型转换运算符* → **as** [*类型*](../chapter3/03_Types.html#type) +> *类型转换运算符* → **as ?** [*类型*](../chapter3/03_Types.html#type) > *类型转换运算符* → **as !** [*类型*](../chapter3/03_Types.html#type) -> 主表达式语法 -> *主表达式* → [*标识符*](../chapter3/02_Lexical_Structure.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/02_Lexical_Structure.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/02_Lexical_Structure.html#literal) -> *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal) -> *字面量表达式* → **__FILE__** | **__LINE__** | **__COLUMN__** | **__FUNCTION__** -> *数组字面量* → **[** [*数组字面量项集*](../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/02_Lexical_Structure.html#literal) +> *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal) +> *字面量表达式* → **__FILE__** | **__LINE__** | **__COLUMN__** | **__FUNCTION__** +> *数组字面量* → **[** [*数组字面量项集*](../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 表达式* → **self** -> *self 表达式* → **self** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *self 表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** -> *self 表达式* → **self** **.** **init** +> Self 表达式语法 +> +> *self 表达式* → **self** +> *self 表达式* → **self** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *self 表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** +> *self 表达式* → **self** **.** **init** -> 超类表达式语法 -> *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression) -> *超类方法表达式* → **super** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** -> *超类构造器表达式* → **super** **.** **init** +> 超类表达式语法 +> +> *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression) +> *超类方法表达式* → **super** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** +> *超类构造器表达式* → **super** **.** **init** -> 闭包表达式语法 -> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}** -> *闭包签名(Signational)* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名(Signational)* → [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*标识符集*](../chapter3/02_Lexical_Structure.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)** +> 闭包表达式语法 +> +> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}** +> *闭包签名(Signational)* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** +> *闭包签名(Signational)* → [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** +> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** +> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*标识符集*](../chapter3/02_Lexical_Structure.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)** -> 隐式成员表达式语法 +> 隐式成员表达式语法 +> > *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> 圆括号表达式(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) +> 圆括号表达式(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#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) +> 后置表达式语法 +> +> *后置表达式* → [*主表达式*](../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#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) -> 构造器表达式语法 +> 构造器表达式语法 +> > *构造器表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init** -> 显式成员表达式语法 -> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) +> 显式成员表达式语法 +> +> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) > *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ -> 后置 Self 表达式语法 +> 后置 Self 表达式语法 +> > *后置 self 表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self** -> 动态类型表达式语法 +> 动态类型表达式语法 +> > *动态类型表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType** -> 附属脚本表达式语法 +> 附属脚本表达式语法 +> > *附属脚本表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式集*](../chapter3/04_Expressions.html#expression_list) **]** -> 强制取值(Forced Value)语法 +> 强制取值(Forced Value)语法 +> > *强制取值(Forced Value)表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!** -> 可选链表达式语法 +> 可选链表达式语法 +> > *可选链表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **?** ## 词法结构 -> 标识符语法 -> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ -> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ -> *标识符* → [*隐式参数名*](../chapter3/02_Lexical_Structure.html#implicit_parameter_name) -> *标识符集* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **,** [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) -> *标识符头(Head)* → Upper- or lowercase letter A through Z - -> *标识符头(Head)* → _ - -> *标识符头(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA -> *标识符头(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF -> *标识符头(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF -> *标识符头(Head)* → U+1E00–U+1FFF -> *标识符头(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F -> *标识符头(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793 -> *标识符头(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF -> *标识符头(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF -> *标识符头(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44 -> *标识符头(Head)* → U+FE47–U+FFFD -> *标识符头(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD -> *标识符头(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD -> *标识符头(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD -> *标识符头(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD -> *标识符字符* → 数值 0 到 9 -> *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F -> *标识符字符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) -> *标识符字符集* → [*标识符字符*](../chapter3/02_Lexical_Structure.html#identifier_character) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ +> 标识符语法 +> +> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ +> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ +> *标识符* → [*隐式参数名*](../chapter3/02_Lexical_Structure.html#implicit_parameter_name) +> *标识符集* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **,** [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) +> *标识符头(Head)* → Upper- or lowercase letter A through Z +> *标识符头(Head)* → _ +> *标识符头(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA +> *标识符头(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF +> *标识符头(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF +> *标识符头(Head)* → U+1E00–U+1FFF +> *标识符头(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F +> *标识符头(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793 +> *标识符头(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF +> *标识符头(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF +> *标识符头(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44 +> *标识符头(Head)* → U+FE47–U+FFFD +> *标识符头(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD +> *标识符头(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD +> *标识符头(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD +> *标识符头(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD +> *标识符字符* → 数值 0 到 9 +> *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F +> *标识符字符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) +> *标识符字符集* → [*标识符字符*](../chapter3/02_Lexical_Structure.html#identifier_character) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ > *隐式参数名* → **$** [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits) -> 字面量语法 -> *字面量* → [*数值型字面量*](../chapter3/02_Lexical_Structure.html#integer_literal) | [*字符串字面量*](../chapter3/02_Lexical_Structure.html#floating_point_literal) | [*布尔字面量*](../chapter3/02_Lexical_Structure.html#string_literal) | [*空字面量*](TODO) - -> *数值型字面量* → **-** _可选_ [*整形字面量*](TODO) | **-** _可选_ [*浮点型字面量*](TODO) - -> *布尔字面量* → **true** | **false** - -> *空字面量* → **nil** +> 字面量语法 +> +> *字面量* → [*数值型字面量*](../chapter3/02_Lexical_Structure.html#integer_literal) | [*字符串字面量*](../chapter3/02_Lexical_Structure.html#floating_point_literal) | [*布尔字面量*](../chapter3/02_Lexical_Structure.html#string_literal) | [*空字面量*](TODO) +> *数值型字面量* → **-** _可选_ [*整形字面量*](TODO) | **-** _可选_ [*浮点型字面量*](TODO) +> *布尔字面量* → **true** | **false** +> *空字面量* → **nil** -> 整型字面量语法 -> *整型字面量* → [*二进制字面量*](../chapter3/02_Lexical_Structure.html#binary_literal) -> *整型字面量* → [*八进制字面量*](../chapter3/02_Lexical_Structure.html#octal_literal) -> *整型字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) -> *整型字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) -> *二进制字面量* → **0b** [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_ -> *二进制数字* → 数值 0 到 1 -> *二进制字面量字符* → [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) | **_** -> *二进制字面量字符集* → [*二进制字面量字符*](../chapter3/02_Lexical_Structure.html#binary_literal_character) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_ -> *八进制字面量* → **0o** [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_ -> *八进字数字* → 数值 0 到 7 -> *八进制字符* → [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) | **_** -> *八进制字符集* → [*八进制字符*](../chapter3/02_Lexical_Structure.html#octal_literal_character) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_ -> *十进制字面量* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_ -> *十进制数字* → 数值 0 到 9 -> *十进制数字集* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits) _可选_ -> *十进制字面量字符* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) | **_** -> *十进制字面量字符集* → [*十进制字面量字符*](../chapter3/02_Lexical_Structure.html#decimal_literal_character) [*十进制字面量字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_ -> *十六进制字面量* → **0x** [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_ -> *十六进制数字* → 数值 0 到 9, a through f, or A through F -> *十六进制字符* → [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) | **_** -> *十六进制字面量字符集* → [*十六进制字符*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_character) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_ +> 整型字面量语法 +> +> *整型字面量* → [*二进制字面量*](../chapter3/02_Lexical_Structure.html#binary_literal) +> *整型字面量* → [*八进制字面量*](../chapter3/02_Lexical_Structure.html#octal_literal) +> *整型字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) +> *整型字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) +> *二进制字面量* → **0b** [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_ +> *二进制数字* → 数值 0 到 1 +> *二进制字面量字符* → [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) | **_** +> *二进制字面量字符集* → [*二进制字面量字符*](../chapter3/02_Lexical_Structure.html#binary_literal_character) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_ +> *八进制字面量* → **0o** [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_ +> *八进字数字* → 数值 0 到 7 +> *八进制字符* → [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) | **_** +> *八进制字符集* → [*八进制字符*](../chapter3/02_Lexical_Structure.html#octal_literal_character) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_ +> *十进制字面量* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_ +> *十进制数字* → 数值 0 到 9 +> *十进制数字集* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits) _可选_ +> *十进制字面量字符* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) | **_** +> *十进制字面量字符集* → [*十进制字面量字符*](../chapter3/02_Lexical_Structure.html#decimal_literal_character) [*十进制字面量字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_ +> *十六进制字面量* → **0x** [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_ +> *十六进制数字* → 数值 0 到 9, a through f, or A through F +> *十六进制字符* → [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) | **_** +> *十六进制字面量字符集* → [*十六进制字符*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_character) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_ -> 浮点型字面量语法 -> *浮点数字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) [*十进制分数*](../chapter3/02_Lexical_Structure.html#decimal_fraction) _可选_ [*十进制指数*](../chapter3/02_Lexical_Structure.html#decimal_exponent) _可选_ -> *浮点数字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) [*十六进制分数*](../chapter3/02_Lexical_Structure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](../chapter3/02_Lexical_Structure.html#hexadecimal_exponent) -> *十进制分数* → **.** [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) -> *十进制指数* → [*浮点数 e*](../chapter3/02_Lexical_Structure.html#floating_point_e) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) +> 浮点型字面量语法 +> +> *浮点数字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) [*十进制分数*](../chapter3/02_Lexical_Structure.html#decimal_fraction) _可选_ [*十进制指数*](../chapter3/02_Lexical_Structure.html#decimal_exponent) _可选_ +> *浮点数字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) [*十六进制分数*](../chapter3/02_Lexical_Structure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](../chapter3/02_Lexical_Structure.html#hexadecimal_exponent) +> *十进制分数* → **.** [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) +> *十进制指数* → [*浮点数 e*](../chapter3/02_Lexical_Structure.html#floating_point_e) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) > *十六进制分数* → **.** [*十六进制数*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) - [*十六进制字面量字符集*](TODO)_可选_ -> *十六进制指数* → [*浮点数 p*](../chapter3/02_Lexical_Structure.html#floating_point_p) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) -> *浮点数 e* → **e** | **E** -> *浮点数 p* → **p** | **P** -> *正负号* → **+** | **-** + [*十六进制字面量字符集*](TODO)_可选_ +> *十六进制指数* → [*浮点数 p*](../chapter3/02_Lexical_Structure.html#floating_point_p) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) +> *浮点数 e* → **e** | **E** +> *浮点数 p* → **p** | **P** +> *正负号* → **+** | **-** -> 字符串型字面量语法 -> *字符串字面量* → **"** [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) **"** -> *引用文本* → [*引用文本条目*](../chapter3/02_Lexical_Structure.html#quoted_text_item) [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) _可选_ -> *引用文本条目* → [*转义字符*](../chapter3/02_Lexical_Structure.html#escaped_character) -> *引用文本条目* → **(** [*表达式*](../chapter3/04_Expressions.html#expression) **)** -> *引用文本条目* → 除了"­, \­, U+000A, or U+000D 的所有 Unicode 的字符 -> *转义字符* → **/0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'** -> *转义字符* → **\u** **{** [*十六进制标量数字集*](TODO) **}** -> *unicode 标量数字集* → Between one and eight hexadecimal digits +> 字符串型字面量语法 +> +> *字符串字面量* → **"** [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) **"** +> *引用文本* → [*引用文本条目*](../chapter3/02_Lexical_Structure.html#quoted_text_item) [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) _可选_ +> *引用文本条目* → [*转义字符*](../chapter3/02_Lexical_Structure.html#escaped_character) +> *引用文本条目* → **(** [*表达式*](../chapter3/04_Expressions.html#expression) **)** +> *引用文本条目* → 除了"­, \­, U+000A, or U+000D 的所有 Unicode 的字符 +> *转义字符* → **/0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'** +> *转义字符* → **\u** **{** [*十六进制标量数字集*](TODO) **}** +> *unicode 标量数字集* → Between one and eight hexadecimal digits -> 运算符语法语法 -> *运算符* → [*运算符头*](../chapter3/02_Lexical_Structure.html#operator_character) [*运算符字符集*](../chapter3/02_Lexical_Structure.html#operator) _可选_ -> *运算符* → [*点运算符头*](TODO) [*点运算符字符集*](TODO) _可选_ -> *运算符字符* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **?** -> *运算符头* → U+00A1–U+00A7 - -> *运算符头* → U+00A9 or U+00AB - -> *运算符头* → U+00AC or U+00AE - -> *运算符头* → U+00B0–U+00B1, U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7 - -> *运算符头* → U+2016–U+2017 or U+2020–U+2027 - -> *运算符头* → U+2030–U+203E - -> *运算符头* → U+2041–U+2053 - -> *运算符头* → U+2055–U+205E - -> *运算符头* → U+2190–U+23FF - -> *运算符头* → U+2500–U+2775 - -> *运算符头* → U+2794–U+2BFF - -> *运算符头* → U+2E00–U+2E7F - -> *运算符头* → U+3001–U+3003 - -> *运算符头* → U+3008–U+3030 - -> *运算符字符* → [*运算符头*](TODO) - -> *运算符字符* → U+0300–U+036F - -> *运算符字符* → U+1DC0–U+1DFF - -> *运算符字符* → U+20D0–U+20FF - -> *运算符字符* → U+FE00–U+FE0F - -> *运算符字符* → U+FE20–U+FE2F - -> *运算符字符* → U+E0100–U+E01EF - -> *运算符字符集* → [*运算符字符*](TODO) [*运算符字符集*](TODO)_可选_ - -> *点运算符头* → **..** - -> *点运算符字符* → **.** | [*运算符字符*](TODO) - -> *点运算符字符集* → [*点运算符字符*](TODO) [*点运算符字符集*](TODO) _可选_ - -> *二元运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> *前置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> *后置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) +> 运算符语法语法 +> +> *运算符* → [*运算符头*](../chapter3/02_Lexical_Structure.html#operator_character) [*运算符字符集*](../chapter3/02_Lexical_Structure.html#operator) _可选_ +> *运算符* → [*点运算符头*](TODO) [*点运算符字符集*](TODO) _可选_ +> *运算符字符* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **?** +> *运算符头* → U+00A1–U+00A7 +> *运算符头* → U+00A9 or U+00AB +> *运算符头* → U+00AC or U+00AE +> *运算符头* → U+00B0–U+00B1, U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7 +> *运算符头* → U+2016–U+2017 or U+2020–U+2027 +> *运算符头* → U+2030–U+203E +> *运算符头* → U+2041–U+2053 +> *运算符头* → U+2055–U+205E +> *运算符头* → U+2190–U+23FF +> *运算符头* → U+2500–U+2775 +> *运算符头* → U+2794–U+2BFF +> *运算符头* → U+2E00–U+2E7F +> *运算符头* → U+3001–U+3003 +> *运算符头* → U+3008–U+3030 +> *运算符字符* → [*运算符头*](TODO) +> *运算符字符* → U+0300–U+036F +> *运算符字符* → U+1DC0–U+1DFF +> *运算符字符* → U+20D0–U+20FF +> *运算符字符* → U+FE00–U+FE0F +> *运算符字符* → U+FE20–U+FE2F +> *运算符字符* → U+E0100–U+E01EF +> *运算符字符集* → [*运算符字符*](TODO) [*运算符字符集*](TODO)_可选_ +> *点运算符头* → **..** +> *点运算符字符* → **.** | [*运算符字符*](TODO) +> *点运算符字符集* → [*点运算符字符*](TODO) [*点运算符字符集*](TODO) _可选_ +> *二元运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) +> *前置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) +> *后置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator) ## 类型 -> 类型语法 +> 类型语法 +> > *类型* → [*数组类型*](../chapter3/03_Types.html#array_type) | [*字典类型*](TODO) | [*函数类型*](../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) -> 类型注解语法 +> 类型注解语法 +> > *类型注解* → **:** [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) -> 类型标识语法 -> *类型标识* → [*类型名称*](../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) > *类型名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> 元组类型语法 -> *元组类型* → **(** [*元组类型主体*](../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) > *元素名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> 函数类型语法 -> *函数类型* → [*类型*](../chapter3/03_Types.html#type) **throws** _可选_ **->** [*类型*](../chapter3/03_Types.html#type) +> 函数类型语法 +> +> *函数类型* → [*类型*](../chapter3/03_Types.html#type) **throws** _可选_ **->** [*类型*](../chapter3/03_Types.html#type) > *函数类型* → [*类型*](TODO) **rethrows** **->** [*类型*](TODO) -> 数组类型语法 +> 数组类型语法 +> > *数组类型* → **[** [*类型*](../chapter3/03_Types.html#array_type) **]** -> 字典类型语法 +> 字典类型语法 +> > *字典类型* → **[** [*类型 **:** 类型*](TODO) **]** -> 可选类型语法 +> 可选类型语法 +> > *可选类型* → [*类型*](../chapter3/03_Types.html#type) **?** -> 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法 +> 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法 +> > *隐式解析可选类型* → [*类型*](../chapter3/03_Types.html#type) **!** -> 协议合成类型语法 -> *协议合成类型* → **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) +> 协议合成类型语法 +> +> *协议合成类型* → **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) -> 元(Metatype)类型语法 +> 元(Metatype)类型语法 +> > *元类型* → [*类型*](../chapter3/03_Types.html#type) **.** **Type** | [*类型*](../chapter3/03_Types.html#type) **.** **Protocol** -> 类型继承从句语法 - -> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) - -> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) - -> *类型继承从句* → **:** [*类型继承集*](TODO) - -> *类型继承集* → [*类型标识符*](../chapter3/03_Types.html#type_identifier) | [*类型标识符*](../chapter3/03_Types.html#type_identifier) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) - +> 类型继承从句语法 +> +> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) +> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) +> *类型继承从句* → **:** [*类型继承集*](TODO) +> *类型继承集* → [*类型标识符*](../chapter3/03_Types.html#type_identifier) | [*类型标识符*](../chapter3/03_Types.html#type_identifier) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) > *类条件* → **class** diff --git a/source/chapter3/chapter3.md b/source/chapter3/chapter3.md index e69de29b..227aa9e7 100755 --- a/source/chapter3/chapter3.md +++ b/source/chapter3/chapter3.md @@ -0,0 +1,3 @@ +# Swift 教程 + +本章描述了 Swift 的语言参考。 \ No newline at end of file