From ca027e913214b152f026123ec108dbdd7fad916b Mon Sep 17 00:00:00 2001 From: Nemocdz Date: Sun, 29 Sep 2019 23:40:39 +0800 Subject: [PATCH 1/4] update swift 5.1 --- source/chapter2/23_Automatic_Reference_Counting.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/source/chapter2/23_Automatic_Reference_Counting.md b/source/chapter2/23_Automatic_Reference_Counting.md index 4200122d..e8b80cca 100755 --- a/source/chapter2/23_Automatic_Reference_Counting.md +++ b/source/chapter2/23_Automatic_Reference_Counting.md @@ -477,13 +477,14 @@ paragraph = nil ### 定义捕获列表 {#defining-a-capture-list} -捕获列表中的每一项都由一对元素组成，一个元素是 `weak` 或 `unowned` 关键字，另一个元素是类实例的引用（例如 `self`）或初始化过的变量（如 `delegate = self.delegate!`）。这些项在方括号中用逗号分开。 +捕获列表中的每一项都由一对元素组成，一个元素是 `weak` 或 `unowned` 关键字，另一个元素是类实例的引用（例如 `self`）或初始化过的变量（如 `delegate = self.delegate`）。这些项在方括号中用逗号分开。 如果闭包有参数列表和返回类型，把捕获列表放在它们前面： ```swift -lazy var someClosure: (Int, String) -> String = { - [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in +lazy var someClosure = { + [unowned self, weak delegate = self.delegate] + (index: Int, stringToProcess: String) -> String in // 这里是闭包的函数体 } ``` @@ -491,8 +492,8 @@ lazy var someClosure: (Int, String) -> String = { 如果闭包没有指明参数列表或者返回类型，它们会通过上下文推断，那么可以把捕获列表和关键字 `in` 放在闭包最开始的地方： ```swift -lazy var someClosure: () -> String = { - [unowned self, weak delegate = self.delegate!] in +lazy var someClosure = { + [unowned self, weak delegate = self.delegate] in // 这里是闭包的函数体 } ``` From 20f0cb7f816f588494089886b647d630c6e03763 Mon Sep 17 00:00:00 2001 From: Nemocdz Date: Mon, 30 Sep 2019 00:40:09 +0800 Subject: [PATCH 2/4] update post --- .../23_Automatic_Reference_Counting.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/source/chapter2/23_Automatic_Reference_Counting.md b/source/chapter2/23_Automatic_Reference_Counting.md index e8b80cca..5727e2c6 100755 --- a/source/chapter2/23_Automatic_Reference_Counting.md +++ b/source/chapter2/23_Automatic_Reference_Counting.md @@ -10,11 +10,11 @@ Swift 使用*自动引用计数（ARC）*机制来跟踪和管理你的应用程 ## 自动引用计数的工作机制 {#how-arc-works} -当你每次创建一个类的新的实例的时候，ARC 会分配一块内存来储存该实例信息。内存中会包含实例的类型信息，以及这个实例所有相关的存储型属性的值。 +每当你创建一个新的类实例时，ARC 会分配一块内存来储存该实例的信息。内存中会包含实例的类型信息，以及这个实例所关联的任何存储属性的值。 此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。 -然而，当 ARC 收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。 +然而，当 ARC 回收并释放了正在被使用中的实例后，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。 为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为 1，ARC 都不会销毁这个实例。 @@ -37,9 +37,9 @@ class Person { } ``` -`Person` 类有一个构造器，此构造器为实例的 `name` 属性赋值，并打印一条消息以表明初始化过程生效。`Person` 类也拥有一个析构器，这个析构器会在实例被销毁时打印一条消息。 +`Person` 类有一个构造器，此构造器给实例的 `name` 属性赋值，并打印一条消息以表明初始化过程生效。`Person` 类也拥有一个析构器，这个析构器会在实例被销毁时打印一条消息。 -接下来的代码片段定义了三个类型为 `Person?` 的变量，用来按照代码片段中的顺序，为新的 `Person` 实例建立多个引用。由于这些变量是被定义为可选类型（`Person?`，而不是 `Person`），它们的值会被自动初始化为 `nil`，目前还不会引用到 `Person` 类的实例。 +接下来的代码片段定义了三个类型为 `Person?` 的变量，按照代码片段中的顺序，为新的 `Person` 实例建立多个引用。由于这些变量是被定义为可选类型（`Person?`，而不是 `Person`），它们的值会被自动初始化为 `nil`，目前还不会引用到 `Person` 类的实例。 ```swift var reference1: Person? @@ -87,7 +87,7 @@ reference3 = nil 然而，我们可能会写出一个类实例的强引用数*永远不能*变成 `0` 的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的*循环强引用*。 -你可以通过定义类之间的关系为弱引用或无主引用，以替代强引用，从而解决循环强引用的问题。具体的过程在 [解决类实例之间的循环强引用](#resolving_strong_reference_cycles_between_class_instances) 中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。 +你可以通过定义类之间的关系为弱引用或无主引用，来替代强引用，从而解决循环强引用的问题。具体的过程在 [解决类实例之间的循环强引用](#resolving_strong_reference_cycles_between_class_instances) 中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。 下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：`Person` 和 `Apartment`，用来建模公寓和它其中的居民： @@ -111,9 +111,9 @@ class Apartment { 类似的，每个 `Apartment` 实例有一个叫 `unit`，类型为 `String` 的属性，并有一个可选的初始化为 `nil` 的 `tenant` 属性。`tenant` 属性是可选的，因为一栋公寓并不总是有居民。 -这两个类都定义了析构器，用以在类实例被析构的时候输出信息。这让你能够知晓 `Person` 和 `Apartment` 的实例是否像预期的那样被销毁。 +这两个类都定义了析构器，在类实例被析构的时候输出信息。这让你能够知晓 `Person` 和 `Apartment` 的实例是否像预期的那样被销毁。 -接下来的代码片段定义了两个可选类型的变量 `john` 和 `unit4A`，并分别被设定为下面的 `Apartment` 和 `Person` 的实例。这两个变量都被初始化为 `nil`，这正是可选类型的优点： +接下来的代码片段定义了两个可选类型的变量 `john` 和 `unit4A`，并分别被设为下面的 `Apartment` 和 `Person` 的实例。这两个变量都被初始化为 `nil`，这正是可选类型的优点： ```swift var john: Person? @@ -171,7 +171,7 @@ Swift 提供了两种办法用来解决你在使用类的属性时所遇到的 因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其弱引用赋值为 `nil`。并且因为弱引用需要在运行时允许被赋值为 `nil`，所以它们会被定义为可选类型变量，而不是常量。 -你可以像其他可选值一样，检查弱引用的值是否存在，你将永远不会访问已销毁的实例的引用。 +你可以像其他可选值一样，检查弱引用的值是否存在，这样可以避免访问已销毁的实例的引用。 > 注意 > @@ -363,7 +363,7 @@ class City { 由于 `capitalCity` 默认值为 `nil`，一旦 `Country` 的实例在构造器中给 `name` 属性赋值后，整个初始化过程就完成了。这意味着一旦 `name` 属性被赋值后，`Country` 的构造器就能引用并传递隐式的 `self`。`Country` 的构造器在赋值 `capitalCity` 时，就能将 `self` 作为参数传递给 `City` 的构造器。 -以上的意义在于你可以通过一条语句同时创建 `Country` 和 `City` 的实例，而不产生循环强引用，并且 `capitalCity` 的属性能被直接访问，而不需要通过感叹号来展开它的可选值： +上述的意义在于你可以通过一条语句同时创建 `Country` 和 `City` 的实例，而不产生循环强引用，并且 `capitalCity` 的属性能被直接访问，而不需要通过感叹号来展开它的可选值： ```swift var country = Country(name: "Canada", capitalName: "Ottawa") From d34aee47cd2efe78451a4c4bfaaccca4e59b62fa Mon Sep 17 00:00:00 2001 From: Nemocdz Date: Tue, 1 Oct 2019 18:14:33 +0800 Subject: [PATCH 3/4] update swift 5.1 --- source/chapter3/03_Types.md | 63 +++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 35 deletions(-) diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md index 3e71ef8a..708d3628 100644 --- a/source/chapter3/03_Types.md +++ b/source/chapter3/03_Types.md @@ -41,14 +41,14 @@ Swift 语言存在两种类型：命名型类型和复合型类型。*命名型 > *类型* → **（** [类型](#type) **）** ## 类型注解 {#type-annotation-h} -*类型注解*显式地指定一个变量或表达式的类型。类型注解始于冒号 `:` 终于类型，比如下面两个例子： +*类型注解*显式地指定一个变量或表达式的类型。类型注解从冒号 （`:`）开始， 以类型结尾，比如下面两个例子： ```swift let someTuple: (Double, Double) = (3.14159, 2.71828) func someFunction(a: Int) { /* ... */ } ``` -在第一个例子中，表达式 `someTuple` 的类型被指定为 `(Double, Double)`。在第二个例子中，函数 `someFunction` 的参数 `a` 的类型被指定为 `Int`。 +在第一个例子中，表达式 `someTuple` 的类型被指定为 `(Double, Double)`。在第二个例子中，函数 `someFunction` 的形参 `a` 的类型被指定为 `Int`。 类型注解可以在类型之前包含一个类型特性的可选列表。 @@ -59,7 +59,7 @@ func someFunction(a: Int) { /* ... */ } > *类型注解* → **:** [*特性列表*](./07_Attributes.md#attributes)可选 **输入输出参数**可选 [*类型*](#type) ## 类型标识符 {#type-identifier-h} -*类型标识符*引用命名型类型，还可引用命名型或复合型类型的别名。 +*类型标识符*可以引用命名型类型，还可引用命名型或复合型类型的别名。 大多数情况下，类型标识符引用的是与之同名的命名型类型。例如类型标识符 `Int` 引用命名型类型 `Int`，同样，类型标识符 `Dictionary` 引用命名型类型 `Dictionary`。 @@ -80,8 +80,7 @@ var someValue: ExampleModule.MyType > #### type-identifier {#type-identifier} -> *类型标识符* → [*类型名称*](#type-name) [*泛型参数子句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause)可选 | [*类型名称*](#type-name) [*泛型参数子句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause)可选 **.** [*类型标识符*](#type-identifier) -> +> *类型标识符* → [*类型名称*](#type-name) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause)可选 | [*类型名称*](#type-name) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause)可选 **.** [*类型标识符*](#type-identifier) #### type-name {#type-name} > *类型名称* → [*标识符*](./02_Lexical_Structure.md#identifier) @@ -122,21 +121,21 @@ someTuple = (left: 5, right: 5) // 错误：命名类型不匹配 > ## 函数类型 {#function-type-h} -*函数类型*表示一个函数、方法或闭包的类型，它由参数类型和返回值类型组成，中间用箭头（`->`）隔开： +*函数类型*表示一个函数、方法或闭包的类型，它由形参类型和返回值类型组成，中间用箭头（`->`）隔开： -> （`参数类型`）->（`返回值类型`） +> （`形参类型`）->（`返回值类型`） -*参数类型*是由逗号间隔的类型列表。由于*返回值类型*可以是元组类型，所以函数类型支持多返回值的函数与方法。 +*形参类型*是由逗号间隔的类型列表。由于*返回值类型*可以是元组类型，所以函数类型支持多返回值的函数与方法。 -你可以对参数类型为 `() -> T`（其中 T 是任何类型）的函数使用 `autoclosure` 特性。这会自动将参数表达式转化为闭包，表达式的结果即闭包返回值。这从语法结构上提供了一种便捷：延迟对表达式的求值，直到其值在函数体中被调用。以自动闭包做为参数的函数类型的例子详见 [自动闭包](../chapter2/07_Closures.md#autoclosures)。 +你可以对形参类型为 `() -> T`（其中 T 是任何类型）的函数使用 `autoclosure` 特性，这会在调用侧隐式创建一个闭包。这从语法结构上提供了一种便捷：延迟对表达式的求值，直到其值在函数体中被调用。以自动闭包做为形参的函数类型的例子详见 [自动闭包](../chapter2/07_Closures.md#autoclosures)。 -函数类型可以拥有一个可变长参数作为*参数类型*中的最后一个参数。从语法角度上讲，可变长参数由一个基础类型名字紧随三个点（`...`）组成，如 `Int...`。可变长参数被认为是一个包含了基础类型元素的数组。即 `Int...` 就是 `[Int]`。关于使用可变长参数的例子，请参阅 [可变参数](../chapter2/06_Functions.md#variadic_parameters)。 +函数类型可以拥有一个可变参数在*形参类型*中。从语法角度上讲，可变参数由一个基础类型名字紧随三个点（`...`）组成，如 `Int...`。可变参数被认为是一个包含了基础类型元素的数组。即 `Int...` 就是 `[Int]`。关于使用可变参数的例子，请参阅 [可变参数](../chapter2/06_Functions.md#variadic-parameters)。 -为了指定一个 `in-out` 参数，可以在参数类型前加 `inout` 前缀。但是你不可以对可变长参数或返回值类型使用 `inout`。关于这种参数的详细讲解请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 +为了指定一个 `in-out` 参数，可以在形参类型前加 `inout` 前缀。但是你不可以对可变参数或返回值类型使用 `inout`。关于这种形参的详细讲解请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 -如果一个函数类型只有一个形式参数而且形式参数的类型是元组类型，那么元组类型在写函数类型的时候必须用圆括号括起来。比如说，`((Int, Int)) -> Void` 是接收一个元组 `(Int, Int)` 作为形式参数并且不返回任何值的函数类型。与此相对，不加括号的 `(Int, Int) -> Void` 是一个接收两个 `Int` 作为形式参数并且不返回任何值的函数类型。相似地，因为 `Void` 是空元组类型 `()` 的别名，函数类型 `(Void)-> Void` 与 `(()) -> ()` 是一样的 - 一个将空元组作为唯一参数的函数。但这些类型和无变量的函数类型 `() -> ()` 是不一样的。 +如果函数类型只有一个类型是元组类型的一个形参，那么元组类型在写函数类型的时候必须用圆括号括起来。比如说，`((Int, Int)) -> Void` 是接收一个元组 `(Int, Int)` 作为形参并且不返回任何值的函数类型。与此相对，不加括号的 `(Int, Int) -> Void` 是一个接收两个 `Int` 作为形参并且不返回任何值的函数类型。相似地，因为 `Void` 是空元组类型 `()` 的别名，函数类型 `(Void)-> Void` 与 `(()) -> ()` 是一样的 - 一个将空元组作为唯一实参的函数。但这些类型和 `() -> ()` 是不一样的 - 一个无实参的函数。 -函数和方法中的变量名并不是函数类型的一部分。例如： +函数和方法中的实参名并不是函数类型的一部分。例如： ```swift func someFunction(left: Int, right: Int) {} @@ -155,7 +154,7 @@ func functionWithDifferentNumberOfArguments(left: Int, right: Int, top: Int) {} f = functionWithDifferentNumberOfArguments // 错误 ``` -由于变量标签不是函数类型的一部分，你可以在写函数类型的时候省略它们。 +由于实参标签不是函数类型的一部分，你可以在写函数类型的时候省略它们。 ```swift var operation: (lhs: Int, rhs: Int) -> Int // 错误 @@ -163,14 +162,14 @@ var operation: (_ lhs: Int, _ rhs: Int) -> Int // 正确 var operation: (Int, Int) -> Int // 正确 ``` -如果一个函数类型包涵多个箭头（->），那么函数类型将从右向左进行组合。例如，函数类型 `(Int) -> (Int) -> Int` 可以理解为 `(Int) -> ((Int) -> Int)`，也就是说，该函数类型的参数为 `Int` 类型，其返回类型是一个参数类型为 `Int`，返回类型为 `Int` 的函数。 +如果一个函数类型包涵多个箭头（->），那么函数类型将从右向左进行组合。例如，函数类型 `(Int) -> (Int) -> Int` 可以理解为 `(Int) -> ((Int) -> Int)`，也就是说，该函数传入 `Int`，并返回另一个传入并返回 `Int` 的函数。 -函数类型若要抛出错误就必须使用 `throws` 关键字来标记，若要重抛错误则必须使用 `rethrows` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](./06_Declarations.md#throwing_functions_and_methods) 和 [重抛函数与方法](./06_Declarations.md#rethrowing_functions_and_methods)。 +函数类型若要抛出或重抛错误就必须使用 `throws` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数的子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](./06_Declarations.md#throwing_functions_and_methods) 和 [重抛函数与方法](./06_Declarations.md#rethrowing_functions_and_methods)。 ### 对非逃逸闭包的限制 {#Restrictions for Nonescaping Closures} -当非逃逸闭包函数是参数时，不能存储在属性、变量或任何 `Any` 类型的常量中，因为这可能导致值的逃逸。 +当非逃逸闭包函数是形参时，不能存储在属性、变量或任何 `Any` 类型的常量中，因为这可能导致值的逃逸。 -当非逃逸闭包函数是参数时，不能作为参数传递到另一个非逃逸闭包函数中。这样的限制可以让 Swift 在编译时就完成更多的内存访问冲突检查，而不是在运行时。举个例子： +当非逃逸闭包函数是形参时，不能作为实参传递到另一个非逃逸闭包函数中。这样的限制可以让 Swift 在编译时就完成更好的内存访问冲突检查，而不是在运行时。举个例子： ```swift let external: (Any) -> Void = { _ in () } @@ -186,37 +185,31 @@ func takesTwoFunctions(first: (Any) -> Void, second: (Any) -> Void) { } ``` -在上面代码里，`takesTwoFunctions(first:second:)` 的两个参数都是函数。它们都没有标记为 `@escaping`, 因此它们都是非逃逸的。 +在上面代码里，`takesTwoFunctions(first:second:)` 的两个形参都是函数。它们都没有标记为 `@escaping`, 因此它们都是非逃逸的。 -上述例子里的被标记为“错误”的四个函数调用会产生编译错误。因为参数 `first` 和 `second` 是非逃逸函数，它们不能够作为参数被传递到另一个非闭包函数。相对的, 标记“正确”的两个函数不会产生编译错误。这些函数调用不会违反限制，因为 `external` 不是 `takesTwoFunctions(first:second:)` 的参数之一。 +上述例子里的被标记为“错误”的四个函数调用会产生编译错误。因为形参 `first` 和 `second` 是非逃逸函数，它们不能够作为实参被传递到另一个非闭包函数。相对的, 标记“正确”的两个函数不会产生编译错误。这些函数调用不会违反限制，因为 `external` 不是 `takesTwoFunctions(first:second:)` 的形参之一。 -如果你需要避免这个限制，标记其中之一的参数为逃逸，或者使用 `withoutActuallyEscaping(_:do:)` 函数临时地转换非逃逸函数的其中一个参数为逃逸函数。关于避免内存访问冲突，可以参阅 [内存安全](../chapter2/24_Memory_Safety.md)。 +如果你需要避免这个限制，标记其中一个形参为逃逸，或者使用 `withoutActuallyEscaping(_:do:)` 函数临时转换其中一个非逃逸函数形参为逃逸函数。关于避免内存访问冲突，可以参阅 [内存安全](../chapter2/24_Memory_Safety.md)。 > 函数类型语法 > #### function-type {#function-type} > *函数类型* → [*特性列表*](./07_Attributes.md#attributes)可选 [*函数类型子句*](#function-type-argument-clause) **throws**可选 **->** [*类型*](#type) -> -> *函数类型* → [*特性列表*](./07_Attributes.md#attributes)可选 [*函数类型子句*](#function-type-argument-clause) **rethrows­** **->** [*类型*](#type) -> #### function-type-argument-clause {#function-type-argument-clause} > *函数类型子句* → **(**­ **)**­ -> *函数类型子句* → **(** [*函数类型参数列表*](#function-type-argument-list) *...*­ 可选 **)** -> +> *函数类型子句* → **(** [*函数类型实参列表*](#function-type-argument-list) *...*­ 可选 **)** #### function-type-argument-list {#function-type-argument-list} -> *函数类型参数列表* → [*函数类型参数*](function-type-argument) | [*函数类型参数*](function-type-argument)， [*函数类型参数列表*](#function-type-argument-list) -> +> *函数类型实参列表* → [*函数类型实参*](function-type-argument) | [*函数类型实参*](function-type-argument)， [*函数类型实参列表*](#function-type-argument-list) #### function-type-argument {#function-type-argument} -> *函数类型参数* → [*特性列表*](./07_Attributes.md#attributes)可选 **输入输出参数**可选 [*类型*](#type) | [*参数标签*](#argument-label) [*类型注解*](#type-annotation) -> + +> *函数类型实参* → [*特性列表*](./07_Attributes.md#attributes)可选 **输入输出参数**可选 [*类型*](#type) | [*实参标签*](#argument-label) [*类型注解*](#type-annotation) #### argument-label {#argument-label} -> *参数标签* → [*标识符*](./02_Lexical_Structure.md#identifier) -> +> *形参标签* → [*标识符*](./02_Lexical_Structure.md#identifier) ## 数组类型 {#array-type-h} Swift 语言为标准库中定义的 `Array` 类型提供了如下语法糖： @@ -299,7 +292,7 @@ optionalInteger! // 42 使用 `!` 运算符解包值为 `nil` 的可选值会导致运行错误。 -你也可以使用可选链式调用和可选绑定来选择性地在可选表达式上执行操作。如果值为 `nil`，不会执行任何操作，因此也就没有运行错误产生。 +你也可以使用可选链式调用和可选绑定来选择性在可选表达式上执行操作。如果值为 `nil`，不会执行任何操作，因此也就没有运行错误产生。 更多细节以及更多如何使用可选类型的例子，请参阅 [可选类型](../chapter2/01_The_Basics.md#optionals)。 @@ -346,7 +339,7 @@ let implicitlyUnwrappedArray: [Int]! // 正确 > ## 协议合成类型 {#protocol-composition-type-h} -*协议合成类型*定义了一种遵循协议列表中每个指定协议的类型，或者一个现有类型的子类并遵循协议列表中每个指定协议。协议合成类型只能用在类型注解、泛型参数子句和泛型 `where` 子句中指定类型。 +*协议合成类型*定义了一种遵循协议列表中每个指定协议的类型，或者一个现有类型的子类并遵循协议列表中每个指定协议。协议合成类型只能用在类型注解、泛型形参子句和泛型 `where` 子句中指定类型。 协议合成类型的形式如下： @@ -393,7 +386,7 @@ typealias PQR = PQ & Q & R 协议声明里不能包括不透明类型。类不能使用不透明类型作为非 final 方法的返回值。 -使用不透明类型作为返回值的函数必须返回单一公用底层类型。返回的类型可以包含函数范型类型参数的一部分。举个例子，函数 `someFunction()` 可以返回类型 `T` 或者 `Dictionary` 的值。 +使用不透明类型作为返回值的函数必须返回单一公用底层类型。返回的类型可以包含函数范型类型形参的一部分。举个例子，函数 `someFunction()` 可以返回类型 `T` 或者 `Dictionary` 的值。 > 不透明类型语法 From e5e81b81d1cb27c4bc6aebf7a28387400c2a58ee Mon Sep 17 00:00:00 2001 From: Nemocdz Date: Mon, 4 Nov 2019 12:30:07 +0800 Subject: [PATCH 4/4] update Swift 5.1 --- source/03_language_reference/02_Lexical_Structure.md | 4 ++-- .../03_language_reference/10_Summary_of_the_Grammar.md | 9 +++++++++ 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/source/03_language_reference/02_Lexical_Structure.md b/source/03_language_reference/02_Lexical_Structure.md index 5a1a6997..34c1e583 100755 --- a/source/03_language_reference/02_Lexical_Structure.md +++ b/source/03_language_reference/02_Lexical_Structure.md @@ -74,7 +74,7 @@ Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言 闭包中如果没有明确指定参数名称，参数将被隐式命名为 `$0`、`$1`、`$2` 等等。这些命名在闭包作用域范围内是合法的标识符。 -编译器给含有属性包装器映射的属性自动合成以美元符号（*$*）开头的标识符。你的代码可以与这些标识符进行交互，，但是不能使用该前缀声明标识符。更详细的介绍，请查看 [特性](./07_Attributes.md) 章节中的 [属性包装器](./07_Attributes.md#propertywrapper) 部分。 +编译器给含有属性包装器呈现值的属性自动合成以美元符号（*$*）开头的标识符。你的代码可以与这些标识符进行交互，，但是不能使用该前缀声明标识符。更详细的介绍，请查看 [特性](./07_Attributes.md) 章节中的 [属性包装器](./07_Attributes.md#propertywrapper) 部分。 > 标识符语法 > @@ -141,7 +141,7 @@ Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言 > #### property-wrapper-projection {#property-wrapper-projection} > -> *属性包装器映射* → **$** [标识符字符组](#identifier-characters) +> *属性包装器呈现值* → **$** [标识符字符组](#identifier-characters) > ## 关键字和标点符号 {#keywords-and-punctuation} diff --git a/source/03_language_reference/10_Summary_of_the_Grammar.md b/source/03_language_reference/10_Summary_of_the_Grammar.md index 76b4f652..c4dbe9d9 100755 --- a/source/03_language_reference/10_Summary_of_the_Grammar.md +++ b/source/03_language_reference/10_Summary_of_the_Grammar.md @@ -22,6 +22,8 @@ > > *换行符* → U+000D 后面是 U+000A > +> +> > *注释* → **//** [单行内容注释](./02_Lexical_Structure.md#comment-text) [换行符](./02-Lexical-Structure.md#line-break) > > *注释* → **/\*** [多行内容注释](./02_Lexical_Structure.md#multiline-comment-text) **\*/** @@ -53,6 +55,8 @@ > > *标识符* → [隐式参数名](./02_Lexical_Structure.md#implicit-parameter-name) > +> *标识符* → [属性包装器呈现值](./02_Lexical_Structure.md#property-wrapper-projection) +> > *标识符集* → [标识符](./02_Lexical_Structure.md#identifier) | [标识符](./02-Lexical-Structure.md#identifier) **,** [标识符集](./02-Lexical-Structure.md#identifier-list) > > *标识符头（Head）* → 大写或者小写字母 A 到 Z @@ -97,6 +101,8 @@ > > *隐式参数名* → **$** [十进制数字集](./02_Lexical_Structure.md#decimal-digits) > +> *属性包装器呈现值* → **$** [标识符字符集](./02-Lexical-Structure.md#identifier-characters) +> @@ -1660,6 +1666,9 @@ > > *同类型约束* → [类型标识](./03_Types.md#type-identifier) **==** [类型](./03-Types.md#type-identifier) > + + + > 泛型实参子句语法 > > *泛型实参子句* → **<** [泛型实参集](./09_Generic_Parameters_and_Arguments.md#generic-argument-list) **>**