From 2d10a8d6ec550b1e350184230d9d17a9d41c109b Mon Sep 17 00:00:00 2001 From: DanziChen Date: Mon, 15 Jul 2019 11:57:21 +0800 Subject: [PATCH 01/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=BF=BB=E8=AF=91=20(#?= =?UTF-8?q?964)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter1/04_revision_history.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/source/chapter1/04_revision_history.md b/source/chapter1/04_revision_history.md index 230873f4..dfa173fb 100644 --- a/source/chapter1/04_revision_history.md +++ b/source/chapter1/04_revision_history.md @@ -71,7 +71,7 @@ * 更新至 Swift 3.0.1。 * 更新 [自动引用计数](../chapter2/23_Automatic_Reference_Counting.md) 章节中有关 weak 和 unowned 引用的讨论。 * 在 [声明标识符](../chapter3/06_Declarations.md#declaration-modifiers) 章节中新增了有关新的标识符 `unowned`，`unowend(safe)` 和 `unowned(unsafe)` 的内容。 -* 在 [Any 和 AnyObject 的类型转换](../chapter2/18_Type_Casting.md#type-casting-for-any-and-anyobject) 章节中新增了一条提示，有关使用类型 `Any` 作为可选值。 +* 在 [Any 和 AnyObject 的类型转换](../chapter2/18_Type_Casting.md#type-casting-for-any-and-anyobject) 章节中新增了一处说明，有关使用类型 `Any` 作为可选值。 * 更新 [表达式](../chapter3/04_Expressions.md) 章节，把括号表达式和元组表达式的描述分开。 ### 2016-09-13 @@ -120,8 +120,8 @@ * 在 [关键字和标点符号](../chapter3/02_Lexical_Structure.md#keywords-and-punctuation) 章节中新增了使用关键字作为外部参数名的内容。 * 更新 [声明特性](../chapter3/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@objc` 特性的讨论，并指出枚举和枚举用例。 * 更新 [操作符](../chapter3/02_Lexical_Structure.md#operator) 章节中对于自定义运算符的包含了 `.` 的讨论。 -* 在 [重新抛出错误的函数和方法](../chapter3/06_Declarations.md#rethrowing-functions-and-methods) 章节中新增了一条提示，重新抛出错误函数不能直接抛出错误。 -* 在 [属性观察器](../chapter2/10_Properties.md#property-observers) 章节中新增了一条提示，当作为 in-out 参数传递属性时，属性观察器的调用行为。 +* 在 [重新抛出错误的函数和方法](../chapter3/06_Declarations.md#rethrowing-functions-and-methods) 章节中新增了一处说明，重新抛出错误函数不能直接抛出错误。 +* 在 [属性观察器](../chapter2/10_Properties.md#property-observers) 章节中新增了一处说明，当作为 in-out 参数传递属性时，属性观察器的调用行为。 * 在 [Swift 初见](./03_a_swift_tour.md) 篇章中新增了错误处理的章节。 * 更新 [弱引用](../chapter2/23_Automatic_Reference_Counting.md#weak-references) 章节中的图片用以更清楚的展示重新分配过程。 * 删除 C 语言风格的 `for` 循环，`++` 前缀和后缀运算符，以及 `--` 前缀和后缀运算符。 @@ -161,22 +161,22 @@ * 在 [可选绑定](../chapter2/01_TheBasics.md#optional-binding) 章节中新增了有关使用 `where` 子句进行多可选绑定的相关内容。 * 在 [字符串字面量](../chapter3/02_Lexical_Structure.md#string-literal) 章节中新增了有关在编译时使用 `+` 运算符拼接字符串字面量的相关内容。 * 在 [元类型](../chapter3/03_Types.md#metatype-type-h) 章节中新增了有关元类型值的比较和使用它们通过构造器表达式构造实例相关内容。 -* 在 [断言调试](../chapter2/01_TheBasics.md#debugging-with-assertions) 章节中新增了一条提示，有关用户定义断言何时会失效。 +* 在 [断言调试](../chapter2/01_TheBasics.md#debugging-with-assertions) 章节中新增了一处说明，有关用户定义断言何时会失效。 * 更新 [声明特性](../chapter3/07_Attributes.md#Ideclaration-attributes) 章节中对 `@NSManaged` 特性的讨论，现在这个特性可以被应用到一个确定实例方法。 * 更新 [可变参数](../chapter2/06_Functions.md#variadic-parameters) 章节，现在可变参数可以声明在函数参数列表的任意位置中。 * 在 [重写可失败构造器](../chapter2/14_Initialization.md#overriding-a-failable-initializer) 章节中新增了有关非可失败构造器相当于一个可失败构造器通过父类构造器的结果进行强制拆包的相关内容。 * 在 [任意类型用例的枚举](../chapter3/06_Declarations.md#enumerations-with-cases-of-any-type) 章节中新增了有关枚举用例作为函数的内容。 * 在 [构造器表达式](../chapter3/04_Expressions.md#initializer-expression) 章节中新增了有关显式引用一个构造器相关内容。 * 在 [编译控制语句](../chapter3/05_Statements.md#compiler-control-statements) 章节中新增了有关编译内容以及行控制语句相关内容。 -* 在 [元类型](../chapter3/03_Types.md#metatype-type-h) 章节新增了一条提示，有关如何从元类型值中构造类实例相关内容。 -* 在 [弱引用](../chapter2/23_Automatic_Reference_Counting.md#weak-references) 章节新增了一条提示，有关弱引用作为缓存所存在的不足。 +* 在 [元类型](../chapter3/03_Types.md#metatype-type-h) 章节新增了一处说明，有关如何从元类型值中构造类实例相关内容。 +* 在 [弱引用](../chapter2/23_Automatic_Reference_Counting.md#weak-references) 章节新增了一处说明，有关弱引用作为缓存所存在的不足。 * 更新 [类型特性](../chapter2/10_Properties.md#type-properties) 章节，提到了存储型特性其实是懒加载。 * 更新 [捕获类型](../chapter2/07_Closures.md#capturing_values) 章节，阐明了变量和常量在闭包中如何被捕获。 * 更新 [声明特性](../chapter3/07_Attributes.md#Ideclaration-attributes) 章节，用以描述何时在类中使用 `@objc` 关键字。 -* 在 [错误处理](../chapter2/17_Error_Handling.md#handling-errors) 章节中新增了一条提示，有关执行 `throw` 语句的性能。在 [Do 语句](../chapter3/05_Statements.md#do-statement) 章节的 do 语句部分也新增了类似内容。 +* 在 [错误处理](../chapter2/17_Error_Handling.md#handling-errors) 章节中新增了一处说明，有关执行 `throw` 语句的性能。在 [Do 语句](../chapter3/05_Statements.md#do-statement) 章节的 do 语句部分也新增了类似内容。 * 更新 [类型特性](../chapter2/10_Properties.md#type-properties) 章节中有关类、结构体和枚举的存储型和计算型特性相关的内容。 * 更新 [Break 语句](../chapter3/05_Statements.md#break_statement) 章节中有关带标签的 break 语句相关内容。 -* 在 [属性观察器](../chapter2/10_Properties.md#property-observers) 章节更新了一处提示，用来明确 `willSet` 和 `didSet` 观察器的行为。 +* 在 [属性观察器](../chapter2/10_Properties.md#property-observers) 章节更新了一处说明，用来明确 `willSet` 和 `didSet` 观察器的行为。 * 在 [访问级别](../chapter2/25_Access_Control.md#access-levels) 章节新增了有关 `private` 作用域的相关内容说明。 * 在 [弱引用](../chapter2/23_Automatic_Reference_Counting.md#weak-references) 章节新增了有关弱应用在垃圾回收系统和 ARC 之间的区别的说明。 * 更新 [字符串字面量中特殊字符](../chapter2/03_Strings_And_Characters.md#special-characters-in-string-literals) 章节，对 Unicode 标量更精确定义。 @@ -230,13 +230,13 @@ * 现在，你可以通过下标赋值或者 [可选调用链](../chapter2/16_Optional_Chaining.md) 中的可变方法和操作符来给属性设值。相应地更新了有关 [通过可选链接访问属性](../chapter2/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 的内容，并扩展了 [通过可选链接调用方法](../chapter2/16_Optional_Chaining.md#calling-methods-through-optional-chaining) 时检查方法调用成功的示例，以显示如何检查属性设置是否成功。 * 在可选链中新增了 [访问可选类型的下标脚注](../chapter2/16_Optional_Chaining.md#accessing-subscripts-through-optional-chaining) 章节。 * 更新 [访问和修改数组](../chapter2/CollectionTypes.md#accessing-and-modifying-a-dictionary) 章节以标示，从该版本起，不能再通过 `+=` 运算符给一个数组新增一个新的项。对应的替代方案是，使 `append` 方法，或者通过 `+=` 运算符来新增一个只有一个项的数组。 -* 新增一条提示，在 [范围运算符](../chapter2/BasicOperators.md#range-operators) 中，比如， `a..b` 和 `a.. Date: Mon, 15 Jul 2019 17:50:12 +0800 Subject: [PATCH 02/36] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=BF=BB=E8=AF=91?= =?UTF-8?q?=E9=94=99=E8=AF=AF=20(#965)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 修正翻译错误 * Update 14_Initialization.md --- source/chapter2/14_Initialization.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md index a0fc0df4..25d1411d 100755 --- a/source/chapter2/14_Initialization.md +++ b/source/chapter2/14_Initialization.md @@ -535,7 +535,7 @@ print("Bicycle: \(bicycle.description)") // 打印“Bicycle: 2 wheel(s)” ``` -如果子类的构造器没有在阶段 2 过程中做自定义操作，并且父类有一个无参数的自定义构造器。你可以在所有父类的存储属性赋值之后省略 `super.init()` 的调用。 +如果子类的构造器没有在阶段 2 过程中做自定义操作，并且父类有一个无参数的指定构造器，你可以在所有子类的存储属性赋值之后省略 `super.init()` 的调用。 这个例子定义了另一个 `Vehicle` 的子类 `Hoverboard` ，只设置它的 `color` 属性。这个构造器依赖隐式调用父类的构造器来完成，而不是显示调用 `super.init()`。 From 15ee26ca6d9767e243739e2d6bf88d8f24efcc3f Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Mon, 15 Jul 2019 05:23:45 -0500 Subject: [PATCH 03/36] Update 04_revision_history.md --- source/chapter1/04_revision_history.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter1/04_revision_history.md b/source/chapter1/04_revision_history.md index dfa173fb..591b2308 100644 --- a/source/chapter1/04_revision_history.md +++ b/source/chapter1/04_revision_history.md @@ -34,7 +34,7 @@ * 更新至 Swift 4.1。 * 在 [等价运算符](../chapter2/26_Advanced_Operators.md#equivalence-operators) 章节新增了有关等价运算符的合成实现的内容。 * 在 [声明](../chapter3/06_Declarations.md) 篇章中 [申明拓展](../chapter3/06_Declarations.md#extension-declaration) 章节和 [协议](../chapter2/21_Protocols.md) 篇章中 [有条件地遵循协议](../chapter2/21_Protocols.md#Conditionally-Conforming-to-a-Protocol) 章节新增了有关协议有条件遵循的内容。 -* 在 [关联类型约束中使用协议](../chapter2/22_Generics.md#using-a-protocol-in-its-associated-type's-constraints) 章节中新增了有关递归协议约束的内容。 +* 在 [关联类型约束中使用协议](../chapter2/22_Generics.md#using-a-protocol-in-its-associated-types-constraints) 章节中新增了有关递归协议约束的内容。 * 在 [条件编译块](../chapter3/05_Statements.md#Conditional-Compilation-Block) 章节中新增了有关 `canImport()` 和 `targetEnvironment()` 平台条件的内容。 ### 2017-12-04 From ed7eb9e045479b2faed859d9bf8b54bafbbddbc8 Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Mon, 15 Jul 2019 05:24:12 -0500 Subject: [PATCH 04/36] Update 22_Generics.md --- source/chapter2/22_Generics.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter2/22_Generics.md b/source/chapter2/22_Generics.md index 2650fef3..3035fce8 100644 --- a/source/chapter2/22_Generics.md +++ b/source/chapter2/22_Generics.md @@ -435,7 +435,7 @@ protocol Container { 要遵守 `Container` 协议，`Item` 类型也必须遵守 `Equatable` 协议。 -### 在关联类型约束里使用协议 {#using-a-protocol-in-its-associated-type’s-constraints} +### 在关联类型约束里使用协议 {#using-a-protocol-in-its-associated-types-constraints} 协议可以作为它自身的要求出现。例如，有一个协议细化了 `Container` 协议，添加了一个` suffix(_:)` 方法。`suffix(_:)` 方法返回容器中从后往前给定数量的元素，并把它们存储在一个 `Suffix` 类型的实例里。 From b95202eb6d10227272369bd9c6abd7ca142cae5e Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Mon, 15 Jul 2019 06:30:00 -0500 Subject: [PATCH 05/36] Update 03_Strings_and_Characters.md (#967) --- source/chapter2/03_Strings_and_Characters.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md index 22102fa4..c52b5aa8 100755 --- a/source/chapter2/03_Strings_and_Characters.md +++ b/source/chapter2/03_Strings_and_Characters.md @@ -106,11 +106,11 @@ Escaping all three quotes \"\"\" ### 扩展字符串分隔符 {#extended-string-delimiters} -您可以将字符串文字放在扩展分隔符中，这样字符串中的特殊字符将会被直接包含而非转义后的效果。将字符串放在引号（**"**）中并用数字符号（**＃**）括起来。例如，打印字符串文字 **＃"Line 1 \ nLine 2"＃** 打印换行符转义序列（**\n**）而不是进行换行打印。 +您可以将字符串文字放在扩展分隔符中，这样字符串中的特殊字符将会被直接包含而非转义后的效果。将字符串放在引号（`"`）中并用数字符号（`＃`）括起来。例如，打印字符串文字 `＃"Line 1 \nLine 2"＃` 会打印换行符转义序列（`\n`）而不是给文字换行。 -如果需要字符串文字中字符的特殊效果，请匹配转义字符（**\\**）后面添加与起始位置个数相匹配的 **#** 符。 例如，如果您的字符串是 **＃"Line 1 \ nLine 2"＃** 并且您想要换行，则可以使用 **＃“Line 1 \ #nLine 2”＃** 来代替。 同样，**###"Line1 \ ### nLine2"###** 也可以实现换行效果。 +如果需要字符串文字中字符的特殊效果，请匹配转义字符（`\`）后面添加与起始位置个数相匹配的 `#` 符。 例如，如果您的字符串是 `＃"Line 1 \nLine 2"＃` 并且您想要换行，则可以使用 `＃“Line 1 \#nLine 2”＃` 来代替。 同样，`###"Line1 \###nLine2"###` 也可以实现换行效果。 -扩展分隔符创建的字符串文字也可以是多行字符串文字。 您可以使用扩展分隔符在多行字符串中包含文本 **"""**，覆盖原有的结束文字的默认行为。例如： +扩展分隔符创建的字符串文字也可以是多行字符串文字。 您可以使用扩展分隔符在多行字符串中包含文本 `"""`，覆盖原有的结束文字的默认行为。例如： ```swift let threeMoreDoubleQuotationMarks = #""" From 3d64a8e5e639c6834b11ee3cbaa027fb5f81fc47 Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Mon, 15 Jul 2019 06:35:00 -0500 Subject: [PATCH 06/36] trigger gitbook building --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 612891b9..69f8a73a 100755 --- a/README.md +++ b/README.md @@ -17,6 +17,7 @@ - 更新到 Swift 4.1，2018-04-12，感谢 [@Mylittleswift](https://github.com/Mylittleswift) - 更新到 Swift 3.0，2016-09-23 + # 贡献力量 如果想做出贡献的话，你可以： From 546db6bc4775094e8e27caa332584c516b3dcfb2 Mon Sep 17 00:00:00 2001 From: xuezhulian <43400789+xuezhulian@users.noreply.github.com> Date: Thu, 18 Jul 2019 13:49:10 +0800 Subject: [PATCH 07/36] Update 05_Control_Flow.md swith -> switch --- source/chapter2/05_Control_Flow.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md index 2507f1f4..c0e75cea 100755 --- a/source/chapter2/05_Control_Flow.md +++ b/source/chapter2/05_Control_Flow.md @@ -324,7 +324,7 @@ default: // 输出“The last letter of the alphabet” ``` -在这个例子中，第一个 case 分支用于匹配第一个英文字母 `a`，第二个 case 分支用于匹配最后一个字母 `z`。因为 `switch` 语句必须有一个 case 分支用于覆盖所有可能的字符，而不仅仅是所有的英文字母，所以 switch 语句使用 `default` 分支来匹配除了 `a` 和 `z` 外的所有值，这个分支保证了 swith 语句的完备性。 +在这个例子中，第一个 case 分支用于匹配第一个英文字母 `a`，第二个 case 分支用于匹配最后一个字母 `z`。因为 `switch` 语句必须有一个 case 分支用于覆盖所有可能的字符，而不仅仅是所有的英文字母，所以 switch 语句使用 `default` 分支来匹配除了 `a` 和 `z` 外的所有值，这个分支保证了 switch 语句的完备性。 #### 不存在隐式的贯穿 {#no-implicit-fallthrough} From b7a8566a0fc5d8028923837d6cd9ae7b28d67057 Mon Sep 17 00:00:00 2001 From: Johnson <32932766+johnsongs@users.noreply.github.com> Date: Wed, 24 Jul 2019 12:31:38 +0800 Subject: [PATCH 08/36] =?UTF-8?q?=E6=A0=A1=E5=AF=B9=20(#973)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Update 09_Structures_And_Classes.md 驼峰 * Update 17_Error_Handling.md 病句 --- source/chapter2/09_Structures_And_Classes.md | 2 +- source/chapter2/17_Error_Handling.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/source/chapter2/09_Structures_And_Classes.md b/source/chapter2/09_Structures_And_Classes.md index e34733bc..7238ca4e 100755 --- a/source/chapter2/09_Structures_And_Classes.md +++ b/source/chapter2/09_Structures_And_Classes.md @@ -47,7 +47,7 @@ class SomeClass { > 注意 > -> 每当你定义一个新的结构体或者类时，你都是定义了一个新的 Swift 类型。请使用 `UpperCamelCase` 这种方式来命名类型（如这里的 `SomeClass` 和 `SomeStructure`），以便符合标准 Swift 类型的大写命名风格（如 `String`，`Int` 和 `Bool`）。请使用 `lowerCamelCase` 这种方式来命名属性和方法（如 `framerate` 和 `incrementCount`），以便和类型名区分。 +> 每当你定义一个新的结构体或者类时，你都是定义了一个新的 Swift 类型。请使用 `UpperCamelCase` 这种方式来命名类型（如这里的 `SomeClass` 和 `SomeStructure`），以便符合标准 Swift 类型的大写命名风格（如 `String`，`Int` 和 `Bool`）。请使用 `lowerCamelCase` 这种方式来命名属性和方法（如 `frameRate` 和 `incrementCount`），以便和类型名区分。 以下是定义结构体和定义类的示例： diff --git a/source/chapter2/17_Error_Handling.md b/source/chapter2/17_Error_Handling.md index 60f7d5b8..450c9b4c 100755 --- a/source/chapter2/17_Error_Handling.md +++ b/source/chapter2/17_Error_Handling.md @@ -114,7 +114,7 @@ func buyFavoriteSnack(person: String, vendingMachine: VendingMachine) throws { } ``` -上例中，`buyFavoriteSnack(person:vendingMachine:)` 函数会查找某人最喜欢的零食，并通过调用 `vend(itemNamed:)` 方法来尝试为他们购买。因为 `vend(itemNamed:)` 方法能抛出错误，所以在调用的它时候在它前面加了 `try` 关键字。 +上例中，`buyFavoriteSnack(person:vendingMachine:)` 函数会查找某人最喜欢的零食，并通过调用 `vend(itemNamed:)` 方法来尝试为他们购买。因为 `vend(itemNamed:)` 方法能抛出错误，所以在调用它的时候在它前面加了 `try` 关键字。 `throwing` 构造器能像 `throwing` 函数一样传递错误。例如下面代码中的 `PurchasedSnack` 构造器在构造过程中调用了 throwing 函数，并且通过传递到它的调用者来处理这些错误。 From eedcd69d286313d804398fe107a4e16d1f7ede9d Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Tue, 23 Jul 2019 23:35:29 -0500 Subject: [PATCH 09/36] Update 25_Access_Control.md (#974) --- source/chapter2/25_Access_Control.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/chapter2/25_Access_Control.md b/source/chapter2/25_Access_Control.md index fb018e37..ecdee110 100644 --- a/source/chapter2/25_Access_Control.md +++ b/source/chapter2/25_Access_Control.md @@ -188,7 +188,7 @@ public enum CompassPoint { 此外，你可以在符合当前访问级别的条件下重写任意类成员（方法、属性、构造器、下标等）。 -可以通过重写为继承来的类成员提供更高的访问级别。下面的例子中，类 `A` 的访问级别是 `public`，它包含一个方法 `someMethod()`，访问级别为 `private`。类 `B` 继承自类 `A`，访问级别为 `internal`，但是在类 `B` 中重写了类 `A` 中访问级别为 `private` 的方法 `someMethod()`，并重新指定为 `internal` 级别。通过这种方式，我们就可以将某类中 `private` 级别的类成员重新指定为更高的访问级别，以便其他人使用： +可以通过重写为继承来的类成员提供更高的访问级别。下面的例子中，类 `A` 的访问级别是 `public`，它包含一个方法 `someMethod()`，访问级别为 `fileprivate`。类 `B` 继承自类 `A`，访问级别为 `internal`，但是在类 `B` 中重写了类 `A` 中访问级别为 `fileprivate` 的方法 `someMethod()`，并重新指定为 `internal` 级别。通过这种方式，我们就可以将某类中 `fileprivate` 级别的类成员重新指定为更高的访问级别，以便其他人使用： ```swift public class A { @@ -200,7 +200,7 @@ internal class B: A { } ``` -我们甚至可以在子类中，用子类成员去访问访问级别更低的父类成员，只要这一操作在相应访问级别的限制范围内（也就是说，在同一源文件中访问父类 `private` 级别的成员，在同一模块内访问父类 `internal` 级别的成员）： +我们甚至可以在子类中，用子类成员去访问访问级别更低的父类成员，只要这一操作在相应访问级别的限制范围内（也就是说，在同一源文件中访问父类 `fileprivate` 级别的成员，在同一模块内访问父类 `internal` 级别的成员）： ```swift public class A { From 38ba1198b7e0348c2fbea9e932a12cdc9ae8b2e6 Mon Sep 17 00:00:00 2001 From: tbchen Date: Fri, 26 Jul 2019 13:05:50 +0900 Subject: [PATCH 10/36] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=A4=BA=E4=BE=8B?= =?UTF-8?q?=E4=BB=A3=E7=A0=81=20(#975)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter1/03_a_swift_tour.md | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/source/chapter1/03_a_swift_tour.md b/source/chapter1/03_a_swift_tour.md index 32897c38..b918ce21 100755 --- a/source/chapter1/03_a_swift_tour.md +++ b/source/chapter1/03_a_swift_tour.md @@ -788,15 +788,16 @@ possibleInteger = .some(100) ```swift func anyCommonElements(_ lhs: T, _ rhs: U) -> Bool - where T.Iterator.Element: Equatable, T.Iterator.Element == U.Iterator.Element { - for lhsItem in lhs { - for rhsItem in rhs { - if lhsItem == rhsItem { - return true - } + where T.Element: Equatable, T.Element == U.Element +{ + for lhsItem in lhs { + for rhsItem in rhs { + if lhsItem == rhsItem { + return true } } - return false + } + return false } anyCommonElements([1, 2, 3], [3]) ``` From 02e0b33fd633b592259509fc15337d9211a5f9c6 Mon Sep 17 00:00:00 2001 From: Johnson <32932766+johnsongs@users.noreply.github.com> Date: Thu, 8 Aug 2019 21:55:03 +0800 Subject: [PATCH 11/36] Update 21_Protocols.md (#976) --- source/chapter2/21_Protocols.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter2/21_Protocols.md b/source/chapter2/21_Protocols.md index 5e433eb1..db4e1f79 100644 --- a/source/chapter2/21_Protocols.md +++ b/source/chapter2/21_Protocols.md @@ -883,7 +883,7 @@ extension PrettyTextRepresentable { 在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。这些限制条件写在协议名之后，使用 `where` 子句来描述，正如 [泛型 Where 子句](./22_Generics.md#where_clauses) 中所描述的。 -例如，你可以扩展 `Collection` 协议，适用于集合中的元素遵循了 `Equatable` 协议的情况。通过限制集合元素遵 `Equatable` 协议， 作为标准库的一部分， 你可以使用 `==` 和 `!=` 操作符来检查两个元素的等价性和非等价性。 +例如，你可以扩展 `Collection` 协议，适用于集合中的元素遵循了 `Equatable` 协议的情况。通过限制集合元素遵循 `Equatable` 协议， 作为标准库的一部分， 你可以使用 `==` 和 `!=` 操作符来检查两个元素的等价性和非等价性。 ```swift extension Collection where Element: Equatable { From f3a4630915e1b7052ab06ae9b4f412e27d5205ea Mon Sep 17 00:00:00 2001 From: aizliang <749994379@qq.com> Date: Fri, 23 Aug 2019 00:03:02 +0800 Subject: [PATCH 12/36] Update 03_Strings_and_Characters.md (#978) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 错别字修改 --- source/chapter2/03_Strings_and_Characters.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md index c52b5aa8..731b3384 100755 --- a/source/chapter2/03_Strings_and_Characters.md +++ b/source/chapter2/03_Strings_and_Characters.md @@ -2,7 +2,7 @@ *字符串*是是一系列字符的集合，例如 `"hello, world"`，`"albatross"`。Swift 的字符串通过 `String` 类型来表示。而 `String` 内容的访问方式有多种，例如以 `Character` 值的集合。 -Swift 的 `String` 和 `Character` 类型提供了一种快速且兼容 Unicode 的方式来处理代码中的文本内容。创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。通过 `+` 符号就可以非常简单的实现两个字符串的拼接操作。与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。你可以在已有字符串中插入常量、变量、字面量和表达式从而形成更长的字符串，这一过程也被成为字符串插值。尤其是在为显示、存储和打印创建自定义字符串值时，字符串插值操作尤其有用。 +Swift 的 `String` 和 `Character` 类型提供了一种快速且兼容 Unicode 的方式来处理代码中的文本内容。创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。通过 `+` 符号就可以非常简单的实现两个字符串的拼接操作。与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。你可以在已有字符串中插入常量、变量、字面量和表达式从而形成更长的字符串，这一过程也被称为字符串插值。尤其是在为显示、存储和打印创建自定义字符串值时，字符串插值操作尤其有用。 尽管语法简易，但 Swift 中的 `String` 类型的实现却很快速和现代化。每一个字符串都是由编码无关的 Unicode 字符组成，并支持访问字符的多种 Unicode 表示形式。 From 6d6118e7a36a3351b28debf3096933a036f96756 Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Sat, 28 Sep 2019 22:26:58 -0500 Subject: [PATCH 13/36] Update README.md --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 69f8a73a..e5abf0b7 100755 --- a/README.md +++ b/README.md @@ -57,6 +57,7 @@ diff 操作如下： | 术语 | 备选翻译 | | --- | --- | +| property wrapper | 属性包装器（[翻译相关讨论](https://github.com/SwiftGGTeam/the-swift-programming-language-in-chinese/issues/982#issuecomment-536244784)） | | argument | 实参 | | parameter | 形参 | | associated type | 关联类型 | From 9284579c0bf5458a69c8a392d43645a90872345d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=83=91=E4=B8=80=E4=B8=80?= <43005999+YiYiZheng@users.noreply.github.com> Date: Mon, 30 Sep 2019 11:29:32 +0800 Subject: [PATCH 14/36] Update Swift 5.1 21_protocols (#997) --- source/chapter2/21_Protocols.md | 32 +++++++++++++++++--------------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/source/chapter2/21_Protocols.md b/source/chapter2/21_Protocols.md index db4e1f79..38ccd042 100644 --- a/source/chapter2/21_Protocols.md +++ b/source/chapter2/21_Protocols.md @@ -22,7 +22,7 @@ struct SomeStructure: FirstProtocol, AnotherProtocol { } ``` -若一个拥有父类的类在遵循协议时，应该将父类名放在协议名之前，以逗号分隔： +若是一个类拥有父类，应该将父类名放在遵循的协议名之前，以逗号分隔： ```swift class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { @@ -75,7 +75,7 @@ let john = Person(fullName: "John Appleseed") 这个例子中定义了一个叫做 `Person` 的结构体，用来表示一个具有名字的人。从第一行代码可以看出，它遵循了 `FullyNamed` 协议。 -`Person` 结构体的每一个实例都有一个 `String` 类型的存储型属性 `fullName`。这正好满足了 `FullyNamed` 协议的要求，也就意味着 `Person` 结构体正确地符合了协议。（如果协议要求未被完全满足，在编译时会报错。） +`Person` 结构体的每一个实例都有一个 `String` 类型的存储型属性 `fullName`。这正好满足了 `FullyNamed` 协议的要求，也就意味着 `Person` 结构体正确地遵循了协议。（如果协议要求未被完全满足，在编译时会报错。） 下面是一个更为复杂的类，它采纳并遵循了 `FullyNamed` 协议： @@ -204,7 +204,7 @@ class SomeClass: SomeProtocol { } ``` -使用 `required` 修饰符可以确保所有子类也必须提供此构造器实现，从而也能符合协议。 +使用 `required` 修饰符可以确保所有子类也必须提供此构造器实现，从而也能遵循协议。 关于 `required` 构造器的更多内容，请参考 [必要构造器](./14_Initialization.md#required_initializers)。 @@ -355,7 +355,7 @@ class SnakesAndLadders: DiceGame { 游戏使用 `SnakesAndLadders` 类的 `init()` 构造器来初始化游戏。所有的游戏逻辑被转移到了协议中的 `play()` 方法，`play()` 方法使用协议要求的 `dice` 属性提供骰子摇出的值。 -注意，`delegate` 并不是游戏的必备条件，因此 `delegate` 被定义为 `DiceGameDelegate` 类型的可选属性。因为 `delegate` 是可选值，因此会被自动赋予初始值 `nil`。随后，可以在游戏中为 `delegate` 设置适当的值。 +注意，`delegate` 并不是游戏的必备条件，因此 `delegate` 被定义为 `DiceGameDelegate` 类型的可选属性。因为 `delegate` 是可选值，因此会被自动赋予初始值 `nil`。随后，可以在游戏中为 `delegate` 设置适当的值。因为 `DiceGameDelegate` 协议是类专属的，可以将 `delegate` 声明为 `weak`，从而避免循环引用。 `DicegameDelegate` 协议提供了三个方法用来追踪游戏过程。这三个方法被放置于游戏的逻辑中，即 `play()` 方法内。分别在游戏开始时，新一轮开始时，以及游戏结束时被调用。 @@ -387,7 +387,7 @@ class DiceGameTracker: DiceGameDelegate { `gameDidStart(_:)` 方法从 `game` 参数获取游戏信息并打印。`game` 参数是 `DiceGame` 类型而不是 `SnakeAndLadders` 类型，所以在 `gameDidStart(_:)` 方法中只能访问 `DiceGame` 协议中的内容。当然了，`SnakeAndLadders` 的方法也可以在类型转换之后调用。在上例代码中，通过 `is` 操作符检查 `game` 是否为 `SnakesAndLadders` 类型的实例，如果是，则打印出相应的消息。 -无论当前进行的是何种游戏，由于 `game` 符合 `DiceGame` 协议，可以确保 `game` 含有 `dice` 属性。因此在 `gameDidStart(_:)` 方法中可以通过传入的 `game` 参数来访问 `dice` 属性，进而打印出 `dice` 的 `sides` 属性的值。 +无论当前进行的是何种游戏，由于 `game` 遵循 `DiceGame` 协议，可以确保 `game` 含有 `dice` 属性。因此在 `gameDidStart(_:)` 方法中可以通过传入的 `game` 参数来访问 `dice` 属性，进而打印出 `dice` 的 `sides` 属性的值。 `DiceGameTracker` 的运行情况如下所示： @@ -473,7 +473,7 @@ print(myDice.textualDescription) ## 在扩展里声明采纳协议 {#declaring-protocol-adoption-with-an-extension} -当一个类型已经符合了某个协议中的所有要求，却还没有声明采纳该协议时，可以通过空的扩展来让它采纳该协议： +当一个类型已经遵循了某个协议中的所有要求，却还没有声明采纳该协议时，可以通过空的扩展来让它采纳该协议： ```swift struct Hamster { @@ -619,9 +619,9 @@ wishHappyBirthday(to: birthdayPerson) `Named` 协议包含 `String` 类型的 `name` 属性。`Aged` 协议包含 `Int` 类型的 `age` 属性。`Person` 结构体采纳了这两个协议。 -`wishHappyBirthday(to:)` 函数的参数 `celebrator` 的类型为 `Named & Aged`， 这意味着“任何同时遵循 Named 和 Aged 的协议”。它不关心参数的具体类型，只要参数符合这两个协议即可。 +`wishHappyBirthday(to:)` 函数的参数 `celebrator` 的类型为 `Named & Aged`， 这意味着“任何同时遵循 Named 和 Aged 的协议”。它不关心参数的具体类型，只要参数遵循这两个协议即可。 -上面的例子创建了一个名为 `birthdayPerson` 的 `Person` 的实例，作为参数传递给了 `wishHappyBirthday(to:)` 函数。因为 `Person` 同时符合这两个协议，所以这个参数合法，函数将打印生日问候语。 +上面的例子创建了一个名为 `birthdayPerson` 的 `Person` 的实例，作为参数传递给了 `wishHappyBirthday(to:)` 函数。因为 `Person` 同时遵循这两个协议，所以这个参数合法，函数将打印生日问候语。 这里有一个例子：将 Location 类和前面的 Named 协议进行组合： @@ -650,16 +650,16 @@ beginConcert(in: seattle) // 打印 "Hello, Seattle!" ``` -`beginConcert(in:)` 函数接受一个类型为 `Location & Named` 的参数，这意味着“任何 Location 的子类，并且遵循 Named 协议”。例如，City 就满足这样的条件。 +`beginConcert(in:)` 函数接受一个类型为 `Location & Named` 的参数，这意味着“任何 Location 的子类，并且遵循 Named 协议”。在这个例子中，City 就满足这样的条件。 将 birthdayPerson 传入 `beginConcert(in:)` 函数是不合法的，因为 Person 不是 Location 的子类。同理，如果你新建一个类继承于 Location，但是没有遵循 Named 协议，而用这个类的实例去调用 `beginConcert(in:)` 函数也是非法的。 ## 检查协议一致性 {#checking-for-protocol-conformance} -你可以使用 [类型转换](./18_Type_Casting.md) 中描述的 `is` 和 `as` 操作符来检查协议一致性，即是否符合某协议，并且可以转换到指定的协议类型。检查和转换协议的语法与检查和转换类型是完全一样的： +你可以使用 [类型转换](./18_Type_Casting.md) 中描述的 `is` 和 `as` 操作符来检查协议一致性，即是否遵循某协议，并且可以转换到指定的协议类型。检查和转换协议的语法与检查和转换类型是完全一样的： -* `is` 用来检查实例是否符合某个协议，若符合则返回 `true`，否则返回 `false`； -* `as?` 返回一个可选值，当实例符合某个协议时，返回类型为协议类型的可选值，否则返回 `nil`； +* `is` 用来检查实例是否遵循某个协议，若遵循则返回 `true`，否则返回 `false`； +* `as?` 返回一个可选值，当实例遵循某个协议时，返回类型为协议类型的可选值，否则返回 `nil`； * `as!` 将实例强制向下转换到某个协议类型，如果强转失败，将触发运行时错误。 下面的例子定义了一个 `HasArea` 协议，该协议定义了一个 `Double` 类型的可读属性 `area`： @@ -708,7 +708,7 @@ let objects: [AnyObject] = [ `objects` 数组使用字面量初始化，数组包含一个 `radius` 为 `2` 的 `Circle` 的实例，一个保存了英国国土面积的 `Country` 实例和一个 `legs` 为 `4` 的 `Animal` 实例。 -如下所示，`objects` 数组可以被迭代，并对迭代出的每一个元素进行检查，看它是否符合 `HasArea` 协议： +如下所示，`objects` 数组可以被迭代，并对迭代出的每一个元素进行检查，看它是否遵循 `HasArea` 协议： ```swift for object in objects { @@ -723,7 +723,7 @@ for object in objects { // Something that doesn't have an area ``` -当迭代出的元素符合 `HasArea` 协议时，将 `as?` 操作符返回的可选值通过可选绑定，绑定到 `objectWithArea` 常量上。`objectWithArea` 是 `HasArea` 协议类型的实例，因此 `area` 属性可以被访问和打印。 +当迭代出的元素遵循 `HasArea` 协议时，将 `as?` 操作符返回的可选值通过可选绑定，绑定到 `objectWithArea` 常量上。`objectWithArea` 是 `HasArea` 协议类型的实例，因此 `area` 属性可以被访问和打印。 `objects` 数组中的元素的类型并不会因为强转而丢失类型信息，它们仍然是 `Circle`，`Country`，`Animal` 类型。然而，当它们被赋值给 `objectWithArea` 常量时，只被视为 `HasArea` 类型，因此只有 `area` 属性能够被访问。 @@ -861,9 +861,11 @@ print("And here's a random Boolean: \(generator.randomBool())") // 打印 “And here's a random Boolean: true” ``` +协议扩展可以为遵循协议的类型增加实现，但不能声明该协议继承自另一个协议。协议的继承只能在协议声明处进行指定。 + ### 提供默认实现 {#providing-default-implementations} -可以通过协议扩展来为协议要求的属性、方法以及下标提供默认的实现。如果遵循协议的类型为这些要求提供了自己的实现，那么这些自定义实现将会替代扩展中的默认实现被使用。 +可以通过协议扩展来为协议要求的方法、计算属性提供默认的实现。如果遵循协议的类型为这些要求提供了自己的实现，那么这些自定义实现将会替代扩展中的默认实现被使用。 > 注意 > From db48920fa302d01935dc256e45a042e976be6131 Mon Sep 17 00:00:00 2001 From: DanziChen Date: Mon, 30 Sep 2019 11:30:36 +0800 Subject: [PATCH 15/36] update ARC (#998) * update swift 5.1 * update post --- .../23_Automatic_Reference_Counting.md | 29 ++++++++++--------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/source/chapter2/23_Automatic_Reference_Counting.md b/source/chapter2/23_Automatic_Reference_Counting.md index 4200122d..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") @@ -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 64f80c9cba9f5899bc45e0d63c238f747ee11179 Mon Sep 17 00:00:00 2001 From: YinjunXi Date: Mon, 30 Sep 2019 22:26:00 +0800 Subject: [PATCH 16/36] update 25_Access_Control to 5.1 (#994) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * update 25_Access_Control to 5.1 * Update 25_Access_Control.md * Update 25_Access_Control.md 修改语句不通顺的翻译。 --- source/chapter2/25_Access_Control.md | 77 +++++++++++++--------------- 1 file changed, 36 insertions(+), 41 deletions(-) diff --git a/source/chapter2/25_Access_Control.md b/source/chapter2/25_Access_Control.md index ecdee110..501d0cbb 100644 --- a/source/chapter2/25_Access_Control.md +++ b/source/chapter2/25_Access_Control.md @@ -1,14 +1,14 @@ # 访问控制 -*访问控制*可以限定其它源文件或模块中的代码对你的代码的访问级别。这个特性可以让我们隐藏代码的一些实现细节，并且可以为其他人可以访问和使用的代码提供接口。 +*访问控制*可以限定其它源文件或模块对你的代码的访问。这个特性可以让你隐藏代码的实现细节，并且能提供一个接口来让别人访问和使用你的代码。 -你可以明确地给单个类型（类、结构体、枚举）设置访问级别，也可以给这些类型的属性、方法、构造器、下标等设置访问级别。协议也可以被限定在一定的范围内使用，包括协议里的全局常量、变量和函数。 +你可以明确地给单个类型（类、结构体、枚举）设置访问级别，也可以给这些类型的属性、方法、构造器、下标等设置访问级别。协议也可以被限定在一定访问级别的范围内使用，包括协议里的全局常量、变量和函数。 -Swift 不仅提供了多种不同的访问级别，还为某些典型场景提供了默认的访问级别，这样就不需要我们在每段代码中都申明显式访问级别。其实，如果只是开发一个单一 target 的应用程序，我们完全可以不用显式声明代码的访问级别。 +Swift 不仅提供了多种不同的访问级别，还为某些典型场景提供了默认的访问级别，这样就不需要我们在每段代码中都显式声明访问级别。如果你只是开发一个单 target 的应用程序，完全可以不用显式声明代码的访问级别。 > 注意 > -> 为了简单起见，对于代码中可以设置访问级别的特性（属性、基本类型、函数等），在下面的章节中我们会称之为“实体”。 +> 为了简单起见，对于代码中可以设置访问级别的特性（属性、基本类型、函数等），在下面的章节中我们会统一称之为“实体”。 ## 模块和源文件 {#modules-and-source-files} @@ -16,29 +16,22 @@ Swift 中的访问控制模型基于模块和源文件这两个概念。 *模块*指的是独立的代码单元，框架或应用程序会作为一个独立的模块来构建和发布。在 Swift 中，一个模块可以使用 `import` 关键字导入另外一个模块。 -在 Swift 中，Xcode 的每个 target（例如框架或应用程序）都被当作独立的模块处理。如果你是为了实现某个通用的功能，或者是为了封装一些常用方法而将代码打包成独立的框架，这个框架就是 Swift 中的一个模块。当它被导入到某个应用程序或者其他框架时，框架内容都将属于这个独立的模块。 +在 Swift 中，Xcode 的每个 target（例如框架或应用程序）都被当作独立的模块处理。如果你是为了实现某个通用的功能，或者是为了封装一些常用方法而将代码打包成独立的框架，这个框架就是 Swift 中的一个模块。当它被导入到某个应用程序或者其他框架时，框架的内容都将属于这个独立的模块。 -*源文件*就是 Swift 中的源代码文件，它通常属于一个模块，即一个应用程序或者框架。尽管我们一般会将不同的类型分别定义在不同的源文件中，但是同一个源文件也可以包含多个类型、函数之类的定义。 +*源文件* 就是 Swift 模块中的源代码文件（实际上，源文件属于一个应用程序或框架）。尽管我们一般会将不同的类型分别定义在不同的源文件中，但是同一个源文件也可以包含多个类型、函数等的定义。 ## 访问级别 {#access-levels} Swift 为代码中的实体提供了五种不同的*访问级别*。这些访问级别不仅与源文件中定义的实体相关，同时也与源文件所属的模块相关。 -- *Open* 和 *Public* 级别可以让实体被同一模块源文件中的所有实体访问，在模块外也可以通过导入该模块来访问源文件里的所有实体。通常情况下，你会使用 Open 或 Public 级别来指定框架的外部接口。Open 和 Public 的区别在后面会提到。 -- *Internal* 级别让实体被同一模块源文件中的任何实体访问，但是不能被模块外的实体访问。通常情况下，如果某个接口只在应用程序或框架内部使用，就可以将其设置为 Internal 级别。 -- *File-private* 限制实体只能在其定义的文件内部访问。如果功能的部分细节只需要在文件内使用时，可以使用 File-private 来将其隐藏。 -- *Private* 限制实体只能在其定义的作用域，以及同一文件内的 extension 访问。如果功能的部分细节只需要在当前作用域内使用时，可以使用 Private 来将其隐藏。 +- *open* 和 *public* 级别可以让实体被同一模块源文件中的所有实体访问，在模块外也可以通过导入该模块来访问源文件里的所有实体。通常情况下，你会使用 open 或 public 级别来指定框架的外部接口。open 和 public 的区别在后面会提到。 +- *internal* 级别让实体被同一模块源文件中的任何实体访问，但是不能被模块外的实体访问。通常情况下，如果某个接口只在应用程序或框架内部使用，就可以将其设置为 internal 级别。 +- *fileprivate* 限制实体只能在其定义的文件内部访问。如果功能的部分实现细节只需要在文件内使用时，可以使用 fileprivate 来将其隐藏。 +- *private* 限制实体只能在其定义的作用域，以及同一文件内的 extension 访问。如果功能的部分细节只需要在当前作用域内使用时，可以使用 private 来将其隐藏。 -Open 为最高访问级别（限制最少），Private 为最低访问级别（限制最多）。 +open 为最高访问级别（限制最少），private 为最低访问级别（限制最多）。 -Open 只能作用于类和类的成员，它和 Public 的区别如下： - -* Public 或者其它更严访问级别的类，只能在其定义的模块内部被继承。 -* Public 或者其它更严访问级别的类成员，只能在其定义的模块内部的子类中重写。 -* Open 的类，可以在其定义的模块中被继承，也可以在引用它的模块中被继承。 -* Open 的类成员，可以在其定义的模块中子类中重写，也可以在引用它的模块中的子类重写。 - -把一个类标记为 `open`，明确的表示你已经充分考虑过外部模块使用此类作为父类的影响，并且设计好了你的类的代码了。 +open 只能作用于类和类的成员，它和 public 的区别主要在于 open 限定的类和成员能够在模块外能被继承和重写，在下面的 [子类](#subclassing) 这一节中有详解。将类的访问级别显示指定为 `open` 表明你已经设计好了类的代码，并且充分考虑过这个类在其他模块中用作父类时的影响。 ### 访问级别基本原则 {#guiding-principle-of-access-levels} @@ -46,22 +39,22 @@ Swift 中的访问级别遵循一个基本原则：*实体不能定义在具有 例如： -- 一个 Public 的变量，其类型的访问级别不能是 Internal，File-private 或是 Private。因为无法保证变量的类型在使用变量的地方也具有访问权限。 +- 一个 public 的变量，其类型的访问级别不能是 internal，fileprivate 或是 private。因为无法保证变量的类型在使用变量的地方也具有访问权限。 - 函数的访问级别不能高于它的参数类型和返回类型的访问级别。因为这样就会出现函数可以在任何地方被访问，但是它的参数类型和返回类型却不可以的情况。 关于此原则在各种情况下的具体表现，将在下文有所体现。 ### 默认访问级别 {#default-access-levels} -如果你没有为代码中的实体显式指定访问级别，那么它们默认为 `internal` 级别（有一些例外情况，稍后会进行说明）。因此，在大多数情况下，我们不需要显式指定实体的访问级别。 +你代码中所有的实体，如果你不显式的指定它们的访问级别，那么它们将都有一个 `internal` 的默认访问级别，（有一些例外情况，本文稍后会有说明）。因此，多数情况下你不需要显示指定实体的访问级别。 ### 单 target 应用程序的访问级别 {#access-levels-for-single-target-apps} -当你编写一个单目标应用程序时，应用的所有功能都是为该应用服务，而不需要提供给其他应用或者模块使用，所以我们不需要明确设置访问级别，使用默认的访问级别 Internal 即可。但是，你也可以使用 `fileprivate` 访问或 `private` 访问级别，用于隐藏一些功能的实现细节。 +当你编写一个单 target 应用程序时，应用的所有功能都是为该应用服务，而不需要提供给其他应用或者模块使用，所以你不需要明确设置访问级别，使用默认的访问级别 internal 即可。但是，你也可以使用 `fileprivate` 或 `private` 访问级别，用于隐藏一些功能的实现细节。 ### 框架的访问级别 {#access-levels-for-frameworks} -当你开发框架时，就需要把一些对外的接口定义为 Open 或 Public，以便使用者导入该框架后可以正常使用其功能。这些被你定义为对外的接口，就是这个框架的 API。 +当你开发框架时，就需要把一些对外的接口定义为 open 或 public 访问级别，以便使用者导入该框架后可以正常使用其功能。这些被你定义为对外的接口，就是这个框架的 API。 > 注意 > @@ -87,7 +80,7 @@ fileprivate func someFilePrivateFunction() {} private func somePrivateFunction() {} ``` -除非专门指定，否则实体默认的访问级别为 `internal`，可以查阅 [默认访问级别](#default_access_levels) 这一节。这意味着在不使用修饰符显式声明访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 仍然拥有隐式的 `internal`： +除非专门指定，否则实体默认的访问级别为 `internal`，可以查阅 [默认访问级别](#default_access_levels) 这一节。这意味着在不使用修饰符显式声明访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 的访问级别是 `internal`： ```swift class SomeInternalClass {} // 隐式 internal @@ -96,7 +89,7 @@ var someInternalConstant = 0 // 隐式 internal ## 自定义类型 {#custom-types} -如果想为一个自定义类型指定访问级别，在定义类型时进行指定即可。新类型只能在它的访问级别限制范围内使用。例如，你定义了一个 `fileprivate` 级别的类，那这个类就只能在定义它的源文件中使用，可以作为属性类型、函数参数类型或者返回类型，等等。 +如果想为一个自定义类型指定访问级别，在定义类型时进行指定即可。新类型只能在它的访问级别限制范围内使用。例如，你定义了一个 `fileprivate` 级别的类，那这个类就只能在定义它的源文件中使用，可以作为属性类型、函数参数类型或者返回类型等等。 一个类型的访问级别也会影响到类型*成员*（属性、方法、构造器、下标）的默认访问级别。如果你将类型指定为 `private` 或者 `fileprivate` 级别，那么该类型的所有成员的默认访问级别也会变成 `private` 或者 `fileprivate` 级别。如果你将类型指定为 `internal` 或 `public`（或者不明确指定访问级别，而使用默认的 `internal` ），那么该类型的所有成员的默认访问级别将是 `internal`。 @@ -127,13 +120,15 @@ private class SomePrivateClass { // 显式 private 类 func somePrivateMethod() {} // 隐式 private 类成员 } ``` + ### 元组类型 {#tuple-types} 元组的访问级别将由元组中访问级别最严格的类型来决定。例如，如果你构建了一个包含两种不同类型的元组，其中一个类型为 `internal`，另一个类型为 `private`，那么这个元组的访问级别为 `private`。 > 注意 > -> 元组不同于类、结构体、枚举、函数那样有单独的定义。元组的访问级别是在它被使用时自动推断出的，而无法明确指定。 +> 元组不同于类、结构体、枚举、函数那样有单独的定义。一个元组的访问级别由元组中元素的访问级别来决定的，不能被显示指定。 + ### 函数类型 {#function-types} @@ -149,7 +144,7 @@ func someFunction() -> (SomeInternalClass, SomePrivateClass) { 我们可以看到，这个函数的返回类型是一个元组，该元组中包含两个自定义的类（可查阅 [自定义类型](#custom_types)）。其中一个类的访问级别是 `internal`，另一个的访问级别是 `private`，所以根据元组访问级别的原则，该元组的访问级别是 `private`（元组的访问级别与元组中访问级别最低的类型一致）。 -因为该函数返回类型的访问级别是 `private`，所以你必须使用 `private` 修饰符，明确指定该函数的访问级别： +因为该函数返回类型的访问级别是 `private`，所以你必须使用 `private` 修饰符来明确指定该函数的访问级别： ```swift private func someFunction() -> (SomeInternalClass, SomePrivateClass) { @@ -163,7 +158,7 @@ private func someFunction() -> (SomeInternalClass, SomePrivateClass) { 枚举成员的访问级别和该枚举类型相同，你不能为枚举成员单独指定不同的访问级别。 -比如下面的例子，枚举 `CompassPoint` 被明确指定为 `public`，那么它的成员 `North`、`South`、`East`、`West` 的访问级别同样也是 `public`： +比如下面的例子，枚举 `CompassPoint` 被明确指定为 `public`，那么它的成员 `north`、`south`、`east`、`west` 的访问级别同样也是 `public`： ```swift public enum CompassPoint { @@ -180,15 +175,15 @@ public enum CompassPoint { ### 嵌套类型 {#nested-types} -如果在 `private` 的类型中定义嵌套类型，那么该嵌套类型就自动拥有 `private` 访问级别。如果在 `public` 或者 `internal` 级别的类型中定义嵌套类型，那么该嵌套类型自动拥有 `internal` 访问级别。如果想让嵌套类型拥有 `public` 访问级别，那么需要明确指定该嵌套类型的访问级别。 +嵌套类型的访问级别和包含它的类型的访问级别相同，嵌套类型是 public 的情况除外。在一个 public 的类型中定义嵌套类型，那么嵌套类型自动拥有 `internal` 的访问级别。如果你想让嵌套类型拥有 `public` 访问级别，那么必须显式指定该嵌套类型的访问级别为 public。 ## 子类 {#subclassing} -子类的访问级别不得高于父类的访问级别。例如，父类的访问级别是 `internal`，子类的访问级别就不能是 `public`。 +你可以继承同一模块中的所有有访问权限的类，也可以继承不同模块中被 open 修饰的类。一个子类的访问级别不得高于父类的访问级别。例如，父类的访问级别是 `internal`，子类的访问级别就不能是 `public`。 -此外，你可以在符合当前访问级别的条件下重写任意类成员（方法、属性、构造器、下标等）。 +此外，在同一模块中，你可以在符合当前访问级别的条件下重写任意类成员（方法、属性、构造器、下标等）。在不同模块中，你可以重写类中被 open 修饰的成员。 -可以通过重写为继承来的类成员提供更高的访问级别。下面的例子中，类 `A` 的访问级别是 `public`，它包含一个方法 `someMethod()`，访问级别为 `fileprivate`。类 `B` 继承自类 `A`，访问级别为 `internal`，但是在类 `B` 中重写了类 `A` 中访问级别为 `fileprivate` 的方法 `someMethod()`，并重新指定为 `internal` 级别。通过这种方式，我们就可以将某类中 `fileprivate` 级别的类成员重新指定为更高的访问级别，以便其他人使用： +可以通过重写给所继承类的成员提供更高的访问级别。下面的例子中，类 `A` 的访问级别是 `public`，它包含一个方法 `someMethod()`，访问级别为 `fileprivate`。类 `B` 继承自类 `A`，访问级别为 `internal`，但是在类 `B` 中重写了类 `A` 中访问级别为 `fileprivate` 的方法 `someMethod()`，并重新指定为 `internal` 级别。通过这种方式，我们就可以将某类中 `fileprivate` 级别的类成员重新指定为更高的访问级别，以便其他人使用： ```swift public class A { @@ -234,7 +229,7 @@ private var privateInstance = SomePrivateClass() > 注意 > -> 这个规则同时适用于存储型属性和计算型属性。即使你不明确指定存储型属性的 `Getter` 和 `Setter`，Swift 也会隐式地为其创建 `Getter` 和 `Setter`，用于访问该属性的后备存储。使用 `fileprivate(set)`，`private(set)` 和 `internal(set)` 可以改变 `Setter` 的访问级别，这对计算型属性也同样适用。 +> 这个规则同时适用于存储型属性和计算型属性。即使你不明确指定存储型属性的 `Getter` 和 `Setter`，Swift 也会隐式地为其创建 `Getter` 和 `Setter`，用于访问该属性的存储内容。使用 `fileprivate(set)`，`private(set)` 和 `internal(set)` 可以改变 `Setter` 的访问级别，这对计算型属性也同样适用。 下面的例子中定义了一个名为 `TrackedString` 的结构体，它记录了 `value` 属性被修改的次数： @@ -300,17 +295,17 @@ public struct TrackedString { ## 协议 {#protocols} -如果想为一个协议类型明确地指定访问级别，在定义协议时指定即可。这将限制该协议只能在适当的访问级别范围内被遵循。 +如果想为一个协议类型明确地指定访问级别，在声明协议时指定即可。这将限制该协议只能在适当的访问级别范围内被遵循。 -协议中的每一个要求都具有和该协议相同的访问级别。你不能将协议中的要求设置为其他访问级别。这样才能确保该协议的所有要求对于任意遵循者都将可用。 +协议中的每个方法或属性都必须具有和该协议相同的访问级别。你不能将协议中的方法或属性设置为其他访问级别。这样才能确保该协议的所有方法或属性对于任意遵循者都可用。 > 注意 > -> 如果你定义了一个 `public` 访问级别的协议，那么该协议的所有实现也会是 `public` 访问级别。这一点不同于其他类型，例如，当类型是 `public` 访问级别时，其成员的访问级别却只是 `internal`。 +> 如果你定义了一个 `public` 访问级别的协议，那么该协议的所有实现也会是 `public` 访问级别。这一点不同于其他类型，例如，类型是 `public` 访问级别时，其成员的访问级别却只是 `internal`。 ### 协议继承 {#protocol-inheritance} -如果定义了一个继承自其他协议的新协议，那么新协议拥有的访问级别最高也只能和被继承协议的访问级别相同。例如，你不能将继承自 `internal` 协议的新协议定义为 `public` 协议。 +如果定义了一个继承自其他协议的新协议，那么新协议拥有的访问级别最高也只能和被继承协议的访问级别相同。例如，你不能将继承自 `internal` 协议的新协议访问级别指定为 `public` 协议。 ### 协议遵循 {#protocol-conformance} @@ -326,9 +321,9 @@ public struct TrackedString { ## Extension {#extensions} -Extension 可以在访问级别允许的情况下对类、结构体、枚举进行扩展。Extension 的成员具有和原始类型成员一致的访问级别。例如，你使用 extension 扩展了一个 `public` 或者 `internal` 类型，extension 中的成员就默认使用 `internal` 访问级别，和原始类型中的成员一致。如果你使用 extension 扩展了一个 `private` 类型，则 extension 的成员默认使用 `private` 访问级别。 +Extension 可以在访问级别允许的情况下对类、结构体、枚举进行扩展。Extension 的新增成员具有和原始类型成员一致的访问级别。例如，你使用 extension 扩展了一个 `public` 或者 `internal` 类型，则 extension 中的成员就默认使用 `internal` 访问级别。如果你使用 extension 扩展一个 `fileprivate` 类型，则 extension 中的成员默认使用 `fileprivate` 访问级别。如果你使用 extension 扩展了一个 `private` 类型，则 extension 的成员默认使用 `private` 访问级别。 -或者，你可以明确指定 extension 的访问级别（例如，`private extension`），从而给该 extension 中的所有成员指定一个新的默认访问级别。这个新的默认访问级别仍然可以被单独指定的访问级别所覆盖。 +或者，你可以通过修饰语重新指定 extension 的默认访问级别（例如，`private`），从而给该 extension 中的所有成员指定一个新的默认访问级别。这个新的默认访问级别仍然可以被单独成员指定的访问级别所覆盖。 如果你使用 extension 来遵循协议的话，就不能显式地声明 extension 的访问级别。extension 每个 protocol 要求的实现都默认使用 protocol 的访问级别。 @@ -340,7 +335,7 @@ Extension 可以在访问级别允许的情况下对类、结构体、枚举进 - 在 extension 里声明一个私有成员，在同一文件的另一个 extension 里访问。 - 在 extension 里声明一个私有成员，在同一文件的类型声明里访问。 -这意味着你可以像组织的代码去使用 extension，而且不受私有成员的影响。例如，给定下面这样一个简单的协议： +这意味着你可以使用 extension 来组织你的代码，而且不受私有成员的影响。例如，给定下面这样一个简单的协议： ```swift protocol SomeProtocol { @@ -368,7 +363,7 @@ extension SomeStruct: SomeProtocol { ## 类型别名 {#type-aliases} -你定义的任何类型别名都会被当作不同的类型，以便于进行访问控制。类型别名的访问级别不可高于其表示的类型的访问级别。例如，`private` 级别的类型别名可以作为 `private`、`file-private`、`internal`、`public` 或者 `open` 类型的别名，但是 `public` 级别的类型别名只能作为 `public` 类型的别名，不能作为 `internal`、`file-private` 或 `private` 类型的别名。 +你定义的任何类型别名都会被当作不同的类型，以便于进行访问控制。类型别名的访问级别不可高于其表示的类型的访问级别。例如，`private` 级别的类型别名可以作为 `private`、`fileprivate`、`internal`、`public` 或者 `open` 类型的别名，但是 `public` 级别的类型别名只能作为 `public` 类型的别名，不能作为 `internal`、`fileprivate` 或 `private` 类型的别名。 > 注意 > From 30db13bc1eccca66fffa464b151ad43c3df7c269 Mon Sep 17 00:00:00 2001 From: DanziChen Date: Tue, 1 Oct 2019 18:17:42 +0800 Subject: [PATCH 17/36] Update README.md --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index e5abf0b7..ea3209b5 100755 --- a/README.md +++ b/README.md @@ -60,6 +60,7 @@ diff 操作如下： | property wrapper | 属性包装器（[翻译相关讨论](https://github.com/SwiftGGTeam/the-swift-programming-language-in-chinese/issues/982#issuecomment-536244784)） | | argument | 实参 | | parameter | 形参 | +| variadic parameters| 可变参数 | | associated type | 关联类型 | | range | 区间 | | type property | 类型属性 | From 8b743fafe52ba18b5646221c864c9d0339df745d Mon Sep 17 00:00:00 2001 From: DanziChen Date: Tue, 1 Oct 2019 21:14:17 +0800 Subject: [PATCH 18/36] update Types 5.1 (#1000) * update swift 5.1 * update post * 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 5392b093d2de28a34e869a6fcbbbfa099638c05e Mon Sep 17 00:00:00 2001 From: liangning-gh <56049801+liangning-gh@users.noreply.github.com> Date: Wed, 2 Oct 2019 06:04:22 +0800 Subject: [PATCH 19/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E7=A9=BA=E6=A0=BC=20(#?= =?UTF-8?q?1001)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/chapter4/01_Access_Control.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter4/01_Access_Control.md b/source/chapter4/01_Access_Control.md index 27b79f82..95cb921a 100644 --- a/source/chapter4/01_Access_Control.md +++ b/source/chapter4/01_Access_Control.md @@ -11,7 +11,7 @@ > 小明说哇靠学姐你还会妖法...... -Swift 语言从 Xcode 6 beta 5版本起，加入了对权限控制（Access Control）的支持。其实权限控制和小明的物品一样，你可以设定水壶是只有自己能用，还是只有宿舍里的人能用，还是全校都可以用。 +Swift 语言从 Xcode 6 beta 5 版本起，加入了对权限控制（Access Control）的支持。其实权限控制和小明的物品一样，你可以设定水壶是只有自己能用，还是只有宿舍里的人能用，还是全校都可以用。 从此以后，你可以好像神盾局局长一样，完全掌控自己的代码块的”保密级别“，哪些是只能在本文件引用，哪些能用在整个项目里，你还可以发挥大爱精神，把它开源成只要导入你的框架，大家都可以使用的 API。 From 06e3e126210f080160480da14940edaba088b754 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=81=B0s?= Date: Wed, 9 Oct 2019 03:32:30 +0800 Subject: [PATCH 20/36] =?UTF-8?q?Subscripts=20#984=20=E6=9B=B4=E6=96=B0=20?= =?UTF-8?q?5.1=20(#999)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 04_Collection_Types 5.1初版 * 校对以后的更新 * 第二次校对以后的修正 * 初次5.1更改 * 装饰改为包装 * 校对以后的更改 * 5.1更新初次完成 * 还原Attributes相关更新，避免冲突 * 初次校对的更改 --- source/chapter2/12_Subscripts.md | 54 ++++++++++++++++---------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md index e6d1862a..78ef926c 100755 --- a/source/chapter2/12_Subscripts.md +++ b/source/chapter2/12_Subscripts.md @@ -2,11 +2,11 @@ *下标*可以定义在类、结构体和枚举中，是访问集合、列表或序列中元素的快捷方式。可以使用下标的索引，设置和获取值，而不需要再调用对应的存取方法。举例来说，用下标访问一个 `Array` 实例中的元素可以写作 `someArray[index]`，访问 `Dictionary` 实例中的元素可以写作 `someDictionary[key]`。 -一个类型可以定义多个下标，通过不同索引类型进行重载。下标不限于一维，你可以定义具有多个入参的下标满足自定义类型的需求。 +一个类型可以定义多个下标，通过不同索引类型进行对应的重载。下标不限于一维，你可以定义具有多个入参的下标满足自定义类型的需求。 ## 下标语法 {#subscript-syntax} -下标允许你通过在实例名称后面的方括号中传入一个或者多个索引值来对实例进行存取。语法类似于实例方法语法和计算型属性语法的混合。与定义实例方法类似，定义下标使用 `subscript` 关键字，指定一个或多个输入参数和返回类型；与实例方法不同的是，下标可以设定为读写或只读。这种行为由 getter 和 setter 实现，有点类似计算型属性： +下标允许你通过在实例名称后面的方括号中传入一个或者多个索引值来对实例进行查询。它的语法类似于实例方法语法和计算型属性语法。定义下标使用 `subscript` 关键字，与定义实例方法类似，都是指定一个或多个输入参数和一个返回类型。与实例方法不同的是，下标可以设定为读写或只读。这种行为由 getter 和 setter 实现，类似计算型属性： ```swift subscript(index: Int) -> Int { @@ -19,9 +19,9 @@ subscript(index: Int) -> Int { } ``` -`newValue` 的类型和下标的返回类型相同。如同计算型属性，可以不指定 setter 的参数（`newValue`）。如果不指定参数，setter 会提供一个名为 `newValue` 的默认参数。 +`newValue` 的类型和下标操作的返回类型相同。如同计算型属性，可以不指定 setter 的参数（`newValue`）。如果不指定参数，setter 会提供一个名为 `newValue` 的默认参数。 -如同只读计算型属性，可以省略只读下标的 `get` 关键字： +如同只读计算型属性，对于只读下标的声明，你可以通过省略 `get` 关键字和对应的大括号组来进行简写： ```swift subscript(index: Int) -> Int { @@ -29,7 +29,7 @@ subscript(index: Int) -> Int { } ``` -下面代码演示了只读下标的实现，这里定义了一个 `TimesTable` 结构体，用来表示传入整数的乘法表： +下面代码演示了只读下标的实现，这里定义了一个 `TimesTable` 结构体，用来表示对应整数的乘法表： ```swift struct TimesTable { @@ -45,7 +45,7 @@ print("six times three is \(threeTimesTable[6])") 在上例中，创建了一个 `TimesTable` 实例，用来表示整数 `3` 的乘法表。数值 `3` 被传递给结构体的构造函数，作为实例成员 `multiplier` 的值。 -你可以通过下标访问 `threeTimesTable` 实例，例如上面演示的 `threeTimesTable[6]`。这条语句查询了 `3` 的乘法表中的第六个元素，返回 `3` 的 `6` 倍即 `18`。 +你可以通过下标访问 `threeTimesTable` 实例，例如上面演示的 `threeTimesTable[6]`。这条语句查询了乘法表中 `3` 的第六个元素，返回 `3` 的 `6` 倍即 `18`。 > 注意 > @@ -53,9 +53,9 @@ print("six times three is \(threeTimesTable[6])") ## 下标用法 {#subscript-usage} -下标的确切含义取决于使用场景。下标通常作为访问集合，列表或序列中元素的快捷方式。你可以针对自己特定的类或结构体的功能来自由地以最恰当的方式实现下标。 +“下标”的确切含义取决于使用场景。下标通常作为访问集合，列表或序列中元素的快捷方式。你可以针对自己特定的类或结构体功能来以最恰当的方式实现下标。 -例如，Swift 的 `Dictionary` 类型实现下标用于对其实例中储存的值进行存取操作。为字典设值时，在下标中使用和字典的键类型相同的键，并把一个和字典的值类型相同的值赋给这个下标： +例如，Swift 的 `Dictionary` 类型实现下标用于对实例中储存的值进行存取操作。为字典设值时，在下标中使用和字典的键类型相同的键，并把一个和字典的值类型相同的值赋给这个下标： ```swift var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4] @@ -68,13 +68,13 @@ numberOfLegs["bird"] = 2 > 注意 > -> Swift 的 `Dictionary` 类型的下标接受并返回可选类型的值。上例中的 `numberOfLegs` 字典通过下标返回的是一个 `Int?` 或者说“可选的 int”。`Dictionary` 类型之所以如此实现下标，是因为不是每个键都有个对应的值，同时这也提供了一种通过键删除对应值的方式，只需将键对应的值赋值为 `nil` 即可。 +> Swift 的 `Dictionary` 类型的下标接受并返回_可选_类型的值。上例中的 `numberOfLegs` 字典通过下标返回的是一个 `Int?` 或者说“可选的 int”。`Dictionary` 类型之所以如此实现下标，是因为不是每个键都有对应的值，同时这也提供了一种通过键删除对应值的方式，只需将键对应的值赋值为 `nil` 即可。 ## 下标选项 {#subscript-options} -下标可以接受任意数量的入参，并且这些入参可以是任意类型。下标的返回值也可以是任意类型。下标可以使用可变参数，并且可以提供默认参数数值，但是不能使用输入输出参数。 +下标可以接受任意数量的入参，并且这些入参可以是任意类型。下标的返回值也可以是任意类型。下标可以使用可变参数，但是不能使用 in-out 参数以及不能提供默认参数。 -一个类或结构体可以根据自身需要提供多个下标实现，使用下标时将通过入参的数量和类型进行区分，自动匹配合适的下标，这就是*下标的重载*。 +一个类或结构体可以根据自身需要提供多个下标实现，使用下标时将通过入参的数量和类型进行区分，自动匹配合适的下标。它通常被称为*下标的重载*。 虽然接受单一入参的下标是最常见的，但也可以根据情况定义接受多个入参的下标。例如下例定义了一个 `Matrix` 结构体，用于表示一个 `Double` 类型的二维矩阵。`Matrix` 结构体的下标接受两个整型参数： @@ -105,13 +105,13 @@ struct Matrix { `Matrix` 提供了一个接受两个入参的构造方法，入参分别是 `rows` 和 `columns`，创建了一个足够容纳 `rows * columns` 个 `Double` 类型的值的数组。通过传入数组长度和初始值 `0.0` 到数组的构造器，将矩阵中每个位置的值初始化为 `0.0`。关于数组的这种构造方法请参考 [创建一个带有默认值的数组](./04_Collection_Types.md#creating_an_array_with_a_default_value)。 -你可以通过传入合适的 `row` 和 `column` 的数量来构造一个新的 `Matrix` 实例： +你可以通过传入合适的 `row` 和 `column` 数值来构造一个新的 `Matrix` 实例： ```swift var matrix = Matrix(rows: 2, columns: 2) ``` -上例中创建了一个 `Matrix` 实例来表示两行两列的矩阵。该 `Matrix` 实例的 `grid` 数组按照从左上到右下的阅读顺序将矩阵扁平化存储： +上例中创建了一个两行两列的 `Matrix` 实例。该 `Matrix` 实例的 `grid` 数组按照从左上到右下的阅读顺序将矩阵扁平化存储： ![](https://docs.swift.org/swift-book/_images/subscriptMatrix01_2x.png) @@ -139,18 +139,18 @@ func indexIsValid(row: Int, column: Int) -> Bool { ```swift let someValue = matrix[2, 2] // 断言将会触发，因为 [2, 2] 已经超过了 matrix 的范围 -``` - -## 类型下标{#type-subscripts} -正如上节所述，实例下标是在特定类型的一个实例上调用的下标。你也可以定义一种在这个类型本身上调用的下标。这种下标的类型被称作类型下标。你可以通过在 `subscript` 关键字之前写下 `static` 关键字的方式来表示一个类型下标。类可以使用 `class` 关键字来允许子类重写父类中对那个下标的实现。下面的例子展示了如何定义和调用一个类型下标： -``` -enum Planet: Int { - case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune - static subscript(n: Int) -> Planet { - return Planet(rawValue: n)! - } -} -let mars = Planet[4] -print(mars) -``` +``` + +## 类型下标{#type-subscripts} +正如上节所述，实例下标是在特定类型的一个实例上调用的下标。你也可以定义一种在这个类型自身上调用的下标。这种下标被称作_类型下标_。你可以通过在 `subscript` 关键字之前写下 `static` 关键字的方式来表示一个类型下标。类类型可以使用 `class` 关键字来代替 `static`，它允许子类重写父类中对那个下标的实现。下面的例子展示了如何定义和调用一个类型下标： +``` +enum Planet: Int { + case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune + static subscript(n: Int) -> Planet { + return Planet(rawValue: n)! + } +} +let mars = Planet[4] +print(mars) +``` From 603a40adb0e8753563a5c3f4f8a2223a75a61e67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=81=B0s?= Date: Wed, 9 Oct 2019 11:53:57 +0800 Subject: [PATCH 21/36] =?UTF-8?q?=E5=88=9D=E6=AD=A5=E5=AE=8C=E6=88=90=20#9?= =?UTF-8?q?85=20(#996)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 04_Collection_Types 5.1初版 * 校对以后的更新 * 第二次校对以后的修正 * 初次5.1更改 * 装饰改为包装 * 校对以后的更改 * 二次校对 --- source/chapter3/07_Attributes.md | 170 +++++++++++++++++++++++-------- 1 file changed, 126 insertions(+), 44 deletions(-) diff --git a/source/chapter3/07_Attributes.md b/source/chapter3/07_Attributes.md index 3166d464..7bc8d6e8 100755 --- a/source/chapter3/07_Attributes.md +++ b/source/chapter3/07_Attributes.md @@ -45,7 +45,7 @@ `deprecated`: `版本号` -可选的*版本号*由一个或多个正整数构成，由句点分隔的。省略版本号表示该声明目前已弃用，当弃用出现时没有给出任何有关信息。如果你省略了版本号，冒号（`:`）也可省略。 +可选的*版本号*由一个或多个正整数构成，由句点分隔的。省略版本号表示该声明目前已弃用，而不提供有关弃用发生时间的任何信息。如果你省略了版本号，冒号（`:`）也可省略。 - `obsoleted` 参数表示指定平台或语言从哪一版本开始废弃该声明。当一个声明被废弃后，它就从平台或语言中移除，不能再被使用。格式如下： @@ -53,19 +53,19 @@ *版本号*由一至三个正整数构成，由句点分隔的。 -- `message` 参数用来提供文本信息。当使用被弃用或者被废弃的声明时，编译器会抛出警告或错误信息。格式如下： +- `message` 参数用来提供文本信息。当使用被弃用或者被废弃的声明时，编译器会抛出该信息作为警告或错误。格式如下： `message`: `信息内容` _信息内容_由一个字符串构成。 -- `renamed` 参数用来提供文本信息，用以表示被重命名的声明的新名字。当使用声明的旧名字时，编译器会报错提示新名字。格式如下： +- `renamed` 参数用来提供文本信息，用以表示被重命名声明的新名字。当使用声明的旧名字时，编译器会报错并提示新名字。格式如下： `renamed`: `新名字` _新名字_由一个字符串构成。 -你可以将 `renamed` 参数和 `unavailable` 参数用于 `available` 特性，来表示声明在不同平台和 Swift 版本上的可用性。如下所示，表示声明的名字在一个框架或者库的不同发布版本间发生了变化。以此组合表示该声明被重命名的编译错误。 +你可以将带有 `renamed` 和 `unavailable` 参数的 `available` 特性应用于类型别名声明，如下所示，来表明框架和库发行版本之间的声明名称已经被更改。这个组合会导致声明已重命名的编译时错误。 ```swift // 首发版本 @@ -83,15 +83,15 @@ protocol MyRenamedProtocol { typealias MyProtocol = MyRenamedProtocol ``` -你可以在某个声明上使用多个 `available` 特性，以指定该声明在不同平台和 Swift 版本上的可用性。编译器只有在与 `available` 特性中指定的平台或语言版本匹配时，才会使用 `available` 特性。 +你可以在某个声明上使用多个 `available` 特性，以指定该声明在不同平台和 Swift 版本上的可用性。如果当前目标与 `available` 特性中指定的平台或语言版本不匹配时，该声明将会被忽略。如果你使用了多个 `available` 特性，则最终效果是平台和 Swift 可用性的组合。 -如果 `available` 特性除了平台名称参数外，只指定了一个 `introduced` 参数，那么可以使用以下简写语法代替： +如果 `available` 特性除了平台名称或者语言版本参数之外，只指定了一个 `introduced` 参数，那么可以使用以下简写语法代替： @available(`平台名称` `版本号`, *) @available(swift `版本号`) -`available` 特性的简写语法可以简明地表达出声明在多个平台上的可用性。尽管这两种形式在功能上是相同的，但请尽可能地使用简写语法形式。 +`available` 特性的简写语法简洁的表示了多个平台的可用性。尽管这两种形式在功能上是相同的，但请尽可能地使用简写语法形式。 ```swift @available(iOS 10.0, macOS 10.12, *) @@ -100,7 +100,7 @@ class MyClass { } ``` -当 `available` 特性需要同时指定 Swift 版本和平台可用性，需要使用单独的 `available` 特性来声明。 +当需要同时指定 Swift 版本和平台可用性，需要使用一个单独的 `available` 特性来指明 Swift 版本，以及一个或者多个 `available` 特性来声明平台可用性。 ```swift @available(swift 3.0.2) @@ -112,7 +112,7 @@ struct MyStruct { ### `discardableResult` {#discardableresult} -该特性用于的函数或方法声明，以抑制编译器中函数或方法的返回值被调而没有使用其结果的警告。 +该特性用于的函数或方法声明，以抑制编译器中函数或方法被调用而其返回值没有被使用时的警告。 ### `dynamicCallable` {#dynamiccallable} @@ -147,6 +147,8 @@ dial.dynamicallyCall(withArguments: [4, 1, 1]) `dynamicallyCall(withArguments:)` 方法的声明必须至少有一个参数遵循 [`ExpressibleByArrayLiteral`](https://developer.apple.com/documentation/swift/expressiblebyarrayliteral) 协议，如 `[Int]`，而返回值类型可以是任意类型。 +如果实现 `dynamicallyCall(withKeywordArguments:)` 方法，则可以在动态方法调用中包含标签。 + ```swift @dynamicCallable struct Repeater { @@ -168,7 +170,7 @@ print(repeatLabels(a: 1, b: 2, c: 3, b: 2, a: 1)) // a ``` -`dynamicallyCall(withKeywordArguments:)` 方法声明必须至少有一个参数遵循 [`ExpressibleByDictionaryLiteral`](https://developer.apple.com/documentation/swift/expressiblebydictionaryliteral) 协议，返回值可以任意类型。参数的 [`Key`](https://developer.apple.com/documentation/swift/expressiblebydictionaryliteral/2294108-key) 必须遵循 [`ExpressibleByStringLiteral`](https://developer.apple.com/documentation/swift/expressiblebystringliteral) 协议。上述的示例使用 [`KeyValuePairs`](https://developer.apple.com/documentation/swift/keyvaluepairs) 作为参数类型，以便调用者可以传入重复的参数标签，`a` 和 `b` 在调用 `repeat`中多次使用。 +`dynamicallyCall(withKeywordArguments:)` 方法声明必须只有一个遵循 [`ExpressibleByDictionaryLiteral`](https://developer.apple.com/documentation/swift/expressiblebydictionaryliteral) 协议的参数，返回值可以任意类型。参数的 [`Key`](https://developer.apple.com/documentation/swift/expressiblebydictionaryliteral/2294108-key) 必须遵循 [`ExpressibleByStringLiteral`](https://developer.apple.com/documentation/swift/expressiblebystringliteral) 协议。上述的示例使用 [`KeyValuePairs`](https://developer.apple.com/documentation/swift/keyvaluepairs) 作为参数类型，以便调用者可以传入重复的参数标签，`a` 和 `b` 在调用 `repeat`中多次使用。 如果你同时实现两种 `dynamicallyCall` 方法，则当在方法调用中包含关键字参数时，会调用 `dynamicallyCall(withKeywordArguments:)` 方法，否则调用 `dynamicallyCall(withArguments:)` 方法。 @@ -182,11 +184,11 @@ repeatLabels(a: "four") // Error 该特性用于类、结构体、枚举或协议，让其能在运行时查找成员。该类型必须实现 `subscript(dynamicMemberLookup:)` 下标。 -在显式成员表达式中，如果没有成名指定成员，则该表达式被理解为对该类型的 `subscript(dynamicMemberLookup:)` 下标的调用，传递包含成员名称字符串的参数。下标接收参数既可以是键路径，也可以是成员名称字符串；如果你同时实现这两种方式的下标调用，那么以键路径参数方式为准。 +在显式成员表达式中，如果指定成员没有相应的声明，则该表达式被理解为对该类型的 `subscript(dynamicMemberLookup:)` 下标调用，将有关该成员的信息作为参数传递。下标接收参数既可以是键路径，也可以是成员名称字符串；如果你同时实现这两种方式的下标调用，那么以键路径参数方式为准。 - `subscript(dynamicMemberLookup:)` 实现允许接收 [`KeyPath`](https://developer.apple.com/documentation/swift/keypath)，[`WritableKeyPath`](https://developer.apple.com/documentation/swift/writablekeypath) 或 [`ReferenceWritableKeyPath`](https://developer.apple.com/documentation/swift/referencewritablekeypath) 类型的键路径参数。而遵循 [`ExpressibleByStringLiteral`](https://developer.apple.com/documentation/swift/expressiblebystringliteral) 协议，下标调用接收参数为成员名称字符串 —— 在大多数情况下，下标的参数是一个 `String` 值。下标返回值类型可以为任意类型。 + `subscript(dynamicMemberLookup:)` 实现允许接收 [`KeyPath`](https://developer.apple.com/documentation/swift/keypath)，[`WritableKeyPath`](https://developer.apple.com/documentation/swift/writablekeypath) 或 [`ReferenceWritableKeyPath`](https://developer.apple.com/documentation/swift/referencewritablekeypath) 类型的键路径参数。它可以使用遵循 [`ExpressibleByStringLiteral`](https://developer.apple.com/documentation/swift/expressiblebystringliteral) 协议的类型作为参数来接受成员名 -- 通常情况下是 `String`。下标返回值类型可以为任意类型。 -根据成员名称来动态地查找成员，可以帮助我们创建一个包裹数据的包装类型，但该类型无法在编译时进行类型检查，例如其他语言的数据桥接到 Swift 语言时。例如： +按成员名进行的动态成员查找可用于围绕编译时无法进行类型检查的数据创建包装类型，例如在将其他语言的数据桥接到 `Swift` 时。例如： ```swift @dynamicMemberLookup @@ -210,7 +212,7 @@ print(dynamic == equivalent) // 打印“true” ``` -根据键路径来动态地查找成员，可用于创建一个包裹数据的包装类型，该类型在编译时期进行类型检查。例如： +根据键路径来动态地查找成员，可用于创建一个包裹数据的包装类型，该类型支持在编译时期进行类型检查。例如： ```swift struct Point { var x, y: Int } @@ -228,9 +230,24 @@ let wrapper = PassthroughWrapper(value: point) print(wrapper.x) ``` +### `frozen` {#frozen} + +针对枚举或者结构体的声明使用该特性，可以限制你对该类型的修改。它只有在编译迭代库时被允许使用。未来版本的库不能通过添加、删除或重新排序枚举的 case 或结构的存储实例属性来更改声明。在未冻结的类型上，这些操作都是允许的，但是他们破坏了冻结类型的 ABI 兼容性。 + +> 注意 +> 当编译器不处于迭代库的模式，所有的结构体和枚举都是隐性冻结，并且你不能使用该特性。 + +在迭代库的模式中，与未冻结结构体和枚举的成员进行交互的代码在被编译时，允许它在不重新编译的情况下继续工作，即使在新版本的库中添加、删除或重新排序该类型的成员。编译器用类似运行时查找信息和添加间接层的技术使之可能。将一个枚举或者结构体标记为冻结将以放弃这种灵活性为代价来获取性能上的提升：未来版本的库只能对类型进行有限的更改，但编译器可以对与类型成员交互的代码进行额外的优化。 + +使用冻结类型，结构体存储属性的类型以及枚举 case 的关联值必须是 `public` 或使用 `usablefrominline` 特性标记。冻结结构体的属性不能有属性观察器，为存储实例属性提供初始值的表达式必须遵循与 `inlinable` 函数相同的限制，如 [`inlinable`](#inlinable) 中所述。 + +要在命令行上启用迭代库模式，请将 `-enable-library-evolution` 选项传递给 Swift 编译器。要在 Xcode 中支持它，则将生成设置 “Build Libraries for Distribution”（`BUILD_LIBRARY_FOR_DISTRIBUTION`）设置为 Yes，详情查看 [`Xcode 帮助文档`](https://help.apple.com/xcode/mac/current/#/dev04b3a04ba)。 + +针对冻结枚举的 switch 语法，不需要 `default` case，就像 [`对未来枚举的 case 进行 switch`](./05_Statements.md#future-case)。在针对冻结枚举使用 switch 语法时包含 `default` 或 `@unknown default` case 将生成警告，因为该代码永远不会执行。 + ### `GKInspectable` {#gkinspectable} -应用此属性，暴露一个自定义 GameplayKit 组件属性给 SpriteKit 编辑器 UI。 +应用此特性可将自定义 GameplayKit 组件属性公开到 SpriteKit 编辑器 UI。应用此特性同时表示应用了 `objc` 特性。 ### `inlinable` {#inlinable} @@ -238,11 +255,11 @@ print(wrapper.x) 内联代码可以与任意模块中 `public` 访问级别的符号进行交互，同时可以与在相同模块中标记 `usableFromInline` 特性的 `internal` 访问级别的符号进行交互。内联代码不能与 `private` 或 `fileprivate` 级别的符号进行交互。 -该特性不能用于嵌套在函数内的声明，也不能用于 `fileprivate` 或 `private` 访问级别的声明。在内联函数定义的函数和闭包是隐式非内联的，即使他们不能标记该特性。 +该特性不能用于嵌套在函数内的声明，也不能用于 `fileprivate` 或 `private` 访问级别的声明。在内联函数内定义的函数和闭包都是隐式内联的，即使他们不能标记该特性。 ### `nonobjc` {#nonobjc} -该特性用于方法、属性、下标、或构造器的声明，这些声明本可以在 Objective-C 代码中使用，而使用 `nonobjc` 特性则告诉编译器这个声明不能在 Objective-C 代码中使用。 +针对方法、属性、下标、或构造器的声明使用该特性将覆盖隐式的 `objc` 特性。`nonobjc` 特性告诉编译器该声明不能在 Objective-C 代码中使用，即便它能在 Objective-C 中表示。 该特性用在扩展中，与在没有明确标记为 `objc` 特性的扩展中给每个成员添加该特性具有相同效果。 @@ -252,9 +269,9 @@ print(wrapper.x) ### `NSApplicationMain` {#nsapplicationmain} -在类上使用该特性表示该类是应用程序委托类，使用该特性与调用 `NSApplicationMain(_:_:)` 函数并且把该类的名字作为委托类的名字传递给函数的效果相同。 +在类上使用该特性表示该类是应用程序委托类。使用该特性与调用 `NSApplicationMain(_:_:)` 函数的效果相同。 -如果你不想使用这个特性，可以提供一个 `main.swift` 文件，并在代码**顶层**调用 `NSApplicationMain(_:_:)` 函数，如下所示: +如果你不想使用这个特性，可以提供一个 `main.swift` 文件，并在代码顶层调用 `NSApplicationMain(_:_:)` 函数，如下所示: ```swift import AppKit @@ -263,9 +280,9 @@ NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv) ### `NSCopying` {#nscopying} -该特性用于修饰一个类的存储型变量属性。该特性将使属性的设值方法使用传入值的副本进行赋值，这个值由传入值的 `copyWithZone(_:)` 方法返回。该属性的类型必需符合 `NSCopying` 协议。 +该特性用于修饰一个类的存储型变量属性。该特性将使属性的设值方法使用传入值的`副本`进行赋值，这个值由传入值的 `copyWithZone(_:)` 方法返回，而不是传入值本身。该属性的类型必需符合 `NSCopying` 协议。 -`NSCopying` 特性的行为与 Objective-C 中的 `copy` 特性相似。 +`NSCopying` 特性的行为与 Objective-C 中的 `copy` 属性特性相似。 ### `NSManaged` {#nsmanaged} @@ -273,21 +290,21 @@ NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv) ### `objc` {#objc} -该特性用于修饰任何可以在 Objective-C 中表示的声明。比如，非嵌套类、协议、非泛型枚举（仅限原始值为整型的枚举）、类和协议中的属性和方法（包括存取方法）、构造器、析构器以及下标运算符。`objc` 特性告诉编译器这个声明可以在 Objective-C 代码中使用。 +该特性用于修饰任何可以在 Objective-C 中表示的声明。比如，非嵌套类、协议、非泛型枚举（仅限原始值为整型的枚举）、类的属性和方法（包括存取方法）、协议以及协议中的可选成员、构造器以及下标运算符。`objc` 特性告诉编译器这个声明可以在 Objective-C 代码中使用。 该特性用在扩展中，与在没有明确标记为 `nonobjc` 特性的扩展中给每个成员添加该特性具有相同效果。 编译器隐式地将 `objc` 特性添加到 Objective-C 中定义的任何类的子类。但是，子类不能是泛型的，并且不能继承于任何泛型类。你可以将 `objc` 特性显式添加到满足这些条件的子类，来指定其 Objective-C 名称，如下所述。添加了 `objc` 的协议不能继承于没有此特性的协议。 -在以下情况中隐式添加了 `objc` 特性。 +在以下情况中同样会隐式的添加 `objc` 特性： - 父类有 `objc` 特性，且重写为子类的声明。 - 遵循带有 `objc` 特性协议的声明。 -- 带有 `IBAction`、 `IBSegueAction` 、 `IBOutlet` 、 `IBDesignable` 、 `IBInspectable` 、 `NSManaged` 或 `GKInspectable` 特性的声明。 +- 带有 `IBAction`、`IBSegueAction`、`IBOutlet`、`IBDesignable`、`IBInspectable`、`NSManaged` 或 `GKInspectable` 特性的声明。 -如果你将 `objc` 特性应用于枚举，每一个枚举用例都会以枚举名称和用例名称组合的方式暴露在 Objective-C 代码中。例如，在 `Planet` 枚举中有一个名为 `Venus` 的用例，该用例暴露在 Objective-C 代码中时叫做 `PlanetVenus`。 +如果你将 `objc` 特性应用于枚举，每一个枚举 case 都会以枚举名称和 case 名称组合的方式暴露在 Objective-C 代码中。实例名称的首字母大写。例如，在 Swift 枚举类型 `Planet` 中有一个名为 `Venus` 的 case，该 case 暴露在 Objective-C 代码中时叫做 `PlanetVenus`。 -`objc` 特性有一个可选的参数，由标识符构成。当你想把 `objc` 所修饰的实体以一个不同的名字暴露给 Objective-C 时，你就可以使用这个特性参数。你可以使用这个参数来命名类、枚举类型、枚举用例、协议、方法、存取方法以及构造器。如果你要指定类、协议或枚举在 Objective-C 下的名称，在名称上包含三个字母的前缀，如 [Objective-C 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011210) 中的 [约定](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.html#//apple_ref/doc/uid/TP40011210-CH10-SW1)。下面的例子把 `ExampleClass` 中的 `enabled` 属性的取值方法暴露给 Objective-C，名字是 `isEnabled`，而不是它原来的属性名。 +`objc` 特性可以接受一个可选的特性参数，由标识符构成。当你想把 `objc` 所修饰的实体以一个不同的名字暴露给 Objective-C 时，你就可以使用这个特性参数。你可以使用这个参数来命名类、枚举类型、枚举 case、协议、方法、存取方法以及构造器。如果你要指定类、协议或枚举在 Objective-C 下的名称，请在名称上包含三个字母的前缀，就像 [Objective-C 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011210) 中的 [约定](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.html#//apple_ref/doc/uid/TP40011210-CH10-SW1)描述的一样。下面的例子把 `ExampleClass` 中的 `enabled` 属性的取值方法暴露给 Objective-C，名字是 `isEnabled`，而不是它原来的属性名。 ```swift class ExampleClass: NSObject { @@ -305,41 +322,106 @@ class ExampleClass: NSObject { 大多数代码应该使用 `objc` 特性，以暴露所需的声明。如果需要暴露多个声明，可以将其分组到添加 `objc` 特性的扩展中。`objcMembers` 特性为大量使用 Objective-C 运行时的内省工具的库提供了便利。添加不必要的 `objc` 特性会增加二进制体积并影响性能。 +### `propertyWrapper` {#propertywrapper} + +在类、结构体或者枚举的声明时使用该特性，可以让其成为一个属性包装器。如果将该特性应用在一个类型上，将会创建一个与该类型同名的自定义特性。将这个新的特性用于类、结构体、枚举的属性，则可以通过包装器的实例封装对该属性的访问。局部和全局变量不能使用属性包装器。 + +包装器必须定义一个 `wrappedValue` 实例属性。该属性 _wrapped value_ 是该属性存取方法暴露的值。大多数时候，`wrappedValue` 是一个计算属性，但它可以是一个存储属性。包装器负责定义和管理其包装值所需的任何底层存储。编译器通过在包装属性的名称前加下划线（`_`）来为包装器的实例提供同步存储。例如，`someProperty` 的包装器存储为 `_someProperty`。包装器的同步存储具有 `private` 的访问控制级别。 + +拥有属性包装器的属性可以包含 `willSet` 和 `didSet` 闭包，但是不能重写编译器合成的 `get` 和 `set` 闭包。 + +Swift 为属性包装器的构造函数提供了两种形式的语法糖。可以在包装值的定义中使用赋值语法，将赋值语句右侧的表达式作为值传递给属性包装器构造函数中的 `wrappedValue` 参数。同样的，你也可以为包装器提供一些参数，这些参数将会传递给包装器的构造函数。就像下面的例子，`SomeStruct` 中，定义 `SomeWrapper` 的地方各自调用了对应的构造函数。 + +```swift +@propertyWrapper +struct SomeWrapper { + var wrappedValue: Int + var someValue: Double + init() { + self.wrappedValue = 100 + self.someValue = 12.3 + } + init(wrappedValue: Int) { + self.wrappedValue = wrappedValue + self.someValue = 45.6 + } + init(wrappedValue value: Int, custom: Double) { + self.wrappedValue = value + self.someValue = custom + } +} + +struct SomeStruct { + // 使用 init() + @SomeWrapper var a: Int + + // 使用 init(wrappedValue:) + @SomeWrapper var b = 10 + + // 两个都是使用 init(wrappedValue:custom:) + @SomeWrapper(custom: 98.7) var c = 30 + @SomeWrapper(wrappedValue: 30, custom: 98.7) var d +} +``` + +属性包装器中 _projected value_ 是它可以用来暴露额外功能的第二个值。属性包装器的作者负责确认其映射值的含义并定义公开映射值的接口。若要通过属性包装器来映射值，请在包装器的类型上定义 `projectedValue` 实例属性。编译器通过在包装属性的名称前面加上美元符号（`$`）来合成映射值的标识符。例如，`someProperty` 的映射值是 `$someProperty`。映射值具有与原始包装属性相同的访问控制级别。 + +```swift +@propertyWrapper +struct WrapperWithProjection { + var wrappedValue: Int + var projectedValue: SomeProjection { + return SomeProjection(wrapper: self) + } +} +struct SomeProjection { + var wrapper: WrapperWithProjection +} + +struct SomeStruct { + @WrapperWithProjection var x = 123 +} +let s = SomeStruct() +s.x // Int value +s.$x // SomeProjection value +s.$x.wrapper // WrapperWithProjection value +``` + ### `requires_stored_property_inits` {#requires-stored-property-inits} 该特性用于类声明，以要求类中所有存储属性提供默认值作为其定义的一部分。对于从中继承的任何类都推断出 `NSManagedObject` 特性。 ### `testable` {#testable} -在导入允许测试的编译模块时，该特性用于修饰 `import` 声明，这样就能访问被导入模块中的任何标有 `internal` 访问级别修饰符的实体，犹如它们被标记了 `public` 访问级别修饰符。测试也可以访问使用 `internal` 或者 `public` 访问级别修饰符标记的类和类成员，就像它们是 `open` 访问修饰符声明的。 +将此特性应用于 `import` 声明以导入该模块，并更改其访问控制以简化对该模块代码的测试。这样就能访问被导入模块中的任何标有 `internal` 访问级别修饰符的实体，犹如它们被标记了 `public` 访问级别修饰符。测试也可以访问使用 `internal` 或者 `public` 访问级别修饰符标记的类和类成员，就像它们是 `open` 访问修饰符声明的。被导入的模块必须以允许测试的方式编译。 ### `UIApplicationMain` {#uiapplicationmain} -在类上使用该特性表示该类是应用程序委托类，使用该特性与调用 `UIApplicationMain` 函数并且把该类的名字作为委托类的名字传递给函数的效果相同。 +在类上使用该特性表示该类是应用程序委托类。使用该特性与调用 `UIApplicationMain` 函数并且把该类的名字作为委托类的名字传递给函数的效果相同。 -如果你不想使用这个特性，可以提供一个 `main.swift` 文件，并在代码顶层调用 `UIApplicationMain(_:_:_:_:)` 函数。比如，如果你的应用程序使用一个继承于 UIApplication 的自定义子类作为主要类，你可以调用 `UIApplicationMain(_:_:_:_:)` 函数而不是使用该特性。 +如果你不想使用这个特性，可以提供一个 `main.swift` 文件，并在代码顶层调用 `UIApplicationMain(_:_:_:_:)` 函数。比如，如果你的应用程序使用一个继承于 `UIApplication` 的自定义子类作为主要类，你可以调用 `UIApplicationMain(_:_:_:_:)` 函数而不是使用该特性。 ### `usableFromInline` {#usablefrominline} -该特性用于函数、方法、计算属性、下标、构造器或析构器的声明，以在同一模块中允许该符号用于内联代码的声明。声明必须具有 `internal` 访问级别修饰符。 +该特性用于函数、方法、计算属性、下标、构造器或析构器的声明，以在同一模块中允许该符号用于内联代码的声明。声明必须具有 `internal` 访问级别修饰符。被标记为 `usableFromInline` 的结构体或类它们属性的类型只能是被标记为 public 或者 `usableFromInline` 的类型。被标记为 `usableFromInline` 的枚举，它 case 的真实值或者关联类型只能是被标记为 public 或者 `usableFromInline` 的类型。 -与 `public` 访问修饰符相同的是，该特性将声明公开为模块公共接口的一部分。区别于 `public`，编译器不允许在模块外部的代码通过名称引用 `usableFromInline` 标记的声明，即使导出了声明符号也是无法引用。但是，模块外的代码仍然可以通过运行时交换声明符号。 +与 `public` 访问修饰符相同的是，该特性将声明公开为模块公共接口的一部分。区别于 `public`，编译器不允许在模块外部的代码通过名称引用 `usableFromInline` 标记的声明，即使导出了声明符号也无法引用。但是，模块外的代码仍然可以通过运行时与声明符号进行交互。 标记为 `inlinable` 特性的声明，在内联代码中可以隐式使用。虽然 `inlinable` 或 `usableFromInline` 可以用于 `internal` 声明，但这两者不能同时使用。 ### `warn_unqualified_access` {#warn-unqualified-access} -该特性应用于顶级函数、实例方法、类方法或静态方法，以在没有前置限定符（例如模块名称、类型名称、实例变量或常量）的情况下使用该函数或方法时触发警告。使用该特性可以帮助减少在同一作用于访问同名函数之间的歧义。 +该特性应用于顶级函数、实例方法、类方法或静态方法，以在没有前置限定符（例如模块名称、类型名称、实例变量或常量）的情况下使用该函数或方法时触发警告。使用该特性可以减少在同一作用域里访问的同名函数之间的歧义。 -例如，Swift 标准库包含 [`min(_:_:)`](https://developer.apple.com/documentation/swift/1538339-min/) 顶级函数和用于序列比较元素的 [`min()`](https://developer.apple.com/documentation/swift/sequence/1641174-min) 方法。序列方法声明使用了 `warn_unqualified_access`，以减少在 `Sequence` 扩展中使用它们的歧义。 +例如，Swift 标准库包含 [`min(_:_:)`](https://developer.apple.com/documentation/swift/1538339-min/) 顶级函数和用于序列比较元素的 [`min()`](https://developer.apple.com/documentation/swift/sequence/1641174-min) 方法。序列方法声明使用了 `warn_unqualified_access`，以减少在 `Sequence` 扩展中使用它们的歧义。 ### Interface Builder 使用的声明特性 {#declaration-attributes-used-by-interface-builder} -`Interface Builder` 特性是 `Interface Builder` 用来与 Xcode 同步的声明特性。`Swift` 提供了以下的 `Interface Builder` 特性：`IBAction`，`IBSegueAction`，`IBOutlet`，`IBDesignable`，以及 `IBInspectable` 。这些特性与 Objective-C 中对应的特性在概念上是相同的。 +Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特性。Swift 提供了以下的 Interface Builder 特性：`IBAction`，`IBSegueAction`，`IBOutlet`，`IBDesignable`，以及 `IBInspectable`。这些特性与 Objective-C 中对应的特性在概念上是相同的。 -`IBOutlet` 和 `IBInspectable` 用于修饰一个类的属性声明，`IBAction` 特性用于修饰一个类的方法声明，`IBDesignable` 用于修饰类的声明。 +`IBOutlet` 和 `IBInspectable` 用于修饰一个类的属性声明。`IBAction` 和 `IBSegueAction` 特性用于修饰一个类的方法声明，`IBDesignable` 用于修饰类的声明。 -应用 `IBAction`、`IBSegueAction`、`IBOutlet`、`IBDesignable` 或者 `IBInspectable` 特性都意味着同时应用 `objc` 特性。 +应用 `IBAction`、`IBSegueAction`、`IBOutlet`、`IBDesignable` 或者 `IBInspectable` 特性都意味着同时应用 `objc` 特性。 ## 类型特性 {#type-attributes} @@ -347,33 +429,33 @@ class ExampleClass: NSObject { ### `autoclosure` {#autoclosure} -这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 autoclosure 特性的例子，请参阅 [自动闭包](../chapter2/07_Closures.md#autoclosures) 和 [函数类型](./03_Types.md#function_type)。 +这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 `autoclosure` 特性的例子，请参阅 [自动闭包](../chapter2/07_Closures.md#autoclosures) 和 [函数类型](./03_Types.md#function_type)。 ### `convention` {#convention} 该特性用于修饰函数类型，它指出了函数调用的约定。 -convention 特性总是与下面的参数之一一起出现。 +`convention` 特性总是与下面的参数之一一起出现。 - `swift` 参数用于表示一个 Swift 函数引用。这是 Swift 中函数值的标准调用约定。 - `block` 参数用于表示一个 Objective-C 兼容的块引用。函数值会作为一个块对象的引用，块是一种 `id` 兼容的 Objective-C 对象，其中嵌入了调用函数。调用函数使用 C 的调用约定。 -- `c` 参数用于表示一个 C 函数引用。函数值没有上下文，不具备捕获功能，同样使用 C 的调用约定。 +- `c` 参数用于表示一个 C 函数引用。函数值没有上下文，不具备捕获功能，并且使用 C 的调用约定。 -使用 C 函数调用约定的函数也可用作使用 Objective-C 块调用约定的函数，同时使用 Objective-C 块调用约定的函数也可用作使用 Swift 函数调用约定的函数。然而，只有非泛型的全局函数、局部函数以及未捕获任何局部变量的闭包，才可以被用作使用 C 函数调用约定的函数。 +除了少数例外，当函数需要任何其他调用约定时，可以转换成任意调用约定的函数。非范型全局函数、不捕获任何局部变量的局部函数或不捕获任何局部变量的闭包可以转换为 C 调用约定。其余的 Swift 函数不能转换成 C 调用约定。一个 Objective-C 块调用约定的函数不能转换成 C 调用约定。 ### `escaping` {#escaping} -在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行，这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 声明特性的函数类型中访问属性和方法时不需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../chapter2/07_Closures.md#escaping_closures)。 +在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行。这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 特性声明的函数类型中访问属性和方法时需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../chapter2/07_Closures.md#escaping_closures)。 ## Switch Case 特性 {#switch-case-attributes} -你只能在 switch cases 中使用 switch case 特性。 +你只能在 switch cases 语句中使用 switch case 特性。 ### `unknown` {#unknown} -次特性用于 switch case，表示在编译时该地方不会匹配枚举的任何情况。有关如何使用 `unknown` 特性的示例，可参阅 [对未来枚举的 `case` 进行 `switch`](./05_Statements.md#future-case)。 +该特性用于 switch case，用于没有匹配上代码编译时已知 case 的情况。有关如何使用 `unknown` 特性的示例，可参阅 [对未来枚举的 `case` 进行 `switch`](./05_Statements.md#future-case)。 > 特性语法 > @@ -381,7 +463,7 @@ convention 特性总是与下面的参数之一一起出现。 > #### attribute {#attribute} > -> *特性*→ [特性名](#attribute_name) [特性参数子句](#atribute_argument_clause)可选 +> *特性* → @ [特性名](#attribute_name) [特性参数子句](#atribute_argument_clause)可选 > > #### attribute_name {#attribute-name} From 8f53cc7d82eb8966e998dabc8d610b834e50178a Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Wed, 9 Oct 2019 11:36:24 -0500 Subject: [PATCH 22/36] fix wrong translation, ref #1003 --- source/chapter2/01_The_Basics.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md index f124536e..fe4bf259 100755 --- a/source/chapter2/01_The_Basics.md +++ b/source/chapter2/01_The_Basics.md @@ -589,7 +589,7 @@ if let actualNumber = Int(possibleNumber) { 你可以在可选绑定中使用常量和变量。如果你想在 `if` 语句的第一个分支中操作 `actualNumber` 的值，你可以改成 `if var actualNumber`，这样可选类型包含的值就会被赋给一个变量而非常量。 -你可以包含多个可选绑定或多个布尔条件在一个 `if` 语句中，只要使用逗号分开就行。只要有任意一个可选绑定的值为 `nil`，或者任意一个布尔条件为 `false`，则整个 `if` 条件判断为 `false`，这时你就需要使用嵌套 `if` 条件语句来处理，如下所示： +你可以包含多个可选绑定或多个布尔条件在一个 `if` 语句中，只要使用逗号分开就行。只要有任意一个可选绑定的值为 `nil`，或者任意一个布尔条件为 `false`，则整个 `if` 条件判断为 `false`。下面的两个 `if` 语句是等价的： ```swift if let firstNumber = Int("4"), let secondNumber = Int("42"), firstNumber < secondNumber && secondNumber < 100 { From 4dcdd13e748a9ff1e4fc5503b15219b52368b855 Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Wed, 9 Oct 2019 11:38:51 -0500 Subject: [PATCH 23/36] use english punctuation, ref #1004 --- source/chapter2/03_Strings_and_Characters.md | 4 ++-- source/chapter3/04_Expressions.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md index 731b3384..26bf3168 100755 --- a/source/chapter2/03_Strings_and_Characters.md +++ b/source/chapter2/03_Strings_and_Characters.md @@ -106,9 +106,9 @@ Escaping all three quotes \"\"\" ### 扩展字符串分隔符 {#extended-string-delimiters} -您可以将字符串文字放在扩展分隔符中，这样字符串中的特殊字符将会被直接包含而非转义后的效果。将字符串放在引号（`"`）中并用数字符号（`＃`）括起来。例如，打印字符串文字 `＃"Line 1 \nLine 2"＃` 会打印换行符转义序列（`\n`）而不是给文字换行。 +您可以将字符串文字放在扩展分隔符中，这样字符串中的特殊字符将会被直接包含而非转义后的效果。将字符串放在引号（`"`）中并用数字符号（`#`）括起来。例如，打印字符串文字 `#"Line 1 \nLine 2"#` 会打印换行符转义序列（`\n`）而不是给文字换行。 -如果需要字符串文字中字符的特殊效果，请匹配转义字符（`\`）后面添加与起始位置个数相匹配的 `#` 符。 例如，如果您的字符串是 `＃"Line 1 \nLine 2"＃` 并且您想要换行，则可以使用 `＃“Line 1 \#nLine 2”＃` 来代替。 同样，`###"Line1 \###nLine2"###` 也可以实现换行效果。 +如果需要字符串文字中字符的特殊效果，请匹配转义字符（`\`）后面添加与起始位置个数相匹配的 `#` 符。 例如，如果您的字符串是 `#"Line 1 \nLine 2"#` 并且您想要换行，则可以使用 `#"Line 1 \#nLine 2"#` 来代替。 同样，`###"Line1 \###nLine2"###` 也可以实现换行效果。 扩展分隔符创建的字符串文字也可以是多行字符串文字。 您可以使用扩展分隔符在多行字符串中包含文本 `"""`，覆盖原有的结束文字的默认行为。例如： diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md index 586d57d8..79b2c79d 100644 --- a/source/chapter3/04_Expressions.md +++ b/source/chapter3/04_Expressions.md @@ -237,7 +237,7 @@ f(x as Any) `#function` | `String` | 所在的声明的名字 -对于 `＃function`，在函数中会返回当前函数的名字，在方法中会返回当前方法的名字，在属性的存取器中会返回属性的名字，在特殊的成员如 `init` 或 `subscript` 中会返回这个关键字的名字，在某个文件中会返回当前模块的名字。 +对于 `#function`，在函数中会返回当前函数的名字，在方法中会返回当前方法的名字，在属性的存取器中会返回属性的名字，在特殊的成员如 `init` 或 `subscript` 中会返回这个关键字的名字，在某个文件中会返回当前模块的名字。 当其作为函数或者方法的默认参数值时，该字面量的值取决于函数或方法的调用环境。 From 028a6aa79546abc6a395e865c6667b600bdd7e38 Mon Sep 17 00:00:00 2001 From: Licardo <1014660822@qq.com> Date: Fri, 11 Oct 2019 03:00:57 +0800 Subject: [PATCH 24/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=96=87=E6=A1=A3?= =?UTF-8?q?=E5=90=8D=E7=A7=B0=E5=8F=8A=E9=A1=BA=E5=BA=8F=EF=BC=8C=E4=B8=8E?= =?UTF-8?q?=E5=AE=98=E6=96=B9=E6=96=87=E6=A1=A3=E4=BF=9D=E6=8C=81=E4=B8=80?= =?UTF-8?q?=E8=87=B4=20(#1005)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../01_about_swift.md | 0 .../02_version_compatibility.md | 0 .../03_a_swift_tour.md | 2 +- .../chapter1.md | 0 .../01_The_Basics.md | 2 +- .../02_Basic_Operators.md | 6 +- .../03_Strings_and_Characters.md | 0 .../04_Collection_Types.md | 0 .../05_Control_Flow.md | 2 +- .../06_Functions.md | 0 .../07_Closures.md | 4 +- .../08_Enumerations.md | 2 +- .../09_Structures_And_Classes.md | 4 +- .../10_Properties.md | 2 +- .../11_Methods.md | 2 +- .../12_Subscripts.md | 0 .../13_Inheritance.md | 2 +- .../14_Initialization.md | 0 .../15_Deinitialization.md | 2 +- .../16_Optional_Chaining.md | 0 .../17_Error_Handling.md | 2 +- .../18_Type_Casting.md | 0 .../19_Nested_Types.md | 0 .../20_Extensions.md | 0 .../21_Protocols.md | 2 +- .../22_Generics.md | 0 .../23_Opaque_Types.md} | 0 .../24_Automatic_Reference_Counting.md} | 2 +- .../25_Memory_Safety.md} | 0 .../26_Access_Control.md} | 0 .../27_Advanced_Operators.md} | 2 +- .../chapter2.md | 2 +- .../01_About_the_Language_Reference.md | 0 .../02_Lexical_Structure.md | 8 +- .../03_Types.md | 24 +- .../04_Expressions.md | 18 +- .../05_Statements.md | 22 +- .../06_Declarations.md | 104 +++---- .../07_Attributes.md | 4 +- .../08_Patterns.md | 4 +- .../09_Generic_Parameters_and_Arguments.md | 4 +- .../10_Summary_of_the_Grammar.md | 0 .../chapter3.md | 2 +- .../04_revision_history.md | 267 +++++++++++++++++ source/04_revision_history/chapter4.md | 3 + source/README.md | 283 ++++++++++++++++-- source/SUMMARY.md | 82 ++--- source/chapter1/04_revision_history.md | 267 ----------------- source/chapter4/chapter4.md | 0 .../01_Access_Control.md | 0 .../{chapter4 => old_files}/02_Type_Custom.md | 0 source/{chapter4 => old_files}/03_Ballons.md | 0 .../04_Interacting_with_C_Pointers.md | 0 .../05_Value_and_Reference_Types.md | 0 .../06_Access_Control_and_Protected.md | 0 .../07_Optional_Case_Study.md | 0 56 files changed, 690 insertions(+), 442 deletions(-) rename source/{chapter1 => 01_welcome_to_swift}/01_about_swift.md (100%) rename source/{chapter1 => 01_welcome_to_swift}/02_version_compatibility.md (100%) rename source/{chapter1 => 01_welcome_to_swift}/03_a_swift_tour.md (99%) rename source/{chapter1 => 01_welcome_to_swift}/chapter1.md (100%) rename source/{chapter2 => 02_language_guide}/01_The_Basics.md (99%) rename source/{chapter2 => 02_language_guide}/02_Basic_Operators.md (99%) rename source/{chapter2 => 02_language_guide}/03_Strings_and_Characters.md (100%) rename source/{chapter2 => 02_language_guide}/04_Collection_Types.md (100%) rename source/{chapter2 => 02_language_guide}/05_Control_Flow.md (99%) rename source/{chapter2 => 02_language_guide}/06_Functions.md (100%) rename source/{chapter2 => 02_language_guide}/07_Closures.md (99%) rename source/{chapter2 => 02_language_guide}/08_Enumerations.md (99%) rename source/{chapter2 => 02_language_guide}/09_Structures_And_Classes.md (99%) rename source/{chapter2 => 02_language_guide}/10_Properties.md (99%) rename source/{chapter2 => 02_language_guide}/11_Methods.md (99%) rename source/{chapter2 => 02_language_guide}/12_Subscripts.md (100%) rename source/{chapter2 => 02_language_guide}/13_Inheritance.md (99%) rename source/{chapter2 => 02_language_guide}/14_Initialization.md (100%) rename source/{chapter2 => 02_language_guide}/15_Deinitialization.md (98%) rename source/{chapter2 => 02_language_guide}/16_Optional_Chaining.md (100%) rename source/{chapter2 => 02_language_guide}/17_Error_Handling.md (99%) rename source/{chapter2 => 02_language_guide}/18_Type_Casting.md (100%) rename source/{chapter2 => 02_language_guide}/19_Nested_Types.md (100%) rename source/{chapter2 => 02_language_guide}/20_Extensions.md (100%) rename source/{chapter2 => 02_language_guide}/21_Protocols.md (99%) rename source/{chapter2 => 02_language_guide}/22_Generics.md (100%) rename source/{chapter2/27_Opaque_Types.md => 02_language_guide/23_Opaque_Types.md} (100%) rename source/{chapter2/23_Automatic_Reference_Counting.md => 02_language_guide/24_Automatic_Reference_Counting.md} (99%) rename source/{chapter2/24_Memory_Safety.md => 02_language_guide/25_Memory_Safety.md} (100%) rename source/{chapter2/25_Access_Control.md => 02_language_guide/26_Access_Control.md} (100%) rename source/{chapter2/26_Advanced_Operators.md => 02_language_guide/27_Advanced_Operators.md} (99%) rename source/{chapter2 => 02_language_guide}/chapter2.md (80%) rename source/{chapter3 => 03_language_reference}/01_About_the_Language_Reference.md (100%) rename source/{chapter3 => 03_language_reference}/02_Lexical_Structure.md (97%) rename source/{chapter3 => 03_language_reference}/03_Types.md (95%) rename source/{chapter3 => 03_language_reference}/04_Expressions.md (97%) rename source/{chapter3 => 03_language_reference}/05_Statements.md (96%) rename source/{chapter3 => 03_language_reference}/06_Declarations.md (94%) rename source/{chapter3 => 03_language_reference}/07_Attributes.md (99%) rename source/{chapter3 => 03_language_reference}/08_Patterns.md (96%) rename source/{chapter3 => 03_language_reference}/09_Generic_Parameters_and_Arguments.md (97%) rename source/{chapter3 => 03_language_reference}/10_Summary_of_the_Grammar.md (100%) rename source/{chapter3 => 03_language_reference}/chapter3.md (64%) create mode 100644 source/04_revision_history/04_revision_history.md create mode 100644 source/04_revision_history/chapter4.md delete mode 100644 source/chapter1/04_revision_history.md delete mode 100644 source/chapter4/chapter4.md rename source/{chapter4 => old_files}/01_Access_Control.md (100%) rename source/{chapter4 => old_files}/02_Type_Custom.md (100%) rename source/{chapter4 => old_files}/03_Ballons.md (100%) rename source/{chapter4 => old_files}/04_Interacting_with_C_Pointers.md (100%) rename source/{chapter4 => old_files}/05_Value_and_Reference_Types.md (100%) rename source/{chapter4 => old_files}/06_Access_Control_and_Protected.md (100%) rename source/{chapter4 => old_files}/07_Optional_Case_Study.md (100%) diff --git a/source/chapter1/01_about_swift.md b/source/01_welcome_to_swift/01_about_swift.md similarity index 100% rename from source/chapter1/01_about_swift.md rename to source/01_welcome_to_swift/01_about_swift.md diff --git a/source/chapter1/02_version_compatibility.md b/source/01_welcome_to_swift/02_version_compatibility.md similarity index 100% rename from source/chapter1/02_version_compatibility.md rename to source/01_welcome_to_swift/02_version_compatibility.md diff --git a/source/chapter1/03_a_swift_tour.md b/source/01_welcome_to_swift/03_a_swift_tour.md similarity index 99% rename from source/chapter1/03_a_swift_tour.md rename to source/01_welcome_to_swift/03_a_swift_tour.md index b918ce21..9eeeff67 100755 --- a/source/chapter1/03_a_swift_tour.md +++ b/source/01_welcome_to_swift/03_a_swift_tour.md @@ -14,7 +14,7 @@ print("Hello, world!") > > 最好的体验是把这一章作为 Playground 文件在 Xcode 中打开。 Playgrounds 允许你可以编辑代码并立刻看到输出结果。 > -> [Download Playground](https://docs.swift.org/swift-book/GuidedTour/GuidedTour.playground.zip) +> [下载 Playground](https://docs.swift.org/swift-book/GuidedTour/GuidedTour.playground.zip) ## 简单值 {#simple-values} diff --git a/source/chapter1/chapter1.md b/source/01_welcome_to_swift/chapter1.md similarity index 100% rename from source/chapter1/chapter1.md rename to source/01_welcome_to_swift/chapter1.md diff --git a/source/chapter2/01_The_Basics.md b/source/02_language_guide/01_The_Basics.md similarity index 99% rename from source/chapter2/01_The_Basics.md rename to source/02_language_guide/01_The_Basics.md index fe4bf259..1dbe16a7 100755 --- a/source/chapter2/01_The_Basics.md +++ b/source/02_language_guide/01_The_Basics.md @@ -619,7 +619,7 @@ if let firstNumber = Int("4") { 这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选类型。 -当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考 [无主引用以及隐式解析可选属性](./23_Automatic_Reference_Counting.md#unowned_references_and_implicitly_unwrapped_optional_properties)。 +当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考 [无主引用以及隐式解析可选属性](./24_Automatic_Reference_Counting.md#unowned_references_and_implicitly_unwrapped_optional_properties)。 一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型 `String` 和隐式解析可选类型 `String` 之间的区别： diff --git a/source/chapter2/02_Basic_Operators.md b/source/02_language_guide/02_Basic_Operators.md similarity index 99% rename from source/chapter2/02_Basic_Operators.md rename to source/02_language_guide/02_Basic_Operators.md index e6b561ff..1aab686b 100755 --- a/source/chapter2/02_Basic_Operators.md +++ b/source/02_language_guide/02_Basic_Operators.md @@ -2,11 +2,11 @@ *运算符*是检查、改变、合并值的特殊符号或短语。例如，加号（`+`）将两个数相加（如 `let i = 1 + 2`）。更复杂的运算例子包括逻辑与运算符 `&&`（如 `if enteredDoorCode && passedRetinaScan`）。 -Swift 支持大部分标准 C 语言的运算符，且为了减少常见编码错误做了部分改进。如：赋值符（`=`）不再有返回值，这样就消除了手误将判等运算符（`==`）写成赋值符导致代码错误的缺陷。算术运算符（`+`，`-`，`*`，`/`，`%` 等）的结果会被检测并禁止值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见 [溢出运算符](./26_Advanced_Operators.md#overflow_operators)。 +Swift 支持大部分标准 C 语言的运算符，且为了减少常见编码错误做了部分改进。如：赋值符（`=`）不再有返回值，这样就消除了手误将判等运算符（`==`）写成赋值符导致代码错误的缺陷。算术运算符（`+`，`-`，`*`，`/`，`%` 等）的结果会被检测并禁止值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见 [溢出运算符](./27_Advanced_Operators.md#overflow_operators)。 Swift 还提供了 C 语言没有的区间运算符，例如 `a.. $1 } ) reversedNames = names.sorted(by: >) ``` -更多关于运算符方法的内容请查看 [运算符方法](./26_Advanced_Operators.md#operator_methods)。 +更多关于运算符方法的内容请查看 [运算符方法](./27_Advanced_Operators.md#operator_methods)。 ## 尾随闭包 {#trailing-closures} @@ -290,7 +290,7 @@ incrementByTen() > 注意 > -> 如果你将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，你将在闭包和该实例间创建一个循环强引用。Swift 使用捕获列表来打破这种循环强引用。更多信息，请参考 [闭包引起的循环强引用](./23_Automatic_Reference_Counting.md#strong_reference_cycles_for_closures)。 +> 如果你将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，你将在闭包和该实例间创建一个循环强引用。Swift 使用捕获列表来打破这种循环强引用。更多信息，请参考 [闭包引起的循环强引用](./24_Automatic_Reference_Counting.md#strong_reference_cycles_for_closures)。 ## 闭包是引用类型 {#closures-are-reference-types} diff --git a/source/chapter2/08_Enumerations.md b/source/02_language_guide/08_Enumerations.md similarity index 99% rename from source/chapter2/08_Enumerations.md rename to source/02_language_guide/08_Enumerations.md index 4eed2a8c..c45d4910 100755 --- a/source/chapter2/08_Enumerations.md +++ b/source/02_language_guide/08_Enumerations.md @@ -273,7 +273,7 @@ let possiblePlanet = Planet(rawValue: 7) > 注意 > -> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见 [可失败构造器](../chapter3/05_Declarations.html#failable_initializers) +> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见 [可失败构造器](../03_language_reference/05_Declarations.html#failable_initializers) 如果你试图寻找一个位置为 `11` 的行星，通过原始值构造器返回的可选 `Planet` 值将是 `nil`： diff --git a/source/chapter2/09_Structures_And_Classes.md b/source/02_language_guide/09_Structures_And_Classes.md similarity index 99% rename from source/chapter2/09_Structures_And_Classes.md rename to source/02_language_guide/09_Structures_And_Classes.md index 7238ca4e..3c42606c 100755 --- a/source/chapter2/09_Structures_And_Classes.md +++ b/source/02_language_guide/09_Structures_And_Classes.md @@ -28,7 +28,7 @@ Swift 中结构体和类有很多共同点。两者都可以： * 析构器允许一个类实例释放任何其所被分配的资源 * 引用计数允许对一个类的多次引用 -更多信息请参见 [继承](./13_Inheritance.md)、[类型转换](./18_Type_Casting.md)、[析构过程](./15_Deinitialization.md) 和 [自动引用计数](./23_Automatic_Reference_Counting.md)。 +更多信息请参见 [继承](./13_Inheritance.md)、[类型转换](./18_Type_Casting.md)、[析构过程](./15_Deinitialization.md) 和 [自动引用计数](./24_Automatic_Reference_Counting.md)。 类支持的附加功能是以增加复杂性为代价的。作为一般准则，优先使用结构体，因为它们更容易理解，仅在适当或必要时才使用类。实际上，这意味着你的大多数自定义数据类型都会是结构体和枚举。更多详细的比较参见 [在结构和类之间进行选择](https://developer.apple.com/documentation/swift/choosing_between_structures_and_classes)。 @@ -243,7 +243,7 @@ if tenEighty === alsoTenEighty { 请注意，“相同”（用三个等号表示，`===`）与“等于”（用两个等号表示，`==`）的不同。“相同”表示两个类类型（class type）的常量或者变量引用同一个类实例。“等于”表示两个实例的值“相等”或“等价”，判定时要遵照设计者定义的评判标准。 -当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./26_Advanced_Operators.md#equivalence_operators) 中将会详细介绍实现自定义 == 和 !== 运算符的流程。 +当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./27_Advanced_Operators.md#equivalence_operators) 中将会详细介绍实现自定义 == 和 !== 运算符的流程。 ### 指针 {#pointers} diff --git a/source/chapter2/10_Properties.md b/source/02_language_guide/10_Properties.md similarity index 99% rename from source/chapter2/10_Properties.md rename to source/02_language_guide/10_Properties.md index c37d9e9d..71476131 100755 --- a/source/chapter2/10_Properties.md +++ b/source/02_language_guide/10_Properties.md @@ -278,7 +278,7 @@ stepCounter.totalSteps = 896 > 注意 > -> 如果将带有观察器的属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出内存模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考 [输入输出参数](../chapter3/05_Declarations.html#in-out_parameters) +> 如果将带有观察器的属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出内存模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考 [输入输出参数](../03_language_reference/05_Declarations.html#in-out_parameters) ## 全局变量和局部变量 {#global-and-local-variables} diff --git a/source/chapter2/11_Methods.md b/source/02_language_guide/11_Methods.md similarity index 99% rename from source/chapter2/11_Methods.md rename to source/02_language_guide/11_Methods.md index 2aeee2e8..eb5d6236 100755 --- a/source/chapter2/11_Methods.md +++ b/source/02_language_guide/11_Methods.md @@ -213,7 +213,7 @@ struct LevelTracker { 除了类型属性和类型方法，`LevelTracker` 还监测每个玩家的进度。它用实例属性 `currentLevel` 来监测每个玩家当前的等级。 -为了便于管理 `currentLevel` 属性，`LevelTracker` 定义了实例方法 `advance(to:)`。这个方法会在更新 `currentLevel` 之前检查所请求的新等级是否已经解锁。`advance(to:)` 方法返回布尔值以指示是否能够设置 `currentLevel`。因为允许在调用 `advance(to:)` 时候忽略返回值，不会产生编译警告，所以函数被标注为 `@discardableResult` 属性，更多关于属性信息，请参考 [特性](../chapter3/07_Attributes.html)章节。 +为了便于管理 `currentLevel` 属性，`LevelTracker` 定义了实例方法 `advance(to:)`。这个方法会在更新 `currentLevel` 之前检查所请求的新等级是否已经解锁。`advance(to:)` 方法返回布尔值以指示是否能够设置 `currentLevel`。因为允许在调用 `advance(to:)` 时候忽略返回值，不会产生编译警告，所以函数被标注为 `@discardableResult` 属性，更多关于属性信息，请参考 [特性](../03_language_reference/07_Attributes.html)章节。 下面，`Player` 类使用 `LevelTracker` 来监测和更新每个玩家的发展进度： diff --git a/source/chapter2/12_Subscripts.md b/source/02_language_guide/12_Subscripts.md similarity index 100% rename from source/chapter2/12_Subscripts.md rename to source/02_language_guide/12_Subscripts.md diff --git a/source/chapter2/13_Inheritance.md b/source/02_language_guide/13_Inheritance.md similarity index 99% rename from source/chapter2/13_Inheritance.md rename to source/02_language_guide/13_Inheritance.md index 3b21502f..7fe7452d 100755 --- a/source/chapter2/13_Inheritance.md +++ b/source/02_language_guide/13_Inheritance.md @@ -184,7 +184,7 @@ print("Car: \(car.description)") #### 重写属性观察器 {#overriding-property-observers} -你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，无论被继承属性原本是如何实现的，当其属性值发生改变时，你就会被通知到。关于属性观察器的更多内容，请看 [属性观察器](../chapter2/10_Properties.html#property_observers)。 +你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，无论被继承属性原本是如何实现的，当其属性值发生改变时，你就会被通知到。关于属性观察器的更多内容，请看 [属性观察器](../02_language_guide/10_Properties.html#property_observers)。 > 注意 > diff --git a/source/chapter2/14_Initialization.md b/source/02_language_guide/14_Initialization.md similarity index 100% rename from source/chapter2/14_Initialization.md rename to source/02_language_guide/14_Initialization.md diff --git a/source/chapter2/15_Deinitialization.md b/source/02_language_guide/15_Deinitialization.md similarity index 98% rename from source/chapter2/15_Deinitialization.md rename to source/02_language_guide/15_Deinitialization.md index f01b7c89..bbeab2c5 100755 --- a/source/chapter2/15_Deinitialization.md +++ b/source/02_language_guide/15_Deinitialization.md @@ -4,7 +4,7 @@ ## 析构过程原理 {#how-deinitialization-works} -Swift 会自动释放不再需要的实例以释放资源。如 [自动引用计数](./23_Automatic_Reference_Counting.md) 章节中所讲述，Swift 通过*自动引用计数（ARC)* 处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。 +Swift 会自动释放不再需要的实例以释放资源。如 [自动引用计数](./24_Automatic_Reference_Counting.md) 章节中所讲述，Swift 通过*自动引用计数（ARC)* 处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。 在类的定义中，每个类最多只能有一个析构器，而且析构器不带任何参数和圆括号，如下所示： diff --git a/source/chapter2/16_Optional_Chaining.md b/source/02_language_guide/16_Optional_Chaining.md similarity index 100% rename from source/chapter2/16_Optional_Chaining.md rename to source/02_language_guide/16_Optional_Chaining.md diff --git a/source/chapter2/17_Error_Handling.md b/source/02_language_guide/17_Error_Handling.md similarity index 99% rename from source/chapter2/17_Error_Handling.md rename to source/02_language_guide/17_Error_Handling.md index 450c9b4c..8de1fbc2 100755 --- a/source/chapter2/17_Error_Handling.md +++ b/source/02_language_guide/17_Error_Handling.md @@ -147,7 +147,7 @@ do { } ``` -在 `catch` 后面写一个匹配模式来表明这个子句能处理什么样的错误。如果一条 `catch` 子句没有指定匹配模式，那么这条子句可以匹配任何错误，并且把错误绑定到一个名字为 `error` 的局部常量。关于模式匹配的更多信息请参考 [模式](../chapter3/07_Patterns.html)。 +在 `catch` 后面写一个匹配模式来表明这个子句能处理什么样的错误。如果一条 `catch` 子句没有指定匹配模式，那么这条子句可以匹配任何错误，并且把错误绑定到一个名字为 `error` 的局部常量。关于模式匹配的更多信息请参考 [模式](../03_language_reference/07_Patterns.html)。 举例来说，下面的代码处理了 `VendingMachineError` 枚举类型的全部三种情况： diff --git a/source/chapter2/18_Type_Casting.md b/source/02_language_guide/18_Type_Casting.md similarity index 100% rename from source/chapter2/18_Type_Casting.md rename to source/02_language_guide/18_Type_Casting.md diff --git a/source/chapter2/19_Nested_Types.md b/source/02_language_guide/19_Nested_Types.md similarity index 100% rename from source/chapter2/19_Nested_Types.md rename to source/02_language_guide/19_Nested_Types.md diff --git a/source/chapter2/20_Extensions.md b/source/02_language_guide/20_Extensions.md similarity index 100% rename from source/chapter2/20_Extensions.md rename to source/02_language_guide/20_Extensions.md diff --git a/source/chapter2/21_Protocols.md b/source/02_language_guide/21_Protocols.md similarity index 99% rename from source/chapter2/21_Protocols.md rename to source/02_language_guide/21_Protocols.md index 38ccd042..fbf83683 100644 --- a/source/chapter2/21_Protocols.md +++ b/source/02_language_guide/21_Protocols.md @@ -312,7 +312,7 @@ protocol DiceGameDelegate { `DiceGame` 协议可以被任意涉及骰子的游戏遵循。 -`DiceGameDelegate` 协议可以被任意类型遵循，用来追踪 `DiceGame` 的游戏过程。为了防止强引用导致的循环引用问题，可以把协议声明为弱引用，更多相关的知识请看 [类实例之间的循环强引用](./23_Automatic_Reference_Counting.md#strong_reference_cycles_between_class_instances)，当协议标记为类专属可以使 `SnakesAndLadders` 类在声明协议时强制要使用弱引用。若要声明类专属的协议就必须继承于 `AnyObject` ，更多请看 [类专属的协议](#class_only_protocol)。 +`DiceGameDelegate` 协议可以被任意类型遵循，用来追踪 `DiceGame` 的游戏过程。为了防止强引用导致的循环引用问题，可以把协议声明为弱引用，更多相关的知识请看 [类实例之间的循环强引用](./24_Automatic_Reference_Counting.md#strong_reference_cycles_between_class_instances)，当协议标记为类专属可以使 `SnakesAndLadders` 类在声明协议时强制要使用弱引用。若要声明类专属的协议就必须继承于 `AnyObject` ，更多请看 [类专属的协议](#class_only_protocol)。 如下所示，`SnakesAndLadders` 是 [控制流](./05_Control_Flow.md) 章节引入的蛇梯棋游戏的新版本。新版本使用 `Dice` 实例作为骰子，并且实现了 `DiceGame` 和 `DiceGameDelegate` 协议，后者用来记录游戏的过程： diff --git a/source/chapter2/22_Generics.md b/source/02_language_guide/22_Generics.md similarity index 100% rename from source/chapter2/22_Generics.md rename to source/02_language_guide/22_Generics.md diff --git a/source/chapter2/27_Opaque_Types.md b/source/02_language_guide/23_Opaque_Types.md similarity index 100% rename from source/chapter2/27_Opaque_Types.md rename to source/02_language_guide/23_Opaque_Types.md diff --git a/source/chapter2/23_Automatic_Reference_Counting.md b/source/02_language_guide/24_Automatic_Reference_Counting.md similarity index 99% rename from source/chapter2/23_Automatic_Reference_Counting.md rename to source/02_language_guide/24_Automatic_Reference_Counting.md index 5727e2c6..09e6b23c 100755 --- a/source/chapter2/23_Automatic_Reference_Counting.md +++ b/source/02_language_guide/24_Automatic_Reference_Counting.md @@ -558,4 +558,4 @@ paragraph = nil // 打印“p is being deinitialized” ``` -你可以查看 [捕获列表](../chapter3/04_Expressions.html) 章节，获取更多关于捕获列表的信息。 +你可以查看 [捕获列表](../03_language_reference/04_Expressions.html) 章节，获取更多关于捕获列表的信息。 diff --git a/source/chapter2/24_Memory_Safety.md b/source/02_language_guide/25_Memory_Safety.md similarity index 100% rename from source/chapter2/24_Memory_Safety.md rename to source/02_language_guide/25_Memory_Safety.md diff --git a/source/chapter2/25_Access_Control.md b/source/02_language_guide/26_Access_Control.md similarity index 100% rename from source/chapter2/25_Access_Control.md rename to source/02_language_guide/26_Access_Control.md diff --git a/source/chapter2/26_Advanced_Operators.md b/source/02_language_guide/27_Advanced_Operators.md similarity index 99% rename from source/chapter2/26_Advanced_Operators.md rename to source/02_language_guide/27_Advanced_Operators.md index fbd4d978..45e389e6 100644 --- a/source/chapter2/26_Advanced_Operators.md +++ b/source/02_language_guide/27_Advanced_Operators.md @@ -414,7 +414,7 @@ if twoThreeFour == anotherTwoThreeFour { ## 自定义运算符 {#custom-operators} -除了实现标准运算符，在 Swift 中还可以声明和实现*自定义运算符*。可以用来自定义运算符的字符列表请参考 [运算符](../chapter3/02_Lexical_Structure.html#operators)。 +除了实现标准运算符，在 Swift 中还可以声明和实现*自定义运算符*。可以用来自定义运算符的字符列表请参考 [运算符](../03_language_reference/02_Lexical_Structure.html#operators)。 新的运算符要使用 `operator` 关键字在全局作用域内进行定义，同时还要指定 `prefix`、`infix` 或者 `postfix` 修饰符： diff --git a/source/chapter2/chapter2.md b/source/02_language_guide/chapter2.md similarity index 80% rename from source/chapter2/chapter2.md rename to source/02_language_guide/chapter2.md index 1430240b..aefc617d 100644 --- a/source/chapter2/chapter2.md +++ b/source/02_language_guide/chapter2.md @@ -1,3 +1,3 @@ -# Swift 教程 +# Swift 语言教程 本章介绍了 Swift 的各种特性及其使用方法，是全书的核心部分。 \ No newline at end of file diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/03_language_reference/01_About_the_Language_Reference.md similarity index 100% rename from source/chapter3/01_About_the_Language_Reference.md rename to source/03_language_reference/01_About_the_Language_Reference.md diff --git a/source/chapter3/02_Lexical_Structure.md b/source/03_language_reference/02_Lexical_Structure.md similarity index 97% rename from source/chapter3/02_Lexical_Structure.md rename to source/03_language_reference/02_Lexical_Structure.md index 71c16399..71d4a5a6 100755 --- a/source/chapter3/02_Lexical_Structure.md +++ b/source/03_language_reference/02_Lexical_Structure.md @@ -187,7 +187,7 @@ true // 布尔值字面量 整型字面面可以使用下划线（`_`）来增加数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，这同样也会被系统所忽略，并不会影响字面量的值。 -除非特别指定，整数字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数](../chapter2/01_The_Basics.md#integers)。 +除非特别指定，整数字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数](../02_language_guide/01_The_Basics.md#integers)。 > 整数字面量语法 > @@ -412,7 +412,7 @@ print(# # #"Line 1\# # #nLine 2"# # #) // Error 使用扩展分隔符创建的多行字符串字面量与普通多行字符串字面量具有相同的缩进要求。 -字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../chapter2/03_Strings_and_Characters.md) 以及 [*字符串结构参考*](https://developer.apple.com/documentation/swift/string)。 +字符串字面量的默认推导类型为 `String`。更多有关 `String` 类型的信息请参考 [字符串和字符](../02_language_guide/03_Strings_and_Characters.md) 以及 [*字符串结构参考*](https://developer.apple.com/documentation/swift/string)。 用 `＋` 操作符连接的字符型字面量是在编译时进行连接的。比如下面的 `textA` 和 `textB` 是完全一样的，`textA` 没有任何运行时的连接操作。 @@ -520,7 +520,7 @@ let textB = "Hello world" ## 运算符 {#operator} -Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 +Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../02_language_guide/02_Basic_Operators.md) 和 [高级运算符](../02_language_guide/27_Advanced_Operators.md) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号（Miscellaneous Symbols）* 以及印刷符号（Dingbats）之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。 @@ -545,7 +545,7 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 在某些特定的设计中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号，剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的符号，因而不会被错误解析为 `>>` 运算符。 -要学习如何自定义运算符，请参考 [自定义运算符](../chapter2/26_Advanced_Operators.md#custom_operators) 和 [运算符声明](./06_Declarations.md#operator_declaration)。要学习如何重载运算符，请参考 [运算符函数](../chapter2/26_Advanced_Operators.md#operator_functions)。 +要学习如何自定义运算符，请参考 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom_operators) 和 [运算符声明](./06_Declarations.md#operator_declaration)。要学习如何重载运算符，请参考 [运算符函数](../02_language_guide/27_Advanced_Operators.md#operator_functions)。 > 运算符语法 > diff --git a/source/chapter3/03_Types.md b/source/03_language_reference/03_Types.md similarity index 95% rename from source/chapter3/03_Types.md rename to source/03_language_reference/03_Types.md index 708d3628..a7dd6339 100644 --- a/source/chapter3/03_Types.md +++ b/source/03_language_reference/03_Types.md @@ -2,7 +2,7 @@ Swift 语言存在两种类型：命名型类型和复合型类型。*命名型类型*是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义类 `MyClass` 的实例拥有类型 `MyClass`。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。 -那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照 [扩展](../chapter2/20_Extensions.md) 和 [扩展声明](./06_Declarations.md#extension_declaration) 中讨论的那样，声明一个扩展来增加它们的行为以满足你程序的需求。 +那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照 [扩展](../02_language_guide/20_Extensions.md) 和 [扩展声明](./06_Declarations.md#extension_declaration) 中讨论的那样，声明一个扩展来增加它们的行为以满足你程序的需求。 *复合型类型*是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型 `(Int, (Int, Int))` 包含两个元素：第一个是命名型类型 `Int`，第二个是另一个复合型类型 `(Int, Int)`。 @@ -88,7 +88,7 @@ var someValue: ExampleModule.MyType ## 元组类型 {#tuple-type-h} *元组类型*是使用括号括起来的零个或多个类型，类型间用逗号隔开。 -你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符紧跟一个冒号 `(:)` 组成。[函数和多返回值](../chapter2/06_Functions.md#functions_with_multiple_return_values) 章节里有一个展示上述特性的例子。 +你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符紧跟一个冒号 `(:)` 组成。[函数和多返回值](../02_language_guide/06_Functions.md#functions_with_multiple_return_values) 章节里有一个展示上述特性的例子。 当一个元组类型的元素有名字的时候，这个名字就是类型的一部分。 @@ -127,11 +127,11 @@ someTuple = (left: 5, right: 5) // 错误：命名类型不匹配 *形参类型*是由逗号间隔的类型列表。由于*返回值类型*可以是元组类型，所以函数类型支持多返回值的函数与方法。 -你可以对形参类型为 `() -> T`（其中 T 是任何类型）的函数使用 `autoclosure` 特性，这会在调用侧隐式创建一个闭包。这从语法结构上提供了一种便捷：延迟对表达式的求值，直到其值在函数体中被调用。以自动闭包做为形参的函数类型的例子详见 [自动闭包](../chapter2/07_Closures.md#autoclosures)。 +你可以对形参类型为 `() -> T`（其中 T 是任何类型）的函数使用 `autoclosure` 特性，这会在调用侧隐式创建一个闭包。这从语法结构上提供了一种便捷：延迟对表达式的求值，直到其值在函数体中被调用。以自动闭包做为形参的函数类型的例子详见 [自动闭包](../02_language_guide/07_Closures.md#autoclosures)。 -函数类型可以拥有一个可变参数在*形参类型*中。从语法角度上讲，可变参数由一个基础类型名字紧随三个点（`...`）组成，如 `Int...`。可变参数被认为是一个包含了基础类型元素的数组。即 `Int...` 就是 `[Int]`。关于使用可变参数的例子，请参阅 [可变参数](../chapter2/06_Functions.md#variadic-parameters)。 +函数类型可以拥有一个可变参数在*形参类型*中。从语法角度上讲，可变参数由一个基础类型名字紧随三个点（`...`）组成，如 `Int...`。可变参数被认为是一个包含了基础类型元素的数组。即 `Int...` 就是 `[Int]`。关于使用可变参数的例子，请参阅 [可变参数](../02_language_guide/06_Functions.md#variadic-parameters)。 -为了指定一个 `in-out` 参数，可以在形参类型前加 `inout` 前缀。但是你不可以对可变参数或返回值类型使用 `inout`。关于这种形参的详细讲解请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 +为了指定一个 `in-out` 参数，可以在形参类型前加 `inout` 前缀。但是你不可以对可变参数或返回值类型使用 `inout`。关于这种形参的详细讲解请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in_out_parameters)。 如果函数类型只有一个类型是元组类型的一个形参，那么元组类型在写函数类型的时候必须用圆括号括起来。比如说，`((Int, Int)) -> Void` 是接收一个元组 `(Int, Int)` 作为形参并且不返回任何值的函数类型。与此相对，不加括号的 `(Int, Int) -> Void` 是一个接收两个 `Int` 作为形参并且不返回任何值的函数类型。相似地，因为 `Void` 是空元组类型 `()` 的别名，函数类型 `(Void)-> Void` 与 `(()) -> ()` 是一样的 - 一个将空元组作为唯一实参的函数。但这些类型和 `() -> ()` 是不一样的 - 一个无实参的函数。 @@ -189,7 +189,7 @@ func takesTwoFunctions(first: (Any) -> Void, second: (Any) -> Void) { 上述例子里的被标记为“错误”的四个函数调用会产生编译错误。因为形参 `first` 和 `second` 是非逃逸函数，它们不能够作为实参被传递到另一个非闭包函数。相对的, 标记“正确”的两个函数不会产生编译错误。这些函数调用不会违反限制，因为 `external` 不是 `takesTwoFunctions(first:second:)` 的形参之一。 -如果你需要避免这个限制，标记其中一个形参为逃逸，或者使用 `withoutActuallyEscaping(_:do:)` 函数临时转换其中一个非逃逸函数形参为逃逸函数。关于避免内存访问冲突，可以参阅 [内存安全](../chapter2/24_Memory_Safety.md)。 +如果你需要避免这个限制，标记其中一个形参为逃逸，或者使用 `withoutActuallyEscaping(_:do:)` 函数临时转换其中一个非逃逸函数形参为逃逸函数。关于避免内存访问冲突，可以参阅 [内存安全](../02_language_guide/25_Memory_Safety.md)。 > 函数类型语法 > @@ -234,7 +234,7 @@ var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]] 访问一个多维数组的元素时，最左边的下标指向最外层数组的相应位置元素。接下来往右的下标指向第一层嵌入的相应位置元素，依次类推。这就意味着，在上面的例子中，`array3D[0]` 是 `[[1, 2], [3, 4]]`，`array3D[0][1]` 是 `[3, 4]`，`array3D[0][1][1]` 则是 `4`。 -关于 Swift 标准库中 `Array` 类型的详细讨论，请参阅 [数组](../chapter2/04_Collection_Types.md#arrays)。 +关于 Swift 标准库中 `Array` 类型的详细讨论，请参阅 [数组](../02_language_guide/04_Collection_Types.md#arrays)。 > 数组类型语法 > @@ -262,7 +262,7 @@ let someDictionary: Dictionary = ["Alex": 31, "Paul": 39] 字典中键的类型必须符合 Swift 标准库中的 `Hashable` 协议。 -关于 Swift 标准库中 `Dictionary` 类型的详细讨论，请参阅 [字典](../chapter2/04_Collection_Types.md#dictionaries)。 +关于 Swift 标准库中 `Dictionary` 类型的详细讨论，请参阅 [字典](../02_language_guide/04_Collection_Types.md#dictionaries)。 > 字典类型语法 > @@ -294,7 +294,7 @@ optionalInteger! // 42 你也可以使用可选链式调用和可选绑定来选择性在可选表达式上执行操作。如果值为 `nil`，不会执行任何操作，因此也就没有运行错误产生。 -更多细节以及更多如何使用可选类型的例子，请参阅 [可选类型](../chapter2/01_The_Basics.md#optionals)。 +更多细节以及更多如何使用可选类型的例子，请参阅 [可选类型](../02_language_guide/01_The_Basics.md#optionals)。 > 可选类型语法 > @@ -329,7 +329,7 @@ let implicitlyUnwrappedArray: [Int]! // 正确 可以使用可选链式调用对隐式解析可选表达式选择性地执行操作。如果值为 `nil`，就不会执行任何操作，因此也不会产生运行错误。 -关于隐式解析可选类型的更多细节，请参阅 [隐式解析可选类型](../chapter2/01_The_Basics.md#implicityly_unwrapped_optionals)。 +关于隐式解析可选类型的更多细节，请参阅 [隐式解析可选类型](../02_language_guide/01_The_Basics.md#implicityly_unwrapped_optionals)。 > 隐式解析可选类型语法 > @@ -486,11 +486,11 @@ print(type(of: z.f())) *类型继承子句*被用来指定一个命名型类型继承自哪个类、采纳哪些协议。类型继承子句开始于冒号 `:`，其后是类型标识符列表。 -类可以继承自单个超类，并遵循任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要遵循的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，请参阅 [继承](../chapter2/13_Inheritance.md)。 +类可以继承自单个超类，并遵循任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要遵循的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，请参阅 [继承](../02_language_guide/13_Inheritance.md)。 其它命名型类型只能继承自或采纳一系列协议。协议类型可以继承自任意数量的其他协议。当一个协议类型继承自其它协议时，其它协议中定义的要求会被整合在一起，然后从当前协议继承的任意类型必须符合所有这些条件。 -枚举定义中的类型继承子句可以是一系列协议，或者是指定单一的命名类型，此时枚举为其用例分配原始值。在枚举定义中使用类型继承子句来指定原始值类型的例子，请参阅 [原始值](../chapter2/08_Enumerations.md#raw_values)。 +枚举定义中的类型继承子句可以是一系列协议，或者是指定单一的命名类型，此时枚举为其用例分配原始值。在枚举定义中使用类型继承子句来指定原始值类型的例子，请参阅 [原始值](../02_language_guide/08_Enumerations.md#raw_values)。 > 类型继承子句语法 > diff --git a/source/chapter3/04_Expressions.md b/source/03_language_reference/04_Expressions.md similarity index 97% rename from source/chapter3/04_Expressions.md rename to source/03_language_reference/04_Expressions.md index 79b2c79d..dd89d5b4 100644 --- a/source/chapter3/04_Expressions.md +++ b/source/03_language_reference/04_Expressions.md @@ -18,11 +18,11 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表 ## 前缀表达式 {#prefix-expressions} 前缀表达式由可选的前缀运算符和表达式组成。前缀运算符只接收一个参数，表达式则紧随其后。 -关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md)。 +关于这些运算符的更多信息，请参阅 [基本运算符](../02_language_guide/02_Basic_Operators.md) 和 [高级运算符](../02_language_guide/27_Advanced_Operators.md)。 关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Operators Declarations*](https://developer.apple.com/documentation/swift/operator_declarations)。 -除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。更多信息，请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 +除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。更多信息，请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in_out_parameters)。 > 前缀表达式语法 > @@ -67,7 +67,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try `try` 表达式不能出现在二元运算符的的右侧，除非二元运算符是赋值运算符或者 `try` 表达式是被圆括号括起来的。 -关于 `try`、`try?` 和 `try!` 的更多信息，以及该如何使用的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md)。 +关于 `try`、`try?` 和 `try!` 的更多信息，以及该如何使用的例子，请参阅 [错误处理](../02_language_guide/17_Error_Handling.md)。 > Try 表达式语法 > @@ -81,7 +81,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try > `左侧参数` `二元运算符` `右侧参数` > -关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md)。 +关于这些运算符的更多信息，请参阅 [基本运算符](../02_language_guide/02_Basic_Operators.md) 和 [高级运算符](../02_language_guide/27_Advanced_Operators.md)。 关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Swift Standard Library Operators Reference*](https://developer.apple.com/documentation/swift/operator_declarations)。 @@ -137,7 +137,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try 如果条件为真，那么对第一个表达式进行求值并返回结果。否则，对第二个表达式进行求值并返回结果。未使用的表达式不会进行求值。 -关于使用三元条件运算符的例子，请参阅 [三元条件运算符](../chapter2/02_Basic_Operators.md#ternary_conditional_operator)。 +关于使用三元条件运算符的例子，请参阅 [三元条件运算符](../02_language_guide/02_Basic_Operators.md#ternary_conditional_operator)。 > 三元条件运算符语法 > @@ -183,7 +183,7 @@ f(x as Any) `as!` 运算符执行强制类型转换，返回目标类型的非可选值。如果转换失败，则会导致运行时错误。表达式 `x as! T` 效果等同于 `(x as? T)!`。 -关于类型转换的更多内容和例子，请参阅 [类型转换](../chapter2/18_Type_Casting.md)。 +关于类型转换的更多内容和例子，请参阅 [类型转换](../02_language_guide/18_Type_Casting.md)。 #### type-casting-operator {#type-casting-operator} @@ -464,7 +464,7 @@ myFunction { $0 + $1 } 使用闭包表达式时，可以不必将其存储在一个变量或常量中，例如作为函数调用的一部分来立即使用一个闭包。在上面的例子中，传入 `myFunction` 的闭包表达式就是这种立即使用类型的闭包。因此，一个闭包是否逃逸与其使用时的上下文相关。一个会被立即调用或者作为函数的非逃逸参数传递的闭包表达式是非逃逸的，否则，这个闭包表达式是逃逸的。 -关于逃逸闭包的内容，请参阅 [逃逸闭包](./chapter2/07_Closures.md#escaping_closures)。 +关于逃逸闭包的内容，请参阅 [逃逸闭包](./02_language_guide/07_Closures.md#escaping_closures)。 ## 捕获列表 {#capture-lists} 默认情况下，闭包会捕获附近作用域中的常量和变量，并使用强引用指向它们。你可以通过一个*捕获列表*来显式指定它的捕获行为。 @@ -522,7 +522,7 @@ myFunction { [unowned self] in print(self.title) } // 无主引用捕获 myFunction { [weak parent = self.parent] in print(parent!.title) } ``` -关于闭包表达式的更多信息和例子，请参阅 [闭包表达式](../chapter2/07_Closures.md#closure_expressions)。关于捕获列表的更多信息和例子，请参阅 [解决闭包引起的循环强引用](../chapter2/23_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_for_closures)。 +关于闭包表达式的更多信息和例子，请参阅 [闭包表达式](../02_language_guide/07_Closures.md#closure_expressions)。关于捕获列表的更多信息和例子，请参阅 [解决闭包引起的循环强引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_for_closures)。 > 闭包表达式语法 > @@ -918,7 +918,7 @@ print(keyPath == c.getSomeKeyPath()) ## 后缀表达式 {#postfix-expressions} *后缀表达式*就是在某个表达式的后面运用后缀运算符或其他后缀语法。从语法构成上来看，基本表达式也是后缀表达式。 -关于这些运算符的更多信息，请参阅 [基本运算符](../chapter2/02_Basic_Operators.md) 和 [高级运算符](../chapter2/26_Advanced_Operators.md)。 +关于这些运算符的更多信息，请参阅 [基本运算符](../02_language_guide/02_Basic_Operators.md) 和 [高级运算符](../02_language_guide/27_Advanced_Operators.md)。 关于 Swift 标准库提供的运算符的更多信息，请参阅 [运算符定义](https://developer.apple.com/documentation/swift/operator_declarations)。 diff --git a/source/chapter3/05_Statements.md b/source/03_language_reference/05_Statements.md similarity index 96% rename from source/chapter3/05_Statements.md rename to source/03_language_reference/05_Statements.md index a407555e..ac520281 100755 --- a/source/chapter3/05_Statements.md +++ b/source/03_language_reference/05_Statements.md @@ -86,7 +86,7 @@ while condition { 由于会在执行循环体中的语句前判断条件的值，因此循环体中的语句可能会被执行若干次，也可能一次也不会被执行。 -条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../chapter2/01_The_Basics.md#optional_binding)。 +条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 > while 语句语法 > @@ -132,7 +132,7 @@ repeat { 由于条件的值是在循环体中的语句执行后才进行判断，因此循环体中的语句至少会被执行一次。 -条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../chapter2/01_The_Basics.md#optional_binding)。 +条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 > repeat-while 语句语法 > @@ -194,7 +194,7 @@ if condition 1 { } ``` -`if` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../chapter2/01_The_Basics.md#optional_binding)。 +`if` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 > if 语句语法 > @@ -219,7 +219,7 @@ guard condition else { } ``` -`guard` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件也可以是一条可选绑定，请参阅 [可选绑定](../chapter2/01_The_Basics.md#optional_binding)。 +`guard` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件也可以是一条可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 在 `guard` 语句中进行可选绑定的任何常量或者变量，其可用范围从声明开始直到作用域结束。 @@ -261,7 +261,7 @@ default: `switch` 语句会先计算*控制表达式*的值，然后与每一个 `case` 的模式进行匹配。如果匹配成功，程序将会执行对应的 `case` 中的语句。另外，每一个 `case` 的作用域都不能为空，也就是说在每一个 `case` 的冒号（`:`）后面必须至少有一条语句。如果你不想在匹配到的 `case` 中执行代码，只需在该 `case` 中写一条 `break` 语句即可。 -可以用作控制表达式的值是十分灵活的。除了标量类型外，如 `Int`、`Character`，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类型的实例和可选类型。控制表达式的值还可以用来匹配枚举类型中的成员值或是检查该值是否包含在指定的 `Range` 中。关于如何在 `switch` 语句中使用这些类型，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章中的 [Switch](../chapter2/05_Control_Flow.md#switch)。 +可以用作控制表达式的值是十分灵活的。除了标量类型外，如 `Int`、`Character`，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类型的实例和可选类型。控制表达式的值还可以用来匹配枚举类型中的成员值或是检查该值是否包含在指定的 `Range` 中。关于如何在 `switch` 语句中使用这些类型，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章中的 [Switch](../02_language_guide/05_Control_Flow.md#switch)。 每个 `case` 的模式后面可以有一个 `where` 子句。`where` 子句由 `where` 关键字紧跟一个提供额外条件的表达式组成。因此，当且仅当控制表达式匹配一个 `case` 的模式且 `where` 子句的表达式为真时，`case` 中的语句才会被执行。在下面的例子中，控制表达式只会匹配包含两个相等元素的元组，例如 `(1, 1)`： @@ -369,7 +369,7 @@ case .suppressed: 标签的作用域在该标签所标记的语句内。可以嵌套使用带标签的语句，但标签名必须唯一。 -关于使用带标签的语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章中的 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 +关于使用带标签的语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章中的 [带标签的语句](../02_language_guide/05_Control_Flow.md#labeled_statements)。 > 带标签的语句语法 > @@ -426,7 +426,7 @@ case .suppressed: 无论哪种情况，控制权都会被转移给被终止的控制流语句后面的第一行语句。 -关于使用 `break` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [Break](../chapter2/05_Control_Flow.md#break) 和 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 +关于使用 `break` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [Break](../02_language_guide/05_Control_Flow.md#break) 和 [带标签的语句](../02_language_guide/05_Control_Flow.md#labeled_statements)。 > break 语句语法 > @@ -452,7 +452,7 @@ case .suppressed: 在 `for` 语句中，`continue` 语句执行后，增量表达式还是会被计算，这是因为每次循环体执行完毕后，增量表达式都会被计算。 -关于使用 `continue` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [Continue](../chapter2/05_Control_Flow.md#continue) 和 [带标签的语句](../chapter2/05_Control_Flow.md#labeled_statements)。 +关于使用 `continue` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [Continue](../02_language_guide/05_Control_Flow.md#continue) 和 [带标签的语句](../02_language_guide/05_Control_Flow.md#labeled_statements)。 > continue 语句语法 > @@ -467,7 +467,7 @@ case .suppressed: `fallthrough` 语句可出现在 `switch` 语句中的任意 `case` 中，但不能出现在最后一个 `case` 中。同时，`fallthrough` 语句也不能把控制权转移到使用了值绑定的 `case`。 -关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../chapter2/05_Control_Flow.md) 一章的 [控制转移语句](../chapter2/05_Control_Flow.md#control_transfer_statements)。 +关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [控制转移语句](../02_language_guide/05_Control_Flow.md#control_transfer_statements)。 > fallthrough 语句语法 > @@ -517,7 +517,7 @@ case .suppressed: 表达式的结果必须符合 `ErrorType` 协议。 -关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../chapter2/17_Error_Handling.md#propagating_errors_using_throwing_functions)。 +关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../02_language_guide/17_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../02_language_guide/17_Error_Handling.md#propagating_errors_using_throwing_functions)。 > throw 语句语法 > @@ -586,7 +586,7 @@ do { 为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](./08_Patterns.md)。 -关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../chapter2/17_Error_Handling.md#handling_errors)。 +关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../02_language_guide/17_Error_Handling.md#handling_errors)。 > do 语句语法 > diff --git a/source/chapter3/06_Declarations.md b/source/03_language_reference/06_Declarations.md similarity index 94% rename from source/chapter3/06_Declarations.md rename to source/03_language_reference/06_Declarations.md index d672ab1a..be615036 100755 --- a/source/chapter3/06_Declarations.md +++ b/source/03_language_reference/06_Declarations.md @@ -137,9 +137,9 @@ print("The second number is \(secondNumber).") 当常量名称的类型（`:` 类型）可以被推断出时，类型注解在常量声明中是可选的，正如 [类型推断](./03_Types.md#type_inference) 中所描述的。 -声明一个常量类型属性要使用 `static` 声明修饰符。类的常量类型属性总是隐式地被标记为 `final` ；你无法用 `class` 或 `final` 声明修饰符实现允许或禁止被子类重写的目的。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties) 中有介绍。 +声明一个常量类型属性要使用 `static` 声明修饰符。类的常量类型属性总是隐式地被标记为 `final` ；你无法用 `class` 或 `final` 声明修饰符实现允许或禁止被子类重写的目的。类型属性在 [类型属性](../02_language_guide/10_Properties.md#type_properties) 中有介绍。 -如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../chapter2/01_The_Basics.md#constants_and_variables) 和 [存储属性](../chapter2/10_Properties.md#stored_properties)。 +如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../02_language_guide/01_The_Basics.md#constants_and_variables) 和 [存储属性](../02_language_guide/10_Properties.md#stored_properties)。 #### grammer_of_a_constant_declaration {#grammer-of-a-constant-declaration} @@ -176,7 +176,7 @@ print("The second number is \(secondNumber).") > 也可以在协议声明中声明属性，详情请参阅 [协议属性声明](#protocol_property_declaration)。 > -可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../chapter2/13_Inheritance.md#overriding)。 +可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../02_language_guide/13_Inheritance.md#overriding)。 ### 存储型变量和存储型变量属性 {#stored-variables-and-stored-variable-properties} 使用如下形式声明一个存储型变量或存储型变量属性： @@ -209,13 +209,13 @@ var 变量名称: 类型 { 可以在全局范围、函数内部，以及类、结构体、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构体、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性（computed property）*。 -getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../chapter2/10_Properties.md#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 +getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../02_language_guide/10_Properties.md#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 -setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../chapter2/10_Properties.md#shorthand_setter_declaration) 中描述的那样。 +setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../02_language_guide/10_Properties.md#shorthand_setter_declaration) 中描述的那样。 与存储型变量和存储型属性不同，计算型变量和计算型属性的值不存储在内存中。 -要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../chapter2/10_Properties.md#computed_properties)。 +要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../02_language_guide/10_Properties.md#computed_properties)。 ### 存储型变量和属性的观察器 {#stored-variable-observers-and-property-observers} 可以在声明存储型变量或属性时提供 `willSet` 和 `didSet` 观察器。一个包含观察器的存储型变量或属性以如下形式声明： @@ -234,7 +234,7 @@ var 变量名称: 类型 = 表达式 { 可以在全局范围、函数内部，或者类、结构体的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，观察器表示一个存储型变量观察器。当它在类和结构体的声明中被声明时，观察器表示一个属性观察器。 可以为任何存储型属性添加观察器。也可以通过重写父类属性的方式为任何继承的属性（无论是存储型还是计算型的）添加观察器 -，正如 [重写属性观察器](../chapter2/13_Inheritance.md#overriding_property_observers) 中所描述的。 +，正如 [重写属性观察器](../02_language_guide/13_Inheritance.md#overriding_property_observers) 中所描述的。 用于初始化的表达式在类或者结构的声明中是可选的，但是在其他声明中则是必须的。如果可以从初始化表达式中推断出类型信息，那么可以不提供类型注解。 @@ -246,10 +246,10 @@ var 变量名称: 类型 = 表达式 { 提供了 `willSet` 时，`didSet` 是可选的。同样的，提供了 `didSet` 时，`willSet` 则是可选的。 -要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../chapter2/10_Properties.md#property_observers)。 +要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../02_language_guide/10_Properties.md#property_observers)。 ### 类型变量属性 {#type-variable-properties} -要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties) 章节有详细讨论。 +要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../02_language_guide/10_Properties.md#type_properties) 章节有详细讨论。 #### grammer_of_a_variable_declaration {#grammer-of-a-variable-declaration} @@ -436,7 +436,7 @@ func 函数名称(参数列表) { 大多数时候，嵌套函数都是可逃逸的函数。仅当一个嵌套函数捕获了某个确保了永不逃逸的值——例如一个输入输出参数——或者传入一个非逃逸函数参数的时候，这个嵌套函数才是非逃逸的。 -更多关于嵌套函数的讨论，请参阅 [嵌套函数](../chapter2/06_Functions.md#Nested_Functions)。 +更多关于嵌套函数的讨论，请参阅 [嵌套函数](../02_language_guide/06_Functions.md#Nested_Functions)。 ### 参数名 {#parameter-names} 函数的参数列表由一个或多个函数参数组成，参数间以逗号分隔。函数调用时的参数顺序必须和函数声明时的参数顺序一致。最简单的参数列表有着如下的形式： @@ -479,7 +479,7 @@ repeatGreeting("Hello, world!", count: 2) // count 有标签, greeting 没有 不能将同一个值传递给多个输入输出参数，因为这种情况下的拷贝与覆盖行为的顺序是不确定的，因此原始值的最终值也将无法确定。 -更多关于内存安全和内存独占权的讨论，请参阅 [内存安全](../chapter2/24_MemorySafety.md)。 +更多关于内存安全和内存独占权的讨论，请参阅 [内存安全](../02_language_guide/24_MemorySafety.md)。 如果一个闭包或者嵌套函数捕获了一个输入输出参数，那么这个闭包或者嵌套函数必须是非逃逸的。如果你需要捕获一个输入输出参数，但并不对其进行修改或者在其他代码中观察其值变化，那么你可以使用捕获列表来显式地表明这是个不可变捕获。 @@ -505,7 +505,7 @@ func multithreadedFunction(queue: DispatchQueue, x: inout Int) { } ``` -关于输入输出参数的详细讨论，请参阅 [输入输出参数](../chapter2/06_Functions.md#in_out_parameters)。 +关于输入输出参数的详细讨论，请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in_out_parameters)。 ### 特殊参数 {#special-kinds-of-parameters} 参数可以被忽略，数量可以不固定，还可以为其提供默认值，使用形式如下： @@ -518,7 +518,7 @@ _ : 参数类型 以下划线（`_`）命名的参数会被显式忽略，无法在函数内使用。 -一个参数的基本类型名称如果紧跟着三个点（`...`），会被视为可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数会作为包含该参数类型元素的数组处理。举例来讲，可变参数 `Int...` 会作为 `[Int]` 来处理。关于使用可变参数的例子，请参阅 [可变参数](../chapter2/06_Functions.md#variadic_parameters)。 +一个参数的基本类型名称如果紧跟着三个点（`...`），会被视为可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数会作为包含该参数类型元素的数组处理。举例来讲，可变参数 `Int...` 会作为 `[Int]` 来处理。关于使用可变参数的例子，请参阅 [可变参数](../02_language_guide/06_Functions.md#variadic_parameters)。 如果在参数类型后面有一个以等号（`=`）连接的表达式，该参数会拥有默认值，即给定表达式的值。当函数被调用时，给定的表达式会被求值。如果参数在函数调用时被省略了，就会使用其默认值。 @@ -670,7 +670,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它 不同于类或者结构体，枚举类型并不隐式提供默认构造器，所有构造器必须显式声明。一个构造器可以委托给枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例赋值给 `self` 后才算完成。 -和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 +和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。 @@ -703,7 +703,7 @@ let f = Number.integer let evenInts: [Number] = [0, 2, 4, 6].map(f) ``` -要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../chapter2/08_Enumerations.md#associated_values)。 +要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../02_language_guide/08_Enumerations.md#associated_values)。 #### 递归枚举 {#enumerations-with-indirection} 枚举类型可以具有递归结构，就是说，枚举用例的关联值类型可以是枚举类型自身。然而，枚举类型的实例具有值语义，这意味着它们在内存中有固定布局。为了支持递归，编译器必须插入一个间接层。 @@ -753,12 +753,12 @@ enum GamePlayMode: String { 在上面这个例子中，`GamePlayMode.cooperative` 的原始值是 `"cooperative"`，`GamePlayMode.individual` 的原始值是 `"individual"`，`GamePlayMode.competitive` 的原始值是 `"competitive"`。 -枚举用例具有原始值的枚举类型隐式地符合定义在 Swift 标准库中的 `RawRepresentable` 协议。所以，它们拥有一个 `rawValue` 属性和一个可失败构造器 `init?(rawValue: RawValue)`。可以使用 `rawValue` 属性去获取枚举用例的原始值，例如 `ExampleEnum.b.rawValue`。还可以根据原始值来创建一个相对应的枚举用例，只需调用枚举的可失败构造器，例如 `ExampleEnum(rawValue: 5)`，这个可失败构造器返回一个可选类型的用例。要获得更多关于具有原始值的枚举用例的信息和例子，请参阅 [原始值](../chapter2/08_Enumerations.md#raw_values)。 +枚举用例具有原始值的枚举类型隐式地符合定义在 Swift 标准库中的 `RawRepresentable` 协议。所以，它们拥有一个 `rawValue` 属性和一个可失败构造器 `init?(rawValue: RawValue)`。可以使用 `rawValue` 属性去获取枚举用例的原始值，例如 `ExampleEnum.b.rawValue`。还可以根据原始值来创建一个相对应的枚举用例，只需调用枚举的可失败构造器，例如 `ExampleEnum(rawValue: 5)`，这个可失败构造器返回一个可选类型的用例。要获得更多关于具有原始值的枚举用例的信息和例子，请参阅 [原始值](../02_language_guide/08_Enumerations.md#raw_values)。 ### 访问枚举用例 {#accessing-enumeration-cases} -使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.enumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../chapter2/08_Enumerations.md#enumeration_syntax) 和 [显式成员表达式](./04_Expressions.md#explicit_member_expression) 所述。 +使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.enumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../02_language_guide/08_Enumerations.md#enumeration_syntax) 和 [显式成员表达式](./04_Expressions.md#explicit_member_expression) 所述。 -可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../chapter2/08_Enumerations.md#matching_enumeration_values_with_a_switch_statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](./08_Patterns.md#enumeration_case_pattern) 所述。 +可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../02_language_guide/08_Enumerations.md#matching_enumeration_values_with_a_switch_statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](./08_Patterns.md#enumeration_case_pattern) 所述。 #### grammer_of_an_enumeration_declaration {#grammer-of-an-enumeration-declaration} @@ -861,24 +861,24 @@ struct 结构体名称: 采纳的协议 { } ``` -结构体内可包含零个或多个声明。这些声明可以包括存储型和计算型属性、类型属性、实例方法、类型方法、构造器、下标、类型别名，甚至其他结构体、类、和枚举声明。结构体声明不能包含析构器或者协议声明。关于结构体的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Structures_And_Classes.md)。 +结构体内可包含零个或多个声明。这些声明可以包括存储型和计算型属性、类型属性、实例方法、类型方法、构造器、下标、类型别名，甚至其他结构体、类、和枚举声明。结构体声明不能包含析构器或者协议声明。关于结构体的详细讨论和示例，请参阅 [类和结构体](../02_language_guide/09_Structures_And_Classes.md)。 结构体可以采纳任意数量的协议，但是不能继承自类、枚举或者其他结构体。 有三种方法可以创建一个已声明的结构体实例： -* 调用结构体内声明的构造器，正如 [构造器](../chapter2/14_Initialization.md#initializers) 所述。 +* 调用结构体内声明的构造器，正如 [构造器](../02_language_guide/14_Initialization.md#initializers) 所述。 -* 如果没有声明构造器，调用结构体的成员逐一构造器，正如 [结构体类型的成员逐一构造器](../chapter2/14_Initialization.md#memberwise_initializers_for_structure_types) 所述。 +* 如果没有声明构造器，调用结构体的成员逐一构造器，正如 [结构体类型的成员逐一构造器](../02_language_guide/14_Initialization.md#memberwise_initializers_for_structure_types) 所述。 -* 如果没有声明构造器，而且结构体的所有属性都有初始值，调用结构体的默认构造器，正如 [默认构造器](../chapter2/14_Initialization.md#default_initializers) 所述。 +* 如果没有声明构造器，而且结构体的所有属性都有初始值，调用结构体的默认构造器，正如 [默认构造器](../02_language_guide/14_Initialization.md#default_initializers) 所述。 -结构体的构造过程请参阅 [构造过程](../chapter2/14_Initialization.md)。 +结构体的构造过程请参阅 [构造过程](../02_language_guide/14_Initialization.md)。 -结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../chapter2/09_Structures_And_Classes.md#accessing_properties) 所述。 +结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../02_language_guide/09_Structures_And_Classes.md#accessing_properties) 所述。 结构体是值类型。结构体的实例在被赋予变量或常量，或传递给函数作为参数时会被复制。关于值类型的更多信息，请参阅 -[结构体和枚举是值类型](../chapter2/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 +[结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension_declaration)。 @@ -923,7 +923,7 @@ class 类名: 超类, 采纳的协议 { } ``` -类内可以包含零个或多个声明。这些声明可以包括存储型和计算型属性、实例方法、类型方法、构造器、唯一的析构器、下标、类型别名，甚至其他结构体、类和枚举声明。类声明不能包含协议声明。关于类的详细讨论和示例，请参阅 [类和结构体](../chapter2/09_Structures_And_Classes.md)。 +类内可以包含零个或多个声明。这些声明可以包括存储型和计算型属性、实例方法、类型方法、构造器、唯一的析构器、下标、类型别名，甚至其他结构体、类和枚举声明。类声明不能包含协议声明。关于类的详细讨论和示例，请参阅 [类和结构体](../02_language_guide/09_Structures_And_Classes.md)。 一个类只能继承自一个超类，但是可以采纳任意数量的协议。超类紧跟在类名和冒号后面，其后跟着采纳的协议。泛型类可以继承自其它泛型类和非泛型类，但是非泛型类只能继承自其它非泛型类。当在冒号后面写泛型超类的名称时，必须写上泛型类的全名，包括它的泛型形参子句。 @@ -937,13 +937,13 @@ class 类名: 超类, 采纳的协议 { 有两种方法来创建已声明的类的实例： -* 调用类中声明的构造器，请参阅 [构造器](../chapter2/14_Initialization.md#initializers)。 +* 调用类中声明的构造器，请参阅 [构造器](../02_language_guide/14_Initialization.md#initializers)。 -* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../chapter2/14_Initialization.md#default_initializers)。 +* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../02_language_guide/14_Initialization.md#default_initializers)。 -类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../chapter2/09_Structures_And_Classes.md#accessing_properties)。 +类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../02_language_guide/09_Structures_And_Classes.md#accessing_properties)。 -类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../chapter2/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 +类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension_declaration)。 @@ -989,16 +989,16 @@ protocol 协议名称: 继承的协议 { 协议的主体包含零个或多个协议成员声明，这些成员描述了任何采纳该协议的类型必须满足的一致性要求。一个协议可以声明采纳者必须实现的某些属性、方法、构造器以及下标。协议也可以声明各种各样的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议声明不能包括类、结构体、枚举或者其它协议的声明。协议成员声明会在后面进行讨论。 -协议类型可以继承自任意数量的其它协议。当一个协议类型继承自其它协议的时候，来自其它协议的所有要求会聚合在一起，而且采纳当前协议的类型必须符合所有的这些要求。关于如何使用协议继承的例子，请参阅 [协议继承](../chapter2/21_Protocols.md#protocol_inheritance)。 +协议类型可以继承自任意数量的其它协议。当一个协议类型继承自其它协议的时候，来自其它协议的所有要求会聚合在一起，而且采纳当前协议的类型必须符合所有的这些要求。关于如何使用协议继承的例子，请参阅 [协议继承](../02_language_guide/21_Protocols.md#protocol_inheritance)。 > 注意 > -> 也可以使用协议合成类型来聚合多个协议的一致性要求，请参阅 [协议合成类型](./03_Types.md#protocol_composition_type) 和 [协议合成](../chapter2/21_Protocols.md#protocol_composition)。 +> 也可以使用协议合成类型来聚合多个协议的一致性要求，请参阅 [协议合成类型](./03_Types.md#protocol_composition_type) 和 [协议合成](../02_language_guide/21_Protocols.md#protocol_composition)。 > 可以通过类型的扩展声明来采纳协议，从而为之前声明的类型添加协议一致性。在扩展中，必须实现所有采纳协议的要求。如果该类型已经实现了所有的要求，可以让这个扩展声明的主体留空。 -默认地，符合某个协议的类型必须实现所有在协议中声明的属性、方法和下标。即便如此，可以用 `optional` 声明修饰符标注协议成员声明，以指定它们的实现是可选的。`optional` 修饰符仅仅可以用于使用 `objc` 特性标记过的协议。因此，仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用 `optional` 声明修饰符的信息，以及如何访问可选协议成员的指导——例如不能确定采纳协议的类型是否实现了它们时——请参阅 [可选协议要求](../chapter2/21_Protocols.md#optional_protocol_requirements)。 +默认地，符合某个协议的类型必须实现所有在协议中声明的属性、方法和下标。即便如此，可以用 `optional` 声明修饰符标注协议成员声明，以指定它们的实现是可选的。`optional` 修饰符仅仅可以用于使用 `objc` 特性标记过的协议。因此，仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用 `optional` 声明修饰符的信息，以及如何访问可选协议成员的指导——例如不能确定采纳协议的类型是否实现了它们时——请参阅 [可选协议要求](../02_language_guide/21_Protocols.md#optional_protocol_requirements)。 为了限制协议只能被类类型采纳，需要使用 `AnyObject` 关键字来标记协议，将 `AnyObject` 关键在写在冒号后面的继承的协议列表的首位。例如，下面的协议只能被类类型采纳： @@ -1015,9 +1015,9 @@ protocol SomeProtocol: AnyObject { > 如果协议已经用 `objc` 特性标记了，`AnyObject` 要求就隐式地应用于该协议，无需显式使用 `AnyObject` 关键字。 > -协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../chapter2/21_Protocols.md#protocols_as_types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。 +协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../02_language_guide/21_Protocols.md#protocols_as_types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。 -可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托（代理）模式](../chapter2/21_Protocols.md#delegation) 中所述。 +可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托（代理）模式](../02_language_guide/21_Protocols.md#delegation) 中所述。 #### grammer_of_a_protocol_declaration {#grammer-of-a-protocol-declaration} @@ -1076,7 +1076,7 @@ var 属性名: 类型 { get set } 同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了 getter 和 setter 要求，你不能在协议中直接实现 getter 和 setter。 -符合类型可以通过多种方式满足 getter 和 setter 要求。如果属性声明包含 `get` 和 `set` 关键字，符合类型就可以用存储型变量属性或可读可写的计算型属性来满足此要求，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含 `get` 关键字的话，它可以作为任意类型的属性被实现。关于如何实现协议中的属性要求的例子，请参阅 [属性要求](../chapter2/21_Protocols.md#property_requirements) 。 +符合类型可以通过多种方式满足 getter 和 setter 要求。如果属性声明包含 `get` 和 `set` 关键字，符合类型就可以用存储型变量属性或可读可写的计算型属性来满足此要求，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含 `get` 关键字的话，它可以作为任意类型的属性被实现。关于如何实现协议中的属性要求的例子，请参阅 [属性要求](../02_language_guide/21_Protocols.md#property_requirements) 。 协议声明中声明一个类型属性，属性声明语句必须用 `static` 声明修饰符。当结构体和枚举遵循该协议时，使用 `static` 关键字修饰，而类遵循该协议时，使用 `static` 或 `class` 关键字皆可。当结构体，枚举或类添加扩展遵循协议时，和之前扩展用到的关键字保持一致。扩展为类属性提供默认实现时，必须使用 `static` 关键字修饰。 @@ -1093,7 +1093,7 @@ var 属性名: 类型 { get set } > ### 协议方法声明 {#protocol-method-declaration} -协议可以通过在协议声明主体中引入一个协议方法声明，来声明符合的类型必须实现的方法。协议方法声明和函数方法声明有着相同的形式，但有两项例外：它们不包括函数体，也不能包含默认参数。关于如何实现协议中的方法要求的例子，请参阅 [方法要求](../chapter2/21_Protocols.md#method_requirements)。 +协议可以通过在协议声明主体中引入一个协议方法声明，来声明符合的类型必须实现的方法。协议方法声明和函数方法声明有着相同的形式，但有两项例外：它们不包括函数体，也不能包含默认参数。关于如何实现协议中的方法要求的例子，请参阅 [方法要求](../02_language_guide/21_Protocols.md#method_requirements)。 协议声明中声明一个类型方法，方法声明语句必须用 `static` 声明修饰符。结构体和枚举遵循协议时，必须使用 `static` 关键字修饰，而类遵循协议时，使用 `static` 或 `class` 关键字皆可。当结构体，枚举或类添加扩展遵循协议时，和之前扩展用到的关键字保持一致。扩展为类方法提供默认实现时，必须使用 `static` 关键字修饰。 @@ -1155,7 +1155,7 @@ subscript (参数列表) -> 返回类型 { get set } > ### 协议关联类型声明 {#protocol-associated-type-declaration} -使用关键字 `associatedtype` 来声明协议关联类型。关联类型为作为协议声明的一部分，为某种类型提供了一个别名。关联类型和泛型参数子句中的类型参数很相似，但是它们和 `Self` 一样，用于协议中。`Self` 指代采纳协议的类型。要获得更多信息和例子，请参阅 [关联类型](../chapter2/22_Generics.md#associated_types)。 +使用关键字 `associatedtype` 来声明协议关联类型。关联类型为作为协议声明的一部分，为某种类型提供了一个别名。关联类型和泛型参数子句中的类型参数很相似，但是它们和 `Self` 一样，用于协议中。`Self` 指代采纳协议的类型。要获得更多信息和例子，请参阅 [关联类型](../02_language_guide/22_Generics.md#associated_types)。 在协议声明中使用泛型 `where` 子句来为继承的协议关联类型添加约束，且不需要重新声明关联类型。例如下面代码中的 `SubProtocol` 声明。 @@ -1190,7 +1190,7 @@ protocol SubProtocolB: SomeProtocol where SomeType: Equatable { } ## 构造器声明 {#initializer-declaration} 构造器声明会为程序中的类、结构体或枚举引入构造器。构造器使用关键字 `init` 来声明，有两种基本形式。 -结构体、枚举、类可以有任意数量的构造器，但是类的构造器具有不同的规则和行为。不同于结构体和枚举，类有两种构造器，即指定构造器和便利构造器，请参阅 [构造过程](../chapter2/14_Initialization.md)。 +结构体、枚举、类可以有任意数量的构造器，但是类的构造器具有不同的规则和行为。不同于结构体和枚举，类有两种构造器，即指定构造器和便利构造器，请参阅 [构造过程](../02_language_guide/14_Initialization.md)。 采用如下形式声明结构体和枚举的构造器，以及类的指定构造器： @@ -1229,7 +1229,7 @@ convenience init(参数列表) { 就像函数和方法，构造器也可以抛出或者重抛错误，你可以在构造器参数列表的圆括号之后使用 `throws` 或 `rethrows` 关键字来表明相应的抛出行为。 -关于在不同类型中声明构造器的例子，请参阅 [构造过程](../chapter2/14_Initialization.md)。 +关于在不同类型中声明构造器的例子，请参阅 [构造过程](../02_language_guide/14_Initialization.md)。 ### 可失败构造器 {#failable-initializers} 可失败构造器可以生成所属类型的可选实例或者隐式解包可选实例，因此，这种构造器通过返回 `nil` 来指明构造过程失败。 @@ -1268,7 +1268,7 @@ if let actualInstance = SomeStruct(input: "Hello") { 子类可以用任意种类的指定构造器重写超类的可失败指定构造器，但是只能用非可失败指定构造器重写超类的非可失败指定构造器。 -更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../chapter2/14_Initialization.md#failable_initializers)。 +更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../02_language_guide/14_Initialization.md#failable_initializers)。 #### grammer_of_an_initializer_declaration {#grammer-of-an-initializer-declaration} @@ -1311,7 +1311,7 @@ deinit { 析构器不能直接调用。 -关于如何在类声明中使用析构器的例子，请参阅 [析构过程](../chapter2/15_Deinitialization.md)。 +关于如何在类声明中使用析构器的例子，请参阅 [析构过程](../02_language_guide/15_Deinitialization.md)。 #### grammer_of_a_deinitializer_declaration {#grammer-of-a-deinitializer-declaration} @@ -1332,7 +1332,7 @@ extension 类型名称 where 要求 { } ``` -扩展声明体可包含零个或多个声明语句。这些声明语句可以包括计算型属性、计算型类型属性、实例方法、类型方法、构造器、下标声明，甚至是类、结构体和枚举声明。扩展声明不能包含析构器、协议声明、存储型属性、属性观察器或其他扩展声明。关于扩展声明的详细讨论，以及各种扩展声明的例子，请参阅 [扩展](../chapter2/20_Extensions.md)。 +扩展声明体可包含零个或多个声明语句。这些声明语句可以包括计算型属性、计算型类型属性、实例方法、类型方法、构造器、下标声明，甚至是类、结构体和枚举声明。扩展声明不能包含析构器、协议声明、存储型属性、属性观察器或其他扩展声明。关于扩展声明的详细讨论，以及各种扩展声明的例子，请参阅 [扩展](../02_language_guide/20_Extensions.md)。 如果类型为类，结构体，或枚举类型，则扩展声明会扩展相应的类型。如果类型为协议类型，则扩展声明会扩展所有遵守这个协议的类型。在扩展的协议体中声明语句不能使用 `final` 标识符。 @@ -1542,7 +1542,7 @@ subscript (参数列表) -> 返回类型 { 同样可以在协议声明中声明下标，正如 [协议下标声明](#protocol_subscript_declaration) 中所述。 -更多关于下标的信息和例子，请参阅 [下标](../chapter2/12_Subscripts.md)。 +更多关于下标的信息和例子，请参阅 [下标](../02_language_guide/12_Subscripts.md)。 ### 类型下标声明 @@ -1611,7 +1611,7 @@ postfix operator 运算符名称 {} 和前缀运算符一样，后缀运算符的声明中不指定优先级，而且后缀运算符是非结合的。 -声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../chapter2/26_Advanced_Operators.md#custom_operators)。 +声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom_operators)。 #### grammer_of_an_operator_declaration {#grammer-of-an-operator-declaration} @@ -1734,13 +1734,13 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用， `lazy` -该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在它被第一次访问时。关于如何使用 `lazy` 修饰符的例子，请参阅 [惰性存储型属性](../chapter2/10_Properties.md#lazy_stored_properties)。 +该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在它被第一次访问时。关于如何使用 `lazy` 修饰符的例子，请参阅 [惰性存储型属性](../02_language_guide/10_Properties.md#lazy_stored_properties)。 `optional` 该修饰符用于修饰协议中的属性、方法以及下标成员，表示符合类型可以不实现这些成员要求。 -只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../chapter2/21_Protocols.md#optional_protocol_requirements)。 +只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../02_language_guide/21_Protocols.md#optional_protocol_requirements)。 `required` @@ -1752,7 +1752,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用， `unowned` -该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会引发运行时错误。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../chapter2/23_Automatic_Reference_Counting.md#unowned_references) +该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会引发运行时错误。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../02_language_guide/24_Automatic_Reference_Counting.md#unowned_references) `unowned(safe)` @@ -1760,14 +1760,14 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用， `unowned(unsafe)` -该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会直接访问该对象释放前存储的内存地址，因此这是非内存安全的操作。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../chapter2/23_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 +该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会直接访问该对象释放前存储的内存地址，因此这是非内存安全的操作。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 `weak` -该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../chapter2/23_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 +该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 ### 访问控制级别 {#access-control-levels} -Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../chapter2/25_Access_Control.md) 中有详细讨论。 +Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../02_language_guide/26_Access_Control.md) 中有详细讨论。 `public` @@ -1781,7 +1781,7 @@ Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private` 该修饰符表示声明只能被所在源文件的代码访问。 -以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../chapter2/25_Access_Control.md#getters_and_setters) 中所讨论的。 +以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../02_language_guide/26_Access_Control.md#getters_and_setters) 中所讨论的。 #### grammer_of_a_declaration_modifier {#grammer-of-a-declaration-modifier} diff --git a/source/chapter3/07_Attributes.md b/source/03_language_reference/07_Attributes.md similarity index 99% rename from source/chapter3/07_Attributes.md rename to source/03_language_reference/07_Attributes.md index 7bc8d6e8..91093af8 100755 --- a/source/chapter3/07_Attributes.md +++ b/source/03_language_reference/07_Attributes.md @@ -429,7 +429,7 @@ Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特 ### `autoclosure` {#autoclosure} -这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 `autoclosure` 特性的例子，请参阅 [自动闭包](../chapter2/07_Closures.md#autoclosures) 和 [函数类型](./03_Types.md#function_type)。 +这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 `autoclosure` 特性的例子，请参阅 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 和 [函数类型](./03_Types.md#function_type)。 ### `convention` {#convention} @@ -447,7 +447,7 @@ Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特 ### `escaping` {#escaping} -在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行。这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 特性声明的函数类型中访问属性和方法时需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../chapter2/07_Closures.md#escaping_closures)。 +在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行。这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 特性声明的函数类型中访问属性和方法时需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../02_language_guide/07_Closures.md#escaping_closures)。 ## Switch Case 特性 {#switch-case-attributes} diff --git a/source/chapter3/08_Patterns.md b/source/03_language_reference/08_Patterns.md similarity index 96% rename from source/chapter3/08_Patterns.md rename to source/03_language_reference/08_Patterns.md index 806a7347..8a0073e5 100755 --- a/source/chapter3/08_Patterns.md +++ b/source/03_language_reference/08_Patterns.md @@ -129,7 +129,7 @@ let (a): Int = 2 // a: Int = 2 ## 枚举用例模式（Enumeration Case Pattern） {#enumeration-case-pattern} *枚举用例模式*匹配现有的某个枚举类型的某个用例。枚举用例模式出现在 `switch` 语句中的 `case` 标签中，以及 `if`、`while`、`guard` 和 `for-in` 语句的 `case` 条件中。 -如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../chapter2/08_Enumerations.md#associated_values)。 +如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../02_language_guide/08_Enumerations.md#associated_values)。 > 枚举用例模式语法 > @@ -188,7 +188,7 @@ for case let number? in arrayOfOptinalInts { `as` 模式仅当一个值的类型在运行时和 `as` 模式右边的指定类型一致，或者是其子类的情况下，才会匹配这个值。如果匹配成功，被匹配的值的类型被转换成 `as` 模式右边指定的类型。 -关于使用 `switch` 语句配合 `is` 模式和 `as` 模式来匹配值的例子，请参阅 [Any 和 AnyObject 的类型转换](../chapter2/18_Type_Casting.md#type_casting_for_any_and_anyobject)。 +关于使用 `switch` 语句配合 `is` 模式和 `as` 模式来匹配值的例子，请参阅 [Any 和 AnyObject 的类型转换](../02_language_guide/18_Type_Casting.md#type_casting_for_any_and_anyobject)。 > 类型转换模式语法 > diff --git a/source/chapter3/09_Generic_Parameters_and_Arguments.md b/source/03_language_reference/09_Generic_Parameters_and_Arguments.md similarity index 97% rename from source/chapter3/09_Generic_Parameters_and_Arguments.md rename to source/03_language_reference/09_Generic_Parameters_and_Arguments.md index 98b487ba..f56d1f69 100755 --- a/source/chapter3/09_Generic_Parameters_and_Arguments.md +++ b/source/03_language_reference/09_Generic_Parameters_and_Arguments.md @@ -2,7 +2,7 @@ 本节涉及泛型类型、泛型函数以及泛型构造器的参数，包括形参和实参。声明泛型类型、函数或构造器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型构造器时，就用具体的类型实参替代之。 -关于 Swift 语言的泛型概述，请参阅 [泛型](../chapter2/22_Generics.md)。 +关于 Swift 语言的泛型概述，请参阅 [泛型](../02_language_guide/22_Generics.md)。 ## 泛型形参子句 {#generic-parameter} *泛型形参子句*指定泛型类型或函数的类型形参，以及这些参数相关的约束和要求。泛型形参子句用尖括号（`<>`）包住，形式如下： @@ -51,7 +51,7 @@ simpleMax(3.14159, 2.71828) // T 被推断为 Double 类型 泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会根据这些约束来决定调用哪个重载函数或构造器。 -更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](../chapter2/22_Generics.md#where_clauses)。 +更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](../02_language_guide/22_Generics.md#where_clauses)。 > 泛型形参子句语法 > diff --git a/source/chapter3/10_Summary_of_the_Grammar.md b/source/03_language_reference/10_Summary_of_the_Grammar.md similarity index 100% rename from source/chapter3/10_Summary_of_the_Grammar.md rename to source/03_language_reference/10_Summary_of_the_Grammar.md diff --git a/source/chapter3/chapter3.md b/source/03_language_reference/chapter3.md similarity index 64% rename from source/chapter3/chapter3.md rename to source/03_language_reference/chapter3.md index 227aa9e7..051b2ee4 100755 --- a/source/chapter3/chapter3.md +++ b/source/03_language_reference/chapter3.md @@ -1,3 +1,3 @@ -# Swift 教程 +# Swift 语言参考 本章描述了 Swift 的语言参考。 \ No newline at end of file diff --git a/source/04_revision_history/04_revision_history.md b/source/04_revision_history/04_revision_history.md new file mode 100644 index 00000000..3a857ea6 --- /dev/null +++ b/source/04_revision_history/04_revision_history.md @@ -0,0 +1,267 @@ +# Swift 文档修订历史 + +### 2019-06-03 + +* 更新至 Swift 5.1。 +* 在 [不透明类型](../02_language_guide/23_Opaque_Types.md) 篇章中新增了有关函数返回值遵循指定协议，而不需要提供指定返回类型的内容。 +* 新增 [隐式返回的函数](../02_language_guide/06_Functions.md#functions-with-an-implicit-return) 和 [简化 Getter 声明](../02_language_guide/10_Properties.md#shorthand-getter-declaration) 章节，其中包含函数省略 `return` 的内容。 +* 在 [类型下标](../02_language_guide/12_Subscripts.md#type-subscripts) 章节中新增有关在类型中使用下标的内容。 +* 更新 [结构体的逐一成员构造器](../02_language_guide/14_Initialization.md#memberwise-initializers-for-structure-types) 章节，现在逐一成员构造器支持在属性有默认值时省略形参。 +* 在 [动态查找成员](../03_language_reference/07_Attributes.md#dynamicmemberlookup) 章节中新增了有关在运行时用 key path 查找动态成员的内容。 +* 更新 [自身类型](../03_language_reference/03_Types.md#self-type-h) 章节，现在 `Self` 可以指向当前类，结构体或者枚举声明时的类型。 + +### 2019-03-25 + +* 更新至 Swift 5。 +* 新增 [拓展字符串分隔符](../02_language_guide/03_Strings_And_Characters.md#extended-string-delimiters) 章节。更新 [字符串字面量](../03_language_reference/03_Lexical_Structure.md#string-literal) 章节，拓展有关字符串分隔符的内容。 +* 新增 [动态调用](../03_language_reference/07_Attributes.md#dynamiccallable) 章节，其中包含使用 `dynamicCallable` 属性动态调用实例作为函数的内容。 +* 新增 [unknown](../03_language_reference/07_Attributes.md#unknown) 和 [未来枚举匹配](../03_language_reference/05_Statements.md#future-case2) 章节，其中包含了使用 `unknown` 来处理未来枚举可能发生改变的情形。 +* 在 [Key-Path 表达式](../03_language_reference/04_Expressions.md#key-path-expression) 章节新增了有关标示 key path (\\.self) 的内容。 +* 在 [可选编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了有关小于比较符 `<` 的内容。 + +### 2018-09-17 + +* 更新至 Swift 4.2。 +* 在 [遍历枚举情形](../02_language_guide/08_Enumerations.md#iterating-over-enumeration-cases) 章节新增了有关访问所有枚举情形的内容。 +* 在 [编译诊断](../03_language_reference/05_Statements.md#compile-time-diagnostic-statement) 章节新增了有关 `#error` 和 `#warning` 的内容。 +* 在 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `inlinable` 和 `usableFromInline` 属性的内容。 +* 在 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `requires_stored_property_inits` 和 `warn_unqualified_access` 属性的内容。 +* 在 [可选编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了有关如何根据 Swift 编译器版本对代码进行对应编译处理的内容。 +* 在 [字面量语法](../03_language_reference/04_Expressions.md#literal-expression) 章节新增了有关 `#dsohandle` 的内容。 + +### 2018-03-29 + +* 更新至 Swift 4.1。 +* 在 [等价运算符](../02_language_guide/27_Advanced_Operators.md#equivalence-operators) 章节新增了有关等价运算符的合成实现的内容。 +* 在 [声明](../03_language_reference/06_Declarations.md) 篇章中 [申明拓展](../03_language_reference/06_Declarations.md#extension-declaration) 章节和 [协议](../02_language_guide/21_Protocols.md) 篇章中 [有条件地遵循协议](../02_language_guide/21_Protocols.md#Conditionally-Conforming-to-a-Protocol) 章节新增了有关协议有条件遵循的内容。 +* 在 [关联类型约束中使用协议](../02_language_guide/22_Generics.md#using-a-protocol-in-its-associated-types-constraints) 章节中新增了有关递归协议约束的内容。 +* 在 [条件编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中新增了有关 `canImport()` 和 `targetEnvironment()` 平台条件的内容。 + +### 2017-12-04 + +* 更新至 Swift 4.0.3。 +* 更新 [Key-Path 表达式](../03_language_reference/04_Expressions.md#key-path-expression) 章节，现在 key path 支持下标子路径。 + +### 2017-09-19 + +* 更新至 Swift 4.0。 +* 在 [内存安全](../02_language_guide/24_MemorySafety.md) 章节新增了有关内存互斥访问的内容。 +* 新增 [带有泛型 Where 子句联类型](../02_language_guide/22_Generics.md#associated-types-with-a-generic-where-clause) 章节，现在可以使用泛型 `where` 子句约束关联类型。 +* 在 [字符串和字符](../02_language_guide/03_Strings_And_Characters.md) 篇章中 [字面量](../02_language_guide/03_Strings_And_Characters.md#string-literals) 章节以及 [词法结构](../03_language_reference/02_Lexical_Structure.md) 篇章的 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节中新增了有关多行字符串字面量的内容。 +* 更新 [声明属性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 中 `objc` 属性的讨论，现在该属性会在更少的位置被推断出来。 +* 新增 [范型下标](../02_language_guide/22_Generics.md#generic-subscripts) 章节，现在下标也支持范型特性了。 +* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03_language_reference/03_Types.md) 篇章中 [协议组合类型](../03_language_reference/03_Types.md#protocol-composition-type-h) 章节的讨论，现在协议组合类型支持进行父类约束了。 +* 更新 [拓展声明](../03_language_reference/06_Declarations.md#extension-declaration) 中有关协议扩展的讨论，现在它们不支持 `final` 特性了。 +* 在 [断言和前置条件](../02_language_guide/01_TheBasics.md#assertions-and-preconditions) 章节中新增了部分前置条件和致命错误的内容。 + +### 2017-03-27 + +* 更新至 Swift 3.1。 +* 新增 [范型 Where 子句扩展](../02_language_guide/22_Generics.md#extensions-with-a-generic-where-clause) 章节，包含需要的扩展内容。 +* 在 [For-In 循环](../02_language_guide/05_Control_Flow.md#for-in-loops) 章节中新增了区间迭代的例子。 +* 在 [到可失败构造器](http://typora-app/02_language_guide/14_Initialization.md#failable-initializers) 章节中新增了可失败数值转换的例子。 +* 在 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关使用 Swift 语言版本的 `available` 特性的内容 。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节中的讨论，注意在写函数类型时不允许使用参数标签。 +* 更新 [条件编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中的 Swift 语言版本号的讨论，现在可以使用可选的补丁版本号。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节的讨论，现在 Swift 区分了采用多参数的函数和采用元组类型的单个参数的函数。 +* 在 [表达式](../03_language_reference/04_Expressions.md) 篇章中删除了动态表达式的章节，现在 `type(of:)` 是 Swift 标准库函数。 + +### 2016-10-27 + +* 更新至 Swift 3.0.1。 +* 更新 [自动引用计数](../02_language_guide/24_Automatic_Reference_Counting.md) 章节中有关 weak 和 unowned 引用的讨论。 +* 在 [声明标识符](../03_language_reference/06_Declarations.md#declaration-modifiers) 章节中新增了有关新的标识符 `unowned`，`unowend(safe)` 和 `unowned(unsafe)` 的内容。 +* 在 [Any 和 AnyObject 的类型转换](../02_language_guide/18_Type_Casting.md#type-casting-for-any-and-anyobject) 章节中新增了一处说明，有关使用类型 `Any` 作为可选值。 +* 更新 [表达式](../03_language_reference/04_Expressions.md) 章节，把括号表达式和元组表达式的描述分开。 + +### 2016-09-13 + +* 更新至 Swift 3.0。 +* 更新 [函数](../02_language_guide/06_Functions.md) 篇章和 [函数声明](../03_language_reference/06_Declarations.md#function-declaration) 章节中有关函数的讨论，所有函数参数默认都有函数标签。 +* 更新 [高级操作符](../02_language_guide/27_Advanced_Operators.md) 篇章中有关操作符的讨论，现在你可以作为类型函数来实现，替代之前的全局函数实现方式。 +* 在 [访问控制](../02_language_guide/26_Access_Control.md) 章节中新增有关对新的访问级别描述符 `open` 和 `fileprivate` 的内容。 +* 更新 [函数声明](../03_language_reference/06_Declarations.md#function-declaration) 章节中有关 `inout` 的讨论，注意它现在出现在参数类型的前面，而不是在参数名称的前面。 +* 更新 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 和 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节还有 [属性](../03_language_reference/07_Attributes.md) 篇章中有关 `@noescape` 和 `@autoclosure` 的讨论，现在他们是类型属性，而不是定义属性。 +* 在 [高级操作符](../02_language_guide/27_Advanced_Operators.md) 篇章中 [自定义中缀操作符的优先级](./02_language_guide/27_Advanced_Operators.md#precedence-and-associativity-for-custom-infix-operators) 章节和 [定义](../03_language_reference/06_Declarations.md) 篇章中 [优先级组声明](../03_language_reference/06_Declarations.md#precedence-group-declaration-modifiers) 章节中新增了有关操作符优先级组的内容。 +* 更新一些讨论，使用 macOS 替换掉 OS X， Error 替换掉 ErrorProtocol。更新一些协议名称，比如使用 ExpressibleByStringLiteral 替换掉 StringLiteralConvertible。 +* 更新 [泛型](../02_language_guide/22_Generics.md) 篇章中 [泛型 Where 语句](../02_language_guide/22_Generics.md#extensions-with-a-generic-where-clause) 章节和 [泛型形参和实参](../03_language_reference/09_Generic_Parameters_And_Arguments.md) 篇章的讨论，现在泛型的 where 语句写在一个声明的最后。 +* 更新 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 章节中的讨论，现在闭包默认为非逃逸的。 +* 更新 [基础部分](../02_language_guide/01_TheBasics.md) 篇章中 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章中 [While 语句](../03_language_reference/05_Statements.md#while-statement) 章节中的讨论，现在 if，`while` 和 `guard` 语句使用逗号分隔条件列表，不需要使用 `where` 语句。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章中 [Switch](../02_language_guide/05_Control_Flow.md#switch) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章中 [Switch 语句](../03_language_reference/05_Statements.md#switch-statement) 章节中新增了 switch cases 可以使用多模式的内容。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节有关现在函数参数标签不包含在函数类型中的讨论。 +* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03_language_reference/03_Types.md) 篇章中 [协议组合类型](../03_language_reference/03_Types.md#protocol-composition-type-h) 章节中有关使用新的 Protocol1 & Protocol2 语法的内容。 +* 更新动态类型表达式章节中使用新的 `type(of:)` 表达式的讨论。 +* 更新 [行控制表达式](../03_language_reference/05_Statements.md#line-control-statement) 章节中使用 `#sourceLocation(file:line:)` 表达式的讨论。 +* 更新 [永不返回函数](../03_language_reference/06_Declarations.md#functions-that-never-return) 章节中使用 新的 `Never` 类型的讨论。 +* 在 [字面量表达式](../03_language_reference/04_Expressions.md#literal-expression) 章节中新增了有关 `playground` 字面量的内容。 +* 更新 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out_parameters) 章节，标明只有非逃逸闭包能捕获 `in-out` 参数。 +* 更新 [默认参数值](../02_language_guide/06_Functions.md#default-parameter-values) 章节，现在默认参数不能在调用时候重新排序。 +* 更新 [属性](../03_language_reference/07_Attributes.md) 篇章中有关属性参数使用分号的说明。 +* 在 [重新抛出函数和方法](../03_language_reference/06_Declarations.md#rethrowing-functions-and-methods) 章节中新增了有关在 catch 代码块中抛出错误的重新抛出函数的内容。 +* 在 [Selector 表达式](../03_language_reference/04_Expressions.md#selector-expression7) 章节中新增了中有关访问 Objective-C 中 Selector 的 getter 和 setter 的内容。 +* 在 [类型别名声明](../03_language_reference/06_Declarations.md#type-alias-declaration) 章节中中新增了有关泛型类型别名和在协议内使用类型别名的内容。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节中有关函数类型的讨论，标明函数类型作为参数类型必须使用括号包裹。 +* 更新 [属性](../03_language_reference/07_Attributes.md) 篇章，标明 `@IBAction`，`@IBOutlet` 和 `@NSManaged` 隐式含有 `@objc` 属性。 +* 在 [声明属性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `@GKInspectable` 的内容。 +* 更新 [可选协议要求](../02_language_guide/21_Protocols.md#optional-protocol-requirements) 章节中有关只能在与 `Objective-C` 交互的代码中才能使用可选协议要求的内容。 +* 删除 [函数声明](../03_language_reference/06_Declarations.md#function-declaration) 章节中有关显式使用 `let` 关键字作为函数参数的内容。 +* 删除 [语句](../03_language_reference/05_Statements.md) 章节中有关 `Boolean` 协议的内容， 现在这个协议已经被 Swift 标准库删除。 +* 更正 [声明属性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@NSApplicationMain` 协议的内容。 + +### 2016-03-21 + +* 更新至 Swift 2.2。 +* 在 [编译配置语句](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了中有关如何根据 Swift 版本进行条件编译。 +* 在 [显示成员表达式](../03_language_reference/04_Expressions.md#explicit-member-expression) 章节中新增了有关如何区分只有参数名不同的方法和构造器的内容。 +* 在 [选择器表达式](../03_language_reference/04_Expressions.md#selector-expression7) 章节中新增了了针对 Objective-C 选择器的 `#selector` 语法。 +* 更新 [关联类型](../02_language_guide/22_Generics.md#associated-types) 和 [协议关联类型声明](../03_language_reference/06_Declarations.md#protocol_associated_type_declaration) 章节中有关使用 `associatedtype` 关键词修饰关联类型的讨论。 +* 更新 [可失败构造器](../02_language_guide/14_Initialization.md#failable-initializers) 章节中有关当构造器在实例完全初始化之前返回 `nil` 的相关内容。 +* 在 [比较运算符](../02_language_guide/BasicOperators.md#comparison-operators) 章节中新增了比较元组的内容。 +* 在 [关键字和标点符号](../03_language_reference/02_Lexical_Structure.md#keywords-and-punctuation) 章节中新增了使用关键字作为外部参数名的内容。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@objc` 特性的讨论，并指出枚举和枚举用例。 +* 更新 [操作符](../03_language_reference/02_Lexical_Structure.md#operator) 章节中对于自定义运算符的包含了 `.` 的讨论。 +* 在 [重新抛出错误的函数和方法](../03_language_reference/06_Declarations.md#rethrowing-functions-and-methods) 章节中新增了一处说明，重新抛出错误函数不能直接抛出错误。 +* 在 [属性观察器](../02_language_guide/10_Properties.md#property-observers) 章节中新增了一处说明，当作为 in-out 参数传递属性时，属性观察器的调用行为。 +* 在 [Swift 初见](./03_a_swift_tour.md) 篇章中新增了错误处理的章节。 +* 更新 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节中的图片用以更清楚的展示重新分配过程。 +* 删除 C 语言风格的 `for` 循环，`++` 前缀和后缀运算符，以及 `--` 前缀和后缀运算符。 +* 删除对变量函数参数和柯里化函数的特殊语法的讨论。 + +### 2015-10-20 + +* 更新至 Swift 2.1。 +* 更新 [字符串插值](../02_language_guide/03_Strings_And_Characters.md#string-interpolation) 和 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节，现在字符串插值可包含字符串字面量。 +* 在 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 章节中新增了有关 `@noescape` 属性的相关内容。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 和 [编译配置语句](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中与 tvOS 相关的内容。 +* 在 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out_parameters) 章节中新增了与 in-out 参数行为相关的内容。 +* 在 [捕获列表](../03_language_reference/04_Expressions.md#capture-lists) 章节新增了有关指定闭包捕获列表被捕获时捕获值的相关内容。 +* 更新 [可选链式调用访问属性](../02_language_guide/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 章节，阐明了如何通过可选链式调用进行赋值。 +* 改进 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节中对自闭包的讨论。 +* 在 [Swift 初见](./03_a_swift_tour.md) 篇章中新增了一个使用 `??` 操作符的例子。 + +### 2015-09-16 + +* 更新至 Swift 2.0。 +* 在 [错误处理](../02_language_guide/17_Error_Handling.md) 篇章中新增了有关错误处理的相关内容，包括 [Do 语句](../03_language_reference/05_Statements.md#do-statement)、 [Throw 语句](../03_language_reference/05_Statements.md#throw-statement)、 [Defer 语句](../03_language_reference/05_Statements.md##defer-statements) 以及 [try 运算符](../03_language_reference/04_Expressions.md#try-operator)。 +* 更新 [错误表示和抛出](../02_language_guide/17_Error_Handling.md#representing-and-throwing-errors) 章节，现在所有类型都可以遵循 `ErrorType` 协议了。 +* 在 [将错误装换成可选值](../02_language_guide/17_Error_Handling.md#converting_errors_to_optional_values) 篇章增加了 `try?` 关键字相关内容。 +* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [递归枚举](../02_language_guide/08_Enumerations.md#recursive-enumerations) 章节以及以及 [声明](../03_language_reference/06_Declarations.md) 篇章的 [任意类型用例的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-any-type) 章节中新增了递归枚举相关内容。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [API 可用性检查](../02_language_guide/05_Control_Flow.md#checking-api-availability) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章的 [可用性条件](../03_language_reference/05_Statements.md#availability-condition) 章节中新增了有关 API 可用性检查相关的内容。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [尽早退出](../02_language_guide/05_Control_Flow.md#early-exit) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章的 [Guard 语句](../03_language_reference/05_Statements.md#guard-statement) 章节新增了与 `guard` 语句相关的内容。 +* 在 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议扩展](../02_language_guide/21_Protocols.md#protocol-extensions) 章节中新增了有关协议扩展的内容。 +* 在 [访问控制](../02_language_guide/26_Access_Control.md) 篇章的 [单元测试 target 的访问级别](../02_language_guide/26_Access_Control.md#access-levels-for-unit-test-targets) 章节中新增了有关单元测试访问控制相关的内容。 +* 在 [模式](../03_language_reference/08_Patterns.md) 篇章的 [可选模式](../03_language_reference/08_Patterns.md#optional-pattern) 章节中新增了可选模式相关内容。 +* 更新 [Repeat-While](../02_language_guide/05_Control_Flow.md#repeat-while) 章节中有关 `repeat-while` 循环相关的内容。 +* 更新 [字符串和字符](../02_language_guide/03_Strings_And_Characters.md) 章节，现在 `String` 类型在 Swift 标准库中不再遵循 `CollectionType` 协议。 +* 在 [常量与变量打印](../02_language_guide/01_TheBasics.md#printing) 章节中新增了新 Swift 标准库中有关 `print(_:separator:terminator) ` 相关内容。 +* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [原始值的隐式赋值](../02_language_guide/08_Enumerations.md#implicitly-assigned-raw-values) 章节和 [声明](../03_language_reference/06_Declarations.md) 篇章的 [包含原始值类型的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-a-raw-value-type) 章节中新增了有关包含 `String` 原始值的枚举用例的行为相关内容。 +* 在 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节中新增了有关 `@autoclosure` 特性的相关内容，包括它的 `@autoclosure(escaping)` 形式。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@avaliable` 和 `warn_unused_result` 特性的相关内容。 +* 更新 [类型特性](../03_language_reference/07_Attributes.md#type-attributes) 章节中有关 `@convention` 特性的相关内容。 +* 在 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding) 章节中新增了有关使用 `where` 子句进行多可选绑定的相关内容。 +* 在 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节中新增了有关在编译时使用 `+` 运算符拼接字符串字面量的相关内容。 +* 在 [元类型](../03_language_reference/03_Types.md#metatype-type-h) 章节中新增了有关元类型值的比较和使用它们通过构造器表达式构造实例相关内容。 +* 在 [断言调试](../02_language_guide/01_TheBasics.md#debugging-with-assertions) 章节中新增了一处说明，有关用户定义断言何时会失效。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中对 `@NSManaged` 特性的讨论，现在这个特性可以被应用到一个确定实例方法。 +* 更新 [可变参数](../02_language_guide/06_Functions.md#variadic-parameters) 章节，现在可变参数可以声明在函数参数列表的任意位置中。 +* 在 [重写可失败构造器](../02_language_guide/14_Initialization.md#overriding-a-failable-initializer) 章节中新增了有关非可失败构造器相当于一个可失败构造器通过父类构造器的结果进行强制拆包的相关内容。 +* 在 [任意类型用例的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-any-type) 章节中新增了有关枚举用例作为函数的内容。 +* 在 [构造器表达式](../03_language_reference/04_Expressions.md#initializer-expression) 章节中新增了有关显式引用一个构造器相关内容。 +* 在 [编译控制语句](../03_language_reference/05_Statements.md#compiler-control-statements) 章节中新增了有关编译内容以及行控制语句相关内容。 +* 在 [元类型](../03_language_reference/03_Types.md#metatype-type-h) 章节新增了一处说明，有关如何从元类型值中构造类实例相关内容。 +* 在 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节新增了一处说明，有关弱引用作为缓存所存在的不足。 +* 更新 [类型特性](../02_language_guide/10_Properties.md#type-properties) 章节，提到了存储型特性其实是懒加载。 +* 更新 [捕获类型](../02_language_guide/07_Closures.md#capturing_values) 章节，阐明了变量和常量在闭包中如何被捕获。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节，用以描述何时在类中使用 `@objc` 关键字。 +* 在 [错误处理](../02_language_guide/17_Error_Handling.md#handling-errors) 章节中新增了一处说明，有关执行 `throw` 语句的性能。在 [Do 语句](../03_language_reference/05_Statements.md#do-statement) 章节的 do 语句部分也新增了类似内容。 +* 更新 [类型特性](../02_language_guide/10_Properties.md#type-properties) 章节中有关类、结构体和枚举的存储型和计算型特性相关的内容。 +* 更新 [Break 语句](../03_language_reference/05_Statements.md#break_statement) 章节中有关带标签的 break 语句相关内容。 +* 在 [属性观察器](../02_language_guide/10_Properties.md#property-observers) 章节更新了一处说明，用来明确 `willSet` 和 `didSet` 观察器的行为。 +* 在 [访问级别](../02_language_guide/26_Access_Control.md#access-levels) 章节新增了有关 `private` 作用域的相关内容说明。 +* 在 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节新增了有关弱应用在垃圾回收系统和 ARC 之间的区别的说明。 +* 更新 [字符串字面量中特殊字符](../02_language_guide/03_Strings_And_Characters.md#special-characters-in-string-literals) 章节，对 Unicode 标量更精确定义。 + + +### 2015-04-08 + +* 更新至 Swift 1.2。 +* Swift 现在自身提供了一个 `Set` 集合类型，更多内容，请看 [Sets](../02_language_guide/CollectionTypes.md#sets) 。 +* `@autoclosure` 现在是一个参数声明的属性，而不是参数类型的属性。这里还有一个新的参数声明属性 `@noescape`。更多内容，请看 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 。 +* 对于类型属性和方法现在可以使用 `static` 关键字作为声明描述符，更多内容，请看 [类型变量属性](../03_language_reference/06_Declarations.md#type-variable-properties)。 +* Swift 现在包含一个 `as?` 和 `as!` 的向下可失败类型转换运算符。更多内容，请看 [协议遵循性检查](../02_language_guide/21_Protocols.md#checking-for-protocol-conformance)。 +* 新增 [字符串索引](../02_language_guide/03_Strings_And_Characters.md#string-indices) 的新指导章节。 +* 在 [溢出运算符](../02_language_guide/27_Advanced_Operators.md#overflow-operators) 一节中删除了溢出除运算符（`&/`）和求余溢出运算符（`&%`）。 +* 更新常量和常量属性在声明和构造时的规则，更多内容，请看 [常量声明](../03_language_reference/06_Declarations.md#constant-declaration) 。 +* 更新字符串字面量中 Unicode 标量集的定义，请看 [字符串字面量中的特殊字符](../02_language_guide/03_Strings_And_Characters.md#special-characters-in-string-literals) 。 +* 更新 [区间运算符](../02_language_guide/BasicOperators.md#range-operators) 章节，注意当半开区间运算符含有相同的起止索引时，其区间为空。 +* 更新 [闭包引用类型](../02_language_guide/07_Closures.md#closures-are-reference-types) 章节，对于变量的捕获规则进行了阐明。 +* 更新 [值溢出](../02_language_guide/27_Advanced_Operators.md#value-overflow) 章节，对有符号整数和无符号整数的溢出行为进行了阐明。 +* 更新 [协议声明](../03_language_reference/06_Declarations.md#protocol-declaration) 章节，对协议声明时的作用域和成员等内容进行了阐明。 +* 更新 [捕获列表](../02_language_guide/24_Automatic_Reference_Counting.md#defining-a-capture-list) 章节，对于闭包捕获列表中的弱引用和无主引用的使用语法进行了阐明。 +* 更新 [运算符](../03_language_reference/02_Lexical_Structure.md#operator) 章节，明确指明一些例子来说明自定义运算符所支持的特性，如数学运算符，各种符号，Unicode 符号块等。 +* 在函数作用域中的常量声明时可以不被初始化，它必须在第一次使用前被赋值。更多的内容，请看 [常量声明](../03_language_reference/06_Declarations.md#constant-declaration)。 +* 在构造器中，常量属性有且仅能被赋值一次。更多内容，请看 [在构造过程中给常量属性赋值](../02_language_guide/14_Initialization.md{#assigning-constant-properties-during-initialization)。 +* 多个可选绑定现在可以在`if`语句后面以逗号分隔的赋值列表的方式出现，更多内容，请看 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding)。 +* 一个 [可选链表达式](../03_language_reference/04_Expressions.md#optional-chaining-expression) 必须出现在后缀表达式中。 +* 协议类型转换不再局限于 `@obj` 修饰的协议了。 +* 在运行时可能会失败的类型转换可以使用 `as?` 和 `as!` 运算符，而确保不会失败的类型转换现在使用 `as` 运算符。更多内容，请看 [类型转换运算符](../03_language_reference/04_Expressions.md#type-casting-operator)。 + +### 2014-10-16 + +* 更新至 Swift 1.1。 +* 新增 [失败构造器](../02_language_guide/14_Initialization.md#failable-initializers) 的完整指引。 +* 在协议中新增了 [失败构造器要求](../02_language_guide/21_Protocols.md#failable-initializer-requirements) 的描述。 +* 常量和变量的 `Any` 类型现可以包含函数实例。更新了有关 `Any` 相关的示例来展示如何在 `switch` 语句中如何检查并转换到一个函数类型。 +* 带有原始值的枚举类型增加了一个 `rawValue` 属性替代 `toRaw()` 方法，同时使用了一个以 `rawValue` 为参数的失败构造器来替代 `fromRaw()` 方法。更多的内容，请看 [原始值](../02_language_guide/08_Enumerations.md#raw-values) 和 [带原始值的枚举类型](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-a-raw-value-type)。 +* 新增 [Failable Initializer](../03_language_reference/06_Declarations.md#failable-initializers) 的参考章节，它可以触发初始化失败。 +* 自定义运算符现在可以包含 `?` 字符，更新了 [运算符](../03_language_reference/02_Lexical_Structure.md#operator) 涉及改进后的规则的部分，并且在 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom-operators) 章节中删除了重复的运算符有效字符集合。 + +### 2014-08-18 + +* 描述 Swift 1.0 的新文档。Swift 是苹果公司发布的全新编程语言，用于 iOS 和 OS X 应用开发。 +* 在协议中新增了 [对构造器的规定](../02_language_guide/21_Protocols.md#initializer-requirements) 章节。 +* 新增 [类专属协议](../02_language_guide/21_Protocols.md#class-only-protocol) 章节。 +* [断言](../02_language_guide/01_TheBasics.md#assertions-and-preconditions) 现在可以使用字符串内插语法，并删除了文档中有冲突的注释。 +* 更新 [连接字符串和字符](../02_language_guide/03_Strings_And_Characters.md#concatenating-strings-and-characters) 章节来说明字符串和字符不能再用 `+` 号运算符或者复合加法运算符 `+=` 相互连接，这两种运算符现在只能用于字符串之间相连。请使用 `String` 类型的 `append` 方法在一个字符串的尾部增加单个字符。 +* 在 [属性申明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节增加了有关 `availability` 特性的一些内容。 +* [可选类型](../02_language_guide/01_TheBasics.md#optionals) 若有值时，不再隐式的转换为 `true`，同样，若无值时，也不再隐式的转换为 `false`，这是为了避免在判别 optional `Bool` 的值时产生困惑。 替代的方案是，用`==` 或 `!=` 运算符显式地去判断 Optinal 是否是 `nil`，以确认其是否包含值。 +* Swift 新增了一个 [Nil 合并运算符](../02_language_guide/BasicOperators.md#nil-coalescing-operator) (`a ?? b`) , 该表达式中，如果 Optional `a` 的值存在，则取得它并返回，若 Optional `a` 为 `nil`，则返回默认值 `b` +* 更新和扩展 [字符串的比较](../02_language_guide/03_Strings_And_Characters.md#comparing-strings) ，用以反映和展示'字符串和字符的比较'，以及'前缀（prefix）/后缀（postfix）比较'都开始基于扩展字符集（extended grapheme clusters）规范的等价比较。 +* 现在，你可以通过下标赋值或者 [可选调用链](../02_language_guide/16_Optional_Chaining.md) 中的可变方法和操作符来给属性设值。相应地更新了有关 [通过可选链接访问属性](../02_language_guide/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 的内容，并扩展了 [通过可选链接调用方法](../02_language_guide/16_Optional_Chaining.md#calling-methods-through-optional-chaining) 时检查方法调用成功的示例，以显示如何检查属性设置是否成功。 +* 在可选链中新增了 [访问可选类型的下标脚注](../02_language_guide/16_Optional_Chaining.md#accessing-subscripts-through-optional-chaining) 章节。 +* 更新 [访问和修改数组](../02_language_guide/CollectionTypes.md#accessing-and-modifying-a-dictionary) 章节以标示，从该版本起，不能再通过 `+=` 运算符给一个数组新增一个新的项。对应的替代方案是，使 `append` 方法，或者通过 `+=` 运算符来新增一个只有一个项的数组。 +* 新增一处说明，在 [范围运算符](../02_language_guide/BasicOperators.md#range-operators) 中，比如， `a..b` 和 `a.. 2016.9.23: 已经更新到 Swift 3.0。 -# 3.0 更新说明 -Swift 3.0 是自 Swift 开源以来第一个大的版本更新。从语言角度不兼容之前的 Swift 2.2 和 Swift 2.3 版本。Swift 3.0 的更新说明，大家可以查看[官方 blog 的说明](https://swift.org/blog/swift-3-0-released/)，也可以关注 [SwiftGG](http://swift.gg) 最新的文章。学习官方文档，是掌握语言特性点的最佳途径，感谢翻译的小伙伴们为 Swift 社区所做贡献！ +# Swift 文档修订历史 -# 3.0 译者记录 -相关[issue](https://github.com/numbbbbb/the-swift-programming-language-in-chinese/issues/628) -- Functions: [crayygy](https://github.com/crayygy) -- Control Flow: [Realank](https://github.com/Realank) -- Closures: [LanfordCai](https://github.com/LanfordCai) -- Protocols: [chenmingbiao](https://github.com/chenmingbiao) -- The Basics:[chenmingbiao](https://github.com/chenmingbiao) -- Advanced Operators: [mmoaay](https://github.com/mmoaay) +### 2019-06-03 -Language Reference: -- Attributes: [WhoJave](https://github.com/WhoJave) -- Statements: [chenmingjia](https://github.com/chenmingjia) -- Declarations: [chenmingjia](https://github.com/chenmingjia) -- Expressions: [chenmingjia](https://github.com/chenmingjia) -- Types: [lettleprince](https://github.com/lettleprince) -- Generic Parameters and Arguments: [chenmingjia](https://github.com/chenmingjia) +* 更新至 Swift 5.1。 +* 在 [不透明类型](../02_language_guide/23_Opaque_Types.md) 篇章中新增了有关函数返回值遵循指定协议，而不需要提供指定返回类型的内容。 +* 新增 [隐式返回的函数](../02_language_guide/06_Functions.md#functions-with-an-implicit-return) 和 [简化 Getter 声明](../02_language_guide/10_Properties.md#shorthand-getter-declaration) 章节，其中包含函数省略 `return` 的内容。 +* 在 [类型下标](../02_language_guide/12_Subscripts.md#type-subscripts) 章节中新增有关在类型中使用下标的内容。 +* 更新 [结构体的逐一成员构造器](../02_language_guide/14_Initialization.md#memberwise-initializers-for-structure-types) 章节，现在逐一成员构造器支持在属性有默认值时省略形参。 +* 在 [动态查找成员](../03_language_reference/07_Attributes.md#dynamicmemberlookup) 章节中新增了有关在运行时用 key path 查找动态成员的内容。 +* 更新 [自身类型](../03_language_reference/03_Types.md#self-type-h) 章节，现在 `Self` 可以指向当前类，结构体或者枚举声明时的类型。 + +### 2019-03-25 + +* 更新至 Swift 5。 +* 新增 [拓展字符串分隔符](../02_language_guide/03_Strings_And_Characters.md#extended-string-delimiters) 章节。更新 [字符串字面量](../03_language_reference/03_Lexical_Structure.md#string-literal) 章节，拓展有关字符串分隔符的内容。 +* 新增 [动态调用](../03_language_reference/07_Attributes.md#dynamiccallable) 章节，其中包含使用 `dynamicCallable` 属性动态调用实例作为函数的内容。 +* 新增 [unknown](../03_language_reference/07_Attributes.md#unknown) 和 [未来枚举匹配](../03_language_reference/05_Statements.md#future-case2) 章节，其中包含了使用 `unknown` 来处理未来枚举可能发生改变的情形。 +* 在 [Key-Path 表达式](../03_language_reference/04_Expressions.md#key-path-expression) 章节新增了有关标示 key path (\\.self) 的内容。 +* 在 [可选编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了有关小于比较符 `<` 的内容。 + +### 2018-09-17 + +* 更新至 Swift 4.2。 +* 在 [遍历枚举情形](../02_language_guide/08_Enumerations.md#iterating-over-enumeration-cases) 章节新增了有关访问所有枚举情形的内容。 +* 在 [编译诊断](../03_language_reference/05_Statements.md#compile-time-diagnostic-statement) 章节新增了有关 `#error` 和 `#warning` 的内容。 +* 在 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `inlinable` 和 `usableFromInline` 属性的内容。 +* 在 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `requires_stored_property_inits` 和 `warn_unqualified_access` 属性的内容。 +* 在 [可选编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了有关如何根据 Swift 编译器版本对代码进行对应编译处理的内容。 +* 在 [字面量语法](../03_language_reference/04_Expressions.md#literal-expression) 章节新增了有关 `#dsohandle` 的内容。 + +### 2018-03-29 + +* 更新至 Swift 4.1。 +* 在 [等价运算符](../02_language_guide/27_Advanced_Operators.md#equivalence-operators) 章节新增了有关等价运算符的合成实现的内容。 +* 在 [声明](../03_language_reference/06_Declarations.md) 篇章中 [申明拓展](../03_language_reference/06_Declarations.md#extension-declaration) 章节和 [协议](../02_language_guide/21_Protocols.md) 篇章中 [有条件地遵循协议](../02_language_guide/21_Protocols.md#Conditionally-Conforming-to-a-Protocol) 章节新增了有关协议有条件遵循的内容。 +* 在 [关联类型约束中使用协议](../02_language_guide/22_Generics.md#using-a-protocol-in-its-associated-types-constraints) 章节中新增了有关递归协议约束的内容。 +* 在 [条件编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中新增了有关 `canImport()` 和 `targetEnvironment()` 平台条件的内容。 + +### 2017-12-04 + +* 更新至 Swift 4.0.3。 +* 更新 [Key-Path 表达式](../03_language_reference/04_Expressions.md#key-path-expression) 章节，现在 key path 支持下标子路径。 + +### 2017-09-19 + +* 更新至 Swift 4.0。 +* 在 [内存安全](../02_language_guide/24_MemorySafety.md) 章节新增了有关内存互斥访问的内容。 +* 新增 [带有泛型 Where 子句联类型](../02_language_guide/22_Generics.md#associated-types-with-a-generic-where-clause) 章节，现在可以使用泛型 `where` 子句约束关联类型。 +* 在 [字符串和字符](../02_language_guide/03_Strings_And_Characters.md) 篇章中 [字面量](../02_language_guide/03_Strings_And_Characters.md#string-literals) 章节以及 [词法结构](../03_language_reference/02_Lexical_Structure.md) 篇章的 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节中新增了有关多行字符串字面量的内容。 +* 更新 [声明属性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 中 `objc` 属性的讨论，现在该属性会在更少的位置被推断出来。 +* 新增 [范型下标](../02_language_guide/22_Generics.md#generic-subscripts) 章节，现在下标也支持范型特性了。 +* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03_language_reference/03_Types.md) 篇章中 [协议组合类型](../03_language_reference/03_Types.md#protocol-composition-type-h) 章节的讨论，现在协议组合类型支持进行父类约束了。 +* 更新 [拓展声明](../03_language_reference/06_Declarations.md#extension-declaration) 中有关协议扩展的讨论，现在它们不支持 `final` 特性了。 +* 在 [断言和前置条件](../02_language_guide/01_TheBasics.md#assertions-and-preconditions) 章节中新增了部分前置条件和致命错误的内容。 + +### 2017-03-27 + +* 更新至 Swift 3.1。 +* 新增 [范型 Where 子句扩展](../02_language_guide/22_Generics.md#extensions-with-a-generic-where-clause) 章节，包含需要的扩展内容。 +* 在 [For-In 循环](../02_language_guide/05_Control_Flow.md#for-in-loops) 章节中新增了区间迭代的例子。 +* 在 [到可失败构造器](http://typora-app/02_language_guide/14_Initialization.md#failable-initializers) 章节中新增了可失败数值转换的例子。 +* 在 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关使用 Swift 语言版本的 `available` 特性的内容 。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节中的讨论，注意在写函数类型时不允许使用参数标签。 +* 更新 [条件编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中的 Swift 语言版本号的讨论，现在可以使用可选的补丁版本号。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节的讨论，现在 Swift 区分了采用多参数的函数和采用元组类型的单个参数的函数。 +* 在 [表达式](../03_language_reference/04_Expressions.md) 篇章中删除了动态表达式的章节，现在 `type(of:)` 是 Swift 标准库函数。 + +### 2016-10-27 + +* 更新至 Swift 3.0.1。 +* 更新 [自动引用计数](../02_language_guide/24_Automatic_Reference_Counting.md) 章节中有关 weak 和 unowned 引用的讨论。 +* 在 [声明标识符](../03_language_reference/06_Declarations.md#declaration-modifiers) 章节中新增了有关新的标识符 `unowned`，`unowend(safe)` 和 `unowned(unsafe)` 的内容。 +* 在 [Any 和 AnyObject 的类型转换](../02_language_guide/18_Type_Casting.md#type-casting-for-any-and-anyobject) 章节中新增了一处说明，有关使用类型 `Any` 作为可选值。 +* 更新 [表达式](../03_language_reference/04_Expressions.md) 章节，把括号表达式和元组表达式的描述分开。 + +### 2016-09-13 + +* 更新至 Swift 3.0。 +* 更新 [函数](../02_language_guide/06_Functions.md) 篇章和 [函数声明](../03_language_reference/06_Declarations.md#function-declaration) 章节中有关函数的讨论，所有函数参数默认都有函数标签。 +* 更新 [高级操作符](../02_language_guide/27_Advanced_Operators.md) 篇章中有关操作符的讨论，现在你可以作为类型函数来实现，替代之前的全局函数实现方式。 +* 在 [访问控制](../02_language_guide/26_Access_Control.md) 章节中新增有关对新的访问级别描述符 `open` 和 `fileprivate` 的内容。 +* 更新 [函数声明](../03_language_reference/06_Declarations.md#function-declaration) 章节中有关 `inout` 的讨论，注意它现在出现在参数类型的前面，而不是在参数名称的前面。 +* 更新 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 和 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节还有 [属性](../03_language_reference/07_Attributes.md) 篇章中有关 `@noescape` 和 `@autoclosure` 的讨论，现在他们是类型属性，而不是定义属性。 +* 在 [高级操作符](../02_language_guide/27_Advanced_Operators.md) 篇章中 [自定义中缀操作符的优先级](./02_language_guide/27_Advanced_Operators.md#precedence-and-associativity-for-custom-infix-operators) 章节和 [定义](../03_language_reference/06_Declarations.md) 篇章中 [优先级组声明](../03_language_reference/06_Declarations.md#precedence-group-declaration-modifiers) 章节中新增了有关操作符优先级组的内容。 +* 更新一些讨论，使用 macOS 替换掉 OS X， Error 替换掉 ErrorProtocol。更新一些协议名称，比如使用 ExpressibleByStringLiteral 替换掉 StringLiteralConvertible。 +* 更新 [泛型](../02_language_guide/22_Generics.md) 篇章中 [泛型 Where 语句](../02_language_guide/22_Generics.md#extensions-with-a-generic-where-clause) 章节和 [泛型形参和实参](../03_language_reference/09_Generic_Parameters_And_Arguments.md) 篇章的讨论，现在泛型的 where 语句写在一个声明的最后。 +* 更新 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 章节中的讨论，现在闭包默认为非逃逸的。 +* 更新 [基础部分](../02_language_guide/01_TheBasics.md) 篇章中 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章中 [While 语句](../03_language_reference/05_Statements.md#while-statement) 章节中的讨论，现在 if，`while` 和 `guard` 语句使用逗号分隔条件列表，不需要使用 `where` 语句。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章中 [Switch](../02_language_guide/05_Control_Flow.md#switch) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章中 [Switch 语句](../03_language_reference/05_Statements.md#switch-statement) 章节中新增了 switch cases 可以使用多模式的内容。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节有关现在函数参数标签不包含在函数类型中的讨论。 +* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03_language_reference/03_Types.md) 篇章中 [协议组合类型](../03_language_reference/03_Types.md#protocol-composition-type-h) 章节中有关使用新的 Protocol1 & Protocol2 语法的内容。 +* 更新动态类型表达式章节中使用新的 `type(of:)` 表达式的讨论。 +* 更新 [行控制表达式](../03_language_reference/05_Statements.md#line-control-statement) 章节中使用 `#sourceLocation(file:line:)` 表达式的讨论。 +* 更新 [永不返回函数](../03_language_reference/06_Declarations.md#functions-that-never-return) 章节中使用 新的 `Never` 类型的讨论。 +* 在 [字面量表达式](../03_language_reference/04_Expressions.md#literal-expression) 章节中新增了有关 `playground` 字面量的内容。 +* 更新 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out_parameters) 章节，标明只有非逃逸闭包能捕获 `in-out` 参数。 +* 更新 [默认参数值](../02_language_guide/06_Functions.md#default-parameter-values) 章节，现在默认参数不能在调用时候重新排序。 +* 更新 [属性](../03_language_reference/07_Attributes.md) 篇章中有关属性参数使用分号的说明。 +* 在 [重新抛出函数和方法](../03_language_reference/06_Declarations.md#rethrowing-functions-and-methods) 章节中新增了有关在 catch 代码块中抛出错误的重新抛出函数的内容。 +* 在 [Selector 表达式](../03_language_reference/04_Expressions.md#selector-expression7) 章节中新增了中有关访问 Objective-C 中 Selector 的 getter 和 setter 的内容。 +* 在 [类型别名声明](../03_language_reference/06_Declarations.md#type-alias-declaration) 章节中中新增了有关泛型类型别名和在协议内使用类型别名的内容。 +* 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节中有关函数类型的讨论，标明函数类型作为参数类型必须使用括号包裹。 +* 更新 [属性](../03_language_reference/07_Attributes.md) 篇章，标明 `@IBAction`，`@IBOutlet` 和 `@NSManaged` 隐式含有 `@objc` 属性。 +* 在 [声明属性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `@GKInspectable` 的内容。 +* 更新 [可选协议要求](../02_language_guide/21_Protocols.md#optional-protocol-requirements) 章节中有关只能在与 `Objective-C` 交互的代码中才能使用可选协议要求的内容。 +* 删除 [函数声明](../03_language_reference/06_Declarations.md#function-declaration) 章节中有关显式使用 `let` 关键字作为函数参数的内容。 +* 删除 [语句](../03_language_reference/05_Statements.md) 章节中有关 `Boolean` 协议的内容， 现在这个协议已经被 Swift 标准库删除。 +* 更正 [声明属性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@NSApplicationMain` 协议的内容。 + +### 2016-03-21 + +* 更新至 Swift 2.2。 +* 在 [编译配置语句](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了中有关如何根据 Swift 版本进行条件编译。 +* 在 [显示成员表达式](../03_language_reference/04_Expressions.md#explicit-member-expression) 章节中新增了有关如何区分只有参数名不同的方法和构造器的内容。 +* 在 [选择器表达式](../03_language_reference/04_Expressions.md#selector-expression7) 章节中新增了了针对 Objective-C 选择器的 `#selector` 语法。 +* 更新 [关联类型](../02_language_guide/22_Generics.md#associated-types) 和 [协议关联类型声明](../03_language_reference/06_Declarations.md#protocol_associated_type_declaration) 章节中有关使用 `associatedtype` 关键词修饰关联类型的讨论。 +* 更新 [可失败构造器](../02_language_guide/14_Initialization.md#failable-initializers) 章节中有关当构造器在实例完全初始化之前返回 `nil` 的相关内容。 +* 在 [比较运算符](../02_language_guide/BasicOperators.md#comparison-operators) 章节中新增了比较元组的内容。 +* 在 [关键字和标点符号](../03_language_reference/02_Lexical_Structure.md#keywords-and-punctuation) 章节中新增了使用关键字作为外部参数名的内容。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@objc` 特性的讨论，并指出枚举和枚举用例。 +* 更新 [操作符](../03_language_reference/02_Lexical_Structure.md#operator) 章节中对于自定义运算符的包含了 `.` 的讨论。 +* 在 [重新抛出错误的函数和方法](../03_language_reference/06_Declarations.md#rethrowing-functions-and-methods) 章节中新增了一处说明，重新抛出错误函数不能直接抛出错误。 +* 在 [属性观察器](../02_language_guide/10_Properties.md#property-observers) 章节中新增了一处说明，当作为 in-out 参数传递属性时，属性观察器的调用行为。 +* 在 [Swift 初见](./03_a_swift_tour.md) 篇章中新增了错误处理的章节。 +* 更新 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节中的图片用以更清楚的展示重新分配过程。 +* 删除 C 语言风格的 `for` 循环，`++` 前缀和后缀运算符，以及 `--` 前缀和后缀运算符。 +* 删除对变量函数参数和柯里化函数的特殊语法的讨论。 + +### 2015-10-20 + +* 更新至 Swift 2.1。 +* 更新 [字符串插值](../02_language_guide/03_Strings_And_Characters.md#string-interpolation) 和 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节，现在字符串插值可包含字符串字面量。 +* 在 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 章节中新增了有关 `@noescape` 属性的相关内容。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 和 [编译配置语句](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中与 tvOS 相关的内容。 +* 在 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out_parameters) 章节中新增了与 in-out 参数行为相关的内容。 +* 在 [捕获列表](../03_language_reference/04_Expressions.md#capture-lists) 章节新增了有关指定闭包捕获列表被捕获时捕获值的相关内容。 +* 更新 [可选链式调用访问属性](../02_language_guide/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 章节，阐明了如何通过可选链式调用进行赋值。 +* 改进 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节中对自闭包的讨论。 +* 在 [Swift 初见](./03_a_swift_tour.md) 篇章中新增了一个使用 `??` 操作符的例子。 + +### 2015-09-16 + +* 更新至 Swift 2.0。 +* 在 [错误处理](../02_language_guide/17_Error_Handling.md) 篇章中新增了有关错误处理的相关内容，包括 [Do 语句](../03_language_reference/05_Statements.md#do-statement)、 [Throw 语句](../03_language_reference/05_Statements.md#throw-statement)、 [Defer 语句](../03_language_reference/05_Statements.md##defer-statements) 以及 [try 运算符](../03_language_reference/04_Expressions.md#try-operator)。 +* 更新 [错误表示和抛出](../02_language_guide/17_Error_Handling.md#representing-and-throwing-errors) 章节，现在所有类型都可以遵循 `ErrorType` 协议了。 +* 在 [将错误装换成可选值](../02_language_guide/17_Error_Handling.md#converting_errors_to_optional_values) 篇章增加了 `try?` 关键字相关内容。 +* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [递归枚举](../02_language_guide/08_Enumerations.md#recursive-enumerations) 章节以及以及 [声明](../03_language_reference/06_Declarations.md) 篇章的 [任意类型用例的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-any-type) 章节中新增了递归枚举相关内容。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [API 可用性检查](../02_language_guide/05_Control_Flow.md#checking-api-availability) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章的 [可用性条件](../03_language_reference/05_Statements.md#availability-condition) 章节中新增了有关 API 可用性检查相关的内容。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [尽早退出](../02_language_guide/05_Control_Flow.md#early-exit) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章的 [Guard 语句](../03_language_reference/05_Statements.md#guard-statement) 章节新增了与 `guard` 语句相关的内容。 +* 在 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议扩展](../02_language_guide/21_Protocols.md#protocol-extensions) 章节中新增了有关协议扩展的内容。 +* 在 [访问控制](../02_language_guide/26_Access_Control.md) 篇章的 [单元测试 target 的访问级别](../02_language_guide/26_Access_Control.md#access-levels-for-unit-test-targets) 章节中新增了有关单元测试访问控制相关的内容。 +* 在 [模式](../03_language_reference/08_Patterns.md) 篇章的 [可选模式](../03_language_reference/08_Patterns.md#optional-pattern) 章节中新增了可选模式相关内容。 +* 更新 [Repeat-While](../02_language_guide/05_Control_Flow.md#repeat-while) 章节中有关 `repeat-while` 循环相关的内容。 +* 更新 [字符串和字符](../02_language_guide/03_Strings_And_Characters.md) 章节，现在 `String` 类型在 Swift 标准库中不再遵循 `CollectionType` 协议。 +* 在 [常量与变量打印](../02_language_guide/01_TheBasics.md#printing) 章节中新增了新 Swift 标准库中有关 `print(_:separator:terminator) ` 相关内容。 +* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [原始值的隐式赋值](../02_language_guide/08_Enumerations.md#implicitly-assigned-raw-values) 章节和 [声明](../03_language_reference/06_Declarations.md) 篇章的 [包含原始值类型的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-a-raw-value-type) 章节中新增了有关包含 `String` 原始值的枚举用例的行为相关内容。 +* 在 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节中新增了有关 `@autoclosure` 特性的相关内容，包括它的 `@autoclosure(escaping)` 形式。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@avaliable` 和 `warn_unused_result` 特性的相关内容。 +* 更新 [类型特性](../03_language_reference/07_Attributes.md#type-attributes) 章节中有关 `@convention` 特性的相关内容。 +* 在 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding) 章节中新增了有关使用 `where` 子句进行多可选绑定的相关内容。 +* 在 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节中新增了有关在编译时使用 `+` 运算符拼接字符串字面量的相关内容。 +* 在 [元类型](../03_language_reference/03_Types.md#metatype-type-h) 章节中新增了有关元类型值的比较和使用它们通过构造器表达式构造实例相关内容。 +* 在 [断言调试](../02_language_guide/01_TheBasics.md#debugging-with-assertions) 章节中新增了一处说明，有关用户定义断言何时会失效。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中对 `@NSManaged` 特性的讨论，现在这个特性可以被应用到一个确定实例方法。 +* 更新 [可变参数](../02_language_guide/06_Functions.md#variadic-parameters) 章节，现在可变参数可以声明在函数参数列表的任意位置中。 +* 在 [重写可失败构造器](../02_language_guide/14_Initialization.md#overriding-a-failable-initializer) 章节中新增了有关非可失败构造器相当于一个可失败构造器通过父类构造器的结果进行强制拆包的相关内容。 +* 在 [任意类型用例的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-any-type) 章节中新增了有关枚举用例作为函数的内容。 +* 在 [构造器表达式](../03_language_reference/04_Expressions.md#initializer-expression) 章节中新增了有关显式引用一个构造器相关内容。 +* 在 [编译控制语句](../03_language_reference/05_Statements.md#compiler-control-statements) 章节中新增了有关编译内容以及行控制语句相关内容。 +* 在 [元类型](../03_language_reference/03_Types.md#metatype-type-h) 章节新增了一处说明，有关如何从元类型值中构造类实例相关内容。 +* 在 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节新增了一处说明，有关弱引用作为缓存所存在的不足。 +* 更新 [类型特性](../02_language_guide/10_Properties.md#type-properties) 章节，提到了存储型特性其实是懒加载。 +* 更新 [捕获类型](../02_language_guide/07_Closures.md#capturing_values) 章节，阐明了变量和常量在闭包中如何被捕获。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节，用以描述何时在类中使用 `@objc` 关键字。 +* 在 [错误处理](../02_language_guide/17_Error_Handling.md#handling-errors) 章节中新增了一处说明，有关执行 `throw` 语句的性能。在 [Do 语句](../03_language_reference/05_Statements.md#do-statement) 章节的 do 语句部分也新增了类似内容。 +* 更新 [类型特性](../02_language_guide/10_Properties.md#type-properties) 章节中有关类、结构体和枚举的存储型和计算型特性相关的内容。 +* 更新 [Break 语句](../03_language_reference/05_Statements.md#break_statement) 章节中有关带标签的 break 语句相关内容。 +* 在 [属性观察器](../02_language_guide/10_Properties.md#property-observers) 章节更新了一处说明，用来明确 `willSet` 和 `didSet` 观察器的行为。 +* 在 [访问级别](../02_language_guide/26_Access_Control.md#access-levels) 章节新增了有关 `private` 作用域的相关内容说明。 +* 在 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节新增了有关弱应用在垃圾回收系统和 ARC 之间的区别的说明。 +* 更新 [字符串字面量中特殊字符](../02_language_guide/03_Strings_And_Characters.md#special-characters-in-string-literals) 章节，对 Unicode 标量更精确定义。 + + +### 2015-04-08 + +* 更新至 Swift 1.2。 +* Swift 现在自身提供了一个 `Set` 集合类型，更多内容，请看 [Sets](../02_language_guide/CollectionTypes.md#sets) 。 +* `@autoclosure` 现在是一个参数声明的属性，而不是参数类型的属性。这里还有一个新的参数声明属性 `@noescape`。更多内容，请看 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 。 +* 对于类型属性和方法现在可以使用 `static` 关键字作为声明描述符，更多内容，请看 [类型变量属性](../03_language_reference/06_Declarations.md#type-variable-properties)。 +* Swift 现在包含一个 `as?` 和 `as!` 的向下可失败类型转换运算符。更多内容，请看 [协议遵循性检查](../02_language_guide/21_Protocols.md#checking-for-protocol-conformance)。 +* 新增 [字符串索引](../02_language_guide/03_Strings_And_Characters.md#string-indices) 的新指导章节。 +* 在 [溢出运算符](../02_language_guide/27_Advanced_Operators.md#overflow-operators) 一节中删除了溢出除运算符（`&/`）和求余溢出运算符（`&%`）。 +* 更新常量和常量属性在声明和构造时的规则，更多内容，请看 [常量声明](../03_language_reference/06_Declarations.md#constant-declaration) 。 +* 更新字符串字面量中 Unicode 标量集的定义，请看 [字符串字面量中的特殊字符](../02_language_guide/03_Strings_And_Characters.md#special-characters-in-string-literals) 。 +* 更新 [区间运算符](../02_language_guide/BasicOperators.md#range-operators) 章节，注意当半开区间运算符含有相同的起止索引时，其区间为空。 +* 更新 [闭包引用类型](../02_language_guide/07_Closures.md#closures-are-reference-types) 章节，对于变量的捕获规则进行了阐明。 +* 更新 [值溢出](../02_language_guide/27_Advanced_Operators.md#value-overflow) 章节，对有符号整数和无符号整数的溢出行为进行了阐明。 +* 更新 [协议声明](../03_language_reference/06_Declarations.md#protocol-declaration) 章节，对协议声明时的作用域和成员等内容进行了阐明。 +* 更新 [捕获列表](../02_language_guide/24_Automatic_Reference_Counting.md#defining-a-capture-list) 章节，对于闭包捕获列表中的弱引用和无主引用的使用语法进行了阐明。 +* 更新 [运算符](../03_language_reference/02_Lexical_Structure.md#operator) 章节，明确指明一些例子来说明自定义运算符所支持的特性，如数学运算符，各种符号，Unicode 符号块等。 +* 在函数作用域中的常量声明时可以不被初始化，它必须在第一次使用前被赋值。更多的内容，请看 [常量声明](../03_language_reference/06_Declarations.md#constant-declaration)。 +* 在构造器中，常量属性有且仅能被赋值一次。更多内容，请看 [在构造过程中给常量属性赋值](../02_language_guide/14_Initialization.md{#assigning-constant-properties-during-initialization)。 +* 多个可选绑定现在可以在`if`语句后面以逗号分隔的赋值列表的方式出现，更多内容，请看 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding)。 +* 一个 [可选链表达式](../03_language_reference/04_Expressions.md#optional-chaining-expression) 必须出现在后缀表达式中。 +* 协议类型转换不再局限于 `@obj` 修饰的协议了。 +* 在运行时可能会失败的类型转换可以使用 `as?` 和 `as!` 运算符，而确保不会失败的类型转换现在使用 `as` 运算符。更多内容，请看 [类型转换运算符](../03_language_reference/04_Expressions.md#type-casting-operator)。 + +### 2014-10-16 + +* 更新至 Swift 1.1。 +* 新增 [失败构造器](../02_language_guide/14_Initialization.md#failable-initializers) 的完整指引。 +* 在协议中新增了 [失败构造器要求](../02_language_guide/21_Protocols.md#failable-initializer-requirements) 的描述。 +* 常量和变量的 `Any` 类型现可以包含函数实例。更新了有关 `Any` 相关的示例来展示如何在 `switch` 语句中如何检查并转换到一个函数类型。 +* 带有原始值的枚举类型增加了一个 `rawValue` 属性替代 `toRaw()` 方法，同时使用了一个以 `rawValue` 为参数的失败构造器来替代 `fromRaw()` 方法。更多的内容，请看 [原始值](../02_language_guide/08_Enumerations.md#raw-values) 和 [带原始值的枚举类型](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-a-raw-value-type)。 +* 新增 [Failable Initializer](../03_language_reference/06_Declarations.md#failable-initializers) 的参考章节，它可以触发初始化失败。 +* 自定义运算符现在可以包含 `?` 字符，更新了 [运算符](../03_language_reference/02_Lexical_Structure.md#operator) 涉及改进后的规则的部分，并且在 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom-operators) 章节中删除了重复的运算符有效字符集合。 + +### 2014-08-18 + +* 描述 Swift 1.0 的新文档。Swift 是苹果公司发布的全新编程语言，用于 iOS 和 OS X 应用开发。 +* 在协议中新增了 [对构造器的规定](../02_language_guide/21_Protocols.md#initializer-requirements) 章节。 +* 新增 [类专属协议](../02_language_guide/21_Protocols.md#class-only-protocol) 章节。 +* [断言](../02_language_guide/01_TheBasics.md#assertions-and-preconditions) 现在可以使用字符串内插语法，并删除了文档中有冲突的注释。 +* 更新 [连接字符串和字符](../02_language_guide/03_Strings_And_Characters.md#concatenating-strings-and-characters) 章节来说明字符串和字符不能再用 `+` 号运算符或者复合加法运算符 `+=` 相互连接，这两种运算符现在只能用于字符串之间相连。请使用 `String` 类型的 `append` 方法在一个字符串的尾部增加单个字符。 +* 在 [属性申明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节增加了有关 `availability` 特性的一些内容。 +* [可选类型](../02_language_guide/01_TheBasics.md#optionals) 若有值时，不再隐式的转换为 `true`，同样，若无值时，也不再隐式的转换为 `false`，这是为了避免在判别 optional `Bool` 的值时产生困惑。 替代的方案是，用`==` 或 `!=` 运算符显式地去判断 Optinal 是否是 `nil`，以确认其是否包含值。 +* Swift 新增了一个 [Nil 合并运算符](../02_language_guide/BasicOperators.md#nil-coalescing-operator) (`a ?? b`) , 该表达式中，如果 Optional `a` 的值存在，则取得它并返回，若 Optional `a` 为 `nil`，则返回默认值 `b` +* 更新和扩展 [字符串的比较](../02_language_guide/03_Strings_And_Characters.md#comparing-strings) ，用以反映和展示'字符串和字符的比较'，以及'前缀（prefix）/后缀（postfix）比较'都开始基于扩展字符集（extended grapheme clusters）规范的等价比较。 +* 现在，你可以通过下标赋值或者 [可选调用链](../02_language_guide/16_Optional_Chaining.md) 中的可变方法和操作符来给属性设值。相应地更新了有关 [通过可选链接访问属性](../02_language_guide/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 的内容，并扩展了 [通过可选链接调用方法](../02_language_guide/16_Optional_Chaining.md#calling-methods-through-optional-chaining) 时检查方法调用成功的示例，以显示如何检查属性设置是否成功。 +* 在可选链中新增了 [访问可选类型的下标脚注](../02_language_guide/16_Optional_Chaining.md#accessing-subscripts-through-optional-chaining) 章节。 +* 更新 [访问和修改数组](../02_language_guide/CollectionTypes.md#accessing-and-modifying-a-dictionary) 章节以标示，从该版本起，不能再通过 `+=` 运算符给一个数组新增一个新的项。对应的替代方案是，使 `append` 方法，或者通过 `+=` 运算符来新增一个只有一个项的数组。 +* 新增一处说明，在 [范围运算符](../02_language_guide/BasicOperators.md#range-operators) 中，比如， `a..b` 和 `a.. Date: Thu, 10 Oct 2019 17:55:30 -0500 Subject: [PATCH 25/36] fix anchor name and link format --- source/02_language_guide/01_The_Basics.md | 12 +- .../02_language_guide/02_Basic_Operators.md | 8 +- .../03_Strings_and_Characters.md | 10 +- .../02_language_guide/04_Collection_Types.md | 6 +- source/02_language_guide/05_Control_Flow.md | 8 +- source/02_language_guide/06_Functions.md | 2 +- source/02_language_guide/07_Closures.md | 14 +- source/02_language_guide/08_Enumerations.md | 4 +- .../09_Structures_And_Classes.md | 2 +- source/02_language_guide/10_Properties.md | 8 +- source/02_language_guide/11_Methods.md | 6 +- source/02_language_guide/12_Subscripts.md | 4 +- source/02_language_guide/13_Inheritance.md | 2 +- source/02_language_guide/14_Initialization.md | 18 +- .../02_language_guide/16_Optional_Chaining.md | 6 +- source/02_language_guide/17_Error_Handling.md | 4 +- source/02_language_guide/18_Type_Casting.md | 2 +- source/02_language_guide/19_Nested_Types.md | 2 +- source/02_language_guide/21_Protocols.md | 18 +- source/02_language_guide/22_Generics.md | 10 +- source/02_language_guide/23_Opaque_Types.md | 2 +- .../24_Automatic_Reference_Counting.md | 10 +- source/02_language_guide/26_Access_Control.md | 8 +- .../27_Advanced_Operators.md | 6 +- .../01_About_the_Language_Reference.md | 6 +- .../02_Lexical_Structure.md | 10 +- source/03_language_reference/03_Types.md | 16 +- .../03_language_reference/04_Expressions.md | 52 +- source/03_language_reference/05_Statements.md | 128 ++-- .../03_language_reference/06_Declarations.md | 236 +++--- source/03_language_reference/07_Attributes.md | 30 +- source/03_language_reference/08_Patterns.md | 14 +- .../09_Generic_Parameters_and_Arguments.md | 14 +- .../10_Summary_of_the_Grammar.md | 712 +++++++++--------- .../04_revision_history.md | 70 +- 35 files changed, 730 insertions(+), 730 deletions(-) diff --git a/source/02_language_guide/01_The_Basics.md b/source/02_language_guide/01_The_Basics.md index 1dbe16a7..4fad7363 100755 --- a/source/02_language_guide/01_The_Basics.md +++ b/source/02_language_guide/01_The_Basics.md @@ -116,7 +116,7 @@ print(friendlyWelcome) // 输出“Bonjour!” ``` -`print(_:separator:terminator:)` 是一个用来输出一个或多个值到适当输出区的全局函数。如果你用 Xcode，`print(_:separator:terminator:)` 将会输出内容到“console”面板上。`separator` 和 `terminator` 参数具有默认值，因此你调用这个函数的时候可以忽略它们。默认情况下，该函数通过添加换行符来结束当前行。如果不想换行，可以传递一个空字符串给 `terminator` 参数--例如，`print(someValue, terminator:"")` 。关于参数默认值的更多信息，请参考 [默认参数值](./06_Functions.md#default_parameter_values)。 +`print(_:separator:terminator:)` 是一个用来输出一个或多个值到适当输出区的全局函数。如果你用 Xcode，`print(_:separator:terminator:)` 将会输出内容到“console”面板上。`separator` 和 `terminator` 参数具有默认值，因此你调用这个函数的时候可以忽略它们。默认情况下，该函数通过添加换行符来结束当前行。如果不想换行，可以传递一个空字符串给 `terminator` 参数--例如，`print(someValue, terminator:"")` 。关于参数默认值的更多信息，请参考 [默认参数值](./06_Functions.md#default-parameter-values)。 Swift 用*字符串插值（string interpolation）*的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义： @@ -127,7 +127,7 @@ print("The current value of friendlyWelcome is \(friendlyWelcome)") > 注意 > -> 字符串插值所有可用的选项，请参考 [字符串插值](./03_Strings_and_Characters.md#string_interpolation)。 +> 字符串插值所有可用的选项，请参考 [字符串插值](./03_Strings_and_Characters.md#string-interpolation)。 ## 注释 {#comments} @@ -200,7 +200,7 @@ Swift 也提供了一个特殊的无符号类型 `UInt`，长度与当前平台 > 注意 > -> 尽量不要使用 `UInt`，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用 `Int`，即使你要存储的值已知是非负的。统一使用 `Int` 可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推断，请参考 [类型安全和类型推断](#type_safety_and_type_inference)。 +> 尽量不要使用 `UInt`，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用 `Int`，即使你要存储的值已知是非负的。统一使用 `Int` 可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推断，请参考 [类型安全和类型推断](#type-safety-and-type-inference)。 ## 浮点数 {#floating-point-numbers} @@ -477,7 +477,7 @@ print("The status message is \(http200Status.description)") // 输出“The status message is OK” ``` -作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个 `(Int, String)` 元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考 [函数参数与返回值](./06_Functions.md#Function_Parameters_and_Return_Values)。 +作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个 `(Int, String)` 元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考 [函数参数与返回值](./06_Functions.md#Function-Parameters-and-Return-Values)。 > 注意 > @@ -609,7 +609,7 @@ if let firstNumber = Int("4") { > 注意 > -> 在 `if` 条件语句中使用常量和变量来创建一个可选绑定，仅在 `if` 语句的句中（`body`）中才能获取到值。相反，在 `guard` 语句中使用常量和变量来创建一个可选绑定，仅在 `guard` 语句外且在语句后才能获取到值，请参考 [提前退出](./05_Control_Flow.md#early_exit)。 +> 在 `if` 条件语句中使用常量和变量来创建一个可选绑定，仅在 `if` 语句的句中（`body`）中才能获取到值。相反，在 `guard` 语句中使用常量和变量来创建一个可选绑定，仅在 `guard` 语句外且在语句后才能获取到值，请参考 [提前退出](./05_Control_Flow.md#early-exit)。 ### 隐式解析可选类型 {#implicityly-unwrapped-optionals} @@ -619,7 +619,7 @@ if let firstNumber = Int("4") { 这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选类型。 -当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考 [无主引用以及隐式解析可选属性](./24_Automatic_Reference_Counting.md#unowned_references_and_implicitly_unwrapped_optional_properties)。 +当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考 [无主引用以及隐式解析可选属性](./24_Automatic_Reference_Counting.md#unowned-references-and-implicitly-unwrapped-optional-properties)。 一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型 `String` 和隐式解析可选类型 `String` 之间的区别： diff --git a/source/02_language_guide/02_Basic_Operators.md b/source/02_language_guide/02_Basic_Operators.md index 1aab686b..9c5bbc0a 100755 --- a/source/02_language_guide/02_Basic_Operators.md +++ b/source/02_language_guide/02_Basic_Operators.md @@ -2,7 +2,7 @@ *运算符*是检查、改变、合并值的特殊符号或短语。例如，加号（`+`）将两个数相加（如 `let i = 1 + 2`）。更复杂的运算例子包括逻辑与运算符 `&&`（如 `if enteredDoorCode && passedRetinaScan`）。 -Swift 支持大部分标准 C 语言的运算符，且为了减少常见编码错误做了部分改进。如：赋值符（`=`）不再有返回值，这样就消除了手误将判等运算符（`==`）写成赋值符导致代码错误的缺陷。算术运算符（`+`，`-`，`*`，`/`，`%` 等）的结果会被检测并禁止值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见 [溢出运算符](./27_Advanced_Operators.md#overflow_operators)。 +Swift 支持大部分标准 C 语言的运算符，且为了减少常见编码错误做了部分改进。如：赋值符（`=`）不再有返回值，这样就消除了手误将判等运算符（`==`）写成赋值符导致代码错误的缺陷。算术运算符（`+`，`-`，`*`，`/`，`%` 等）的结果会被检测并禁止值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见 [溢出运算符](./27_Advanced_Operators.md#overflow-operators)。 Swift 还提供了 C 语言没有的区间运算符，例如 `a.. 注意 > -> `hasPrefix(_:)` 和 `hasSuffix(_:)` 方法都是在每个字符串中逐字符比较其可扩展的字符群集是否标准相等，详细描述在 [字符串/字符相等](#string_and_character_equality)。 +> `hasPrefix(_:)` 和 `hasSuffix(_:)` 方法都是在每个字符串中逐字符比较其可扩展的字符群集是否标准相等，详细描述在 [字符串/字符相等](#string-and-character-equality)。 ## 字符串的 Unicode 表示形式 {#unicode-representations-of-strings} 当一个 Unicode 字符串被写进文本文件或者其他储存时，字符串中的 Unicode 标量会用 Unicode 定义的几种 `编码格式`（encoding forms）编码。每一个字符串中的小块编码都被称 `代码单元`（code units）。这些包括 UTF-8 编码格式（编码字符串为 8 位的代码单元）， UTF-16 编码格式（编码字符串位 16 位的代码单元），以及 UTF-32 编码格式（编码字符串32位的代码单元）。 -Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。你可以利用 `for-in` 来对字符串进行遍历，从而以 Unicode 可扩展的字符群集的方式访问每一个 `Character` 值。该过程在 [使用字符](#working_with_characters) 中进行了描述。 +Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。你可以利用 `for-in` 来对字符串进行遍历，从而以 Unicode 可扩展的字符群集的方式访问每一个 `Character` 值。该过程在 [使用字符](#working-with-characters) 中进行了描述。 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值： diff --git a/source/02_language_guide/04_Collection_Types.md b/source/02_language_guide/04_Collection_Types.md index 97852fbc..d1a4df39 100755 --- a/source/02_language_guide/04_Collection_Types.md +++ b/source/02_language_guide/04_Collection_Types.md @@ -235,7 +235,7 @@ for (index, value) in shoppingList.enumerated() { // Item 5: Bananas ``` -更多关于 `for-in` 循环的介绍请参见 [For 循环](05_Control_Flow.html#for_loops)。 +更多关于 `for-in` 循环的介绍请参见 [For 循环](05_Control_Flow.html#for-loops)。 ## 集合（Sets） {#sets} @@ -380,7 +380,7 @@ for genre in favoriteGenres { // Hip hop ``` -更多关于 `for-in` 循环的信息，参见 [For 循环](./05_Control_Flow.md#for_loops)。 +更多关于 `for-in` 循环的信息，参见 [For 循环](./05_Control_Flow.md#for-loops)。 Swift 的 `Set` 类型没有确定的顺序，为了按照特定顺序来遍历一个集合中的值可以使用 `sorted()` 方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符 `<` 对元素进行比较的结果来确定。 @@ -613,7 +613,7 @@ for (airportCode, airportName) in airports { // LHR: London Heathrow ``` -更多关于 `for-in` 循环的信息，参见 [For 循环](./05_Control_Flow.md#for_loops)。 +更多关于 `for-in` 循环的信息，参见 [For 循环](./05_Control_Flow.md#for-loops)。 通过访问 `keys` 或者 `values` 属性，你也可以遍历字典的键或者值： diff --git a/source/02_language_guide/05_Control_Flow.md b/source/02_language_guide/05_Control_Flow.md index f6d49e1f..cd375168 100755 --- a/source/02_language_guide/05_Control_Flow.md +++ b/source/02_language_guide/05_Control_Flow.md @@ -69,7 +69,7 @@ print("\(base) to the power of \(power) is \(answer)") 这个例子计算 base 这个数的 power 次幂（本例中，是 `3` 的 `10` 次幂），从 `1`（`3` 的 `0` 次幂）开始做 `3` 的乘法， 进行 `10` 次，使用 `1` 到 `10` 的闭区间循环。这个计算并不需要知道每一次循环中计数器具体的值，只需要执行了正确的循环次数即可。下划线符号 `_` （替代循环中的变量）能够忽略当前值，并且不提供循环遍历时对值的访问。 -在某些情况下，你可能不想使用包括两个端点的闭区间。想象一下，你在一个手表上绘制分钟的刻度线。总共 `60` 个刻度，从 `0` 分开始。使用半开区间运算符（`..<`）来表示一个左闭右开的区间。有关区间的更多信息，请参阅 [区间运算符](./02_Basic_Operators.md#range_operators)。 +在某些情况下，你可能不想使用包括两个端点的闭区间。想象一下，你在一个手表上绘制分钟的刻度线。总共 `60` 个刻度，从 `0` 分开始。使用半开区间运算符（`..<`）来表示一个左闭右开的区间。有关区间的更多信息，请参阅 [区间运算符](./02_Basic_Operators.md#range-operators)。 ```swift let minutes = 60 @@ -332,7 +332,7 @@ default: > 注意 > -> 虽然在 Swift 中 `break` 不是必须的，但你依然可以在 case 分支中的代码执行完毕前使用 `break` 跳出，详情请参见 [Switch 语句中的 break](#break_in_a_switch_statement)。 +> 虽然在 Swift 中 `break` 不是必须的，但你依然可以在 case 分支中的代码执行完毕前使用 `break` 跳出，详情请参见 [Switch 语句中的 break](#break-in-a-switch-statement)。 每一个 case 分支都*必须*包含至少一条语句。像下面这样书写代码是无效的，因为第一个 case 分支是空的： @@ -363,7 +363,7 @@ default: // 输出“The letter A” ``` -为了可读性，符合匹配可以写成多行形式，详情请参考 [复合匹配](#compound_cases) +为了可读性，符合匹配可以写成多行形式，详情请参考 [复合匹配](#compound-cases)。 > 注意 > @@ -527,7 +527,7 @@ default: - `return` - `throw` -我们将会在下面讨论 `continue`、`break` 和 `fallthrough` 语句。`return` 语句将会在 [函数](./06_Functions.md) 章节讨论，`throw` 语句会在 [错误抛出](./18_Error_Handling.md#throwing_errors) 章节讨论。 +我们将会在下面讨论 `continue`、`break` 和 `fallthrough` 语句。`return` 语句将会在 [函数](./06_Functions.md) 章节讨论，`throw` 语句会在 [错误抛出](./18_Error_Handling.md#throwing-errors) 章节讨论。 ### Continue {#continue} diff --git a/source/02_language_guide/06_Functions.md b/source/02_language_guide/06_Functions.md index 235f82d1..77427bb2 100755 --- a/source/02_language_guide/06_Functions.md +++ b/source/02_language_guide/06_Functions.md @@ -318,7 +318,7 @@ arithmeticMean(3, 8.25, 18.75) 函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为*输入输出参数（In-Out Parameters）*。 -定义一个输入输出参数时，在参数定义前加 `inout` 关键字。一个 `输入输出参数`有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。想获取更多的关于输入输出参数的细节和相关的编译器优化，请查看 [输入输出参数](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-ID545) 一节。 +定义一个输入输出参数时，在参数定义前加 `inout` 关键字。一个 `输入输出参数`有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。想获取更多的关于输入输出参数的细节和相关的编译器优化，请查看 [输入输出参数](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple-ref/doc/uid/TP40014097-CH34-ID545) 一节。 你只能传递变量给输入输出参数。你不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 `&` 符，表示这个值可以被函数修改。 diff --git a/source/02_language_guide/07_Closures.md b/source/02_language_guide/07_Closures.md index da3959e0..8745e55b 100755 --- a/source/02_language_guide/07_Closures.md +++ b/source/02_language_guide/07_Closures.md @@ -6,7 +6,7 @@ > 注意 > -> 如果你不熟悉捕获（capturing）这个概念也不用担心，在 [值捕获](#capturing_values) 章节有它更详细的介绍。 +> 如果你不熟悉捕获（capturing）这个概念也不用担心，在 [值捕获](#capturing-values) 章节有它更详细的介绍。 在 [函数](./06_Functions.md) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采用如下三种形式之一： @@ -23,7 +23,7 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进 ## 闭包表达式 {#closure-expressions} -[嵌套函数](./06_Functions.md#Nested_Functions) 作为复杂函数的一部分时，它自包含代码块式的定义和命名形式在使用上带来了方便。当然，编写未完整声明和没有函数名的类函数结构代码是很有用的，尤其是在编码中涉及到函数作为参数的那些方法时。 +[嵌套函数](./06_Functions.md#Nested-Functions) 作为复杂函数的一部分时，它自包含代码块式的定义和命名形式在使用上带来了方便。当然，编写未完整声明和没有函数名的类函数结构代码是很有用的，尤其是在编码中涉及到函数作为参数的那些方法时。 *闭包表达式*是一种构建内联闭包的方式，它的语法简洁。在保证不丢失它语法清晰明了的同时，闭包表达式提供了几种优化的语法简写形式。下面通过对 `sorted(by:)` 这一个案例的多次迭代改进来展示这个过程，每次迭代都使用了更加简明的方式描述了相同功能。。 @@ -129,7 +129,7 @@ reversedNames = names.sorted(by: { $0 > $1 } ) reversedNames = names.sorted(by: >) ``` -更多关于运算符方法的内容请查看 [运算符方法](./27_Advanced_Operators.md#operator_methods)。 +更多关于运算符方法的内容请查看 [运算符方法](./27_Advanced_Operators.md#operator-methods)。 ## 尾随闭包 {#trailing-closures} @@ -151,7 +151,7 @@ someFunctionThatTakesAClosure() { } ``` -在 [闭包表达式语法](#closure_expression_syntax) 上章节中的字符串排序闭包可以作为尾随包的形式改写在 `sorted(by:)` 方法圆括号的外面： +在 [闭包表达式语法](#closure-expression-syntax) 上章节中的字符串排序闭包可以作为尾随包的形式改写在 `sorted(by:)` 方法圆括号的外面： ```swift reversedNames = names.sorted() { $0 > $1 } @@ -233,7 +233,7 @@ func makeIncrementer(forIncrement amount: Int) -> () -> Int { } ``` -`makeIncrementer` 返回类型为 `() -> Int`。这意味着其返回的是一个*函数*，而非一个简单类型的值。该函数在每次调用时不接受参数，只返回一个 `Int` 类型的值。关于函数返回其他函数的内容，请查看 [函数类型作为返回类型](./06_Functions.md#function_types_as_return_types)。 +`makeIncrementer` 返回类型为 `() -> Int`。这意味着其返回的是一个*函数*，而非一个简单类型的值。该函数在每次调用时不接受参数，只返回一个 `Int` 类型的值。关于函数返回其他函数的内容，请查看 [函数类型作为返回类型](./06_Functions.md#function-types-as-return-types)。 `makeIncrementer(forIncrement:)` 函数定义了一个初始值为 `0` 的整型变量 `runningTotal`，用来存储当前总计数值。该值为 `incrementer` 的返回值。 @@ -290,7 +290,7 @@ incrementByTen() > 注意 > -> 如果你将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，你将在闭包和该实例间创建一个循环强引用。Swift 使用捕获列表来打破这种循环强引用。更多信息，请参考 [闭包引起的循环强引用](./24_Automatic_Reference_Counting.md#strong_reference_cycles_for_closures)。 +> 如果你将闭包赋值给一个类实例的属性，并且该闭包通过访问该实例或其成员而捕获了该实例，你将在闭包和该实例间创建一个循环强引用。Swift 使用捕获列表来打破这种循环强引用。更多信息，请参考 [闭包引起的循环强引用](./24_Automatic_Reference_Counting.md#strong-reference-cycles-for-closures)。 ## 闭包是引用类型 {#closures-are-reference-types} @@ -397,7 +397,7 @@ serve(customer: customersInLine.remove(at: 0)) > > 过度使用 `autoclosures` 会让你的代码变得难以理解。上下文和函数名应该能够清晰地表明求值是被延迟执行的。 -如果你想让一个自动闭包可以“逃逸”，则应该同时使用 `@autoclosure` 和 `@escaping` 属性。`@escaping` 属性的讲解见上面的 [逃逸闭包](#escaping_closures)。 +如果你想让一个自动闭包可以“逃逸”，则应该同时使用 `@autoclosure` 和 `@escaping` 属性。`@escaping` 属性的讲解见上面的 [逃逸闭包](#escaping-closures)。 ```swift // customersInLine i= ["Barry", "Daniella"] diff --git a/source/02_language_guide/08_Enumerations.md b/source/02_language_guide/08_Enumerations.md index c45d4910..a8ad7ec4 100755 --- a/source/02_language_guide/08_Enumerations.md +++ b/source/02_language_guide/08_Enumerations.md @@ -200,7 +200,7 @@ case let .qrCode(productCode): ## 原始值 {#raw-values} -在 [关联值](#associated_values) 小节的条形码例子中，演示了如何声明存储不同类型关联值的枚举成员。作为关联值的替代选择，枚举成员可以被默认值（称为*原始值*）预填充，这些原始值的类型必须相同。 +在 [关联值](#associated-values) 小节的条形码例子中，演示了如何声明存储不同类型关联值的枚举成员。作为关联值的替代选择，枚举成员可以被默认值（称为*原始值*）预填充，这些原始值的类型必须相同。 这是一个使用 ASCII 码作为原始值的枚举： @@ -273,7 +273,7 @@ let possiblePlanet = Planet(rawValue: 7) > 注意 > -> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见 [可失败构造器](../03_language_reference/05_Declarations.html#failable_initializers) +> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见 [可失败构造器](../03_language_reference/05_Declarations.html#failable-initializers)。 如果你试图寻找一个位置为 `11` 的行星，通过原始值构造器返回的可选 `Planet` 值将是 `nil`： diff --git a/source/02_language_guide/09_Structures_And_Classes.md b/source/02_language_guide/09_Structures_And_Classes.md index 3c42606c..31537451 100755 --- a/source/02_language_guide/09_Structures_And_Classes.md +++ b/source/02_language_guide/09_Structures_And_Classes.md @@ -243,7 +243,7 @@ if tenEighty === alsoTenEighty { 请注意，“相同”（用三个等号表示，`===`）与“等于”（用两个等号表示，`==`）的不同。“相同”表示两个类类型（class type）的常量或者变量引用同一个类实例。“等于”表示两个实例的值“相等”或“等价”，判定时要遵照设计者定义的评判标准。 -当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./27_Advanced_Operators.md#equivalence_operators) 中将会详细介绍实现自定义 == 和 !== 运算符的流程。 +当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./27_Advanced_Operators.md#equivalence-operators) 中将会详细介绍实现自定义 == 和 !== 运算符的流程。 ### 指针 {#pointers} diff --git a/source/02_language_guide/10_Properties.md b/source/02_language_guide/10_Properties.md index 71476131..9326ff25 100755 --- a/source/02_language_guide/10_Properties.md +++ b/source/02_language_guide/10_Properties.md @@ -10,7 +10,7 @@ 简单来说，一个存储属性就是存储在特定类或结构体实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字 `var` 定义），也可以是*常量存储属性*（用关键字 `let` 定义）。 -可以在定义存储属性的时候指定默认值，请参考 [默认构造器](./14_Initialization.md#default_initializers) 一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考 [构造过程中常量属性的修改](./14_Initialization.md#assigning_constant_properties_during_initialization) 一节。 +可以在定义存储属性的时候指定默认值，请参考 [默认构造器](./14_Initialization.md#default-initializers) 一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考 [构造过程中常量属性的修改](./14-Initialization.md#assigning-constant-properties-during-initialization) 一节。 下面的例子定义了一个名为 `FixedLengthRange` 的结构体，该结构体用于描述整数的区间，且这个范围值在被创建后不能被修改。 @@ -239,7 +239,7 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)") > > 在父类初始化方法调用之后，在子类构造器中给父类的属性赋值时，会调用父类属性的 `willSet` 和 `didSet` 观察器。而在父类初始化方法调用之前，给子类的属性赋值时不会调用子类属性的观察器。 > -> 有关构造器代理的更多信息，请参考 [值类型的构造器代理](./14_Initialization.md#initializer_delegation_for_value_types) 和 [类的构造器代理](./14_Initialization.md#initializer_delegation_for_class_types)。 +> 有关构造器代理的更多信息，请参考 [值类型的构造器代理](./14_Initialization.md#initializer-delegation-for-value-types) 和 [类的构造器代理](./14-Initialization.md#initializer-delegation-for-class-types)。 下面是一个 `willSet` 和 `didSet` 实际运用的例子，其中定义了一个名为 `StepCounter` 的类，用来统计一个人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。 @@ -278,7 +278,7 @@ stepCounter.totalSteps = 896 > 注意 > -> 如果将带有观察器的属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出内存模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考 [输入输出参数](../03_language_reference/05_Declarations.html#in-out_parameters) +> 如果将带有观察器的属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出内存模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考 [输入输出参数](../03_language_reference/05_Declarations.html#in-out-parameters)。 ## 全局变量和局部变量 {#global-and-local-variables} @@ -290,7 +290,7 @@ stepCounter.totalSteps = 896 > 注意 > -> 全局的常量或变量都是延迟计算的，跟 [延时加载存储属性](#lazy_stored_properties) 相似，不同的地方在于，全局的常量或变量不需要标记 `lazy` 修饰符。 +> 全局的常量或变量都是延迟计算的，跟 [延时加载存储属性](#lazy-stored-properties) 相似，不同的地方在于，全局的常量或变量不需要标记 `lazy` 修饰符。 > > 局部范围的常量和变量从不延迟计算。 diff --git a/source/02_language_guide/11_Methods.md b/source/02_language_guide/11_Methods.md index eb5d6236..c785079a 100755 --- a/source/02_language_guide/11_Methods.md +++ b/source/02_language_guide/11_Methods.md @@ -47,7 +47,7 @@ counter.reset() // 计数值现在是0 ``` -函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见 [指定外部参数名](./06_Functions.md#specifying_external_parameter_names)。方法参数也一样，因为方法就是函数，只是这个函数与某个类型相关联了。 +函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见 [指定外部参数名](./06_Functions.md#specifying-external-parameter-names)。方法参数也一样，因为方法就是函数，只是这个函数与某个类型相关联了。 ### self 属性 {#the-self-property} @@ -107,7 +107,7 @@ print("The point is now at (\(somePoint.x), \(somePoint.y))") 上面的 `Point` 结构体定义了一个可变方法 `moveBy（x：y :)` 来移动 `Point` 实例到给定的位置。该方法被调用时修改了这个点，而不是返回一个新的点。方法定义时加上了 `mutating` 关键字，从而允许修改属性。 -注意，不能在结构体类型的常量（a constant of structure type）上调用可变方法，因为其属性不能被改变，即使属性是变量属性，详情参见 [常量结构体的存储属性](./10_Properties.md#stored_properties_of_constant_structure_instances)： +注意，不能在结构体类型的常量（a constant of structure type）上调用可变方法，因为其属性不能被改变，即使属性是变量属性，详情参见 [常量结构体的存储属性](./10_Properties.md#stored-properties-of-constant-structure-instances)： ```swift let fixedPoint = Point(x: 3.0, y: 3.0) @@ -213,7 +213,7 @@ struct LevelTracker { 除了类型属性和类型方法，`LevelTracker` 还监测每个玩家的进度。它用实例属性 `currentLevel` 来监测每个玩家当前的等级。 -为了便于管理 `currentLevel` 属性，`LevelTracker` 定义了实例方法 `advance(to:)`。这个方法会在更新 `currentLevel` 之前检查所请求的新等级是否已经解锁。`advance(to:)` 方法返回布尔值以指示是否能够设置 `currentLevel`。因为允许在调用 `advance(to:)` 时候忽略返回值，不会产生编译警告，所以函数被标注为 `@discardableResult` 属性，更多关于属性信息，请参考 [特性](../03_language_reference/07_Attributes.html)章节。 +为了便于管理 `currentLevel` 属性，`LevelTracker` 定义了实例方法 `advance(to:)`。这个方法会在更新 `currentLevel` 之前检查所请求的新等级是否已经解锁。`advance(to:)` 方法返回布尔值以指示是否能够设置 `currentLevel`。因为允许在调用 `advance(to:)` 时候忽略返回值，不会产生编译警告，所以函数被标注为 `@discardableResult` 属性，更多关于属性信息，请参考 [特性](../03_language_reference/07_Attributes.html) 章节。 下面，`Player` 类使用 `LevelTracker` 来监测和更新每个玩家的发展进度： diff --git a/source/02_language_guide/12_Subscripts.md b/source/02_language_guide/12_Subscripts.md index 78ef926c..51d8ffe2 100755 --- a/source/02_language_guide/12_Subscripts.md +++ b/source/02_language_guide/12_Subscripts.md @@ -64,7 +64,7 @@ numberOfLegs["bird"] = 2 上例定义一个名为 `numberOfLegs` 的变量，并用一个包含三对键值的字典字面量初始化它。`numberOfLegs` 字典的类型被推断为 `[String: Int]`。字典创建完成后，该例子通过下标将 `String` 类型的键 `bird` 和 `Int` 类型的值 `2` 添加到字典中。 -更多关于 `Dictionary` 下标的信息请参考 [读取和修改字典](./04_Collection_Types.md#accessing_and_modifying_a_dictionary)。 +更多关于 `Dictionary` 下标的信息请参考 [读取和修改字典](./04_Collection_Types.md#accessing-and-modifying-a-dictionary)。 > 注意 > @@ -103,7 +103,7 @@ struct Matrix { } ``` -`Matrix` 提供了一个接受两个入参的构造方法，入参分别是 `rows` 和 `columns`，创建了一个足够容纳 `rows * columns` 个 `Double` 类型的值的数组。通过传入数组长度和初始值 `0.0` 到数组的构造器，将矩阵中每个位置的值初始化为 `0.0`。关于数组的这种构造方法请参考 [创建一个带有默认值的数组](./04_Collection_Types.md#creating_an_array_with_a_default_value)。 +`Matrix` 提供了一个接受两个入参的构造方法，入参分别是 `rows` 和 `columns`，创建了一个足够容纳 `rows * columns` 个 `Double` 类型的值的数组。通过传入数组长度和初始值 `0.0` 到数组的构造器，将矩阵中每个位置的值初始化为 `0.0`。关于数组的这种构造方法请参考 [创建一个带有默认值的数组](./04_Collection_Types.md#creating-an-array-with-a-default-value)。 你可以通过传入合适的 `row` 和 `column` 数值来构造一个新的 `Matrix` 实例： diff --git a/source/02_language_guide/13_Inheritance.md b/source/02_language_guide/13_Inheritance.md index 7fe7452d..a88ff244 100755 --- a/source/02_language_guide/13_Inheritance.md +++ b/source/02_language_guide/13_Inheritance.md @@ -184,7 +184,7 @@ print("Car: \(car.description)") #### 重写属性观察器 {#overriding-property-observers} -你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，无论被继承属性原本是如何实现的，当其属性值发生改变时，你就会被通知到。关于属性观察器的更多内容，请看 [属性观察器](../02_language_guide/10_Properties.html#property_observers)。 +你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，无论被继承属性原本是如何实现的，当其属性值发生改变时，你就会被通知到。关于属性观察器的更多内容，请看 [属性观察器](../02_language_guide/10_Properties.html#property-observers)。 > 注意 > diff --git a/source/02_language_guide/14_Initialization.md b/source/02_language_guide/14_Initialization.md index 25d1411d..3b0f7d69 100755 --- a/source/02_language_guide/14_Initialization.md +++ b/source/02_language_guide/14_Initialization.md @@ -131,7 +131,7 @@ let veryGreen = Color(0.0, 1.0, 0.0) 如果你不希望构造器的某个形参使用实参标签，可以使用下划线（`_`）来代替显式的实参标签来重写默认行为。 -下面是之前 [形参的构造过程](#initialization_parameters) 中 `Celsius` 例子的扩展，多了一个用已经的摄氏表示的 `Double` 类型值来创建新的 `Celsius` 实例的额外构造器： +下面是之前 [形参的构造过程](#initialization-parameters) 中 `Celsius` 例子的扩展，多了一个用已经的摄氏表示的 `Double` 类型值来创建新的 `Celsius` 实例的额外构造器： ```swift struct Celsius { @@ -258,7 +258,7 @@ print(zeroByZero.width, zeroByZero.height) 构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为*构造器代理*，它能避免多个构造器间的代码重复。 -构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给自己的其它构造器。类则不同，它可以继承自其它类（请参考 [继承](./13_Inheritance.md)）。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节 [类的继承和构造过程](#class_inheritance_and_initialization) 中介绍。 +构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给自己的其它构造器。类则不同，它可以继承自其它类（请参考 [继承](./13_Inheritance.md)）。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节 [类的继承和构造过程](#class-inheritance-and-initialization) 中介绍。 对于值类型，你可以使用 `self.init` 在自定义的构造器中引用相同类型中的其它构造器。并且你只能在构造器内部调用 `self.init`。 @@ -342,7 +342,7 @@ Swift 为类类型提供了两种构造器来确保实例中所有存储型属 类倾向于拥有极少的指定构造器，普遍的是一个类只拥有一个指定构造器。指定构造器像一个个“漏斗”放在构造过程发生的地方，让构造过程沿着父类链继续往上进行。 -每一个类都必须至少拥有一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节 [构造器的自动继承](#automatic_initializer_inheritance)。 +每一个类都必须至少拥有一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节 [构造器的自动继承](#automatic-initializer-inheritance)。 *便利构造器*是类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为部分形参提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入值的实例。 @@ -479,11 +479,11 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造 > 注意 > -> 父类的构造器仅会在安全和适当的某些情况下被继承。具体内容请参考后续章节 [构造器的自动继承](#automatic_initializer_inheritance)。 +> 父类的构造器仅会在安全和适当的某些情况下被继承。具体内容请参考后续章节 [构造器的自动继承](#automatic-initializer-inheritance)。 假如你希望自定义的子类中能提供一个或多个跟父类相同的构造器，你可以在子类中提供这些构造器的自定义实现。 -当你在编写一个和父类中指定构造器相匹配的子类构造器时，你实际上是在重写父类的这个指定构造器。因此，你必须在定义子类构造器时带上 `override` 修饰符。即使你重写的是系统自动提供的默认构造器，也需要带上 `override` 修饰符，具体内容请参考 [默认构造器](#default_initializers)。 +当你在编写一个和父类中指定构造器相匹配的子类构造器时，你实际上是在重写父类的这个指定构造器。因此，你必须在定义子类构造器时带上 `override` 修饰符。即使你重写的是系统自动提供的默认构造器，也需要带上 `override` 修饰符，具体内容请参考 [默认构造器](#default-initializers)。 正如重写属性，方法或者是下标，`override` 修饰符会让编译器去检查父类中是否有相匹配的指定构造器，并验证构造器参数是否被按预想中被指定。 @@ -491,7 +491,7 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造 > > 当你重写一个父类的指定构造器时，你总是需要写 `override` 修饰符，即使是为了实现子类的便利构造器。 -相反，如果你编写了一个和父类便利构造器相匹配的子类构造器，由于子类不能直接调用父类的便利构造器（每个规则都在上文 [类的构造器代理规则](#initializer_delegation_for_class_types) 有所描述），因此，严格意义上来讲，你的子类并未对一个父类构造器提供重写。最后的结果就是，你在子类中“重写”一个父类便利构造器时，不需要加 `override` 修饰符。 +相反，如果你编写了一个和父类便利构造器相匹配的子类构造器，由于子类不能直接调用父类的便利构造器（每个规则都在上文 [类的构造器代理规则](#initializer-delegation-for-class-types) 有所描述），因此，严格意义上来讲，你的子类并未对一个父类构造器提供重写。最后的结果就是，你在子类中“重写”一个父类便利构造器时，不需要加 `override` 修饰符。 在下面的例子中定义了一个叫 `Vehicle` 的基类。基类中声明了一个存储型属性 `numberOfWheels`，它是默认值为 `Int` 类型的 `0`。`numberOfWheels` 属性用在一个描述车辆特征 `String` 类型为 `descrpiption` 的计算型属性中： @@ -504,7 +504,7 @@ class Vehicle { } ``` -`Vehicle` 类只为存储型属性提供默认值，也没有提供自定义构造器。因此，它会自动获得一个默认构造器，具体内容请参考 [默认构造器](#default_initializers)。默认构造器（如果有的话）总是类中的指定构造器，可以用于创建 `numberOfWheels` 为 `0` 的 `Vehicle` 实例： +`Vehicle` 类只为存储型属性提供默认值，也没有提供自定义构造器。因此，它会自动获得一个默认构造器，具体内容请参考 [默认构造器](#default-initializers)。默认构造器（如果有的话）总是类中的指定构造器，可以用于创建 `numberOfWheels` 为 `0` 的 `Vehicle` 实例： ```swift let vehicle = Vehicle() @@ -642,11 +642,11 @@ class RecipeIngredient: Food { ![RecipeIngredient 构造器](https://docs.swift.org/swift-book/_images/initializersExample02_2x.png) -`RecipeIngredient` 类拥有一个指定构造器 `init(name: String, quantity: Int)`，它可以用来填充 `RecipeIngredient` 实例的所有属性值。这个构造器一开始先将传入的 `quantity` 实参赋值给 `quantity` 属性，这个属性也是唯一在 `RecipeIngredient` 中新引入的属性。随后，构造器向上代理到父类 `Food` 的 `init(name: String)`。这个过程满足 [两段式构造过程](#two_phase_initialization) 中的安全检查 1。 +`RecipeIngredient` 类拥有一个指定构造器 `init(name: String, quantity: Int)`，它可以用来填充 `RecipeIngredient` 实例的所有属性值。这个构造器一开始先将传入的 `quantity` 实参赋值给 `quantity` 属性，这个属性也是唯一在 `RecipeIngredient` 中新引入的属性。随后，构造器向上代理到父类 `Food` 的 `init(name: String)`。这个过程满足 [两段式构造过程](#two-phase-initialization) 中的安全检查 1。 `RecipeIngredient` 也定义了一个便利构造器 `init(name: String)`，它只通过 `name` 来创建 `RecipeIngredient` 的实例。这个便利构造器假设任意 `RecipeIngredient` 实例的 `quantity` 为 `1`，所以不需要显式的质量即可创建出实例。这个便利构造器的定义可以更加方便和快捷地创建实例，并且避免了创建多个 `quantity` 为 `1` 的 `RecipeIngredient` 实例时的代码重复。这个便利构造器只是简单地横向代理到类中的指定构造器，并为 `quantity` 参数传递 `1`。 -`RecipeIngredient` 的便利构造器 `init(name: String)` 使用了跟 `Food` 中指定构造器 `init(name: String)` 相同的形参。由于这个便利构造器重写了父类的指定构造器 `init(name: String)`，因此必须在前面使用 `override` 修饰符（参见 [构造器的继承和重写](#initializer_inheritance_and_overriding)）。 +`RecipeIngredient` 的便利构造器 `init(name: String)` 使用了跟 `Food` 中指定构造器 `init(name: String)` 相同的形参。由于这个便利构造器重写了父类的指定构造器 `init(name: String)`，因此必须在前面使用 `override` 修饰符（参见 [构造器的继承和重写](#initializer-inheritance-and-overriding)）。 尽管 `RecipeIngredient` 将父类的指定构造器重写为了便利构造器，但是它依然提供了父类的所有指定构造器的实现。因此，`RecipeIngredient` 会自动继承父类的所有便利构造器。 diff --git a/source/02_language_guide/16_Optional_Chaining.md b/source/02_language_guide/16_Optional_Chaining.md index f848ea29..f88d77f7 100755 --- a/source/02_language_guide/16_Optional_Chaining.md +++ b/source/02_language_guide/16_Optional_Chaining.md @@ -156,7 +156,7 @@ class Address { ## 通过可选链式调用访问属性 {#accessing-properties-through-optional-chaining} -正如 [使用可选链式调用代替强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping) 中所述，可以通过可选链式调用在一个可选值上访问它的属性，并判断访问是否成功。 +正如 [使用可选链式调用代替强制展开](#optional-chaining-as-an-alternative-to-forced-unwrapping) 中所述，可以通过可选链式调用在一个可选值上访问它的属性，并判断访问是否成功。 使用前面定义过的类，创建一个 `Person` 实例，然后像之前一样，尝试访问 `numberOfRooms` 属性： @@ -212,7 +212,7 @@ func printNumberOfRooms() { } ``` -这个方法没有返回值。然而，没有返回值的方法具有隐式的返回类型 `Void`，如 [无返回值函数](./06_Functions.md#functions_without_return_values) 中所述。这意味着没有返回值的方法也会返回 `()`，或者说空的元组。 +这个方法没有返回值。然而，没有返回值的方法具有隐式的返回类型 `Void`，如 [无返回值函数](./06_Functions.md#functions-without-return-values) 中所述。这意味着没有返回值的方法也会返回 `()`，或者说空的元组。 如果在可选值上通过可选链式调用来调用这个方法，该方法的返回类型会是 `Void?`，而不是 `Void`，因为通过可选链式调用得到的返回值都是可选的。这样我们就可以使用 `if` 语句来判断能否成功调用 `printNumberOfRooms()` 方法，即使方法本身没有定义返回值。通过判断返回值是否为 `nil` 可以判断调用是否成功： @@ -225,7 +225,7 @@ if john.residence?.printNumberOfRooms() != nil { // 打印“It was not possible to print the number of rooms.” ``` -同样的，可以据此判断通过可选链式调用为属性赋值是否成功。在上面的 [通过可选链式调用访问属性](#accessing_properties_through_optional_chaining) 的例子中，我们尝试给 `john.residence` 中的 `address` 属性赋值，即使 `residence` 为 `nil`。通过可选链式调用给属性赋值会返回 `Void?`，通过判断返回值是否为 `nil` 就可以知道赋值是否成功： +同样的，可以据此判断通过可选链式调用为属性赋值是否成功。在上面的 [通过可选链式调用访问属性](#accessing-properties-through-optional-chaining) 的例子中，我们尝试给 `john.residence` 中的 `address` 属性赋值，即使 `residence` 为 `nil`。通过可选链式调用给属性赋值会返回 `Void?`，通过判断返回值是否为 `nil` 就可以知道赋值是否成功： ```swift if (john.residence?.address = someAddress) != nil { diff --git a/source/02_language_guide/17_Error_Handling.md b/source/02_language_guide/17_Error_Handling.md index 8de1fbc2..1eec9345 100755 --- a/source/02_language_guide/17_Error_Handling.md +++ b/source/02_language_guide/17_Error_Handling.md @@ -194,7 +194,7 @@ do { 如果 `vend(itemNamed:)` 抛出的是一个 `VendingMachineError` 类型的错误，`nourish(with:)` 会打印一条消息，否则 `nourish(with:)` 会将错误抛给它的调用方。这个错误之后会被通用的 `catch` 语句捕获。 -### 将错误转换成可选值 {#converting_errors_to_optional_values} +### 将错误转换成可选值 {#converting-errors-to-optional-values} 可以使用 `try?` 通过将错误转换成一个可选值来处理错误。如果是在计算 `try?` 表达式时抛出错误，该表达式的结果就为 `nil`。例如，在下面的代码中，`x` 和 `y` 有着相同的数值和等价的含义： @@ -225,7 +225,7 @@ func fetchData() -> Data? { } ``` -### 禁用错误传递 {#disabling_error_propagation} +### 禁用错误传递 {#disabling-error-propagation} 有时你知道某个 `throwing` 函数实际上在运行时是不会抛出错误的，在这种情况下，你可以在表达式前面写 `try!` 来禁用错误传递，这会把调用包装在一个不会有错误抛出的运行时断言中。如果真的抛出了错误，你会得到一个运行时错误。 diff --git a/source/02_language_guide/18_Type_Casting.md b/source/02_language_guide/18_Type_Casting.md index 26058961..d24acab9 100644 --- a/source/02_language_guide/18_Type_Casting.md +++ b/source/02_language_guide/18_Type_Casting.md @@ -4,7 +4,7 @@ 类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符分别提供了一种简单达意的方式去检查值的类型或者转换它的类型。 -你也可以用它来检查一个类型是否遵循了某个协议，就像在 [检验协议遵循](./21_Protocols.md#checking_for_protocol_conformance) 部分讲述的一样。 +你也可以用它来检查一个类型是否遵循了某个协议，就像在 [检验协议遵循](./21_Protocols.md#checking-for-protocol-conformance) 部分讲述的一样。 ## 为类型转换定义类层次 {#defining-a-class-hierarchy-for-type-casting} diff --git a/source/02_language_guide/19_Nested_Types.md b/source/02_language_guide/19_Nested_Types.md index 64aa26cb..944198b2 100755 --- a/source/02_language_guide/19_Nested_Types.md +++ b/source/02_language_guide/19_Nested_Types.md @@ -63,7 +63,7 @@ struct BlackjackCard { `BlackjackCard` 结构体拥有两个属性——`rank` 与 `suit`。它也同样定义了一个计算型属性 `description`，`description` 属性用 `rank` 和 `suit` 中的内容来构建对扑克牌名字和数值的描述。该属性使用可选绑定来检查可选类型 `second` 是否有值，若有值，则在原有的描述中增加对 `second` 的描述。 -因为 `BlackjackCard` 是一个没有自定义构造器的结构体，在 [结构体的逐一成员构造器](./14_Initialization.md#memberwise_initializers_for_structure_types) 中可知，结构体有默认的成员构造器，所以你可以用默认的构造器去初始化新常量 `theAceOfSpades`： +因为 `BlackjackCard` 是一个没有自定义构造器的结构体，在 [结构体的逐一成员构造器](./14_Initialization.md#memberwise-initializers-for-structure-types) 中可知，结构体有默认的成员构造器，所以你可以用默认的构造器去初始化新常量 `theAceOfSpades`： ```swift let theAceOfSpades = BlackjackCard(rank: .ace, suit: .spades) diff --git a/source/02_language_guide/21_Protocols.md b/source/02_language_guide/21_Protocols.md index fbf83683..fdcc1aac 100644 --- a/source/02_language_guide/21_Protocols.md +++ b/source/02_language_guide/21_Protocols.md @@ -143,7 +143,7 @@ print("And another one: \(generator.random())") ## 异变方法要求 {#mutating-method-requirements} -有时需要在方法中改变（或*异变*）方法所属的实例。例如，在值类型（即结构体和枚举）的实例方法中，将 `mutating` 关键字作为方法的前缀，写在 `func` 关键字之前，表示可以在该方法中修改它所属的实例以及实例的任意属性的值。这一过程在 [在实例方法中修改值类型](./11_Methods.md#modifying_value_types_from_within_instance_methods) 章节中有详细描述。 +有时需要在方法中改变（或*异变*）方法所属的实例。例如，在值类型（即结构体和枚举）的实例方法中，将 `mutating` 关键字作为方法的前缀，写在 `func` 关键字之前，表示可以在该方法中修改它所属的实例以及实例的任意属性的值。这一过程在 [在实例方法中修改值类型](./11_Methods.md#modifying-value-types-from-within-instance-methods) 章节中有详细描述。 如果你在协议中定义了一个实例方法，该方法会改变遵循该协议的类型的实例，那么在定义协议时需要在方法前加 `mutating` 关键字。这使得结构体和枚举能够遵循此协议并满足此方法要求。 @@ -206,11 +206,11 @@ class SomeClass: SomeProtocol { 使用 `required` 修饰符可以确保所有子类也必须提供此构造器实现，从而也能遵循协议。 -关于 `required` 构造器的更多内容，请参考 [必要构造器](./14_Initialization.md#required_initializers)。 +关于 `required` 构造器的更多内容，请参考 [必要构造器](./14_Initialization.md#required-initializers)。 > 注意 > -> 如果类已经被标记为 `final`，那么不需要在协议构造器的实现中使用 `required` 修饰符，因为 `final` 类不能有子类。关于 `final` 修饰符的更多内容，请参见 [防止重写](./13_Inheritance.md#preventing_overrides)。 +> 如果类已经被标记为 `final`，那么不需要在协议构造器的实现中使用 `required` 修饰符，因为 `final` 类不能有子类。关于 `final` 修饰符的更多内容，请参见 [防止重写](./13_Inheritance.md#preventing-overrides)。 如果一个子类重写了父类的指定构造器，并且该构造器满足了某个协议的要求，那么该构造器的实现需要同时标注 `required` 和 `override` 修饰符： @@ -236,7 +236,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol { ### 可失败构造器要求 {#failable-initializer-requirements} -协议还可以为遵循协议的类型定义可失败构造器要求，详见 [可失败构造器](./14_Initialization.md#failable_initializers)。 +协议还可以为遵循协议的类型定义可失败构造器要求，详见 [可失败构造器](./14_Initialization.md#failable-initializers)。 遵循协议的类型可以通过可失败构造器（`init?`）或非可失败构造器（`init`）来满足协议中定义的可失败构造器要求。协议中定义的非可失败构造器要求可以通过非可失败构造器（`init`）或隐式解包可失败构造器（`init!`）来满足。 @@ -312,7 +312,7 @@ protocol DiceGameDelegate { `DiceGame` 协议可以被任意涉及骰子的游戏遵循。 -`DiceGameDelegate` 协议可以被任意类型遵循，用来追踪 `DiceGame` 的游戏过程。为了防止强引用导致的循环引用问题，可以把协议声明为弱引用，更多相关的知识请看 [类实例之间的循环强引用](./24_Automatic_Reference_Counting.md#strong_reference_cycles_between_class_instances)，当协议标记为类专属可以使 `SnakesAndLadders` 类在声明协议时强制要使用弱引用。若要声明类专属的协议就必须继承于 `AnyObject` ，更多请看 [类专属的协议](#class_only_protocol)。 +`DiceGameDelegate` 协议可以被任意类型遵循，用来追踪 `DiceGame` 的游戏过程。为了防止强引用导致的循环引用问题，可以把协议声明为弱引用，更多相关的知识请看 [类实例之间的循环强引用](./24_Automatic_Reference_Counting.md#strong-reference-cycles-between-class-instances)，当协议标记为类专属可以使 `SnakesAndLadders` 类在声明协议时强制要使用弱引用。若要声明类专属的协议就必须继承于 `AnyObject` ，更多请看 [类专属的协议](#class-only-protocol)。 如下所示，`SnakesAndLadders` 是 [控制流](./05_Control_Flow.md) 章节引入的蛇梯棋游戏的新版本。新版本使用 `Dice` 实例作为骰子，并且实现了 `DiceGame` 和 `DiceGameDelegate` 协议，后者用来记录游戏的过程： @@ -455,7 +455,7 @@ print(game.textualDescription) ## 有条件地遵循协议 {#Conditionally-Conforming-to-a-Protocol} -泛型类型可能只在某些情况下满足一个协议的要求，比如当类型的泛型形式参数遵循对应协议时。你可以通过在扩展类型时列出限制让泛型类型有条件地遵循某协议。在你采纳协议的名字后面写泛型 `where` 分句。更多关于泛型 `where` 分句，见 [泛型 Where 分句](./22_Generics.md##where_clauses)。 +泛型类型可能只在某些情况下满足一个协议的要求，比如当类型的泛型形式参数遵循对应协议时。你可以通过在扩展类型时列出限制让泛型类型有条件地遵循某协议。在你采纳协议的名字后面写泛型 `where` 分句。更多关于泛型 `where` 分句，见 [泛型 Where 分句](./22_Generics.md##where-clauses)。 下面的扩展让 `Array` 类型只要在存储遵循 `TextRepresentable` 协议的元素时就遵循 `TextRepresentable` 协议。 @@ -500,7 +500,7 @@ print(somethingTextRepresentable.textualDescription) ## 协议类型的集合 {#collections-of-protocol-types} -协议类型可以在数组或者字典这样的集合中使用，在 [协议类型](./21_Protocols.md##protocols_as_types) 提到了这样的用法。下面的例子创建了一个元素类型为 `TextRepresentable` 的数组： +协议类型可以在数组或者字典这样的集合中使用，在 [协议类型](./21_Protocols.md##protocols-as-types) 提到了这样的用法。下面的例子创建了一个元素类型为 `TextRepresentable` 的数组： ```swift let things: [TextRepresentable] = [game, d12, simonTheHamster] @@ -588,7 +588,7 @@ protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol { > 注意 > -> 当协议定义的要求需要遵循协议的类型必须是引用语义而非值语义时，应该采用类类型专属协议。关于引用语义和值语义的更多内容，请查看 [结构体和枚举是值类型](./09_Classes_and_Structures.md#structures_and_enumerations_are_value_types) 和 [类是引用类型](./09_Classes_and_Structures.md#classes_are_reference_types)。 +> 当协议定义的要求需要遵循协议的类型必须是引用语义而非值语义时，应该采用类类型专属协议。关于引用语义和值语义的更多内容，请查看 [结构体和枚举是值类型](./09_Classes_and_Structures.md#structures-and-enumerations-are-value-types) 和 [类是引用类型](./09-Classes-and-Structures.md#classes-are-reference-types)。 ## 协议合成 {#protocol-composition} @@ -883,7 +883,7 @@ extension PrettyTextRepresentable { ### 为协议扩展添加限制条件 {#adding-constraints-to-protocol-extensions} -在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。这些限制条件写在协议名之后，使用 `where` 子句来描述，正如 [泛型 Where 子句](./22_Generics.md#where_clauses) 中所描述的。 +在扩展协议的时候，可以指定一些限制条件，只有遵循协议的类型满足这些限制条件时，才能获得协议扩展提供的默认实现。这些限制条件写在协议名之后，使用 `where` 子句来描述，正如 [泛型 Where 子句](./22_Generics.md#where-clauses) 中所描述的。 例如，你可以扩展 `Collection` 协议，适用于集合中的元素遵循了 `Equatable` 协议的情况。通过限制集合元素遵循 `Equatable` 协议， 作为标准库的一部分， 你可以使用 `==` 和 `!=` 操作符来检查两个元素的等价性和非等价性。 diff --git a/source/02_language_guide/22_Generics.md b/source/02_language_guide/22_Generics.md index 3035fce8..9a8a645d 100644 --- a/source/02_language_guide/22_Generics.md +++ b/source/02_language_guide/22_Generics.md @@ -16,7 +16,7 @@ func swapTwoInts(_ a: inout Int, _ b: inout Int) { } ``` -这个函数使用输入输出参数（`inout`）来交换 `a` 和 `b` 的值，具体请参考 [输入输出参数](./06_Functions.md#in_out_parameters)。 +这个函数使用输入输出参数（`inout`）来交换 `a` 和 `b` 的值，具体请参考 [输入输出参数](./06_Functions.md#in-out-parameters)。 `swapTwoInts(_:_:)` 函数将 `b` 的原始值换成了 `a`，将 `a` 的原始值换成了 `b`，你可以调用这个函数来交换两个 `Int` 类型变量： @@ -226,7 +226,7 @@ if let topItem = stackOfStrings.topItem { // 打印“The top item on the stack is tres.” ``` -泛型类型的扩展，还可以包括类型扩展需要额外满足的条件，从而对类型添加新功能，这一部分将在[具有泛型 Where 子句的扩展](#extensions-with-a-generic-where-clause)中进行讨论。 +泛型类型的扩展，还可以包括类型扩展需要额外满足的条件，从而对类型添加新功能，这一部分将在 [具有泛型 Where 子句的扩展](#extensions-with-a-generic-where-clause) 中进行讨论。 ## 类型约束 {#type-constraints} @@ -410,7 +410,7 @@ struct Stack: Container { ### 扩展现有类型来指定关联类型 {#extending-an-existing-type-to-specify-an-associated-type} -[在扩展添加协议一致性](./21_Protocols.md#adding_protocol_conformance_with_an_extension) 中描述了如何利用扩展让一个已存在的类型遵循一个协议，这包括使用了关联类型协议。 +[在扩展添加协议一致性](./21_Protocols.md#adding-protocol-conformance-with-an-extension) 中描述了如何利用扩展让一个已存在的类型遵循一个协议，这包括使用了关联类型协议。 Swift 的 `Array` 类型已经提供 `append(_:)` 方法，`count` 属性，以及带有 `Int` 索引的下标来检索其元素。这三个功能都符合 `Container` 协议的要求，也就意味着你只需声明 `Array` 遵循`Container` 协议，就可以扩展 Array，使其遵从 Container 协议。你可以通过一个空扩展来实现这点，正如通过扩展采纳协议中的描述： @@ -446,7 +446,7 @@ protocol SuffixableContainer: Container { } ``` -在这个协议里，`Suffix` 是一个关联类型，就像上边例子中 `Container` 的 `Item` 类型一样。`Suffix` 拥有两个约束：它必须遵循 `SuffixableContainer` 协议（就是当前定义的协议），以及它的 `Item` 类型必须是和容器里的 `Item` 类型相同。`Item` 的约束是一个 `where` 分句，它在下面[具有泛型 Where 子句的扩展](#extensions-with-a-generic-where-clause)中有讨论。 +在这个协议里，`Suffix` 是一个关联类型，就像上边例子中 `Container` 的 `Item` 类型一样。`Suffix` 拥有两个约束：它必须遵循 `SuffixableContainer` 协议（就是当前定义的协议），以及它的 `Item` 类型必须是和容器里的 `Item` 类型相同。`Item` 的约束是一个 `where` 分句，它在下面 [具有泛型 Where 子句的扩展](#extensions-with-a-generic-where-clause) 中有讨论。 这是上面 [泛型类型](#generic-types) 中 `Stack` 类型的扩展，它遵循了 SuffixableContainer 协议： @@ -486,7 +486,7 @@ extension IntStack: SuffixableContainer { ## 泛型 Where 语句 {#where-clauses} -[类型约束](#type_constraints) 让你能够为泛型函数、下标、类型的类型参数定义一些强制要求。 +[类型约束](#type-constraints) 让你能够为泛型函数、下标、类型的类型参数定义一些强制要求。 对关联类型添加约束通常是非常有用的。你可以通过定义一个泛型 `where` 子句来实现。通过泛型 `where` 子句让关联类型遵从某个特定的协议，以及某个特定的类型参数和关联类型必须类型相同。你可以通过将 `where` 关键字紧跟在类型参数列表后面来定义 `where` 子句，`where` 子句后跟一个或者多个针对关联类型的约束，以及一个或多个类型参数和关联类型间的相等关系。你可以在函数体或者类型的大括号之前添加 `where` 子句。 diff --git a/source/02_language_guide/23_Opaque_Types.md b/source/02_language_guide/23_Opaque_Types.md index 87ceba54..76a88085 100644 --- a/source/02_language_guide/23_Opaque_Types.md +++ b/source/02_language_guide/23_Opaque_Types.md @@ -133,7 +133,7 @@ print(opaqueJoinedTriangles.draw()) // * ``` -这个例子中 `opaqueJoinedTriangles` 的值和前文 [不透明类型解决的问题](#the-problem-that-opaque-types-solve) 中关于泛型的那个例子中的 `joinedTriangles` 完全一样。不过和前文不一样的是，`flip(_:)` 和 `join(_:_:)` 将对泛型参数的操作后的返回结果包装成了不透明类型，这样保证了在结果中泛型参数类型不可见。两个函数都是泛型函数，因为他们都依赖于泛型参数，而泛型参数又将 `FlippedShape` 和 `JoinedShape` 所需要的类型信息传递给它们。 +这个例子中 `opaqueJoinedTriangles` 的值和前文 [不透明类型解决的问题](#the-problem-that-opaque-types-solve) 中关于泛型的那个例子中的 `joinedTriangles` 完全一样。不过和前文不一样的是，`flip(-:)` 和 `join(-:-:)` 将对泛型参数的操作后的返回结果包装成了不透明类型，这样保证了在结果中泛型参数类型不可见。两个函数都是泛型函数，因为他们都依赖于泛型参数，而泛型参数又将 `FlippedShape` 和 `JoinedShape` 所需要的类型信息传递给它们。 如果函数中有多个地方返回了不透明类型，那么所有可能的返回值都必须是同一类型。即使对于泛型函数，不透明返回类型可以使用泛型参数，但仍需保证返回类型唯一。比如，下面就是一个*非法*示例 —— 包含针对 `Square` 类型进行特殊处理的翻转函数。 diff --git a/source/02_language_guide/24_Automatic_Reference_Counting.md b/source/02_language_guide/24_Automatic_Reference_Counting.md index 09e6b23c..905a6fc1 100755 --- a/source/02_language_guide/24_Automatic_Reference_Counting.md +++ b/source/02_language_guide/24_Automatic_Reference_Counting.md @@ -2,7 +2,7 @@ Swift 使用*自动引用计数（ARC）*机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 内存管理机制会一直起作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。 -然而在少数情况下，为了能帮助你管理内存，ARC 需要更多的，代码之间关系的信息。本章描述了这些情况，并且为你示范怎样才能使 ARC 来管理你的应用程序的所有内存。在 Swift 使用 ARC 与在 Obejctive-C 中使用 ARC 非常类似，具体请参考 [过渡到 ARC 的发布说明](https://developer.apple.com/library/content/releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011226)。 +然而在少数情况下，为了能帮助你管理内存，ARC 需要更多的，代码之间关系的信息。本章描述了这些情况，并且为你示范怎样才能使 ARC 来管理你的应用程序的所有内存。在 Swift 使用 ARC 与在 Obejctive-C 中使用 ARC 非常类似，具体请参考 [过渡到 ARC 的发布说明](https://developer.apple.com/library/content/releasenotes/ObjectiveC/RN-TransitioningToARC/Introduction/Introduction.html#//apple-ref/doc/uid/TP40011226)。 > 注意 > @@ -87,7 +87,7 @@ reference3 = nil 然而，我们可能会写出一个类实例的强引用数*永远不能*变成 `0` 的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的*循环强引用*。 -你可以通过定义类之间的关系为弱引用或无主引用，来替代强引用，从而解决循环强引用的问题。具体的过程在 [解决类实例之间的循环强引用](#resolving_strong_reference_cycles_between_class_instances) 中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。 +你可以通过定义类之间的关系为弱引用或无主引用，来替代强引用，从而解决循环强引用的问题。具体的过程在 [解决类实例之间的循环强引用](#resolving-strong-reference-cycles-between-class-instances) 中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。 下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：`Person` 和 `Apartment`，用来建模公寓和它其中的居民： @@ -357,9 +357,9 @@ class City { 为了建立两个类的依赖关系，`City` 的构造器接受一个 `Country` 实例作为参数，并且将实例保存到 `country` 属性。 -`Country` 的构造器调用了 `City` 的构造器。然而，只有 `Country` 的实例完全初始化后，`Country` 的构造器才能把 `self` 传给 `City` 的构造器。在 [两段式构造过程](./14_Initialization.md#two_phase_initialization) 中有具体描述。 +`Country` 的构造器调用了 `City` 的构造器。然而，只有 `Country` 的实例完全初始化后，`Country` 的构造器才能把 `self` 传给 `City` 的构造器。在 [两段式构造过程](./14_Initialization.md#two-phase-initialization) 中有具体描述。 -为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将 `Country` 的 `capitalCity` 属性声明为隐式解包可选值类型的属性。这意味着像其他可选类型一样，`capitalCity` 属性的默认值为 `nil`，但是不需要展开它的值就能访问它。在 [隐式解包可选值](./01_The_Basics.md#implicityly_unwrapped_optionals) 中有描述。 +为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将 `Country` 的 `capitalCity` 属性声明为隐式解包可选值类型的属性。这意味着像其他可选类型一样，`capitalCity` 属性的默认值为 `nil`，但是不需要展开它的值就能访问它。在 [隐式解包可选值](./01_The_Basics.md#implicityly-unwrapped-optionals) 中有描述。 由于 `capitalCity` 默认值为 `nil`，一旦 `Country` 的实例在构造器中给 `name` 属性赋值后，整个初始化过程就完成了。这意味着一旦 `name` 属性被赋值后，`Country` 的构造器就能引用并传递隐式的 `self`。`Country` 的构造器在赋值 `capitalCity` 时，就能将 `self` 作为参数传递给 `City` 的构造器。 @@ -453,7 +453,7 @@ print(paragraph!.asHTML()) ![](https://docs.swift.org/swift-book/_images/closureReferenceCycle01_2x.png) -实例的 `asHTML` 属性持有闭包的强引用。但是，闭包在其闭包体内使用了 `self`（引用了 `self.name` 和 `self.text`），因此闭包捕获了 `self`，这意味着闭包又反过来持有了 `HTMLElement` 实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考 [值捕获](./07_Closures.md#capturing_values)）。 +实例的 `asHTML` 属性持有闭包的强引用。但是，闭包在其闭包体内使用了 `self`（引用了 `self.name` 和 `self.text`），因此闭包捕获了 `self`，这意味着闭包又反过来持有了 `HTMLElement` 实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考 [值捕获](./07_Closures.md#capturing-values)）。 > 注意 > diff --git a/source/02_language_guide/26_Access_Control.md b/source/02_language_guide/26_Access_Control.md index 501d0cbb..193ad1c0 100644 --- a/source/02_language_guide/26_Access_Control.md +++ b/source/02_language_guide/26_Access_Control.md @@ -80,7 +80,7 @@ fileprivate func someFilePrivateFunction() {} private func somePrivateFunction() {} ``` -除非专门指定，否则实体默认的访问级别为 `internal`，可以查阅 [默认访问级别](#default_access_levels) 这一节。这意味着在不使用修饰符显式声明访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 的访问级别是 `internal`： +除非专门指定，否则实体默认的访问级别为 `internal`，可以查阅 [默认访问级别](#default-access-levels) 这一节。这意味着在不使用修饰符显式声明访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 的访问级别是 `internal`： ```swift class SomeInternalClass {} // 隐式 internal @@ -142,7 +142,7 @@ func someFunction() -> (SomeInternalClass, SomePrivateClass) { } ``` -我们可以看到，这个函数的返回类型是一个元组，该元组中包含两个自定义的类（可查阅 [自定义类型](#custom_types)）。其中一个类的访问级别是 `internal`，另一个的访问级别是 `private`，所以根据元组访问级别的原则，该元组的访问级别是 `private`（元组的访问级别与元组中访问级别最低的类型一致）。 +我们可以看到，这个函数的返回类型是一个元组，该元组中包含两个自定义的类（可查阅 [自定义类型](#custom-types)）。其中一个类的访问级别是 `internal`，另一个的访问级别是 `private`，所以根据元组访问级别的原则，该元组的访问级别是 `private`（元组的访问级别与元组中访问级别最低的类型一致）。 因为该函数返回类型的访问级别是 `private`，所以你必须使用 `private` 修饰符来明确指定该函数的访问级别： @@ -277,13 +277,13 @@ public struct TrackedString { ## 构造器 {#initializers} -自定义构造器的访问级别可以低于或等于其所属类型的访问级别。唯一的例外是 [必要构造器](./14_Initialization.md#required_initializers)，它的访问级别必须和所属类型的访问级别相同。 +自定义构造器的访问级别可以低于或等于其所属类型的访问级别。唯一的例外是 [必要构造器](./14_Initialization.md#required-initializers)，它的访问级别必须和所属类型的访问级别相同。 如同函数或方法的参数，构造器参数的访问级别也不能低于构造器本身的访问级别。 ### 默认构造器 {#default-initializers} -如 [默认构造器](./14_Initialization.md#default_initializers) 所述，Swift 会为结构体和类提供一个默认的无参数的构造器，只要它们为所有存储型属性设置了默认初始值，并且未提供自定义的构造器。 +如 [默认构造器](./14_Initialization.md#default-initializers) 所述，Swift 会为结构体和类提供一个默认的无参数的构造器，只要它们为所有存储型属性设置了默认初始值，并且未提供自定义的构造器。 默认构造器的访问级别与所属类型的访问级别相同，除非类型的访问级别是 `public`。如果一个类型被指定为 `public` 级别，那么默认构造器的访问级别将为 `internal`。如果你希望一个 `public` 级别的类型也能在其他模块中使用这种无参数的默认构造器，你只能自己提供一个 `public` 访问级别的无参数构造器。 diff --git a/source/02_language_guide/27_Advanced_Operators.md b/source/02_language_guide/27_Advanced_Operators.md index 45e389e6..a19573a0 100644 --- a/source/02_language_guide/27_Advanced_Operators.md +++ b/source/02_language_guide/27_Advanced_Operators.md @@ -210,7 +210,7 @@ unsignedOverflow = unsignedOverflow &- 1 ![Art/overflowUnsignedSubtraction_2x.png](https://docs.swift.org/swift-book/_images/overflowUnsignedSubtraction_2x.png) -溢出也会发生在有符号整型上。针对有符号整型的所有溢出加法或者减法运算都是按位运算的方式执行的，符号位也需要参与计算，正如 [按位左移、右移运算符](#bitwise_left_and_right_shift_operators) 所描述的。 +溢出也会发生在有符号整型上。针对有符号整型的所有溢出加法或者减法运算都是按位运算的方式执行的，符号位也需要参与计算，正如 [按位左移、右移运算符](#bitwise-left-and-right-shift-operators) 所描述的。 ```Swift var signedOverflow = Int8.min @@ -440,7 +440,7 @@ let afterDoubling = +++toBeDoubled ### 自定义中缀运算符的优先级 {#precedence-and-associativity-for-custom-infix-operators} -每个自定义中缀运算符都属于某个优先级组。优先级组指定了这个运算符相对于其他中缀运算符的优先级和结合性。[优先级和结合性](#precedence_and_associativity) 中详细阐述了这两个特性是如何对中缀运算符的运算产生影响的。 +每个自定义中缀运算符都属于某个优先级组。优先级组指定了这个运算符相对于其他中缀运算符的优先级和结合性。[优先级和结合性](#precedence-and-associativity) 中详细阐述了这两个特性是如何对中缀运算符的运算产生影响的。 而没有明确放入某个优先级组的自定义中缀运算符将会被放到一个默认的优先级组内，其优先级高于三元运算符。 @@ -459,7 +459,7 @@ let plusMinusVector = firstVector +- secondVector // plusMinusVector 是一个 Vector2D 实例，并且它的值为 (4.0, -2.0) ``` -这个运算符把两个向量的 `x` 值相加，同时从第一个向量的 `y` 中减去第二个向量的 `y` 。因为它本质上是属于“相加型”运算符，所以将它放置在 `+` 和 `-` 等默认中缀“相加型”运算符相同的优先级组中。关于 Swift 标准库提供的运算符，以及完整的运算符优先级组和结合性设置，请参考 [运算符声明](https://developer.apple.com/documentation/swift/operator_declarations)。而更多关于优先级组以及自定义操作符和优先级组的语法，请参考 [运算符声明](./06_Declarations.md#operator_declaration)。 +这个运算符把两个向量的 `x` 值相加，同时从第一个向量的 `y` 中减去第二个向量的 `y` 。因为它本质上是属于“相加型”运算符，所以将它放置在 `+` 和 `-` 等默认中缀“相加型”运算符相同的优先级组中。关于 Swift 标准库提供的运算符，以及完整的运算符优先级组和结合性设置，请参考 [运算符声明](https://developer.apple.com/documentation/swift/operator_declarations)。而更多关于优先级组以及自定义操作符和优先级组的语法，请参考 [运算符声明](./06_Declarations.md#operator-declaration)。 > 注意 > diff --git a/source/03_language_reference/01_About_the_Language_Reference.md b/source/03_language_reference/01_About_the_Language_Reference.md index 2bac40fd..8832ad8c 100755 --- a/source/03_language_reference/01_About_the_Language_Reference.md +++ b/source/03_language_reference/01_About_the_Language_Reference.md @@ -19,14 +19,14 @@ Swift 语言相对较小，这是由于 Swift 代码中常用的类型、函数 > getter-setter 方法块语法 > -> *getter-setter 方法块* → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06_Declarations.md#setter-clause)可选 } | { [*setter 子句*](./06_Declarations.md#setter-clause) [*getter 子句*](./06_Declarations.md#getter-clause) } +> *getter-setter 方法块* → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06-Declarations.md#setter-clause)可选 } | { [*setter 子句*](./06-Declarations.md#setter-clause) [*getter 子句*](./06-Declarations.md#getter-clause) } > 这个定义表明，一个 getter-setter 方法块可以由一个 getter 分句后跟一个可选的 setter 分句构成，然后用大括号括起来，或者由一个 setter 分句后跟一个 getter 分句构成，然后用大括号括起来。上述的语法产式等价于下面的两个语法产式, ： > getter-setter 方法块语法 > -> getter-setter 方法块 → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06_Declarations.md#setter-clause)可选 } +> getter-setter 方法块 → { [*getter 子句*](./06_Declarations.md#getter-clause) [*setter 子句*](./06-Declarations.md#setter-clause)可选 } > -> getter-setter 方法块 → { [*setter 子句*](./06_Declarations.md#setter-clause) [*getter 子句*](./06_Declarations.md#getter-clause) } +> getter-setter 方法块 → { [*setter 子句*](./06_Declarations.md#setter-clause) [*getter 子句*](./06-Declarations.md#getter-clause) } > diff --git a/source/03_language_reference/02_Lexical_Structure.md b/source/03_language_reference/02_Lexical_Structure.md index 71d4a5a6..8558c3d2 100755 --- a/source/03_language_reference/02_Lexical_Structure.md +++ b/source/03_language_reference/02_Lexical_Structure.md @@ -212,7 +212,7 @@ true // 布尔值字面量 > > *二进制数字* → 数值 0 到 1 > -> *二进制字面量字符* → [*二进制数字*](#binary-digit) | _ +> *二进制字面量字符* → [*二进制数字*](#binary-digit) | - > > #### binary-literal-characters {#binary-literal-characters} @@ -229,7 +229,7 @@ true // 布尔值字面量 > > *八进字数字* → 数值 0 到 7 > -> *八进制字符* → [*八进字数字*](#octal-digit) | _ +> *八进制字符* → [*八进字数字*](#octal-digit) | - > > #### octal-literal-characters {#octal-literal-characters} @@ -251,7 +251,7 @@ true // 布尔值字面量 > > *十进制数字组* → [*十进制数字*](#decimal-digit) [*十进制数字组*](#decimal-literal-characters)可选 > -> *十进制字符* → [*十进制数字*](#decimal-digit) | _ +> *十进制字符* → [*十进制数字*](#decimal-digit) | - > > *十进制字符组* → [*十进制字符*](#decimal-literal-characters) [*十进制字符组*](#decimal-literal-characters)可选 > @@ -265,7 +265,7 @@ true // 布尔值字面量 > > *十六进制数字* → 数值 0 到 9, 字母 a 到 f, 或 A 到 F > -> *十六进制字符* → [*十六进制数字*](#hexadecimal-digit) | _ +> *十六进制字符* → [*十六进制数字*](#hexadecimal-digit) | - > > #### hexadecimal-literal-characters {#hexadecimal-literal-characters} @@ -545,7 +545,7 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 在某些特定的设计中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号，剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的符号，因而不会被错误解析为 `>>` 运算符。 -要学习如何自定义运算符，请参考 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom_operators) 和 [运算符声明](./06_Declarations.md#operator_declaration)。要学习如何重载运算符，请参考 [运算符函数](../02_language_guide/27_Advanced_Operators.md#operator_functions)。 +要学习如何自定义运算符，请参考 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom-operators) 和 [运算符声明](./06-Declarations.md#operator-declaration)。要学习如何重载运算符，请参考 [运算符函数](../02-language-guide/27-Advanced-Operators.md#operator-functions)。 > 运算符语法 > diff --git a/source/03_language_reference/03_Types.md b/source/03_language_reference/03_Types.md index a7dd6339..84df38e7 100644 --- a/source/03_language_reference/03_Types.md +++ b/source/03_language_reference/03_Types.md @@ -2,7 +2,7 @@ Swift 语言存在两种类型：命名型类型和复合型类型。*命名型类型*是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义类 `MyClass` 的实例拥有类型 `MyClass`。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。 -那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照 [扩展](../02_language_guide/20_Extensions.md) 和 [扩展声明](./06_Declarations.md#extension_declaration) 中讨论的那样，声明一个扩展来增加它们的行为以满足你程序的需求。 +那些通常被其它语言认为是基本或原始的数据型类型，比如表示数字、字符和字符串的类型，实际上就是命名型类型，这些类型在 Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照 [扩展](../02_language_guide/20_Extensions.md) 和 [扩展声明](./06_Declarations.md#extension-declaration) 中讨论的那样，声明一个扩展来增加它们的行为以满足你程序的需求。 *复合型类型*是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型 `(Int, (Int, Int))` 包含两个元素：第一个是命名型类型 `Int`，第二个是另一个复合型类型 `(Int, Int)`。 @@ -80,7 +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) @@ -88,7 +88,7 @@ var someValue: ExampleModule.MyType ## 元组类型 {#tuple-type-h} *元组类型*是使用括号括起来的零个或多个类型，类型间用逗号隔开。 -你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符紧跟一个冒号 `(:)` 组成。[函数和多返回值](../02_language_guide/06_Functions.md#functions_with_multiple_return_values) 章节里有一个展示上述特性的例子。 +你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符紧跟一个冒号 `(:)` 组成。[函数和多返回值](../02_language_guide/06_Functions.md#functions-with-multiple-return-values) 章节里有一个展示上述特性的例子。 当一个元组类型的元素有名字的时候，这个名字就是类型的一部分。 @@ -131,7 +131,7 @@ someTuple = (left: 5, right: 5) // 错误：命名类型不匹配 函数类型可以拥有一个可变参数在*形参类型*中。从语法角度上讲，可变参数由一个基础类型名字紧随三个点（`...`）组成，如 `Int...`。可变参数被认为是一个包含了基础类型元素的数组。即 `Int...` 就是 `[Int]`。关于使用可变参数的例子，请参阅 [可变参数](../02_language_guide/06_Functions.md#variadic-parameters)。 -为了指定一个 `in-out` 参数，可以在形参类型前加 `inout` 前缀。但是你不可以对可变参数或返回值类型使用 `inout`。关于这种形参的详细讲解请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in_out_parameters)。 +为了指定一个 `in-out` 参数，可以在形参类型前加 `inout` 前缀。但是你不可以对可变参数或返回值类型使用 `inout`。关于这种形参的详细讲解请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in-out-parameters)。 如果函数类型只有一个类型是元组类型的一个形参，那么元组类型在写函数类型的时候必须用圆括号括起来。比如说，`((Int, Int)) -> Void` 是接收一个元组 `(Int, Int)` 作为形参并且不返回任何值的函数类型。与此相对，不加括号的 `(Int, Int) -> Void` 是一个接收两个 `Int` 作为形参并且不返回任何值的函数类型。相似地，因为 `Void` 是空元组类型 `()` 的别名，函数类型 `(Void)-> Void` 与 `(()) -> ()` 是一样的 - 一个将空元组作为唯一实参的函数。但这些类型和 `() -> ()` 是不一样的 - 一个无实参的函数。 @@ -164,7 +164,7 @@ var operation: (Int, Int) -> Int // 正确 如果一个函数类型包涵多个箭头（->），那么函数类型将从右向左进行组合。例如，函数类型 `(Int) -> (Int) -> Int` 可以理解为 `(Int) -> ((Int) -> Int)`，也就是说，该函数传入 `Int`，并返回另一个传入并返回 `Int` 的函数。 -函数类型若要抛出或重抛错误就必须使用 `throws` 关键字来标记。`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` 类型的常量中，因为这可能导致值的逃逸。 @@ -329,7 +329,7 @@ let implicitlyUnwrappedArray: [Int]! // 正确 可以使用可选链式调用对隐式解析可选表达式选择性地执行操作。如果值为 `nil`，就不会执行任何操作，因此也不会产生运行错误。 -关于隐式解析可选类型的更多细节，请参阅 [隐式解析可选类型](../02_language_guide/01_The_Basics.md#implicityly_unwrapped_optionals)。 +关于隐式解析可选类型的更多细节，请参阅 [隐式解析可选类型](../02_language_guide/01_The_Basics.md#implicityly-unwrapped-optionals)。 > 隐式解析可选类型语法 > @@ -490,12 +490,12 @@ print(type(of: z.f())) 其它命名型类型只能继承自或采纳一系列协议。协议类型可以继承自任意数量的其他协议。当一个协议类型继承自其它协议时，其它协议中定义的要求会被整合在一起，然后从当前协议继承的任意类型必须符合所有这些条件。 -枚举定义中的类型继承子句可以是一系列协议，或者是指定单一的命名类型，此时枚举为其用例分配原始值。在枚举定义中使用类型继承子句来指定原始值类型的例子，请参阅 [原始值](../02_language_guide/08_Enumerations.md#raw_values)。 +枚举定义中的类型继承子句可以是一系列协议，或者是指定单一的命名类型，此时枚举为其用例分配原始值。在枚举定义中使用类型继承子句来指定原始值类型的例子，请参阅 [原始值](../02_language_guide/08_Enumerations.md#raw-values)。 > 类型继承子句语法 > -#### type_inheritance_clause {#type-inheritance-clause} +#### type-inheritance-clause {#type-inheritance-clause} > *类型继承子句* → **:** [*类型继承列表*](#type-inheritance-list) > diff --git a/source/03_language_reference/04_Expressions.md b/source/03_language_reference/04_Expressions.md index dd89d5b4..faa77830 100644 --- a/source/03_language_reference/04_Expressions.md +++ b/source/03_language_reference/04_Expressions.md @@ -22,7 +22,7 @@ Swift 中存在四种表达式：前缀表达式，二元表达式，基本表 关于 Swift 标准库提供的运算符的更多信息，请参阅 [*Operators Declarations*](https://developer.apple.com/documentation/swift/operator_declarations)。 -除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。更多信息，请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in_out_parameters)。 +除了标准库运算符，你也可以对某个变量使用 `&` 运算符，从而将其传递给函数的输入输出参数。更多信息，请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in-out-parameters)。 > 前缀表达式语法 > @@ -137,7 +137,7 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try 如果条件为真，那么对第一个表达式进行求值并返回结果。否则，对第二个表达式进行求值并返回结果。未使用的表达式不会进行求值。 -关于使用三元条件运算符的例子，请参阅 [三元条件运算符](../02_language_guide/02_Basic_Operators.md#ternary_conditional_operator)。 +关于使用三元条件运算符的例子，请参阅 [三元条件运算符](../02_language_guide/02_Basic_Operators.md#ternary-conditional-operator)。 > 三元条件运算符语法 > @@ -205,7 +205,7 @@ f(x as Any) > #### primary-expression {#primary-expression} -> *基本表达式* → [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选 +> *基本表达式* → [*标识符*](./02_Lexical_Structure.md#identifier) [*泛型实参子句*](./09-Generic-Parameters-and-Arguments.md#generic-argument-clause)可选 > > *基本表达式* → [*字面量表达式*](#literal-expression) > @@ -330,7 +330,7 @@ Xcode 使用 playground 字面量对程序编辑器中的颜色、文件或者 > *playground 字面量* → **#fileLiteral ( resourceName : [*表达式*](#expression) )** > > -#### playground 字面量* → **#imageLiteral ( resourceName : [*表达式*](#expression) )**self_expression {#self-expression} +#### playground 字面量* → **#imageLiteral ( resourceName : [*表达式*](#expression) )**self-expression {#self-expression} > ### Self 表达式 @@ -434,7 +434,7 @@ struct Point { } ``` -闭包的参数声明形式跟函数一样，请参阅 [函数声明](./06_Declarations.md#function_declaration)。 +闭包的参数声明形式跟函数一样，请参阅 [函数声明](./06_Declarations.md#function-declaration)。 闭包还有几种特殊的形式，能让闭包使用起来更加简洁： @@ -460,11 +460,11 @@ myFunction { return $0 + $1 } myFunction { $0 + $1 } ``` -关于如何将闭包作为参数来传递的内容，请参阅 [函数调用表达式](#function_call_expression)。 +关于如何将闭包作为参数来传递的内容，请参阅 [函数调用表达式](#function-call-expression)。 使用闭包表达式时，可以不必将其存储在一个变量或常量中，例如作为函数调用的一部分来立即使用一个闭包。在上面的例子中，传入 `myFunction` 的闭包表达式就是这种立即使用类型的闭包。因此，一个闭包是否逃逸与其使用时的上下文相关。一个会被立即调用或者作为函数的非逃逸参数传递的闭包表达式是非逃逸的，否则，这个闭包表达式是逃逸的。 -关于逃逸闭包的内容，请参阅 [逃逸闭包](./02_language_guide/07_Closures.md#escaping_closures)。 +关于逃逸闭包的内容，请参阅 [逃逸闭包](./02_language_guide/07_Closures.md#escaping-closures)。 ## 捕获列表 {#capture-lists} 默认情况下，闭包会捕获附近作用域中的常量和变量，并使用强引用指向它们。你可以通过一个*捕获列表*来显式指定它的捕获行为。 @@ -522,7 +522,7 @@ myFunction { [unowned self] in print(self.title) } // 无主引用捕获 myFunction { [weak parent = self.parent] in print(parent!.title) } ``` -关于闭包表达式的更多信息和例子，请参阅 [闭包表达式](../02_language_guide/07_Closures.md#closure_expressions)。关于捕获列表的更多信息和例子，请参阅 [解决闭包引起的循环强引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_for_closures)。 +关于闭包表达式的更多信息和例子，请参阅 [闭包表达式](../02_language_guide/07_Closures.md#closure-expressions)。关于捕获列表的更多信息和例子，请参阅 [解决闭包引起的循环强引用](../02-language-guide/24-Automatic-Reference-Counting.md#resolving-strong-reference-cycles-for-closures)。 > 闭包表达式语法 > @@ -537,13 +537,13 @@ myFunction { [weak parent = self.parent] in print(parent!.title) } #### closure-signature {#closure-signature} > > -> 闭包签名* → [*参数子句*](#parameter-clause) [*函数结果*](05_Declarations.md#function-result)可选 **in** +> 闭包签名* → [*参数子句*](#parameter-clause) [*函数结果*](05-Declarations.md#function-result)可选 **in** > -> *闭包签名* → [*标识符列表*](#identifier-list) [*函数结果*](05_Declarations.md#function-result)可选 **in** +> *闭包签名* → [*标识符列表*](#identifier-list) [*函数结果*](05-Declarations.md#function-result)可选 **in** > -> *闭包签名* → [*捕获列表*](#capture-list) [*参数子句*](05_Declarations.md#parameter-clause) [*函数结果*](./06_Declarations.md#function-result)可选 **in** +> *闭包签名* → [*捕获列表*](#capture-list) [*参数子句*](05-Declarations.md#parameter-clause) [*函数结果*](./06-Declarations.md#function-result)可选 **in** > -> *闭包签名* → [*捕获列表*](#capture-list) [*标识符列表*](02_Lexical_Structure.md#identifier-list) [*函数结果*](./06_Declarations.md#function-result)可选 **in** +> *闭包签名* → [*捕获列表*](#capture-list) [*标识符列表*](02-Lexical-Structure.md#identifier-list) [*函数结果*](./06-Declarations.md#function-result)可选 **in** > > *闭包签名* → [*捕获列表*](#capture-list) **in** > @@ -772,7 +772,7 @@ print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count.bitWidth // 打印 "64" ``` -关于更多如何使用 key path 与 Objective-C APIs 交互的信息，请参阅 [在 Swift 中使用 Objective-C 运行时特性](https://developer.apple.com/documentation/swift/using_objective_c_runtime_features_in_swift)。关于更多 key-value 编程和 key-value 观察的信息，请参阅 [Key-Value 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueCoding/index.html#//apple_ref/doc/uid/10000107i) 和 [Key-Value 观察编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.html#//apple_ref/doc/uid/10000177i)。 +关于更多如何使用 key path 与 Objective-C APIs 交互的信息，请参阅 [在 Swift 中使用 Objective-C 运行时特性](https://developer.apple.com/documentation/swift/using_objective_c_runtime_features_in_swift)。关于更多 key-value 编程和 key-value 观察的信息，请参阅 [Key-Value 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueCoding/index.html#//apple-ref/doc/uid/10000107i) 和 [Key-Value 观察编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.html#//apple-ref/doc/uid/10000177i)。 > key-path 表达式语法 > @@ -823,7 +823,7 @@ class SomeClass: NSObject { self.property = property } } -let selectorForMethod = #selector(SomeClass.doSomething(_:)) +let selectorForMethod = #selector(SomeClass.doSomething(-:)) let selectorForPropertyGetter = #selector(getter: SomeClass.property) ``` @@ -836,7 +836,7 @@ extension SomeClass { @objc(doSomethingWithString:) func doSomething(_ x: String) { } } -let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (String) -> Void) +let anotherSelector = #selector(SomeClass.doSomething(-:) as (SomeClass) -> (String) -> Void) ``` 由于选择器是在编译时创建的，因此编译器可以检查方法或者属性是否存在，以及是否在运行时暴露给了 Objective-C 。 @@ -852,11 +852,11 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str > #### selector-expression {#selector-expression} -> *选择器表达式* → __#selector__ **(** [*表达式*](#expression) **)** +> *选择器表达式* → __#selector-- **(** [*表达式*](#expression) **)** > -> *选择器表达式* → __#selector__ **(** [*getter:表达式*](#expression) **)** +> *选择器表达式* → __#selector-- **(** [*getter:表达式*](#expression) **)** > -> *选择器表达式* → __#selector__ **(** [*setter:表达式*](#expression) **)** +> *选择器表达式* → __#selector-- **(** [*setter:表达式*](#expression) **)** > ## Key-path 字符串表达式 {#key-path-string-expressions} @@ -899,7 +899,7 @@ print(keyPath == c.getSomeKeyPath()) 由于 key-path 字符串表达式在编译期才创建，编译期可以检查属性是否存在，以及属性是否暴露给 Objective-C 运行时。 -关于更多如何使用 key path 与 Objective-C APIs 交互的信息，请参阅 [在 Swift 中使用 Objective-C 运行时特性](./https://developer.apple.com/documentation/swift/using_objective_c_runtime_features_in_swift)。关于更多 key-value 编程和 key-value 观察的信息，请参阅 [Key-Value 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueCoding/index.md#//apple_ref/doc/uid/10000107i) 和 [Key-Value 观察编程](./https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.md#//apple_ref/doc/uid/10000177i)。 +关于更多如何使用 key path 与 Objective-C APIs 交互的信息，请参阅 [在 Swift 中使用 Objective-C 运行时特性](./https://developer.apple.com/documentation/swift/using_objective_c_runtime_features_in_swift)。关于更多 key-value 编程和 key-value 观察的信息，请参阅 [Key-Value 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueCoding/index.md#//apple-ref/doc/uid/10000107i) 和 [Key-Value 观察编程](./https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.md#//apple-ref/doc/uid/10000177i)。 > 注意 > @@ -928,7 +928,7 @@ print(keyPath == c.getSomeKeyPath()) #### postfix-expression {#postfix-expression} > *后缀表达式* → [*基本表达式*](#primary-expression) > -> *后缀表达式* → [*后缀表达式*](#postfix-expression) [*后缀运算符*](02_Lexical_Structure.md#postfix-operator) +> *后缀表达式* → [*后缀表达式*](#postfix-expression) [*后缀运算符*](02-Lexical-Structure.md#postfix-operator) > > *后缀表达式* → [*函数调用表达式*](#function-call-expression) > @@ -999,9 +999,9 @@ myData.someMethod {$0 == 13} > #### function-call-argument {#function-call-argument} > -> *函数调用参数* → [表达式](#expression) | [标识符](02_Lexical_Structure.md#identifier) **:** [*表达式*](#expression) +> *函数调用参数* → [表达式](#expression) | [标识符](02-Lexical-Structure.md#identifier) **:** [*表达式*](#expression) > -> *函数调用参数* → [运算符](./02_Lexical_Structure.md#operator) | [标识符](./02_Lexical_Structure.md#identifier) **:** [*运算符*](./02_Lexical_Structure.md#operator) +> *函数调用参数* → [运算符](./02_Lexical_Structure.md#operator) | [标识符](./02-Lexical-Structure.md#identifier) **:** [*运算符*](./02-Lexical-Structure.md#operator) > > > @@ -1116,11 +1116,11 @@ let x = [10, 3, 20, 15, 4] > #### explicit-member-expression {#explicit-member-expression} -> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*] (02_Lexical_Structure.md#decimal-digit) +> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*十进制数字*] (02-Lexical-Structure.md#decimal-digit) > -> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02_Lexical_Structure.md#identifier) [*泛型实参子句*](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选
+> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*](02-Lexical-Structure.md#identifier) [*泛型实参子句*](./09-Generic-Parameters-and-Arguments.md#generic-argument-clause)可选
> -> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*] (02_Lexical_Structure.md#identifier) **(** [*参数名称*](#argument-names) **)** +> *显式成员表达式* → [*后缀表达式*](#postfix-expression) **.** [*标识符*] (02-Lexical-Structure.md#identifier) **(** [*参数名称*](#argument-names) **)** > #### argument-names {#argument-names} @@ -1159,7 +1159,7 @@ let x = [10, 3, 20, 15, 4] 要获取下标表达式的值，可将索引表达式作为下标表达式的参数来调用下标 getter。下标 setter 的调用方式与之一样。 -关于下标的声明，请参阅 [协议下标声明](./06_Declarations.md#protocol_subscript_declaration)。 +关于下标的声明，请参阅 [协议下标声明](./06_Declarations.md#protocol-subscript-declaration)。 > 下标表达式语法 > diff --git a/source/03_language_reference/05_Statements.md b/source/03_language_reference/05_Statements.md index ac520281..ee3ed1c1 100755 --- a/source/03_language_reference/05_Statements.md +++ b/source/03_language_reference/05_Statements.md @@ -32,7 +32,7 @@ ## 循环语句 {#loop-statements} 循环语句会根据特定的循环条件来重复执行代码块。Swift 提供三种类型的循环语句：`for-in` 语句、`while` 语句和 `repeat-while` 语句。 -通过 `break` 语句和 `continue` 语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement) 和 [Continue 语句](#continue_statement)。 +通过 `break` 语句和 `continue` 语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break-statement) 和 [Continue 语句](#continue-statement)。 > 循环语句语法 > @@ -65,7 +65,7 @@ for item in collection { > #### for-in-statement {#for-in-statement} -> *for-in 语句* → **for** **case**可选 [*模式*](./08_Patterns.md#pattern) **in** [*表达式*](./04_Expressions.md#expression) [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.md#code-block) +> *for-in 语句* → **for** **case**可选 [*模式*](./08_Patterns.md#pattern) **in** [*表达式*](./04-Expressions.md#expression) [*where 子句*](#where-clause)可选 [*代码块*](05-Declarations.md#code-block) > ### While 语句 {#while-statements} @@ -86,19 +86,19 @@ while condition { 由于会在执行循环体中的语句前判断条件的值，因此循环体中的语句可能会被执行若干次，也可能一次也不会被执行。 -条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 +条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional-binding)。 > while 语句语法 > > #### while-statement {#while-statement} -> *while 语句* → **while** [*条件子句*](#condition-clause) [*代码块*](./05_Declarations.md#code-block) +> *while 语句* → **while** [*条件子句*](#condition-clause) [*代码块*](./05-Declarations.md#code-block) > #### condition-clause {#condition-clause} -> *条件子句* → [*表达式*](./04_Expressions.md#expression) | [*表达式*](./04_Expressions.md#expression) **,** [*条件列表*](#condition-list) +> *条件子句* → [*表达式*](./04_Expressions.md#expression) | [*表达式*](./04-Expressions.md#expression) **,** [*条件列表*](#condition-list) > #### condition {#condition} @@ -107,11 +107,11 @@ while condition { > #### case-condition {#case-condition} -> *case 条件* → **case** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) +> *case 条件* → **case** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06-Declarations.md#initializer) > #### optional-binding-condition {#optional-binding-condition} -> *可选绑定条件* → **let** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) | **var** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06_Declarations.md#initializer) +> *可选绑定条件* → **let** [*模式*](./08_Patterns.md#pattern) [*构造器*](./06-Declarations.md#initializer) | **var** [*模式*](./08-Patterns.md#pattern) [*构造器*](./06-Declarations.md#initializer) > ### Repeat-While 语句 {#repeat-while-statements} @@ -132,20 +132,20 @@ repeat { 由于条件的值是在循环体中的语句执行后才进行判断，因此循环体中的语句至少会被执行一次。 -条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 +条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional-binding)。 > repeat-while 语句语法 > > #### repeat-while-statement {#repeat-while-statement} -> *repeat-while 语句* → **repeat** [*代码块*](./06_Declarations.md#code-block) **while** [*表达式*](./04_Expressions.md#expression) +> *repeat-while 语句* → **repeat** [*代码块*](./06_Declarations.md#code-block) **while** [*表达式*](./04-Expressions.md#expression) > ## 分支语句 {#branch-statements} 分支语句会根据一个或者多个条件来执行指定部分的代码。分支语句中的条件将会决定程序如何分支以及执行哪部分代码。Swift 提供三种类型的分支语句：`if` 语句、 `guard` 语句和 `switch` 语句。 -`if` 语句和 `switch` 语句中的控制流可以用 `break` 语句改变，请参阅 [Break 语句](#break_statement)。 +`if` 语句和 `switch` 语句中的控制流可以用 `break` 语句改变，请参阅 [Break 语句](#break-statement)。 > 分支语句语法 > @@ -194,14 +194,14 @@ if condition 1 { } ``` -`if` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 +`if` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件语句也可以使用可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional-binding)。 > if 语句语法 > > #### if-statement {#if-statement} -> *if 语句* → **if** [*条件子句*](#condition-clause) [*代码块*](05_Declarations.md#code-block) [*else 子句*](#else-clause)可选 +> *if 语句* → **if** [*条件子句*](#condition-clause) [*代码块*](05-Declarations.md#code-block) [*else 子句*](#else-clause)可选 > #### else-clause {#else-clause} @@ -219,7 +219,7 @@ guard condition else { } ``` -`guard` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件也可以是一条可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional_binding)。 +`guard` 语句中条件的结果必须是 Bool 类型或者 Bool 的桥接类型。另外，条件也可以是一条可选绑定，请参阅 [可选绑定](../02_language_guide/01_The_Basics.md#optional-binding)。 在 `guard` 语句中进行可选绑定的任何常量或者变量，其可用范围从声明开始直到作用域结束。 @@ -230,14 +230,14 @@ guard condition else { * `continue` * `throw` -关于控制转移语句，请参阅 [控制转移语句](#control_transfer_statements)。关于 `Never` 返回类型的函数，请参阅 [永不返回的函数](05_Declarations.md#rethrowing_functions_and_methods)。 +关于控制转移语句，请参阅 [控制转移语句](#control-transfer-statements)。关于 `Never` 返回类型的函数，请参阅 [永不返回的函数](05-Declarations.md#rethrowing-functions-and-methods)。 > guard 语句语法 > > #### guard-statement {#guard-statement} -> *guard 语句* → **guard** [*条件子句*](#condition-clause) **else** [*代码块*] (05_Declarations.md#code-block) +> *guard 语句* → **guard** [*条件子句*](#condition-clause) **else** [*代码块*] (05-Declarations.md#code-block) > ### Switch 语句 {#switch-statements} @@ -303,7 +303,7 @@ case .suppressed: #### 不存在隐式落入 -当匹配到的 `case` 中的代码执行完毕后，`switch` 语句会直接退出，而不会继续执行下一个 `case` 。这就意味着，如果你想执行下一个 `case`，需要显式地在当前 `case` 中使用 `fallthrough` 语句。关于 `fallthrough` 语句的更多信息，请参阅 [Fallthrough 语句](#fallthrough_statements)。 +当匹配到的 `case` 中的代码执行完毕后，`switch` 语句会直接退出，而不会继续执行下一个 `case` 。这就意味着，如果你想执行下一个 `case`，需要显式地在当前 `case` 中使用 `fallthrough` 语句。关于 `fallthrough` 语句的更多信息，请参阅 [Fallthrough 语句](#fallthrough-statements)。 > switch 语句语法 > @@ -327,7 +327,7 @@ case .suppressed: > #### case-item-list {#case-item-list} -> *case 项列表* → [*模式*](./08_Patterns.md#pattern) [*where 子句*](#where-clause)可选 | [*模式*](07_Patterns.md#pattern) [*where 子句*](#where-clause)可选 **,** [*case 项列表*](#case-item-list) +> *case 项列表* → [*模式*](./08_Patterns.md#pattern) [*where 子句*](#where-clause)可选 | [*模式*](07-Patterns.md#pattern) [*where 子句*](#where-clause)可选 **,** [*case 项列表*](#case-item-list) > #### default-label {#default-label} @@ -344,39 +344,39 @@ case .suppressed: > > -#### grammar_conditional-switch-case {#grammar-conditional-switch-case} +#### grammar-conditional-switch-case {#grammar-conditional-switch-case} > *conditional-switch-case* → [*switch-if-directive-clause*](#switch-case-attributes-label) [*switch-elseif-directive-clauses*](#switch-case-attributes-label) 可选 [*switch-else-directive-clause*](#switch-case-attributes-label) 可选 [*endif-directive*](#switch-case-attributes-label) > -#### grammar_switch-if-directive-clause {#grammar-switch-if-directive-clause} +#### grammar-switch-if-directive-clause {#grammar-switch-if-directive-clause} > *switch-if-directive 语句* → [*if-directive*](#switch-case-attributes-label) [*compilation-condition*](#switch-case-attributes-label) [*switch-cases*](#switch-case-attributes-label) 可选 > -#### grammar_switch-elseif-directive-clauses {#grammar-switch-elseif-directive-clauses} +#### grammar-switch-elseif-directive-clauses {#grammar-switch-elseif-directive-clauses} > *switch-elseif-directive 语句（复数）* → [*elseif-directive-clause*](#switch-case-attributes-label) [*switch-elseif-directive-clauses*](#switch-case-attributes-label)可选 > -#### grammar_switch-elseif-directive-clause {#grammar-switch-elseif-directive-clause} +#### grammar-switch-elseif-directive-clause {#grammar-switch-elseif-directive-clause} > *switch-elseif-directive 语句* → [*elseif-directive*](#switch-case-attributes-label) [*compilation-condition*](#switch-case-attributes-label) [*switch-cases*](#switch-case-attributes-label)可选 > -#### grammar_switch-else-directive-clause {#grammar-switch-else-directive-clause} +#### grammar-switch-else-directive-clause {#grammar-switch-else-directive-clause} > *switch-else-directive 语句* → [*else-directive*](#switch-case-attributes-label) [*switch-cases*](#switch-case-attributes-label) 可选 > ## 带标签的语句 {#labeled-statements} -你可以在循环语句或 `switch` 语句前面加上标签，它由标签名和紧随其后的冒号（`:`）组成。在 `break` 和 `continue` 后面跟上标签名可以显式地在循环语句或 `switch` 语句中改变相应的控制流。关于这两条语句用法，请参阅 [Break 语句](#break_statement) 和 [Continue 语句](#continue_statement)。 +你可以在循环语句或 `switch` 语句前面加上标签，它由标签名和紧随其后的冒号（`:`）组成。在 `break` 和 `continue` 后面跟上标签名可以显式地在循环语句或 `switch` 语句中改变相应的控制流。关于这两条语句用法，请参阅 [Break 语句](#break-statement) 和 [Continue 语句](#continue-statement)。 标签的作用域在该标签所标记的语句内。可以嵌套使用带标签的语句，但标签名必须唯一。 -关于使用带标签的语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章中的 [带标签的语句](../02_language_guide/05_Control_Flow.md#labeled_statements)。 +关于使用带标签的语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章中的 [带标签的语句](../02_language_guide/05_Control_Flow.md#labeled-statements)。 > 带标签的语句语法 > > #### labeled-statement {#labeled-statement} -> *带标签的语句* → [*语句标签*](#statement-label) [*循环语句*](#grammar_loop-statement) +> *带标签的语句* → [*语句标签*](#statement-label) [*循环语句*](#grammar-loop-statement) > > *带标签的语句* → [*语句标签*](#statement-label) [*if 语句*](#if-statement) > @@ -426,7 +426,7 @@ case .suppressed: 无论哪种情况，控制权都会被转移给被终止的控制流语句后面的第一行语句。 -关于使用 `break` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [Break](../02_language_guide/05_Control_Flow.md#break) 和 [带标签的语句](../02_language_guide/05_Control_Flow.md#labeled_statements)。 +关于使用 `break` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [Break](../02_language_guide/05_Control_Flow.md#break) 和 [带标签的语句](../02-language-guide/05-Control-Flow.md#labeled-statements)。 > break 语句语法 > @@ -452,7 +452,7 @@ case .suppressed: 在 `for` 语句中，`continue` 语句执行后，增量表达式还是会被计算，这是因为每次循环体执行完毕后，增量表达式都会被计算。 -关于使用 `continue` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [Continue](../02_language_guide/05_Control_Flow.md#continue) 和 [带标签的语句](../02_language_guide/05_Control_Flow.md#labeled_statements)。 +关于使用 `continue` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [Continue](../02_language_guide/05_Control_Flow.md#continue) 和 [带标签的语句](../02-language-guide/05-Control-Flow.md#labeled-statements)。 > continue 语句语法 > @@ -467,7 +467,7 @@ case .suppressed: `fallthrough` 语句可出现在 `switch` 语句中的任意 `case` 中，但不能出现在最后一个 `case` 中。同时，`fallthrough` 语句也不能把控制权转移到使用了值绑定的 `case`。 -关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [控制转移语句](../02_language_guide/05_Control_Flow.md#control_transfer_statements)。 +关于在 `switch` 语句中使用 `fallthrough` 语句的例子，请参阅 [控制流](../02_language_guide/05_Control_Flow.md) 一章的 [控制转移语句](../02_language_guide/05_Control_Flow.md#control-transfer-statements)。 > fallthrough 语句语法 > @@ -492,7 +492,7 @@ case .suppressed: > 注意 > > -> 正如 [可失败构造器](./06_Declarations.md#failable_initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。 +> 正如 [可失败构造器](./06_Declarations.md#failable-initializers) 中所描述的，`return nil` 在可失败构造器中用于表明构造失败。 > 而只写 `return` 时，仅仅是从该函数或方法中返回，而不返回任何值（也就是说，函数或方法的返回类型为 `Void` 或者说 `()`）。 @@ -517,7 +517,7 @@ case .suppressed: 表达式的结果必须符合 `ErrorType` 协议。 -关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../02_language_guide/17_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../02_language_guide/17_Error_Handling.md#propagating_errors_using_throwing_functions)。 +关于如何使用 `throw` 语句的例子，请参阅 [错误处理](../02_language_guide/17_Error_Handling.md) 一章的 [用 throwing 函数传递错误](../02_language_guide/17_Error_Handling.md#propagating-errors-using-throwing-functions)。 > throw 语句语法 > @@ -586,7 +586,7 @@ do { 为了确保错误已经被处理，可以让 `catch` 子句使用匹配所有错误的模式，如通配符模式（`_`）。如果一个 `catch` 子句不指定一种具体模式，`catch` 子句会匹配任何错误，并绑定到名为 `error` 的局部常量。有关在 `catch` 子句中使用模式的更多信息，请参阅 [模式](./08_Patterns.md)。 -关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../02_language_guide/17_Error_Handling.md#handling_errors)。 +关于如何在 `do` 语句中使用一系列 `catch` 子句的例子，请参阅 [错误处理](../02_language_guide/17_Error_Handling.md#handling-errors)。 > do 语句语法 > @@ -601,7 +601,7 @@ do { > #### catch-clause {#catch-clause} -> *catch 子句* → **catch** [*模式*](./08_Patterns.md#pattern)可选 [*where 子句*](#where-clause)可选 [*代码块*](05_Declarations.md#code-block) +> *catch 子句* → **catch** [*模式*](./08_Patterns.md#pattern)可选 [*where 子句*](#where-clause)可选 [*代码块*](05-Declarations.md#code-block) > ## 编译器控制语句 {#compiler-control-statements} @@ -612,11 +612,11 @@ do { > #### compiler-control-statement {#compiler-control-statement} -> *编译器控制语句* → [*条件编译语句*](#grammar_conditional-compilation-block) +> *编译器控制语句* → [*条件编译语句*](#grammar-conditional-compilation-block) > > *编译器控制语句* → [*线路控制语句*](#line-control-statement) > -> *编译器控制语句* → [*诊断语句*](#grammar_diagnostic-statement) +> *编译器控制语句* → [*诊断语句*](#grammar-diagnostic-statement) > ### 条件编译代码块 {#Conditional-Compilation-Block} @@ -697,24 +697,24 @@ statements to compile if both compilation conditions are false > > -#### grammar_conditional-compilation-block {#grammar-conditional-compilation-block} -> *条件编译代码块* → [*if-directive 语句*](#grammar_if-directive-clause) [*elseif-directive 语句（复数）*](#grammar_elseif-directive-clauses)可选 [*else-directive 语句*](#grammar_else-directive-clause)可选 [*endif-directive*](#grammar_endif-directive) +#### grammar-conditional-compilation-block {#grammar-conditional-compilation-block} +> *条件编译代码块* → [*if-directive 语句*](#grammar-if-directive-clause) [*elseif-directive 语句（复数）*](#grammar-elseif-directive-clauses)可选 [*else-directive 语句*](#grammar-else-directive-clause)可选 [*endif-directive*](#grammar-endif-directive) > -#### grammar_if-directive-clause {#grammar-if-directive-clause} -> *if-directive 语句* → [*if-directive*](#grammar_if-directive) [*编译条件*](#compilation-condition) [*语句（复数）*](#statements)可选 +#### grammar-if-directive-clause {#grammar-if-directive-clause} +> *if-directive 语句* → [*if-directive*](#grammar-if-directive) [*编译条件*](#compilation-condition) [*语句（复数）*](#statements)可选 > -#### grammar_elseif-directive-clauses {#grammar-elseif-directive-clauses} -> *elseif-directive 语句（复数）* → [*elseif-directive 语句*](#grammar_elseif-directive-clause) [*elseif-directive 语句（复数）*](#grammar_elseif-directive-clauses) +#### grammar-elseif-directive-clauses {#grammar-elseif-directive-clauses} +> *elseif-directive 语句（复数）* → [*elseif-directive 语句*](#grammar-elseif-directive-clause) [*elseif-directive 语句（复数）*](#grammar-elseif-directive-clauses) > -#### grammar_elseif-directive-clauses {#grammar-elseif-directive-clauses} -> *elseif-directive 语句* → [*elseif-directive*](#grammar_elseif-directive) [*编译条件*](#compilation-condition) [*语句（复数）*](#statements)可选 +#### grammar-elseif-directive-clauses {#grammar-elseif-directive-clauses} +> *elseif-directive 语句* → [*elseif-directive*](#grammar-elseif-directive) [*编译条件*](#compilation-condition) [*语句（复数）*](#statements)可选 > -#### grammar_else-directive-clause {#grammar-else-directive-clause} -> *else-directive 语句* → [*else-directive*](#grammar_else-directive) [*语句（复数）*](#statements)可选 +#### grammar-else-directive-clause {#grammar-else-directive-clause} +> *else-directive 语句* → [*else-directive*](#grammar-else-directive) [*语句（复数）*](#statements)可选 > @@ -729,7 +729,7 @@ statements to compile if both compilation conditions are false #### compilation-condition {#compilation-condition} -> *编译条件* → [*平台条件*](#grammar_platform-condition) +> *编译条件* → [*平台条件*](#grammar-platform-condition) > > *编译条件* → [*标识符*](./02_Lexical_Structure.md#identifier) > @@ -745,30 +745,30 @@ statements to compile if both compilation conditions are false > -#### grammar_platform-condition {#grammar-platform-condition} +#### grammar-platform-condition {#grammar-platform-condition} -#### grammar_platform-condition-os {#grammar-platform-condition-os} +#### grammar-platform-condition-os {#grammar-platform-condition-os} > *平台条件* → **os ( [*操作系统*](#operating-system) )** > -#### grammar_platform-condition-arch {#grammar-platform-condition-arch} +#### grammar-platform-condition-arch {#grammar-platform-condition-arch} > *平台条件* → **arch ( [*架构*](#architecture) )** > -#### grammar_platform-condition-swift {#grammar-platform-condition-swift} +#### grammar-platform-condition-swift {#grammar-platform-condition-swift} > *平台条件* → **swift ( >= [*swift 版本*](#swift-version) )** | **swift ( < [*swift 版本*](#swift-version) )** > -#### grammar_platform-condition-compiler {#grammar-platform-condition-compiler} +#### grammar-platform-condition-compiler {#grammar-platform-condition-compiler} > *平台条件* → **compiler ( >= [*swift 版本*](#swift-version) )** | **compiler ( < [*swift 版本*](#swift-version) )** > -#### grammar_platform-condition-canImport {#grammar-platform-condition-canImport} -> *平台条件* → **canImport ( [*模块名*](#grammar_module-name) )** +#### grammar-platform-condition-canImport {#grammar-platform-condition-canImport} +> *平台条件* → **canImport ( [*模块名*](#grammar-module-name) )** > -#### grammar_platform-condition-targetEnvironment {#grammar-platform-condition-targetEnvironment} -> *平台条件* → **targetEnvironment ( [*环境*](#grammar_environment) )** +#### grammar-platform-condition-targetEnvironment {#grammar-platform-condition-targetEnvironment} +> *平台条件* → **targetEnvironment ( [*环境*](#grammar-environment) )** > #### operating-system {#operating-system} @@ -780,18 +780,18 @@ statements to compile if both compilation conditions are false > #### swift-version {#swift-version} -> *swift 版本* → [*十进制数字*](./02_Lexical_Structure.md#decimal-digit) ­**.** ­[*swift 版本延续*](#grammar_swift-version-continuation) 可选 +> *swift 版本* → [*十进制数字*](./02_Lexical_Structure.md#decimal-digit) ­**.** ­[*swift 版本延续*](#grammar-swift-version-continuation) 可选 > -#### grammar_swift-version-continuation {#grammar-swift-version-continuation} -> *swift 版本延续* → **.** [*十进制数字*](./02_Lexical_Structure.md#decimal-digit) [*swift 版本延续*](#grammar_swift-version-continuation) 可选 +#### grammar-swift-version-continuation {#grammar-swift-version-continuation} +> *swift 版本延续* → **.** [*十进制数字*](./02_Lexical_Structure.md#decimal-digit) [*swift 版本延续*](#grammar-swift-version-continuation) 可选 > -#### grammar_module-name {#grammar-module-name} +#### grammar-module-name {#grammar-module-name} > *模块名* → [*identifier*](./02_Lexical_Structure.md#identifier) > -#### grammar_environment {#grammar-environment} +#### grammar-environment {#grammar-environment} > *环境* → **模拟器** > @@ -843,10 +843,10 @@ statements to compile if both compilation conditions are false > > -#### grammar_compile-time-diagnostic-statement {#grammar-compile-time-diagnostic-statement} -> *诊断语句* → **#error** **(** [*diagnostic-message*](#grammar_diagnostic-message) **)** +#### grammar-compile-time-diagnostic-statement {#grammar-compile-time-diagnostic-statement} +> *诊断语句* → **#error** **(** [*diagnostic-message*](#grammar-diagnostic-message) **)** > -> *诊断语句* → **#warning** **(** [*diagnostic-message*](#grammar_diagnostic-message) **)** +> *诊断语句* → **#warning** **(** [*diagnostic-message*](#grammar-diagnostic-message) **)** > > *诊断语句* → [*静态字符串字面量*](./02_Lexical_Structure.md#static-string-literal) > @@ -903,7 +903,7 @@ if #available(platform name version, ..., *) { #### platform-version {#platform-version} > *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) > -> *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02_Lexical_Structure.md#decimal-digits) +> *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02-Lexical-Structure.md#decimal-digits) > -> *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02_Lexical_Structure.md#decimal-digits) +> *平台版本* → [十进制数字](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字](./02-Lexical-Structure.md#decimal-digits) **.** [十进制数字](./02-Lexical-Structure.md#decimal-digits) > diff --git a/source/03_language_reference/06_Declarations.md b/source/03_language_reference/06_Declarations.md index be615036..ee36f61d 100755 --- a/source/03_language_reference/06_Declarations.md +++ b/source/03_language_reference/06_Declarations.md @@ -44,7 +44,7 @@ > ## 顶级代码 {#top-level-code} -Swift 的源文件中的顶级代码（top-level code）由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access_control_levels)。 +Swift 的源文件中的顶级代码（top-level code）由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access-control-levels)。 > 顶级声明语法 > @@ -85,7 +85,7 @@ import 模块.子模块 ``` -#### grammer_of_an_import_declaration {#grammer-of-an-import-declaration} +#### grammer-of-an-import-declaration {#grammer-of-an-import-declaration} > 导入声明语法 > > @@ -106,7 +106,7 @@ import 模块.子模块 > #### import-path-identifier {#import-path-identifier} > -> *导入路径标识符* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator) +> *导入路径标识符* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02-Lexical-Structure.md#operator) > ## 常量声明 {#constant-declaration} @@ -135,14 +135,14 @@ print("The second number is \(secondNumber).") // 打印“The second number is 42.” ``` -当常量名称的类型（`:` 类型）可以被推断出时，类型注解在常量声明中是可选的，正如 [类型推断](./03_Types.md#type_inference) 中所描述的。 +当常量名称的类型（`:` 类型）可以被推断出时，类型注解在常量声明中是可选的，正如 [类型推断](./03_Types.md#type-inference) 中所描述的。 -声明一个常量类型属性要使用 `static` 声明修饰符。类的常量类型属性总是隐式地被标记为 `final` ；你无法用 `class` 或 `final` 声明修饰符实现允许或禁止被子类重写的目的。类型属性在 [类型属性](../02_language_guide/10_Properties.md#type_properties) 中有介绍。 +声明一个常量类型属性要使用 `static` 声明修饰符。类的常量类型属性总是隐式地被标记为 `final` ；你无法用 `class` 或 `final` 声明修饰符实现允许或禁止被子类重写的目的。类型属性在 [类型属性](../02_language_guide/10_Properties.md#type-properties) 中有介绍。 -如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../02_language_guide/01_The_Basics.md#constants_and_variables) 和 [存储属性](../02_language_guide/10_Properties.md#stored_properties)。 +如果还想获得更多关于常量的信息或者想在使用中获得帮助，请参阅 [常量和变量](../02_language_guide/01_The_Basics.md#constants-and-variables) 和 [存储属性](../02-language-guide/10-Properties.md#stored-properties)。 -#### grammer_of_a_constant_declaration {#grammer-of-a-constant-declaration} +#### grammer-of-a-constant-declaration {#grammer-of-a-constant-declaration} > 常量声明语法 > > @@ -173,7 +173,7 @@ print("The second number is \(secondNumber).") > 注意 > -> 也可以在协议声明中声明属性，详情请参阅 [协议属性声明](#protocol_property_declaration)。 +> 也可以在协议声明中声明属性，详情请参阅 [协议属性声明](#protocol-property-declaration)。 > 可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../02_language_guide/13_Inheritance.md#overriding)。 @@ -209,13 +209,13 @@ var 变量名称: 类型 { 可以在全局范围、函数内部，以及类、结构体、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构体、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性（computed property）*。 -getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../02_language_guide/10_Properties.md#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 +getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../02_language_guide/10_Properties.md#computed-properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 -setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../02_language_guide/10_Properties.md#shorthand_setter_declaration) 中描述的那样。 +setter 的圆括号以及 setter 名称是可选的。如果提供了 setter 名称，它就会作为 setter 的参数名称使用。如果不提供 setter 名称，setter 的参数的默认名称为 `newValue`，正如在 [便捷 setter 声明](../02_language_guide/10_Properties.md#shorthand-setter-declaration) 中描述的那样。 与存储型变量和存储型属性不同，计算型变量和计算型属性的值不存储在内存中。 -要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../02_language_guide/10_Properties.md#computed_properties)。 +要获得更多关于计算型属性的信息和例子，请参阅 [计算型属性](../02_language_guide/10_Properties.md#computed-properties)。 ### 存储型变量和属性的观察器 {#stored-variable-observers-and-property-observers} 可以在声明存储型变量或属性时提供 `willSet` 和 `didSet` 观察器。一个包含观察器的存储型变量或属性以如下形式声明： @@ -234,7 +234,7 @@ var 变量名称: 类型 = 表达式 { 可以在全局范围、函数内部，或者类、结构体的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，观察器表示一个存储型变量观察器。当它在类和结构体的声明中被声明时，观察器表示一个属性观察器。 可以为任何存储型属性添加观察器。也可以通过重写父类属性的方式为任何继承的属性（无论是存储型还是计算型的）添加观察器 -，正如 [重写属性观察器](../02_language_guide/13_Inheritance.md#overriding_property_observers) 中所描述的。 +，正如 [重写属性观察器](../02_language_guide/13_Inheritance.md#overriding-property-observers) 中所描述的。 用于初始化的表达式在类或者结构的声明中是可选的，但是在其他声明中则是必须的。如果可以从初始化表达式中推断出类型信息，那么可以不提供类型注解。 @@ -246,28 +246,28 @@ var 变量名称: 类型 = 表达式 { 提供了 `willSet` 时，`didSet` 是可选的。同样的，提供了 `didSet` 时，`willSet` 则是可选的。 -要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../02_language_guide/10_Properties.md#property_observers)。 +要获得更多信息以及查看如何使用属性观察器的例子，请参阅 [属性观察器](../02_language_guide/10_Properties.md#property-observers)。 ### 类型变量属性 {#type-variable-properties} -要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../02_language_guide/10_Properties.md#type_properties) 章节有详细讨论。 +要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../02_language_guide/10_Properties.md#type-properties) 章节有详细讨论。 -#### grammer_of_a_variable_declaration {#grammer-of-a-variable-declaration} +#### grammer-of-a-variable-declaration {#grammer-of-a-variable-declaration} > 变量声明语法 > #### variable-declaration {#variable-declaration} > *变量声明* → [*变量声明头*](#variable-declaration-head) [*模式构造器列表*](#pattern-initializer-list) > -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03_Types.md#type-annotation) [*代码块*](#code-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03-Types.md#type-annotation) [*代码块*](#code-block) > -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03_Types.md#type-annotation) [*getter-setter 代码块*](#getter-setter-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03-Types.md#type-annotation) [*getter-setter 代码块*](#getter-setter-block) > -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03-Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > > *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*构造器*](#initializer) [*willSet-didSet 代码块*](#willSet-didSet-block) > -> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03_Types.md#type-annotation) [*构造器*](#initializer)可选 [*willSet-didSet 代码块*](#willSet-didSet-block) +> *变量声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03-Types.md#type-annotation) [*构造器*](#initializer)可选 [*willSet-didSet 代码块*](#willSet-didSet-block) > @@ -386,10 +386,10 @@ func sum(_ sequence: T) -> Int where T.Element == Int { 假如没有类型别名，sum 函数将必须引用关联类型通过 T.Iterator.Element 的形式来替代 T.Element。 -另请参阅 [协议关联类型声明](#protocol_associated_type_declaration)。 +另请参阅 [协议关联类型声明](#protocol-associated-type-declaration)。 -#### grammer_of_a_type_alias_declaration {#grammer-of-a-type-alias-declaration} +#### grammer-of-a-type-alias-declaration {#grammer-of-a-type-alias-declaration} > 类型别名声明语法 > > @@ -426,7 +426,7 @@ func 函数名称(参数列表) { } ``` -每个参数的类型都要标明，因为它们不能被推断出来。如果您在某个参数类型前面加上了 `inout`，那么这个参数就可以在这个函数作用域当中被修改。更多关于 `inout` 参数的讨论，请参阅 [输入输出参数](#in-out_parameters)。 +每个参数的类型都要标明，因为它们不能被推断出来。如果您在某个参数类型前面加上了 `inout`，那么这个参数就可以在这个函数作用域当中被修改。更多关于 `inout` 参数的讨论，请参阅 [输入输出参数](#in-out-parameters)。 函数声明中语句只包含一个表达式，可以理解为返回该表达式的值。 @@ -436,7 +436,7 @@ func 函数名称(参数列表) { 大多数时候，嵌套函数都是可逃逸的函数。仅当一个嵌套函数捕获了某个确保了永不逃逸的值——例如一个输入输出参数——或者传入一个非逃逸函数参数的时候，这个嵌套函数才是非逃逸的。 -更多关于嵌套函数的讨论，请参阅 [嵌套函数](../02_language_guide/06_Functions.md#Nested_Functions)。 +更多关于嵌套函数的讨论，请参阅 [嵌套函数](../02_language_guide/06_Functions.md#Nested-Functions)。 ### 参数名 {#parameter-names} 函数的参数列表由一个或多个函数参数组成，参数间以逗号分隔。函数调用时的参数顺序必须和函数声明时的参数顺序一致。最简单的参数列表有着如下的形式： @@ -505,7 +505,7 @@ func multithreadedFunction(queue: DispatchQueue, x: inout Int) { } ``` -关于输入输出参数的详细讨论，请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in_out_parameters)。 +关于输入输出参数的详细讨论，请参阅 [输入输出参数](../02_language_guide/06_Functions.md#in-out-parameters)。 ### 特殊参数 {#special-kinds-of-parameters} 参数可以被忽略，数量可以不固定，还可以为其提供默认值，使用形式如下： @@ -518,7 +518,7 @@ _ : 参数类型 以下划线（`_`）命名的参数会被显式忽略，无法在函数内使用。 -一个参数的基本类型名称如果紧跟着三个点（`...`），会被视为可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数会作为包含该参数类型元素的数组处理。举例来讲，可变参数 `Int...` 会作为 `[Int]` 来处理。关于使用可变参数的例子，请参阅 [可变参数](../02_language_guide/06_Functions.md#variadic_parameters)。 +一个参数的基本类型名称如果紧跟着三个点（`...`），会被视为可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数会作为包含该参数类型元素的数组处理。举例来讲，可变参数 `Int...` 会作为 `[Int]` 来处理。关于使用可变参数的例子，请参阅 [可变参数](../02_language_guide/06_Functions.md#variadic-parameters)。 如果在参数类型后面有一个以等号（`=`）连接的表达式，该参数会拥有默认值，即给定表达式的值。当函数被调用时，给定的表达式会被求值。如果参数在函数调用时被省略了，就会使用其默认值。 @@ -584,17 +584,17 @@ func someFunction(callback: () throws -> Void) rethrows { ### 永不返回的函数 {#functions-that-never-return} Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它的调用者。`Never` 返回类型的函数或方法可以称为不归，不归函数、方法要么引发不可恢复的错误，要么永远不停地运作，这会使调用后本应执行得代码就不再执行了。但即使是不归函数、方法，抛错函数和重抛出函数也可以将程序控制转移到合适的 `catch` 代码块。 -不归函数、方法可以在 guard 语句的 else 字句中调用，具体讨论在 [*Guard 语句*](./05_Statements.md#guard_statements)。 +不归函数、方法可以在 guard 语句的 else 字句中调用，具体讨论在 [*Guard 语句*](./05_Statements.md#guard-statements)。 你可以重写一个不归方法，但是新的方法必须保持原有的返回类型和没有返回的行为。 -#### grammer_of_a_function_declaration {#grammer-of-a-function-declaration} +#### grammer-of-a-function-declaration {#grammer-of-a-function-declaration} > 函数声明语法 > #### function-declaration {#function-declaration} -> *函数声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*函数签名*](#function-signature) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause) [*函数体*](#function-body)可选 +> *函数声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*函数签名*](#function-signature) [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause) [*函数体*](#function-body)可选 > @@ -604,7 +604,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它 > #### function-name {#function-name} > -> *函数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02_Lexical_Structure.md#operator) +> *函数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | [*运算符*](./02-Lexical-Structure.md#operator) > > > @@ -618,7 +618,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它 > #### function-result {#function-result} > -> *函数结果* → **->** [*特性列表*](./07_Attributes.md#attributes)可选 [*类型*](./03_Types.md#type) +> *函数结果* → **->** [*特性列表*](./07_Attributes.md#attributes)可选 [*类型*](./03-Types.md#type) > > #### function-body {#function-body} @@ -639,21 +639,21 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它 > #### parameter {#parameter} > -> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型注解*](03_Types.md#type-annotation) [*默认参数子句*](#default-argument-clause)可选 +> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型注解*](03-Types.md#type-annotation) [*默认参数子句*](#default-argument-clause)可选 > -> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型注解*](03_Types.md#type-annotation) +> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型注解*](03-Types.md#type-annotation) > -> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型注解*](03_Types.md#type-annotation) **...** +> *参数* → [*外部参数名*](#external-parameter-name)可选 [*内部参数名*](#local-parameter-name) [*类型注解*](03-Types.md#type-annotation) **...** > > #### external-parameter-name {#external-parameter-name} > -> *外部参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | **_** +> *外部参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | **-** > > #### local-parameter-name {#local-parameter-name} > -> *内部参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | **_** +> *内部参数名* → [*标识符*](./02_Lexical_Structure.md#identifier) | **-** > > #### default-argument-clause {#default-argument-clause} @@ -670,9 +670,9 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它 不同于类或者结构体，枚举类型并不隐式提供默认构造器，所有构造器必须显式声明。一个构造器可以委托给枚举中的其他构造器，但是构造过程仅当构造器将一个枚举用例赋值给 `self` 后才算完成。 -和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 +和结构体类似但是和类不同，枚举是值类型。枚举实例在被赋值到变量或常量时，或者传递给函数作为参数时会被复制。更多关于值类型的信息，请参阅 [结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures-and-enumerations-are-value-types)。 -可以扩展枚举类型，正如在 [扩展声明](#extension_declaration) 中讨论的一样。 +可以扩展枚举类型，正如在 [扩展声明](#extension-declaration) 中讨论的一样。 ### 任意类型的枚举用例 {#enumerations-with-cases-of-any-type} 如下的形式声明了一个包含任意类型枚举用例的枚举变量： @@ -703,7 +703,7 @@ let f = Number.integer let evenInts: [Number] = [0, 2, 4, 6].map(f) ``` -要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../02_language_guide/08_Enumerations.md#associated_values)。 +要获得更多关于具有关联值的枚举用例的信息和例子，请参阅 [关联值](../02_language_guide/08_Enumerations.md#associated-values)。 #### 递归枚举 {#enumerations-with-indirection} 枚举类型可以具有递归结构，就是说，枚举用例的关联值类型可以是枚举类型自身。然而，枚举类型的实例具有值语义，这意味着它们在内存中有固定布局。为了支持递归，编译器必须插入一个间接层。 @@ -753,15 +753,15 @@ enum GamePlayMode: String { 在上面这个例子中，`GamePlayMode.cooperative` 的原始值是 `"cooperative"`，`GamePlayMode.individual` 的原始值是 `"individual"`，`GamePlayMode.competitive` 的原始值是 `"competitive"`。 -枚举用例具有原始值的枚举类型隐式地符合定义在 Swift 标准库中的 `RawRepresentable` 协议。所以，它们拥有一个 `rawValue` 属性和一个可失败构造器 `init?(rawValue: RawValue)`。可以使用 `rawValue` 属性去获取枚举用例的原始值，例如 `ExampleEnum.b.rawValue`。还可以根据原始值来创建一个相对应的枚举用例，只需调用枚举的可失败构造器，例如 `ExampleEnum(rawValue: 5)`，这个可失败构造器返回一个可选类型的用例。要获得更多关于具有原始值的枚举用例的信息和例子，请参阅 [原始值](../02_language_guide/08_Enumerations.md#raw_values)。 +枚举用例具有原始值的枚举类型隐式地符合定义在 Swift 标准库中的 `RawRepresentable` 协议。所以，它们拥有一个 `rawValue` 属性和一个可失败构造器 `init?(rawValue: RawValue)`。可以使用 `rawValue` 属性去获取枚举用例的原始值，例如 `ExampleEnum.b.rawValue`。还可以根据原始值来创建一个相对应的枚举用例，只需调用枚举的可失败构造器，例如 `ExampleEnum(rawValue: 5)`，这个可失败构造器返回一个可选类型的用例。要获得更多关于具有原始值的枚举用例的信息和例子，请参阅 [原始值](../02_language_guide/08_Enumerations.md#raw-values)。 ### 访问枚举用例 {#accessing-enumeration-cases} -使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.enumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../02_language_guide/08_Enumerations.md#enumeration_syntax) 和 [显式成员表达式](./04_Expressions.md#explicit_member_expression) 所述。 +使用点语法（`.`）来引用枚举类型的枚举用例，例如 `EnumerationType.enumerationCase`。当枚举类型可以由上下文推断而出时，可以省略它（但是 `.` 仍然需要），正如 [枚举语法](../02_language_guide/08_Enumerations.md#enumeration-syntax) 和 [显式成员表达式](./04-Expressions.md#explicit-member-expression) 所述。 -可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../02_language_guide/08_Enumerations.md#matching_enumeration_values_with_a_switch_statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](./08_Patterns.md#enumeration_case_pattern) 所述。 +可以使用 `switch` 语句来检验枚举用例的值，正如 [使用 switch 语句匹配枚举值](../02_language_guide/08_Enumerations.md#matching-enumeration-values-with-a-switch-statement) 所述。枚举类型是模式匹配的，依靠 `switch` 语句 `case` 块中的枚举用例模式，正如 [枚举用例模式](./08-Patterns.md#enumeration-case-pattern) 所述。 -#### grammer_of_an_enumeration_declaration {#grammer-of-an-enumeration-declaration} +#### grammer-of-an-enumeration-declaration {#grammer-of-an-enumeration-declaration} > 枚举声明语法 > > @@ -773,7 +773,7 @@ enum GamePlayMode: String { > *枚举声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier) 可选 [*原始值风格枚举*](#raw-value-style-enum) > > -> *联合风格枚举* → **indirect**可选 **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [类型继承子句](./03_Types.md#type-inheritance-clause)可选 **{** [*多个联合风格枚举成员*](#union-style-enum-members)可选 **}** +> *联合风格枚举* → **indirect**可选 **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [类型继承子句](./03-Types.md#type-inheritance-clause)可选 **{** [*多个联合风格枚举成员*](#union-style-enum-members)可选 **}** > > #### union-style-enum-members {#union-style-enum-members} @@ -783,7 +783,7 @@ enum GamePlayMode: String { > #### union-style-enum-member {#union-style-enum-member} > -> *联合风格枚举成员* → [*声明*](#declaration) | [*联合风格枚举用例子句*](#union-style-enum-case-clause) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) +> *联合风格枚举成员* → [*声明*](#declaration) | [*联合风格枚举用例子句*](#union-style-enum-case-clause) | [*编译控制流语句*](05-Statements.md#compiler-control-statement) > > #### union-style-enum-case-clause {#union-style-enum-case-clause} @@ -798,7 +798,7 @@ enum GamePlayMode: String { > #### union-style-enum-case {#union-style-enum-case} > -> *联合风格枚举用例* → [*枚举用例名称*](#enum-case-name) [*元组类型*](03_Types.md#tuple-type)可选 +> *联合风格枚举用例* → [*枚举用例名称*](#enum-case-name) [*元组类型*](03-Types.md#tuple-type)可选 > > #### enum-name {#enum-name} @@ -814,7 +814,7 @@ enum GamePlayMode: String { > #### raw-value-style-enum {#raw-value-style-enum} > > -> *原始值风格枚举* → **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03_Types.md#type-inheritance-clause) [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause) **{** [*多个原始值风格枚举成员*](#raw-value-style-enum-members) **}** +> *原始值风格枚举* → **enum** [*枚举名称*](#enum-name) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03-Types.md#type-inheritance-clause) [*泛型 where 子句*](./09-Generic-Parameters-and-Arguments.md#generic-where-clause) **{** [*多个原始值风格枚举成员*](#raw-value-style-enum-members) **}** > > #### raw-value-style-enum-members {#raw-value-style-enum-members} @@ -824,7 +824,7 @@ enum GamePlayMode: String { > #### raw-value-style-enum-member {#raw-value-style-enum-member} > -> *原始值风格枚举成员* → [*声明*](#declaration) | [*原始值风格枚举用例子句*](#raw-value-style-enum-case-clause) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) +> *原始值风格枚举成员* → [*声明*](#declaration) | [*原始值风格枚举用例子句*](#raw-value-style-enum-case-clause) | [*编译控制流语句*](05-Statements.md#compiler-control-statement) > > #### raw-value-style-enum-case-clause {#raw-value-style-enum-case-clause} @@ -849,7 +849,7 @@ enum GamePlayMode: String { > #### raw-value-literal {#raw-value-literal} > -> *原始值字面量* → [数字型字面量](./02_Lexical_Structure.md#numeric-literal) | [字符串型字面量](./02_Lexical_Structure.md#static-string-literal) | [布尔型字面量](./02_Lexical_Structure.md#boolean-literal) +> *原始值字面量* → [数字型字面量](./02_Lexical_Structure.md#numeric-literal) | [字符串型字面量](./02-Lexical-Structure.md#static-string-literal) | [布尔型字面量](./02-Lexical-Structure.md#boolean-literal) > ## 结构体声明 {#structure-declaration} @@ -869,28 +869,28 @@ struct 结构体名称: 采纳的协议 { * 调用结构体内声明的构造器，正如 [构造器](../02_language_guide/14_Initialization.md#initializers) 所述。 -* 如果没有声明构造器，调用结构体的成员逐一构造器，正如 [结构体类型的成员逐一构造器](../02_language_guide/14_Initialization.md#memberwise_initializers_for_structure_types) 所述。 +* 如果没有声明构造器，调用结构体的成员逐一构造器，正如 [结构体类型的成员逐一构造器](../02_language_guide/14_Initialization.md#memberwise-initializers-for-structure-types) 所述。 -* 如果没有声明构造器，而且结构体的所有属性都有初始值，调用结构体的默认构造器，正如 [默认构造器](../02_language_guide/14_Initialization.md#default_initializers) 所述。 +* 如果没有声明构造器，而且结构体的所有属性都有初始值，调用结构体的默认构造器，正如 [默认构造器](../02_language_guide/14_Initialization.md#default-initializers) 所述。 结构体的构造过程请参阅 [构造过程](../02_language_guide/14_Initialization.md)。 -结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../02_language_guide/09_Structures_And_Classes.md#accessing_properties) 所述。 +结构体实例的属性可以用点语法（`.`）来访问，正如 [访问属性](../02_language_guide/09_Structures_And_Classes.md#accessing-properties) 所述。 结构体是值类型。结构体的实例在被赋予变量或常量，或传递给函数作为参数时会被复制。关于值类型的更多信息，请参阅 -[结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 +[结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures-and-enumerations-are-value-types)。 -可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension_declaration)。 +可以使用扩展声明来扩展结构体类型的行为，请参阅 [扩展声明](#extension-declaration)。 -#### grammer_of_a_structure_declaration {#grammer-of-a-structure-declaration} +#### grammer-of-a-structure-declaration {#grammer-of-a-structure-declaration} > 结构体声明语法 > > > #### struct-declaration {#struct-declaration} > -> *结构体声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier) 可选 **struct** [*结构体名称*](#struct-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03_Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*结构体主体*](#struct-body) +> *结构体声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier) 可选 **struct** [*结构体名称*](#struct-name) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03-Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*结构体主体*](#struct-body) > > #### struct-name {#struct-name} @@ -911,7 +911,7 @@ struct 结构体名称: 采纳的协议 { > #### struct-member {#struct-member} > -> *结构体成员* → [*声明*](#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) +> *结构体成员* → [*声明*](#declaration) | [*编译控制流语句*](05-Statements.md#compiler-control-statement) > ## 类声明 {#class-declaration} @@ -927,7 +927,7 @@ class 类名: 超类, 采纳的协议 { 一个类只能继承自一个超类，但是可以采纳任意数量的协议。超类紧跟在类名和冒号后面，其后跟着采纳的协议。泛型类可以继承自其它泛型类和非泛型类，但是非泛型类只能继承自其它非泛型类。当在冒号后面写泛型超类的名称时，必须写上泛型类的全名，包括它的泛型形参子句。 -正如 [构造器声明](#initializer_declaration) 所讨论的，类可以有指定构造器和便利构造器。类的指定构造器必须初始化类中声明的所有属性，并且必须在调用超类构造器之前。 +正如 [构造器声明](#initializer-declaration) 所讨论的，类可以有指定构造器和便利构造器。类的指定构造器必须初始化类中声明的所有属性，并且必须在调用超类构造器之前。 类可以重写属性、方法、下标以及构造器。重写的属性、方法、下标和指定构造器必须以 `override` 声明修饰符标记。 @@ -939,25 +939,25 @@ class 类名: 超类, 采纳的协议 { * 调用类中声明的构造器，请参阅 [构造器](../02_language_guide/14_Initialization.md#initializers)。 -* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../02_language_guide/14_Initialization.md#default_initializers)。 +* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，请参阅 [默认构造器](../02_language_guide/14_Initialization.md#default-initializers)。 -类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../02_language_guide/09_Structures_And_Classes.md#accessing_properties)。 +类实例属性可以用点语法（`.`）来访问，请参阅 [访问属性](../02_language_guide/09_Structures_And_Classes.md#accessing-properties)。 -类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures_and_enumerations_are_value_types)。 +类是引用类型。当被赋予常量或变量，或者传递给函数作为参数时，类的实例会被引用，而不是被复制。关于引用类型的更多信息，请参阅 [结构体和枚举是值类型](../02_language_guide/09_Structures_And_Classes.md#structures-and-enumerations-are-value-types)。 -可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension_declaration)。 +可以使用扩展声明来扩展类的行为，请参阅 [扩展声明](#extension-declaration)。 -#### grammer_of_a_class_declaration {#grammer-of-a-class-declaration} +#### grammer-of-a-class-declaration {#grammer-of-a-class-declaration} > 类声明语法 > > > #### class-declaration {#class-declaration} > -> *类声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **final**可选 **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03_Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*类主体*](#class-body) +> *类声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **final**可选 **class** [*类名*](#class-name) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03-Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*类主体*](#class-body) > -> *类声明* → [*特性列表*](./07_Attributes.md#attributes)可选 **final** [访问级别修饰符](#access-level-modifier)可选 **class** [*类名*](#class-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03_Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*类主体*](#class-body) +> *类声明* → [*特性列表*](./07_Attributes.md#attributes)可选 **final** [访问级别修饰符](#access-level-modifier)可选 **class** [*类名*](#class-name) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*类型继承子句*](./03-Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*类主体*](#class-body) > > #### class-name {#class-name} @@ -975,7 +975,7 @@ class 类名: 超类, 采纳的协议 { > #### class-member {#class-member} > -> *类成员* → [*声明*](#declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) +> *类成员* → [*声明*](#declaration) | [*编译控制流语句*](05-Statements.md#compiler-control-statement) > ## 协议声明 {#protocol-declaration} @@ -989,16 +989,16 @@ protocol 协议名称: 继承的协议 { 协议的主体包含零个或多个协议成员声明，这些成员描述了任何采纳该协议的类型必须满足的一致性要求。一个协议可以声明采纳者必须实现的某些属性、方法、构造器以及下标。协议也可以声明各种各样的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议声明不能包括类、结构体、枚举或者其它协议的声明。协议成员声明会在后面进行讨论。 -协议类型可以继承自任意数量的其它协议。当一个协议类型继承自其它协议的时候，来自其它协议的所有要求会聚合在一起，而且采纳当前协议的类型必须符合所有的这些要求。关于如何使用协议继承的例子，请参阅 [协议继承](../02_language_guide/21_Protocols.md#protocol_inheritance)。 +协议类型可以继承自任意数量的其它协议。当一个协议类型继承自其它协议的时候，来自其它协议的所有要求会聚合在一起，而且采纳当前协议的类型必须符合所有的这些要求。关于如何使用协议继承的例子，请参阅 [协议继承](../02_language_guide/21_Protocols.md#protocol-inheritance)。 > 注意 > -> 也可以使用协议合成类型来聚合多个协议的一致性要求，请参阅 [协议合成类型](./03_Types.md#protocol_composition_type) 和 [协议合成](../02_language_guide/21_Protocols.md#protocol_composition)。 +> 也可以使用协议合成类型来聚合多个协议的一致性要求，请参阅 [协议合成类型](./03_Types.md#protocol-composition-type) 和 [协议合成](../02-language-guide/21-Protocols.md#protocol-composition)。 > 可以通过类型的扩展声明来采纳协议，从而为之前声明的类型添加协议一致性。在扩展中，必须实现所有采纳协议的要求。如果该类型已经实现了所有的要求，可以让这个扩展声明的主体留空。 -默认地，符合某个协议的类型必须实现所有在协议中声明的属性、方法和下标。即便如此，可以用 `optional` 声明修饰符标注协议成员声明，以指定它们的实现是可选的。`optional` 修饰符仅仅可以用于使用 `objc` 特性标记过的协议。因此，仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用 `optional` 声明修饰符的信息，以及如何访问可选协议成员的指导——例如不能确定采纳协议的类型是否实现了它们时——请参阅 [可选协议要求](../02_language_guide/21_Protocols.md#optional_protocol_requirements)。 +默认地，符合某个协议的类型必须实现所有在协议中声明的属性、方法和下标。即便如此，可以用 `optional` 声明修饰符标注协议成员声明，以指定它们的实现是可选的。`optional` 修饰符仅仅可以用于使用 `objc` 特性标记过的协议。因此，仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用 `optional` 声明修饰符的信息，以及如何访问可选协议成员的指导——例如不能确定采纳协议的类型是否实现了它们时——请参阅 [可选协议要求](../02_language_guide/21_Protocols.md#optional-protocol-requirements)。 为了限制协议只能被类类型采纳，需要使用 `AnyObject` 关键字来标记协议，将 `AnyObject` 关键在写在冒号后面的继承的协议列表的首位。例如，下面的协议只能被类类型采纳： @@ -1015,19 +1015,19 @@ protocol SomeProtocol: AnyObject { > 如果协议已经用 `objc` 特性标记了，`AnyObject` 要求就隐式地应用于该协议，无需显式使用 `AnyObject` 关键字。 > -协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../02_language_guide/21_Protocols.md#protocols_as_types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。 +协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../02_language_guide/21_Protocols.md#protocols-as-types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。 可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托（代理）模式](../02_language_guide/21_Protocols.md#delegation) 中所述。 -#### grammer_of_a_protocol_declaration {#grammer-of-a-protocol-declaration} +#### grammer-of-a-protocol-declaration {#grammer-of-a-protocol-declaration} > 协议声明语法 > > > #### protocol-declaration {#protocol-declaration} > -> *协议声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 **protocol** [*协议名称*](#protocol-name) [*类型继承子句*](03_Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*协议主体*](#protocol-body) +> *协议声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 **protocol** [*协议名称*](#protocol-name) [*类型继承子句*](03-Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*协议主体*](#protocol-body) > > #### protocol-name {#protocol-name} @@ -1045,7 +1045,7 @@ protocol SomeProtocol: AnyObject { > #### protocol-member {#protocol-member} > -> *协议成员* → [*协议成员声明*](#protocol-member-declaration) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) +> *协议成员* → [*协议成员声明*](#protocol-member-declaration) | [*编译控制流语句*](05-Statements.md#compiler-control-statement) > > > @@ -1076,37 +1076,37 @@ var 属性名: 类型 { get set } 同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了 getter 和 setter 要求，你不能在协议中直接实现 getter 和 setter。 -符合类型可以通过多种方式满足 getter 和 setter 要求。如果属性声明包含 `get` 和 `set` 关键字，符合类型就可以用存储型变量属性或可读可写的计算型属性来满足此要求，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含 `get` 关键字的话，它可以作为任意类型的属性被实现。关于如何实现协议中的属性要求的例子，请参阅 [属性要求](../02_language_guide/21_Protocols.md#property_requirements) 。 +符合类型可以通过多种方式满足 getter 和 setter 要求。如果属性声明包含 `get` 和 `set` 关键字，符合类型就可以用存储型变量属性或可读可写的计算型属性来满足此要求，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含 `get` 关键字的话，它可以作为任意类型的属性被实现。关于如何实现协议中的属性要求的例子，请参阅 [属性要求](../02_language_guide/21_Protocols.md#property-requirements) 。 协议声明中声明一个类型属性，属性声明语句必须用 `static` 声明修饰符。当结构体和枚举遵循该协议时，使用 `static` 关键字修饰，而类遵循该协议时，使用 `static` 或 `class` 关键字皆可。当结构体，枚举或类添加扩展遵循协议时，和之前扩展用到的关键字保持一致。扩展为类属性提供默认实现时，必须使用 `static` 关键字修饰。 -另请参阅 [变量声明](#variable_declaration)。 +另请参阅 [变量声明](#variable-declaration)。 -#### grammer_of_an_import_declaration {#grammer-of-an-import-declaration} +#### grammer-of-an-import-declaration {#grammer-of-an-import-declaration} > 协议属性声明语法 > > #### protocol-property-declaration {#protocol-property-declaration} > -> *协议属性声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03_Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> *协议属性声明* → [*变量声明头*](#variable-declaration-head) [*变量名称*](#variable-name) [*类型注解*](03-Types.md#type-annotation) [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > ### 协议方法声明 {#protocol-method-declaration} -协议可以通过在协议声明主体中引入一个协议方法声明，来声明符合的类型必须实现的方法。协议方法声明和函数方法声明有着相同的形式，但有两项例外：它们不包括函数体，也不能包含默认参数。关于如何实现协议中的方法要求的例子，请参阅 [方法要求](../02_language_guide/21_Protocols.md#method_requirements)。 +协议可以通过在协议声明主体中引入一个协议方法声明，来声明符合的类型必须实现的方法。协议方法声明和函数方法声明有着相同的形式，但有两项例外：它们不包括函数体，也不能包含默认参数。关于如何实现协议中的方法要求的例子，请参阅 [方法要求](../02_language_guide/21_Protocols.md#method-requirements)。 协议声明中声明一个类型方法，方法声明语句必须用 `static` 声明修饰符。结构体和枚举遵循协议时，必须使用 `static` 关键字修饰，而类遵循协议时，使用 `static` 或 `class` 关键字皆可。当结构体，枚举或类添加扩展遵循协议时，和之前扩展用到的关键字保持一致。扩展为类方法提供默认实现时，必须使用 `static` 关键字修饰。 -另请参阅 [函数声明](#function_declaration)。 +另请参阅 [函数声明](#function-declaration)。 -#### grammer_of_a_protocol_declaration {#grammer-of-a-protocol-declaration} +#### grammer-of-a-protocol-declaration {#grammer-of-a-protocol-declaration} > 协议方法声明语法 > > #### protocol-method-declaration {#protocol-method-declaration} > -> *协议方法声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*函数签名*](#function-signature) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 +> *协议方法声明* → [*函数头*](#function-head) [*函数名*](#function-name) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*函数签名*](#function-signature) [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > ### 协议构造器声明 {#protocol-initializer-declaration} @@ -1117,18 +1117,18 @@ var 属性名: 类型 { get set } 类在实现一个构造器去满足一个协议的构造器要求时，如果这个类还没有用 `final` 声明修饰符标记，这个构造器必须用 `required` 声明修饰符标记。 -另请参阅 [构造器声明](#initializer_declaration)。 +另请参阅 [构造器声明](#initializer-declaration)。 -#### grammer_of_a_protocol_initializer_declaration {#grammer-of-a-protocol-initializer-declaration} +#### grammer-of-a-protocol-initializer-declaration {#grammer-of-a-protocol-initializer-declaration} > 协议构造器声明语法 > > #### protocol-initializer-declaration {#protocol-initializer-declaration} > -> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 +> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > -> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows** [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 +> *协议构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows** [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > ### 协议下标声明 {#protocol-subscript-declaration} @@ -1142,20 +1142,20 @@ subscript (参数列表) -> 返回类型 { get set } 协议声明中声明一个静态下标，下标声明语句必须用 `static` 声明修饰符。当结构体和枚举遵循该协议时，下标声明使用 `static` 关键字修饰，而类遵循该协议时，使用 `static` 或 `class` 关键字皆可。当结构体，枚举或类添加扩展遵循协议时，和之前扩展用到的关键字保持一致。扩展为下标声明提供默认实现时，必须使用 `static` 关键字修饰。 -另请参阅 [下标声明](#subscript_declaration)。 +另请参阅 [下标声明](#subscript-declaration)。 -#### grammer_of_a_protocol_subscript_declaration {#grammer-of-a-protocol-subscript-declaration} +#### grammer-of-a-protocol-subscript-declaration {#grammer-of-a-protocol-subscript-declaration} > 协议下标声明语法 > > #### protocol-subscript-declaration {#protocol-subscript-declaration} > -> *协议下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> *协议下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > ### 协议关联类型声明 {#protocol-associated-type-declaration} -使用关键字 `associatedtype` 来声明协议关联类型。关联类型为作为协议声明的一部分，为某种类型提供了一个别名。关联类型和泛型参数子句中的类型参数很相似，但是它们和 `Self` 一样，用于协议中。`Self` 指代采纳协议的类型。要获得更多信息和例子，请参阅 [关联类型](../02_language_guide/22_Generics.md#associated_types)。 +使用关键字 `associatedtype` 来声明协议关联类型。关联类型为作为协议声明的一部分，为某种类型提供了一个别名。关联类型和泛型参数子句中的类型参数很相似，但是它们和 `Self` 一样，用于协议中。`Self` 指代采纳协议的类型。要获得更多信息和例子，请参阅 [关联类型](../02_language_guide/22_Generics.md#associated-types)。 在协议声明中使用泛型 `where` 子句来为继承的协议关联类型添加约束，且不需要重新声明关联类型。例如下面代码中的 `SubProtocol` 声明。 @@ -1175,16 +1175,16 @@ protocol SubProtocolB: SomeProtocol where SomeType: Equatable { } -另请参阅 [类型别名声明](#type_alias_declaration)。 +另请参阅 [类型别名声明](#type-alias-declaration)。 -#### grammer_of_a_protocol_associated_type_declaration {#grammer-of-a-protocol-associated-type-declaration} +#### grammer-of-a-protocol-associated-type-declaration {#grammer-of-a-protocol-associated-type-declaration} > 协议关联类型声明语法 > > #### protocol-associated-type-declaration {#protocol-associated-type-declaration} > -> *协议关联类型声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 **associatedtype** [*类型别名头*](#typealias-head) [*类型继承子句*](03_Types.md#type-inheritance-clause)可选 [*类型别名赋值*](#typealias-assignment)可选 [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 +> *协议关联类型声明* → [*特性列表*](./07_Attributes.md#attributes)可选 [*访问级别修饰符*](#access-level-modifier)可选 **associatedtype** [*类型别名头*](#typealias-head) [*类型继承子句*](03-Types.md#type-inheritance-clause)可选 [*类型别名赋值*](#typealias-assignment)可选 [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > ## 构造器声明 {#initializer-declaration} @@ -1268,18 +1268,18 @@ if let actualInstance = SomeStruct(input: "Hello") { 子类可以用任意种类的指定构造器重写超类的可失败指定构造器，但是只能用非可失败指定构造器重写超类的非可失败指定构造器。 -更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../02_language_guide/14_Initialization.md#failable_initializers)。 +更多关于可失败构造器的信息和例子，请参阅 [可失败构造器](../02_language_guide/14_Initialization.md#failable-initializers)。 -#### grammer_of_an_initializer_declaration {#grammer-of-an-initializer-declaration} +#### grammer-of-an-initializer-declaration {#grammer-of-an-initializer-declaration} > 构造器声明语法 > > #### initializer-declaration {#initializer-declaration} > -> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*构造器主体*](#initializer-body) +> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **throws**可选 [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*构造器主体*](#initializer-body) > -> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows**可选 [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*构造器主体*](#initializer-body) +> *构造器声明* → [*构造器头*](#initializer-head) [*泛型形参子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) **rethrows**可选 [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*构造器主体*](#initializer-body) > > #### initializer-head {#initializer-head} @@ -1314,7 +1314,7 @@ deinit { 关于如何在类声明中使用析构器的例子，请参阅 [析构过程](../02_language_guide/15_Deinitialization.md)。 -#### grammer_of_a_deinitializer_declaration {#grammer-of-a-deinitializer-declaration} +#### grammer-of-a-deinitializer-declaration {#grammer-of-a-deinitializer-declaration} > 析构器声明语法 > > @@ -1495,23 +1495,23 @@ extension Array: Loggable where Element: MarkedLoggable { } ``` -#### grammer_of_an_extension_declaration {#grammer-of-an-extension-declaration} +#### grammer-of-an-extension-declaration {#grammer-of-an-extension-declaration} > 扩展声明语法 > > > #### extension-declaration {#extension-declaration} > -> *扩展声明* → [特性](./07_Attributes.md#type_attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **extension** [*类型标识符*](03_Types.md#type-identifier) [*类型-继承-子句*](./03_Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*扩展主体*](#extension-body) +> *扩展声明* → [特性](./07_Attributes.md#type-attributes)可选 [访问级别修饰符](#access-level-modifier)可选 **extension** [*类型标识符*](03-Types.md#type-identifier) [*类型-继承-子句*](./03-Types.md#type-inheritance-clause)可选 [*泛型 where 子句*](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*扩展主体*](#extension-body) > > #### extension-body {#extension-body} > > *扩展主体* → **{** [*多条声明*](#declarations)可选 **}** > -> *多条声明* → [单条声明](#subscript_declaration) [多条声明](#declarations) 可选 +> *多条声明* → [单条声明](#subscript-declaration) [多条声明](#declarations) 可选 > -> *单条声明* → [声明语句](#declarations) | [*编译控制流语句*](05_Statements.md#compiler-control-statement) +> *单条声明* → [声明语句](#declarations) | [*编译控制流语句*](05-Statements.md#compiler-control-statement) > ## 下标声明 {#subscript-declaration} @@ -1540,7 +1540,7 @@ subscript (参数列表) -> 返回类型 { 下标参数遵循与函数参数相同的规则，但有两个例外。默认情况下，下标中使用的参数不需要指定标签，这与函数，方法和构造器不同。但是你也可以同它们一样，显式地提供参数标签。此外，下标不能有 `In-out` 参数。 -同样可以在协议声明中声明下标，正如 [协议下标声明](#protocol_subscript_declaration) 中所述。 +同样可以在协议声明中声明下标，正如 [协议下标声明](#protocol-subscript-declaration) 中所述。 更多关于下标的信息和例子，请参阅 [下标](../02_language_guide/12_Subscripts.md)。 @@ -1550,28 +1550,28 @@ subscript (参数列表) -> 返回类型 { -#### grammer_of_a_subscript_declaration {#grammer-of-a-subscript-declaration} +#### grammer-of-a-subscript-declaration {#grammer-of-a-subscript-declaration} > 下标声明语法 > > > #### subscript-declaration {#subscript-declaration} > -> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*代码块*](#code-block) +> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*代码块*](#code-block) > -> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*getter-setter 代码块*](#getter-setter-block) +> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*getter-setter 代码块*](#getter-setter-block) > -> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08_Generic_Parameters_and_Arguments.md#generic-where-clause)可选 [*getter-setter 关键字代码块*](#getter-setter-keyword-block) +> *下标声明* → [*下标头*](#subscript-head) [*下标结果*](#subscript-result) [*泛型 where 子句*](08-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [*getter-setter 关键字代码块*](#getter-setter-keyword-block) > > #### subscript-head {#subscript-head} > -> *下标头* → [*特性列表*](./07_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **subscript** [*泛型参数子句*](08_Generic_Parameters_and_Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) +> *下标头* → [*特性列表*](./07_Attributes.md#attributes)可选 [*声明修饰符列表*](#declaration-modifiers)可选 **subscript** [*泛型参数子句*](08-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [*参数子句*](#parameter-clause) > > #### subscript-result {#subscript-result} > -> *下标结果* → **->** [*特性列表*](./07_Attributes.md#attributes)可选 [*类型*](./03_Types.md#type) +> *下标结果* → **->** [*特性列表*](./07_Attributes.md#attributes)可选 [*类型*](./03-Types.md#type) > ## 运算符声明 {#operator-declaration} @@ -1589,7 +1589,7 @@ infix operator 运算符名称: 优先级组 中缀运算符是二元运算符，置于两个运算对象之间，例如加法运算符（`+`）位于表达式 `1 + 2` 的中间。 -中缀运算符可以选择指定优先级组。如果没有为运算符设置优先级组，Swift 会设置默认优先级组 `DefaultPrecedence`,它的优先级比三目优先级 `TernaryPrecedence` 要高，更多内容参考[*优先级组声明*](#precedence_group_declaration_modifiers) +中缀运算符可以选择指定优先级组。如果没有为运算符设置优先级组，Swift 会设置默认优先级组 `DefaultPrecedence`,它的优先级比三目优先级 `TernaryPrecedence` 要高，更多内容参考[*优先级组声明*](#precedence-group-declaration-modifiers) 下面的形式声明了一个新的前缀运算符： @@ -1611,10 +1611,10 @@ postfix operator 运算符名称 {} 和前缀运算符一样，后缀运算符的声明中不指定优先级，而且后缀运算符是非结合的。 -声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom_operators)。 +声明了一个新的运算符以后，需要实现一个跟这个运算符同名的函数来实现这个运算符。如果是实现一个前缀或者后缀运算符，也必须使用相符的 `prefix` 或者 `postfix` 声明修饰符标记函数声明。如果是实现中缀运算符，则不需要使用 `infix` 声明修饰符标记函数声明。关于如何实现一个新的运算符的例子，请参阅 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom-operators)。 -#### grammer_of_an_operator_declaration {#grammer-of-an-operator-declaration} +#### grammer-of-an-operator-declaration {#grammer-of-an-operator-declaration} > 运算符声明语法 > @@ -1667,7 +1667,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用， 优先级组的赋值性表示在包含可选链操作时的运算符优先级。当设为 true 时，与优先级组对应的运算符在可选链操作中使用和标准库中赋值运算符同样的分组规则，当设为 false 或者不设置，该优先级组的运算符与不赋值的运算符遵循同样的可选链规则。 -#### grammer_of_a_precedence_group_declaration {#grammer-of-a-precedence-group-declaration} +#### grammer-of-a-precedence-group-declaration {#grammer-of-a-precedence-group-declaration} > 优先级组声明语法 > @@ -1734,13 +1734,13 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用， `lazy` -该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在它被第一次访问时。关于如何使用 `lazy` 修饰符的例子，请参阅 [惰性存储型属性](../02_language_guide/10_Properties.md#lazy_stored_properties)。 +该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在它被第一次访问时。关于如何使用 `lazy` 修饰符的例子，请参阅 [惰性存储型属性](../02_language_guide/10_Properties.md#lazy-stored-properties)。 `optional` 该修饰符用于修饰协议中的属性、方法以及下标成员，表示符合类型可以不实现这些成员要求。 -只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../02_language_guide/21_Protocols.md#optional_protocol_requirements)。 +只能将 `optional` 修饰符用于被 `objc` 特性标记的协议。这样一来，就只有类类型可以采纳并符合拥有可选成员要求的协议。关于如何使用 `optional` 修饰符，以及如何访问可选协议成员（比如，不确定符合类型是否已经实现了这些可选成员）的信息，请参阅 [可选协议要求](../02_language_guide/21_Protocols.md#optional-protocol-requirements)。 `required` @@ -1752,7 +1752,7 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用， `unowned` -该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会引发运行时错误。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../02_language_guide/24_Automatic_Reference_Counting.md#unowned_references) +该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会引发运行时错误。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../02_language_guide/24_Automatic_Reference_Counting.md#unowned-references) `unowned(safe)` @@ -1760,11 +1760,11 @@ Swift 定义了大量的优先级组来与标准库的运算符配合使用， `unowned(unsafe)` -该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会直接访问该对象释放前存储的内存地址，因此这是非内存安全的操作。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 +该修饰符用于修饰存储型变量、常量或者存储型变量属性，表示该变量或属性持有其存储对象的无主引用。如果在此存储对象释放后尝试访问该对象，会直接访问该对象释放前存储的内存地址，因此这是非内存安全的操作。如同弱引用一样，该引用类型的变量或属性必须是类类型。与弱引用不同的是，这种类型的变量或属性是非可选的。关于 `unowned` 更多的信息和例子，请参阅 [无主引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving-strong-reference-cycles-between-class-instances)。 `weak` -该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving_strong_reference_cycles_between_class_instances)。 +该修饰符用于修饰变量或存储型变量属性，表示该变量或属性持有其存储的对象的弱引用。这种变量或属性的类型必须是可选的类类型。使用 `weak` 修饰符可避免强引用循环。关于 `weak` 修饰符的更多信息和例子，请参阅 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#resolving-strong-reference-cycles-between-class-instances)。 ### 访问控制级别 {#access-control-levels} Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private`。可以使用以下任意一种访问级别修饰符来指定声明的访问级别。访问控制在 [访问控制](../02_language_guide/26_Access_Control.md) 中有详细讨论。 @@ -1781,10 +1781,10 @@ Swift 提供了三个级别的访问控制：`public`、`internal` 和 `private` 该修饰符表示声明只能被所在源文件的代码访问。 -以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../02_language_guide/26_Access_Control.md#getters_and_setters) 中所讨论的。 +以上访问级别修饰符都可以选择带上一个参数，该参数由一对圆括号和其中的 `set` 关键字组成（例如，`private(set)`）。使用这种形式的访问级别修饰符来限制某个属性或下标的 setter 的访问级别低于其本身的访问级别，正如 [Getter 和 Setter](../02_language_guide/26_Access_Control.md#getters-and-setters) 中所讨论的。 -#### grammer_of_a_declaration_modifier {#grammer-of-a-declaration-modifier} +#### grammer-of-a-declaration-modifier {#grammer-of-a-declaration-modifier} > 声明修饰符的语法 > diff --git a/source/03_language_reference/07_Attributes.md b/source/03_language_reference/07_Attributes.md index 91093af8..d6918b1d 100755 --- a/source/03_language_reference/07_Attributes.md +++ b/source/03_language_reference/07_Attributes.md @@ -304,7 +304,7 @@ NSApplicationMain(CommandLine.argc, CommandLine.unsafeArgv) 如果你将 `objc` 特性应用于枚举，每一个枚举 case 都会以枚举名称和 case 名称组合的方式暴露在 Objective-C 代码中。实例名称的首字母大写。例如，在 Swift 枚举类型 `Planet` 中有一个名为 `Venus` 的 case，该 case 暴露在 Objective-C 代码中时叫做 `PlanetVenus`。 -`objc` 特性可以接受一个可选的特性参数，由标识符构成。当你想把 `objc` 所修饰的实体以一个不同的名字暴露给 Objective-C 时，你就可以使用这个特性参数。你可以使用这个参数来命名类、枚举类型、枚举 case、协议、方法、存取方法以及构造器。如果你要指定类、协议或枚举在 Objective-C 下的名称，请在名称上包含三个字母的前缀，就像 [Objective-C 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple_ref/doc/uid/TP40011210) 中的 [约定](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.html#//apple_ref/doc/uid/TP40011210-CH10-SW1)描述的一样。下面的例子把 `ExampleClass` 中的 `enabled` 属性的取值方法暴露给 Objective-C，名字是 `isEnabled`，而不是它原来的属性名。 +`objc` 特性可以接受一个可选的特性参数，由标识符构成。当你想把 `objc` 所修饰的实体以一个不同的名字暴露给 Objective-C 时，你就可以使用这个特性参数。你可以使用这个参数来命名类、枚举类型、枚举 case、协议、方法、存取方法以及构造器。如果你要指定类、协议或枚举在 Objective-C 下的名称，请在名称上包含三个字母的前缀，就像 [Objective-C 编程](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html#//apple-ref/doc/uid/TP40011210) 中的 [约定](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Conventions/Conventions.html#//apple-ref/doc/uid/TP40011210-CH10-SW1)描述的一样。下面的例子把 `ExampleClass` 中的 `enabled` 属性的取值方法暴露给 Objective-C，名字是 `isEnabled`，而不是它原来的属性名。 ```swift class ExampleClass: NSObject { @@ -387,7 +387,7 @@ s.$x // SomeProjection value s.$x.wrapper // WrapperWithProjection value ``` -### `requires_stored_property_inits` {#requires-stored-property-inits} +### `requires-stored-property-inits` {#requires-stored-property-inits} 该特性用于类声明，以要求类中所有存储属性提供默认值作为其定义的一部分。对于从中继承的任何类都推断出 `NSManagedObject` 特性。 @@ -409,7 +409,7 @@ s.$x.wrapper // WrapperWithProjection value 标记为 `inlinable` 特性的声明，在内联代码中可以隐式使用。虽然 `inlinable` 或 `usableFromInline` 可以用于 `internal` 声明，但这两者不能同时使用。 -### `warn_unqualified_access` {#warn-unqualified-access} +### `warn-unqualified-access` {#warn-unqualified-access} 该特性应用于顶级函数、实例方法、类方法或静态方法，以在没有前置限定符（例如模块名称、类型名称、实例变量或常量）的情况下使用该函数或方法时触发警告。使用该特性可以减少在同一作用域里访问的同名函数之间的歧义。 @@ -429,7 +429,7 @@ Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特 ### `autoclosure` {#autoclosure} -这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 `autoclosure` 特性的例子，请参阅 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 和 [函数类型](./03_Types.md#function_type)。 +这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以修饰类型为返回表达式结果类型的无参数函数类型的函数参数。关于如何使用 `autoclosure` 特性的例子，请参阅 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 和 [函数类型](./03-Types.md#function-type)。 ### `convention` {#convention} @@ -447,7 +447,7 @@ Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特 ### `escaping` {#escaping} -在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行。这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 特性声明的函数类型中访问属性和方法时需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../02_language_guide/07_Closures.md#escaping_closures)。 +在函数或者方法声明上使用该特性，它表示参数将不会被存储以供延迟执行。这将确保参数不会超出函数调用的生命周期。在使用 `escaping` 特性声明的函数类型中访问属性和方法时需要显式地使用 `self.`。关于如何使用 `escaping` 特性的例子，请参阅 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures)。 ## Switch Case 特性 {#switch-case-attributes} @@ -463,17 +463,17 @@ Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特 > #### attribute {#attribute} > -> *特性* → @ [特性名](#attribute_name) [特性参数子句](#atribute_argument_clause)可选 +> *特性* → @ [特性名](#attribute-name) [特性参数子句](#atribute-argument-clause)可选 > > -#### attribute_name {#attribute-name} +#### attribute-name {#attribute-name} > > *特性名* → [标识符](./02_Lexical_Structure.md#identifier) > > -#### atribute_argument_clause {#atribute-argument-clause} +#### atribute-argument-clause {#atribute-argument-clause} > -> *特性参数子句* → **(** [均衡令牌列表](#balanced_tokens)可选 **)** +> *特性参数子句* → **(** [均衡令牌列表](#balanced-tokens)可选 **)** > > #### attributes {#attributes} @@ -482,18 +482,18 @@ Interface Builder 特性是 Interface Builder 用来与 Xcode 同步的声明特 > > > -#### balanced_tokens {#balanced-tokens} +#### balanced-tokens {#balanced-tokens} > -> *均衡令牌列表* → [均衡令牌](#balanced_token) [均衡令牌列表](#balanced_tokens)可选 +> *均衡令牌列表* → [均衡令牌](#balanced-token) [均衡令牌列表](#balanced-tokens)可选 > > -#### balanced_token {#balanced-token} +#### balanced-token {#balanced-token} > -> *均衡令牌* → **(** [均衡令牌列表](#balanced_tokens)可选 **)** +> *均衡令牌* → **(** [均衡令牌列表](#balanced-tokens)可选 **)** > -> *均衡令牌* → **\[** [均衡令牌列表](#balanced_tokens)可选 **\]** +> *均衡令牌* → **\[** [均衡令牌列表](#balanced-tokens)可选 **\]** > -> *均衡令牌* → **{** [均衡令牌列表](#balanced_tokens)可选 **}** +> *均衡令牌* → **{** [均衡令牌列表](#balanced-tokens)可选 **}** > > *均衡令牌* → 任意标识符，关键字，字面量或运算符 > diff --git a/source/03_language_reference/08_Patterns.md b/source/03_language_reference/08_Patterns.md index 8a0073e5..be2e02b7 100755 --- a/source/03_language_reference/08_Patterns.md +++ b/source/03_language_reference/08_Patterns.md @@ -12,13 +12,13 @@ Swift 中的模式分为两类：一种能成功匹配任何类型的值，另 > #### pattern {#pattern} -> *模式* → [*通配符模式*](#wildcard_pattern) [*类型注解*](03_Types.md#type-annotation)可选 +> *模式* → [*通配符模式*](#wildcard-pattern) [*类型注解*](03-Types.md#type-annotation)可选 > -> *模式* → [*标识符模式*](#identifier_pattern) [*类型注解*](03_Types.md#type-annotation)可选 +> *模式* → [*标识符模式*](#identifier-pattern) [*类型注解*](03-Types.md#type-annotation)可选 > > *模式* → [*值绑定模式*](#value-binding-pattern) > -> *模式* → [*元组模式*](#tuple-pattern) [*类型注解*](03_Types.md#type-annotation)可选 +> *模式* → [*元组模式*](#tuple-pattern) [*类型注解*](03-Types.md#type-annotation)可选 > > *模式* → [*枚举用例模式*](#enum-case-pattern) > @@ -129,13 +129,13 @@ let (a): Int = 2 // a: Int = 2 ## 枚举用例模式（Enumeration Case Pattern） {#enumeration-case-pattern} *枚举用例模式*匹配现有的某个枚举类型的某个用例。枚举用例模式出现在 `switch` 语句中的 `case` 标签中，以及 `if`、`while`、`guard` 和 `for-in` 语句的 `case` 条件中。 -如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../02_language_guide/08_Enumerations.md#associated_values)。 +如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../02_language_guide/08_Enumerations.md#associated-values)。 > 枚举用例模式语法 > #### enum-case-pattern {#enum-case-pattern} -> *枚举用例模式* → [*类型标识*](./03_Types.md#type-identifier)可选 **.** [*枚举用例名*](./06_Declarations.md#enum-case-name) [*元组模式*](#tuple-pattern)可选 +> *枚举用例模式* → [*类型标识*](./03_Types.md#type-identifier)可选 **.** [*枚举用例名*](./06-Declarations.md#enum-case-name) [*元组模式*](#tuple-pattern)可选 > ## 可选模式（Optional Pattern） {#optional-pattern} @@ -188,7 +188,7 @@ for case let number? in arrayOfOptinalInts { `as` 模式仅当一个值的类型在运行时和 `as` 模式右边的指定类型一致，或者是其子类的情况下，才会匹配这个值。如果匹配成功，被匹配的值的类型被转换成 `as` 模式右边指定的类型。 -关于使用 `switch` 语句配合 `is` 模式和 `as` 模式来匹配值的例子，请参阅 [Any 和 AnyObject 的类型转换](../02_language_guide/18_Type_Casting.md#type_casting_for_any_and_anyobject)。 +关于使用 `switch` 语句配合 `is` 模式和 `as` 模式来匹配值的例子，请参阅 [Any 和 AnyObject 的类型转换](../02_language_guide/18_Type_Casting.md#type-casting-for-any-and-anyobject)。 > 类型转换模式语法 > @@ -202,7 +202,7 @@ for case let number? in arrayOfOptinalInts { > #### as-pattern {#as-pattern} -> *as 模式* → [*模式*](#pattern) **as** [*类型*](03_Types.md#type) +> *as 模式* → [*模式*](#pattern) **as** [*类型*](03-Types.md#type) > ## 表达式模式（Expression Pattern） {#expression-pattern} diff --git a/source/03_language_reference/09_Generic_Parameters_and_Arguments.md b/source/03_language_reference/09_Generic_Parameters_and_Arguments.md index f56d1f69..a210c943 100755 --- a/source/03_language_reference/09_Generic_Parameters_and_Arguments.md +++ b/source/03_language_reference/09_Generic_Parameters_and_Arguments.md @@ -51,7 +51,7 @@ simpleMax(3.14159, 2.71828) // T 被推断为 Double 类型 泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会根据这些约束来决定调用哪个重载函数或构造器。 -更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](../02_language_guide/22_Generics.md#where_clauses)。 +更多关于泛型 where 从句的信息和关于泛型函数声明的例子，可以看一看 [泛型 where 子句](../02_language_guide/22_Generics.md#where-clauses)。 > 泛型形参子句语法 > @@ -67,9 +67,9 @@ simpleMax(3.14159, 2.71828) // T 被推断为 Double 类型 #### generic-parameter {#generic-parameter} > *泛形形参* → [*类型名称*](./03_Types.md#type-name) > -> *泛形形参* → [*类型名称*](./03_Types.md#type-name) **:** [*类型标识符*](./03_Types.md#type-identifier) +> *泛形形参* → [*类型名称*](./03_Types.md#type-name) **:** [*类型标识符*](./03-Types.md#type-identifier) > -> *泛形形参* → [*类型名称*](./03_Types.md#type-name) **:** [*协议合成类型*](./03_Types.md#protocol-composition-type) +> *泛形形参* → [*类型名称*](./03_Types.md#type-name) **:** [*协议合成类型*](./03-Types.md#protocol-composition-type) > > #### requirement-clause {#requirement-clause} @@ -87,13 +87,13 @@ simpleMax(3.14159, 2.71828) // T 被推断为 Double 类型 > #### conformance-requirement {#conformance-requirement} > -> *一致性约束* → [*类型标识符*](./03_Types.md#type-identifier) **:** [*类型标识符*](./03_Types.md#type-identifier) +> *一致性约束* → [*类型标识符*](./03_Types.md#type-identifier) **:** [*类型标识符*](./03-Types.md#type-identifier) > -> *一致性约束* → [*类型标识符*](./03_Types.md#type-identifier) **:** [*协议合成类型*](./03_Types.md#protocol-composition-type) +> *一致性约束* → [*类型标识符*](./03_Types.md#type-identifier) **:** [*协议合成类型*](./03-Types.md#protocol-composition-type) > #### same-type-requirement {#same-type-requirement} -> *同类型约束* → [*类型标识符*](./03_Types.md#type-identifier) **==** [*类型*](./03_Types.md#type) +> *同类型约束* → [*类型标识符*](./03_Types.md#type-identifier) **==** [*类型*](./03-Types.md#type) > ## 泛型实参子句 {#generic-argument} @@ -118,7 +118,7 @@ struct Dictionary: CollectionType, DictionaryLiteralConver let arrayOfArrays: Array> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] ``` -如 [泛型形参子句](#generic_parameter) 所述，不能用泛型实参子句来指定泛型函数或构造器的类型实参。 +如 [泛型形参子句](#generic-parameter) 所述，不能用泛型实参子句来指定泛型函数或构造器的类型实参。 > 泛型实参子句语法 > 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 3573f123..76b4f652 100755 --- a/source/03_language_reference/10_Summary_of_the_Grammar.md +++ b/source/03_language_reference/10_Summary_of_the_Grammar.md @@ -4,7 +4,7 @@ > 空白字符语法 > -> *空白字符* → [空白字符项](./02_Lexical_Structure.md#whitespace-item) [空白字符](./02_Lexical_Structure.md#whitespace)可选 +> *空白字符* → [空白字符项](./02_Lexical_Structure.md#whitespace-item) [空白字符](./02-Lexical-Structure.md#whitespace)可选 > > *空白字符项* → [换行符](./02_Lexical_Structure.md#line-break) > @@ -22,19 +22,19 @@ > > *换行符* → U+000D 后面是 U+000A > -> *注释* → **//** [单行内容注释](./02_Lexical_Structure.md#comment-text) [换行符](./02_Lexical_Structure.md#line-break) +> *注释* → **//** [单行内容注释](./02_Lexical_Structure.md#comment-text) [换行符](./02-Lexical-Structure.md#line-break) > > *注释* → **/\*** [多行内容注释](./02_Lexical_Structure.md#multiline-comment-text) **\*/** > > > -> *注释内容* → [注释内容项](./02_Lexical_Structure.md#comment-text-item) [注释内容](./02_Lexical_Structure.md#comment-text)可选 +> *注释内容* → [注释内容项](./02_Lexical_Structure.md#comment-text-item) [注释内容](./02-Lexical-Structure.md#comment-text)可选 > > *注释内容项* → 除 U+000A 或 U+000D 外的任何 Unicode 标量值 > > > -> *多行注释内容* → [多行注释内容项](./02_Lexical_Structure.md#multiline-comment-text-item) [多行注释内容](./02_Lexical_Structure.md#multiline-comment-text)可选 +> *多行注释内容* → [多行注释内容项](./02_Lexical_Structure.md#multiline-comment-text-item) [多行注释内容](./02-Lexical-Structure.md#multiline-comment-text)可选 > > *多行注释内容项* → [多行内容](./02_Lexical_Structure.md#multiline-comment) > @@ -47,13 +47,13 @@ > 标识符语法 > -> *标识符* → [标识符头（Head）](./02_Lexical_Structure.md#identifier_head) [标识符字符集](./02_Lexical_Structure.md#identifier_characters)可选 +> *标识符* → [标识符头（Head）](./02_Lexical_Structure.md#identifier-head) [标识符字符集](./02-Lexical-Structure.md#identifier-characters)可选 > -> *标识符* → [标识符头（Head）](./02_Lexical_Structure.md#identifier_head) [标识符字符集](./02_Lexical_Structure.md#identifier_characters)可选 +> *标识符* → [标识符头（Head）](./02_Lexical_Structure.md#identifier-head) [标识符字符集](./02-Lexical-Structure.md#identifier-characters)可选 > -> *标识符* → [隐式参数名](./02_Lexical_Structure.md#implicit_parameter_name) +> *标识符* → [隐式参数名](./02_Lexical_Structure.md#implicit-parameter-name) > -> *标识符集* → [标识符](./02_Lexical_Structure.md#identifier) | [标识符](./02_Lexical_Structure.md#identifier) **,** [标识符集](./02_Lexical_Structure.md#identifier_list) +> *标识符集* → [标识符](./02_Lexical_Structure.md#identifier) | [标识符](./02-Lexical-Structure.md#identifier) **,** [标识符集](./02-Lexical-Structure.md#identifier-list) > > *标识符头（Head）* → 大写或者小写字母 A 到 Z > @@ -91,20 +91,20 @@ > > *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F > -> *标识符字符* → [标识符头（Head）](./02_Lexical_Structure.md#identifier_head) +> *标识符字符* → [标识符头（Head）](./02_Lexical_Structure.md#identifier-head) > -> *标识符字符集* → [标识符字符](./02_Lexical_Structure.md#identifier_character) [标识符字符集](./02_Lexical_Structure.md#identifier_characters)可选 +> *标识符字符集* → [标识符字符](./02_Lexical_Structure.md#identifier-character) [标识符字符集](./02-Lexical-Structure.md#identifier-characters)可选 > -> *隐式参数名* → **$** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) +> *隐式参数名* → **$** [十进制数字集](./02_Lexical_Structure.md#decimal-digits) > > 字面量语法 > -> *字面量* → [数值型字面量](./02_Lexical_Structure.md#numeric-literal) | [字符串字面量](./02_Lexical_Structure.md#string-literal) | [布尔字面量](./02_Lexical_Structure.md#boolean-literal) | [空字面量](./02_Lexical_Structure.md#nil-literal) +> *字面量* → [数值型字面量](./02_Lexical_Structure.md#numeric-literal) | [字符串字面量](./02-Lexical-Structure.md#string-literal) | [布尔字面量](./02-Lexical-Structure.md#boolean-literal) | [空字面量](./02-Lexical-Structure.md#nil-literal) > -> *数值型字面量* → **-**可选[整形字面量](./02_Lexical_Structure.md#integer_literal) | **-**可选[浮点型字面量](./02_Lexical_Structure.md#floating-point-literal) +> *数值型字面量* → **-**可选[整形字面量](./02_Lexical_Structure.md#integer-literal) | **-**可选[浮点型字面量](./02-Lexical-Structure.md#floating-point-literal) > > *布尔字面量* → **true** | **false** > @@ -115,64 +115,64 @@ > 整型字面量语法 > -> *整型字面量* → [二进制字面量](./02_Lexical_Structure.md#binary_literal) +> *整型字面量* → [二进制字面量](./02_Lexical_Structure.md#binary-literal) > -> *整型字面量* → [八进制字面量](./02_Lexical_Structure.md#octal_literal) +> *整型字面量* → [八进制字面量](./02_Lexical_Structure.md#octal-literal) > -> *整型字面量* → [十进制字面量](./02_Lexical_Structure.md#decimal_literal) +> *整型字面量* → [十进制字面量](./02_Lexical_Structure.md#decimal-literal) > -> *整型字面量* → [十六进制字面量](./02_Lexical_Structure.md#hexadecimal_literal) +> *整型字面量* → [十六进制字面量](./02_Lexical_Structure.md#hexadecimal-literal) > -> *二进制字面量* → **0b** [二进制数字](./02_Lexical_Structure.md#binary_digit) [二进制字面量字符集](./02_Lexical_Structure.md#binary_literal_characters)可选 +> *二进制字面量* → **0b** [二进制数字](./02_Lexical_Structure.md#binary-digit) [二进制字面量字符集](./02-Lexical-Structure.md#binary-literal-characters)可选 > > *二进制数字* → 数值 0 到 1 > -> *二进制字面量字符* → [二进制数字](./02_Lexical_Structure.md#binary_digit) | **_** +> *二进制字面量字符* → [二进制数字](./02_Lexical_Structure.md#binary-digit) | **-** > -> *二进制字面量字符集* → [二进制字面量字符](./02_Lexical_Structure.md#binary_literal_character) [二进制字面量字符集](./02_Lexical_Structure.md#binary_literal_characters)可选 +> *二进制字面量字符集* → [二进制字面量字符](./02_Lexical_Structure.md#binary-literal-character) [二进制字面量字符集](./02-Lexical-Structure.md#binary-literal-characters)可选 > -> *八进制字面量* → **0o** [八进制数字](./02_Lexical_Structure.md#octal_digit) [八进制字符集](./02_Lexical_Structure.md#octal_literal_characters)可选 +> *八进制字面量* → **0o** [八进制数字](./02_Lexical_Structure.md#octal-digit) [八进制字符集](./02-Lexical-Structure.md#octal-literal-characters)可选 > > *八进字数字* → 数值 0 到 7 > -> *八进制字符* → [八进制数字](./02_Lexical_Structure.md#octal_digit) | **_** +> *八进制字符* → [八进制数字](./02_Lexical_Structure.md#octal-digit) | **-** > -> *八进制字符集* → [八进制字符](./02_Lexical_Structure.md#octal_literal_character) [八进制字符集](./02_Lexical_Structure.md#octal_literal_characters)可选 +> *八进制字符集* → [八进制字符](./02_Lexical_Structure.md#octal-literal-character) [八进制字符集](./02-Lexical-Structure.md#octal-literal-characters)可选 > -> *十进制字面量* → [十进制数字](./02_Lexical_Structure.md#decimal_digit) [十进制字符集](./02_Lexical_Structure.md#decimal_literal_characters)可选 +> *十进制字面量* → [十进制数字](./02_Lexical_Structure.md#decimal-digit) [十进制字符集](./02-Lexical-Structure.md#decimal-literal-characters)可选 > > *十进制数字* → 数值 0 到 9 > -> *十进制数字集* → [十进制数字](./02_Lexical_Structure.md#decimal_digit) [十进制数字集](./02_Lexical_Structure.md#decimal_digits)可选 +> *十进制数字集* → [十进制数字](./02_Lexical_Structure.md#decimal-digit) [十进制数字集](./02-Lexical-Structure.md#decimal-digits)可选 > -> *十进制字面量字符* → [十进制数字](./02_Lexical_Structure.md#decimal_digit) | **_** +> *十进制字面量字符* → [十进制数字](./02_Lexical_Structure.md#decimal-digit) | **-** > -> *十进制字面量字符集* → [十进制字面量字符](./02_Lexical_Structure.md#decimal_literal_character) [十进制字面量字符集](./02_Lexical_Structure.md#decimal_literal_characters)可选 +> *十进制字面量字符集* → [十进制字面量字符](./02_Lexical_Structure.md#decimal-literal-character) [十进制字面量字符集](./02-Lexical-Structure.md#decimal-literal-characters)可选 > -> *十六进制字面量* → **0x** [十六进制数字](./02_Lexical_Structure.md#hexadecimal_digit) [十六进制字面量字符集](./02_Lexical_Structure.md#hexadecimal_literal_characters)可选 +> *十六进制字面量* → **0x** [十六进制数字](./02_Lexical_Structure.md#hexadecimal-digit) [十六进制字面量字符集](./02-Lexical-Structure.md#hexadecimal-literal-characters)可选 > > *十六进制数字* → 数值 0 到 9，a 到 f，或者 A 到 F > -> *十六进制字符* → [十六进制数字](./02_Lexical_Structure.md#hexadecimal_digit) | **_** +> *十六进制字符* → [十六进制数字](./02_Lexical_Structure.md#hexadecimal-digit) | **-** > -> *十六进制字面量字符集* → [十六进制字符](./02_Lexical_Structure.md#hexadecimal_literal_character) [十六进制字面量字符集](./02_Lexical_Structure.md#hexadecimal_literal_characters)可选 +> *十六进制字面量字符集* → [十六进制字符](./02_Lexical_Structure.md#hexadecimal-literal-character) [十六进制字面量字符集](./02-Lexical-Structure.md#hexadecimal-literal-characters)可选 > > 浮点型字面量语法 > -> *浮点数字面量* → [十进制字面量](./02_Lexical_Structure.md#decimal_literal) [十进制分数](./02_Lexical_Structure.md#decimal_fraction)可选[十进制指数](./02_Lexical_Structure.md#decimal_exponent)可选 +> *浮点数字面量* → [十进制字面量](./02_Lexical_Structure.md#decimal-literal) [十进制分数](./02-Lexical-Structure.md#decimal-fraction)可选[十进制指数](./02-Lexical-Structure.md#decimal-exponent)可选 > -> *浮点数字面量* → [十六进制字面量](./02_Lexical_Structure.md#hexadecimal_literal) [十六进制分数](./02_Lexical_Structure.md#hexadecimal_fraction)可选[十六进制指数](./02_Lexical_Structure.md#hexadecimal_exponent) +> *浮点数字面量* → [十六进制字面量](./02_Lexical_Structure.md#hexadecimal-literal) [十六进制分数](./02-Lexical-Structure.md#hexadecimal-fraction)可选[十六进制指数](./02-Lexical-Structure.md#hexadecimal-exponent) > -> *十进制分数* → **.** [十进制字面量](./02_Lexical_Structure.md#decimal_literal) +> *十进制分数* → **.** [十进制字面量](./02_Lexical_Structure.md#decimal-literal) > -> *十进制指数* → [浮点数 e](./02_Lexical_Structure.md#floating_point_e) [正负号](./02_Lexical_Structure.md#sign)可选[十进制字面量](./02_Lexical_Structure.md#decimal_literal) +> *十进制指数* → [浮点数 e](./02_Lexical_Structure.md#floating-point-e) [正负号](./02-Lexical-Structure.md#sign)可选[十进制字面量](./02-Lexical-Structure.md#decimal-literal) > -> *十六进制分数* → **.** [十六进制数](./02_Lexical_Structure.md#hexadecimal_literal) +> *十六进制分数* → **.** [十六进制数](./02_Lexical_Structure.md#hexadecimal-literal) > -> *十六进制指数* → [浮点数 p](./02_Lexical_Structure.md#floating_point_p) [正负号](./02_Lexical_Structure.md#sign)可选[十六进制字面量](./02_Lexical_Structure.md#hexadecimal_literal) +> *十六进制指数* → [浮点数 p](./02_Lexical_Structure.md#floating-point-p) [正负号](./02-Lexical-Structure.md#sign)可选[十六进制字面量](./02-Lexical-Structure.md#hexadecimal-literal) > > *浮点数 e* → **e** | **E** > @@ -185,21 +185,21 @@ > 字符串型字面量语法 -> *字符串字面量* → [静态字符串字面量](./02_Lexical_Structure.md#static-string-literal) | [插值字符串字面量](./02_Lexical_Structure.md#interpolated-string-literal) +> *字符串字面量* → [静态字符串字面量](./02_Lexical_Structure.md#static-string-literal) | [插值字符串字面量](./02-Lexical-Structure.md#interpolated-string-literal) > > *字符串开分隔定界符* → [字符串扩展分隔符](./02_Lexical_Structure.md#extended-string-literal-delimiter) **"** > > *字符串闭分隔定界符* → **"** [字符串扩展分隔符](./02_Lexical_Structure.md#extended-string-literal-delimiter)可选 > -> *静态字符串字面量* → [字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [引用文本](./02_Lexical_Structure.md#quoted-text)可选 [字符串闭分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) +> *静态字符串字面量* → [字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [引用文本](./02-Lexical-Structure.md#quoted-text)可选 [字符串闭分隔定界符](./02-Lexical-Structure.md#extended-string-literal-delimiter) > -> *静态字符串字面量* → [多行字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [多行引用文本](./02_Lexical_Structure.md#multiline-quoted-text)可选 [多行字符串闭分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) +> *静态字符串字面量* → [多行字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [多行引用文本](./02-Lexical-Structure.md#multiline-quoted-text)可选 [多行字符串闭分隔定界符](./02-Lexical-Structure.md#extended-string-literal-delimiter) > > *多行字符串开分隔定界符* → [字符串扩展分隔符](./02_Lexical_Structure.md#extended-string-literal-delimiter) **"""** > > *多行字符串闭分隔定界符* → **"""** [字符串扩展分隔符](./02_Lexical_Structure.md#extended-string-literal-delimiter) > -> *字符串扩展分隔符* → **#** [字符串扩展分隔符](./02_Lexical_Structure.md#extended-string-literal-delimiter)可选 +> *字符串扩展分隔符* → **#** [字符串扩展分隔符](./02-Lexical-Structure.md#extended-string-literal-delimiter)可选 > > *引用文本* → [引用文本项](./02_Lexical_Structure.md#quoted-text-item) [引用文本](#quoted-text)可选 > @@ -207,7 +207,7 @@ > > *引用文本项* → 除了 **"**、**\\\**、U+000A、U+000D 以外的所有 Unicode 字符 > -> *多行引用文本* → [多行引用文本项](./02_Lexical_Structure.md#multiline-quoted-text-item) [多行引用文本](./02_Lexical_Structure.md#multiline-quoted-text)可选 +> *多行引用文本* → [多行引用文本项](./02_Lexical_Structure.md#multiline-quoted-text-item) [多行引用文本](./02-Lexical-Structure.md#multiline-quoted-text)可选 > > *多行引用文本项* [转义字符](./02_Lexical_Structure.md#escaped-character)可选 > @@ -215,36 +215,36 @@ > > *多行引用文本* → [转义换行](./02_Lexical_Structure.md#escaped-newline) -> *插值字符串字面量* → [字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [插值文本](./02_Lexical_Structure.md#interpolated-text)可选 [字符串闭分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) +> *插值字符串字面量* → [字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [插值文本](./02-Lexical-Structure.md#interpolated-text)可选 [字符串闭分隔定界符](./02-Lexical-Structure.md#extended-string-literal-delimiter) > -> *插值字符串字面量* → [多行字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [插值文本](./02_Lexical_Structure.md#interpolated-text)可选 [多行字符串闭分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) +> *插值字符串字面量* → [多行字符串开分隔定界符](./02_Lexical_Structure.md#extended-string-literal-delimiter) [插值文本](./02-Lexical-Structure.md#interpolated-text)可选 [多行字符串闭分隔定界符](./02-Lexical-Structure.md#extended-string-literal-delimiter) > -> *插值文本* → [插值文本项](./02_Lexical_Structure.md#interpolated-text-item) [插值文本](./02_Lexical_Structure.md#interpolated-text)可选 +> *插值文本* → [插值文本项](./02_Lexical_Structure.md#interpolated-text-item) [插值文本](./02-Lexical-Structure.md#interpolated-text)可选 > > *插值文本项* → **\\**(**[表达式](./04_Expressions.md)**) | [引用文本项](./02_Lexical_Structure.md#quoted-text-item) > -> *多行插值文本* → [多行插值文本项](./02_Lexical_Structure.md#multiline-quoted-text-item) [多行插值文本](./02_Lexical_Structure.md#multiline-quoted-text)可选 +> *多行插值文本* → [多行插值文本项](./02_Lexical_Structure.md#multiline-quoted-text-item) [多行插值文本](./02-Lexical-Structure.md#multiline-quoted-text)可选 > > *多行插值文本项* → **\\(** [表达式](./04_Expressions.md) **)** | [多行引用文本项](./02_Lexical_Structure.md#multiline-quoted-text-item) > > *转义序列* → **\\** [字符串扩展分隔符](./02_Lexical_Structure.md#extended-string-literal-delimiter) > -> *转义字符* → [转义序列](./02_Lexical_Structure.md#escape-sequence) **0** | [转义序列](./02_Lexical_Structure.md#escape-sequence) **\\** | [转义序列](./02_Lexical_Structure.md#escape-sequence) **t** | [转义序列](#escape-sequence) **n** | [转义序列](./02_Lexical_Structure.md#escape-sequence) **r** | [转义序列](./02_Lexical_Structure.md#escape-sequence) **\"** | [转义序列](./02_Lexical_Structure.md#escape-sequence) **'** +> *转义字符* → [转义序列](./02_Lexical_Structure.md#escape-sequence) **0** | [转义序列](./02-Lexical-Structure.md#escape-sequence) **\\** | [转义序列](./02-Lexical-Structure.md#escape-sequence) **t** | [转义序列](#escape-sequence) **n** | [转义序列](./02-Lexical-Structure.md#escape-sequence) **r** | [转义序列](./02-Lexical-Structure.md#escape-sequence) **\"** | [转义序列](./02-Lexical-Structure.md#escape-sequence) **'** > -> *转义字符* → [转义序列](./02_Lexical_Structure.md#escape-sequence) **u {** [unicode 标量数字](./02_Lexical_Structure.md#unicode-scalar-digits) **}** +> *转义字符* → [转义序列](./02_Lexical_Structure.md#escape-sequence) **u {** [unicode 标量数字](./02-Lexical-Structure.md#unicode-scalar-digits) **}** > > *unicode 标量数字* → 一到八位的十六进制数字 > -> *转义换行符* → [转义序列](./02_Lexical_Structure.md#escape-sequence) [空白](./02_Lexical_Structure.md#whitespace)可选 [换行符](./02_Lexical_Structure.md#line-break) +> *转义换行符* → [转义序列](./02_Lexical_Structure.md#escape-sequence) [空白](./02-Lexical-Structure.md#whitespace)可选 [换行符](./02-Lexical-Structure.md#line-break) > 运算符语法语法 > -> *运算符* → [运算符头](./02_Lexical_Structure.md#operator_character) [运算符字符集](./02_Lexical_Structure.md#operator)可选 +> *运算符* → [运算符头](./02_Lexical_Structure.md#operator-character) [运算符字符集](./02-Lexical-Structure.md#operator)可选 > -> *运算符* → [点运算符头](./02_Lexical_Structure.md#dot-operator-head) [点运算符字符集](./02_Lexical_Structure.md#dot-operator-characters)可选 +> *运算符* → [点运算符头](./02_Lexical_Structure.md#dot-operator-head) [点运算符字符集](./02-Lexical-Structure.md#dot-operator-characters)可选 > > *运算符字符* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **?** > @@ -290,13 +290,13 @@ > > *运算符字符* → U+E0100–U+E01EF > -> *运算符字符集* → [运算符字符](./02_Lexical_Structure.md#operator-character) [运算符字符集](./02_Lexical_Structure.md#operator-characters)可选 +> *运算符字符集* → [运算符字符](./02_Lexical_Structure.md#operator-character) [运算符字符集](./02-Lexical-Structure.md#operator-characters)可选 > > *点运算符头* → **..** > > *点运算符字符* → **.** | [运算符字符](./02_Lexical_Structure.md#operator-character) > -> *点运算符字符集* → [点运算符字符](./02_Lexical_Structure.md#dot-operator-character) [点运算符字符集](./02_Lexical_Structure.md#dot-operator-characters)可选 +> *点运算符字符集* → [点运算符字符](./02_Lexical_Structure.md#dot-operator-character) [点运算符字符集](./02-Lexical-Structure.md#dot-operator-characters)可选 > > *二元运算符* → [运算符](./02_Lexical_Structure.md#operator) > @@ -309,39 +309,39 @@ > 类型语法 > -> *类型* → [数组类型](./03_Types.md#array_type) +> *类型* → [数组类型](./03_Types.md#array-type) > > *类型* → [字典类型](./03_Types.md#dictionary-type) > -> *类型* → [函数类型](./03_Types.md#function_type) +> *类型* → [函数类型](./03_Types.md#function-type) > -> *类型* → [类型标识符](./03_Types.md#type_identifier) +> *类型* → [类型标识符](./03_Types.md#type-identifier) > -> *类型* → [元组类型](./03_Types.md./03_Types.md#tuple_type) +> *类型* → [元组类型](./03_Types.md./03_Types.md#tuple-type) > -> *类型* → [可选类型](./03_Types.md#optional_type) +> *类型* → [可选类型](./03_Types.md#optional-type) > -> *类型* → [隐式解析可选类型](./03_Types.md#implicitly_unwrapped_optional_type) +> *类型* → [隐式解析可选类型](./03_Types.md#implicitly-unwrapped-optional-type) > -> *类型* → [协议合成类型](./03_Types.md#protocol_composition_type) +> *类型* → [协议合成类型](./03_Types.md#protocol-composition-type) > > *类型* → **Any** > > *类型* → **Self** > -> *类型* → **（** [type](./03_Types.md#metatype_type) **）** +> *类型* → **（** [type](./03_Types.md#metatype-type) **）** > 类型注解语法 > -> *类型注解* → **:** [属性（Attributes）集](./07_Attributes.md#attributes)可选[类型](./03_Types.md#type) +> *类型注解* → **:** [属性（Attributes）集](./07_Attributes.md#attributes)可选[类型](./03-Types.md#type) > 类型标识语法 > -> *类型标识* → [类型名称](./03_Types.md#type_name) [泛型参数从句](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause)可选| [类型名称](./03_Types.md#type_name) [泛型参数从句](./09_Generic_Parameters_and_Arguments.md#generic_argument_clause)可选**.** [类型标识符](./03_Types.md#type_identifier) +> *类型标识* → [类型名称](./03_Types.md#type-name) [泛型参数从句](./09-Generic-Parameters-and-Arguments.md#generic-argument-clause)可选| [类型名称](./03-Types.md#type-name) [泛型参数从句](./09-Generic-Parameters-and-Arguments.md#generic-argument-clause)可选**.** [类型标识符](./03-Types.md#type-identifier) > > *类型名* → [标识符](./02_Lexical_Structure.md#identifier) > @@ -350,11 +350,11 @@ > 元组类型语法 > -> *元组类型* → **(** **)** | **(** [元组类型元素](./03_Types.md#tuple-type-element) **,** [元组类型元素列表](./03_Types.md#tuple-type-element-list) **)** +> *元组类型* → **(** **)** | **(** [元组类型元素](./03_Types.md#tuple-type-element) **,** [元组类型元素列表](./03-Types.md#tuple-type-element-list) **)** > -> *元组类型元素列表* → [元组类型元素](./03_Types.md#tuple-type-element) | [元组类型元素](./03_Types.md#tuple-type-element) **,** [元组类型元素列表](./03_Types.md#tuple-type-element-list) +> *元组类型元素列表* → [元组类型元素](./03_Types.md#tuple-type-element) | [元组类型元素](./03-Types.md#tuple-type-element) **,** [元组类型元素列表](./03-Types.md#tuple-type-element-list) > -> *元组类型元素* → [元素名](./03_Types.md#element-name) [类型注解](./03_Types.md#type-annotation) | [类型](./03_Types.md#type) +> *元组类型元素* → [元素名](./03_Types.md#element-name) [类型注解](./03-Types.md#type-annotation) | [类型](./03-Types.md#type) > > *元素名* → [标识符](./02_Lexical_Structure.md#identifier) @@ -362,15 +362,15 @@ > 函数类型语法 > -> *函数类型* → [类型](./03_Types.md#type) **throws**可选**->** [类型](./03_Types.md#type) +> *函数类型* → [类型](./03_Types.md#type) **throws**可选**->** [类型](./03-Types.md#type) > -> *函数类型* → [类型](./03_Types.md#) **rethrows** **->** [类型](./03_Types.md#) +> *函数类型* → [类型](./03_Types.md#) **rethrows** **->** [类型](./03-Types.md#) > > *函数类型子句* → **(** **)** > > *函数类型子句* → **(** [函数类型参数列表](./03_Types.md#function-type-argument-list) *...*­可选 **)** > -> *函数类型参数列表* → [函数类型参数](./03_Types.md#function-type-argument) | [函数类型参数](function-type-argument)， [函数类型参数列表](./03_Types.md#function-type-argument-list) +> *函数类型参数列表* → [函数类型参数](./03_Types.md#function-type-argument) | [函数类型参数](function-type-argument)， [函数类型参数列表](./03-Types.md#function-type-argument-list) > > *函数类型参数* → [特性列表](./07_Attributes.md#attributes)可选 **输入输出参数**可选 [类型](#type) | [参数标签](#argument-label) [类型注解](#type-annotation) > @@ -380,7 +380,7 @@ > 数组类型语法 > -> *数组类型* → **[** [*类型*](./03_Types.md#array_type) **]** +> *数组类型* → **[** [*类型*](./03_Types.md#array-type) **]** > 字典类型语法 @@ -405,23 +405,23 @@ > 协议合成类型语法 > -> *协议合成类型* → [类型标识符](./03_Types.md#type_identifier) | [协议合成延续](./03_Types.md#protocol-composition-continuation) +> *协议合成类型* → [类型标识符](./03_Types.md#type-identifier) | [协议合成延续](./03-Types.md#protocol-composition-continuation) > -> *协议持续延续* → [类型标识符](./03_Types.md#type_identifier) | [协议合成类型](./03_Types.md#protocol-composition-type) +> *协议持续延续* → [类型标识符](./03_Types.md#type-identifier) | [协议合成类型](./03-Types.md#protocol-composition-type) > 元（Metatype）类型语法 > -> *元类型* → [类型](./03_Types.md#type) **.** **Type** | [类型](./03_Types.md#type) **.** **Protocol** +> *元类型* → [类型](./03_Types.md#type) **.** **Type** | [类型](./03-Types.md#type) **.** **Protocol** > 类型继承从句语法 > -> *类型继承从句* → **:** [类型继承集](./03_Types.md#type_inheritance_list) +> *类型继承从句* → **:** [类型继承集](./03_Types.md#type-inheritance-list) > -> *类型继承集* → [类型标识符](./03_Types.md#type_identifier) | [类型标识符](./03_Types.md#type_identifier) **,** [类型继承集](./03_Types.md#type_inheritance_list) +> *类型继承集* → [类型标识符](./03_Types.md#type-identifier) | [类型标识符](./03-Types.md#type-identifier) **,** [类型继承集](./03-Types.md#type-inheritance-list) > > *类条件* → **class** @@ -429,9 +429,9 @@ > 表达式语法 > -> *表达式* → [try 运算符](./04_Expressions.md#try-operator)可选 [前缀表达式](./04_Expressions.md#prefix-expression) [二元表达式列表](./04_Expressions.md#binary-expressions) +> *表达式* → [try 运算符](./04_Expressions.md#try-operator)可选 [前缀表达式](./04-Expressions.md#prefix-expression) [二元表达式列表](./04-Expressions.md#binary-expressions) > -> *表达式列表* → [表达式](./04_Expressions.md#expression)|[表达式](./04_Expressions.md#expression), [表达式列表](./04_Expressions.md#expression-list) +> *表达式列表* → [表达式](./04_Expressions.md#expression)|[表达式](./04-Expressions.md#expression), [表达式列表](./04-Expressions.md#expression-list) > @@ -456,15 +456,15 @@ > 二元表达式语法 > -> *二元表达式* → [二元运算符](./02_Lexical_Structure.md#binary-operator) [前缀表达式](./04_Expressions.md#prefix-expression) +> *二元表达式* → [二元运算符](./02_Lexical_Structure.md#binary-operator) [前缀表达式](./04-Expressions.md#prefix-expression) > -> *二元表达式* → [赋值操作符](./06_Declarations.md#class_declaration) [try 运算符](./04_Expressions.md#try_operator)可选 [前缀表达式](./04_Expressions.md#prefix-expression) +> *二元表达式* → [赋值操作符](./06_Declarations.md#class-declaration) [try 运算符](./04-Expressions.md#try-operator)可选 [前缀表达式](./04-Expressions.md#prefix-expression) > -> *二元表达式* → [条件运算符](./04_Expressions.md#conditional-operator) [try 运算符](./04_Expressions.md#try_operator)可选 [前缀表达式](./04_Expressions.md#prefix-expression) +> *二元表达式* → [条件运算符](./04_Expressions.md#conditional-operator) [try 运算符](./04-Expressions.md#try-operator)可选 [前缀表达式](./04-Expressions.md#prefix-expression) > > *二元表达式* → [类型转换运算符](./04_Expressions.md#type-casting-operator) > -> *二元表达式* → [二元表达式](./04_Expressions.md#binary-expression) [二元表达式列表](./04_Expressions.md#binary-expressions)可选 +> *二元表达式* → [二元表达式](./04_Expressions.md#binary-expression) [二元表达式列表](./04-Expressions.md#binary-expressions)可选 > @@ -496,7 +496,7 @@ > 基础表达式语法 > -> *基础表达式* → [标识符](./02_Lexical_Structure.md#identifier) [泛型实参子句](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选 +> *基础表达式* → [标识符](./02_Lexical_Structure.md#identifier) [泛型实参子句](./09-Generic-Parameters-and-Arguments.md#generic-argument-clause)可选 > > *基础表达式* → [字面量表达式](./04_Expressions.md#literal-expression) > @@ -508,13 +508,13 @@ > > *基础表达式* → [圆括号表达式](./04_Expressions.md#parenthesized-expression) > -> *基础表达式* → [元组表达式](./04_Expressions.md#Tuple_Expression) +> *基础表达式* → [元组表达式](./04_Expressions.md#Tuple-Expression) > > *基础表达式* → [隐式成员表达式](./04_Expressions.md#implicit-member-expression) > > *基础表达式* → [通配符表达式](./04_Expressions.md#wildcard-expression) > -> *基础表达式* → [key-path表达式](./04_Expressions.md#key-path_expression) +> *基础表达式* → [key-path表达式](./04_Expressions.md#key-path-expression) > > *基础表达式* → [选择器表达式](./04_Expressions.md#selector-expression) > @@ -527,25 +527,25 @@ > > *字面量表达式* → [字面量](./04_Expressions.md#literal-expression) > -> *字面量表达式* → [数组字面量](./04_Expressions.md#array-literal) | [字典字面量](./04_Expressions.md#dictionary-literal) | [练习场字面量](./04_Expressions.md#playground-literal) +> *字面量表达式* → [数组字面量](./04_Expressions.md#array-literal) | [字典字面量](./04-Expressions.md#dictionary-literal) | [练习场字面量](./04-Expressions.md#playground-literal) > > *字面量表达式* → **#file** | **#line** | **#column** | **#function** | **dsohandle** > > > *数组字面量* → **[** [数组字面量项列表](./04_Expressions.md#array-literal-items)可选 **]** -> *数组字面量项列表* → [数组字面量项](./04_Expressions.md#array-literal-item)可选 | [数组字面量项](./04_Expressions.md#array-literal-item),[数组字面量项列表](./04_Expressions.md#array-literal-items) +> *数组字面量项列表* → [数组字面量项](./04_Expressions.md#array-literal-item)可选 | [数组字面量项](./04-Expressions.md#array-literal-item),[数组字面量项列表](./04-Expressions.md#array-literal-items) > *数组字面量项* → [表达式](./04_Expressions.md#expression) > > > *字典字面量* → [[字典字面量项列表](./04_Expressions.md#dictionary-literal-items) **]** | **[** **:** **]** > > -> *字典字面量项列表* → [字典字面量项](./04_Expressions.md#dictionary-literal-item) ,**可选 | [字典字面量项](./04_Expressions.md#dictionary-literal-item) ,[字典字面量项列表](./04_Expressions.md#dictionary-literal-items) +> *字典字面量项列表* → [字典字面量项](./04_Expressions.md#dictionary-literal-item) ,**可选 | [字典字面量项](./04-Expressions.md#dictionary-literal-item) ,[字典字面量项列表](./04-Expressions.md#dictionary-literal-items) > -> *字典字面量项* → [表达式](./04_Expressions.md#expression) **:** [表达式](./04_Expressions.md#expression) +> *字典字面量项* → [表达式](./04_Expressions.md#expression) **:** [表达式](./04-Expressions.md#expression) > > -> *palyground 字面量* → **#colorLiteral ( red : [表达式](./04_Expressions.md#expression) , green :[表达式](./04_Expressions.md#expression), blue :[表达式](./04_Expressions.md#expression) , alpha : [表达式](./04_Expressions.md#expression) )** +> *palyground 字面量* → **#colorLiteral ( red : [表达式](./04-Expressions.md#expression) , green :[表达式](./04-Expressions.md#expression), blue :[表达式](./04-Expressions.md#expression) , alpha : [表达式](./04-Expressions.md#expression) )** > > *playground 字面量* → **#fileLiteral ( resourceName : [表达式](#expression) )** > @@ -554,7 +554,7 @@ > self 表达式语法 > -> *self 表达式* → **self** | [self 方法表达式](./04_Expressions.md#self-method-expression) ｜ [self 下标表达式](./04_Expressions.md#self-subscript-expression) | [self 构造器表达式](./04_Expressions.md#self-initializer-expression) +> *self 表达式* → **self** | [self 方法表达式](./04_Expressions.md#self-method-expression) ｜ [self 下标表达式](./04-Expressions.md#self-subscript-expression) | [self 构造器表达式](./04-Expressions.md#self-initializer-expression) > > > *self 方法表达式* → **self** **.** [标识符](./02_Lexical_Structure.md#identifier) @@ -567,7 +567,7 @@ > 父类表达式语法 > -> *父类表达式* → [父类方法表达式](./04_Expressions.md#superclass-method-expression) | [父类下标表达式](./04_Expressions.md#superclass-subscript-expression) | [父类构造器表达式](./04_Expressions.md#superclass-initializer-expression) +> *父类表达式* → [父类方法表达式](./04_Expressions.md#superclass-method-expression) | [父类下标表达式](./04-Expressions.md#superclass-subscript-expression) | [父类构造器表达式](./04-Expressions.md#superclass-initializer-expression) > > *父类方法表达式* → **super** **.** [标识符](./02_Lexical_Structure.md#identifier) > @@ -581,30 +581,30 @@ > 闭包表达式语法 > -> *闭包表达式* → **{** [闭包签名](./04_Expressions.md#closure-signature)可选 [语句](./04_Expressions.md#statements) **}** +> *闭包表达式* → **{** [闭包签名](./04_Expressions.md#closure-signature)可选 [语句](./04-Expressions.md#statements) **}** > > -> 闭包签名* → [参数子句](./04_Expressions.md#parameter-clause) [函数结果](05_Declarations.md#function-result)可选 **in** +> 闭包签名* → [参数子句](./04_Expressions.md#parameter-clause) [函数结果](05-Declarations.md#function-result)可选 **in** > -> *闭包签名* → [标识符列表](./04_Expressions.md#identifier-list) [函数结果](05_Declarations.md#function-result)可选 **in** +> *闭包签名* → [标识符列表](./04_Expressions.md#identifier-list) [函数结果](05-Declarations.md#function-result)可选 **in** > > -> *闭包参数子句* **(** **)** | **(** [闭包参数列表](./04_Expressions.md#closure-parameter-list) | [标识符列表](./04_Expressions.md#identifier-list) **)** +> *闭包参数子句* **(** **)** | **(** [闭包参数列表](./04_Expressions.md#closure-parameter-list) | [标识符列表](./04-Expressions.md#identifier-list) **)** > -> *闭包参数列表* [闭包参数](./04_Expressions.md#implicit-member-expression) | [闭包参数](./04_Expressions.md#implicit-member-expression), [闭包参数列表](./04_Expressions.md#implicit-member-expression) +> *闭包参数列表* [闭包参数](./04_Expressions.md#implicit-member-expression) | [闭包参数](./04-Expressions.md#implicit-member-expression), [闭包参数列表](./04-Expressions.md#implicit-member-expression) > -> *闭包参数* [闭包参数名](./04_Expressions.md#implicit-member-expression) [类型声明](./03_Types.md#type-annotation) 可选 +> *闭包参数* [闭包参数名](./04_Expressions.md#implicit-member-expression) [类型声明](./03-Types.md#type-annotation) 可选 > -> *闭包参数* [闭包参数名](./04_Expressions.md#implicit-member-expression) [类型声明](./03_Types.md#type-annotation) **...** +> *闭包参数* [闭包参数名](./04_Expressions.md#implicit-member-expression) [类型声明](./03-Types.md#type-annotation) **...** > > *闭包参数名* [标识符](./02_Lexical_Structure.md#identifier) > > -> *捕获列表* → [捕获列表](./04_Expressions.md#capture-list) **[** [捕获列表项列表](./04_Expressions.md#capture-list-items) **]** +> *捕获列表* → [捕获列表](./04_Expressions.md#capture-list) **[** [捕获列表项列表](./04-Expressions.md#capture-list-items) **]** > -> *捕获列表项列表* → [捕获列表项](./04_Expressions.md#capture-list-item) | [捕获列表项](./04_Expressions.md#capture-list-item) **,** [捕获列表项列表](./04_Expressions.md#capture-list-items) +> *捕获列表项列表* → [捕获列表项](./04_Expressions.md#capture-list-item) | [捕获列表项](./04-Expressions.md#capture-list-item) **,** [捕获列表项列表](./04-Expressions.md#capture-list-items) > -> *捕获列表项* → [捕获说明符](./04_Expressions.md#capture-specifier)可选 [*表达式*](./04_Expressions.md#expression) +> *捕获列表项* → [捕获说明符](./04_Expressions.md#capture-specifier)可选 [*表达式*](./04-Expressions.md#expression) > > *捕获说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** > @@ -628,10 +628,10 @@ > 元组表达式语法 > -> *元组表达式* → **( )** | **(**[元组元素](./04_Expressions.md#tuple-element)， [元组元素列表](./04_Expressions.md#tuple-element-list) **)** +> *元组表达式* → **( )** | **(**[元组元素](./04_Expressions.md#tuple-element)， [元组元素列表](./04-Expressions.md#tuple-element-list) **)** > -> *元组元素列表* → [元组元素](./04_Expressions.md#tuple-element) | [元组元素](./04_Expressions.md#tuple-element) **,** [元组元素列表](./04_Expressions.md#tuple-element-list) -> *元组元素* → [表达式](./04_Expressions.md#expression) | [标识符](./04_Expressions.md#identifier) **:** [表达式](./04_Expressions.md##expression) +> *元组元素列表* → [元组元素](./04_Expressions.md#tuple-element) | [元组元素](./04-Expressions.md#tuple-element) **,** [元组元素列表](./04-Expressions.md#tuple-element-list) +> *元组元素* → [表达式](./04_Expressions.md#expression) | [标识符](./04-Expressions.md#identifier) **:** [表达式](./04-Expressions.md##expression) > @@ -647,9 +647,9 @@ > key-path表达式语法 > > *key-path 表达式* → **\** [类型](./03_Types.md#type)可选 **.** [多个 key-path 组件] -> *多个 key-path 组件* → [key-path 组件](./04_Expressions.md#key-path-component) | [key-path 组件](./04_Expressions.md#key-path-component) **.** [多个 key-path 组件](./04_Expressions.md#key-path-components) -> *key-path 组件* → [标识符](./02_Lexical_Structure.md#identifier) [多个 key-path 后缀](./04_Expressions.md#key-path-postfixes)可选 | [多个 key-path 后缀](./04_Expressions.md#key-path-postfixes) -> *多个 key-path 后缀* → [key-path 后缀](./04_Expressions.md#key-path-postfix) [多个 key-path 后缀](./04_Expressions.md#key-path-postfixes)可选 key-path-postfixes {./04_Expressions.md#key-path-postfixes} +> *多个 key-path 组件* → [key-path 组件](./04_Expressions.md#key-path-component) | [key-path 组件](./04-Expressions.md#key-path-component) **.** [多个 key-path 组件](./04-Expressions.md#key-path-components) +> *key-path 组件* → [标识符](./02_Lexical_Structure.md#identifier) [多个 key-path 后缀](./04-Expressions.md#key-path-postfixes)可选 | [多个 key-path 后缀](./04-Expressions.md#key-path-postfixes) +> *多个 key-path 后缀* → [key-path 后缀](./04_Expressions.md#key-path-postfix) [多个 key-path 后缀](./04-Expressions.md#key-path-postfixes)可选 key-path-postfixes {./04-Expressions.md#key-path-postfixes} > > *key-path 后缀* → **?** | **!** | **self** | **\[** [函数调用参数表](./04_Expressions.md#function-call-argument-list) **\]** > @@ -659,17 +659,17 @@ > 选择器表达式语法 > -> *选择器表达式* → **#selector** **(** [*表达式*](./04_Expressions.md#expression) **)** +> *选择器表达式* → **#selector** **(** [*表达式*](./04-Expressions.md#expression) **)** > -> *选择器表达式* → **#selector** **(** [*getter:表达式*](./04_Expressions.md#expression) **)** +> *选择器表达式* → **#selector** **(** [*getter:表达式*](./04-Expressions.md#expression) **)** > -> *选择器表达式* → **#selector** **(** [*setter:表达式*](./04_Expressions.md#expression) **)** +> *选择器表达式* → **#selector** **(** [*setter:表达式*](./04-Expressions.md#expression) **)** > > key-path 字符串表达式语法 -> *key-path 字符串表达式* → **#keyPath (** [表达式](./04_Expressions.md#expression) **)** +> *key-path 字符串表达式* → **#keyPath (** [表达式](./04-Expressions.md#expression) **)** > @@ -678,7 +678,7 @@ > > *后缀表达式* → [基本表达式](./04_Expressions.md#primary-expression) > -> *后缀表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) [后缀运算符](02_Lexical_Structure.md#postfix-operator) +> *后缀表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) [后缀运算符](02-Lexical-Structure.md#postfix-operator) > > *后缀表达式* → [函数调用表达式](./04_Expressions.md#function-call-expression) > @@ -699,17 +699,17 @@ > 函数调用表达式语法 > -> *函数调用表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) [函数调用参数子句](./04_Expressions.md#function-call-argument-clause) +> *函数调用表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) [函数调用参数子句](./04-Expressions.md#function-call-argument-clause) > -> *函数调用表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) [函数调用参数子句](./04_Expressions.md#function-call-argument-clause)可选 [尾随闭包](./04_Expressions.md#trailing-closure) +> *函数调用表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) [函数调用参数子句](./04-Expressions.md#function-call-argument-clause)可选 [尾随闭包](./04-Expressions.md#trailing-closure) > > *函数调用参数子句* → **(** **)** | **(** [函数调用参数表](./04_Expressions.md#function-call-argument-list) **)** > -> *函数调用参数表* → [函数调用参数](./04_Expressions.md#function-call-argument) | [函数调用参数](./04_Expressions.md#function-call-argument) **,** [函数调用参数表](./04_Expressions.md#function-call-argument-list) +> *函数调用参数表* → [函数调用参数](./04_Expressions.md#function-call-argument) | [函数调用参数](./04-Expressions.md#function-call-argument) **,** [函数调用参数表](./04-Expressions.md#function-call-argument-list) > -> *函数调用参数* → [表达式](./04_Expressions.md#expression) | [标识符](02_Lexical_Structure.md#identifier) **:** [表达式](./04_Expressions.md#expression) +> *函数调用参数* → [表达式](./04_Expressions.md#expression) | [标识符](02-Lexical-Structure.md#identifier) **:** [表达式](./04-Expressions.md#expression) > -> *函数调用参数* → [运算符](./02_Lexical_Structure.md#operator) | [标识符](./02_Lexical_Structure.md#identifier) **:** [运算符](./02_Lexical_Structure.md#operator) +> *函数调用参数* → [运算符](./02_Lexical_Structure.md#operator) | [标识符](./02-Lexical-Structure.md#identifier) **:** [运算符](./02-Lexical-Structure.md#operator) > > *尾随闭包* → [闭包表达式](./04_Expressions.md#closure-expression) > @@ -720,20 +720,20 @@ > > *构造器表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** **init** > -> *构造器表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** **init** **(** [参数名称](./04_Expressions.md#argument-names) **)** +> *构造器表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** **init** **(** [参数名称](./04-Expressions.md#argument-names) **)** > > 显式成员表达式语法 > -> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [十进制数字] (02_Lexical_Structure.md#decimal-digit) +> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [十进制数字] (02-Lexical-Structure.md#decimal-digit) > -> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符](02_Lexical_Structure.md#identifier) [泛型实参子句](./09_Generic_Parameters_and_Arguments.md#generic-argument-clause)可选
+> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符](02-Lexical-Structure.md#identifier) [泛型实参子句](./09-Generic-Parameters-and-Arguments.md#generic-argument-clause)可选
> -> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符] (02_Lexical_Structure.md#identifier) **(** [参数名称](./04_Expressions.md#argument-names) **)** +> *显式成员表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **.** [标识符] (02-Lexical-Structure.md#identifier) **(** [参数名称](./04-Expressions.md#argument-names) **)** > -> *参数名称* → [参数名](./04_Expressions.md#argument-name) [参数名称](./04_Expressions.md#argument-names)可选
+> *参数名称* → [参数名](./04_Expressions.md#argument-name) [参数名称](./04-Expressions.md#argument-names)可选
> > *参数名* → [标识符](./02_Lexical_Structure.md#identifier) **:** > @@ -749,7 +749,7 @@ > 下标表达式语法 > -> *下标表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **[** [表达式列表](./04_Expressions.md#expression-list) **]** +> *下标表达式* → [后缀表达式](./04_Expressions.md#postfix-expression) **[** [表达式列表](./04-Expressions.md#expression-list) **]** > @@ -773,84 +773,84 @@ > > *语句* → [声明](./06_Declarations.md#declaration) **;**可选 > -> *语句* → [循环语句](./05_Statements.md#loop_statement) **;**可选 +> *语句* → [循环语句](./05_Statements.md#loop-statement) **;**可选 > -> *语句* → [分支语句](./05_Statements.md#branch_statement) **;**可选 +> *语句* → [分支语句](./05_Statements.md#branch-statement) **;**可选 > -> *语句* → [标签语句](./05_Statements.md#labeled_statement) **;**可选 +> *语句* → [标签语句](./05_Statements.md#labeled-statement) **;**可选 > -> *语句* → [控制转移语句](./05_Statements.md#control_transfer_statement) **;**可选 +> *语句* → [控制转移语句](./05_Statements.md#control-transfer-statement) **;**可选 > -> *语句* → [延迟语句](./05_Statements.md#defer_statement) **;**可选 +> *语句* → [延迟语句](./05_Statements.md#defer-statement) **;**可选 > -> *语句* → [执行语句](./05_Statements.md#do_statement) **;**可选 +> *语句* → [执行语句](./05_Statements.md#do-statement) **;**可选 > -> *语句* → [编译控制语句](./05_Statements.md#compiler_control_statement) +> *语句* → [编译控制语句](./05_Statements.md#compiler-control-statement) > -> *语句集* → [语句](./05_Statements.md#statement) [语句集](./05_Statements.md#statements)可选 +> *语句集* → [语句](./05_Statements.md#statement) [语句集](./05-Statements.md#statements)可选 > > 循环语句语法 > -> *循环语句* → [for-in 语句](./05_Statements.md#for_in_statement) +> *循环语句* → [for-in 语句](./05_Statements.md#for-in-statement) > -> *循环语句* → [while 语句](./05_Statements.md#wheetatype 类型 ile_statement) +> *循环语句* → [while 语句](./05_Statements.md#wheetatype 类型 ile-statement) > -> *循环语句* → [repeat-while 语句](./05_Statements.md#do_while_statement) +> *循环语句* → [repeat-while 语句](./05_Statements.md#do-while-statement) > > For-In 循环语法 > -> *for-in 语句* → **for case**可选 [模式](./08_Patterns.md#pattern) **in** [表达式](./04_Expressions.md#expression) [where 子句](./05_Statements.md#where_clause)可选 [代码块](./06_Declarations.md#code_block) +> *for-in 语句* → **for case**可选 [模式](./08_Patterns.md#pattern) **in** [表达式](./04-Expressions.md#expression) [where 子句](./05-Statements.md#where-clause)可选 [代码块](./06-Declarations.md#code-block) > > While 循环语法 > -> *while 语句* → **while** [条件集](./05_Statements.md#condition_list) [代码块](./06_Declarations.md#code_block) +> *while 语句* → **while** [条件集](./05_Statements.md#condition-list) [代码块](./06-Declarations.md#code-block) > -> *条件集* → [条件](./05_Statements.md#condition) | [条件](./05_Statements.md#condition) **,** [条件集](./05_Statements.md#condition_list) -> *条件* → [表达式](./04_Expressions.md#expression) | [可用性条件](./05_Statements.md#availability_condition) | [case 条件](./05_Statements.md#case_condition) | [可选绑定条件](./05_Statements.md#optional_binding_condition) +> *条件集* → [条件](./05_Statements.md#condition) | [条件](./05-Statements.md#condition) **,** [条件集](./05-Statements.md#condition-list) +> *条件* → [表达式](./04_Expressions.md#expression) | [可用性条件](./05-Statements.md#availability-condition) | [case 条件](./05-Statements.md#case-condition) | [可选绑定条件](./05-Statements.md#optional-binding-condition) > -> *case 条件* → **case** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) +> *case 条件* → **case** [模式](./08_Patterns.md#pattern) [构造器](./06-Declarations.md#initializer) > -> *可选绑定条件* → **let** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) | **var** [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer) +> *可选绑定条件* → **let** [模式](./08_Patterns.md#pattern) [构造器](./06-Declarations.md#initializer) | **var** [模式](./08-Patterns.md#pattern) [构造器](./06-Declarations.md#initializer) > > Repeat-While 语句语法 > -*repeat-while-statement* → **repeat** [代码块](./06_Declarations.md#code_block) **while** [表达式](./04_Expressions.md#expression) +*repeat-while-statement* → **repeat** [代码块](./06_Declarations.md#code-block) **while** [表达式](./04-Expressions.md#expression) > 分支语句语法 > -> *分支语句* → [if 语句](./05_Statements.md#if_statement) +> *分支语句* → [if 语句](./05_Statements.md#if-statement) > -> *分支语句* → [guard 语句](./05_Statements.md#guard_statement) +> *分支语句* → [guard 语句](./05_Statements.md#guard-statement) > -> *分支语句* → [switch 语句](./05_Statements.md#switch_statement) +> *分支语句* → [switch 语句](./05_Statements.md#switch-statement) > > If 语句语法 > -> *if 语句* → **if** [条件集](./05_Statements.md#condition_list) [代码块](./06_Declarations.md#code_block) [else 子句](./05_Statements.md#else_clause)可选 +> *if 语句* → **if** [条件集](./05_Statements.md#condition-list) [代码块](./06-Declarations.md#code-block) [else 子句](./05-Statements.md#else-clause)可选 > -> *else 子句* → **else** [代码块](./06_Declarations.md#code_block) | **else** [if 语句](./05_Statements.md#if_statement) +> *else 子句* → **else** [代码块](./06_Declarations.md#code-block) | **else** [if 语句](./05-Statements.md#if-statement) > > Guard 语句语法 > -> *guard 语句* → **guard** [条件集](./05_Statements.md#condition_list) **else** [代码块](./06_Declarations.md#code_block) +> *guard 语句* → **guard** [条件集](./05_Statements.md#condition-list) **else** [代码块](./06-Declarations.md#code-block) > @@ -858,50 +858,50 @@ > Switch 语句语法 > -> *switch 语句* → **switch** [表达式](./04_Expressions.md#expression) **{** [switch-case集](./05_Statements.md#switch_cases)可选 **}** +> *switch 语句* → **switch** [表达式](./04_Expressions.md#expression) **{** [switch-case集](./05-Statements.md#switch-cases)可选 **}** > -> *switch-case集* → [switch-case](./05_Statements.md#switch_case) [switch-case集](./05_Statements.md#switch_cases)可选 +> *switch-case集* → [switch-case](./05_Statements.md#switch-case) [switch-case集](./05-Statements.md#switch-cases)可选 > -> *switch-case* → [case 标签](./05_Statements.md#case_label) [语句集](./05_Statements.md#statements) +> *switch-case* → [case 标签](./05_Statements.md#case-label) [语句集](./05-Statements.md#statements) > -> *switch-case* → [default 标签](./05_Statements.md#default_label) [语句集](./05_Statements.md#statements) +> *switch-case* → [default 标签](./05_Statements.md#default-label) [语句集](./05-Statements.md#statements) > -> *switch-case* → [条件 switch-case](./05_Statements.md#conditional_switch_case) +> *switch-case* → [条件 switch-case](./05_Statements.md#conditional-switch-case) > -> *case 标签* → [特性](./07_Attributes.md#attributes)可选 **case** [case 项集](./05_Statements.md#case_item_list) **:** +> *case 标签* → [特性](./07_Attributes.md#attributes)可选 **case** [case 项集](./05-Statements.md#case-item-list) **:** > -> *case 项集* → [模式](./08_Patterns.md#pattern) [where 子句](./05_Statements.md#where_clause)可选 | [模式](./08_Patterns.md#pattern) [where 子句](./05_Statements.md#guard_clause)可选 **,** [case 项集](./05_Statements.md#case_item_list) +> *case 项集* → [模式](./08_Patterns.md#pattern) [where 子句](./05-Statements.md#where-clause)可选 | [模式](./08-Patterns.md#pattern) [where 子句](./05-Statements.md#guard-clause)可选 **,** [case 项集](./05-Statements.md#case-item-list) > > *default 标签* → [特性](./07_Attributes.md#attributes)可选 **default** **:** > -> *where 子句* → **where** [where 表达式](./05_Statements.md#where_expression) +> *where 子句* → **where** [where 表达式](./05_Statements.md#where-expression) > > *where 表达式* → [表达式](./04_Expressions.md#expression) > -> *条件 switch-case* → [switch if 指令子句](./05_Statements.md#switch_if_directive_clause) [switch elseif 指令子句集](./05_Statements.md#switch_elseif_directive_clauses)可选 [switch else 指令子句](./05_Statements.md#switch_else_directive_clause)可选 [endif 指令](./05_Statements.md#endif_directive) +> *条件 switch-case* → [switch if 指令子句](./05_Statements.md#switch-if-directive-clause) [switch elseif 指令子句集](./05-Statements.md#switch-elseif-directive-clauses)可选 [switch else 指令子句](./05-Statements.md#switch-else-directive-clause)可选 [endif 指令](./05-Statements.md#endif-directive) > -> *switch if 指令子句* → [if 指令](./05_Statements.md#if_directive) [编译条件](./05_Statements.md#compilation_condition) [switch-case集](./05_Statements.md#switch_cases)可选 +> *switch if 指令子句* → [if 指令](./05_Statements.md#if-directive) [编译条件](./05-Statements.md#compilation-condition) [switch-case集](./05-Statements.md#switch-cases)可选 > -> *switch elseif 指令子句集* → [elseif 指令子句](./05_Statements.md#else_if_directive_clause) [switch elseif 指令子句集](./05_Statements.md#switch_elseif_directive_clauses)可选 +> *switch elseif 指令子句集* → [elseif 指令子句](./05_Statements.md#else-if-directive-clause) [switch elseif 指令子句集](./05-Statements.md#switch-elseif-directive-clauses)可选 > -> *switch elseif 指令子句* → [elseif 指令](./05_Statements.md#elseif_directive) [编译条件](./05_Statements.md#compilation_condition) [switch-case集](./05_Statements.md#switch_cases)可选 +> *switch elseif 指令子句* → [elseif 指令](./05_Statements.md#elseif-directive) [编译条件](./05-Statements.md#compilation-condition) [switch-case集](./05-Statements.md#switch-cases)可选 > -> *switch else 指令子句* → [else 指令](./05_Statements.md#else_directive) [switch-case集](./05_Statements.md#switch_cases)可选 +> *switch else 指令子句* → [else 指令](./05_Statements.md#else-directive) [switch-case集](./05-Statements.md#switch-cases)可选 > > 标签语句语法 > -> *标签语句* → [语句标签](./05_Statements.md#statement_label) [循环语句](./05_Statements.md#loop_statement) +> *标签语句* → [语句标签](./05_Statements.md#statement-label) [循环语句](./05-Statements.md#loop-statement) > -> *标签语句* → [语句标签](./05_Statements.md#statement_label) [if 语句](./05_Statements.md#if_statement) +> *标签语句* → [语句标签](./05_Statements.md#statement-label) [if 语句](./05-Statements.md#if-statement) > -> *标签语句* → [语句标签](./05_Statements.md#statement_label) [switch 语句](./05_Statements.md#switch_statement) +> *标签语句* → [语句标签](./05_Statements.md#statement-label) [switch 语句](./05-Statements.md#switch-statement) > -> *标签语句* → [语句标签](./05_Statements.md#statement_label) [do 语句](./05_Statements.md#do_statement) +> *标签语句* → [语句标签](./05_Statements.md#statement-label) [do 语句](./05-Statements.md#do-statement) > -> *语句标签* → [标签名称](./05_Statements.md#label_name) **:** +> *语句标签* → [标签名称](./05_Statements.md#label-name) **:** > > *标签名称* → [标识符](./02_Lexical_Structure.md#identifier) > @@ -910,29 +910,29 @@ > 控制转移语句语法 > -> *控制转移语句* → [break 语句](./05_Statements.md#break_statement) +> *控制转移语句* → [break 语句](./05_Statements.md#break-statement) > -> *控制转移语句* → [continue 语句](./05_Statements.md#continue_statement) +> *控制转移语句* → [continue 语句](./05_Statements.md#continue-statement) > -> *控制转移语句* → [fallthrough 语句](./05_Statements.md#fallthrough_statement) +> *控制转移语句* → [fallthrough 语句](./05_Statements.md#fallthrough-statement) > -> *控制转移语句* → [return 语句](./05_Statements.md#return_statement) +> *控制转移语句* → [return 语句](./05_Statements.md#return-statement) > -> *控制转移语句* → [throw 语句](./05_Statements.md#throw_statement) +> *控制转移语句* → [throw 语句](./05_Statements.md#throw-statement) > > Break 语句语法 > -> *break 语句* → **break** [标签名称](./05_Statements.md#label_name)可选 +> *break 语句* → **break** [标签名称](./05_Statements.md#label-name)可选 > > Continue 语句语法 > -> *continue 语句* → **continue** [标签名称](./05_Statements.md#label_name)可选 +> *continue 语句* → **continue** [标签名称](./05_Statements.md#label-name)可选 > @@ -960,41 +960,41 @@ > Defer 语句语法 > -> *defer 语句* → **defer** [代码块](./06_Declarations.md#code_block) +> *defer 语句* → **defer** [代码块](./06_Declarations.md#code-block) > > Do 语句语法 > -> *do 语句* → **do** [代码块](./06_Declarations.md#code_block) [catch 子句集](./05_Statements.md#catch_clauses)可选 +> *do 语句* → **do** [代码块](./06_Declarations.md#code-block) [catch 子句集](./05-Statements.md#catch-clauses)可选 > -> *catch 子句集* → [catch 子句](./05_Statements.md#catch_clause) [catch 子句集](05_Statements.md#catch_clauses)可选 +> *catch 子句集* → [catch 子句](./05_Statements.md#catch-clause) [catch 子句集](05-Statements.md#catch-clauses)可选 > -> *catch 子句* → **catch** [模式](./08_Patterns.md#pattern)可选 [where 子句](./05_Statements.md#where_clause)可选 [代码块](./06_Declarations.md#code_block)可选 +> *catch 子句* → **catch** [模式](./08_Patterns.md#pattern)可选 [where 子句](./05-Statements.md#where-clause)可选 [代码块](./06-Declarations.md#code-block)可选 > > 编译控制语句 > -> *编译控制语句* → [条件编译块](./05_Statements.md#conditional_complation_block) +> *编译控制语句* → [条件编译块](./05_Statements.md#conditional-complation-block) > -> *编译控制语句* → [行控制语句](./05_Statements.md#line_control_statement) +> *编译控制语句* → [行控制语句](./05_Statements.md#line-control-statement) > -> *编译控制语句* → [诊断语句](./05_Statements.md#diagnostic_statement) +> *编译控制语句* → [诊断语句](./05_Statements.md#diagnostic-statement) > > 条件编译块语法 > -> *条件编译块* → [if 指令子句](./05_Statements.md#if_directive_clause) [elseif 指令子句集](./05_Statements.md#elseif_directive_clauses)可选 [else 指令子句](./05_Statements.md#else_directive_clause)可选 [endif 指令](./05_Statements.md#endif_directive) +> *条件编译块* → [if 指令子句](./05_Statements.md#if-directive-clause) [elseif 指令子句集](./05-Statements.md#elseif-directive-clauses)可选 [else 指令子句](./05-Statements.md#else-directive-clause)可选 [endif 指令](./05-Statements.md#endif-directive) > -> *if 指令子句* → [if 指令](./05_Statements.md#if_directive) [编译条件](./05_Statements.md#compilation_condition) [语句集](./05_Statements.md#statements)可选 +> *if 指令子句* → [if 指令](./05_Statements.md#if-directive) [编译条件](./05-Statements.md#compilation-condition) [语句集](./05-Statements.md#statements)可选 > -> *elseif 指令子句集* → [elseif 指令子句](./05_Statements.md#else_if_directive_clause) [elseif 指令子句集](./05_Statements.md#elseif_directive_clauses)可选 +> *elseif 指令子句集* → [elseif 指令子句](./05_Statements.md#else-if-directive-clause) [elseif 指令子句集](./05-Statements.md#elseif-directive-clauses)可选 > -> *elseif 指令子句* → [elseif 指令](./05_Statements.md#elseif_directive) [编译条件](./05_Statements.md#compilation_condition) [语句集](./05_Statements.md#statements)可选 +> *elseif 指令子句* → [elseif 指令](./05_Statements.md#elseif-directive) [编译条件](./05-Statements.md#compilation-condition) [语句集](./05-Statements.md#statements)可选 > -> *else 指令子句* → [else 指令](./05_Statements.md#else_directive) [语句集](./05_Statements.md#statements)可选 +> *else 指令子句* → [else 指令](./05_Statements.md#else-directive) [语句集](./05-Statements.md#statements)可选 > > *if 指令* → **#if** > @@ -1004,29 +1004,29 @@ > > *endif 指令* → **#endif** > -> *编译条件* → [平台条件](./05_Statements.md#platform_condition) +> *编译条件* → [平台条件](./05_Statements.md#platform-condition) > > *编译条件* → [标识符](./02_Lexical_Structure.md#identifier) > -> *编译条件* → [布尔字面量](./02_Lexical_Structure.md#boolean_literal) +> *编译条件* → [布尔字面量](./02_Lexical_Structure.md#boolean-literal) > -> *编译条件* → **(** [编译条件](./05_Statements.md#compilation_condition) **)** +> *编译条件* → **(** [编译条件](./05_Statements.md#compilation-condition) **)** > -> *编译条件* → **!** [编译条件](./05_Statements.md#compilation_condition) +> *编译条件* → **!** [编译条件](./05_Statements.md#compilation-condition) > -> *编译条件* → [编译条件](./05_Statements.md#compilation_condition) **&&** [编译条件](./05_Statements.md#compilation_condition) +> *编译条件* → [编译条件](./05_Statements.md#compilation-condition) **&&** [编译条件](./05-Statements.md#compilation-condition) > -> *编译条件* → [编译条件](./05_Statements.md#compilation_condition) **||** [编译条件](./05_Statements.md#compilation_condition) +> *编译条件* → [编译条件](./05_Statements.md#compilation-condition) **||** [编译条件](./05-Statements.md#compilation-condition) > -> *平台条件* → **os** **(** [操作系统](./05_Statements.md#operating_system) **)** +> *平台条件* → **os** **(** [操作系统](./05_Statements.md#operating-system) **)** > > *平台条件* → **arch** **(** [架构](./05_Statements.md#architecture) **)** > -> *平台条件* → **swift** **(** **>=** [swift 版本](./05_Statements.md#swift_version) **)** | **swift** **(** **<** [swift 版本](./05_Statements.md#swift_version) **)** +> *平台条件* → **swift** **(** **>=** [swift 版本](./05_Statements.md#swift-version) **)** | **swift** **(** **<** [swift 版本](./05-Statements.md#swift-version) **)** > -> *平台条件* → **compiler** **(** **>=** [swift 版本](./05_Statements.md#swift_version) **)** | **compiler** **(** **<** [swift 版本](./05_Statements.md#swift_version) **)** +> *平台条件* → **compiler** **(** **>=** [swift 版本](./05_Statements.md#swift-version) **)** | **compiler** **(** **<** [swift 版本](./05-Statements.md#swift-version) **)** > -> *平台条件* → **canImport** **(** [模块名](./05_Statements.md#module_name) **)** +> *平台条件* → **canImport** **(** [模块名](./05_Statements.md#module-name) **)** > > *平台条件* → **targetEnvironment** **(** [环境](./05_Statements.md#environment) **)** > @@ -1034,9 +1034,9 @@ > > *架构* → **i386** | **x86_64** | **arm** | **arm64** > -> *swift 版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) [swift 版本后缀](./05_Statements.md#swift_version_continuation)可选 +> *swift 版本* → [十进制数字集](./02_Lexical_Structure.md#decimal-digits) [swift 版本后缀](./05-Statements.md#swift-version-continuation)可选 > -> *swift 版本后缀* → **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) [swift 版本集](./05_Statements.md#swift_version_continuation)可选 +> *swift 版本后缀* → **.** [十进制数字集](./02_Lexical_Structure.md#decimal-digits) [swift 版本集](./05-Statements.md#swift-version-continuation)可选 > > *模块名* → [标识符](./02_Lexical_Structure.md#identifier) > @@ -1046,33 +1046,33 @@ > 行控制语句语法 > -> *行控制语句* → **#sourceLocation** **(** **file:** [文件名](./05_Statements.md#file_name) **,** **line:** [行号](./05_Statements.md#line_number) **)** +> *行控制语句* → **#sourceLocation** **(** **file:** [文件名](./05-Statements.md#file-name) **,** **line:** [行号](./05-Statements.md#line-number) **)** > > *行控制语句* → **#sourceLocation** **(** **)** > > *行号* → 一个大于 0 的十进制数字 > -> *文件名* → [静态字符串字面量](./02_Lexical_Structure.md#static_string_literal) +> *文件名* → [静态字符串字面量](./02_Lexical_Structure.md#static-string-literal) > > 编译期诊断语句语法 > -> *诊断语句* → **#error** **(** [诊断信息](./05_Statements.md#diagnostic_message) **)** +> *诊断语句* → **#error** **(** [诊断信息](./05-Statements.md#diagnostic-message) **)** > -> *诊断语句* → **#warning** **(** [诊断信息](./05_Statements.md#diagnostic_message) **)** +> *诊断语句* → **#warning** **(** [诊断信息](./05-Statements.md#diagnostic-message) **)** > -> *诊断信息* → [静态字符串字面量](./02_Lexical_Structure.md#static_string_literal) +> *诊断信息* → [静态字符串字面量](./02_Lexical_Structure.md#static-string-literal) > > 可用性条件语法 > -> *可用性条件* → **#available** **(** [可用性参数集](./05_Statements.md#availability_arguments) **)** +> *可用性条件* → **#available** **(** [可用性参数集](./05-Statements.md#availability-arguments) **)** > -> *可用性参数集* → [可用性参数](./05_Statements.md#availability_argument) | [可用性参数](./05_Statements.md#availability_argument) , [可用性参数集）](./05_Statements.md#availability_arguments) +> *可用性参数集* → [可用性参数](./05_Statements.md#availability-argument) | [可用性参数](./05-Statements.md#availability-argument) , [可用性参数集）](./05-Statements.md#availability-arguments) > -> *可用性参数* → [平台名](./05_Statements.md#platform_name) [平台版本](./05_Statements.md#platform_version) +> *可用性参数* → [平台名](./05_Statements.md#platform-name) [平台版本](./05-Statements.md#platform-version) > > *可用性参数* → **\*** > @@ -1084,48 +1084,48 @@ > > *平台名* → **tvOS** > -> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) +> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal-digits) > -> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) +> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字集](./02-Lexical-Structure.md#decimal-digits) > -> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal_digits) **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) **.** [十进制数字集](./02_Lexical_Structure.md#decimal_digits) +> *平台版本* → [十进制数字集](./02_Lexical_Structure.md#decimal-digits) **.** [十进制数字集](./02-Lexical-Structure.md#decimal-digits) **.** [十进制数字集](./02-Lexical-Structure.md#decimal-digits) > ## 声明 {#declarations} > 声明语法 > -> *声明* → [导入声明](./06_Declarations.md#import_declaration) +> *声明* → [导入声明](./06_Declarations.md#import-declaration) > -> *声明* → [常量声明](./06_Declarations.md#constant_declaration) +> *声明* → [常量声明](./06_Declarations.md#constant-declaration) > -> *声明* → [变量声明](./06_Declarations.md#variable_declaration) +> *声明* → [变量声明](./06_Declarations.md#variable-declaration) > -> *声明* → [类型别名声明](./06_Declarations.md#typealias_declaration) +> *声明* → [类型别名声明](./06_Declarations.md#typealias-declaration) > -> *声明* → [函数声明](./06_Declarations.md#function_declaration) +> *声明* → [函数声明](./06_Declarations.md#function-declaration) > -> *声明* → [枚举声明](./06_Declarations.md#enum_declaration) +> *声明* → [枚举声明](./06_Declarations.md#enum-declaration) > -> *声明* → [结构体声明](./06_Declarations.md#struct_declaration) +> *声明* → [结构体声明](./06_Declarations.md#struct-declaration) > -> *声明* → [类声明](./06_Declarations.md#class_declaration) +> *声明* → [类声明](./06_Declarations.md#class-declaration) > -> *声明* → [协议声明](./06_Declarations.md#protocol_declaration) +> *声明* → [协议声明](./06_Declarations.md#protocol-declaration) > -> *声明* → [构造器声明](./06_Declarations.md#initializer_declaration) +> *声明* → [构造器声明](./06_Declarations.md#initializer-declaration) > -> *声明* → [析构器声明](./06_Declarations.md#deinitializer_declaration) +> *声明* → [析构器声明](./06_Declarations.md#deinitializer-declaration) > -> *声明* → [扩展声明](./06_Declarations.md#extension_declaration) +> *声明* → [扩展声明](./06_Declarations.md#extension-declaration) > -> *声明* → [下标声明](./06_Declarations.md#subscript_declaration) +> *声明* → [下标声明](./06_Declarations.md#subscript-declaration) > -> *声明* → [运算符声明](./06_Declarations.md#operator_declaration) +> *声明* → [运算符声明](./06_Declarations.md#operator-declaration) > -> *声明* → [优先级组声明](./06_Declarations.md#precedence_group_declaration) +> *声明* → [优先级组声明](./06_Declarations.md#precedence-group-declaration) > -> *声明集* → [声明](./06_Declarations.md#declaration) [声明集](./06_Declarations.md#declarations)可选 +> *声明集* → [声明](./06_Declarations.md#declaration) [声明集](./06-Declarations.md#declarations)可选 > @@ -1147,24 +1147,24 @@ > 导入声明语法 > -> *导入声明* → [特性](./07_Attributes.md#attributes)可选 **import** [导入类型](./06_Declarations.md#import_kind)可选 [导入路径](./06_Declarations.md#import_path) +> *导入声明* → [特性](./07_Attributes.md#attributes)可选 **import** [导入类型](./06-Declarations.md#import-kind)可选 [导入路径](./06-Declarations.md#import-path) > > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **let** | **var** | **func** > -> *导入路径* → [导入路径标识符](./06_Declarations.md#import_path_identifier) | [导入路径标识符](./06_Declarations.md#import_path_identifier) **.** [导入路径](./06_Declarations.md#import_path) +> *导入路径* → [导入路径标识符](./06_Declarations.md#import-path-identifier) | [导入路径标识符](./06-Declarations.md#import-path-identifier) **.** [导入路径](./06-Declarations.md#import-path) > -> *导入路径标识符* → [标识符](./02_Lexical_Structure.md#identifier) | [运算符](./02_Lexical_Structure.md#operator) +> *导入路径标识符* → [标识符](./02_Lexical_Structure.md#identifier) | [运算符](./02-Lexical-Structure.md#operator) > > 常数声明语法 > -> *常量声明* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_specifiers)可选 **let** [模式构造器集](./06_Declarations.md#pattern_initializer_list) +> *常量声明* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06-Declarations.md#declaration-specifiers)可选 **let** [模式构造器集](./06-Declarations.md#pattern-initializer-list) > -> *模式构造器集* → [模式构造器](./06_Declarations.md#pattern_initializer) | [模式构造器](./06_Declarations.md#pattern_initializer) **,** [模式构造器集](./06_Declarations.md#pattern_initializer_list) +> *模式构造器集* → [模式构造器](./06_Declarations.md#pattern-initializer) | [模式构造器](./06-Declarations.md#pattern-initializer) **,** [模式构造器集](./06-Declarations.md#pattern-initializer-list) > -> *模式构造器* → [模式](./08_Patterns.md#pattern) [构造器](./06_Declarations.md#initializer)可选 +> *模式构造器* → [模式](./08_Patterns.md#pattern) [构造器](./06-Declarations.md#initializer)可选 > > *构造器* → **=** [表达式](./04_Expressions.md#expression) > @@ -1173,57 +1173,57 @@ > 变量声明语法 > -> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [模式构造器集](./06_Declarations.md#pattern_initializer_list) +> *变量声明* → [变量声明头](./06_Declarations.md#variable-declaration-head) [模式构造器集](./06-Declarations.md#pattern-initializer-list) > -> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [代码块](./06_Declarations.md#code_block) +> *变量声明* → [变量声明头](./06_Declarations.md#variable-declaration-head) [变量名](./06-Declarations.md#variable-name) [类型注解](./03-Types.md#type-annotation) [代码块](./06-Declarations.md#code-block) > -> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [getter-setter 块](./06_Declarations.md#getter_setter_block) +> *变量声明* → [变量声明头](./06_Declarations.md#variable-declaration-head) [变量名](./06-Declarations.md#variable-name) [类型注解](./03-Types.md#type-annotation) [getter-setter 块](./06-Declarations.md#getter-setter-block) > -> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> *变量声明* → [变量声明头](./06_Declarations.md#variable-declaration-head) [变量名](./06-Declarations.md#variable-name) [类型注解](./03-Types.md#type-annotation) [getter-setter 关键字块](./06-Declarations.md#getter-setter-keyword-block) > -> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [构造器](./06_Declarations.md#initializer)可选 [willSet-didSet 代码块](./06_Declarations.md#willSet_didSet_block) +> *变量声明* → [变量声明头](./06_Declarations.md#variable-declaration-head) [变量名](./06-Declarations.md#variable-name) [构造器](./06-Declarations.md#initializer)可选 [willSet-didSet 代码块](./06-Declarations.md#willSet-didSet-block) > -> *变量声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [构造器](./06_Declarations.md#initializer)可选 [willSet-didSet 代码块](./06_Declarations.md#willSet_didSet_block) +> *变量声明* → [变量声明头](./06_Declarations.md#variable-declaration-head) [变量名](./06-Declarations.md#variable-name) [类型注解](./03-Types.md#type-annotation) [构造器](./06-Declarations.md#initializer)可选 [willSet-didSet 代码块](./06-Declarations.md#willSet-didSet-block) > -> *变量声明头* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_specifiers)可选 **var** +> *变量声明头* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06-Declarations.md#declaration-specifiers)可选 **var** > > *变量名称* → [标识符](./02_Lexical_Structure.md#identifier) > -> *getter-setter 块* → [代码块](./06_Declarations.md#code_block) +> *getter-setter 块* → [代码块](./06_Declarations.md#code-block) > -> *getter-setter 块* → **{** [getter 子句](./06_Declarations.md#getter_keyword_clause) [setter 子句](./06_Declarations.md#setter_keyword_clause)可选 **}** +> *getter-setter 块* → **{** [getter 子句](./06_Declarations.md#getter-keyword-clause) [setter 子句](./06-Declarations.md#setter-keyword-clause)可选 **}** > -> *getter-setter 块* → **{** [setter 子句](./06_Declarations.md#setter_keyword_clause) [getter 子句](./06_Declarations.md#getter_keyword_clause) **}** +> *getter-setter 块* → **{** [setter 子句](./06_Declarations.md#setter-keyword-clause) [getter 子句](./06-Declarations.md#getter-keyword-clause) **}** > -> *getter 子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **get** [代码块](./06_Declarations.md#code_block) +> *getter 子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06-Declarations.md#mutation-modifier)可选 **get** [代码块](./06-Declarations.md#code-block) > -> *setter 子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **set** [setter 名称](./06_Declarations.md#setter_name)可选 [代码块](./06_Declarations.md#code_block) +> *setter 子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06-Declarations.md#mutation-modifier)可选 **set** [setter 名称](./06-Declarations.md#setter-name)可选 [代码块](./06-Declarations.md#code-block) > > *setter 名称* → **(** [标识符](./02_Lexical_Structure.md#identifier) **)** > -> *getter-setter 关键字（Keyword）块* → **{** [getter 关键字子句](./06_Declarations.md#getter_keyword_clause) [setter 关键字子句](./06_Declarations.md#setter_keyword_clause)可选 **}** +> *getter-setter 关键字（Keyword）块* → **{** [getter 关键字子句](./06_Declarations.md#getter-keyword-clause) [setter 关键字子句](./06-Declarations.md#setter-keyword-clause)可选 **}** > -> *getter-setter 关键字（Keyword）块* → **{** [setter 关键字子句](./06_Declarations.md#setter_keyword_clause) [getter 关键字子句](./06_Declarations.md#getter_keyword_clause) **}** +> *getter-setter 关键字（Keyword）块* → **{** [setter 关键字子句](./06_Declarations.md#setter-keyword-clause) [getter 关键字子句](./06-Declarations.md#getter-keyword-clause) **}** > -> *getter 关键字（Keyword）子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **get** +> *getter 关键字（Keyword）子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06-Declarations.md#mutation-modifier)可选 **get** > -> *setter 关键字（Keyword）子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06_Declarations.md#mutation-modifier)可选 **set** +> *setter 关键字（Keyword）子句* → [特性](./07_Attributes.md#attributes)可选 [可变性修饰符](./06-Declarations.md#mutation-modifier)可选 **set** > -> *willSet-didSet 代码块* → **{** [willSet 子句](./06_Declarations.md#willSet_clause) [didSet 子句](./06_Declarations.md#didSet_clause)可选 **}** +> *willSet-didSet 代码块* → **{** [willSet 子句](./06_Declarations.md#willSet-clause) [didSet 子句](./06-Declarations.md#didSet-clause)可选 **}** > -> *willSet-didSet 代码块* → **{** [didSet 子句](./06_Declarations.md#didSet_clause) [willSet 子句](./06_Declarations.md#willSet_clause)可选 **}** +> *willSet-didSet 代码块* → **{** [didSet 子句](./06_Declarations.md#didSet-clause) [willSet 子句](./06-Declarations.md#willSet-clause)可选 **}** > -> *willSet 子句* → [特性](./07_Attributes.md#attributes)可选 **willSet** [setter 名称](./06_Declarations.md#setter_name)可选 [代码块](./06_Declarations.md#code_block) +> *willSet 子句* → [特性](./07_Attributes.md#attributes)可选 **willSet** [setter 名称](./06-Declarations.md#setter-name)可选 [代码块](./06-Declarations.md#code-block) > > *didSet 子句* → [特性](./07_Attributes.md#attributes)可选 > - **didSet** [setter 名称](./06_Declarations.md#setter_name)可选 [代码块](./06_Declarations.md#code_block) + **didSet** [setter 名称](./06_Declarations.md#setter-name)可选 [代码块](./06-Declarations.md#code-block) > 类型别名声明语法 > -> *类型别名声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier) **typealias** [类型别名名称](./06_Declarations.md#typealias_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型别名赋值](./06_Declarations.md#typealias_assignment) +> *类型别名声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier) **typealias** [类型别名名称](./06-Declarations.md#typealias-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [类型别名赋值](./06-Declarations.md#typealias-assignment) > > *类型别名名称* → [标识符](./02_Lexical_Structure.md#identifier) > @@ -1234,30 +1234,30 @@ > 函数声明语法 > -> *函数声明* → [函数头](./06_Declarations.md#function_head) [函数名](./06_Declarations.md#function_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [函数签名](./06_Declarations.md#function_signature) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [函数体](./06_Declarations.md#function_body)可选 +> *函数声明* → [函数头](./06_Declarations.md#function-head) [函数名](./06-Declarations.md#function-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [函数签名](./06-Declarations.md#function-signature) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [函数体](./06-Declarations.md#function-body)可选 > -> *函数头* → [特性](./07_Attributes.md#attributes)可选 [声明描述符集](./06_Declarations.md#declaration_specifiers)可选 **func** +> *函数头* → [特性](./07_Attributes.md#attributes)可选 [声明描述符集](./06-Declarations.md#declaration-specifiers)可选 **func** > -> *函数名* → [标识符](./02_Lexical_Structure.md#identifier) | [运算符](./02_Lexical_Structure.md#operator) +> *函数名* → [标识符](./02_Lexical_Structure.md#identifier) | [运算符](./02-Lexical-Structure.md#operator) > -> *函数签名* → [参数子句](./06_Declarations.md#parameter_clause) **throws**可选 [函数结果](./06_Declarations.md#function_result)可选 +> *函数签名* → [参数子句](./06_Declarations.md#parameter-clause) **throws**可选 [函数结果](./06-Declarations.md#function-result)可选 > -> *函数签名* → [参数子句](./06_Declarations.md#parameter_clause) **rethrows** [函数结果](./06_Declarations.md#function_result)可选 +> *函数签名* → [参数子句](./06_Declarations.md#parameter-clause) **rethrows** [函数结果](./06-Declarations.md#function-result)可选 > -> *函数结果* → **->** [特性](./07_Attributes.md#attributes)可选 [类型](./03_Types.md#type) +> *函数结果* → **->** [特性](./07_Attributes.md#attributes)可选 [类型](./03-Types.md#type) > -> *函数体* → [代码块](./06_Declarations.md#code_block) +> *函数体* → [代码块](./06_Declarations.md#code-block) > -> *参数子句* → **(** **)** | **(** [参数集](./06_Declarations.md#parameter_list) **)** +> *参数子句* → **(** **)** | **(** [参数集](./06_Declarations.md#parameter-list) **)** > -> *参数集* → [参数](./06_Declarations.md#parameter) | [参数](./06_Declarations.md#parameter) **,** [参数集](./06_Declarations.md#parameter_list) +> *参数集* → [参数](./06_Declarations.md#parameter) | [参数](./06-Declarations.md#parameter) **,** [参数集](./06-Declarations.md#parameter-list) > -> *参数* → [外部参数名](./06_Declarations.md#parameter_name)可选 [本地参数名](./06_Declarations.md#local_parameter_name) [类型注解](./03_Types.md#type_annotation) [默认参数子句](./06_Declarations.md#default_argument_clause)可选 +> *参数* → [外部参数名](./06_Declarations.md#parameter-name)可选 [本地参数名](./06-Declarations.md#local-parameter-name) [类型注解](./03-Types.md#type-annotation) [默认参数子句](./06-Declarations.md#default-argument-clause)可选 > -> *参数* → [外部参数名](./06_Declarations.md#parameter_name)可选 [本地参数名](./06_Declarations.md#local_parameter_name) [类型注解](./03_Types.md#type_annotation) +> *参数* → [外部参数名](./06_Declarations.md#parameter-name)可选 [本地参数名](./06-Declarations.md#local-parameter-name) [类型注解](./03-Types.md#type-annotation) > -> *参数* → [外部参数名](./06_Declarations.md#parameter_name)可选 [本地参数名](./06_Declarations.md#local_parameter_name) [类型注解](./03_Types.md#type_annotation) **...** +> *参数* → [外部参数名](./06_Declarations.md#parameter-name)可选 [本地参数名](./06-Declarations.md#local-parameter-name) [类型注解](./03-Types.md#type-annotation) **...** > > *外部参数名* → [标识符](./02_Lexical_Structure.md#identifier) > @@ -1270,211 +1270,211 @@ > 枚举声明语法 > -> *枚举声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 [联合式枚举](./06_Declarations.md#union_style_enum) +> *枚举声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 [联合式枚举](./06-Declarations.md#union-style-enum) > -> *枚举声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 [原始值式枚举](./06_Declarations.md#raw-value-style-enum) +> *枚举声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 [原始值式枚举](./06-Declarations.md#raw-value-style-enum) > -> *联合式枚举* → **indirect**可选 **enum** [枚举名](./06_Declarations.md#enum_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type-inheritance-clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 **{** [联合式枚举成员](./06_Declarations.md#union_style_enum_members)可选 **}** +> *联合式枚举* → **indirect**可选 **enum** [枚举名](./06_Declarations.md#enum-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [类型继承子句](./03-Types.md#type-inheritance-clause)可选 [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 **{** [联合式枚举成员](./06-Declarations.md#union-style-enum-members)可选 **}** > -> *联合式枚举成员集* → [联合式枚举成员](./06_Declarations.md#union_style_enum_member) [联合样式枚举成员集](./06_Declarations.md#union_style_enum_members)可选 +> *联合式枚举成员集* → [联合式枚举成员](./06_Declarations.md#union-style-enum-member) [联合样式枚举成员集](./06-Declarations.md#union-style-enum-members)可选 > -> *联合样式枚举成员* → [声明](./06_Declarations.md#declaration) | [联合式枚举 case 子句](./06_Declarations.md#union_style_enum_case_clause) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> *联合样式枚举成员* → [声明](./06_Declarations.md#declaration) | [联合式枚举 case 子句](./06-Declarations.md#union-style-enum-case-clause) | [编译控制语句](./05-Statements.md#compiler-control-statement) > -> *联合式枚举 case 子句* → [特性](./07_Attributes.md#attributes)可选 **indirect**可选 **case** [联合式枚举 case 集](./06_Declarations.md#union_style_enum_case_list) +> *联合式枚举 case 子句* → [特性](./07_Attributes.md#attributes)可选 **indirect**可选 **case** [联合式枚举 case 集](./06-Declarations.md#union-style-enum-case-list) > -> *联合式枚举 case 集* → [联合式枚举 case](./06_Declarations.md#union_style_enum_case) | [联合式枚举 case](./06_Declarations.md#union_style_enum_case) **,** [联合式枚举 case 集](./06_Declarations.md#union_style_enum_case_list) +> *联合式枚举 case 集* → [联合式枚举 case](./06_Declarations.md#union-style-enum-case) | [联合式枚举 case](./06-Declarations.md#union-style-enum-case) **,** [联合式枚举 case 集](./06-Declarations.md#union-style-enum-case-list) > -> *联合式枚举 case* → [枚举的 case 名](./06_Declarations.md#enum_case_name) [元组类型](./03_Types.md#tuple_type)可选 +> *联合式枚举 case* → [枚举的 case 名](./06_Declarations.md#enum-case-name) [元组类型](./03-Types.md#tuple-type)可选 > > *枚举名* → [标识符](./02_Lexical_Structure.md#identifier) > > *枚举的 case 名* → [标识符](./02_Lexical_Structure.md#identifier) > -> *原始值式枚举* → **enum** [枚举名](./06_Declarations.md#enum_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type-inheritance-clause) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 **{** [原始值式枚举成员集](./06_Declarations.md#raw_value_style_enum_members) **}** +> *原始值式枚举* → **enum** [枚举名](./06_Declarations.md#enum-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [类型继承子句](./03-Types.md#type-inheritance-clause) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 **{** [原始值式枚举成员集](./06-Declarations.md#raw-value-style-enum-members) **}** > -> *原始值式枚举成员集* → [原始值式枚举成员](./06_Declarations.md#raw_value_style_enum_member) [原始值式枚举成员集](./06_Declarations.md#raw_value_style_enum_members)可选 +> *原始值式枚举成员集* → [原始值式枚举成员](./06_Declarations.md#raw-value-style-enum-member) [原始值式枚举成员集](./06-Declarations.md#raw-value-style-enum-members)可选 > -> *原始值式枚举成员* → [声明](./06_Declarations.md#declaration) | [原始值式枚举 case 子句](./06_Declarations.md#raw_value_style_enum_case_clause) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> *原始值式枚举成员* → [声明](./06_Declarations.md#declaration) | [原始值式枚举 case 子句](./06-Declarations.md#raw-value-style-enum-case-clause) | [编译控制语句](./05-Statements.md#compiler-control-statement) > -> *原始值式枚举 case 子句* → [特性](./07_Attributes.md#attributes)可选 **case** [原始值式枚举 case 集](./06_Declarations.md#raw_value_style_enum_case_list) +> *原始值式枚举 case 子句* → [特性](./07_Attributes.md#attributes)可选 **case** [原始值式枚举 case 集](./06-Declarations.md#raw-value-style-enum-case-list) > -> *原始值式枚举 case 集* → [原始值式枚举 case](./06_Declarations.md#raw_value_style_enum_case) | [原始值式枚举 case](./06_Declarations.md#raw_value_style_enum_case) **,** [原始值式枚举 case 集](./06_Declarations.md#raw_value_style_enum_case_list) +> *原始值式枚举 case 集* → [原始值式枚举 case](./06_Declarations.md#raw-value-style-enum-case) | [原始值式枚举 case](./06-Declarations.md#raw-value-style-enum-case) **,** [原始值式枚举 case 集](./06-Declarations.md#raw-value-style-enum-case-list) > -> *原始值式枚举 case* → [枚举的 case 名](./06_Declarations.md#enum_case_name) [原始值赋值](./06_Declarations.md#raw_value_assignment)可选 +> *原始值式枚举 case* → [枚举的 case 名](./06_Declarations.md#enum-case-name) [原始值赋值](./06-Declarations.md#raw-value-assignment)可选 > > *原始值赋值* → **=** [原始值字面量](./02_Lexical_Structure.md#literal) > -> *原始值字面量（raw-value-literal）* → [数值字面量](./02_Lexical_Structure.md#literal) | [静态字符串字面量](./02_Lexical_Structure.md#literal) | [布尔字面量](./02_Lexical_Structure.md#literal) +> *原始值字面量（raw-value-literal）* → [数值字面量](./02_Lexical_Structure.md#literal) | [静态字符串字面量](./02-Lexical-Structure.md#literal) | [布尔字面量](./02-Lexical-Structure.md#literal) > > 结构体声明语法 > -> *结构体声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **struct** [结构体名称](./06_Declarations.md#struct_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [结构体主体](./06_Declarations.md#struct_body) +> *结构体声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 **struct** [结构体名称](./06-Declarations.md#struct-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [类型继承子句](./03-Types.md#type-inheritance-clause)可选 [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [结构体主体](./06-Declarations.md#struct-body) > > *结构体名称* → [标识符](./02_Lexical_Structure.md#identifier) > > *结构体主体* → **{** [结构体成员集](./06_Declarations.md#declarations)可选 **}** > -> *结构体成员集* → [结构体成员](./06_Declarations.md#declarations) [结构体成员集](./06_Declarations.md#declarations)可选 +> *结构体成员集* → [结构体成员](./06_Declarations.md#declarations) [结构体成员集](./06-Declarations.md#declarations)可选 > -> *结构体成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> *结构体成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05-Statements.md#compiler-control-statement) > > 类声明语法 > -> *类声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **final**可选 **class** [类名](./06_Declarations.md#class_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type_inheritance_clause) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [类主体](./06_Declarations.md#class_body) +> *类声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 **final**可选 **class** [类名](./06-Declarations.md#class-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [类型继承子句](./03-Types.md#type-inheritance-clause) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [类主体](./06-Declarations.md#class-body) > -> *类声明* → [特性](./07_Attributes.md#attributes)可选 **final** [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **class** [类名](./06_Declarations.md#class_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [类型继承子句](./03_Types.md#type_inheritance_clause) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [类主体](./06_Declarations.md#class_body) +> *类声明* → [特性](./07_Attributes.md#attributes)可选 **final** [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 **class** [类名](./06-Declarations.md#class-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [类型继承子句](./03-Types.md#type-inheritance-clause) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [类主体](./06-Declarations.md#class-body) > > *类名* → [标识符](./02_Lexical_Structure.md#identifier) > > *类主体* → **{** [类成员集](./06_Declarations.md#declarations)可选 **}** > -> *类成员集* → [类成员](./06_Declarations.md#declarations) [类成员集](./06_Declarations.md#declarations)可选 +> *类成员集* → [类成员](./06_Declarations.md#declarations) [类成员集](./06-Declarations.md#declarations)可选 > -> *类成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> *类成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05-Statements.md#compiler-control-statement) > > 协议声明语法 > -> *协议声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **protocol** [协议名](./06_Declarations.md#protocol_name) [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [协议主体](./06_Declarations.md#protocol_body) +> *协议声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 **protocol** [协议名](./06-Declarations.md#protocol-name) [类型继承子句](./03-Types.md#type-inheritance-clause)可选 [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [协议主体](./06-Declarations.md#protocol-body) > > *协议名* → [标识符](./02_Lexical_Structure.md#identifier) > -> *协议主体* → **{** [协议成员集](./06_Declarations.md#protocol_member_declarations)可选 **}** +> *协议主体* → **{** [协议成员集](./06_Declarations.md#protocol-member-declarations)可选 **}** > -> *协议成员集* → [协议成员](./06_Declarations.md#declarations) [协议成员集](./06_Declarations.md#declarations)可选 +> *协议成员集* → [协议成员](./06_Declarations.md#declarations) [协议成员集](./06-Declarations.md#declarations)可选 > -> *协议成员* → [协议成员声明](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> *协议成员* → [协议成员声明](./06_Declarations.md#declarations) | [编译控制语句](./05-Statements.md#compiler-control-statement) > -> *协议成员声明* → [协议属性声明](./06_Declarations.md#protocol_property_declaration) +> *协议成员声明* → [协议属性声明](./06_Declarations.md#protocol-property-declaration) > -> *协议成员声明* → [协议方法声明](./06_Declarations.md#protocol_method_declaration) +> *协议成员声明* → [协议方法声明](./06_Declarations.md#protocol-method-declaration) > -> *协议成员声明* → [协议构造器声明](./06_Declarations.md#protocol_initializer_declaration) +> *协议成员声明* → [协议构造器声明](./06_Declarations.md#protocol-initializer-declaration) > -> *协议成员声明* → [协议下标声明](./06_Declarations.md#protocol_subscript_declaration) +> *协议成员声明* → [协议下标声明](./06_Declarations.md#protocol-subscript-declaration) > -> *协议成员声明* → [协议关联类型声明](./06_Declarations.md#protocol_associated_type_declaration) +> *协议成员声明* → [协议关联类型声明](./06_Declarations.md#protocol-associated-type-declaration) > -> *协议成员声明* → [类型别名声明](./06_Declarations.md#typealias_declaration) +> *协议成员声明* → [类型别名声明](./06_Declarations.md#typealias-declaration) > > 协议属性声明语法 > -> *协议属性声明* → [变量声明头](./06_Declarations.md#variable_declaration_head) [变量名](./06_Declarations.md#variable_name) [类型注解](./03_Types.md#type_annotation) [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> *协议属性声明* → [变量声明头](./06_Declarations.md#variable-declaration-head) [变量名](./06-Declarations.md#variable-name) [类型注解](./03-Types.md#type-annotation) [getter-setter 关键字块](./06-Declarations.md#getter-setter-keyword-block) > > 协议方法声明语法 > -> *协议方法声明* → [函数头](./06_Declarations.md#function_head) [函数名](./06_Declarations.md#function_name) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [函数签名](./06_Declarations.md#function_signature) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> *协议方法声明* → [函数头](./06_Declarations.md#function-head) [函数名](./06-Declarations.md#function-name) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [函数签名](./06-Declarations.md#function-signature) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > > 协议构造器声明语法 > -> *协议构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **throws**可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> *协议构造器声明* → [构造器头](./06_Declarations.md#initializer-head) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [参数子句](./06-Declarations.md#parameter-clause) **throws**可选 [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > -> *协议构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **rethrows** [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> *协议构造器声明* → [构造器头](./06_Declarations.md#initializer-head) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [参数子句](./06-Declarations.md#parameter-clause) **rethrows** [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > > 协议下标声明语法 > -> *协议下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> *协议下标声明* → [下标头](./06_Declarations.md#subscript-head) [下标结果](./06-Declarations.md#subscript-result) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [getter-setter 关键字块](./06-Declarations.md#getter-setter-keyword-block) > > 协议关联类型声明语法 > -> *协议关联类型声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **associatedtype** [类型别名](./06_Declarations.md#typealias_name) [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [类型别名赋值](./06_Declarations.md#typealias_assignment)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 +> *协议关联类型声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 **associatedtype** [类型别名](./06-Declarations.md#typealias-name) [类型继承子句](./03-Types.md#type-inheritance-clause)可选 [类型别名赋值](./06-Declarations.md#typealias-assignment)可选 [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 > > 构造器声明语法 > -> *构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **throws**可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [构造器主体](./06_Declarations.md#initializer_body) +> *构造器声明* → [构造器头](./06_Declarations.md#initializer-head) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [参数子句](./06-Declarations.md#parameter-clause) **throws**可选 [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [构造器主体](./06-Declarations.md#initializer-body) > -> *构造器声明* → [构造器头](./06_Declarations.md#initializer_head) [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) **rethrows** [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [构造器主体](./06_Declarations.md#initializer_body) +> *构造器声明* → [构造器头](./06_Declarations.md#initializer-head) [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [参数子句](./06-Declarations.md#parameter-clause) **rethrows** [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [构造器主体](./06-Declarations.md#initializer-body) > -> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **init** +> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06-Declarations.md#declaration-modifiers)可选 **init** > -> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **init ?** +> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06-Declarations.md#declaration-modifiers)可选 **init ?** > -> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **init !** +> *构造器头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06-Declarations.md#declaration-modifiers)可选 **init !** > -> *构造器主体* → [代码块](./06_Declarations.md#code_block) +> *构造器主体* → [代码块](./06_Declarations.md#code-block) > > 析构器声明语法 > -> *析构器声明* → [特性](./07_Attributes.md#attributes)可选 **deinit** [代码块](./06_Declarations.md#code_block) +> *析构器声明* → [特性](./07_Attributes.md#attributes)可选 **deinit** [代码块](./06-Declarations.md#code-block) > > 扩展声明语法 > -> *扩展声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07_Attributes.md#access-level-modifier)可选 **extension** [类型标识](./03_Types.md#type_identifier) [类型继承子句](./03_Types.md#type_inheritance_clause)可选 [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [扩展主体](./06_Declarations.md#extension_body) +> *扩展声明* → [特性](./07_Attributes.md#attributes)可选 [访问级别修饰符](./07-Attributes.md#access-level-modifier)可选 **extension** [类型标识](./03-Types.md#type-identifier) [类型继承子句](./03-Types.md#type-inheritance-clause)可选 [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [扩展主体](./06-Declarations.md#extension-body) > > *扩展主体* → **{** [扩展成员集](./06_Declarations.md#declarations)可选 **}** > -> *扩展成员集* → [扩展成员](./06_Declarations.md#declarations) [扩展成员集](./06_Declarations.md#declarations)可选 +> *扩展成员集* → [扩展成员](./06_Declarations.md#declarations) [扩展成员集](./06-Declarations.md#declarations)可选 > -> *扩展成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05_Statements.md#compiler-control-statement) +> *扩展成员* → [声明集](./06_Declarations.md#declarations) | [编译控制语句](./05-Statements.md#compiler-control-statement) > > 下标声明语法 > -> *下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [代码块](./06_Declarations.md#code_block) +> *下标声明* → [下标头](./06_Declarations.md#subscript-head) [下标结果](./06-Declarations.md#subscript-result) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [代码块](./06-Declarations.md#code-block) > -> *下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [getter-setter 块](./06_Declarations.md#getter_setter_block) +> *下标声明* → [下标头](./06_Declarations.md#subscript-head) [下标结果](./06-Declarations.md#subscript-result) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [getter-setter 块](./06-Declarations.md#getter-setter-block) > -> *下标声明* → [下标头](./06_Declarations.md#subscript_head) [下标结果](./06_Declarations.md#subscript_result) [泛型 where 子句](./09_Generic_Parameters_and_Arguments.md#generic_where_clause)可选 [getter-setter 关键字块](./06_Declarations.md#getter_setter_keyword_block) +> *下标声明* → [下标头](./06_Declarations.md#subscript-head) [下标结果](./06-Declarations.md#subscript-result) [泛型 where 子句](./09-Generic-Parameters-and-Arguments.md#generic-where-clause)可选 [getter-setter 关键字块](./06-Declarations.md#getter-setter-keyword-block) > -> *下标头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 **subscript** [泛型参数子句](./09_Generic_Parameters_and_Arguments.md#generic_parameter_clause)可选 [参数子句](./06_Declarations.md#parameter_clause) +> *下标头（Head）* → [特性](./07_Attributes.md#attributes)可选 [声明修饰符集](./06-Declarations.md#declaration-modifiers)可选 **subscript** [泛型参数子句](./09-Generic-Parameters-and-Arguments.md#generic-parameter-clause)可选 [参数子句](./06-Declarations.md#parameter-clause) > -> *下标结果（Result）* → **->** [特性](./07_Attributes.md#attributes)可选 [类型](./03_Types.md#type) +> *下标结果（Result）* → **->** [特性](./07_Attributes.md#attributes)可选 [类型](./03-Types.md#type) > > 运算符声明语法 > -> *运算符声明* → [前置运算符声明](./06_Declarations.md#prefix_operator_declaration) | [后置运算符声明](./06_Declarations.md#postfix_operator_declaration) | [中置运算符声明](./06_Declarations.md#infix_operator_declaration) +> *运算符声明* → [前置运算符声明](./06_Declarations.md#prefix-operator-declaration) | [后置运算符声明](./06-Declarations.md#postfix-operator-declaration) | [中置运算符声明](./06-Declarations.md#infix-operator-declaration) > > *前置运算符声明* → **prefix** **operator** [运算符](./02_Lexical_Structure.md#operator) > > *后置运算符声明* → **postfix** **operator** [运算符](./02_Lexical_Structure.md#operator) > -> *中置运算符声明* → **infix** **operator** [运算符](./02_Lexical_Structure.md#operator) [中置运算符特性](./06_Declarations.md#infix_operator_attributes)可选 +> *中置运算符声明* → **infix** **operator** [运算符](./02_Lexical_Structure.md#operator) [中置运算符特性](./06-Declarations.md#infix-operator-attributes)可选 > -> *中置运算符特性* → [优先级组名](./06_Declarations.md#precedence_group_name) +> *中置运算符特性* → [优先级组名](./06_Declarations.md#precedence-group-name) > > 优先级组声明语法 > -> *优先级组声明* → **precedencegroup** [优先级组名](./06_Declarations.md#precedence_group_name) **{** [优先级组特性](./06_Declarations.md#precedence_group_attributes)可选 **}** +> *优先级组声明* → **precedencegroup** [优先级组名](./06_Declarations.md#precedence-group-name) **{** [优先级组特性](./06-Declarations.md#precedence-group-attributes)可选 **}** > -> *优先级组特性* → [优先级组属性](./06_Declarations.md#declarations) [优先级组特性](./06_Declarations.md#declarations)可选 +> *优先级组特性* → [优先级组属性](./06_Declarations.md#declarations) [优先级组特性](./06-Declarations.md#declarations)可选 > > *优先级组属性* → [优先级组关系](./06_Declarations.md#declarations) > @@ -1486,7 +1486,7 @@ > > *优先级组关系* → **lowerThan :** [优先级组名集](./06_Declarations.md#declarations) > -> *优先级组赋值* → **assignment :** [布尔字面量](./02_Lexical_Structure.md#string_literal) +> *优先级组赋值* → **assignment :** [布尔字面量](./02_Lexical_Structure.md#string-literal) > > *优先级组结合* → **associativity : left** > @@ -1494,7 +1494,7 @@ > > *优先级组结合* → **associativity : none** > -> *优先级组名集* → [优先级组名](./06_Declarations.md#declarations) | [优先级组名](./06_Declarations.md#declarations) **,** [优先级组名集](./06_Declarations.md#declarations) +> *优先级组名集* → [优先级组名](./06_Declarations.md#declarations) | [优先级组名](./06-Declarations.md#declarations) **,** [优先级组名集](./06-Declarations.md#declarations) > > *优先级组名* → [标识符](./02_Lexical_Structure.md#identifier) > @@ -1508,7 +1508,7 @@ > > *声明修饰符* → [可变性修饰符](./07_Attributes.md#mutation-modifier) > -> *声明修饰符集* → [声明修饰符](./06_Declarations.md#declaration_modifier) [声明修饰符集](./06_Declarations.md#declaration_modifiers)可选 +> *声明修饰符集* → [声明修饰符](./06_Declarations.md#declaration-modifier) [声明修饰符集](./06-Declarations.md#declaration-modifiers)可选 > > *访问级别修饰符* → **private** | **private(set)** > @@ -1527,21 +1527,21 @@ > 属性语法 > -> *属性* → **@** [属性名](./07_Attributes.md#attribute_name) [属性参数子句](./07_Attributes.md#attribute_argument_clause)可选 +> *属性* → **@** [属性名](./07_Attributes.md#attribute-name) [属性参数子句](./07-Attributes.md#attribute-argument-clause)可选 > > *属性名* → [标识符](./02_Lexical_Structure.md#identifier) > -> *属性参数子句* → **{** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **}** +> *属性参数子句* → **{** [平衡令牌集](./07_Attributes.md#balanced-tokens)可选 **}** > -> *属性（Attributes）集* → [属性](./07_Attributes.md#attribute) [特性](./07_Attributes.md#attributes)可选 +> *属性（Attributes）集* → [属性](./07_Attributes.md#attribute) [特性](./07-Attributes.md#attributes)可选 > -> *平衡令牌集* → [平衡令牌](./07_Attributes.md#balanced_token) [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 +> *平衡令牌集* → [平衡令牌](./07_Attributes.md#balanced-token) [平衡令牌集](./07-Attributes.md#balanced-tokens)可选 > -> *平衡令牌* → **(** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **)** +> *平衡令牌* → **(** [平衡令牌集](./07_Attributes.md#balanced-tokens)可选 **)** > -> *平衡令牌* → **[** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **]** +> *平衡令牌* → **[** [平衡令牌集](./07_Attributes.md#balanced-tokens)可选 **]** > -> *平衡令牌* → **{** [平衡令牌集](./07_Attributes.md#balanced_tokens)可选 **}** +> *平衡令牌* → **{** [平衡令牌集](./07_Attributes.md#balanced-tokens)可选 **}** > > *平衡令牌* → 任意标识符、关键字、字面量或运算符 > @@ -1553,21 +1553,21 @@ > 模式语法 > -> *模式* → [通配符模式](./08_Patterns.md#wildcard_pattern) [类型注解](./03_Types.md#type_annotation)可选 +> *模式* → [通配符模式](./08_Patterns.md#wildcard-pattern) [类型注解](./03-Types.md#type-annotation)可选 > -> *模式* → [标识符模式](./08_Patterns.md#identifier_pattern) [类型注解](./03_Types.md#type_annotati Value Bindingon )可选 +> *模式* → [标识符模式](./08_Patterns.md#identifier-pattern) [类型注解](./03-Types.md#type-annotati Value Bindingon )可选 > -> *模式* → [值绑定模式](./08_Patterns.md#value_binding_pattern) +> *模式* → [值绑定模式](./08_Patterns.md#value-binding-pattern) > -> *模式* → [元组模式](./08_Patterns.md#tuple_pattern) [类型注解](./03_Types.md#type_annotation)可选 +> *模式* → [元组模式](./08_Patterns.md#tuple-pattern) [类型注解](./03-Types.md#type-annotation)可选 > -> *模式* → [枚举 case 模式](./08_Patterns.md#enum_case_pattern) +> *模式* → [枚举 case 模式](./08_Patterns.md#enum-case-pattern) > -> *模式* → [可选模式](./08_Patterns.md#optional_pattern) +> *模式* → [可选模式](./08_Patterns.md#optional-pattern) > -> *模式* → [类型转换模式](./08_Patterns.md#type_casting_pattern) +> *模式* → [类型转换模式](./08_Patterns.md#type-casting-pattern) > -> *模式* → [表达式模式](./08_Patterns.md#expression_pattern) +> *模式* → [表达式模式](./08_Patterns.md#expression-pattern) > @@ -1588,25 +1588,25 @@ > 值绑定模式语法 > -> *值绑定模式* → **var** [模式](./08_Patterns.md#pattern) | **let** [模式](./08_Patterns.md#pattern) +> *值绑定模式* → **var** [模式](./08_Patterns.md#pattern) | **let** [模式](./08-Patterns.md#pattern) > > 元组模式语法 > -> *元组模式* → **(** [元组模式元素集](./08_Patterns.md#tuple_pattern_element_list)可选 **)** +> *元组模式* → **(** [元组模式元素集](./08_Patterns.md#tuple-pattern-element-list)可选 **)** > -> *元组模式元素集* → [元组模式元素](./08_Patterns.md#tuple_pattern_element) | [元组模式元素](./08_Patterns.md#tuple_pattern_element) **,** [元组模式元素集](./08_Patterns.md#tuple_pattern_element_list) +> *元组模式元素集* → [元组模式元素](./08_Patterns.md#tuple-pattern-element) | [元组模式元素](./08-Patterns.md#tuple-pattern-element) **,** [元组模式元素集](./08-Patterns.md#tuple-pattern-element-list) > -> *元组模式元素* → [模式](./08_Patterns.md#pattern) | [标识符](./02_Lexical_Structure.md#identifier) **:** [模式](./08_Patterns.md#pattern) +> *元组模式元素* → [模式](./08_Patterns.md#pattern) | [标识符](./02-Lexical-Structure.md#identifier) **:** [模式](./08-Patterns.md#pattern) > > 枚举 case 模式语法 > -> *enum-case-pattern* → [类型标识](./03_Types.md#type_identifier)可选 **.** [枚举 case 名](./06_Declarations.md#enum_case_name) [元组模式](./08_Patterns.md#tuple_pattern)可选 +> *enum-case-pattern* → [类型标识](./03_Types.md#type-identifier)可选 **.** [枚举 case 名](./06-Declarations.md#enum-case-name) [元组模式](./08-Patterns.md#tuple-pattern)可选 > @@ -1619,11 +1619,11 @@ > 类型转换模式语法 > -> *类型转换模式* → [is 模式](./08_Patterns.md#is_pattern) | [as 模式](./08_Patterns.md#as_pattern) +> *类型转换模式* → [is 模式](./08_Patterns.md#is-pattern) | [as 模式](./08-Patterns.md#as-pattern) > > *is 模式* → **is** [类型](./03_Types.md#type) > -> *as 模式* → [模式](./08_Patterns.md#pattern) **as** [类型](./03_Types.md#type) +> *as 模式* → [模式](./08_Patterns.md#pattern) **as** [类型](./03-Types.md#type) > @@ -1638,32 +1638,32 @@ > 泛型形参子句语法 > > -> *泛型参数子句* → **<** [泛型参数集](./09_Generic_Parameters_and_Arguments.md#generic_parameter_list) **>** +> *泛型参数子句* → **<** [泛型参数集](./09_Generic_Parameters_and_Arguments.md#generic-parameter-list) **>** > -> *泛型参数集* → [泛型参数](./09_Generic_Parameters_and_Arguments.md#generic_parameter) | [泛形参数](./09_Generic_Parameters_and_Arguments.md#generic_parameter) **,** [泛型参数集](./09_Generic_Parameters_and_Arguments.md#generic_parameter_list) +> *泛型参数集* → [泛型参数](./09_Generic_Parameters_and_Arguments.md#generic-parameter) | [泛形参数](./09-Generic-Parameters-and-Arguments.md#generic-parameter) **,** [泛型参数集](./09-Generic-Parameters-and-Arguments.md#generic-parameter-list) > -> *泛形参数* → [类型名称](./03_Types.md#type_name) +> *泛形参数* → [类型名称](./03_Types.md#type-name) > -> *泛形参数* → [类型名称](./03_Types.md#type_name) **:** [类型标识](./03_Types.md#type_identifier) +> *泛形参数* → [类型名称](./03_Types.md#type-name) **:** [类型标识](./03-Types.md#type-identifier) > -> *泛形参数* → [类型名称](./03_Types.md#type_name) **:** [协议合成类型](./03_Types.md#protocol_composition_type) +> *泛形参数* → [类型名称](./03_Types.md#type-name) **:** [协议合成类型](./03-Types.md#protocol-composition-type) > -> *泛型 where 子句* → **where** [约束集](./09_Generic_Parameters_and_Arguments.md#requirement_list) +> *泛型 where 子句* → **where** [约束集](./09_Generic_Parameters_and_Arguments.md#requirement-list) > -> *约束集* → [约束](./09_Generic_Parameters_and_Arguments.md#requirement) | [约束](./09_Generic_Parameters_and_Arguments.md#requirement) **,** [约束集](./09_Generic_Parameters_and_Arguments.md#requirement_list) +> *约束集* → [约束](./09_Generic_Parameters_and_Arguments.md#requirement) | [约束](./09-Generic-Parameters-and-Arguments.md#requirement) **,** [约束集](./09-Generic-Parameters-and-Arguments.md#requirement-list) > -> *约束* → [一致性约束](./09_Generic_Parameters_and_Arguments.md#conformance_requirement) | [同类型约束](./09_Generic_Parameters_and_Arguments.md#same_type_requirement) +> *约束* → [一致性约束](./09_Generic_Parameters_and_Arguments.md#conformance-requirement) | [同类型约束](./09-Generic-Parameters-and-Arguments.md#same-type-requirement) > -> *一致性约束* → [类型标识](./03_Types.md#type_identifier) **:** [类型标识](./03_Types.md#type_identifier) +> *一致性约束* → [类型标识](./03_Types.md#type-identifier) **:** [类型标识](./03-Types.md#type-identifier) > -> *一致性约束* → [类型标识](./03_Types.md#type_identifier) **:** [协议合成类型](./03_Types.md#protocol_composition_type) +> *一致性约束* → [类型标识](./03_Types.md#type-identifier) **:** [协议合成类型](./03-Types.md#protocol-composition-type) > -> *同类型约束* → [类型标识](./03_Types.md#type_identifier) **==** [类型](./03_Types.md#type_identifier) +> *同类型约束* → [类型标识](./03_Types.md#type-identifier) **==** [类型](./03-Types.md#type-identifier) > > 泛型实参子句语法 > > *泛型实参子句* → **<** [泛型实参集](./09_Generic_Parameters_and_Arguments.md#generic-argument-list) **>** > -> *泛型实参集* → [泛型实参](./09_Generic_Parameters_and_Arguments.md#generic_argument) | [泛形实参](./09_Generic_Parameters_and_Arguments.md#generic_argument) **,** [泛型实参集](./09_Generic_Parameters_and_Arguments.md#generic-argument-list) +> *泛型实参集* → [泛型实参](./09_Generic_Parameters_and_Arguments.md#generic-argument) | [泛形实参](./09-Generic-Parameters-and-Arguments.md#generic-argument) **,** [泛型实参集](./09-Generic-Parameters-and-Arguments.md#generic-argument-list) > > *泛形实参* → [类型](./03_Types.md#type) \ No newline at end of file diff --git a/source/04_revision_history/04_revision_history.md b/source/04_revision_history/04_revision_history.md index 3a857ea6..c3e398d5 100644 --- a/source/04_revision_history/04_revision_history.md +++ b/source/04_revision_history/04_revision_history.md @@ -4,7 +4,7 @@ * 更新至 Swift 5.1。 * 在 [不透明类型](../02_language_guide/23_Opaque_Types.md) 篇章中新增了有关函数返回值遵循指定协议，而不需要提供指定返回类型的内容。 -* 新增 [隐式返回的函数](../02_language_guide/06_Functions.md#functions-with-an-implicit-return) 和 [简化 Getter 声明](../02_language_guide/10_Properties.md#shorthand-getter-declaration) 章节，其中包含函数省略 `return` 的内容。 +* 新增 [隐式返回的函数](../02_language_guide/06_Functions.md#functions-with-an-implicit-return) 和 [简化 Getter 声明](../02-language-guide/10-Properties.md#shorthand-getter-declaration) 章节，其中包含函数省略 `return` 的内容。 * 在 [类型下标](../02_language_guide/12_Subscripts.md#type-subscripts) 章节中新增有关在类型中使用下标的内容。 * 更新 [结构体的逐一成员构造器](../02_language_guide/14_Initialization.md#memberwise-initializers-for-structure-types) 章节，现在逐一成员构造器支持在属性有默认值时省略形参。 * 在 [动态查找成员](../03_language_reference/07_Attributes.md#dynamicmemberlookup) 章节中新增了有关在运行时用 key path 查找动态成员的内容。 @@ -13,9 +13,9 @@ ### 2019-03-25 * 更新至 Swift 5。 -* 新增 [拓展字符串分隔符](../02_language_guide/03_Strings_And_Characters.md#extended-string-delimiters) 章节。更新 [字符串字面量](../03_language_reference/03_Lexical_Structure.md#string-literal) 章节，拓展有关字符串分隔符的内容。 +* 新增 [拓展字符串分隔符](../02_language_guide/03_Strings_And_Characters.md#extended-string-delimiters) 章节。更新 [字符串字面量](../03-language-reference/03-Lexical-Structure.md#string-literal) 章节，拓展有关字符串分隔符的内容。 * 新增 [动态调用](../03_language_reference/07_Attributes.md#dynamiccallable) 章节，其中包含使用 `dynamicCallable` 属性动态调用实例作为函数的内容。 -* 新增 [unknown](../03_language_reference/07_Attributes.md#unknown) 和 [未来枚举匹配](../03_language_reference/05_Statements.md#future-case2) 章节，其中包含了使用 `unknown` 来处理未来枚举可能发生改变的情形。 +* 新增 [unknown](../03_language_reference/07_Attributes.md#unknown) 和 [未来枚举匹配](../03-language-reference/05-Statements.md#future-case2) 章节，其中包含了使用 `unknown` 来处理未来枚举可能发生改变的情形。 * 在 [Key-Path 表达式](../03_language_reference/04_Expressions.md#key-path-expression) 章节新增了有关标示 key path (\\.self) 的内容。 * 在 [可选编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了有关小于比较符 `<` 的内容。 @@ -25,7 +25,7 @@ * 在 [遍历枚举情形](../02_language_guide/08_Enumerations.md#iterating-over-enumeration-cases) 章节新增了有关访问所有枚举情形的内容。 * 在 [编译诊断](../03_language_reference/05_Statements.md#compile-time-diagnostic-statement) 章节新增了有关 `#error` 和 `#warning` 的内容。 * 在 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `inlinable` 和 `usableFromInline` 属性的内容。 -* 在 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `requires_stored_property_inits` 和 `warn_unqualified_access` 属性的内容。 +* 在 [属性声明](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中新增了有关 `requires-stored-property-inits` 和 `warn-unqualified-access` 属性的内容。 * 在 [可选编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了有关如何根据 Swift 编译器版本对代码进行对应编译处理的内容。 * 在 [字面量语法](../03_language_reference/04_Expressions.md#literal-expression) 章节新增了有关 `#dsohandle` 的内容。 @@ -33,7 +33,7 @@ * 更新至 Swift 4.1。 * 在 [等价运算符](../02_language_guide/27_Advanced_Operators.md#equivalence-operators) 章节新增了有关等价运算符的合成实现的内容。 -* 在 [声明](../03_language_reference/06_Declarations.md) 篇章中 [申明拓展](../03_language_reference/06_Declarations.md#extension-declaration) 章节和 [协议](../02_language_guide/21_Protocols.md) 篇章中 [有条件地遵循协议](../02_language_guide/21_Protocols.md#Conditionally-Conforming-to-a-Protocol) 章节新增了有关协议有条件遵循的内容。 +* 在 [声明](../03_language_reference/06_Declarations.md) 篇章中 [申明拓展](../03_language_reference/06_Declarations.md#extension-declaration) 章节和 [协议](../02-language-guide/21-Protocols.md) 篇章中 [有条件地遵循协议](../02-language-guide/21-Protocols.md#Conditionally-Conforming-to-a-Protocol) 章节新增了有关协议有条件遵循的内容。 * 在 [关联类型约束中使用协议](../02_language_guide/22_Generics.md#using-a-protocol-in-its-associated-types-constraints) 章节中新增了有关递归协议约束的内容。 * 在 [条件编译块](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中新增了有关 `canImport()` 和 `targetEnvironment()` 平台条件的内容。 @@ -47,10 +47,10 @@ * 更新至 Swift 4.0。 * 在 [内存安全](../02_language_guide/24_MemorySafety.md) 章节新增了有关内存互斥访问的内容。 * 新增 [带有泛型 Where 子句联类型](../02_language_guide/22_Generics.md#associated-types-with-a-generic-where-clause) 章节，现在可以使用泛型 `where` 子句约束关联类型。 -* 在 [字符串和字符](../02_language_guide/03_Strings_And_Characters.md) 篇章中 [字面量](../02_language_guide/03_Strings_And_Characters.md#string-literals) 章节以及 [词法结构](../03_language_reference/02_Lexical_Structure.md) 篇章的 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节中新增了有关多行字符串字面量的内容。 +* 在 [字符串和字符](../02_language_guide/03_Strings_And_Characters.md) 篇章中 [字面量](../02_language_guide/03_Strings_And_Characters.md#string-literals) 章节以及 [词法结构](../03-language-reference/02-Lexical-Structure.md) 篇章的 [字符串字面量](../03-language-reference/02-Lexical-Structure.md#string-literal) 章节中新增了有关多行字符串字面量的内容。 * 更新 [声明属性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 中 `objc` 属性的讨论，现在该属性会在更少的位置被推断出来。 * 新增 [范型下标](../02_language_guide/22_Generics.md#generic-subscripts) 章节，现在下标也支持范型特性了。 -* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03_language_reference/03_Types.md) 篇章中 [协议组合类型](../03_language_reference/03_Types.md#protocol-composition-type-h) 章节的讨论，现在协议组合类型支持进行父类约束了。 +* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03-language-reference/03-Types.md) 篇章中 [协议组合类型](../03-language-reference/03-Types.md#protocol-composition-type-h) 章节的讨论，现在协议组合类型支持进行父类约束了。 * 更新 [拓展声明](../03_language_reference/06_Declarations.md#extension-declaration) 中有关协议扩展的讨论，现在它们不支持 `final` 特性了。 * 在 [断言和前置条件](../02_language_guide/01_TheBasics.md#assertions-and-preconditions) 章节中新增了部分前置条件和致命错误的内容。 @@ -81,20 +81,20 @@ * 更新 [高级操作符](../02_language_guide/27_Advanced_Operators.md) 篇章中有关操作符的讨论，现在你可以作为类型函数来实现，替代之前的全局函数实现方式。 * 在 [访问控制](../02_language_guide/26_Access_Control.md) 章节中新增有关对新的访问级别描述符 `open` 和 `fileprivate` 的内容。 * 更新 [函数声明](../03_language_reference/06_Declarations.md#function-declaration) 章节中有关 `inout` 的讨论，注意它现在出现在参数类型的前面，而不是在参数名称的前面。 -* 更新 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 和 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节还有 [属性](../03_language_reference/07_Attributes.md) 篇章中有关 `@noescape` 和 `@autoclosure` 的讨论，现在他们是类型属性，而不是定义属性。 -* 在 [高级操作符](../02_language_guide/27_Advanced_Operators.md) 篇章中 [自定义中缀操作符的优先级](./02_language_guide/27_Advanced_Operators.md#precedence-and-associativity-for-custom-infix-operators) 章节和 [定义](../03_language_reference/06_Declarations.md) 篇章中 [优先级组声明](../03_language_reference/06_Declarations.md#precedence-group-declaration-modifiers) 章节中新增了有关操作符优先级组的内容。 +* 更新 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 和 [自动闭包](../02-language-guide/07-Closures.md#autoclosures) 章节还有 [属性](../03-language-reference/07-Attributes.md) 篇章中有关 `@noescape` 和 `@autoclosure` 的讨论，现在他们是类型属性，而不是定义属性。 +* 在 [高级操作符](../02_language_guide/27_Advanced_Operators.md) 篇章中 [自定义中缀操作符的优先级](./02_language_guide/27_Advanced_Operators.md#precedence-and-associativity-for-custom-infix-operators) 章节和 [定义](../03-language-reference/06-Declarations.md) 篇章中 [优先级组声明](../03-language-reference/06-Declarations.md#precedence-group-declaration-modifiers) 章节中新增了有关操作符优先级组的内容。 * 更新一些讨论，使用 macOS 替换掉 OS X， Error 替换掉 ErrorProtocol。更新一些协议名称，比如使用 ExpressibleByStringLiteral 替换掉 StringLiteralConvertible。 -* 更新 [泛型](../02_language_guide/22_Generics.md) 篇章中 [泛型 Where 语句](../02_language_guide/22_Generics.md#extensions-with-a-generic-where-clause) 章节和 [泛型形参和实参](../03_language_reference/09_Generic_Parameters_And_Arguments.md) 篇章的讨论，现在泛型的 where 语句写在一个声明的最后。 +* 更新 [泛型](../02_language_guide/22_Generics.md) 篇章中 [泛型 Where 语句](../02_language_guide/22_Generics.md#extensions-with-a-generic-where-clause) 章节和 [泛型形参和实参](../03-language-reference/09-Generic-Parameters-And-Arguments.md) 篇章的讨论，现在泛型的 where 语句写在一个声明的最后。 * 更新 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 章节中的讨论，现在闭包默认为非逃逸的。 -* 更新 [基础部分](../02_language_guide/01_TheBasics.md) 篇章中 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章中 [While 语句](../03_language_reference/05_Statements.md#while-statement) 章节中的讨论，现在 if，`while` 和 `guard` 语句使用逗号分隔条件列表，不需要使用 `where` 语句。 -* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章中 [Switch](../02_language_guide/05_Control_Flow.md#switch) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章中 [Switch 语句](../03_language_reference/05_Statements.md#switch-statement) 章节中新增了 switch cases 可以使用多模式的内容。 +* 更新 [基础部分](../02_language_guide/01_TheBasics.md) 篇章中 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding) 章节和 [语句](../03-language-reference/05-Statements.md) 篇章中 [While 语句](../03-language-reference/05-Statements.md#while-statement) 章节中的讨论，现在 if，`while` 和 `guard` 语句使用逗号分隔条件列表，不需要使用 `where` 语句。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章中 [Switch](../02_language_guide/05_Control_Flow.md#switch) 章节和 [语句](../03-language-reference/05-Statements.md) 篇章中 [Switch 语句](../03-language-reference/05-Statements.md#switch-statement) 章节中新增了 switch cases 可以使用多模式的内容。 * 更新 [函数类型](../03_language_reference/03_Types.md#function-type-h) 章节有关现在函数参数标签不包含在函数类型中的讨论。 -* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03_language_reference/03_Types.md) 篇章中 [协议组合类型](../03_language_reference/03_Types.md#protocol-composition-type-h) 章节中有关使用新的 Protocol1 & Protocol2 语法的内容。 +* 更新 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议组合](../02_language_guide/21_Protocols.md#protocol-composition) 章节和 [类型](../03-language-reference/03-Types.md) 篇章中 [协议组合类型](../03-language-reference/03-Types.md#protocol-composition-type-h) 章节中有关使用新的 Protocol1 & Protocol2 语法的内容。 * 更新动态类型表达式章节中使用新的 `type(of:)` 表达式的讨论。 * 更新 [行控制表达式](../03_language_reference/05_Statements.md#line-control-statement) 章节中使用 `#sourceLocation(file:line:)` 表达式的讨论。 * 更新 [永不返回函数](../03_language_reference/06_Declarations.md#functions-that-never-return) 章节中使用 新的 `Never` 类型的讨论。 * 在 [字面量表达式](../03_language_reference/04_Expressions.md#literal-expression) 章节中新增了有关 `playground` 字面量的内容。 -* 更新 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out_parameters) 章节，标明只有非逃逸闭包能捕获 `in-out` 参数。 +* 更新 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out-parameters) 章节，标明只有非逃逸闭包能捕获 `in-out` 参数。 * 更新 [默认参数值](../02_language_guide/06_Functions.md#default-parameter-values) 章节，现在默认参数不能在调用时候重新排序。 * 更新 [属性](../03_language_reference/07_Attributes.md) 篇章中有关属性参数使用分号的说明。 * 在 [重新抛出函数和方法](../03_language_reference/06_Declarations.md#rethrowing-functions-and-methods) 章节中新增了有关在 catch 代码块中抛出错误的重新抛出函数的内容。 @@ -114,7 +114,7 @@ * 在 [编译配置语句](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节新增了中有关如何根据 Swift 版本进行条件编译。 * 在 [显示成员表达式](../03_language_reference/04_Expressions.md#explicit-member-expression) 章节中新增了有关如何区分只有参数名不同的方法和构造器的内容。 * 在 [选择器表达式](../03_language_reference/04_Expressions.md#selector-expression7) 章节中新增了了针对 Objective-C 选择器的 `#selector` 语法。 -* 更新 [关联类型](../02_language_guide/22_Generics.md#associated-types) 和 [协议关联类型声明](../03_language_reference/06_Declarations.md#protocol_associated_type_declaration) 章节中有关使用 `associatedtype` 关键词修饰关联类型的讨论。 +* 更新 [关联类型](../02_language_guide/22_Generics.md#associated-types) 和 [协议关联类型声明](../03-language-reference/06-Declarations.md#protocol-associated-type-declaration) 章节中有关使用 `associatedtype` 关键词修饰关联类型的讨论。 * 更新 [可失败构造器](../02_language_guide/14_Initialization.md#failable-initializers) 章节中有关当构造器在实例完全初始化之前返回 `nil` 的相关内容。 * 在 [比较运算符](../02_language_guide/BasicOperators.md#comparison-operators) 章节中新增了比较元组的内容。 * 在 [关键字和标点符号](../03_language_reference/02_Lexical_Structure.md#keywords-and-punctuation) 章节中新增了使用关键字作为外部参数名的内容。 @@ -130,10 +130,10 @@ ### 2015-10-20 * 更新至 Swift 2.1。 -* 更新 [字符串插值](../02_language_guide/03_Strings_And_Characters.md#string-interpolation) 和 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节，现在字符串插值可包含字符串字面量。 +* 更新 [字符串插值](../02_language_guide/03_Strings_And_Characters.md#string-interpolation) 和 [字符串字面量](../03-language-reference/02-Lexical-Structure.md#string-literal) 章节，现在字符串插值可包含字符串字面量。 * 在 [逃逸闭包](../02_language_guide/07_Closures.md#escaping-closures) 章节中新增了有关 `@noescape` 属性的相关内容。 -* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 和 [编译配置语句](../03_language_reference/05_Statements.md#Conditional-Compilation-Block) 章节中与 tvOS 相关的内容。 -* 在 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out_parameters) 章节中新增了与 in-out 参数行为相关的内容。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 和 [编译配置语句](../03-language-reference/05-Statements.md#Conditional-Compilation-Block) 章节中与 tvOS 相关的内容。 +* 在 [In-Out 参数](../03_language_reference/06_Declarations.md#in-out-parameters) 章节中新增了与 in-out 参数行为相关的内容。 * 在 [捕获列表](../03_language_reference/04_Expressions.md#capture-lists) 章节新增了有关指定闭包捕获列表被捕获时捕获值的相关内容。 * 更新 [可选链式调用访问属性](../02_language_guide/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 章节，阐明了如何通过可选链式调用进行赋值。 * 改进 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节中对自闭包的讨论。 @@ -142,21 +142,21 @@ ### 2015-09-16 * 更新至 Swift 2.0。 -* 在 [错误处理](../02_language_guide/17_Error_Handling.md) 篇章中新增了有关错误处理的相关内容，包括 [Do 语句](../03_language_reference/05_Statements.md#do-statement)、 [Throw 语句](../03_language_reference/05_Statements.md#throw-statement)、 [Defer 语句](../03_language_reference/05_Statements.md##defer-statements) 以及 [try 运算符](../03_language_reference/04_Expressions.md#try-operator)。 +* 在 [错误处理](../02_language_guide/17_Error_Handling.md) 篇章中新增了有关错误处理的相关内容，包括 [Do 语句](../03_language_reference/05_Statements.md#do-statement)、 [Throw 语句](../03-language-reference/05-Statements.md#throw-statement)、 [Defer 语句](../03-language-reference/05-Statements.md##defer-statements) 以及 [try 运算符](../03-language-reference/04-Expressions.md#try-operator)。 * 更新 [错误表示和抛出](../02_language_guide/17_Error_Handling.md#representing-and-throwing-errors) 章节，现在所有类型都可以遵循 `ErrorType` 协议了。 -* 在 [将错误装换成可选值](../02_language_guide/17_Error_Handling.md#converting_errors_to_optional_values) 篇章增加了 `try?` 关键字相关内容。 -* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [递归枚举](../02_language_guide/08_Enumerations.md#recursive-enumerations) 章节以及以及 [声明](../03_language_reference/06_Declarations.md) 篇章的 [任意类型用例的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-any-type) 章节中新增了递归枚举相关内容。 -* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [API 可用性检查](../02_language_guide/05_Control_Flow.md#checking-api-availability) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章的 [可用性条件](../03_language_reference/05_Statements.md#availability-condition) 章节中新增了有关 API 可用性检查相关的内容。 -* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [尽早退出](../02_language_guide/05_Control_Flow.md#early-exit) 章节和 [语句](../03_language_reference/05_Statements.md) 篇章的 [Guard 语句](../03_language_reference/05_Statements.md#guard-statement) 章节新增了与 `guard` 语句相关的内容。 +* 在 [将错误装换成可选值](../02_language_guide/17_Error_Handling.md#converting-errors-to-optional-values) 篇章增加了 `try?` 关键字相关内容。 +* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [递归枚举](../02_language_guide/08_Enumerations.md#recursive-enumerations) 章节以及以及 [声明](../03-language-reference/06-Declarations.md) 篇章的 [任意类型用例的枚举](../03-language-reference/06-Declarations.md#enumerations-with-cases-of-any-type) 章节中新增了递归枚举相关内容。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [API 可用性检查](../02_language_guide/05_Control_Flow.md#checking-api-availability) 章节和 [语句](../03-language-reference/05-Statements.md) 篇章的 [可用性条件](../03-language-reference/05-Statements.md#availability-condition) 章节中新增了有关 API 可用性检查相关的内容。 +* 在 [控制流](../02_language_guide/05_Control_Flow.md) 篇章的 [尽早退出](../02_language_guide/05_Control_Flow.md#early-exit) 章节和 [语句](../03-language-reference/05-Statements.md) 篇章的 [Guard 语句](../03-language-reference/05-Statements.md#guard-statement) 章节新增了与 `guard` 语句相关的内容。 * 在 [协议](../02_language_guide/21_Protocols.md) 篇章中 [协议扩展](../02_language_guide/21_Protocols.md#protocol-extensions) 章节中新增了有关协议扩展的内容。 * 在 [访问控制](../02_language_guide/26_Access_Control.md) 篇章的 [单元测试 target 的访问级别](../02_language_guide/26_Access_Control.md#access-levels-for-unit-test-targets) 章节中新增了有关单元测试访问控制相关的内容。 * 在 [模式](../03_language_reference/08_Patterns.md) 篇章的 [可选模式](../03_language_reference/08_Patterns.md#optional-pattern) 章节中新增了可选模式相关内容。 * 更新 [Repeat-While](../02_language_guide/05_Control_Flow.md#repeat-while) 章节中有关 `repeat-while` 循环相关的内容。 * 更新 [字符串和字符](../02_language_guide/03_Strings_And_Characters.md) 章节，现在 `String` 类型在 Swift 标准库中不再遵循 `CollectionType` 协议。 -* 在 [常量与变量打印](../02_language_guide/01_TheBasics.md#printing) 章节中新增了新 Swift 标准库中有关 `print(_:separator:terminator) ` 相关内容。 -* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [原始值的隐式赋值](../02_language_guide/08_Enumerations.md#implicitly-assigned-raw-values) 章节和 [声明](../03_language_reference/06_Declarations.md) 篇章的 [包含原始值类型的枚举](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-a-raw-value-type) 章节中新增了有关包含 `String` 原始值的枚举用例的行为相关内容。 +* 在 [常量与变量打印](../02_language_guide/01_TheBasics.md#printing) 章节中新增了新 Swift 标准库中有关 `print(-:separator:terminator) ` 相关内容。 +* 在 [枚举](../02_language_guide/08_Enumerations.md) 篇章的 [原始值的隐式赋值](../02_language_guide/08_Enumerations.md#implicitly-assigned-raw-values) 章节和 [声明](../03-language-reference/06-Declarations.md) 篇章的 [包含原始值类型的枚举](../03-language-reference/06-Declarations.md#enumerations-with-cases-of-a-raw-value-type) 章节中新增了有关包含 `String` 原始值的枚举用例的行为相关内容。 * 在 [自动闭包](../02_language_guide/07_Closures.md#autoclosures) 章节中新增了有关 `@autoclosure` 特性的相关内容，包括它的 `@autoclosure(escaping)` 形式。 -* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@avaliable` 和 `warn_unused_result` 特性的相关内容。 +* 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节中有关 `@avaliable` 和 `warn-unused-result` 特性的相关内容。 * 更新 [类型特性](../03_language_reference/07_Attributes.md#type-attributes) 章节中有关 `@convention` 特性的相关内容。 * 在 [可选绑定](../02_language_guide/01_TheBasics.md#optional-binding) 章节中新增了有关使用 `where` 子句进行多可选绑定的相关内容。 * 在 [字符串字面量](../03_language_reference/02_Lexical_Structure.md#string-literal) 章节中新增了有关在编译时使用 `+` 运算符拼接字符串字面量的相关内容。 @@ -171,11 +171,11 @@ * 在 [元类型](../03_language_reference/03_Types.md#metatype-type-h) 章节新增了一处说明，有关如何从元类型值中构造类实例相关内容。 * 在 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节新增了一处说明，有关弱引用作为缓存所存在的不足。 * 更新 [类型特性](../02_language_guide/10_Properties.md#type-properties) 章节，提到了存储型特性其实是懒加载。 -* 更新 [捕获类型](../02_language_guide/07_Closures.md#capturing_values) 章节，阐明了变量和常量在闭包中如何被捕获。 +* 更新 [捕获类型](../02_language_guide/07_Closures.md#capturing-values) 章节，阐明了变量和常量在闭包中如何被捕获。 * 更新 [声明特性](../03_language_reference/07_Attributes.md#Ideclaration-attributes) 章节，用以描述何时在类中使用 `@objc` 关键字。 -* 在 [错误处理](../02_language_guide/17_Error_Handling.md#handling-errors) 章节中新增了一处说明，有关执行 `throw` 语句的性能。在 [Do 语句](../03_language_reference/05_Statements.md#do-statement) 章节的 do 语句部分也新增了类似内容。 +* 在 [错误处理](../02_language_guide/17_Error_Handling.md#handling-errors) 章节中新增了一处说明，有关执行 `throw` 语句的性能。在 [Do 语句](../03-language-reference/05-Statements.md#do-statement) 章节的 do 语句部分也新增了类似内容。 * 更新 [类型特性](../02_language_guide/10_Properties.md#type-properties) 章节中有关类、结构体和枚举的存储型和计算型特性相关的内容。 -* 更新 [Break 语句](../03_language_reference/05_Statements.md#break_statement) 章节中有关带标签的 break 语句相关内容。 +* 更新 [Break 语句](../03_language_reference/05_Statements.md#break-statement) 章节中有关带标签的 break 语句相关内容。 * 在 [属性观察器](../02_language_guide/10_Properties.md#property-observers) 章节更新了一处说明，用来明确 `willSet` 和 `didSet` 观察器的行为。 * 在 [访问级别](../02_language_guide/26_Access_Control.md#access-levels) 章节新增了有关 `private` 作用域的相关内容说明。 * 在 [弱引用](../02_language_guide/24_Automatic_Reference_Counting.md#weak-references) 章节新增了有关弱应用在垃圾回收系统和 ARC 之间的区别的说明。 @@ -212,9 +212,9 @@ * 新增 [失败构造器](../02_language_guide/14_Initialization.md#failable-initializers) 的完整指引。 * 在协议中新增了 [失败构造器要求](../02_language_guide/21_Protocols.md#failable-initializer-requirements) 的描述。 * 常量和变量的 `Any` 类型现可以包含函数实例。更新了有关 `Any` 相关的示例来展示如何在 `switch` 语句中如何检查并转换到一个函数类型。 -* 带有原始值的枚举类型增加了一个 `rawValue` 属性替代 `toRaw()` 方法，同时使用了一个以 `rawValue` 为参数的失败构造器来替代 `fromRaw()` 方法。更多的内容，请看 [原始值](../02_language_guide/08_Enumerations.md#raw-values) 和 [带原始值的枚举类型](../03_language_reference/06_Declarations.md#enumerations-with-cases-of-a-raw-value-type)。 +* 带有原始值的枚举类型增加了一个 `rawValue` 属性替代 `toRaw()` 方法，同时使用了一个以 `rawValue` 为参数的失败构造器来替代 `fromRaw()` 方法。更多的内容，请看 [原始值](../02_language_guide/08_Enumerations.md#raw-values) 和 [带原始值的枚举类型](../03-language-reference/06-Declarations.md#enumerations-with-cases-of-a-raw-value-type)。 * 新增 [Failable Initializer](../03_language_reference/06_Declarations.md#failable-initializers) 的参考章节，它可以触发初始化失败。 -* 自定义运算符现在可以包含 `?` 字符，更新了 [运算符](../03_language_reference/02_Lexical_Structure.md#operator) 涉及改进后的规则的部分，并且在 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom-operators) 章节中删除了重复的运算符有效字符集合。 +* 自定义运算符现在可以包含 `?` 字符，更新了 [运算符](../03_language_reference/02_Lexical_Structure.md#operator) 涉及改进后的规则的部分，并且在 [自定义运算符](../02-language-guide/27-Advanced-Operators.md#custom-operators) 章节中删除了重复的运算符有效字符集合。 ### 2014-08-18 @@ -227,11 +227,11 @@ * [可选类型](../02_language_guide/01_TheBasics.md#optionals) 若有值时，不再隐式的转换为 `true`，同样，若无值时，也不再隐式的转换为 `false`，这是为了避免在判别 optional `Bool` 的值时产生困惑。 替代的方案是，用`==` 或 `!=` 运算符显式地去判断 Optinal 是否是 `nil`，以确认其是否包含值。 * Swift 新增了一个 [Nil 合并运算符](../02_language_guide/BasicOperators.md#nil-coalescing-operator) (`a ?? b`) , 该表达式中，如果 Optional `a` 的值存在，则取得它并返回，若 Optional `a` 为 `nil`，则返回默认值 `b` * 更新和扩展 [字符串的比较](../02_language_guide/03_Strings_And_Characters.md#comparing-strings) ，用以反映和展示'字符串和字符的比较'，以及'前缀（prefix）/后缀（postfix）比较'都开始基于扩展字符集（extended grapheme clusters）规范的等价比较。 -* 现在，你可以通过下标赋值或者 [可选调用链](../02_language_guide/16_Optional_Chaining.md) 中的可变方法和操作符来给属性设值。相应地更新了有关 [通过可选链接访问属性](../02_language_guide/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 的内容，并扩展了 [通过可选链接调用方法](../02_language_guide/16_Optional_Chaining.md#calling-methods-through-optional-chaining) 时检查方法调用成功的示例，以显示如何检查属性设置是否成功。 +* 现在，你可以通过下标赋值或者 [可选调用链](../02_language_guide/16_Optional_Chaining.md) 中的可变方法和操作符来给属性设值。相应地更新了有关 [通过可选链接访问属性](../02_language_guide/16_Optional_Chaining.md#accessing-properties-through-optional-chaining) 的内容，并扩展了 [通过可选链接调用方法](../02-language-guide/16-Optional-Chaining.md#calling-methods-through-optional-chaining) 时检查方法调用成功的示例，以显示如何检查属性设置是否成功。 * 在可选链中新增了 [访问可选类型的下标脚注](../02_language_guide/16_Optional_Chaining.md#accessing-subscripts-through-optional-chaining) 章节。 * 更新 [访问和修改数组](../02_language_guide/CollectionTypes.md#accessing-and-modifying-a-dictionary) 章节以标示，从该版本起，不能再通过 `+=` 运算符给一个数组新增一个新的项。对应的替代方案是，使 `append` 方法，或者通过 `+=` 运算符来新增一个只有一个项的数组。 * 新增一处说明，在 [范围运算符](../02_language_guide/BasicOperators.md#range-operators) 中，比如， `a..b` 和 `a.. Date: Wed, 16 Oct 2019 10:41:45 +0800 Subject: [PATCH 26/36] #987 Lexicalstructure (#1006) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 04_Collection_Types 5.1初版 * 校对以后的更新 * 第二次校对以后的修正 * 初次5.1更改 * 装饰改为包装 * 校对以后的更改 * 二次校对 * 5.1更新 * 初次校对后的更改 --- .../02_Lexical_Structure.md | 263 +++++++++--------- 1 file changed, 139 insertions(+), 124 deletions(-) diff --git a/source/03_language_reference/02_Lexical_Structure.md b/source/03_language_reference/02_Lexical_Structure.md index 8558c3d2..5a1a6997 100755 --- a/source/03_language_reference/02_Lexical_Structure.md +++ b/source/03_language_reference/02_Lexical_Structure.md @@ -2,25 +2,27 @@ Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言中有效符号（token）的字符序列。这些合法符号组成了语言中最底层的构建基块，并在之后的章节中用于描述语言的其他部分。一个合法符号由一个标识符（identifier）、关键字（keyword）、标点符号（punctuation）、字面量（literal）或运算符（operator）组成。 -通常情况下，通过考虑输入文本当中可能的最长子串，并且在随后将介绍的语法约束之下，根据随后将介绍的语法约束生成的，根据 Swift 源文件当中的字符来生成相应的“符号”。这种方法称为*“最长匹配（longest match）”*，或者*“最大适合（maximal munch）”*。 +通常情况下，符号是考虑了输入文本中最长可能的子字符串，并被随后将介绍的语法约束，根据 Swift 源文件的字符生成的。这种方法称为*“最长匹配（longest match）”*，或者*“最大适合（maximal munch）”*。 ## 空白与注释 {#whitespace} 空白（whitespace）有两个用途：分隔源文件中的符号以及帮助区分运算符属于前缀还是后缀（参见 [运算符](#operators)），在其他情况下空白则会被忽略。以下的字符会被当作空白：空格（U+0020）、换行符（U+000A）、回车符（U+000D）、水平制表符（U+0009）、垂直制表符（U+000B）、换页符（U+000C）以及空字符（U+0000）。 -注释被编译器当作空白处理。单行注释由 `//` 开始直至遇到换行符（U+000A）或者回车符（U+000D）。多行注释由 `/*` 开始，以 `*/` 结束。注释允许嵌套，但注释标记必须匹配。 +注释被编译器当作空白处理。单行注释由 `//` 开始直至遇到换行符（U+000A）或者回车符（U+000D）。多行注释由 `/*` 开始，以 `*/` 结束。多行注释允许嵌套，但注释标记必须成对出现。 + +注释可以包含其他的格式和标记，如 [标记格式参考](https://developer.apple.com/library/archive/documentation/Xcode/Reference/xcode_markup_formatting_ref/index.html)中所述。 > 空白语法 > -> *空白* → [*空白项*](#whitespace-item) [*空白*](#whitespace)可选 +> *空白* → [空白项](#whitespace-item) [空白](#whitespace)可选 > #### whitespace-item {#whitespace-item} > -> *空白项* → [*断行符*](#line-break) +> *空白项* → [断行符](#line-break) > -> *空白项* → [*注释*](#comment) +> *空白项* → [注释](#comment) > -> *空白项* → [*多行注释*](#multiline-comment) +> *空白项* → [多行注释](#multiline-comment) > > *空白项* → U+0000，U+0009，U+000B，U+000C 或者 U+0020 > @@ -36,58 +38,60 @@ Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言 > #### comment {#comment} > -> *注释* → // [*注释内容*](#comment-text) [断行符*](#line-break) +> *注释* → // [注释内容](#comment-text) [断行符](#line-break) > > #### multiline-comment {#multiline-comment} > -> *多行注释* → `/*` [*多行注释内容*](#multiline-commnet-text) `*/` +> *多行注释* → `/*` [多行注释内容](#multiline-commnet-text) `*/` > > #### comment-text {#comment-text} > -> *注释内容* → [*注释内容项*](#comment-text-item) [*注释内容*](#comment-text)可选 +> *注释内容* → [注释内容项](#comment-text-item) [注释内容](#comment-text)可选 > > #### comment-text-item {#comment-text-item} > -> *注释内容项* → 任何 Unicode 标量值， 除了 U+000A 或者 U+000D +> *注释内容项* → 任何 Unicode 标量值，除了 U+000A 或者 U+000D > > #### multiline-commnet-text {#multiline-commnet-text} > -> *多行注释内容* → [*多行注释内容项*](#multiline-comment-text-item) [*多行注释内容*](#multiline-comment-text)可选 +> *多行注释内容* → [多行注释内容项](#multiline-comment-text-item) [多行注释内容](#multiline-comment-text)可选 > -> *多行注释内容项* → [*多行注释*](#multiline-comment). +> *多行注释内容项* → [多行注释](#multiline-comment). > -> *多行注释内容项* → [*注释内容项*](#comment-text-item) +> *多行注释内容项* → [注释内容项](#comment-text-item) > -> *多行注释内容项* → 任何 Unicode 标量值， 除了 `/*` 或者 `*/` +> *多行注释内容项* → 任何 Unicode 标量值，除了 `/*` 或者 `*/` ## 标识符 {#identifiers} -*标识符（identifier）* 可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线（`_`）、基本多文种平面（Basic Multilingual Plane）中非字符数字组合的 Unicode 字符以及基本多文种平面以外的非个人专用区字符。在首字符之后，允许使用数字和组合 Unicode 字符。 +*标识符（identifier）* 可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线（`_`）、基本多文种平面（Basic Multilingual Plane）中非字符数字组合的 Unicode 字符以及基本多文种平面以外的非个人专用区字符。在首字符之后，允许使用数字和组合 Unicode 字符。 使用保留字作为标识符，需要在其前后增加反引号（`` ` ``）。例如，`class` 不是合法的标识符，但可以使用 `` `class` ``。反引号不属于标识符的一部分，`` `x` `` 和 `x` 表示同一标识符。 闭包中如果没有明确指定参数名称，参数将被隐式命名为 `$0`、`$1`、`$2` 等等。这些命名在闭包作用域范围内是合法的标识符。 +编译器给含有属性包装器映射的属性自动合成以美元符号（*$*）开头的标识符。你的代码可以与这些标识符进行交互，，但是不能使用该前缀声明标识符。更详细的介绍，请查看 [特性](./07_Attributes.md) 章节中的 [属性包装器](./07_Attributes.md#propertywrapper) 部分。 + > 标识符语法 > -> *标识符* → [*头部标识符*](#identifier-head) [*标识符字符组*](#identifier-characters)可选 +> *标识符* → [头部标识符](#identifier-head) [标识符字符组](#identifier-characters)可选 > -> *标识符* → \`[*头部标识符*](#identifier-head) [*标识符字符组*](#identifier-characters)可选\` +> *标识符* → \`[头部标识符](#identifier-head) [标识符字符组](#identifier-characters)可选\` > -> *标识符* → [*隐式参数名*](#implicit-parameter-name) +> *标识符* → [隐式参数名](#implicit-parameter-name) > -> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier) +> *标识符列表* → [标识符](#identifier) | [标识符](#identifier) **,** [标识符列表](#identifier) > > #### identifier-head {#identifier-head} > > *头部标识符* → 大写或小写字母 A - Z > -> *头部标识符* → _ +> *头部标识符* → **_** > > *头部标识符* → U+00A8，U+00AA，U+00AD，U+00AF，U+00B2–U+00B5，或者 U+00B7–U+00BA > @@ -116,38 +120,42 @@ 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 -> -> +> #### identifier-character {#identifier-character} +> +> *标识符字符* → 数值 0 - 9 > > *标识符字符* → U+0300–U+036F，U+1DC0–U+1DFF，U+20D0–U+20FF，或者 U+FE20–U+FE2F > -> *标识符字符* → [*头部标识符*](#identifier-head) +> *标识符字符* → [头部标识符](#identifier-head) > > #### identifier-characters {#identifier-characters} > -> *标识符字符组* → [*标识符字符*](#identifier-character) [*标识符字符组*](#identifier-characters)可选 +> *标识符字符组* → [标识符字符](#identifier-character) [标识符字符组](#identifier-characters)可选 > > #### implicit-parameter-name {#implicit-parameter-name} > -> *隐式参数名* → **$** [*十进制数字列表*](#decimal-digit) +> *隐式参数名* → **$** [十进制数字列表](#decimal-digit) +> +#### property-wrapper-projection {#property-wrapper-projection} +> +> *属性包装器映射* → **$** [标识符字符组](#identifier-characters) +> ## 关键字和标点符号 {#keywords-and-punctuation} 下面这些被保留的关键字不允许用作标识符，除非使用反引号转义，具体描述请参考 [标识符](#identifiers)。除了 `inout`、`var` 以及 `let` 之外的关键字可以用作某个函数声明或者函数调用当中的外部参数名，无需添加反引号转义。当一个成员与一个关键字具有相同的名称时，不需要使用反引号来转义对该成员的引用，除非在引用该成员和使用该关键字之间存在歧义 - 例如，`self`，`Type` 和 `Protocol` 在显式的成员表达式中具有特殊的含义，因此它们必须在该上下文中使用反引号进行转义。 -* 用在声明中的关键字： `associatedtype`、`class`、`deinit`、`enum`、`extension`、`fileprivate `、`func`、`import`、`init`、`inout`、`internal`、`let`、`open`、`operator`、`private`、`protocol`、`public`、`static`、`struct`、`subscript`、`typealias` 以及 `var`。 +* 用在声明中的关键字：`associatedtype`、`class`、`deinit`、`enum`、`extension`、`fileprivate `、`func`、`import`、`init`、`inout`、`internal`、`let`、`open`、`operator`、`private`、`protocol`、`public`、`rethrows`、`static`、`struct`、`subscript`、`typealias` 以及 `var`。 * 用在语句中的关键字：`break`、`case`、`continue`、`default`、`defer`、`do`、`else`、`fallthrough`、`for`、`guard`、`if`、`in`、`repeat`、`return`、`switch`、`where` 以及 `while`。 -* 用在表达式和类型中的关键字：`as`、`Any`、`catch`、`false`、`is`、`nil`、`rethrows`、`super`、`self`、`Self`、`throw`、`throws`、`true` 以及 `try `。 +* 用在表达式和类型中的关键字：`as`、`Any`、`catch`、`false`、`is`、`nil`、`super`、`self`、`Self`、`throw`、`throws`、`true` 以及 `try `。 * 用在模式中的关键字：`_`。 -* 以井字号（`#`）开头的关键字：`#available`、`#colorLiteral`、`#column`、`#else`、`#elseif`、`#endif`、`#error`、`#file`、`#fileLiteral`、`#function`、`#if`、`#imageLiteral `、`#line`、`#selector`、`#sourceLocation`以及 `#warning`。 -* 特定上下文中被保留的关键字： `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`。这些关键字在特定上下文之外可以被用做标识符。 +* 以井字号（`#`）开头的关键字：`#available`、`#colorLiteral`、`#column`、`#else`、`#elseif`、`#endif`、`#error`、`#file`、`#fileLiteral`、`#function`、`#if`、`#imageLiteral`、`#line`、`#selector`、`#sourceLocation`以及 `#warning`。 +* 特定上下文中被保留的关键字：`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`。这些关键字在特定上下文之外可以被用做标识符。 -以下符号被当作保留符号，不能用于自定义运算符： `(`、`)`、`{`、`}`、`[`、`]`、`.`、`,`、`:`、`;`、`=`、`@`、`#`、`&`（作为前缀运算符）、`->`、`` ` ``、`?`、`!`（作为后缀运算符）。 +以下符号被保留为标点符号，不能用于自定义运算符：`(`、`)`、`{`、`}`、`[`、`]`、`.`、`,`、`:`、`;`、`=`、`@`、`#`、`&`（作为前缀运算符）、`->`、`` ` ``、`?`、以及 `!`（作为后缀运算符）。 ## 字面量 {#literal} @@ -162,15 +170,16 @@ Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言 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 标准库协议中的一个：整数字面量的 `ExpressibleByIntegerLiteral` 协议、浮点数字面量的 `ExpressibleByFloatLiteral` 协议、字符串字面量的 `ExpressibleByStringLiteral` 协议、布尔值字面量的 `ExpressibleByBooleanLiteral` 协议、只包含单个 Unicode 标量字符串文本的 `ExpressibleByUnicodeScalarLiteral` 协议以及只包含单个扩展字形簇（grapheme cluster）字符串文字的 `ExpressibleByExtendedGraphemeClusterLiteral` 协议。比如，`Int8` 符合 `ExpressibleByIntegerLiteral` 协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整数字面量 `42` 的类型注解。 -当为一个字面量值指定了类型注解的时候，这个标注的类型必须能通过这个字面量值实例化。也就是说，这个类型必须符合这些 Swift 标准库协议中的一个：整数字面量的 `IntegerLiteralConvertible` 协议、浮点数字面量的 `FloatingPointLiteralConvertible` 协议、字符串字面量的 `StringLiteralConvertible` 协议以及布尔值字面量的 `BooleanLiteralConvertible` 协议。比如，`Int8` 符合 `IntegerLiteralConvertible` 协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整数字面量 `42` 的类型注解。 > 字面量语法 > -> *字面量* → [*数值字面量*](#integer-literal) | [*字符串字面量*](#string-literal) | [*布尔值字面量*](#integer-literal) | [*nil 字面量*](#integer-literal) +> *字面量* → [数值字面量](#integer-literal) | [字符串字面量](#string-literal) | [布尔值字面量](#integer-literal) | [nil 字面量](#integer-literal) > -> *数值字面量* → **-**可选 [*整数字面量*](#integer-literal) | **-**可选 [*浮点数字面量*](#floating-point-literal) +> *数值字面量* → **-**可选 [整数字面量](#integer-literal) | **-**可选 [浮点数字面量](#floating-point-literal) > > *布尔值字面量* → **true** | **false** > @@ -179,11 +188,11 @@ true // 布尔值字面量 ### 整数字面量{#integer-literal} -*整数字面量（Integer Literals）* 表示未指定精度整数的值。整数字面量默认用十进制表示，可以加前缀来指定其他的进制。二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 +*整数字面量（Integer Literals）* 表示未指定精度的整数值。整数字面量默认用十进制表示；可以加前缀来指定其他的进制。二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 -十进制字面量包含数字 `0` 至 `9`。二进制字面量只包含 `0` 或 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F`（大小写均可）。 +十进制字面量包含数字 `0` 至 `9`。二进制字面量包含 `0` 和 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F`（大小写均可）。 -负整数的字面量在整数字面量前加负号 `-`，比如 `-42`。 +负整数字面量的表示方式为在整数字面量前加负号 `-`，比如 `-42`。 整型字面面可以使用下划线（`_`）来增加数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，这同样也会被系统所忽略，并不会影响字面量的值。 @@ -194,52 +203,52 @@ true // 布尔值字面量 > #### integer-literal {#integer-literal} > -> *整数字面量* → [*二进制字面量*](#binary-literal) +> *整数字面量* → [二进制字面量](#binary-literal) > -> *整数字面量* → [*八进制字面量*](#octal-literal) +> *整数字面量* → [八进制字面量](#octal-literal) > -> *整数字面量* → [*十进制字面量*](#decimal-literal) +> *整数字面量* → [十进制字面量](#decimal-literal) > -> *整数字面量* → [*十六进制字面量*](#hexadecimal-literal) +> *整数字面量* → [十六进制字面量](#hexadecimal-literal) > > #### binary-literal {#binary-literal} > -> *二进制字面量* → **0b** [*二进制数字*](#binary-digit) [*二进制字面量字符组*](#binary-literal-characters)可选 +> *二进制字面量* → **0b** [二进制数字](#binary-digit) [二进制字面量字符组](#binary-literal-characters)可选 > > #### binary-digit {#binary-digit} > -> *二进制数字* → 数值 0 到 1 +> *二进制数字* → 数值 0 或 1 > -> *二进制字面量字符* → [*二进制数字*](#binary-digit) | - +> *二进制字面量字符* → [二进制数字](#binary-digit) | **_** > > #### binary-literal-characters {#binary-literal-characters} > -> *二进制字面量字符组* → [*二进制字面量字符*](#binary-literal-character) [*二进制字面量字符组*](#binary-literal-characters)可选 +> *二进制字面量字符组* → [二进制字面量字符](#binary-literal-character) [二进制字面量字符组](#binary-literal-characters)可选 > > #### octal-literal {#octal-literal} > -> *八进制字面量* → **0o** [*八进字数字*](#octal-digit) [*八进制字符组*](#octal-literal-characters)可选 +> *八进制字面量* → **0o** [八进字数字](#octal-digit) [八进制字符组](#octal-literal-characters)可选 > > #### octal-digit {#octal-digit} > > *八进字数字* → 数值 0 到 7 > -> *八进制字符* → [*八进字数字*](#octal-digit) | - +> *八进制字符* → [八进字数字](#octal-digit) | **_** > > #### octal-literal-characters {#octal-literal-characters} > -> *八进制字符组* → [*八进制字符*](#octal-literal-character) [*八进制字符组*](#octal-literal-characters)可选 +> *八进制字符组* → [八进制字符](#octal-literal-character) [八进制字符组](#octal-literal-characters)可选 > > #### decimal-literal {#decimal-literal} > -> *十进制字面量* → [*十进制数字*](#decimal-digit) [*十进制字符组*](#decimal-literal-characters)可选 +> *十进制字面量* → [十进制数字](#decimal-digit) [十进制字符组](#decimal-literal-characters)可选 > > #### decimal-digit {#decimal-digit} @@ -249,38 +258,38 @@ true // 布尔值字面量 > #### decimal-literal-characters {#decimal-literal-characters} > -> *十进制数字组* → [*十进制数字*](#decimal-digit) [*十进制数字组*](#decimal-literal-characters)可选 +> *十进制数字组* → [十进制数字](#decimal-digit) [十进制数字组](#decimal-literal-characters)可选 > -> *十进制字符* → [*十进制数字*](#decimal-digit) | - +> *十进制字符* → [十进制数字](#decimal-digit) | **_** > -> *十进制字符组* → [*十进制字符*](#decimal-literal-characters) [*十进制字符组*](#decimal-literal-characters)可选 +> *十进制字符组* → [十进制字符](#decimal-literal-characters) [十进制字符组](#decimal-literal-characters)可选 > > #### hexadecimal-literal {#hexadecimal-literal} > -> *十六进制字面量* → **0x** [*十六进制数字*](#hexadecimal-digit) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 +> *十六进制字面量* → **0x** [十六进制数字](#hexadecimal-digit) [十六进制字面量字符组](#hexadecimal-literal-characters)可选 > > #### hexadecimal-digit {#hexadecimal-digit} > > *十六进制数字* → 数值 0 到 9, 字母 a 到 f, 或 A 到 F > -> *十六进制字符* → [*十六进制数字*](#hexadecimal-digit) | - +> *十六进制字符* → [十六进制数字](#hexadecimal-digit) | **-** > > #### hexadecimal-literal-characters {#hexadecimal-literal-characters} > -> *十六进制字面量字符组* → [*十六进制字符*](#hexadecimal-literal-characters) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 +> *十六进制字面量字符组* → [十六进制字符](#hexadecimal-literal-characters) [十六进制字面量字符组](#hexadecimal-literal-characters)可选 ### 浮点数字面量{#floating-point-literal} -*浮点数字面量（Floating-point literals）* 表示未指定精度浮点数的值。 +*浮点数字面量（Floating-point literals）*表示未指定精度浮点数的值。 浮点数字面量默认用十进制表示（无前缀），也可以用十六进制表示（加前缀 `0x`）。 -十进制浮点数字面量由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点（`.`）后跟十进制数字串组成。指数部分由大写或小写字母 `e` 为前缀后跟十进制数字串组成，这串数字表示 `e` 之前的数量乘以 10 的几次方。例如：`1.25e2` 表示 1.25 x 10²，也就是 `125.0`；同样，`1.25e－2` 表示 1.25 x 10¯²，也就是 `0.0125`。 +十进制浮点数字面量由十进制数字串后跟十进制小数部分或十进制指数部分（或两者皆有）组成。十进制小数部分由小数点（`.`）后跟十进制数字串组成。指数部分由大写或小写字母 `e` 为前缀后跟十进制数字串组成，这串数字表示 `e` 之前的数值乘以 10 的几次方。例如：`1.25e2` 表示 1.25 x 10²，也就是 `125.0`。同样，`1.25e－2` 表示 1.25 x 10¯²，也就是 `0.0125`。 -十六进制浮点数字面量由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 为前缀后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 15 x 2²，也就是 `60`；同样，`0xFp-2` 表示 15 x 2¯²，也就是 `3.75`。 +十六进制浮点数字面量由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 为前缀后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 15 x 2²，也就是 `60`。同样，`0xFp-2` 表示 15 x 2¯²，也就是 `3.75`。 负数的浮点数字面量由负号（`-`）和浮点数字面量组成，例如 `-42.5`。 @@ -293,29 +302,29 @@ true // 布尔值字面量 > #### floating-point-literal {#floating-point-literal} > -> *浮点数字面量* → [*十进制字面量*](#decimal-literal) [*十进制分数*](#decimal-fraction)可选 [*十进制指数*](#decimal-exponent)可选 +> *浮点数字面量* → [十进制字面量](#decimal-literal) [十进制分数](#decimal-fraction)可选 [十进制指数](#decimal-exponent)可选 > -> *浮点数字面量* → [*十六进制字面量*](#hexadecimal-literal) [*十六进制分数*](#hexadecimal-fraction)可选 [*十六进制指数*](#hexadecimal-exponent) +> *浮点数字面量* → [十六进制字面量](#hexadecimal-literal) [十六进制分数](#hexadecimal-fraction)可选 [十六进制指数](#hexadecimal-exponent) > > #### decimal-fraction {#decimal-fraction} > -> *十进制分数* → **.** [*十进制字面量*](#decimal-literal) +> *十进制分数* → **.** [十进制字面量](#decimal-literal) > > #### decimal-exponent {#decimal-exponent} > -> *十进制指数* → [*十进制指数 e*](#floating-point-e) [*正负号*](#sign)可选 [*十进制字面量*](#decimal-literal) +> *十进制指数* → [十进制指数 e](#floating-point-e) [正负号](#sign)可选 [十进制字面量](#decimal-literal) > > #### hexadecimal-fraction {#hexadecimal-fraction} > -> *十六进制分数* → **.** [*十六进制数字*](#hexadecimal-digit) [*十六进制字面量字符组*](#hexadecimal-literal-characters)可选 +> *十六进制分数* → **.** [十六进制数字](#hexadecimal-digit) [十六进制字面量字符组](#hexadecimal-literal-characters)可选 > > #### hexadecimal-exponent {#hexadecimal-exponent} > -> *十六进制指数* → [*十六进制指数 p*](#floating-point-p) [*正负号*](#sign)可选 [*十进制字面量*](#decimal-literal) +> *十六进制指数* → [十六进制指数 p](#floating-point-p) [正负号](#sign)可选 [十进制字面量](#decimal-literal) > > #### floating-point-e {#floating-point-e} @@ -334,7 +343,7 @@ true // 布尔值字面量 ### 字符串字面量 {#string-literal} -字符串字面量是被引号包括的一串字符组成。 单行字符串字面量被包在双引号中的一串字符组成，形式如下： +字符串字面量是被引号包括的一串字符组成。单行字符串字面量是被包在双引号中的一串字符组成，形式如下： > "`字符`" @@ -347,24 +356,24 @@ true // 布尔值字面量 与单行字符串字面量不同的是，多行字符串字面量可以包含不转义的双引号（"），回车以及换行。它不能包含三个未转义的连续双引号。 -""" 之后的回车或者换行开始多行字符串字面量，不是字符串的一部分。 """ 之前回车或者换行结束字面量，也不是字符串的一部分。要让多行字符串字面量的开始或结束带有换行，就在第一行或者最后一行写一个空行。 +`"""` 之后的回车或者换行开始多行字符串字面量，它们不是字符串的一部分。结束部分的 `"""` 以及它之前的回车或者换行，也不是字符串的一部分。要让多行字符串字面量的开始或结束带有换行，就在第一行或者最后一行写一个空行。 -多行字符串字面量可以使用任何空格或制表符组合进行缩进；这些缩进不会包含在字符串中。 """ 的结束符号决定了缩进：字面量中的任何一个非空行必须起始于多行字符串字面量结束符号的前面；空格和制表符不会被转换。你可以包在缩进后含额外的空格和制表符；这些空格和制表符会在字符串中出现。 +多行字符串字面量可以使用任何空格或制表符组合进行缩进；这些缩进不会包含在字符串中。`"""` 的结束符号决定了缩进：字面量中的每一个非空行开头都必须与结束符 `"""` 之前出现的缩进完全一致；空格和制表符不会被转换。你可以在缩进后包含额外的空格和制表符；这些空格和制表符会在字符串中出现。 多行字符串字面量中的一行结束使用规范化的换行符号。尽管你的源代码混用了回车和换行符，字符串中所有的行结束都必须一样. -在多行字符串字面量里， 在行末用反斜线（`\`）可以省略字符串行间中断。 反斜线之间的空白和行间中断也可以省略。 你可以在你的代码里用这种语法硬包裹多行字符串字面量，不需要改变产生的字符串的值。 +在多行字符串字面量里，在行末用反斜线（`\`）可以省略字符串行间中断。反斜线和换行符之间的空白也将被忽略。你可以在你的代码里用这种语法硬包裹多行字符串字面量，而不改变结果字符串的值。 可以在字符串字面量中使用的转义特殊符号如下： -* 空字符 `\0` -* 反斜线 `\\` -* 水平制表符 `\t` -* 换行符 `\n` -* 回车符 `\r` -* 双引号 `\"` -* 单引号 `\'` -* Unicode 标量 `\u{`n`}`，n 为一到八位的十六进制数字 +* 空字符 （`\0`） +* 反斜线 （`\\`） +* 水平制表符 （`\t`） +* 换行符 （`\n`） +* 回车符 （`\r`） +* 双引号 （`\"`） +* 单引号 （`\'`） +* Unicode 标量 （`\u{`n`}`），n 为一到八位的十六进制数字 字符串字面量允许在反斜杠（`\`）后的括号 `()` 中插入表达式的值。插入表达式可以包含字符串字面量，但不能包含未转义的反斜线（`\`）、回车符以及换行符。 @@ -378,7 +387,7 @@ true // 布尔值字面量 let x = 3; "1 2 \(x)" ``` -可以使用一对或多对扩展分隔符(#)包裹字符串进行分隔，被分隔的字符串的形式如下所示： +由扩展分隔符包裹的字符串，它是由引号以及成对出现的数字符号（`#`）包裹的字符串序列。由扩展分隔符包裹的字符串形式如下所示： > \#"`characters`"# > @@ -388,7 +397,7 @@ let x = 3; "1 2 \(x)" > > """# -特殊字符在被分隔符分隔的结果字符串中会展示为普通字符，而不是特殊字符。你可以使用扩展分隔符来创建一些具有特殊效果的字符串。例如，生成字符串插值，启动或终止转义序列(字符串)。 +特殊字符在被扩展分隔符分隔的结果字符串中会展示为普通字符，而不是特殊字符。你可以使用扩展分隔符来创建一些通常情况下具有特殊效果的字符串。例如，生成字符串插值，启动转义序列或终止字符串。 以下所示，由字符串字面量和扩展分隔符所创建的字符串是等价的: @@ -423,75 +432,75 @@ let textB = "Hello world" > 字符串字面量语法 > -> *字符串字面量* → [*静态字符串字面量*](#static-string-literal) | [*插值字符串字面量*](#interpolated-string-literal) +> *字符串字面量* → [静态字符串字面量](#static-string-literal) | [插值字符串字面量](#interpolated-string-literal) > -> *字符串开分隔定界符* → [*字符串扩展分隔符*](#extended-string-literal-delimiter) **"** +> *字符串开分隔定界符* → [字符串扩展分隔符](#extended-string-literal-delimiter) **"** > -> *字符串闭分隔定界符* → **"** [*字符串扩展分隔符*](#extended-string-literal-delimiter)可选 +> *字符串闭分隔定界符* → **"** [字符串扩展分隔符](#extended-string-literal-delimiter)可选 > > #### static-string-literal {#static-string-literal} > -> *静态字符串字面量* → [*字符串开分隔定界符*](#extended-string-literal-delimiter) [*引用文本*](#quoted-text)可选 [*字符串闭分隔定界符*](#extended-string-literal-delimiter) +> *静态字符串字面量* → [字符串开分隔定界符](#extended-string-literal-delimiter) [引用文本](#quoted-text)可选 [字符串闭分隔定界符](#extended-string-literal-delimiter) > -> *静态字符串字面量* → [*多行字符串开分隔定界符*](#extended-string-literal-delimiter) [*多行引用文本*](#multiline-quoted-text)可选 [*多行字符串闭分隔定界符*](#extended-string-literal-delimiter) +> *静态字符串字面量* → [多行字符串开分隔定界符](#extended-string-literal-delimiter) [多行引用文本](#multiline-quoted-text)可选 [多行字符串闭分隔定界符](#extended-string-literal-delimiter) > -> *多行字符串开分隔定界符* → [*字符串扩展分隔符*](#extended-string-literal-delimiter) **"""** +> *多行字符串开分隔定界符* → [字符串扩展分隔符](#extended-string-literal-delimiter) **"""** > -> *多行字符串闭分隔定界符* → **"""** [*字符串扩展分隔符*](#extended-string-literal-delimiter) +> *多行字符串闭分隔定界符* → **"""** [字符串扩展分隔符](#extended-string-literal-delimiter) > > #### extended-string-literal-delimiter {#extended-string-literal-delimiter} > -> *字符串扩展分隔符* → **#** [*字符串扩展分隔符*](#extended-string-literal-delimiter)可选 +> *字符串扩展分隔符* → **#** [字符串扩展分隔符](#extended-string-literal-delimiter)可选 > > #### quoted-text {#quoted-text} > -> *引用文本* → [*引用文本项*](#quoted-text-item) [*引用文本*](#quoted-text)可选 +> *引用文本* → [引用文本项](#quoted-text-item) [引用文本](#quoted-text)可选 > > #### quoted-text-item {#quoted-text-item} > -> *引用文本项* → [*转义字符*](#escaped-character) +> *引用文本项* → [转义字符](#escaped-character) > > *引用文本项* → 除了 **"**、**\\**、U+000A、U+000D 以外的所有 Unicode 字符 > > #### multiline-quoted-text {#multiline-quoted-text} > -> *多行引用文本* → [*多行引用文本项*](#multiline-quoted-text-item) [*多行引用文本*](#multiline-quoted-text)可选 +> *多行引用文本* → [多行引用文本项](#multiline-quoted-text-item) [多行引用文本](#multiline-quoted-text)可选 > > #### multiline-quoted-text-item {#multiline-quoted-text-item} > -> *多行引用文本项* [*转义字符*](#escaped-character)可选 +> *多行引用文本项* [转义字符](#escaped-character)可选 > > #### multiline-quoted-text {#multiline-quoted-text} > -> *多行引用文本* → 除了 **\** 以外的任何Unicode标量值 +> *多行引用文本* → 除了 **\\** 以外的任何 Unicode 标量值 > -> *多行引用文本* → [*转义换行*](#escaped-newline) +> *多行引用文本* → [转义换行](#escaped-newline) > > #### interpolated-string-literal {#interpolated-string-literal} > -> *插值字符串字面量* → [*字符串开分隔定界符*](#extended-string-literal-delimiter) [*插值文本*](#interpolated-text)可选 [*字符串闭分隔定界符*](#extended-string-literal-delimiter) +> *插值字符串字面量* → [字符串开分隔定界符](#extended-string-literal-delimiter) [插值文本](#interpolated-text)可选 [字符串闭分隔定界符](#extended-string-literal-delimiter) > -> *插值字符串字面量* → [*多行字符串开分隔定界符*](#extended-string-literal-delimiter) [*插值文本*](#interpolated-text)可选 [*多行字符串闭分隔定界符*](#extended-string-literal-delimiter) +> *插值字符串字面量* → [多行字符串开分隔定界符](#extended-string-literal-delimiter) [插值文本](#interpolated-text)可选 [多行字符串闭分隔定界符](#extended-string-literal-delimiter) > > #### interpolated-text {#interpolated-text} > -> *插值文本* → [*插值文本项*](#interpolated-text-item) [*插值文本*](#interpolated-text)可选 +> *插值文本* → [插值文本项](#interpolated-text-item) [插值文本](#interpolated-text)可选 > > #### interpolated-text-item {#interpolated-text-item} > -> *插值文本项* → **\\****(**[*表达式*](./04_Expressions.md)**)** | [*引用文本项*](#quoted-text-item) +> *插值文本项* → **\\(**[ 表达式 ](./04_Expressions.md)**)** | [引用文本项](#quoted-text-item) > -> *多行插值文本* → [*多行插值文本项*](#multiline-quoted-text-item) [*多行插值文本*](#multiline-quoted-text)可选 +> *多行插值文本* → [多行插值文本项](#multiline-quoted-text-item) [多行插值文本](#multiline-quoted-text)可选 > > *多行插值文本项* → **\\(** [表达式](./04_Expressions.md) **)** | [多行引用文本项](#multiline-quoted-text-item) > @@ -503,9 +512,9 @@ let textB = "Hello world" > #### escaped-character {#escaped-character} > -> *转义字符* → [*转义序列*](#escape-sequence) **0** | [*转义序列*](#escape-sequence) **\\** | [*转义序列*](#escape-sequence) **t** | [*转义序列*](#escape-sequence) **n** | [*转义序列*](#escape-sequence) **r** | [*转义序列*](#escape-sequence) **\"** | [*转义序列*](#escape-sequence) **'** +> *转义字符* → [转义序列](#escape-sequence) **0** | [转义序列](#escape-sequence) **\\** | [转义序列](#escape-sequence) **t** | [转义序列](#escape-sequence) **n** | [转义序列](#escape-sequence) **r** | [转义序列](#escape-sequence) **\"** | [转义序列](#escape-sequence) **'** > -> *转义字符* → [*转义序列*](#escape-sequence) **u {** [*unicode 标量数字*](#unicode-scalar-digits) **}** +> *转义字符* → [转义序列](#escape-sequence) **u {** [unicode 标量数字](#unicode-scalar-digits) **}** > > #### unicode-scalar-digits {#unicode-scalar-digits} @@ -515,43 +524,43 @@ let textB = "Hello world" > #### escaped-newline {#escaped-newline} > -> *转义换行符* → [*转义序列*](#escape-sequence) [*空白*](#whitespace)可选 [*断行符*](#line-break) +> *转义换行符* → [转义序列](#escape-sequence) [空白](#whitespace)可选 [断行符](#line-break) ## 运算符 {#operator} Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../02_language_guide/02_Basic_Operators.md) 和 [高级运算符](../02_language_guide/27_Advanced_Operators.md) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 -自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号（Miscellaneous Symbols）* 以及印刷符号（Dingbats）之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。 +自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号（Miscellaneous Symbols）* 以及*印刷符号（Dingbats）*之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。 -您也可以以点号（`.`）开头来定义自定义运算符。这些运算符可以包含额外的点，例如 `.+.`。如果某个运算符不是以点号开头的，那么它就无法再包含另外的点号了。例如，`+.+` 就会被看作为一个 `+` 运算符后面跟着一个 `.+` 运算符。 +您也可以以点号（`.`）开头来定义自定义运算符。这些运算符可以包含额外的点。例如 `.+.` 会被看作一个单独的运算符。如果某个运算符不是以点号开头的，那么它就无法再包含另外的点号了。例如，`+.+` 就会被看作为一个 `+` 运算符后面跟着一个 `.+` 运算符。 -虽然您可以用问号 `?` 来自定义运算符，但是这个运算符不能只包含单独的一个问号。此外，虽然运算符可以包含一个惊叹号 `!`，但是前缀运算符不能够以问号或者惊叹号开头。 +虽然您可以用问号 `（?）` 来自定义运算符，但是这个运算符不能只包含单独的一个问号。此外，虽然运算符可以包含一个惊叹号 `（!）`，但是前缀运算符不能够以问号或者惊叹号开头。 > 注意 > -> 以下这些标记 `=`、`->`、`//`、`/*`、`*/`、`.`、`<`（前缀运算符）、`&`、`?`、`?`（中缀运算符）、`>`（后缀运算符）、`!` 、`?` 是被系统保留的。这些符号不能被重载，也不能用于自定义运算符。 +> 以下这些标记 `=`、`->`、`//`、`/*`、`*/`、`.`，前缀运算符 `<`、`&` 和 `?`，中缀运算符 `?`，后缀运算符 `>`、`!` 和 `?` 是被系统保留的。这些符号不能被重载，也不能用作自定义运算符。 运算符两侧的空白被用来区分该运算符是否为前缀运算符、后缀运算符或二元运算符。规则总结如下： * 如果运算符两侧都有空白或两侧都无空白，将被看作二元运算符。例如：`a+++b` 和 `a +++ b` 当中的 `+++` 运算符会被看作二元运算符。 * 如果运算符只有左侧空白，将被看作一元前缀运算符。例如 `a +++b` 中的 `+++` 运算符会被看做是一元前缀运算符。 * 如果运算符只有右侧空白，将被看作一元后缀运算符。例如 `a+++ b` 中的 `+++` 运算符会被看作是一元后缀运算符。 -* 如果运算符左侧没有空白并紧跟 `.`，将被看作一元后缀运算符。例如 `a+++.b` 中的 `+++` 运算符会被视为一元后缀运算符（即上式被视为 `a+++ .b` 而不是 `a +++ .b`）。 +* 如果运算符左侧没有空白并紧跟 `（.）`，将被看作一元后缀运算符。例如 `a+++.b` 中的 `+++` 运算符会被视为一元后缀运算符（即上式被视为 `a+++ .b` 而不是 `a +++ .b`）。 -鉴于这些规则，运算符前的字符 `(`、`[` 和 `{`，运算符后的字符 `)`、`]` 和 `}`，以及字符 `,`、`;` 和 `:` 都被视为空白。 +鉴于这些规则，`(`、`[` 和 `{` 是在运算符前面，`)`、`]` 和 `}` 是在运算符后面，以及字符 `,`、`;` 和 `:` 都被视为空白。 -以上规则需注意一点，如果预定义运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选链式调用运算符，左侧必须无空白。如果用于条件运算符 `? :`，必须两侧都有空白。 +以上规则需注意一点。如果预定义运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选链式调用运算符，左侧必须无空白。如果用于条件运算符 `（? :）`，必须两侧都有空白。 -在某些特定的设计中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号，剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的符号，因而不会被错误解析为 `>>` 运算符。 +在某些特定的设计中，以 `<` 或 `>` 开头的运算符会被分离成两个或多个符号。剩余部分可能会以同样的方式被再次分离。因此，在 `Dictionary>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中，闭合字符 `>` 不会被视为单独的符号，因而不会被错误解析为 `>>` 运算符。 -要学习如何自定义运算符，请参考 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom-operators) 和 [运算符声明](./06-Declarations.md#operator-declaration)。要学习如何重载运算符，请参考 [运算符函数](../02-language-guide/27-Advanced-Operators.md#operator-functions)。 +要学习如何自定义运算符，请参考 [自定义运算符](../02_language_guide/27_Advanced_Operators.md#custom-operators) 和 [运算符声明](./06_Declarations.md#operator-declaration)。要学习如何重载运算符，请参考 [运算符函数](../02_language_guide/27_Advanced_Operators.md#operator-functions)。 > 运算符语法 > -> *运算符* → [*头部运算符*](#operator-head) [*运算符字符组*](#operator-characters)可选 +> *运算符* → [头部运算符](#operator-head) [运算符字符组](#operator-characters)可选 > -> *运算符* → [*头部点运算符*](#dot-operator-head) [*点运算符字符组*](#dot-operator-characters) +> *运算符* → [头部点运算符](#dot-operator-head) [点运算符字符组](#dot-operator-characters) > > #### operator-head {#operator-head} @@ -564,9 +573,13 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 > > *头部运算符* → U+00AC 或 U+00AE > -> *头部运算符* → U+00B0–U+00B1，U+00B6，U+00BB，U+00BF，U+00D7，或 U+00F7 +> *头部运算符* → U+00B0–U+00B1 +> +> *头部运算符* → U+00B6，U+00BB，U+00BF，U+00D7，或 U+00F7 > -> *头部运算符* → U+2016–U+2017 或 U+2020–U+2027 +> *头部运算符* → U+2016–U+2017 +> +> *头部运算符* → U+2020–U+2027 > > *头部运算符* → U+2030–U+203E > @@ -584,12 +597,14 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 > > *头部运算符* → U+3001–U+3003 > -> *头部运算符* → U+3008–U+3030 +> *头部运算符* → U+3008–U+3020 +> +> *头部运算符* → U+3030 > > #### operator-character {#operator-character} > -> *运算符字符* → [*头部运算符*](#operator-head) +> *运算符字符* → [头部运算符](#operator-head) > > *运算符字符* → U+0300–U+036F > @@ -606,25 +621,25 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基 > #### operator-characters {#operator-characters} > -> *运算符字符组* → [*运算符字符*](#operator-character) [*运算符字符组*](#operator-characters)可选 +> *运算符字符组* → [运算符字符](#operator-character) [运算符字符组](#operator-characters)可选 > > #### dot-operator-head {#dot-operator-head} > -> *头部点运算符* → **..** +> *头部点运算符* → **.** > > #### dot-operator-character {#dot-operator-character} > -> *点运算符字符* → **.** | [*运算符字符*](#operator-character) +> *点运算符字符* → **.** | [运算符字符](#operator-character) > > #### dot-operator-characters {#dot-operator-characters} > -> *点运算符字符组* → [*点运算符字符*](#dot-operator-character) [*点运算符字符组*](#dot-operator-characters)可选 +> *点运算符字符组* → [点运算符字符](#dot-operator-character) [点运算符字符组](#dot-operator-characters)可选 > -> *二元运算符* → [*运算符*](#operator) +> *二元运算符* → [运算符](#operator) > -> *前缀运算符* → [*运算符*](#operator) +> *前缀运算符* → [运算符](#operator) > -> *后缀运算符* → [*运算符*](#operator) +> *后缀运算符* → [运算符](#operator) From 05be6d4ba7b4575b5198e5966d3347757fc01725 Mon Sep 17 00:00:00 2001 From: tbchen Date: Wed, 16 Oct 2019 14:20:14 +0900 Subject: [PATCH 27/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=BA=E6=AD=A3?= =?UTF-8?q?=E7=A1=AE=E7=9A=84=E8=B6=85=E7=BA=A7=E9=93=BE=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/02_language_guide/08_Enumerations.md | 2 +- source/02_language_guide/13_Inheritance.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/source/02_language_guide/08_Enumerations.md b/source/02_language_guide/08_Enumerations.md index a8ad7ec4..f1b2902d 100755 --- a/source/02_language_guide/08_Enumerations.md +++ b/source/02_language_guide/08_Enumerations.md @@ -273,7 +273,7 @@ let possiblePlanet = Planet(rawValue: 7) > 注意 > -> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见 [可失败构造器](../03_language_reference/05_Declarations.html#failable-initializers)。 +> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见 [可失败构造器](../03_language_reference/06_Declarations.md#failable-initializers)。 如果你试图寻找一个位置为 `11` 的行星，通过原始值构造器返回的可选 `Planet` 值将是 `nil`： diff --git a/source/02_language_guide/13_Inheritance.md b/source/02_language_guide/13_Inheritance.md index a88ff244..6701511c 100755 --- a/source/02_language_guide/13_Inheritance.md +++ b/source/02_language_guide/13_Inheritance.md @@ -184,7 +184,7 @@ print("Car: \(car.description)") #### 重写属性观察器 {#overriding-property-observers} -你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，无论被继承属性原本是如何实现的，当其属性值发生改变时，你就会被通知到。关于属性观察器的更多内容，请看 [属性观察器](../02_language_guide/10_Properties.html#property-observers)。 +你可以通过重写属性为一个继承来的属性添加属性观察器。这样一来，无论被继承属性原本是如何实现的，当其属性值发生改变时，你就会被通知到。关于属性观察器的更多内容，请看 [属性观察器](../02_language_guide/10_Properties.md#property-observers)。 > 注意 > From 1704931ac4f997a84a49c16e5f400f9386f68f39 Mon Sep 17 00:00:00 2001 From: Zhou Fang Date: Sun, 20 Oct 2019 21:52:20 +0800 Subject: [PATCH 28/36] Update Patterns (#1008) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 修复文章排版问题 * 修复图片饮用链接失效问题 * 增加缺失的标点 * 初次修改 * 修改 链接文件格式 * style: 去除 pattern 中右边文字的斜体 * style: 去除 pattern 中右边文字的斜体 * style: 去除错误样式 * chore: 新增枚举用例模式的翻译 --- source/03_language_reference/08_Patterns.md | 87 +++++++++++---------- 1 file changed, 46 insertions(+), 41 deletions(-) diff --git a/source/03_language_reference/08_Patterns.md b/source/03_language_reference/08_Patterns.md index be2e02b7..9a39405a 100755 --- a/source/03_language_reference/08_Patterns.md +++ b/source/03_language_reference/08_Patterns.md @@ -12,21 +12,21 @@ Swift 中的模式分为两类：一种能成功匹配任何类型的值，另 > #### pattern {#pattern} -> *模式* → [*通配符模式*](#wildcard-pattern) [*类型注解*](03-Types.md#type-annotation)可选 +> *模式* → [通配符模式](#wildcard-pattern) [类型注解](03-Types.md#type-annotation)可选 > -> *模式* → [*标识符模式*](#identifier-pattern) [*类型注解*](03-Types.md#type-annotation)可选 +> *模式* → [标识符模式](#identifier-pattern) [类型注解](03-Types.md#type-annotation)可选 > -> *模式* → [*值绑定模式*](#value-binding-pattern) +> *模式* → [值绑定模式](#value-binding-pattern) > -> *模式* → [*元组模式*](#tuple-pattern) [*类型注解*](03-Types.md#type-annotation)可选 +> *模式* → [元组模式](#tuple-pattern) [类型注解](03-Types.md#type-annotation)可选 > -> *模式* → [*枚举用例模式*](#enum-case-pattern) +> *模式* → [枚举用例模式](#enum-case-pattern) > -> *模式* → [*可选模式*](#optional-pattern) +> *模式* → [可选模式](#optional-pattern) > -> *模式* → [*类型转换模式*](#type-casting-pattern) +> *模式* → [类型转换模式](#type-casting-pattern) > -> *模式* → [*表达式模式*](#expression-pattern) +> *模式* → [表达式模式](#expression-pattern) > ## 通配符模式（Wildcard Pattern） {#wildcard-pattern} @@ -41,8 +41,7 @@ for _ in 1...3 { > 通配符模式语法 > - -#### wildcard-pattern {#wildcard-pattern} +> #### wildcard-pattern {#wildcard-pattern} > *通配符模式* → **_** > @@ -59,9 +58,8 @@ let someValue = 42 > 标识符模式语法 > - -#### identifier-pattern {#identifier-pattern} -> *标识符模式* → [*标识符*](./02_Lexical_Structure.md#identifier) +> #### identifier-pattern {#identifier-pattern} +> *标识符模式* → [标识符](./02_Lexical_Structure.md#identifier) > ## 值绑定模式（Value-Binding Pattern） {#value-binding-pattern} @@ -83,9 +81,8 @@ case let (x, y): > 值绑定模式语法 > - -#### value-binding-pattern {#value-binding-pattern} -> *值绑定模式* → **var** [*模式*](#pattern) | **let** [*模式*](#pattern) +> #### value-binding-pattern {#value-binding-pattern} +> *值绑定模式* → **var** [模式](#pattern) | **let** [模式](#pattern) > ## 元组模式 {#tuple-pattern} @@ -113,17 +110,15 @@ let (a): Int = 2 // a: Int = 2 > 元组模式语法 > - -#### tuple-pattern {#tuple-pattern} -> *元组模式* → **(** [*元组模式元素列表*](#tuple-pattern-element-list)可选 **)** +> #### tuple-pattern {#tuple-pattern} +> *元组模式* → **(** [元组模式元素列表](#tuple-pattern-element-list)可选 **)** > #### tuple-pattern-element-list {#tuple-pattern-element-list} -> *元组模式元素列表* → [*元组模式元素*](#tuple-pattern-element) | [*元组模式元素*](#tuple-pattern-element) **,** [*元组模式元素列表*](#tuple-pattern-element-list) +> *元组模式元素列表* → [元组模式元素](#tuple-pattern-element) | [元组模式元素](#tuple-pattern-element) **,** [元组模式元素列表](#tuple-pattern-element-list) > - -#### tuple-pattern-element {#tuple-pattern-element} -> *元组模式元素* → [*模式*](#pattern) +> #### tuple-pattern-element {#tuple-pattern-element} +> *元组模式元素* → [模式](#pattern) > ## 枚举用例模式（Enumeration Case Pattern） {#enumeration-case-pattern} @@ -131,11 +126,26 @@ let (a): Int = 2 // a: Int = 2 如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用 `switch` 语句来匹配包含关联值的枚举用例的例子，请参阅 [关联值](../02_language_guide/08_Enumerations.md#associated-values)。 +枚举用例模式同样会匹配那些被包装成可选值的用例。简化的语法能将可选模式过滤掉。注意，由于 `Optional` 是枚举实现的，`.none` 和 `.some` 都会作为枚举类型的用例出现在 switch 中。 + +```swift +enum SomeEnum { case left, right } +let x: SomeEnum? = .left +switch x { +case .left: + print("Turn left") +case .right: + print("Turn right") +case nil: + print("Keep going straight") +} +// 打印 "Turn left" +``` + > 枚举用例模式语法 > - -#### enum-case-pattern {#enum-case-pattern} -> *枚举用例模式* → [*类型标识*](./03_Types.md#type-identifier)可选 **.** [*枚举用例名*](./06-Declarations.md#enum-case-name) [*元组模式*](#tuple-pattern)可选 +> #### enum-case-pattern {#enum-case-pattern} +> *枚举用例模式* → [类型标识](./03_Types.md#type-identifier)可选 **.** [枚举用例名](./06-Declarations.md#enum-case-name) [元组模式](#tuple-pattern)可选 > ## 可选模式（Optional Pattern） {#optional-pattern} @@ -171,9 +181,8 @@ for case let number? in arrayOfOptinalInts { > 可选模式语法 > - -#### optional-pattern {#optional-pattern} -> *可选模式* → [*标识符模式*](./03_Types.md#type-identifier) **?** +> #### optional-pattern {#optional-pattern} +> *可选模式* → [标识符模式](./03_Types.md#type-identifier) **?** > ## 类型转换模式（Type-Casting Patterns） {#type-casting-patterns} @@ -192,17 +201,14 @@ for case let number? in arrayOfOptinalInts { > 类型转换模式语法 > - -#### type-casting-pattern {#type-casting-pattern} -> *类型转换模式* → [*is 模式*](#is-pattern) | [*as 模式*](#as-pattern) +> #### type-casting-pattern {#type-casting-pattern} +> *类型转换模式* → [is 模式](#is-pattern) | [as 模式](#as-pattern) > - -#### is-pattern {#is-pattern} -> *is 模式* → **is** [*类型*](./03_Types.md#type) +> #### is-pattern {#is-pattern} +> *is 模式* → **is** [类型](./03_Types.md#type) > - -#### as-pattern {#as-pattern} -> *as 模式* → [*模式*](#pattern) **as** [*类型*](03-Types.md#type) +> #### as-pattern {#as-pattern} +> *as 模式* → [模式](#pattern) **as** [类型](03-Types.md#type) > ## 表达式模式（Expression Pattern） {#expression-pattern} @@ -242,7 +248,6 @@ default: > 表达式模式语法 > - -#### expression-pattern {#expression-pattern} -> *表达式模式* → [*表达式*](./04_Expressions.md#expression) +> #### expression-pattern {#expression-pattern} +> *表达式模式* → [表达式](./04_Expressions.md#expression) > From 3434b008ebe57760682a686cf543e47d4eeec8c3 Mon Sep 17 00:00:00 2001 From: tbchen Date: Mon, 21 Oct 2019 22:45:37 +0900 Subject: [PATCH 29/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9=20!=3D=3D=20=E4=B8=BA?= =?UTF-8?q?=20!=3D=20=E8=BF=90=E7=AE=97=E7=AC=A6=E3=80=82=20(#1009)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/02_language_guide/09_Structures_And_Classes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/02_language_guide/09_Structures_And_Classes.md b/source/02_language_guide/09_Structures_And_Classes.md index 31537451..9c63ad50 100755 --- a/source/02_language_guide/09_Structures_And_Classes.md +++ b/source/02_language_guide/09_Structures_And_Classes.md @@ -243,7 +243,7 @@ if tenEighty === alsoTenEighty { 请注意，“相同”（用三个等号表示，`===`）与“等于”（用两个等号表示，`==`）的不同。“相同”表示两个类类型（class type）的常量或者变量引用同一个类实例。“等于”表示两个实例的值“相等”或“等价”，判定时要遵照设计者定义的评判标准。 -当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./27_Advanced_Operators.md#equivalence-operators) 中将会详细介绍实现自定义 == 和 !== 运算符的流程。 +当在定义你的自定义结构体和类的时候，你有义务来决定判定两个实例“相等”的标准。在章节 [等价操作符](./27_Advanced_Operators.md#equivalence-operators) 中将会详细介绍实现自定义 == 和 != 运算符的流程。 ### 指针 {#pointers} From eeda1ed0ed88f2ee146d7be787feb88a6d03f4ea Mon Sep 17 00:00:00 2001 From: Jie Liang Date: Sat, 26 Oct 2019 08:03:14 -0500 Subject: [PATCH 30/36] update according to #1010 --- source/01_welcome_to_swift/02_version_compatibility.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/01_welcome_to_swift/02_version_compatibility.md b/source/01_welcome_to_swift/02_version_compatibility.md index 4a501b68..2e063b9e 100755 --- a/source/01_welcome_to_swift/02_version_compatibility.md +++ b/source/01_welcome_to_swift/02_version_compatibility.md @@ -2,10 +2,10 @@ 本书描述的是在 Xcode 11 中的默认 Swift 版本 Swift 5.1。你可以使用 Xcode11 来构建 Swift 5.1、Swift 4.2 或 Swift 4 写的项目。 -当您使用 Xcode 11 构建 Swift 4 和 Swift 4.2 代码时，除了下面的功能仅支持 Swift 5.1，其他大多数功能都依然可用。 +当您使用 Xcode 11 构建 Swift 4 和 Swift 4.2 代码时，Swift 5.1 的大多数功能都适用。但以下功能仅支持 Swift 5.1 或更高版本: * 返回值是不透明类型的函数依赖 Swift 5.1 运行时。 * **try?** 表达式不会为已返回可选类型的代码引入额外的可选类型层级。 * 大数字的整型字面量初始化代码的类型将会被正确推导，例如 **UInt64(0xffff_ffff_ffff_ffff)** 将会被推导为整型类型而非溢出。 -用 Swift 5.1 写的项目可以依赖用 Swift 4.2 或 Swift 4 写的项目，反之亦然。这意味着，如果你将一个大的项目分解成多个框架（framework），你可以每次一个框架地迁移 Swift 4 代码到 Swift 5.1。 +用 Swift 5.1 写的项目可以依赖用 Swift 4.2 或 Swift 4 写的项目，反之亦然。这意味着，如果你将一个大的项目分解成多个框架（framework），你可以逐个地将框架从 Swift 4 代码迁移到 Swift 5.1。 From dfd3383bd093d9f9dc8d93334d550e8d5a92963d Mon Sep 17 00:00:00 2001 From: Phenmod Date: Wed, 30 Oct 2019 17:02:03 +0800 Subject: [PATCH 31/36] =?UTF-8?q?=E6=9C=AB=E5=B0=BE=E5=BC=95=E5=8F=B7?= =?UTF-8?q?=E5=BC=80=E5=A7=8B=E5=88=97=E4=B9=8B=E5=90=8E=E7=9A=84=E5=86=85?= =?UTF-8?q?=E5=AE=B9=E7=BC=A9=E8=BF=9B=E4=B8=8D=E4=BC=9A=E8=A2=AB=E5=88=A0?= =?UTF-8?q?=E9=99=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/01_welcome_to_swift/03_a_swift_tour.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/01_welcome_to_swift/03_a_swift_tour.md b/source/01_welcome_to_swift/03_a_swift_tour.md index 9eeeff67..8240ffc4 100755 --- a/source/01_welcome_to_swift/03_a_swift_tour.md +++ b/source/01_welcome_to_swift/03_a_swift_tour.md @@ -65,7 +65,7 @@ let fruitSummary = "I have \(apples + oranges) pieces of fruit." > > 使用 `\()` 来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。 -使用三个双引号（`"""`）来包含多行字符串内容，字符串中的内容（包括引号、空格、换行符等）都会保留下来。举个例子： +使用三个双引号（`"""`）来包含多行字符串内容。每行行首的缩进会被删掉，一直删到块末三个双引号缩进到的那一列。举个例子： ```swift let quotation = """ From 8d0a87909eb9204c33a4c860d3728be5debf87d1 Mon Sep 17 00:00:00 2001 From: Phenmod Date: Wed, 30 Oct 2019 17:17:46 +0800 Subject: [PATCH 32/36] =?UTF-8?q?=E5=B0=91=E4=B8=80=E6=AE=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/01_welcome_to_swift/03_a_swift_tour.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/source/01_welcome_to_swift/03_a_swift_tour.md b/source/01_welcome_to_swift/03_a_swift_tour.md index 8240ffc4..917ad358 100755 --- a/source/01_welcome_to_swift/03_a_swift_tour.md +++ b/source/01_welcome_to_swift/03_a_swift_tour.md @@ -87,6 +87,13 @@ var occupations = [ occupations["Jayne"] = "Public Relations" ``` +数组在添加元素时会自动变大。 + +```swift +shoppingList.append("blue paint") +print(shoppingList) +``` + 使用初始化语法来创建一个空数组或者空字典。 ```swift From 1f0844bb367b45d39e04ffd76de14315e0fb2578 Mon Sep 17 00:00:00 2001 From: Phenmod Date: Wed, 30 Oct 2019 17:27:43 +0800 Subject: [PATCH 33/36] =?UTF-8?q?=E8=B5=8B=E6=96=B0=E5=80=BC=E6=88=96?= =?UTF-8?q?=E8=80=85=E4=BC=A0=E5=8F=82=E6=97=B6=EF=BC=8C=E7=B1=BB=E5=9E=8B?= =?UTF-8?q?=E5=8F=AF=E6=8E=A8=E5=AE=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/01_welcome_to_swift/03_a_swift_tour.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/01_welcome_to_swift/03_a_swift_tour.md b/source/01_welcome_to_swift/03_a_swift_tour.md index 917ad358..879cf8a6 100755 --- a/source/01_welcome_to_swift/03_a_swift_tour.md +++ b/source/01_welcome_to_swift/03_a_swift_tour.md @@ -101,7 +101,7 @@ let emptyArray = [String]() let emptyDictionary = [String: Float]() ``` -如果类型信息可以被推断出来，你可以用 `[]` 和 `[:]` 来创建空数组和空字典——就像你声明变量或者给函数传参数的时候一样。 +如果类型信息可以被推断出来，你可以用 `[]` 和 `[:]` 来创建空数组和空字典——比如，在给变量赋新值或者给函数传参数的时候。 ```swift shoppingList = [] From 3063f18a7890daded266a641155eb12598bc094f Mon Sep 17 00:00:00 2001 From: Phenmod Date: Wed, 30 Oct 2019 20:57:18 +0800 Subject: [PATCH 34/36] =?UTF-8?q?=E6=94=B9=E8=BF=9B=E4=BA=9B=E5=B0=8F?= =?UTF-8?q?=E7=BF=BB=E8=AF=91=E5=92=8C=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/01_welcome_to_swift/03_a_swift_tour.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/source/01_welcome_to_swift/03_a_swift_tour.md b/source/01_welcome_to_swift/03_a_swift_tour.md index 879cf8a6..2433ac2a 100755 --- a/source/01_welcome_to_swift/03_a_swift_tour.md +++ b/source/01_welcome_to_swift/03_a_swift_tour.md @@ -145,6 +145,7 @@ if let name = optionalName { > 把 `optionalName` 改成 `nil`，greeting 会是什么？添加一个 `else` 语句，当 `optionalName` 是 `nil` 时给 greeting 赋一个不同的值。 如果变量的可选值是 `nil`，条件会判断为 `false`，大括号中的代码会被跳过。如果不是 `nil`，会将值解包并赋给 `let` 后面的常量，这样代码块中就可以使用这个值了。 + 另一种处理可选值的方法是通过使用 `??` 操作符来提供一个默认值。如果可选值缺失的话，可以使用默认值来代替。 ```swift @@ -241,7 +242,7 @@ greet(person:"Bob", day: "Tuesday") > 练习 > -> 删除 `day` 参数，添加一个参数来表示今天吃了什么午饭。 +> 删除 `day` 参数，在这个欢迎语中添加一个参数来表示今天的特价菜。 默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用 `_` 表示不使用参数标签。 @@ -321,7 +322,7 @@ var numbers = [20, 19, 7, 12] hasAnyMatches(list: numbers, condition: lessThanTen) ``` -函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包作用域中的变量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数的例子中看过了。你可以使用 `{}` 来创建一个匿名闭包。使用 `in` 将参数和返回值类型的声明与闭包函数体进行分离。 +函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包作用域中的变量和函数，即使闭包是在一个不同的作用域被执行的——你已经在嵌套函数的例子中看过了。你可以使用 `{}` 来创建一个匿名闭包。使用 `in` 将参数和返回值类型的声明与闭包函数体进行分离。 ```swift numbers.map({ @@ -342,7 +343,7 @@ let mappedNumbers = numbers.map({ number in 3 * number }) print(mappedNumbers) ``` -你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。 +你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在圆括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略圆括号。 ```swift let sortedNumbers = numbers.sorted { $0 > $1 } From 273a7bdd3b0abbc712aab7002694c6700d8ef25b Mon Sep 17 00:00:00 2001 From: Phenmod Date: Fri, 1 Nov 2019 16:03:53 +0800 Subject: [PATCH 35/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=83=A8=E5=88=86?= =?UTF-8?q?=E7=BF=BB=E8=AF=91=20&=20=E9=83=A8=E5=88=86=E5=8E=9F=E6=96=87?= =?UTF-8?q?=E6=9C=89=E6=94=B9=E5=8A=A8=E9=9C=80=E8=A6=81=E9=87=8D=E6=96=B0?= =?UTF-8?q?=E7=BF=BB=E8=AF=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/01_welcome_to_swift/03_a_swift_tour.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/source/01_welcome_to_swift/03_a_swift_tour.md b/source/01_welcome_to_swift/03_a_swift_tour.md index 2433ac2a..f02a523f 100755 --- a/source/01_welcome_to_swift/03_a_swift_tour.md +++ b/source/01_welcome_to_swift/03_a_swift_tour.md @@ -427,7 +427,7 @@ test.simpleDescription() > > 创建 `NamedShape` 的另一个子类 `Circle`，构造器接收两个参数，一个是半径一个是名称，在子类 `Circle` 中实现 `area()` 和 `simpleDescription()` 方法。 -除了储存简单的属性之外，属性可以有 getter 和 setter 。 +除了简单的储存值的属性，还有使用 getter 和 setter 的计算属性。 ```swift class EquilateralTriangle: NamedShape { @@ -458,7 +458,7 @@ triangle.perimeter = 9.9 print(triangle.sideLength) ``` -在 `perimeter` 的 setter 中，新值的名字是 `newValue`。你可以在 `set` 之后显式的设置一个名字。 +在 `perimeter` 的 setter 中，新值的名字是 `newValue`。你可以在 `set` 之后的圆括号中显式的设置一个名字。 注意 `EquilateralTriangle` 类的构造器执行了三步： @@ -492,7 +492,7 @@ triangleAndSquare.square = Square(sideLength: 50, name: "larger square") print(triangleAndSquare.triangle.sideLength) ``` -处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加 `?`。如果 `?` 之前的值是 `nil`，`?` 后面的东西都会被忽略，并且整个表达式返回 `nil`。否则，`?` 之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。 +处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加 `?`。如果 `?` 之前的值是 `nil`，`?` 后面的东西都会被忽略，并且整个表达式返回 `nil`。否则，可选值会被解包，之后的所有代码都会按照解包后的值运行。在这两种情况下，整个表达式的值也是一个可选值。 ```swift let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square") @@ -533,7 +533,7 @@ let aceRawValue = ace.rawValue 默认情况下，Swift 按照从 0 开始每次加 1 的方式为原始值进行赋值，不过你可以通过显式赋值进行改变。在上面的例子中，`Ace` 被显式赋值为 1，并且剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。使用 `rawValue` 属性来访问一个枚举成员的原始值。 -使用 `init?(rawValue:)` 初始化构造器来创建一个带有原始值的枚举成员。如果存在与原始值相应的枚举成员就返回该枚举成员，否则就返回 `nil`。 +使用 `init?(rawValue:)` 初始化构造器来从原始值创建一个枚举实例。如果存在与原始值相应的枚举成员就返回该枚举成员，否则就返回 `nil`。 ```swift if let convertedRank = Rank(rawValue: 3) { @@ -567,9 +567,9 @@ let heartsDescription = hearts.simpleDescription() > > 给 `Suit` 添加一个 `color()` 方法，对 `spades` 和 `clubs` 返回 “black” ，对 `hearts` 和 `diamonds` 返回 “red” 。 -注意在上面的例子中用了两种方式引用 `hearts` 枚举成员：给 `hearts` 常量赋值时，枚举成员 `Suit.hearts` 需要用全名来引用，因为常量没有显式指定类型。在 `switch` 里，枚举成员使用缩写 `.hearts` 来引用，因为 `self` 的值已经是一个 `suit` 类型，在已知变量类型的情况下可以使用缩写。 +注意在上面的例子中用了两种方式引用 `hearts` 枚举成员：给 `hearts` 常量赋值时，枚举成员 `Suit.hearts` 需要用全名来引用，因为常量没有显式指定类型。在 `switch` 里，枚举成员使用缩写 `.hearts` 来引用，因为 `self` 的值已经是一个 `suit` 类型。在任何已知变量类型的情况下都可以使用缩写。 -如果枚举成员的实例有原始值，那么这些值是在声明的时候就已经决定了，这意味着不同枚举实例的枚举成员总会有一个相同的原始值。当然我们也可以为枚举成员设定关联值，关联值是在创建实例时决定的。这意味着不同的枚举成员的关联值都可以不同。你可以把关联值想象成枚举成员的寄存属性。例如，考虑从服务器获取日出和日落的时间的情况。服务器会返回正常结果或者错误信息。 +如果枚举成员的实例有原始值，那么这些值是在声明的时候就已经决定了，这意味着不同枚举实例的枚举成员总会有一个相同的原始值。当然我们也可以为枚举成员设定关联值，关联值是在创建实例时决定的。这意味着同一枚举成员的不同实例的关联值是可以不相同的。你可以把关联值想象成枚举成员实例的存储属性。例如，考虑从服务器获取日出和日落的时间的情况。服务器会返回正常结果或者错误信息。 ```swift enum ServerResponse { @@ -592,7 +592,7 @@ case let .failure(message): > > 给 `ServerResponse` 和 switch 添加第三种情况。 -注意日升和日落时间是如何从 `ServerResponse` 中提取到并与 `switch` 的 `case` 相匹配的。 +注意 `ServerResponse` 的值在与 `switch` 的分支匹配时，日升和日落时间是如何从该值中提取出来的。 使用 `struct` 来创建一个结构体。结构体和类有很多相同的地方，包括方法和构造器。它们之间最大的一个区别就是结构体是传值，类是传引用。 @@ -610,7 +610,7 @@ let threeOfSpadesDescription = threeOfSpades.simpleDescription() > 练习 > -> 给 `Card` 添加一个方法，创建一副完整的扑克牌并把每张牌的 rank 和 suit 对应起来。 +> 写一个方法，创建一副完整的扑克牌，这些牌是所有 rank 和 suit 的组合。 ## 协议和扩展 {#protocols-and-extensions} @@ -650,7 +650,7 @@ let bDescription = b.simpleDescription > 练习 > -> 写一个实现这个协议的枚举。 +> 给 `ExampleProtocol` 增加一个要求。你需要怎么改 `SimpleClass` 和 `SimpleStructure` 才能保证它们仍旧遵循这个协议？ 注意声明 `SimpleStructure` 时候 `mutating` 关键字用来标记一个会修改结构体的方法。`SimpleClass` 的声明不需要标记任何方法，因为类中的方法通常可以修改类属性（类的性质）。 From 7a115a996a2a80693410fdacd8dc98ff2d64f642 Mon Sep 17 00:00:00 2001 From: Phenmod Date: Mon, 4 Nov 2019 10:53:16 +0800 Subject: [PATCH 36/36] =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- source/01_welcome_to_swift/03_a_swift_tour.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source/01_welcome_to_swift/03_a_swift_tour.md b/source/01_welcome_to_swift/03_a_swift_tour.md index f02a523f..d87b8388 100755 --- a/source/01_welcome_to_swift/03_a_swift_tour.md +++ b/source/01_welcome_to_swift/03_a_swift_tour.md @@ -65,7 +65,7 @@ let fruitSummary = "I have \(apples + oranges) pieces of fruit." > > 使用 `\()` 来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。 -使用三个双引号（`"""`）来包含多行字符串内容。每行行首的缩进会被删掉，一直删到块末三个双引号缩进到的那一列。举个例子： +使用三个双引号（`"""`）来包含多行字符串内容。每行行首的缩进会被去除，直到和结尾引号的缩进相匹配。举个例子： ```swift let quotation = """ @@ -427,7 +427,7 @@ test.simpleDescription() > > 创建 `NamedShape` 的另一个子类 `Circle`，构造器接收两个参数，一个是半径一个是名称，在子类 `Circle` 中实现 `area()` 和 `simpleDescription()` 方法。 -除了简单的储存值的属性，还有使用 getter 和 setter 的计算属性。 +除了简单的存储属性，还有使用 getter 和 setter 的计算属性。 ```swift class EquilateralTriangle: NamedShape { @@ -458,7 +458,7 @@ triangle.perimeter = 9.9 print(triangle.sideLength) ``` -在 `perimeter` 的 setter 中，新值的名字是 `newValue`。你可以在 `set` 之后的圆括号中显式的设置一个名字。 +在 `perimeter` 的 setter 中，新值的名字是 `newValue`。你可以在 `set` 之后的圆括号中显式地设置一个名字。 注意 `EquilateralTriangle` 类的构造器执行了三步： @@ -569,7 +569,7 @@ let heartsDescription = hearts.simpleDescription() 注意在上面的例子中用了两种方式引用 `hearts` 枚举成员：给 `hearts` 常量赋值时，枚举成员 `Suit.hearts` 需要用全名来引用，因为常量没有显式指定类型。在 `switch` 里，枚举成员使用缩写 `.hearts` 来引用，因为 `self` 的值已经是一个 `suit` 类型。在任何已知变量类型的情况下都可以使用缩写。 -如果枚举成员的实例有原始值，那么这些值是在声明的时候就已经决定了，这意味着不同枚举实例的枚举成员总会有一个相同的原始值。当然我们也可以为枚举成员设定关联值，关联值是在创建实例时决定的。这意味着同一枚举成员的不同实例的关联值是可以不相同的。你可以把关联值想象成枚举成员实例的存储属性。例如，考虑从服务器获取日出和日落的时间的情况。服务器会返回正常结果或者错误信息。 +如果枚举成员的实例有原始值，那么这些值是在声明的时候就已经决定了，这意味着不同枚举实例的枚举成员总会有一个相同的原始值。当然我们也可以为枚举成员设定关联值，关联值是在创建实例时决定的。这意味着同一枚举成员不同实例的关联值可以不相同。你可以把关联值想象成枚举成员实例的存储属性。例如，考虑从服务器获取日出和日落的时间的情况。服务器会返回正常结果或者错误信息。 ```swift enum ServerResponse { @@ -650,7 +650,7 @@ let bDescription = b.simpleDescription > 练习 > -> 给 `ExampleProtocol` 增加一个要求。你需要怎么改 `SimpleClass` 和 `SimpleStructure` 才能保证它们仍旧遵循这个协议？ +> 给 `ExampleProtocol` 再增加一个要求。你需要怎么改 `SimpleClass` 和 `SimpleStructure` 才能保证它们仍旧遵循这个协议？ 注意声明 `SimpleStructure` 时候 `mutating` 关键字用来标记一个会修改结构体的方法。`SimpleClass` 的声明不需要标记任何方法，因为类中的方法通常可以修改类属性（类的性质）。