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

校对

Browse Source
This commit is contained in:
949478479
2015-12-05 17:22:47 +08:00
parent e24082e922
commit 4035ee04bf
1 changed files with 101 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
source/chapter3/04_Expressions.md
View File

@ -25,7 +25,7 @@
- [super 表达式](#superclass_expression)
- [闭包表达式](#closure_expression)
- [隐式成员表达式](#implicit_member_expression)
- [括号表达式](#parenthesized_expression)
- [圆括号表达式](#parenthesized_expression)
- [通配符表达式](#wildcard_expression)
- [后缀表达式](#postfix_expressions)
- [函数调用表达式](#function_call_expression)
@ -56,7 +56,7 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表
关于 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)。
除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。 更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters).
除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。 更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.html#in_out_parameters)。
> 前缀表达式语法
<a name="prefix-expression"></a>
@ -70,17 +70,17 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表
try 表达式由 `try` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下：
try `可抛出错误的表达式`
> try `可抛出错误的表达式`
可选的 try 表达式由 `try?` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下：
try? `可抛出错误的表达式`
> try? `可抛出错误的表达式`
如果可抛出错误的表达式没有抛出错误，整个表达式返回的可选值将包含可抛出错误的表达式的返回值，否则，该可选值为 `nil`。
强制的 try 表达式由 `try!` 运算符加上紧随其后的可抛出错误的表达式组成，形式如下：
try! `可抛出错误的表达式`
> try! `可抛出错误的表达式`
如果可抛出错误的表达式抛出了错误，将会引发运行时错误。
@ -105,7 +105,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
二元表达式形式如下：
`左侧参数` `二元运算符` `右侧参数`
> `左侧参数` `二元运算符` `右侧参数`
关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/25_Advanced_Operators.html)。
@ -128,7 +128,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
赋值表达式会为某个给定的表达式赋值，形式如下；
`表达式` = `值`
> `表达式` = `值`
右边的值会被赋值给左边的表达式。如果左边表达式是一个元组，那么右边必须是一个具有同样元素个数的元组。嵌套元组也是允许的。
@ -148,7 +148,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
三元条件运算符会根据条件来对两个给定表达式中的一个进行求值，形式如下：
`条件` ? `表达式（条件为真则使用）` : `表达式（条件为假则使用）`
> `条件` ? `表达式（条件为真则使用）` : `表达式（条件为假则使用）`
如果条件为真，那么对第一个表达式进行求值并返回结果。否则，对第二个表达式进行求值并返回结果。未使用的表达式不会进行求值。
@ -163,7 +163,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
有 4 种类型转换运算符：`is`、`as`、`? `和`!`。它们有如下的形式：
`表达式` is `类型`
> `表达式` is `类型`
`表达式` as `类型`
`表达式` is? `类型`
`表达式` as! `类型`
@ -196,7 +196,7 @@ f(x as Any)
关于类型转换的更多内容和例子，请参阅 [类型转换](../chapter2/19_Type_Casting.html)。
> 类型转换运算符语法
<a name="type-casting-operator"></a>
<a name="type-casting-operator"></a>
> *类型转换运算符* → **is** [*类型*](03_Types.html#type)
> *类型转换运算符* → **as** [*类型*](03_Types.html#type)
> *类型转换运算符* → **is** **?** [*类型*](03_Types.html#type)
@ -205,74 +205,84 @@ f(x as Any)
<a name="primary_expressions"></a>
## 基本表达式
`主表达式`是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。
基本表达式是最基本的表达式。 它们可以跟前缀表达式、二元表达式、后缀表达式以及其他基本表达式组合使用。
> 主表达式语法
> *主表达式* → [*标识符*](LexicalStructure.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)
> 基本表达式语法
> *基本表达式* → [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](08_Generic_Parameters_and_Arguments.md#generic-argument-clause)<sub>可选</sub>
> *基本表达式* → [*字面量表达式*](#literal-expression)
> *基本表达式* → [*self表达式*](#self-expression)
> *基本表达式* → [*超类表达式*](#superclass-expression)
> *基本表达式* → [*闭包表达式*](#closure-expression)
> *基本表达式* → [*圆括号表达式*](#parenthesized-expression)
> *基本表达式* → [*隐式成员表达式*](#implicit-member-expression)
> *基本表达式* → [*通配符表达式*](#wildcard-expression)
<a name="literal_expression"></a>
### 字面量表达式
由这些内容组成：普通的字符（string, number） , 一个字符的字典或者数组，或者下面列表中的特殊字符。
字面量表达式可由普通字面量（例如字符串或者数字），字典或者数组字面量，或者下面列表中的特殊字面量组成：
字符（Literal） | 类型（Type） | 值（Value）
------------- | ---------- | ----------
/__FILE__ | String | 所在的文件名
/__LINE__ | Int | 所在的行数
/__COLUMN__ | Int | 所在的列数
/__FUNCTION__ | String | 所在的function 的名字
字面量 | 类型 | 值
:------------- | :---------- | :----------
`__FILE__` | `String` | 所在的文件名
`__LINE__` | `Int` | 所在的行数
`__COLUMN__` | `Int` | 所在的列数
`__FUNCTION__` | `String` | 所在的声明的名字
在某个函数（function）中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在特殊的成员如init/subscript中 会返回这个关键字的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。
对于 `__FUNCTION__`，在函数中会返回当前函数的名字，在方法中会返回当前方法的名字，在属性的存取器中会返回属性的名字，在特殊的成员如 `init` 或 `subscript` 中会返回这个关键字的名字，在某个文件中会返回当前模块的名字。
`__FUNCTION__` 作为函数或者方法的默认参数值时，该字面量的值取决于函数或方法调用时所处的环境。
当作为函数或者方法时，字符型表达式的值在被调用时初始化。
```swift
func logFunctionName(string: String = __FUNCTION__) {
print(string)
}
func myFunction() {
logFunctionName() // Prints "myFunction()".
logFunctionName() // 打印 “myFunction()”
}
myFunction()
namedArgs(1, withJay: 2)
```
一个`array literal`，是一个有序的值的集合。 它的形式是：
数组字面量是值的有序集合，形式如下：
> [`value 1`, `value 2`, `...`]
> [`值 1`, `值 2`, `...`]
数组中的最后一个表达式可以紧跟一个逗号。数组字面量的类型是 `[T]`，这个 `T` 就是数组中元素的类型。如果数组中包含多种类型，`T` 则是跟这些类型最接近的的公共父类型。空数组字面量由一组方括号定义，可用来创建特定类型的空数组。
数组中的最后一个表达式可以紧跟一个逗号（','）. []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共`supertype`最接近的type.空的`array literal`由一组方括号定义，可用来创建特定类型的空数组。
```swift
var emptyArray: [Double] = []
```
一个`dictionary literal` 是一个包含无序的键值对（key-value pairs）的集合，它的形式是:
字典字面量是一个包含无序键值对的集合，形式如下：
> [`key 1`: `value 1`, `key 2`: `value 2`, `...`]
> [`键 1` : `值 1`, `键 2` : `值 2`, `...`]
dictionary 的最后一个表达式可以是一个逗号（','）. [:] 表示一个空的dictionary. 它的type是 Dictionary<KeyType, ValueType> （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.一个空的dictionary literal由方括号中加一个冒号组成，以此来与空array literal区分开，可以使用空的dictionary literal来创建特定类型的键值对。
字典中的最后一个表达式可以紧跟一个逗号。字典字面量的类型是 `[Key : Value]`，`Key` 表示键的类型，`Value` 表示值的类型。如果字典中包含多种类型，那么 `Key` 表示的类型则为所有键最接近的公共父类型，`Value` 也是同样如此。一个空的字典字面量由方括号中加一个冒号组成（`[:]`），从而与空数组字面量区分开，可以使用空字典字面量来创建特定类型的字典。
```swift
var emptyDictionary: [String: Double]=[:]
var emptyDictionary: [String : Double] = [:]
```
> 字面量表达式语法
> *字面量表达式* → [*字面量*](LexicalStructure.html#literal)
> *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal)
> *字面量表达式* → **&#95;&#95;FILE&#95;&#95;** | **&#95;&#95;LINE&#95;&#95;** | **&#95;&#95;COLUMN&#95;&#95;** | **&#95;&#95;FUNCTION&#95;&#95;**
> *数组字面量* → **[** [*数组字面量项列表*](../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)
<a name="literal-expression"></a>
> *字面量表达式* → [*字面量*](02_Lexical_Structure.md#literal)
> *字面量表达式* → [*数组字面量*](#array-literal) | [*字典字面量*](#dictionary-literal)
> *字面量表达式* → **\_\_FILE\_\_** | **\_\_LINE\_\_** | **\_\_COLUMN\_\_** | **\_\_FUNCTION\_\_**
<a name="array-literal"></a>
> *数组字面量* → **[** [*数组字面量项列表*](#array-literal-items)<sub>可选</sub> **]**
<a name="array-literal-items"></a>
> *数组字面量项列表* → [*数组字面量项*](#array-literal-item) **,**<sub>可选</sub> | [*数组字面量项*](#array-literal-item) **,** [*数组字面量项列表*](#array-literal-items)
<a name="array-literal-item"></a>
> *数组字面量项* → [*表达式*](#expression)
<a name="dictionary-literal"></a>
> *字典字面量* → **[** [*字典字面量项列表*](#dictionary-literal-items) **]** | **[** **:** **]**
<a name="dictionary-literal-items"></a>
> *字典字面量项列表* → [*字典字面量项*](#dictionary-literal-item) **,**<sub>可选</sub> | [*字典字面量项*](#dictionary-literal-item) **,** [*字典字面量项列表*](#dictionary-literal-items)
<a name="dictionary-literal-item"></a>
> *字典字面量项* → [*表达式*](#expression) **:** [*表达式*](#expression)
<a name="self_expression"></a>
### self 表达式
@ -310,11 +320,12 @@ struct Point {
}
```
> Self 表达式语法
> *self表达式* → **self**
> *self表达式* → **self** **.** [*标识符*](LexicalStructure.html#identifier)
> *self表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**
> *self表达式* → **self** **.** **init**
> self 表达式语法
<a name="self-expression"></a>
> *self 表达式* → **self**
> *self 表达式* → **self** **.** [*标识符*](02_Lexical_Structure.md#identifier)
> *self 表达式* → **self** **[** [*表达式*](#expression) **]**
> *self 表达式* → **self** **.** **init**
<a name="superclass_expression"></a>
### super 表达式
@ -329,10 +340,14 @@ struct Point {
子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。
> 超类(superclass)表达式语法
> *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression)
> super 表达式语法
<a name="superclass-expression"></a>
> *super 表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression)
<a name="superclass-method-expression"></a>
> *超类方法表达式* → **super** **.** [*标识符*](LexicalStructure.html#identifier)
<a name="superclass-subscript-expression"></a>
> *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**
<a name="superclass-initializer-expression"></a>
> *超类构造器表达式* → **super** **.** **init**
<a name="closure_expression"></a>
@ -396,14 +411,25 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
关于闭包表达式的更多信息和例子，请参见： [Closure Expressions](TODO：添加链接)，关于更多参数列表的信息和例子，请参见： [Resolving Strong Reference Cycles for Closures](TODO：添加链接)。
> 闭包表达式语法
> *闭包表达式* → **{** [*闭包签名(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)* → [*标识符列表*](LexicalStructure.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) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**
<a name="closure-expression"></a>
> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature)<sub>可选</sub> [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}**
<a name="closure-signature"></a>
> *闭包签名(Signational)* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **in**
> *闭包签名(Signational)* → [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **in**
> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **in**
> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result)<sub>可选</sub> **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)**
<a name="capture-list"></a>
> *捕获列表* → **[** [*捕获说明符*](#capture-specifier) [*表达式*](#expression) **]**
<a name="capture-list-items"></a>
> *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items)
<a name="capture-list-item"></a>
> *捕获列表项* → [*捕获说明符*](#capture-specifier)<sub>可选</sub> [*表达式*](#expression)
<a name="capture-specifier"></a>
> *捕获说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**
<a name="implicit_member_expression"></a>
### 隐式成员表达式
@ -420,10 +446,11 @@ x = .AnotherValue
```
> 隐式成员表达式语法
<a name="implicit-member-expression"></a>
> *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)
<a name="parenthesized_expression"></a>
### 括号表达式
### 圆括号表达式
圆括号表达式由多个子表达式和逗号','组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下：
@ -431,10 +458,14 @@ x = .AnotherValue
圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int）
> 圆括号表达式(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)
> 圆括号表达式语法
<a name="parenthesized-expression"></a>
> *圆括号表达式* → **(** [*表达式元素列表*](#expression-element-list)<sub>可选</sub> **)**
<a name="expression-element-list"></a>
> *表达式元素列表* → [*表达式元素*](#expression-element) | [*表达式元素*](#expression-element) **,** [*表达式元素列表*](#expression-element-list)
<a name="expression-element"></a>
> *表达式元素* → [*表达式*](#expression) | [*标识符*](02_Lexical_Structure.md#identifier) **:** [*表达式*](#expression)
<a name="wildcard_expression"></a>
### 通配符表达式
@ -446,6 +477,7 @@ x = .AnotherValue
```
> 通配符表达式语法
<a name="wildcard-expression"></a>
> *通配符表达式* → **_**
<a name="postfix_expressions"></a>
@ -704,6 +736,6 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects()
// someDictionary is now [b: [10, 20], a: [42, 2, 3]]
```
> 可选链表达式语法
> *可选链表达式* → [*后缀表达式*](../chapter3/04_Expressions.html#postfix_expression) **?**
<a name="optional-chaining-expression"></a>
> *可选链表达式* → [*后缀表达式*](#postfix-expression) **?**