From 55a56a40c14b6cf6ece1e68fb40530b071e59950 Mon Sep 17 00:00:00 2001 From: 949478479 <949478479@qq.com> Date: Fri, 4 Dec 2015 23:51:16 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E6=A0=A1=E5=AF=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter3/04_Expressions.md | 295 ++++++++++++++++++------------ 1 file changed, 175 insertions(+), 120 deletions(-) diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md index 9cc09211..94c7c2e2 100644 --- a/source/chapter3/04_Expressions.md +++ b/source/chapter3/04_Expressions.md @@ -13,157 +13,197 @@ 本页包含内容： -- [前缀表达式（Prefix Expressions）](#prefix_expressions) -- [二元表达式（Binary Expressions）](#binary_expressions) -- [赋值表达式（Assignment Operator）](#assignment_operator) -- [三元条件运算符（Ternary Conditional Operator）](#ternary_conditional_operator) -- [类型转换运算符（Type-Casting Operators）](#type-casting_operators) -- [主要表达式（Primary Expressions）](#primary_expressions) -- [后缀表达式（Postfix Expressions）](#postfix_expressions) +- [前缀表达式](#prefix_expressions) + - [try 运算符](#try_operator) +- [二元表达式](#binary_expressions) + - [赋值表达式](#assignment_operator) + - [三元条件运算符](#ternary_conditional_operator) + - [类型转换运算符](#type-casting_operators) +- [基本表达式](#primary_expressions) + - [字面量表达式](#literal_expression) + - [self 表达式](#self_expression) + - [super 表达式](#superclass_expression) + - [闭包表达式](#closure_expression) + - [隐式成员表达式](#implicit_member_expression) + - [括号表达式](#parenthesized_expression) + - [通配符表达式](#wildcard_expression) +- [后缀表达式](#postfix_expressions) + - [函数调用表达式](#function_call_expression) + - [构造器表达式](#initializer_expression) + - [显式成员表达式](#explicit_member_expression) + - [后缀 self 表达式](#postfix_self_expression) + - [dynamicType 表达式](#dynamic_type_expression) + - [下标表达式](#subscript_expression) + - [强制取值表达式](#forced-Value_expression) + - [可选链表达式](#optional-chaining_expression) -Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary）表达式，主要（primary）表达式和后缀（postfix）表达式。表达式可以返回一个值，以及运行某些逻辑（causes a side effect）。 +Swift 中存在四种表达式：前缀表达式，二元表达式，基本表达式和后缀表达式。表达式可以返回一个值，还可以执行某些代码。 -前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述。 +前缀表达式和二元表达式就是对某些表达式使用各种运算符。基本表达式是最短小的表达式，它提供了获取值的一种途径。后缀表达式则允许你建立复杂的表达式，例如函数调用和成员访问。每种表达式都在下面有详细论述。 > 表达式语法 -> *表达式* → [*试算子(try operator)*](../chapter3/04_Expressions.html#*) _可选_ | [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) | [*二元表达式列表*](../chapter3/04_Expressions.html#binary_expressions) _可选_ -> *表达式列表* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*表达式*](../chapter3/04_Expressions.html#expression) **,** [*表达式列表*](../chapter3/04_Expressions.html#expression_list) + +> *表达式* → [*try运算符*](#try-operator)可选 [*前缀表达式*](#prefix-expression) [*二元表达式列表*](#binary-expressions)可选 + +> *表达式列表* → [*表达式*](#expression) | [*表达式*](#expression) **,** [*表达式列表*](#expression-list) -## 前缀表达式（Prefix Expressions） +## 前缀表达式 -前缀表达式由可选的前缀符号和表达式组成。（这个前缀符号只能接收一个参数） +前缀表达式由可选的前缀运算符和表达式组成。前缀运算符只接收一个参数。 -对于这些操作符的使用，请参见： [Basic Operators](TODO：添加链接) 和 [Advanced Operators](TODO：添加链接) +关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/25_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)。 +关于 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)。 -作为对上面标准库运算符的补充，你也可以对 某个函数的参数使用 '&'运算符。 更多信息，请参见： [In-Out parameters](TODO：添加链接). +除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。 更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters). -> 前置表达式语法 -> *前置表达式* → [*前置运算符*](LexicalStructure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) -> *前置表达式* → [*写入写出(in-out)表达式*](../chapter3/04_Expressions.html#in_out_expression) -> *写入写出(in-out)表达式* → **&** [*标识符*](LexicalStructure.html#identifier) +> 前缀表达式语法 + +> *前缀表达式* → [*前缀运算符*](02_Lexical_Structure.html#prefix-operator)可选 [*后缀表达式*](#postfix-expression) +> *前缀表达式* → [*输入输出表达式*](#in-out-expression) + +> *输入输出表达式* → **&** [*标识符*](02_Lexical_Structure.html#identifier) -## try 操作符（try operator） -try表达式由紧跟在可能会出错的表达式后面的`try`操作符组成，形式如下： - `try expression` -强制的try表示由紧跟在可能会出错的表达式后面的`try!`操作符组成，出错时会产生一个运行时错误，形式如下： - `try! expression` +### try 运算符 -当在二进制运算符左边的表达式被标记上 `try`、`try?` 或者 `try!` 时，这个操作对整个二进制表达式都产生作用。也就是说，你可以使用圆括号来明确操作符的应用范围。 +try 表达式由 `try` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下： -``` +try `可抛出错误的表达式` + +可选的 try 表达式由 `try?` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下： + +try? `可抛出错误的表达式` + +如果可抛出错误的表达式没有抛出错误，整个表达式返回的可选值将包含可抛出错误的表达式的返回值，否则，该可选值为 `nil`。 + +强制的 try 表达式由 `try!` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下： + +try! `可抛出错误的表达式` + +如果可抛出错误的表达式抛出了错误，将会引发运行时错误。 + +在二进制运算符左侧的表达式被标记上 `try`、`try?` 或者 `try!` 时，这个运算符对整个二进制表达式都产生作用。也就是说，你可以使用括号来明确运算符的作用范围。 + +```swift sum = try someThrowingFunction() + anotherThrowingFunction() // try 对两个方法调用都产生作用 sum = try (someThrowingFunction() + anotherThrowingFunction()) // try 对两个方法调用都产生作用 -sum = (try someThrowingFunction()) + anotherThrowingFunction() // Error: try 只对第一个方法调用产生作用 +sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try 只对第一个方法调用产生作用 ``` -`try` 表达式不能出现在二进制操作符的的右边，除非二进制操作符是赋值操作符或者 `try` 表达式是被圆括号括起来的。 +`try` 表达式不能出现在二进制运算符的的右侧，除非二进制运算符是赋值运算符或者 `try` 表达式是被圆括号括起来的。 -关于`try`、`try?` 和 `try!` 更多的例子和信息请参见：[Error Handling](TODO：添加链接) +关于 `try`、`try?` 和 `try!` 的更多信息，以及如何使用的例子，请参阅 [错误处理](../chapter2/18_Error_Handling.html)。 -> try表达式语法 -> *try 操作符* → [*try*](LexicalStructure.html#try_operator) | try­? | *try!* +> try 表达式语法 + +> *try 运算符* → **try** | **try?** | **try!** -## 二元表达式（Binary Expressions） +## 二元表达式 -二元表达式由 "左边参数" + "二元运算符" + "右边参数" 组成, 它有如下的形式： +二元表达式形式如下： -> `left-hand argument` `operator` `right-hand argument` +`左侧参数` `二元运算符` `右侧参数` -关于这些运算符（operators）的更多信息，请参见：[Basic Operators](TODO：添加链接)和 [Advanced Operators](TODO：添加链接)。 +关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/25_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)。 > 注意 -> 在解析时, 一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 * 5 首先被认为是： 2, + , `` 3``, *, 5. 随后它被转换成 tree （2 + （3 * 5）） +> 在解析时，一个二元表达式将作为一个简单列表表示，然后根据运算符的优先级，再进一步进行组合。例如，`2 + 3 * 5` 首先被看作具有五个元素的列表，即 `2`、`+`、`3`、`*`、`5`，随后根据运算符优先级组合为 `(2 + (3 * 5))`。 > 二元表达式语法 -> *二元表达式* → [*二元运算符*](LexicalStructure.html#binary_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*赋值运算符*](../chapter3/04_Expressions.html#assignment_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*条件运算符*](../chapter3/04_Expressions.html#conditional_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) -> *二元表达式* → [*类型转换运算符*](../chapter3/04_Expressions.html#type_casting_operator) -> *二元表达式列表* → [*二元表达式*](../chapter3/04_Expressions.html#binary_expression) [*二元表达式列表*](../chapter3/04_Expressions.html#binary_expressions) _可选_ -> *赋值操作符* - + +> *二元表达式* → [*二元运算符*](02_Lexical_Structure.html#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)可选 -## 赋值表达式（Assignment Operator） +### 赋值表达式 -赋值表达式会对某个给定的表达式赋值。 它有如下的形式； +赋值表达式会为某个给定的表达式赋值，形式如下； -> `expression` = `value` +`表达式` = `值` -就是把右边的 *value* 赋值给左边的 *expression*. 如果左边的*expression* 需要接收多个参数（是一个tuple ），那么右边必须也是一个具有同样数量参数的tuple. （允许嵌套的tuple） +右边的值会被赋值给左边的表达式。如果左边表达式是一个元组，那么右边必须是一个具有同样元素个数的元组。嵌套元组也是允许的。 ```swift (a, _, (b, c)) = ("test", 9.45, (12, 3)) -// a is "test", b is 12, c is 3, and 9.45 is ignored +// a 为 "test"，b 为 12，c 为 3，9.45 会被忽略 ``` 赋值运算符不返回任何值。 > 赋值运算符语法 + > *赋值运算符* → **=** -## 三元条件运算符（Ternary Conditional Operator） +### 三元条件运算符 -三元条件运算符 是根据条件来获取值。 形式如下： +三元条件运算符会根据条件来对两个给定表达式中的一个进行求值，形式如下： -> `condition` ? `expression used if true` : `expression used if false` +`条件` ? `表达式（条件为真则使用）` : `表达式（条件为假则使用）` -如果 `condition` 是true, 那么返回 第一个表达式的值（此时不会调用第二个表达式）， 否则返回第二个表达式的值（此时不会调用第一个表达式）。 +如果条件为真，那么对第一个表达式进行求值并返回结果。否则，对第二个表达式进行求值并返回结果。未使用的表达式不会进行求值。 -想看三元条件运算符的例子，请参见： Ternary Conditional Operator. +关于使用三元条件运算符的例子，请参阅 [三元条件运算符](../chapter2/02_Basic_Operators.html#ternary_conditional_operator)。 > 三元条件运算符语法 -> *三元条件运算符* → **?** [*表达式*](../chapter3/04_Expressions.html#expression) **:** + +> *三元条件运算符* → **?** [try运算符](#try-operator)可选 [*表达式*](#expression) **:** -## 类型转换运算符（Type-Casting Operators） +### 类型转换运算符 -有4种类型转换运算符： `is`,`as`,`? `和`!`. 它们有如下的形式： +有 4 种类型转换运算符：`is`、`as`、`? `和`!`。它们有如下的形式： -> `expression` is `type` -> `expression` as `type` -> `expression` is? `type` -> `expression` as! `type` +`表达式` is `类型` +`表达式` as `类型` +`表达式` is? `类型` +`表达式` as! `类型` -`is`运算符在程序运行时检查表达式能否向下转化为指定的类型，如果可以在返回`ture`，如果不行，则返回`false`。 +`is` 运算符在运行时检查表达式能否向下转化为指定的类型，如果可以则返回 `ture`，否则返回 `false`。 + +`as` 运算符在编译时执行向上转换和桥接。向上转换可将表达式转换成超类的实例而无需使用任何中间变量。以下表达式是等价的： -`as`运算符在程序编译时执行类型转化，且总是成功，比如进行向上转换（upcast）和桥接（bridging）。向上转换指把表达式转换成类型的超类的一个是实例而不使用中间的变量。以下表达式是等价的： ```swift func f(any: Any) { print("Function for Any") } func f(int: Int) { print("Function for Int") } let x = 10 f(x) -// prints "Function for Int" +// 打印 “Function for Int” let y: Any = x f(y) -// prints "Function for Any" +// 打印 “Function for Any” f(x as Any) -// prints "Function for Any" +// 打印 “Function for Any” ``` -桥接运算可以让你把一个Swift标准库中的类型的表达式作为一个与之相关的基础类（比如NSString）来使用，而不需要新建一个实例。关于桥接的更多实例参见Using Swift with Cocoa and Objective-C中的Cocoa Data Types。 -`as?`操作符为带条件的类型转换。`as?`操作符返回可选的转换类型。在运行时，如果转换成功，表达式的值会被覆盖掉再返回，如果转换不成功的话，则返回`nil`。如果条件转换中的条件的真值一开始就已经确定真伪了，则在编译时会报错。 +桥接可将 Swift 标准库中的类型（例如 `String`）作为一个与之相关的 Foundation 类型（例如 `NSString`）来使用，而不需要新建一个实例。关于桥接的更多信息，请参阅 [*Using Swift with Cocoa and Objective-C*](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)。 -`a!`操作符表示强制转换，其返回指定的类型，而不是可选的类型。如果转换失败，则会出现运行时错误。表达式`x as T` 效果等同于`(x as? T)!`。 +`as?` 运算符有条件地执行类型转换，返回目标类型的可选值。在运行时，如果转换成功，返回的可选值将包含转换后的值，否则返回 `nil`。如果在编译时就能确定转换一定会成功或是失败，则会编译出错。 -关于类型转换的更多内容和例子，请参见： [Type Casting](TODO：添加链接). +`as!` 运算符执行强制类型转换，返回目标类型的非可选值。如果转换失败，则会导致运行时错误。表达式 `x as T` 效果等同于 `(x as? T)!`。 -> 类型转换运算符(type-casting-operator)语法 -> *类型转换运算符* → **is** [*类型*](../chapter3/03_Types.html#type) -> *类型转换运算符* → **as** [*类型*](../chapter3/03_Types.html#type) -> *类型转换运算符* → **is** **?** [*类型*](../chapter3/03_Types.html#type) -> *类型转换运算符* → **as** **!** [*类型*](../chapter3/03_Types.html#type) +关于类型转换的更多内容和例子，请参阅 [类型转换](../chapter2/19_Type_Casting.html)。 + +> 类型转换运算符语法 + +> *类型转换运算符* → **is** [*类型*](03_Types.html#type) +> *类型转换运算符* → **as** [*类型*](03_Types.html#type) +> *类型转换运算符* → **is** **?** [*类型*](03_Types.html#type) +> *类型转换运算符* → **as** **!** [*类型*](03_Types.html#type) -## 主表达式（Primary Expressions） +## 基本表达式 `主表达式`是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。 @@ -177,7 +217,8 @@ f(x as Any) > *主表达式* → [*隐式成员表达式*](../chapter3/04_Expressions.html#implicit_member_expression) > *主表达式* → [*通配符表达式*](../chapter3/04_Expressions.html#wildcard_expression) -### 字符型表达式（Literal Expression） + +### 字面量表达式 由这些内容组成：普通的字符（string, number） , 一个字符的字典或者数组，或者下面列表中的特殊字符。 @@ -217,9 +258,11 @@ var emptyArray: [Double] = [] > [`key 1`: `value 1`, `key 2`: `value 2`, `...`] dictionary 的最后一个表达式可以是一个逗号（','）. [:] 表示一个空的dictionary. 它的type是 Dictionary （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.一个空的dictionary literal由方括号中加一个冒号组成，以此来与空array literal区分开，可以使用空的dictionary literal来创建特定类型的键值对。 + ```swift var emptyDictionary: [String: Double]=[:] ``` + > 字面量表达式语法 > *字面量表达式* → [*字面量*](LexicalStructure.html#literal) > *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal) @@ -231,7 +274,8 @@ var emptyDictionary: [String: Double]=[:] > *字典字面量项列表* → [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项列表*](../chapter3/04_Expressions.html#dictionary_literal_items) > *字典字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression) **:** [*表达式*](../chapter3/04_Expressions.html#expression) -### self表达式（Self Expression） + +### self 表达式 self表达式是对 当前type 或者当前instance的引用。它的形式如下： @@ -272,7 +316,8 @@ struct Point { > *self表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** > *self表达式* → **self** **.** **init** -### 超类表达式（Superclass Expression） + +### super 表达式 超类表达式可以使我们在某个class中访问它的超类. 它有如下形式： @@ -290,7 +335,8 @@ struct Point { > *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** > *超类构造器表达式* → **super** **.** **init** -### 闭包表达式（Closure Expression） + +### 闭包表达式 闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下： @@ -328,7 +374,7 @@ myFunction { $0 + $1 } 关于 向闭包中传递参数的内容，参见： [Function Call Expression](TODO：添加链接). -### 参数列表（Capture Lists） +#### 捕获列表 闭包表达式可以通过一个参数列表（capture list） 来显式指定它需要的参数。 参数列表由中括号 [] 括起来，里面的参数由逗号','分隔。一旦使用了参数列表，就必须使用'in'关键字（在任何情况下都得这样做，包括忽略参数的名字，type, 返回值时等等）。 @@ -359,7 +405,8 @@ myFunction { [weak parent = self.parent] in print(parent!.title) } > *捕获(Capature)列表* → **[** [*捕获(Capature)说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]** > *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** -### 隐式成员表达式（Implicit Member Expression） + +### 隐式成员表达式 在可以判断出类型（type）的上下文（context）中，隐式成员表达式是访问某个type的member（ 例如 class method, enumeration case） 的简洁方法。 它的形式是： @@ -375,7 +422,8 @@ x = .AnotherValue > 隐式成员表达式语法 > *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -### 圆括号表达式（Parenthesized Expression） + +### 括号表达式 圆括号表达式由多个子表达式和逗号','组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下： @@ -387,8 +435,8 @@ x = .AnotherValue > *圆括号表达式* → **(** [*表达式元素列表*](../chapter3/04_Expressions.html#expression_element_list) _可选_ **)** > *表达式元素列表* → [*表达式元素*](../chapter3/04_Expressions.html#expression_element) | [*表达式元素*](../chapter3/04_Expressions.html#expression_element) **,** [*表达式元素列表*](../chapter3/04_Expressions.html#expression_element_list) > *表达式元素* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **:** [*表达式*](../chapter3/04_Expressions.html#expression) - -### 通配符表达式（Wildcard Expression） + +### 通配符表达式 通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。） @@ -401,7 +449,7 @@ x = .AnotherValue > *通配符表达式* → **_** -## 后缀表达式（Postfix Expressions） +## 后缀表达式 后缀表达式就是在某个表达式的后面加上 操作符。 严格的讲，每个主要表达式（primary expression）都是一个后缀表达式 @@ -412,19 +460,21 @@ Swift 标准库提供了下列后缀表达式： 对于这些操作符的使用，请参见： Basic Operators and Advanced Operators -> 后置表达式语法 -> *后置表达式* → [*主表达式*](../chapter3/04_Expressions.html#primary_expression) -> *后置表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*后置运算符*](../chapter3/02_Lexical_Structure.html#postfix_operator) -> *后置表达式* → [*函数调用表达式*](../chapter3/04_Expressions.html#function_call_expression) -> *后置表达式* → [*构造器表达式*](../chapter3/04_Expressions.html#initializer_expression) -> *后置表达式* → [*显示成员表达式*](../chapter3/04_Expressions.html#explicit_member_expression) -> *后置表达式* → [*后置self表达式*](../chapter3/04_Expressions.html#postfix_self_expression) -> *后置表达式* → [*动态类型表达式*](../chapter3/04_Expressions.html#dynamic_type_expression) -> *后置表达式* → [*下标表达式*](../chapter3/04_Expressions.html#subscript_expression) -> *后置表达式* → [*强制取值(Forced Value)表达式*](../chapter3/04_Expressions.html#forced_value_expression) -> *后置表达式* → [*可选链(Optional Chaining)表达式*](../chapter3/04_Expressions.html#optional_chaining_expression) +> 后缀表达式语法 + +> *后缀表达式* → [*主表达式*](../chapter3/04_Expressions.html#primary_expression) +> *后缀表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) [*后缀运算符*](../chapter3/02_Lexical_Structure.html#postfix_operator) +> *后缀表达式* → [*函数调用表达式*](../chapter3/04_Expressions.html#function_call_expression) +> *后缀表达式* → [*构造器表达式*](../chapter3/04_Expressions.html#initializer_expression) +> *后缀表达式* → [*显示成员表达式*](../chapter3/04_Expressions.html#explicit_member_expression) +> *后缀表达式* → [*后缀self表达式*](../chapter3/04_Expressions.html#postfix_self_expression) +> *后缀表达式* → [*动态类型表达式*](../chapter3/04_Expressions.html#dynamic_type_expression) +> *后缀表达式* → [*下标表达式*](../chapter3/04_Expressions.html#subscript_expression) +> *后缀表达式* → [*强制取值(Forced Value)表达式*](../chapter3/04_Expressions.html#forced_value_expression) +> *后缀表达式* → [*可选链(Optional Chaining)表达式*](../chapter3/04_Expressions.html#optional_chaining_expression) -### 函数调用表达式（Function Call Expression） + +### 函数调用表达式 函数调用表达式由函数名和参数列表组成。它的形式如下： @@ -451,11 +501,12 @@ myData.someMethod {$0 == 13} ``` > 函数调用表达式语法 -> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) -> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包(Trailing Closure)*](../chapter3/04_Expressions.html#trailing_closure) -> *后置闭包(Trailing Closure)* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression) +> *函数调用表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) +> *函数调用表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) _可选_ [*后缀闭包(Trailing Closure)*](../chapter3/04_Expressions.html#trailing_closure) +> *后缀闭包(Trailing Closure)* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression) -### 初始化函数表达式（Initializer Expression） + +### 构造器表达式 Initializer表达式用来给某个Type初始化。 它的形式如下： @@ -494,12 +545,11 @@ let s4 = someValue.dynamicType(data: 5) // Error let s3 = someValue.dynamicType.init(data: 7) // Valid ``` - - > 构造器表达式语法 -> *构造器表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init** +> *构造器表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init** -### 显式成员表达式（Explicit Member Expression） + +### 显式成员表达式 显示成员表达式允许我们访问type, tuple, module的成员变量。它的形式如下： @@ -526,10 +576,11 @@ t.0 = t.1 对于某个module的member的调用，只能调用在top-level声明中的member. > 显式成员表达式语法 -> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) -> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ +> *显示成员表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) +> *显示成员表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ -### 后缀self表达式（Postfix Self Expression） + +### 后缀 self 表达式 后缀表达式由 某个表达式 + '.self' 组成. 形式如下： @@ -540,12 +591,13 @@ t.0 = t.1 形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。 -> 后置Self 表达式语法 -> *后置self表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self** +> 后缀Self 表达式语法 +> *后缀self表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self** -### dynamic表达式（Dynamic Type Expression） + +### dynamicType 表达式 -（因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression） +（因为 dynamicType 是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression） dynamicType 表达式由 某个表达式 + '.dynamicType' 组成。 @@ -573,9 +625,10 @@ someInstance.dynamicType.printClassName() ``` > 动态类型表达式语法 -> *动态类型表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType** +> *动态类型表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType** -### 下标脚本表达式（Subscript Expression） + +### 下标脚本表达式 下标脚本表达式提供了通过下标脚本访问getter/setter 的方法。它的形式是： @@ -586,9 +639,10 @@ someInstance.dynamicType.printClassName() 关于subscript的声明，请参见： Protocol Subscript Declaration. > 附属脚本表达式语法 -> *附属脚本表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式列表*](../chapter3/04_Expressions.html#expression_list) **]** +> *附属脚本表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式列表*](../chapter3/04_Expressions.html#expression_list) **]** -### 强制取值表达式（Forced-Value Expression） + +### 强制取值表达式 强制取值表达式用来获取某个目标表达式的值（该目标表达式的值必须不是nil ）。它的形式如下： @@ -607,9 +661,10 @@ someDictionary["a"]![0] = 100 ``` > 强制取值(Forced Value)语法 -> *强制取值(Forced Value)表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!** +> *强制取值(Forced Value)表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **!** -### 可选链表达式（Optional-Chaining Expression） + +### 可选链表达式 可选链表达式由目标表达式 + '?' 组成，形式如下： @@ -651,4 +706,4 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects() > 可选链表达式语法 -> *可选链表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **?** +> *可选链表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **?** From f5380d391245931d0903a171f2ca1c853e07d8c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com> Date: Fri, 4 Dec 2015 23:58:24 +0800 Subject: [PATCH 2/2] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../01_About_the_Language_Reference.md | 6 +- source/chapter3/02_Lexical_Structure.md | 294 +++++++++--------- source/chapter3/03_Types.md | 90 +++--- source/chapter3/05_Declarations.md | 7 +- 4 files changed, 210 insertions(+), 187 deletions(-) diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md index 2a380c8a..db6da062 100755 --- a/source/chapter3/01_About_the_Language_Reference.md +++ b/source/chapter3/01_About_the_Language_Reference.md @@ -31,10 +31,10 @@ Swift 语言相对较小，这是由于 Swift 代码中的几乎所有常见类 举个例子，getter-setter 的语法块的定义如下： > getter-setter 方法块语法 -> *getter-setter 方法块* → { [*getter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) [*setter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause)可选 } | { [*setter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause) [*getter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) } +> *getter-setter 方法块* → { [*getter 子句*](05_Declarations.html#getter-clause) [*setter 子句*](05_Declarations.html#setter-clause)可选 } | { [*setter 子句*](05_Declarations.html#setter-clause) [*getter 子句*](05_Declarations.html#getter-clause) } 这个定义表明，一个 getter-setter 方法块可以由一个 getter 子句后跟一个可选的 setter 子句构成，然后用大括号括起来，或者由一个 setter 子句后跟一个 getter 子句构成，然后用大括号括起来。下面的两个语法产式等价于上述的语法产式，并明确指出了如何取舍： > getter-setter 方法块语法 -> getter-setter 方法块 → { [*getter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) [*setter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause)可选 } -> getter-setter 方法块 → { [*setter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause) [*getter 子句*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) } +> getter-setter 方法块 → { [*getter 子句*](05_Declarations.html#getter-clause) [*setter 子句*](05_Declarations.html#setter-clause)可选 } +> getter-setter 方法块 → { [*setter 子句*](05_Declarations.html#setter-clause) [*getter 子句*](05_Declarations.html#getter-clause) } diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md index e9d093d3..52a1e9bd 100755 --- a/source/chapter3/02_Lexical_Structure.md +++ b/source/chapter3/02_Lexical_Structure.md @@ -14,44 +14,47 @@ 本页包含内容： -- [空白与注释（*Whitespace and Comments*）](#whitespace_and_comments) -- [标识符（*Identifiers*）](#identifiers) -- [关键字和标点符号（*Keywords and Punctuation*）](#keywords) -- [字面量（*Literals*）](#literals) -- [运算符（*Operators*）](#operators) +- [空白与注释](#whitespace_and_comments) +- [标识符](#identifiers) +- [关键字和标点符号](#keywords) +- [字面量](#literals) + - [整数字面量](#integer_literals) + - [浮点数字面量](#floating_point_literals) + - [字符串字面量](#string_literals) +- [运算符](#operators) -Swift 的“词法结构（*lexical structure*）”描述了能构成该语言中合法符号的字符序列。这些合法符号组成了语言中最底层的构建基块，并在之后的章节中用于描述语言的其他部分。一个合法符号由一个标识符、关键字、标点符号、字面量或运算符组成。 +Swift 的“词法结构”描述了能构成该语言中合法符号的字符序列。这些合法符号组成了语言中最底层的构建基块，并在之后的章节中用于描述语言的其他部分。一个合法符号由一个标识符、关键字、标点符号、字面量或运算符组成。 -通常情况下，符号是根据随后将介绍的语法约束，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配（*longest match*）”，或者“最大适合”（*maximal munch*）。 +通常情况下，符号是根据随后将介绍的语法约束，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配”，或者“最大适合”。 ## 空白与注释 -空白（*whitespace*）有两个用途：分隔源文件中的符号以及帮助区分运算符属于前缀还是后缀（参见 [运算符](#operators)），在其他情况下则会被忽略。以下的字符会被当作空白：空格（U+0020）、换行符（U+000A）、回车符（U+000D）、水平制表符（U+0009）、垂直制表符（U+000B）、换页符（U+000C）以及空（U+0000）。 +空白有两个用途：分隔源文件中的符号以及帮助区分运算符属于前缀还是后缀（参见 [运算符](#operators)），在其他情况下则会被忽略。以下的字符会被当作空白：空格（U+0020）、换行符（U+000A）、回车符（U+000D）、水平制表符（U+0009）、垂直制表符（U+000B）、换页符（U+000C）以及空（U+0000）。 -注释（*comments*）被编译器当作空白处理。单行注释由 `//` 开始直至遇到换行符（U+000A）或者回车符（U+000D）。多行注释由 `/*` 开始，以 `*/` 结束。注释允许嵌套，但注释标记必须匹配。 +注释被编译器当作空白处理。单行注释由 `//` 开始直至遇到换行符（U+000A）或者回车符（U+000D）。多行注释由 `/*` 开始，以 `*/` 结束。注释允许嵌套，但注释标记必须匹配。 -正如 [标记格式参考（Markup Formatting Reference）](https://developer.apple.com/library/prerelease/ios/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html#//apple_ref/doc/uid/TP40016497) 所述，注释可以包含附加的格式和标记。 +正如 [*Markup Formatting Reference*](https://developer.apple.com/library/prerelease/ios/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html#//apple_ref/doc/uid/TP40016497) 所述，注释可以包含附加的格式和标记。 ## 标识符 -标识符（*identifiers*）可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 `_`、基本多文种平面（*Basic Multilingual Plane*）中的 Unicode 非组合字符以及基本多文种平面以外的非个人专用区（*Private Use Area*）字符。首字符之后，允许使用数字和 Unicode 字符组合。 +标识符可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 `_`、基本多文种平面中的 Unicode 非组合字符以及基本多文种平面以外的非个人专用区字符。首字符之后，允许使用数字和 Unicode 字符组合。 -使用保留字（*reserved word*）作为标识符，需要在其前后增加反引号 `` ` ``。例如，`class` 不是合法的标识符，但可以使用 `` `class` ``。反引号不属于标识符的一部分，`` `x` `` 和 `x` 表示同一标识符。 +使用保留字作为标识符，需要在其前后增加反引号 `` ` ``。例如，`class` 不是合法的标识符，但可以使用 `` `class` ``。反引号不属于标识符的一部分，`` `x` `` 和 `x` 表示同一标识符。 -闭包（*closure*）中如果没有明确指定参数名称，参数将被隐式命名为 `$0`、`$1`、`$2` 等等。这些命名在闭包作用域范围内是合法的标识符。 +闭包中如果没有明确指定参数名称，参数将被隐式命名为 `$0`、`$1`、`$2` 等等。这些命名在闭包作用域范围内是合法的标识符。 > 标识符语法 -> *标识符* → [*头部标识符*](#identifier_head) [*标识符字符组*](#identifier_characters)可选 -> *标识符* → \`[*头部标识符*](#identifier_head) [*标识符字符组*](#identifier_characters)可选\` -> *标识符* → [*隐式参数名*](#implicit_parameter_name) - -> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier_list) +> *标识符* → [*头部标识符*](#identifier-head) [*标识符字符组*](#identifier-characters)可选 +> *标识符* → \`[*头部标识符*](#identifier-head) [*标识符字符组*](#identifier-characters)可选\` +> *标识符* → [*隐式参数名*](#implicit-parameter-name) + +> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier-list) - + > *头部标识符* → 大写或小写字母 A - Z > *头部标识符* → _ > *头部标识符* → U+00A8，U+00AA，U+00AD，U+00AF，U+00B2–U+00B5，或者 U+00B7–U+00BA @@ -69,28 +72,28 @@ Swift 的“词法结构（*lexical structure*）”描述了能构成该语言 > *头部标识符* → U+90000–U+9FFFD，U+A0000–U+AFFFD，U+B0000–U+BFFFD，或者 U+C0000–U+CFFFD > *头部标识符* → U+D0000–U+DFFFD 或者 U+E0000–U+EFFFD - + > *标识符字符* → 数值 0 - 9 > *标识符字符* → U+0300–U+036F，U+1DC0–U+1DFF，U+20D0–U+20FF，或者 U+FE20–U+FE2F -> *标识符字符* → [*头部标识符*](#identifier_head) - -> *标识符字符组* → [*标识符字符*](#identifier_character) [*标识符字符组*](#identifier_characters)可选 +> *标识符字符* → [*头部标识符*](#identifier-head) + +> *标识符字符组* → [*标识符字符*](#identifier-character) [*标识符字符组*](#identifier-characters)可选 - -> *隐式参数名* → **$** [*十进制数字列表*](#decimal_digits) + +> *隐式参数名* → **$** [*十进制数字列表*](#decimal-digits) ## 关键字和标点符号 -下面这些被保留的关键字（*keywords*）不允许用作标识符，除非被反引号转义，具体描述请参考 [标识符](#identifiers)。 +下面这些被保留的关键字不允许用作标识符，除非被反引号转义，具体描述请参考 [标识符](#identifiers)。 -* 用在声明中的关键字：`class`、`deinit`、`enum`、`extension`、`func`、`import`、`init`、`inout`、`internal`、`let`、`operator`、`private`、`protocol`、`public`、`static`、`struct`、`subscript`、`typealias`、`var`。 -* 用在语句中的关键字：`break`、`case`、`continue`、`default`、`defer`、`do`、`else`、`fallthrough`、`for`、`guard`、`if`、`in`、`repeat`、`return`、`switch`、`where`、`while`。 -* 用在表达式和类型中的关键字：`as`、`catch`、`dynamicType`、`false`、`is`、`nil`、`rethrows`、`super`、`self`、`Self`、`throw`、`throws`、`true`、`try`、`__COLUMN__`、`__FILE__`、`__FUNCTION__`、`__LINE__`。 +* 用在声明中的关键字： `class`、`deinit`、`enum`、`extension`、`func`、`import`、`init`、`inout`、`internal`、`let`、`operator`、`private`、`protocol`、`public`、`static`、`struct`、`subscript`、`typealias`、`var`。 +* 用在语句中的关键字： `break`、`case`、`continue`、`default`、`defer`、`do`、`else`、`fallthrough`、`for`、`guard`、`if`、`in`、`repeat`、`return`、`switch`、`where`、`while`。 +* 用在表达式和类型中的关键字： `as`、`catch`、`dynamicType`、`false`、`is`、`nil`、`rethrows`、`super`、`self`、`Self`、`throw`、`throws`、`true`、`try`、`__COLUMN__`、`__FILE__`、`__FUNCTION__`、`__LINE__`。 * 用在模式中的关键字：`_` -* 特定上下文中被保留的关键字：`associativity`、`convenience`、`dynamic`、`didSet`、`final`、`get`、`infix`、`indirect`、`lazy`、`left`、`mutating`、`none`、`nonmutating`、`optional`、`override`、`postfix`、`precedence`、`prefix`、`Protocol`、`required`、`right`、`set`、`Type`、`unowned`、`weak`、`willSet`，这些关键字在特定上下文之外可以被用做标识符。 +* 特定上下文中被保留的关键字： `associativity`、`convenience`、`dynamic`、`didSet`、`final`、`get`、`infix`、`indirect`、`lazy`、`left`、`mutating`、`none`、`nonmutating`、`optional`、`override`、`postfix`、`precedence`、`prefix`、`Protocol`、`required`、`right`、`set`、`Type`、`unowned`、`weak`、`willSet`，这些关键字在特定上下文之外可以被用做标识符。 -以下符号被当作保留符号，不能用于自定义运算符：`(`、`)`、`{`、`}`、`[`、`]`、`.`、`,`、`:`、`;`、`=`、`@`、`#`、`&`（作为前缀运算符）、`->`、`` ` ``、`?`、`!`（作为后缀运算符）。 +以下符号被当作保留符号，不能用于自定义运算符： `(`、`)`、`{`、`}`、`[`、`]`、`.`、`,`、`:`、`;`、`=`、`@`、`#`、`&`（作为前缀运算符）、`->`、`` ` ``、`?`、`!`（作为后缀运算符）。 ## 字面量 @@ -100,132 +103,136 @@ Swift 的“词法结构（*lexical structure*）”描述了能构成该语言 下面是字面量的一些示例： ```swift -42 // 整型字面量 -3.14159 // 浮点型字面量 -"Hello, world!" // 字符串型字面量 -true // 布尔型字面量 +42 // 整数字面量 +3.14159 // 浮点数字面量 +"Hello, world!" // 字符串字面量 +true // 布尔值字面量 ``` -字面量本身并不包含类型信息。事实上，一个字面量会被解析为拥有无限的精度，然后 Swift 的类型推导会尝试去推导出这个字面量的类型。比如，在 `let x: Int8 = 42` 这个声明中，Swift 使用了显式类型标注（`: Int8`）来推导出 `42` 这个整型字面量的类型是 `Int8`。如果没有可用的类型信息， Swift 则会从标准库中定义的字面量类型中推导出一个默认的类型。整型字面量的默认类型是 `Int`，浮点型字面量的默认类型是 `Double`，字符串型字面量的默认类型是 `String`，布尔型字面量的默认类型是 `Bool`。比如，在 `let str = "Hello, world"` 这个声明中，字符串 `"Hello, world"` 的默认推导类型就是 `String`。 +字面量本身并不包含类型信息。事实上，一个字面量会被解析为拥有无限的精度，然后 Swift 的类型推导会尝试去推导出这个字面量的类型。比如，在 `let x: Int8 = 42` 这个声明中，Swift 使用了显式类型标注（`: Int8`）来推导出 `42` 这个整数字面量的类型是 `Int8`。如果没有可用的类型信息， Swift 则会从标准库中定义的字面量类型中推导出一个默认的类型。整数字面量的默认类型是 `Int`，浮点数字面量的默认类型是 `Double`，字符串字面量的默认类型是 `String`，布尔值字面量的默认类型是 `Bool`。比如，在 `let str = "Hello, world"` 这个声明中，字符串 `"Hello, world"` 的默认推导类型就是 `String`。 -当为一个字面量值指定了类型标注的时候，这个标注的类型必须能通过这个字面量值实例化。也就是说，这个类型必须符合这些 Swift 标准库协议中的一个：整型字面量的 `IntegerLiteralConvertible` 协议、浮点型字面量的 `FloatingPointLiteralConvertible` 协议、字符串字面量的 `StringLiteralConvertible` 协议以及布尔型字面量的 `BooleanLiteralConvertible` 协议。比如，`Int8` 符合 `IntegerLiteralConvertible` 协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整型字面量 `42` 的类型标注。 +当为一个字面量值指定了类型标注的时候，这个标注的类型必须能通过这个字面量值实例化。也就是说，这个类型必须符合这些 Swift 标准库协议中的一个：整数字面量的 `IntegerLiteralConvertible` 协议、浮点数字面量的 `FloatingPointLiteralConvertible` 协议、字符串字面量的 `StringLiteralConvertible` 协议以及布尔值字面量的 `BooleanLiteralConvertible` 协议。比如，`Int8` 符合 `IntegerLiteralConvertible` 协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整数字面量 `42` 的类型标注。 > 字面量语法 -> *字面量* → [*数字型字面量*](#numeric_literal) | [*字符串型字面量*](#string_literal) | [*布尔型字面量*](#boolean_literal) | [*nil型字面量*](#nil_literal) +> *字面量* → [*数值字面量*](#numeric-literal) | [*字符串字面量*](#string-literal) | [*布尔值字面量*](#boolean-literal) | [*nil 字面量*](#nil-literal) - -> *数字型字面量* → **-**可选 [*整型字面量*](#integer_literal) | **-**可选 [*浮点型字面量*](#floating_point_literal) - -> *布尔型字面量* → **true** | **false** - -> *nil型字面量* → **nil** + +> *数值字面量* → **-**可选 [*整数字面量*](#integer-literal) | **-**可选 [*浮点数字面量*](#floating-point-literal) + +> *布尔值字面量* → **true** | **false** + +> *nil 字面量* → **nil** -### 整型字面量 + +### 整数字面量 -整型字面量（*integer literals*）表示未指定精度整型数的值。整型字面量默认用十进制表示，可以加前缀来指定其他的进制，二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 +整数字面量表示未指定精度整数的值。整数字面量默认用十进制表示，可以加前缀来指定其他的进制，二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 十进制字面量包含数字 `0` 至 `9`。二进制字面量只包含 `0` 或 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F`（大小写均可）。 -负整数的字面量在整型字面量前加负号 `-`，比如 `-42`。 +负整数的字面量在整数字面量前加负号 `-`，比如 `-42`。 整型字面面可以使用下划线 `_` 来增加数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，并不会影响字面量的值。 -除非特别指定，整型字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-ID323)。 +除非特别指定，整数字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数](../chapter2/01_The_Basics.html#integers)。 -> 整型字面量语法 +> 整数字面量语法 - -> *整型字面量* → [*二进制字面量*](#binary_literal) -> *整型字面量* → [*八进制字面量*](#octal_literal) -> *整型字面量* → [*十进制字面量*](#decimal_literal) -> *整型字面量* → [*十六进制字面量*](#hexadecimal_literal) + +> *整数字面量* → [*二进制字面量*](#binary-literal) +> *整数字面量* → [*八进制字面量*](#octal-literal) +> *整数字面量* → [*十进制字面量*](#decimal-literal) +> *整数字面量* → [*十六进制字面量*](#hexadecimal-literal) - -> *二进制字面量* → **0b** [*二进制数字*](#binary_digit) [*二进制字面量字符组*](#binary_literal_characters)可选 + +> *二进制字面量* → **0b** [*二进制数字*](#binary-digit) [*二进制字面量字符组*](#binary-literal-characters)可选 +> > *二进制数字* → 数值 0 到 1 - -> *二进制字面量字符* → [*二进制数字*](#binary_digit) | _ - -> *二进制字面量字符组* → [*二进制字面量字符*](#binary_literal_character) [*二进制字面量字符组*](#binary_literal_characters)可选 + +> *二进制字面量字符* → [*二进制数字*](#binary-digit) | _ + +> *二进制字面量字符组* → [*二进制字面量字符*](#binary-literal-character) [*二进制字面量字符组*](#binary-literal-characters)可选 - -> *八进制字面量* → **0o** [*八进字数字*](#octal_digit) [*八进制字符组*](#octal_literal_characters)可选 - + +> *八进制字面量* → **0o** [*八进字数字*](#octal-digit) [*八进制字符组*](#octal-literal-characters)可选 + > *八进字数字* → 数值 0 到 7 - -> *八进制字符* → [*八进字数字*](#octal_digit) | _ - -> *八进制字符组* → [*八进制字符*](#octal_literal_character) [*八进制字符组*](#octal_literal_characters)可选 + +> *八进制字符* → [*八进字数字*](#octal-digit) | _ + +> *八进制字符组* → [*八进制字符*](#octal-literal-character) [*八进制字符组*](#octal-literal-characters)可选 - -> *十进制字面量* → [*十进制数字*](#decimal_digit) [*十进制字符组*](#decimal_literal_characters)可选 - + +> *十进制字面量* → [*十进制数字*](#decimal-digit) [*十进制字符组*](#decimal-literal-characters)可选 + > *十进制数字* → 数值 0 到 9 - -> *十进制数字组* → [*十进制数字*](#decimal_digit) [*十进制数字组*](#decimal_digits)可选 - -> *十进制字符* → [*十进制数字*](#decimal_digit) | _ - -> *十进制字符组* → [*十进制字符*](#decimal_literal_character) [*十进制字符组*](#decimal_literal_characters)可选 + +> *十进制数字组* → [*十进制数字*](#decimal-digit) [*十进制数字组*](#decimal-digits)可选 + +> *十进制字符* → [*十进制数字*](#decimal-digit) | _ + +> *十进制字符组* → [*十进制字符*](#decimal-literal-character) [*十进制字符组*](#decimal-literal-characters)可选 - -> *十六进制字面量* → **0x** [*十六进制数字*](#hexadecimal_digit) [*十六进制字面量字符组*](#hexadecimal_literal_characters)可选 - + +> *十六进制字面量* → **0x** [*十六进制数字*](#hexadecimal-digit) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 + > *十六进制数字* → 数值 0 到 9, 字母 a 到 f, 或 A 到 F - -> *十六进制字符* → [*十六进制数字*](#hexadecimal_digit) | _ - -> *十六进制字面量字符组* → [*十六进制字符*](#hexadecimal_literal_character) [*十六进制字面量字符组*](#hexadecimal_literal_characters)可选 + +> *十六进制字符* → [*十六进制数字*](#hexadecimal-digit) | _ + +> *十六进制字面量字符组* → [*十六进制字符*](#hexadecimal-literal-character) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 -### 浮点型字面量 + +### 浮点数字面量 -浮点型字面量（*floating-point literals*）表示未指定精度浮点数的值。 +浮点数字面量表示未指定精度浮点数的值。 -浮点型字面量默认用十进制表示（无前缀），也可以用十六进制表示（加前缀 `0x`）。 +浮点数字面量默认用十进制表示（无前缀），也可以用十六进制表示（加前缀 `0x`）。 -十进制浮点型字面量由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点 `.` 后跟十进制数字串组成。指数部分由大写或小写字母 `e` 为前缀后跟十进制数字串组成，这串数字表示 `e` 之前的数量乘以 10 的几次方。例如：`1.25e2` 表示 `1.25 ⨉ 10^2`，也就是 `125.0`；同样，`1.25e－2` 表示 `1.25 ⨉ 10^－2`，也就是 `0.0125`。 +十进制浮点数字面量由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点 `.` 后跟十进制数字串组成。指数部分由大写或小写字母 `e` 为前缀后跟十进制数字串组成，这串数字表示 `e` 之前的数量乘以 10 的几次方。例如：`1.25e2` 表示 `1.25 ⨉ 10^2`，也就是 `125.0`；同样，`1.25e－2` 表示 `1.25 ⨉ 10^－2`，也就是 `0.0125`。 -十六进制浮点型字面量由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 为前缀后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 `15 ⨉ 2^2`，也就是 `60`；同样，`0xFp-2` 表示 `15 ⨉ 2^-2`，也就是 `3.75`。 +十六进制浮点数字面量由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 为前缀后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 `15 ⨉ 2^2`，也就是 `60`；同样，`0xFp-2` 表示 `15 ⨉ 2^-2`，也就是 `3.75`。 -负数的浮点型字面量由负号 `-` 和浮点型字面量组成，例如 `-42.5`。 +负数的浮点数字面量由负号 `-` 和浮点数字面量组成，例如 `-42.5`。 -浮点型字面量允许使用下划线 `_` 来增强数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，并不会影响字面量的值。 +浮点数字面量允许使用下划线 `_` 来增强数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，并不会影响字面量的值。 -除非特别指定，浮点型字面量的默认推导类型为 Swift 标准库类型中的 `Double`，表示 64 位浮点数。Swift 标准库也定义了 `Float` 类型，表示 32 位浮点数。 +除非特别指定，浮点数字面量的默认推导类型为 Swift 标准库类型中的 `Double`，表示 64 位浮点数。Swift 标准库也定义了 `Float` 类型，表示 32 位浮点数。 -> 浮点型字面量语法 +> 浮点数字面量语法 - -> *浮点数字面量* → [*十进制字面量*](#decimal_literal) [*十进制分数*](#decimal_fraction)可选 [*十进制指数*](#decimal_exponent)可选 -> *浮点数字面量* → [*十六进制字面量*](#hexadecimal_literal) [*十六进制分数*](#hexadecimal_fraction)可选 [*十六进制指数*](#hexadecimal_exponent) + +> *浮点数字面量* → [*十进制字面量*](#decimal-literal) [*十进制分数*](#decimal-fraction)可选 [*十进制指数*](#decimal-exponent)可选 +> *浮点数字面量* → [*十六进制字面量*](#hexadecimal-literal) [*十六进制分数*](#hexadecimal-fraction)可选 [*十六进制指数*](#hexadecimal-exponent) - -> *十进制分数* → **.** [*十进制字面量*](#decimal_literal) - -> *十进制指数* → [*十进制指数 e*](#floating_point_e) [*正负号*](#sign)可选 [*十进制字面量*](#decimal_literal) + +> *十进制分数* → **.** [*十进制字面量*](#decimal-literal) + +> *十进制指数* → [*十进制指数 e*](#floating-point-e) [*正负号*](#sign)可选 [*十进制字面量*](#decimal-literal) - -> *十六进制分数* → **.** [*十六进制数字*](#hexadecimal_digit) [*十六进制字面量字符组*](#hexadecimal_literal_characters)可选 - -> *十六进制指数* → [*十六进制指数 p*](#floating_point_p) [*正负号*](#sign)可选 [*十进制字面量*](#decimal_literal) + +> *十六进制分数* → **.** [*十六进制数字*](#hexadecimal-digit) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 + +> *十六进制指数* → [*十六进制指数 p*](#floating-point-p) [*正负号*](#sign)可选 [*十进制字面量*](#decimal-literal) - + > *十进制指数 e* → **e** | **E** - + > *十六进制指数 p* → **p** | **P** > *正负号* → **+** | **-** -### 字符串型字面量 + +### 字符串字面量 -字符串型字面量（*string literal*）由被包在双引号中的一串字符组成，形式如下： +字符串字面量由被包在双引号中的一串字符组成，形式如下： ```swift "characters" ``` -字符串型字面量中不能包含未转义的双引号（`"`）、未转义的反斜线（`\`）、回车符、换行符。 +字符串字面量中不能包含未转义的双引号（`"`）、未转义的反斜线（`\`）、回车符、换行符。 可以在字符串字面量中使用的转义特殊符号如下： @@ -250,7 +257,7 @@ true // 布尔型字面量 let x = 3; "1 2 \(x)" ``` -字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../chapter2/03_Strings_and_Characters.html) 以及 [字符串结构体参考](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_String_Structure/index.html#//apple_ref/doc/uid/TP40015181)。 +字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../chapter2/03_Strings_and_Characters.html) 以及 [*String Structure Reference*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Reference/Swift_String_Structure/index.html#//apple_ref/doc/uid/TP40015181)。 用 `＋` 操作符连接的字符型字面量是在编译时进行连接的。比如下面的 `textA` 和 `textB` 是完全一样的，`textA` 没有任何运行时的连接操作。 @@ -259,30 +266,30 @@ let textA = "Hello " + "world" let textB = "Hello world" ``` -> 字符串型字面量语法 +> 字符串字面量语法 - -> *字符串字面量* → [*静态字符串字面量*](#static_string_literal) | [*插值字符串字面量*](#interpolated_string_literal) + +> *字符串字面量* → [*静态字符串字面量*](#static-string-literal) | [*插值字符串字面量*](#interpolated-string-literal) - -> *静态字符串字面量* → **"**[*引用文本*](#quoted_text)可选**"** - -> *引用文本* → [*引用文本项*](#quoted_text_item) [*引用文本*](#quoted_text)可选 - -> *引用文本项* → [*转义字符*](#escaped_character) + +> *静态字符串字面量* → **"**[*引用文本*](#quoted-text)可选**"** + +> *引用文本* → [*引用文本项*](#quoted-text-item) [*引用文本*](#quoted-text)可选 + +> *引用文本项* → [*转义字符*](#escaped-character) > *引用文本项* → 除了 **"**、**\\**、U+000A、U+000D 以外的所有 Unicode 字符 - -> *插值字符串字面量* → **"**[*插值文本*](#interpolated_text)可选**"** - -> *插值文本* → [*插值文本项*](#interpolated_text_item) [*插值文本*](#interpolated_text)可选 - -> *插值文本项* → **\\****(**[*表达式*](./04_Expressions.html)**)** | [*引用文本项*](#quoted_text_item) + +> *插值字符串字面量* → **"**[*插值文本*](#interpolated-text)可选**"** + +> *插值文本* → [*插值文本项*](#interpolated-text-item) [*插值文本*](#interpolated-text)可选 + +> *插值文本项* → **\\****(**[*表达式*](./04_Expressions.html)**)** | [*引用文本项*](#quoted-text-item) - + > *转义字符* → **\\****0** | **\\****\\** | **\t** | **\n** | **\r** | **\\"** | **\\'** -> *转义字符* → **\u {** [*unicode 标量数字*](#unicode_scalar_digits) **}** - +> *转义字符* → **\u {** [*unicode 标量数字*](#unicode-scalar-digits) **}** + > *unicode 标量数字* → 一到八位的十六进制数字 @@ -308,15 +315,15 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 在某些特定的设计中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号，剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的符号，因而不会被错误解析为 `>>` 运算符。 -要学习如何自定义运算符，请参考 [自定义运算符](../chapter2/25_Advanced_Operators.html#custom_operators) 和 [运算符声明](./05_Declarations.html#operator_declaration)。要学习如何重载运算符，请参考 [运算符方法](../chapter2/25_Advanced_Operators.html#operator_functions)。 +要学习如何自定义运算符，请参考 [自定义运算符](../chapter2/25_Advanced_Operators.html#custom_operators) 和 [运算符声明](05_Declarations.html#operator_declaration)。要学习如何重载运算符，请参考 [运算符函数](../chapter2/25_Advanced_Operators.html#operator_functions)。 > 运算符语法 -> *运算符* → [*头部运算符*](#operator_head) [*运算符字符组*](#operator_characters)可选 -> *运算符* → [*头部点运算符*](#dot_operator_head) [*点运算符字符组*](#dot_operator_characters)可选 +> *运算符* → [*头部运算符*](#operator-head) [*运算符字符组*](#operator-characters)可选 +> *运算符* → [*头部点运算符*](#dot-operator-head) [*点运算符字符组*](#dot-operator-characters)可选 - + > *头部运算符* → **/** | **=** | **-** | **+** | **!** | __*__ | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **?** > *头部运算符* → U+00A1–U+00A7 > *头部运算符* → U+00A9 或 U+00AB @@ -333,24 +340,27 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 > *头部运算符* → U+3001–U+3003 > *头部运算符* → U+3008–U+3030 - -> *运算符字符* → [*头部运算符*](#operator_head) + +> *运算符字符* → [*头部运算符*](#operator-head) > *运算符字符* → U+0300–U+036F > *运算符字符* → U+1DC0–U+1DFF > *运算符字符* → U+20D0–U+20FF > *运算符字符* → U+FE00–U+FE0F > *运算符字符* → U+FE20–U+FE2F > *运算符字符* → U+E0100–U+E01EF - -> *运算符字符组* → [*运算符字符*](#operator_character) [*运算符字符组*](#operator_characters)可选 + +> *运算符字符组* → [*运算符字符*](#operator-character) [*运算符字符组*](#operator-characters)可选 - + > *头部点运算符* → **..** - -> *点运算符字符* → **.** | [*运算符字符*](#operator_character) - -> *点运算符字符组* → [*点运算符字符*](#dot_operator_character) [*点运算符字符组*](#dot_operator_characters)可选 + +> *点运算符字符* → **.** | [*运算符字符*](#operator-character) + +> *点运算符字符组* → [*点运算符字符*](#dot-operator-character) [*点运算符字符组*](#dot-operator-characters)可选 + > *二元运算符* → [*运算符*](#operator) -> *前置运算符* → [*运算符*](#operator) -> *后置运算符* → [*运算符*](#operator) + +> *前缀运算符* → [*运算符*](#operator) + +> *后缀运算符* → [*运算符*](#operator) diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md index 5846950f..84f65eac 100644 --- a/source/chapter3/03_Types.md +++ b/source/chapter3/03_Types.md @@ -13,22 +13,22 @@ 本页包含内容： -- [类型注解（Type Annotation）](#type_annotation) -- [类型标识符（Type Identifier）](#type_identifier) -- [元组类型（Tuple Type）](#tuple_type) -- [函数类型（Function Type）](#function_type) -- [数组类型（Array Type）](#array_type) -- [字典类型（Dictionary Type）](#dictionary_type) -- [可选类型（Optional Type）](#optional_type) -- [隐式解析可选类型（Implicitly Unwrapped Optional Type）](#implicitly_unwrapped_optional_type) -- [协议合成类型（Protocol Composition Type）](#protocol_composition_type) -- [元类型（Metatype Type）](#metatype_type) -- [类型继承子句（Type Inheritance Clause）](#type_inheritance_clause) -- [类型推断（Type Inference）](#type_inference) +- [类型注解](#type_annotation) +- [类型标识符](#type_identifier) +- [元组类型](#tuple_type) +- [函数类型](#function_type) +- [数组类型](#array_type) +- [字典类型](#dictionary_type) +- [可选类型](#optional_type) +- [隐式解析可选类型](#implicitly_unwrapped_optional_type) +- [协议合成类型](#protocol_composition_type) +- [元类型](#metatype_type) +- [类型继承子句](#type_inheritance_clause) +- [类型推断](#type_inference) Swift 语言存在两种类型：命名型类型和复合型类型。命名型类型是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类 MyClass 的实例拥有类型 MyClass。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。 -那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照“扩展和扩展声明”章节里讨论的那样，声明一个扩展来增加它们的行为以迎合你程序的需求。 +那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照 [扩展](../chapter2/21_Extensions.html) 和 [扩展声明](05_Declarations.html#extension_declaration) 中讨论的那样，声明一个扩展来增加它们的行为以满足你程序的需求。 复合型类型是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型 `(Int, (Int, Int))` 包含两个元素：第一个是命名型类型 `Int`，第二个是另一个复合型类型 `(Int, Int)`。 @@ -36,7 +36,7 @@ Swift 语言存在两种类型：命名型类型和复合型类型。命名型 > 类型语法 -> *类型* → [*数组类型*](#array_type) | [*字典类型*](#dictionary_type) | [*函数类型*](#function_type) | [*类型标识*](#type_identifier) | [*元组类型*](#tuple_type) | [*可选类型*](#optional_type) | [*隐式解析可选类型*](#implicitly_unwrapped_optional_type) | [*协议合成类型*](#protocol_composition_type) | [*元型类型*](#metatype_type) +> *类型* → [*数组类型*](#array-type) | [*字典类型*](#dictionary-type) | [*函数类型*](#function-type) | [*类型标识*](#type-identifier) | [*元组类型*](#tuple-type) | [*可选类型*](#optional-type) | [*隐式解析可选类型*](#implicitly-unwrapped-optional-type) | [*协议合成类型*](#protocol-composition-type) | [*元型类型*](#metatype-type) ## 类型注解 @@ -52,7 +52,8 @@ func someFunction(a: Int) { /* ... */ } 类型注解可以在类型之前包含一个类型特性的可选列表。 > 类型注解语法 -> *类型注解* → **:** [*特性列表*](../chapter3/06_Attributes.html#attributes)可选 [*类型*](#type) + +> *类型注解* → **:** [*特性列表*](06_Attributes.html#attributes)可选 [*类型*](#type) ## 类型标识符 @@ -75,9 +76,10 @@ var someValue: ExampleModule.MyType ``` > 类型标识符语法 -> *类型标识符* → [*类型名称*](#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause)可选 | [*类型名称*](#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause)可选 **.** [*类型标识符*](#type_identifier) - -> *类型名称* → [*标识符*](LexicalStructure.html#identifier) + +> *类型标识符* → [*类型名称*](#type-name) [*泛型参数子句*](08_Generic_Parameters_and_Arguments.html#generic_argument_clause)可选 | [*类型名称*](#type-name) [*泛型参数子句*](08_Generic_Parameters_and_Arguments.html#generic_argument_clause)可选 **.** [*类型标识符*](#type-identifier) + +> *类型名称* → [*标识符*](02_Lexical_Structure.html#identifier) ## 元组类型 @@ -89,15 +91,16 @@ var someValue: ExampleModule.MyType `Void` 是空元组类型 `()` 的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)` 的类型是 `Int` 而不是 `(Int)`。所以，只有当元组类型包含的元素个数在两个及以上时才可以命名元组元素。 > 元组类型语法 -> *元组类型* → **(** [*元组类型主体*](#tuple_type_body)可选 **)** - -> *元组类型主体* → [*元组类型元素列表*](#tuple_type_element_list) **...**可选 - -> *元组类型元素列表* → [*元组类型元素*](#tuple_type_element) | [*元组类型元素*](#tuple_type_element) **,** [*元组类型元素列表*](#tuple_type_element_list) - -> *元组类型元素* → [*特性列表*](../chapter3/06_Attributes.html#attributes)可选 **inout**可选 [*类型*](#type) | **inout**可选 [*元素名*](#element_name) [*类型注解*](#type_annotation) - -> *元素名* → [*标识符*](LexicalStructure.html#identifier) + +> *元组类型* → **(** [*元组类型主体*](#tuple-type-body)可选 **)** + +> *元组类型主体* → [*元组类型元素列表*](#tuple-type-element-list) **...**可选 + +> *元组类型元素列表* → [*元组类型元素*](#tuple-type-element) | [*元组类型元素*](#tuple-type-element) **,** [*元组类型元素列表*](#tuple-type-element-list) + +> *元组类型元素* → [*特性列表*](06_Attributes.html#attributes)可选 **inout**可选 [*类型*](#type) | **inout**可选 [*元素名*](#element-name) [*类型注解*](#type-annotation) + +> *元素名* → [*标识符*](02_Lexical_Structure.html#identifier) ## 函数类型 @@ -114,11 +117,12 @@ var someValue: ExampleModule.MyType 为了指定一个 `in-out` 参数，可以在参数类型前加 `inout` 前缀。但是你不可以对可变长参数或返回值类型使用 `inout`。关于这种参数的详细讲解请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters)。 -柯里化函数（Curried fuction）的函数类型从右向左进行组合。例如，函数类型 `Int -> Int -> Int` 可以理解为 `Int -> (Int -> Int)`，也就是说，该函数类型的参数为 `Int` 类型，其返回类型是一个参数类型为 `Int`，返回类型为 `Int` 的函数类型。关于柯里化函数的讨论见章节 [柯里化函数](05_Declarations.html#curried_functions)。 +柯里化函数的函数类型从右向左进行组合。例如，函数类型 `Int -> Int -> Int` 可以理解为 `Int -> (Int -> Int)`，也就是说，该函数类型的参数为 `Int` 类型，其返回类型是一个参数类型为 `Int`，返回类型为 `Int` 的函数类型。关于柯里化函数的讨论见章节 [柯里化函数](05_Declarations.html#curried_functions)。 -函数类型若要抛出错误就必须使用 `throws` 关键字来标记，若要重抛错误则必须使用 `rethrows` 关键字来标记。`throws` 关键字是函数类型的一部分，不抛出函数（nonthrowing function）是抛出函数（throwing function）函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。对于柯里化函数，`throws` 关键字只应用于最里层的函数。抛出和重抛函数（rethrowing function）的相关描述见章节 [抛出函数与方法](05_Declarations.html#throwing_functions_and_methods) 和 [重抛函数与方法](05_Declarations.html#rethrowing_functions_and_methods)。 +函数类型若要抛出错误就必须使用 `throws` 关键字来标记，若要重抛错误则必须使用 `rethrows` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。对于柯里化函数，`throws` 关键字只应用于最里层的函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](05_Declarations.html#throwing_functions_and_methods) 和 [重抛函数与方法](05_Declarations.html#rethrowing_functions_and_methods)。 > 函数类型语法 + > *函数类型* → [*类型*](#type) **throws**可选 **->** [*类型*](#type) > *函数类型* → [*类型*](#type) **rethrows**可选 **->** [*类型*](#type) @@ -149,6 +153,7 @@ var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]] 关于 Swift 标准库中 `Array` 类型的详细讨论，请参阅 [数组](../chapter2/04_Collection_Types.html#arrays)。 > 数组类型语法 + > *数组类型* → **[** [*类型*](#type) **]** @@ -174,6 +179,7 @@ let someDictionary: Dictionary = ["Alex": 31, "Paul": 39] 关于 Swift 标准库中 `Dictionary` 类型的详细讨论，请参阅 [字典](../chapter2/04_Collection_Types.html#dictionaries)。 > 字典类型语法 + > *字典类型* → **[** [*类型*](#type) **:** [*类型*](#type) **]** @@ -204,6 +210,7 @@ optionalInteger! // 42 更多细节以及更多如何使用可选类型的例子，请参阅 [可选类型](../chapter2/01_The_Basics.html#optionals)。 > 可选类型语法 + > *可选类型* → [*类型*](#type) **?** @@ -229,6 +236,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional 关于隐式解析可选类型的更多细节，请参阅 [隐式解析可选类型](../chapter2/01_The_Basics.html#implicityly_unwrapped_optionals)。 > 隐式解析可选类型语法 + > *隐式解析可选类型* → [*类型*](#type) **!** @@ -245,11 +253,12 @@ protocol<`Protocol 1`, `Procotol 2`> 协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，每个类型都符合它。 > 协议合成类型语法 -> *协议合成类型* → **protocol** **<** [*协议标识符列表*](#protocol_identifier_list)可选 **>** - -> *协议标识符列表* → [*协议标识符*](#protocol_identifier) | [*协议标识符*](#protocol_identifier) **,** [*协议标识符列表*](#protocol_identifier_list) - -> *协议标识符* → [*类型标识符*](#type_identifier) + +> *协议合成类型* → **protocol** **<** [*协议标识符列表*](#protocol-identifier-list)可选 **>** + +> *协议标识符列表* → [*协议标识符*](#protocol-identifier) | [*协议标识符*](#protocol-identifier) **,** [*协议标识符列表*](#protocol-identifier-list) + +> *协议标识符* → [*类型标识符*](#type-identifier) ## 元类型 @@ -306,6 +315,7 @@ let anotherInstance = metatype.init(string: "some string") ``` > 元类型语法 + > *元类型* → [*类型*](#type) **.** **Type** | [*类型*](#type) **.** **Protocol** @@ -321,12 +331,12 @@ let anotherInstance = metatype.init(string: "some string") > 类型继承子句语法 -> *类型继承子句* → **:** [*类要求*](#class_requirement) **,** [*类型继承列表*](#type_inheritance_list) -> *类型继承子句* → **:** [*类要求*](#class_requirement) -> *类型继承子句* → **:** [*类型继承列表*](#type_inheritance_list) - -> *类型继承列表* → [*类型标识符*](#type_identifier) | [*类型标识符*](#type_identifier) **,** [*类型继承列表*](#type_inheritance_list) - +> *类型继承子句* → **:** [*类要求*](#class-requirement) **,** [*类型继承列表*](#type-inheritance-list) +> *类型继承子句* → **:** [*类要求*](#class-requirement) +> *类型继承子句* → **:** [*类型继承列表*](#type-inheritance-list) + +> *类型继承列表* → [*类型标识符*](#type-identifier) | [*类型标识符*](#type-identifier) **,** [*类型继承列表*](#type-inheritance-list) + > *类要求* → **class** diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md index 1fca522a..d1140445 100755 --- a/source/chapter3/05_Declarations.md +++ b/source/chapter3/05_Declarations.md @@ -245,10 +245,13 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter > *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block) > *变量声明头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var** > *变量名称* → [*标识符*](LexicalStructure.html#identifier) + > *getter-setter块* → **{** [*getter子句*](../chapter3/05_Declarations.html#getter_clause) [*setter子句*](../chapter3/05_Declarations.html#setter_clause) _可选_ **}** > *getter-setter块* → **{** [*setter子句*](../chapter3/05_Declarations.html#setter_clause) [*getter子句*](../chapter3/05_Declarations.html#getter_clause) **}** -> *getter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block) -> *setter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) + +> *getter 子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block) + +> *setter 子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) > *setter名称* → **(** [*标识符*](LexicalStructure.html#identifier) **)** > *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) _可选_ **}** > *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) **}**