From 4ade91c7ac9810d741112f2025570fedf66a0740 Mon Sep 17 00:00:00 2001 From: 949478479 <949478479@qq.com> Date: Sun, 6 Dec 2015 21:31:19 +0800 Subject: [PATCH] =?UTF-8?q?=E6=A0=A1=E5=AF=B9=E8=87=B3=20=E2=80=9C?= =?UTF-8?q?=E5=90=8E=E7=BC=80=E8=A1=A8=E8=BE=BE=E5=BC=8F=E2=80=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter3/04_Expressions.md | 158 ++++++++++++++++++------------ 1 file changed, 97 insertions(+), 61 deletions(-) diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md index 4a7194d6..8a2b6e5f 100644 --- a/source/chapter3/04_Expressions.md +++ b/source/chapter3/04_Expressions.md @@ -22,7 +22,7 @@ - [基本表达式](#primary_expressions) - [字面量表达式](#literal_expression) - [self 表达式](#self_expression) - - [super 表达式](#superclass_expression) + - [超类表达式](#superclass_expression) - [闭包表达式](#closure_expression) - [隐式成员表达式](#implicit_member_expression) - [圆括号表达式](#parenthesized_expression) @@ -114,8 +114,8 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try > 注意 > 在解析时，一个二元表达式将作为一个简单列表表示，然后根据运算符的优先级，再进一步进行组合。例如，`2 + 3 * 5` 首先被看作具有五个元素的列表，即 `2`、`+`、`3`、`*`、`5`，随后根据运算符优先级组合为 `(2 + (3 * 5))`。 -> 二元表达式语法 +> 二元表达式语法 > *二元表达式* → [*二元运算符*](02_Lexical_Structure.html#binary-operator) [*前缀表达式*](#prefix-expression) > *二元表达式* → [*赋值运算符*](#assignment-operator) [*try运算符*](#try-operator)可选 [*前缀表达式*](#prefix-expression) > *二元表达式* → [*条件运算符*](#conditional-operator) [*try运算符*](#try-operator)可选 [*前缀表达式*](#prefix-expression) @@ -238,9 +238,9 @@ func logFunctionName(string: String = __FUNCTION__) { print(string) } func myFunction() { - logFunctionName() // 打印 “myFunction()” + logFunctionName() } -myFunction() +myFunction() // 打印 “myFunction()” ``` 数组字面量是值的有序集合，形式如下： @@ -287,18 +287,17 @@ var emptyDictionary: [String : Double] = [:] ### self 表达式 -self表达式是对 当前type 或者当前instance的引用。它的形式如下： +`self` 表达式是对当前类型或者当前实例的显式引用，它有如下形式： > self -> self.`member name` -> self[`subscript index`] -> self(`initializer arguments`) -> self.init(`initializer arguments`) +> self.`成员名称` +> self[`下标索引`] +> self(`构造器参数`) +> self.init(`构造器参数`) -如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法（static method）, 类方法（class method）中， self等同于当前的type. +如果在构造器、下标、实例方法中，`self` 引用的是当前类型的实例。在一个类型方法中，`self` 引用的是当前的类型。 -当访问 member（成员变量时）， self 用来区分重名变量（例如函数的参数）. 例如， -（下面的 self.greeting 指的是 var greeting: String, 而不是 init（greeting: String） ） +当访问成员时，`self` 可用来区分重名变量，例如函数的参数： ```swift class SomeClass { @@ -309,7 +308,7 @@ class SomeClass { } ``` -在mutating 方法中， 你可以使用self 对 该instance进行赋值。 +在 `mutating` 方法中，你可以对 `self` 重新赋值： ```swift struct Point { @@ -328,48 +327,48 @@ struct Point { > *self 表达式* → **self** **.** **init** -### super 表达式 +### 超类表达式 -超类表达式可以使我们在某个class中访问它的超类. 它有如下形式： +超类表达式可以使我们在某个类中访问它的超类，它有如下形式： -> super.`member name` -> super[`subscript index`] -> super.init(`initializer arguments`) +> super.`成员名称` +> super[`下标索引`] +> super.init(`构造器参数`) -形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer. +第一种形式用来访问超类的某个成员，第二种形式用来访问超类的下标，第三种形式用来访问超类的构造器。 -子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。 +子类可以通过超类表达式在它们的成员、下标和构造器中使用超类中的实现。 -> super 表达式语法 +> 超类表达式语法 -> *super 表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression) +> *超类表达式* → [*超类方法表达式*](#superclass-method-expression) | [*超类下标表达式*](#superclass-subscript-expression) | [*超类构造器表达式*](#superclass-initializer-expression) -> *超类方法表达式* → **super** **.** [*标识符*](LexicalStructure.html#identifier) +> *超类方法表达式* → **super** **.** [*标识符*](02_Lexical_Structure.md#identifier) -> *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]** +> *超类下标表达式* → **super** **[** [*表达式*](#expression) **]** > *超类构造器表达式* → **super** **.** **init** ### 闭包表达式 -闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下： +闭包表达式会创建一个闭包，在其他语言中也叫匿名函数。跟函数一样，闭包包含了待执行的代码，不同的是闭包还会捕获所在环境中的常量和变量。它的形式如下： ```swift -{ (parameters) -> return type in - statements +{ (parameters) -> return type in + statements } ``` -闭包的参数声明形式跟方法中的声明一样, 请参见：[Function Declaration](TODO：添加链接). +闭包的参数声明形式跟函数一样，请参阅 [函数声明](05_Declarations.md#function_declaration)。 -闭包还有几种特殊的形式, 让使用更加简洁： +闭包还有几种特殊的形式，能让闭包使用起来更加简洁： -- 闭包可以省略 它的参数的type 和返回值的type. 如果省略了参数和参数类型，就也要省略 'in'关键字。 如果被省略的type 无法被编译器获知（inferred） ，那么就会抛出编译错误。 -- 闭包可以省略参数，转而在方法体（statement）中使用 $0, $1, $2 来引用出现的第一个，第二个，第三个参数。 -- 如果闭包中只包含了一个表达式，那么该表达式就会自动成为该闭包的返回值。 在执行 'type inference '时，该表达式也会返回。 +- 闭包可以省略它的参数和返回值的类型。如果省略了参数名和参数类型，也要省略 `in` 关键字。如果被省略的类型无法被编译器推断，那么就会导致编译错误。 +- 闭包可以省略参数名，参数会被隐式命名为 `$` 跟上其索引位置，例如 `$0`、`$1`、`$2` 分别表示第一个、第二个、第三个参数，以此类推。 +- 如果闭包中只包含一个表达式，那么该表达式的结果就会自动成为闭包的返回值。表达式结果的类型也会被推断为闭包的返回类型。 -下面几个 闭包表达式是 等价的： +下面几个闭包表达式是等价的： ```swift myFunction { @@ -387,58 +386,95 @@ myFunction { return $0 + $1 } myFunction { $0 + $1 } ``` -关于 向闭包中传递参数的内容，参见： [Function Call Expression](TODO：添加链接). +关于如何将闭包作为参数来传递的内容，请参阅 [函数调用表达式](#function_call_expression)。 #### 捕获列表 -闭包表达式可以通过一个参数列表（capture list） 来显式指定它需要的参数。 参数列表由中括号 [] 括起来，里面的参数由逗号','分隔。一旦使用了参数列表，就必须使用'in'关键字（在任何情况下都得这样做，包括忽略参数的名字，type, 返回值时等等）。 +默认情况下，闭包会通过强引用捕获所在环境中的常量和变量。你可以通过一个捕获列表来显式指定它的捕获行为。 -在闭包的参数列表（ capture list）中， 参数可以声明为 'weak' 或者 'unowned' . +捕获列表在参数列表之前，由中括号括起来，里面是由逗号分隔的一系列表达式。一旦使用了捕获列表，就必须使用 `in` 关键字，即使省略了参数名、参数类型、返回类型。 + +捕获列表中的条目会在闭包创建时被初始化。每一个条目都会被闭包所在环境中的同名常量或者变量初始化。例如下面的代码示例中，捕获列表包含 `a` 而不包含 `b`，这将导致这两个变量具有不同的行为。 ```swift -myFunction { print(self.title) } // strong capture -myFunction { [weak self] in print(self!.title) } // weak capture -myFunction { [unowned self] in print(self.title) } // unowned capture +var a = 0 +var b = 0 +let closure = { [a] in + print(a, b) +} + +a = 10 +b = 10 +closure() +// 打印 “0 10” ``` -在参数列表中，也可以使用任意表达式来赋值. 该表达式会在 闭包被执行时赋值，然后按照不同的力度来获取（这句话请慎重理解）。（captured with the specified strength. ） 例如： +在示例中，变量 `b` 只有一个，然而，变量 `a` 有两个，一个在闭包外，一个在闭包内。闭包内的变量 `a` 会在闭包创建时用闭包外的变量 `a` 的值来初始化，除此之外它们并无其他联系。这意味着在闭包创建后，改变某个 `a` 的值都不会对另一个 `a` 的值造成任何影响。与此相反，闭包内外都是同一个变量 `b`，因此在闭包外改变其值，闭包内的值也会受影响。 + +如果闭包捕获的值是引用语义，则又会有所不同。例如，下面示例中，有两个变量 `x`，一个在闭包外，一个在闭包内，由于它们的值是引用语义，虽然这是两个不同的变量，它们却都引用着同一实例。 ```swift -// Weak capture of "self.parent" as "parent" +class SimpleClass { + var value: Int = 0 +} +var x = SimpleClass() +var y = SimpleClass() +let closure = { [x] in + print(x.value, y.value) +} + +x.value = 10 +y.value = 10 +closure() +// 打印 “10 10” +``` + +如果捕获列表中的值是类类型，你可以使用 `weak` 或者 `unowned` 来修饰它，闭包会分别用弱引用和无主引用来捕获该值。 + +```swift +myFunction { print(self.title) } // 以强引用捕获 +myFunction { [weak self] in print(self!.title) } // 以弱引用捕获 +myFunction { [unowned self] in print(self.title) } // 以无主引用捕获 +``` + +在捕获列表中，也可以使用任意表达式来赋值。该表达式会在闭包被创建时进行求值，闭包会按照指定的引用类型来捕获表达式的值。例如： + +```swift +// 以弱引用捕获 self.parent 并赋值给 parent myFunction { [weak parent = self.parent] in print(parent!.title) } ``` -关于闭包表达式的更多信息和例子，请参见： [Closure Expressions](TODO：添加链接)，关于更多参数列表的信息和例子，请参见： [Resolving Strong Reference Cycles for Closures](TODO：添加链接)。 +关于闭包表达式的更多信息和例子，请参阅 [闭包表达式](../chapter2/07_Closures.md#closure_expressions)。关于捕获列表的更多信息和例子，请参阅 [解决闭包引起的循环强引用](../chapter2/16_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_for_closures)。 > 闭包表达式语法 -> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature)可选 [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}** +> *闭包表达式* → **{** [*闭包签名*](#closure-signature)可选 [*语句*](10_Statements.md#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** -> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) **in** +> *闭包签名* → [*参数子句*](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** -> *捕获列表* → **[** [*捕获说明符*](#capture-specifier) [*表达式*](#expression) **]** +> *捕获列表* → **[** [*捕获列表项列表*](#capture-list-items) **]** > *捕获列表项列表* → [*捕获列表项*](#capture-list-item) | [*捕获列表项*](#capture-list-item) **,** [*捕获列表项列表*](#capture-list-items) - + > *捕获列表项* → [*捕获说明符*](#capture-specifier)可选 [*表达式*](#expression) - + > *捕获说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** ### 隐式成员表达式 -在可以判断出类型（type）的上下文（context）中，隐式成员表达式是访问某个type的member（ 例如 class method, enumeration case） 的简洁方法。 它的形式是： +在可以判断出类型的上下文中，隐式成员表达式是访问某个类型的成员（例如某个枚举成员或某个类型方法）的简洁方法，形式如下： -> .`member name` +> .`成员名称` -例子： +例如： ```swift var x = MyEnumeration.SomeValue @@ -447,20 +483,20 @@ x = .AnotherValue > 隐式成员表达式语法 -> *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *隐式成员表达式* → **.** [*标识符*](02_Lexical_Structure.md#identifier) ### 圆括号表达式 -圆括号表达式由多个子表达式和逗号','组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下： +圆括号表达式由多个逗号分隔的子表达式组成。每个子表达式前面可以有一个标识符，用冒号隔开，其形式如下： ->（`identifier 1`: `expression 1`, `identifier 2`: `expression 2`, `...`） +> (`标识符 1` : `表达式 1`, `标识符 2` : `表达式 2`, `...`) -圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int） +使用圆括号表达式来创建元组，然后将其作为参数传递给函数。如果某个圆括号表达式中只有一个子表达式，那么它的类型就是子表达式的类型。例如，表达式 `(1)` 的类型是 `Int`，而不是 `(Int)`。 > 圆括号表达式语法 -> *圆括号表达式* → **(** [*表达式元素列表*](#expression-element-list)可选 **)** +> *圆括号表达式* → **(** [*表达式元素列表*](#expression-element-list)可选 **)** > *表达式元素列表* → [*表达式元素*](#expression-element) | [*表达式元素*](#expression-element) **,** [*表达式元素列表*](#expression-element-list) @@ -469,11 +505,11 @@ x = .AnotherValue ### 通配符表达式 -通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。） +通配符表达式用来忽略传递进来的某个参数。例如，下面的代码中，`10` 被传递给 `x`，`20` 被忽略： ```swift (x, _) = (10, 20) -// x is 10, 20 is ignored +// x 为 10，20 被忽略 ``` > 通配符表达式语法