diff --git a/source/chapter1/01_about_swift.md b/source/chapter1/01_about_swift.md index c35770b7..9f88d035 100755 --- a/source/chapter1/01_about_swift.md +++ b/source/chapter1/01_about_swift.md @@ -25,7 +25,7 @@ Swift 是一种非常好的编写软件的方式，无论是手机，台式机，服务器，还是其他运行代码的设备。它是一种安全，快速和互动的编程语言，将现代编程语言的精华和苹果工程师文化的智慧，以及来自开源社区的多样化贡献结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。 -Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的系统编程语言。它支持代码预览(playgrounds)，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。 +Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的系统编程语言。它支持代码预览（playgrounds），这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。 Swift 通过采用现代编程模式来避免大量常见编程错误： diff --git a/source/chapter1/03_a_swift_tour.md b/source/chapter1/03_a_swift_tour.md index 69ba7f49..69a6b355 100755 --- a/source/chapter1/03_a_swift_tour.md +++ b/source/chapter1/03_a_swift_tour.md @@ -231,7 +231,7 @@ print(largest) > 练习 > -> 添加另一个变量来记录最大数字的种类(kind)，同时仍然记录这个最大数字的值。 +> 添加另一个变量来记录最大数字的种类（kind），同时仍然记录这个最大数字的值。 使用 `while` 来重复运行一段代码直到条件改变。循环条件也可以在结尾，保证能至少循环一次。 diff --git a/source/chapter1/04_revision_history.md b/source/chapter1/04_revision_history.md index 56a20332..cf7deaf8 100644 --- a/source/chapter1/04_revision_history.md +++ b/source/chapter1/04_revision_history.md @@ -232,7 +232,7 @@
  • - 更新逃逸闭包一节，现在闭包默认为非逃逸的(noescaping)。 + 更新逃逸闭包一节，现在闭包默认为非逃逸的（noescaping）。
  • 更新基础部分章节中可选绑定一节和语句章节中While 语句一节，现在 if，while 和 guard 语句使用逗号分隔条件列表，不需要使用 where 语句。 @@ -344,7 +344,7 @@ 增加了关键字和标点符号一节中关于使用关键字作为外部参数名的信息。
  • - 增加了声明特性一节中关于@objc特性的讨论，并指出枚举(Enumeration)和枚举用例(Enumaration Case)。 + 增加了声明特性一节中关于@objc特性的讨论，并指出枚举（Enumeration)和枚举用例(Enumaration Case）。
  • 增加了操作符一节中对于自定义运算符的讨论包含了.。 @@ -391,28 +391,28 @@ 更新至 Swift 2.1。
  • - 更新了字符串插值(String Interprolation)和字符串字面量(String Literals)小节，现在字符串插值可包含字符串字面量。 + 更新了字符串插值（String Interprolation)和字符串字面量(String Literals）小节，现在字符串插值可包含字符串字面量。
  • - 增加了在非逃逸闭包(Nonescaping Closures)一节中关于 @noescape 属性的相关内容。 + 增加了在非逃逸闭包（Nonescaping Closures）一节中关于 @noescape 属性的相关内容。
  • - 更新了声明特性(Declaration Attributes)和编译配置语句(Build Configuration Statement)小节中与 tvOS 相关的信息。 + 更新了声明特性（Declaration Attributes）和编译配置语句（Build Configuration Statement）小节中与 tvOS 相关的信息。
  • - 增加了 In-Out 参数(In-Out Parameters)小节中与 in-out 参数行为相关的信息。 + 增加了 In-Out 参数（In-Out Parameters）小节中与 in-out 参数行为相关的信息。
  • - 增加了在捕获列表(Capture Lists)一节中关于指定闭包捕获列表被捕获时捕获值的相关内容。 + 增加了在捕获列表（Capture Lists）一节中关于指定闭包捕获列表被捕获时捕获值的相关内容。
  • - 更新了通过可选链式调用访问属性(Accessing Properties Through Optional Chaining)一节，阐明了如何通过可选链式调用进行赋值。 + 更新了通过可选链式调用访问属性（Accessing Properties Through Optional Chaining）一节，阐明了如何通过可选链式调用进行赋值。
  • - 改进了自闭包(Autoclosure)一节中对自闭包的讨论。 + 改进了自闭包（Autoclosure）一节中对自闭包的讨论。
  • - 在Swift 初见(A Swift Tour)一节中更新了一个使用??操作符的例子。 + 在Swift 初见（A Swift Tour）一节中更新了一个使用??操作符的例子。
    • @@ -593,7 +593,7 @@ 增加了一个新的指导章节，它是关于字符串索引的
  • - 从溢出运算符中移除了溢出除运算符(&/)和求余溢出运算符(&%)。 + 从溢出运算符中移除了溢出除运算符（&/）和求余溢出运算符（&%）。
  • 更新了常量和常量属性在声明和构造时的规则，更多信息，请看常量声明 @@ -661,7 +661,7 @@ 更新至 Swift 1.1。
  • - 增加了关于失败构造器(Failable Initializers)的完整章节。 + 增加了关于失败构造器（Failable Initializers）的完整章节。
  • 增加了协议中关于失败构造器要求的描述。 @@ -670,10 +670,10 @@ 常量和变量的 Any 类型现可以包含函数实例。更新了关于 Any 相关的示例来展示如何在 switch 语句中如何检查并转换到一个函数类型。
  • - 带有原始值的枚举类型增加了一个rawValue属性替代toRaw()方法，同时使用了一个以rawValue为参数的失败构造器来替代fromRaw()方法。更多的信息，请看原始值(Raw Values)和带原始值的枚举类型(Enumerations with Cases of a Raw-Value Type)部分。 + 带有原始值的枚举类型增加了一个rawValue属性替代toRaw()方法，同时使用了一个以rawValue为参数的失败构造器来替代fromRaw()方法。更多的信息，请看原始值（Raw Values）和带原始值的枚举类型（Enumerations with Cases of a Raw-Value Type）部分。
  • - 自定义运算符现在可以包含 `?` 字符，更新的运算符(Operators)章节描述了改进后的规则，并且从自定义运算符(Custom Operators)章节删除了重复的运算符有效字符集合 + 自定义运算符现在可以包含 `?` 字符，更新的运算符（Operators）章节描述了改进后的规则，并且从自定义运算符（Custom Operators）章节删除了重复的运算符有效字符集合
    • @@ -706,7 +706,7 @@ 在章节协议中，增加新的小节：类专属协议（class-only protocols）
  • - 断言(assertions)现在可以使用字符串内插语法，并删除了文档中有冲突的注释 + 断言（assertions）现在可以使用字符串内插语法，并删除了文档中有冲突的注释
  • 更新了连接字符串和字符（Concatenating Strings and Characters）小节来说明一个事实，那就是字符串和字符不能再用+号运算符或者复合加法运算符+=相互连接，这两种运算符现在只能用于字符串之间相连。请使用String类型的append方法在一个字符串的尾部增加单个字符 @@ -721,7 +721,7 @@ Swift 新增了一个 Nil 合并运算符（Nil Coalescing Operator） (a ?? b), 该表达式中，如果 Optional a的值存在，则取得它并返回，若 Optional a为nil，则返回默认值 b
  • - 更新和扩展 字符串的比较（Comparing Strings） 章节，用以反映和展示'字符串和字符的比较'，以及'前缀（prefix）/后缀(postfix)比较'都开始基于扩展字符集(extended grapheme clusters)规范的等价比较。 + 更新和扩展 字符串的比较（Comparing Strings） 章节，用以反映和展示'字符串和字符的比较'，以及'前缀（prefix）/后缀（postfix）比较'都开始基于扩展字符集（extended grapheme clusters）规范的等价比较。
  • 现在，你可以通过 可选链（Optional Chaining）来：给属性设值，将其赋给一个下标脚注（subscript）; 或调用一个变异（mutating）方法或运算符。对此，章节——通过可选链访问属性（Accessing Properties Through Optional Chaining）的内容已经被相应的更新。而章节——通过可选链调用方法（Calling Methods Through Optional Chaining中，关于检查方法调用是否成功的例子，已被扩展为展示如何检查一个属性是否被设值成功。 @@ -731,7 +731,7 @@ 在章节可选链中，增加一个新的小节 访问可选类型的下标脚注（Accessing Subscripts of Optional Type）
  • - 更新章节 访问和修改数组(Accessing and Modifying an Array) 以标示：从该版本起，不能再通过+= 运算符给一个数组添加一个新的项。。 对应的替代方案是，使append 方法，或者通过+=运算符来添加一个只有一个项的数组（single-item Array）。
    • + 更新章节 访问和修改数组（Accessing and Modifying an Array） 以标示：从该版本起，不能再通过+= 运算符给一个数组添加一个新的项。。 对应的替代方案是，使append 方法，或者通过+=运算符来添加一个只有一个项的数组（single-item Array）。
  • 添加了一个提示：在 范围运算符（Range Operators）中，比如， a...b 和 a..<b ，起始值a不能大于结束值b.
    • @@ -748,10 +748,10 @@ 中置（Infix）的 运算符函数（Operator Functions） 不再需要@infix 属性。
  • - 前置和后置运算符(Prefix and Postfix Operators)的@prefix 和 @postfix 属性，已变更为 prefix 和 postfix 声明修饰符（declaration modifiers）。 + 前置和后置运算符（Prefix and Postfix Operators）的@prefix 和 @postfix 属性，已变更为 prefix 和 postfix 声明修饰符（declaration modifiers）。
  • - 增加一条注解：当 Prefix 和 postfix 运算符被作用于同一个操作数时，关于前置和后置运算符(Prefix and Postfix Operators)的顺序(postfix 运算符会先被执行) + 增加一条注解：当 Prefix 和 postfix 运算符被作用于同一个操作数时，关于前置和后置运算符（Prefix and Postfix Operators）的顺序（postfix 运算符会先被执行）
  • 在运算符函数（Operator functions）中， 组合赋值运算符（Compound Assignment Operators） 不再使用 @assignment 属性来定义函数。 @@ -772,7 +772,7 @@ 加入新的章节 权限控制（Access Control）.
  • - 更新了章节 字符串和字符（Strings and Characters） 用以表明，在 Swift 中，Character 类型现在代表的是扩展字符集(extended grapheme cluster)中的一个 Unicode，为此，新增了小节 Extended Grapheme Clusters 。同时，为小节 Unicode 标量（Unicode Scalars） 和 字符串比较（Comparing Strings）增加了更多内容。 + 更新了章节 字符串和字符（Strings and Characters） 用以表明，在 Swift 中，Character 类型现在代表的是扩展字符集（extended grapheme cluster）中的一个 Unicode，为此，新增了小节 Extended Grapheme Clusters 。同时，为小节 Unicode 标量（Unicode Scalars） 和 字符串比较（Comparing Strings）增加了更多内容。
  • 更新章节字符串字面量（String Literals）：在一个字符串中，Unicode 标量（Unicode scalars） 以 \u{n}的形式来表示，n 是一个最大可以有8位的16进制数（hexadecimal digits） @@ -823,7 +823,7 @@ 加入新的小节：字典键类型的哈希值（Hash Values for Dictionary Key Types).
  • - 例子 闭包表达式 (Closure Expressions) 中使用新的全局函数 sorted 取代原先的全局函数 sort 去展示如何返回一个全新的数组。 + 例子 闭包表达式（Closure Expressions） 中使用新的全局函数 sorted 取代原先的全局函数 sort 去展示如何返回一个全新的数组。
  • 更新关于 结构体逐一成员构造器 （Memberwise Initializers for Structure Types） 的描述：即使结构体的成员没有默认值，逐一成员构造器也可以自动获得。 diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md index a798b1c2..d2eceeb3 100755 --- a/source/chapter2/01_The_Basics.md +++ b/source/chapter2/01_The_Basics.md @@ -29,32 +29,34 @@ 本页包含内容： - [常量和变量](#constants_and_variables) -- [声明常量和变量](#declaring) -- [类型标注](#type_annotations) -- [常量和变量的命名](#naming) -- [输出常量和变量](#printing) + - [声明常量和变量](#declaring) + - [类型标注](#type_annotations) + - [常量和变量的命名](#naming) + - [输出常量和变量](#printing) - [注释](#comments) - [分号](#semicolons) - [整数](#integers) -- [整数范围](#integer_bounds) -- [Int](#Int) -- [UInt](#UInt) + - [整数范围](#integer_bounds) + - [Int](#Int) + - [UInt](#UInt) - [浮点数](#floating-point_numbers) - [类型安全和类型推断](#type_safety_and_type_inference) - [数值型字面量](#numeric_literals) - [数值型类型转换](#numeric_type_conversion) -- [整数转换](#integer_conversion) -- [数整数和浮点数转换](#integer_and_floating_point_conversion) + - [整数转换](#integer_conversion) + - [数整数和浮点数转换](#integer_and_floating_point_conversion) - [类型别名](#type_aliases) - [布尔值](#booleans) - [元组](#tuples) -- [可选](#optionals) -- [nil](#nil) -- [if 语句以及强制解析](#if) -- [可选绑定](#optional_binding) -- [隐式解析可选类型](#implicityly_unwrapped_optionals) +- [可选类型](#optionals) + - [nil](#nil) + - [if 语句以及强制解析](#if) + - [可选绑定](#optional_binding) + - [隐式解析可选类型](#implicityly_unwrapped_optionals) - [错误处理](#error_handling) -- [断言和先决条件](#assertions_and_Preconditions) +- [断言和先决条件](#assertions_and_preconditions) + - [使用断言进行调试](#debugging_with_assertions) + - [强制执行先决条件](#enforcing_preconditions) Swift 是一门开发 iOS, macOS, watchOS 和 tvOS 应用的新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。 @@ -245,7 +247,7 @@ let minValue = UInt8.min // minValue 为 0，是 UInt8 类型 let maxValue = UInt8.max // maxValue 为 255，是 UInt8 类型 ``` -`min` 和 `max` 所传回值的类型，正是其所对的整数类型(如上例 UInt8, 所传回的类型是 UInt8)，可用在表达式中相同类型值旁。 +`min` 和 `max` 所传回值的类型，正是其所对的整数类型（如上例 UInt8, 所传回的类型是 UInt8），可用在表达式中相同类型值旁。 ### Int @@ -689,7 +691,7 @@ if let firstNumber = Int("4") { > 注意 > -> 在 `if` 条件语句中使用常量和变量来创建一个可选绑定，仅在 `if` 语句的句中(`body`)中才能获取到值。相反，在 `guard` 语句中使用常量和变量来创建一个可选绑定，仅在 `guard` 语句外且在语句后才能获取到值，请参考[提前退出](./05_Control_Flow.html#early_exit)。 +> 在 `if` 条件语句中使用常量和变量来创建一个可选绑定，仅在 `if` 语句的句中（`body`）中才能获取到值。相反，在 `guard` 语句中使用常量和变量来创建一个可选绑定，仅在 `guard` 语句外且在语句后才能获取到值，请参考[提前退出](./05_Control_Flow.html#early_exit)。 ### 隐式解析可选类型 @@ -791,7 +793,7 @@ do { 抛出，捕捉，以及传播错误会在[错误处理](./17_Error_Handling.html)章节详细说明。 - + ## 断言和先决条件 断言和先决条件是在运行时所做的检查。你可以用他们来检查在执行后续代码之前是否一个必要的条件已经被满足了。如果断言或者先决条件中的布尔条件评估的结果为 true（真），则代码像往常一样继续执行。如果布尔条件评估结果为 false（假），程序的当前状态是无效的，则代码执行结束，应用程序中止。 @@ -804,6 +806,7 @@ do { 断言和先决条件的不同点是，他们什么时候进行状态检测：断言仅在调试环境运行，而先决条件则在调试环境和生产环境中运行。在生产环境中，断言的条件将不会进行评估。这个意味着你可以使用很多断言在你的开发阶段，但是这些断言在生产环境中不会产生任何影响。 + ### 使用断言进行调试 你可以调用 Swift 标准库的 `assert(_:_:file:line:)` 函数来写一个断言。向这个函数传入一个结果为 `true` 或者 `false` 的表达式以及一条信息，当表达式的结果为 `false` 的时候这条信息会被显示： @@ -834,6 +837,7 @@ if age > 10 { } ``` + ### 强制执行先决条件 当一个条件可能为假，但是继续执行代码要求条件必须为真的时候，需要使用先决条件。例如使用先决条件来检查是否下标越界，或者来检查是否将一个正确的参数传给函数。 diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md index 6094751b..048f3e52 100755 --- a/source/chapter2/02_Basic_Operators.md +++ b/source/chapter2/02_Basic_Operators.md @@ -26,11 +26,17 @@ - [术语](#terminology) - [赋值运算符](#assignment_operator) - [算术运算符](#arithmetic_operators) + - [求余运算符](#remainder_operator) + - [一元负号运算符](#unary_minus_operator) + - [一元正号运算符](#unary_plus_operator) - [组合赋值运算符](#compound_assignment_operators) - [比较运算符](#comparison_operators) - [三目运算符](#ternary_conditional_operator) - [空合运算符](#nil_coalescing_operator) - [区间运算符](#range_operators) + - [闭区间运算符](#closed_range_operator) + - [半开区间运算符](#half-open_range_operator) + - [单侧区间](#one-sided_ranges) - [逻辑运算符](#logical_operators) *运算符*是检查、改变、合并值的特殊符号或短语。例如，加号（`+`）将两个数相加（如 `let i = 1 + 2`）。更复杂的运算例子包括逻辑与运算符 `&&`（如 `if enteredDoorCode && passedRetinaScan`）。 @@ -106,6 +112,7 @@ Swift 中所有数值类型都支持了基本的四则*算术运算符*： "hello, " + "world" // 等于 "hello, world" ``` + ### 求余运算符 *求余运算符*（`a % b`）是计算 `b` 的多少倍刚刚好可以容入 `a`，返回多出来的那部分（余数）。 @@ -150,6 +157,7 @@ Swift 中所有数值类型都支持了基本的四则*算术运算符*： 在对负数 `b` 求余时，`b` 的符号会被忽略。这意味着 `a % b` 和 `a % -b` 的结果是相同的。 + ### 一元负号运算符 数值的正负号可以使用前缀 `-`（即*一元负号符*）来切换： @@ -162,6 +170,7 @@ let plusThree = -minusThree // plusThree 等于 3, 或 "负负3" 一元负号符（`-`）写在操作数之前，中间没有空格。 + ### 一元正号运算符 *一元正号符*（`+`）不做任何改变地返回操作数的值： @@ -339,6 +348,7 @@ colorNameToUse = userDefinedColorName ?? defaultColorName Swift 提供了几种方便表达一个区间的值的*区间运算符*。 + ### 闭区间运算符 *闭区间运算符*（`a...b`）定义一个包含从 `a` 到 `b`（包括 `a` 和 `b`）的所有值的区间。`a` 的值不能超过 `b`。 @@ -358,7 +368,7 @@ for index in 1...5 { 关于 `for-in` 循环，请看[控制流](./05_Control_Flow.html)。 - + ### 半开区间运算符 *半开区间运算符*（`a.. ### 单侧区间 闭区间操作符有另一个表达形式，可以表达往一侧无限延伸的区间 —— 例如，一个包含了数组从索引 2 到结尾的所有值的区间。在这些情况下，你可以省略掉区间操作符一侧的值。这种区间叫做单侧区间，因为操作符只有一侧有值。例如： diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md index d5ecc153..c1952f4b 100755 --- a/source/chapter2/03_Strings_and_Characters.md +++ b/source/chapter2/03_Strings_and_Characters.md @@ -84,7 +84,7 @@ till you come to the end; then stop." """ ``` -一个多行字符串字面量包含了所有的在开启和关闭引号（`"""`）中的行。这个字符从开启引号(`"""`)之后的第一行开始，到关闭引号(`"""`)之前为止。这就意味着字符串开启引号之后(`"""`)或者结束引号(`"""`)之前都没有换行符号。（译者：下面两个字符串其实是一样的，虽然第二个使用了多行字符串的形式） +一个多行字符串字面量包含了所有的在开启和关闭引号（`"""`）中的行。这个字符从开启引号（`"""`）之后的第一行开始，到关闭引号（`"""`）之前为止。这就意味着字符串开启引号之后（`"""`）或者结束引号（`"""`）之前都没有换行符号。（译者：下面两个字符串其实是一样的，虽然第二个使用了多行字符串的形式） ```swift let singleLineString = "These are the same." @@ -93,7 +93,7 @@ These are the same. """ ``` -如果你的代码中，多行字符串字面量包含换行符的话，则多行字符串字面量中也会包含换行符。如果你想换行，以便加强代码的可读性，但是你又不想在你的多行字符串字面量中出现换行符的话，你可以用在行尾写一个反斜杠(`\`)作为续行符。 +如果你的代码中，多行字符串字面量包含换行符的话，则多行字符串字面量中也会包含换行符。如果你想换行，以便加强代码的可读性，但是你又不想在你的多行字符串字面量中出现换行符的话，你可以用在行尾写一个反斜杠（`\`）作为续行符。 ```swift let softWrappedQuotation = """ @@ -116,11 +116,11 @@ It also ends with a line break. """ ``` -一个多行字符串字面量能够缩进来匹配周围的代码。关闭引号(`"""`)之前的空白字符串告诉 Swift 编译器其他各行多少空白字符串需要忽略。然而，如果你在某行的前面写的空白字符串超出了关闭引号(`"""`)之前的空白字符串，则超出部分将被包含在多行字符串字面量中。 +一个多行字符串字面量能够缩进来匹配周围的代码。关闭引号（`"""`）之前的空白字符串告诉 Swift 编译器其他各行多少空白字符串需要忽略。然而，如果你在某行的前面写的空白字符串超出了关闭引号（`"""`）之前的空白字符串，则超出部分将被包含在多行字符串字面量中。 ![](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Art/multilineStringWhitespace_2x.png) -在上面的例子中，尽管整个多行字符串字面量都是缩进的（源代码缩进），第一行和最后一行没有以空白字符串开始（实际的变量值）。中间一行的缩进用空白字符串（源代码缩进）比关闭引号(`"""`)之前的空白字符串多，所以，它的行首将有4个空格。 +在上面的例子中，尽管整个多行字符串字面量都是缩进的（源代码缩进），第一行和最后一行没有以空白字符串开始（实际的变量值）。中间一行的缩进用空白字符串（源代码缩进）比关闭引号（`"""`）之前的空白字符串多，所以，它的行首将有4个空格。 ### 字符串字面量的特殊字符 @@ -183,12 +183,12 @@ variableString += " and carriage" let constantString = "Highlander" constantString += " and another Highlander" -// 这会报告一个编译错误 (compile-time error) - 常量字符串不可以被修改。 +// 这会报告一个编译错误（compile-time error） - 常量字符串不可以被修改。 ``` > 注意 > -> 在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类(`NSString` 和 `NSMutableString`)来指定字符串是否可以被修改。 +> 在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类（`NSString` 和 `NSMutableString`）来指定字符串是否可以被修改。 ## 字符串是值类型 @@ -249,7 +249,7 @@ var welcome = string1 + string2 // welcome 现在等于 "hello there" ``` -您也可以通过加法赋值运算符 (`+=`) 将一个字符串添加到一个已经存在字符串变量上： +您也可以通过加法赋值运算符（`+=`）将一个字符串添加到一个已经存在字符串变量上： ```swift var instruction = "look over" @@ -314,12 +314,12 @@ let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)" 当创建字符串执行插值计算时此占位符会被替换为 `multiplier` 实际的值。 `multiplier` 的值也作为字符串中后面表达式的一部分。 -该表达式计算 `Double(multiplier) * 2.5` 的值并将结果 (`7.5`) 插入到字符串中。 +该表达式计算 `Double(multiplier) * 2.5` 的值并将结果（`7.5`）插入到字符串中。 在这个例子中，表达式写为 `\(Double(multiplier) * 2.5)` 并包含在字符串字面量中。 > 注意 > -> 插值字符串中写在括号中的表达式不能包含非转义反斜杠 (`\`)，并且不能包含回车或换行符。不过，插值字符串可以包含其他字面量。 +> 插值字符串中写在括号中的表达式不能包含非转义反斜杠（`\`），并且不能包含回车或换行符。不过，插值字符串可以包含其他字面量。 ## Unicode @@ -332,11 +332,11 @@ Swift 的 `String` 和 `Character` 类型是完全兼容 Unicode 标准的。 ### Unicode 标量 Swift 的 `String` 类型是基于 *Unicode 标量* 建立的。 -Unicode 标量是对应字符或者修饰符的唯一的21位数字，例如 `U+0061` 表示小写的拉丁字母(`LATIN SMALL LETTER A`)("`a`")，`U+1F425` 表示小鸡表情(`FRONT-FACING BABY CHICK`) ("`🐥`")。 +Unicode 标量是对应字符或者修饰符的唯一的21位数字，例如 `U+0061` 表示小写的拉丁字母（`LATIN SMALL LETTER A`）（"`a`"），`U+1F425` 表示小鸡表情（`FRONT-FACING BABY CHICK`）（"`🐥`"）。 > 注意 > -> Unicode *码位(code poing)* 的范围是 `U+0000` 到 `U+D7FF` 或者 `U+E000` 到 `U+10FFFF`。Unicode 标量不包括 Unicode *代理项(surrogate pair)* 码位，其码位范围是 `U+D800` 到 `U+DFFF`。 +> Unicode *码位（code poing）* 的范围是 `U+0000` 到 `U+D7FF` 或者 `U+E000` 到 `U+10FFFF`。Unicode 标量不包括 Unicode *代理项（surrogate pair）* 码位，其码位范围是 `U+D800` 到 `U+DFFF`。 注意不是所有的21位 Unicode 标量都代表一个字符，因为有一些标量是留作未来分配的。已经代表一个典型字符的标量都有自己的名字，例如上面例子中的 `LATIN SMALL LETTER A` 和 `FRONT-FACING BABY CHICK`。 @@ -347,7 +347,7 @@ Unicode 标量是对应字符或者修饰符的唯一的21位数字，例如 `U+ 每一个 Swift 的 `Character` 类型代表一个*可扩展的字形群*。 一个可扩展的字形群是一个或多个可生成人类可读的字符 Unicode 标量的有序排列。 -举个例子，字母 `é` 可以用单一的 Unicode 标量 `é`(`LATIN SMALL LETTER E WITH ACUTE`, 或者 `U+00E9`)来表示。然而一个标准的字母 `e`(`LATIN SMALL LETTER E` 或者 `U+0065`) 加上一个急促重音(`COMBINING ACTUE ACCENT`)的标量(`U+0301`)，这样一对标量就表示了同样的字母 `é`。 +举个例子，字母 `é` 可以用单一的 Unicode 标量 `é`(`LATIN SMALL LETTER E WITH ACUTE`, 或者 `U+00E9`)来表示。然而一个标准的字母 `e`(`LATIN SMALL LETTER E` 或者 `U+0065`) 加上一个急促重音（`COMBINING ACTUE ACCENT`）的标量（`U+0301`），这样一对标量就表示了同样的字母 `é`。 这个急促重音的标量形象的将 `e` 转换成了 `é`。 在这两种情况中，字母 `é` 代表了一个单一的 Swift 的 `Character` 值，同时代表了一个可扩展的字形群。 @@ -369,7 +369,7 @@ let decomposed: Character = "\u{1112}\u{1161}\u{11AB}" // ᄒ, ᅡ, ᆫ // precomposed 是 한, decomposed 是 한 ``` -可拓展的字符群集可以使包围记号(例如 `COMBINING ENCLOSING CIRCLE` 或者 `U+20DD`)的标量包围其他 Unicode 标量，作为一个单一的 `Character` 值： +可拓展的字符群集可以使包围记号（例如 `COMBINING ENCLOSING CIRCLE` 或者 `U+20DD`）的标量包围其他 Unicode 标量，作为一个单一的 `Character` 值： ```swift let enclosedEAcute: Character = "\u{E9}\u{20DD}" @@ -423,9 +423,9 @@ print("the number of characters in \(word) is \(word.count)") ### 字符串索引 -每一个 `String` 值都有一个关联的索引(*index*)类型，`String.Index`，它对应着字符串中的每一个 `Character` 的位置。 +每一个 `String` 值都有一个关联的索引（*index*）类型，`String.Index`，它对应着字符串中的每一个 `Character` 的位置。 -前面提到，不同的字符可能会占用不同数量的内存空间，所以要知道 `Character` 的确定位置，就必须从 `String` 开头遍历每一个 Unicode 标量直到结尾。因此，Swift 的字符串不能用整数(integer)做索引。 +前面提到，不同的字符可能会占用不同数量的内存空间，所以要知道 `Character` 的确定位置，就必须从 `String` 开头遍历每一个 Unicode 标量直到结尾。因此，Swift 的字符串不能用整数（integer）做索引。 使用 `startIndex` 属性可以获取一个 `String` 的第一个 `Character` 的索引。使用 `endIndex` 属性可以获取最后一个 `Character` 的后一个位置的索引。因此，`endIndex` 属性不能作为一个字符串的有效下标。如果 `String` 是空串，`startIndex` 和 `endIndex` 是相等的。 @@ -453,7 +453,7 @@ greeting[greeting.endIndex] // error greeting.index(after: endIndex) // error ``` -使用 `indices` 属性会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问单个字符。 +使用 `indices` 属性会创建一个包含全部索引的范围（`Range`），用来在一个字符串中访问单个字符。 ```swift for index in greeting.indices { @@ -528,7 +528,7 @@ Swift 提供了三种方式来比较文本值：字符串字符相等、前缀 ### 字符串/字符相等 -字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在[比较运算符](./02_Basic_Operators.html#comparison_operators)： +字符串/字符可以用等于操作符（`==`）和不等于操作符（`!=`），详细描述在[比较运算符](./02_Basic_Operators.html#comparison_operators)： ```swift let quotation = "We're a lot alike, you and I." @@ -571,7 +571,7 @@ if latinCapitalLetterA != cyrillicCapitalLetterA { > 注意 > -> 在 Swift 中，字符串和字符并不区分地域(not locale-sensitive)。 +> 在 Swift 中，字符串和字符并不区分地域（not locale-sensitive）。 ### 前缀/后缀相等 @@ -640,9 +640,9 @@ Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值： -* UTF-8 代码单元集合 (利用字符串的 `utf8` 属性进行访问) -* UTF-16 代码单元集合 (利用字符串的 `utf16` 属性进行访问) -* 21位的 Unicode 标量值集合，也就是字符串的 UTF-32 编码格式 (利用字符串的 `unicodeScalars` 属性进行访问) +* UTF-8 代码单元集合（利用字符串的 `utf8` 属性进行访问） +* UTF-16 代码单元集合（利用字符串的 `utf16` 属性进行访问） +* 21位的 Unicode 标量值集合，也就是字符串的 UTF-32 编码格式（利用字符串的 `unicodeScalars` 属性进行访问） 下面由 `D`,`o`,`g`,`‼`(`DOUBLE EXCLAMATION MARK`, Unicode 标量 `U+203C`)和 `🐶`(`DOG FACE`，Unicode 标量为 `U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示： @@ -654,7 +654,7 @@ let dogString = "Dog‼🐶" ### UTF-8 表示 您可以通过遍历 `String` 的 `utf8` 属性来访问它的 `UTF-8` 表示。 -其为 `String.UTF8View` 类型的属性，`UTF8View` 是无符号8位 (`UInt8`) 值的集合，每一个 `UInt8` 值都是一个字符的 UTF-8 表示： +其为 `String.UTF8View` 类型的属性，`UTF8View` 是无符号8位（`UInt8`）值的集合，每一个 `UInt8` 值都是一个字符的 UTF-8 表示： @@ -701,15 +701,15 @@ print("") // 68 111 103 226 128 188 240 159 144 182 ``` -上面的例子中，前三个10进制 `codeUnit` 值 (`68`, `111`, `103`) 代表了字符 `D`、`o` 和 `g`，它们的 UTF-8 表示与 ASCII 表示相同。 -接下来的三个10进制 `codeUnit` 值 (`226`, `128`, `188`) 是 `DOUBLE EXCLAMATION MARK` 的3字节 UTF-8 表示。 -最后的四个 `codeUnit` 值 (`240`, `159`, `144`, `182`) 是 `DOG FACE` 的4字节 UTF-8 表示。 +上面的例子中，前三个10进制 `codeUnit` 值（`68`、`111`、`103`）代表了字符 `D`、`o` 和 `g`，它们的 UTF-8 表示与 ASCII 表示相同。 +接下来的三个10进制 `codeUnit` 值（`226`、`128`、`188`）是 `DOUBLE EXCLAMATION MARK` 的3字节 UTF-8 表示。 +最后的四个 `codeUnit` 值（`240`、`159`、`144`、`182`）是 `DOG FACE` 的4字节 UTF-8 表示。 ### UTF-16 表示 您可以通过遍历 `String` 的 `utf16` 属性来访问它的 `UTF-16` 表示。 -其为 `String.UTF16View` 类型的属性，`UTF16View` 是无符号16位 (`UInt16`) 值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示： +其为 `String.UTF16View` 类型的属性，`UTF16View` 是无符号16位（`UInt16`）值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示：
    @@ -748,11 +748,11 @@ print("") // 68 111 103 8252 55357 56374 ``` -同样，前三个 `codeUnit` 值 (`68`, `111`, `103`) 代表了字符 `D`、`o` 和 `g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。 +同样，前三个 `codeUnit` 值（`68`、`111`、`103`）代表了字符 `D`、`o` 和 `g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。 -第四个 `codeUnit` 值 (`8252`) 是一个等于十六进制 `203C` 的的十进制值。这个代表了 `DOUBLE EXCLAMATION MARK` 字符的 Unicode 标量值 `U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。 +第四个 `codeUnit` 值（`8252`）是一个等于十六进制 `203C` 的的十进制值。这个代表了 `DOUBLE EXCLAMATION MARK` 字符的 Unicode 标量值 `U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。 -第五和第六个 `codeUnit` 值 (`55357` 和 `56374`) 是 `DOG FACE` 字符的 UTF-16 表示。 +第五和第六个 `codeUnit` 值（`55357` 和 `56374`）是 `DOG FACE` 字符的 UTF-16 表示。 第一个值为 `U+D83D`(十进制值为 `55357`)，第二个值为 `U+DC36`(十进制值为 `56374`)。 @@ -799,9 +799,9 @@ print("") // 68 111 103 8252 128054 ``` -前三个 `UnicodeScalar` 值(`68`, `111`, `103`)的 `value` 属性仍然代表字符 `D`、`o` 和 `g`。 +前三个 `UnicodeScalar` 值（`68`、`111`、`103`）的 `value` 属性仍然代表字符 `D`、`o` 和 `g`。 -第四个 `codeUnit` 值(`8252`)仍然是一个等于十六进制 `203C` 的十进制值。这个代表了 `DOUBLE EXCLAMATION MARK` 字符的 Unicode 标量 `U+203C`。 +第四个 `codeUnit` 值（`8252`）仍然是一个等于十六进制 `203C` 的十进制值。这个代表了 `DOUBLE EXCLAMATION MARK` 字符的 Unicode 标量 `U+203C`。 第五个 `UnicodeScalar` 值的 `value` 属性，`128054`，是一个十六进制 `1F436` 的十进制表示。其等同于 `DOG FACE` 的 Unicode 标量 `U+1F436`。 diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md index b4156103..2ed85988 100755 --- a/source/chapter2/04_Collection_Types.md +++ b/source/chapter2/04_Collection_Types.md @@ -1,4 +1,4 @@ -# 集合类型 (Collection Types) +# 集合类型（Collection Types） ----------------- > 1.0 @@ -25,9 +25,28 @@ - [集合的可变性](#mutability_of_collections) - [数组](#arrays) + - [创建一个空数组](#creating_an_empty_array) + - [创建一个带有默认值的数组](#creating_an_array_with_a_default_value) + - [通过两个数组相加创建一个数组](#creating_an_array_by_adding_two_arrays_together) + - [用数组字面量构造数组](#creating_an_array_with_an_array_literals) + - [访问和修改数组](#accessing_and_modifying_an_array) + - [数组的遍历](#iterating_over_an_array) - [集合](#sets) + - [集合类型的哈希值](#hash_values_for_set_types) + - [集合类型语法](#set_type_syntax) + - [创建和构造一个空的集合](#creating_and_initalizing_an_empty_set) + - [用数组字面量创建集合](#creating_a_set_with_an_array_literal) + - [访问和修改一个集合](#accesing_and_modifying_a_set) + - [遍历一个集合](#iterating_over_a_set) - [集合操作](#performing_set_operations) + - [基本集合操作](#fundamental_set_operations) + - [集合成员关系和相等](#set_membership_and_equality) - [字典](#dictionaries) + - [字典类型简化语法](#dictionary_type_shorthand_syntax) + - [创建一个空字典](#creating_an_empty_dictionary) + - [用字典字面量创建字典](#creating_a_dictionary_with_a_dictionary_literal) + - [访问和修改字典](#accessing_and_modifying_a_dictionary) + - [字典遍历](#iterating_over_a_dictionary) Swift 语言提供 `Arrays`、`Sets` 和 `Dictionaries` 三种基本的*集合类型*用来存储集合数据。数组（Arrays）是有序数据的集。集合（Sets）是无序无重复数据的集。字典（Dictionaries）是无序的键值对的集。 @@ -49,7 +68,7 @@ Swift 语言中的 `Arrays`、`Sets` 和 `Dictionaries` 中存储的数据值类 > 在我们不需要改变集合的时候创建不可变集合是很好的实践。如此 Swift 编译器可以优化我们创建的集合。 -## 数组(Arrays) +## 数组（Arrays） *数组*使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。 @@ -278,7 +297,7 @@ for (index, value) in shoppingList. enumerated() { ## 集合（Sets） -*集合(Set)*用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。 +*集合（Set）*用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。 > 注意 > Swift 的 `Set` 类型被桥接到 `Foundation` 中的 `NSSet` 类。 @@ -286,17 +305,17 @@ for (index, value) in shoppingList. enumerated() { > 关于使用 `Foundation` 和 `Cocoa` 中 `Set` 的知识，参见 [*Using Swift with Cocoa and Obejective-C(Swift 4.1)*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中[使用 Cocoa 数据类型](https://developer.apple.com/library/content/documentation/Swift/Conceptual/BuildingCocoaApps/WorkingWithCocoaDataTypes.html#//apple_ref/doc/uid/TP40014216-CH6)部分。 -#### 集合类型的哈希值 +### 集合类型的哈希值 一个类型为了存储在集合中，该类型必须是*可哈希化*的--也就是说，该类型必须提供一个方法来计算它的*哈希值*。一个哈希值是 `Int` 类型的，相等的对象哈希值必须相同，比如 `a==b`,因此必须 `a.hashValue == b.hashValue`。 -Swift 的所有基本类型(比如 `String`,`Int`,`Double` 和 `Bool`)默认都是可哈希化的，可以作为集合的值的类型或者字典的键的类型。没有关联值的枚举成员值(在[枚举](./08_Enumerations.html)有讲述)默认也是可哈希化的。 +Swift 的所有基本类型（比如 `String`,`Int`,`Double` 和 `Bool`）默认都是可哈希化的，可以作为集合的值的类型或者字典的键的类型。没有关联值的枚举成员值（在[枚举](./08_Enumerations.html)有讲述）默认也是可哈希化的。 > 注意 > > 你可以使用你自定义的类型作为集合的值的类型或者是字典的键的类型，但你需要使你的自定义类型符合 Swift 标准库中的 `Hashable` 协议。符合 `Hashable` 协议的类型需要提供一个类型为 `Int` 的可读属性 `hashValue`。由类型的 `hashValue` 属性返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。 > -> 因为 `Hashable` 协议符合 `Equatable` 协议，所以遵循该协议的类型也必须提供一个“是否相等”运算符(`==`)的实现。这个 `Equatable` 协议要求任何符合 `==` 实现的实例间都是一种相等的关系。也就是说，对于 `a,b,c` 三个值来说，`==` 的实现必须满足下面三种情况： +> 因为 `Hashable` 协议符合 `Equatable` 协议，所以遵循该协议的类型也必须提供一个“是否相等”运算符（`==`）的实现。这个 `Equatable` 协议要求任何符合 `==` 实现的实例间都是一种相等的关系。也就是说，对于 `a,b,c` 三个值来说，`==` 的实现必须满足下面三种情况： > * `a == a`(自反性) > * `a == b` 意味着 `b == a`(对称性) @@ -345,11 +364,11 @@ var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"] // favoriteGenres 被构造成含有三个初始值的集合 ``` -这个 `favoriteGenres` 变量被声明为“一个 `String` 值的集合”，写为 `Set`。由于这个特定的集合含有指定 `String` 类型的值，所以它只允许存储 `String` 类型值。这里的 `favoriteGenres` 变量有三个 `String` 类型的初始值(`"Rock"`，`"Classical"` 和 `"Hip hop"`)，并以数组字面量的方式出现。 +这个 `favoriteGenres` 变量被声明为“一个 `String` 值的集合”，写为 `Set`。由于这个特定的集合含有指定 `String` 类型的值，所以它只允许存储 `String` 类型值。这里的 `favoriteGenres` 变量有三个 `String` 类型的初始值（`"Rock"`，`"Classical"` 和 `"Hip hop"`），并以数组字面量的方式出现。 > 注意 > -> `favoriteGenres` 被声明为一个变量(拥有 `var` 标示符)而不是一个常量(拥有 `let` 标示符),因为它里面的元素将会在下面的例子中被增加或者移除。 +> `favoriteGenres` 被声明为一个变量（拥有 `var` 标示符）而不是一个常量（拥有 `let` 标示符）,因为它里面的元素将会在下面的例子中被增加或者移除。 一个 `Set` 类型不能从数组字面量中被单独推断出来，因此 `Set` 类型必须显式声明。然而，由于 Swift 的类型推断功能，如果你想使用一个数组字面量构造一个 `Set` 并且该数组字面量中的所有元素类型相同，那么你无须写出 `Set` 的具体类型。`favoriteGenres` 的构造形式可以采用简化的方式代替： @@ -477,11 +496,11 @@ oddDigits. symmetricDifference(singleDigitPrimeNumbers).sorted() ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/setEulerDiagram_2x.png) -* 使用“是否相等”运算符(`==`)来判断两个集合是否包含全部相同的值。 +* 使用“是否相等”运算符（`==`）来判断两个集合是否包含全部相同的值。 * 使用 `isSubset(of:)` 方法来判断一个集合中的值是否也被包含在另外一个集合中。 * 使用 `isSuperset(of:)` 方法来判断一个集合中包含另一个集合中所有的值。 * 使用 `isStrictSubset(of:)` 或者 `isStrictSuperset(of:)` 方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。 -* 使用 `isDisjoint(with:)` 方法来判断两个集合是否不含有相同的值(是否没有交集)。 +* 使用 `isDisjoint(with:)` 方法来判断两个集合是否不含有相同的值（是否没有交集）。 ```swift let houseAnimals: Set = ["🐶", "🐱"] @@ -540,7 +559,7 @@ namesOfIntegers = [:] ``` -## 用字典字面量创建字典 +### 用字典字面量创建字典 我们可以使用*字典字面量*来构造字典，这和我们刚才介绍过的数组字面量拥有相似语法。字典字面量是一种将一个或多个键值对写作 `Dictionary` 集合的快捷途径。 diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md index 5bd11a5a..713e2674 100755 --- a/source/chapter2/05_Control_Flow.md +++ b/source/chapter2/05_Control_Flow.md @@ -122,7 +122,7 @@ for tickMark in 0.. #### 值绑定（Value Bindings） case 分支允许将匹配的值声明为临时常量或变量，并且在 case 分支体内使用 —— 这种行为被称为*值绑定*（value binding），因为匹配的值在 case 分支体内，与临时的常量或变量绑定。 -下面的例子将下图中的点(x, y)，使用 `(Int, Int)` 类型的元组表示，然后分类表示： +下面的例子将下图中的点 (x, y)，使用 `(Int, Int)` 类型的元组表示，然后分类表示： ```swift let anotherPoint = (2, 0) @@ -510,7 +510,7 @@ case let (x, y): case 分支的模式可以使用 `where` 语句来判断额外的条件。 -下面的例子把下图中的点(x, y)进行了分类： +下面的例子把下图中的点 (x, y)进行了分类： ```swift let yetAnotherPoint = (1, -1) @@ -529,7 +529,7 @@ case let (x, y): 在上面的例子中，`switch` 语句会判断某个点是否在绿色的对角线 `x == y` 上，是否在紫色的对角线 `x == -y` 上，或者不在对角线上。 -这三个 case 都声明了常量 `x` 和 `y` 的占位符，用于临时获取元组 `yetAnotherPoint` 的两个值。这两个常量被用作 `where` 语句的一部分，从而创建一个动态的过滤器(filter)。当且仅当 `where` 语句的条件为 `true` 时，匹配到的 case 分支才会被执行。 +这三个 case 都声明了常量 `x` 和 `y` 的占位符，用于临时获取元组 `yetAnotherPoint` 的两个值。这两个常量被用作 `where` 语句的一部分，从而创建一个动态的过滤器（filter）。当且仅当 `where` 语句的条件为 `true` 时，匹配到的 case 分支才会被执行。 就像是值绑定中的例子，由于最后一个 case 分支匹配了余下所有可能的值，`switch` 语句就已经完备了，因此不需要再书写默认分支。 @@ -614,12 +614,12 @@ print(puzzleOutput) #### 循环语句中的 break -当在一个循环体中使用 `break` 时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(`}`)后的第一行代码。不会再有本次循环的代码被执行，也不会再有下次的循环产生。 +当在一个循环体中使用 `break` 时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号（`}`）后的第一行代码。不会再有本次循环的代码被执行，也不会再有下次的循环产生。 #### Switch 语句中的 break -当在一个 `switch` 代码块中使用 `break` 时，会立即中断该 `switch` 代码块的执行，并且跳转到表示 `switch` 代码块结束的大括号(`}`)后的第一行代码。 +当在一个 `switch` 代码块中使用 `break` 时，会立即中断该 `switch` 代码块的执行，并且跳转到表示 `switch` 代码块结束的大括号（`}`）后的第一行代码。 这种特性可以被用来匹配或者忽略一个或多个分支。因为 Swift 的 `switch` 需要包含所有的分支而且不允许有为空的分支，有时为了使你的意图更明显，需要特意匹配或者忽略某个分支。那么当你想忽略某个分支时，可以在该分支内写上 `break` 语句。当那个分支被匹配到时，分支内的 `break` 语句立即结束 `switch` 代码块。 @@ -659,7 +659,7 @@ if let integerValue = possibleIntegerValue { 在上面的例子中，想要把 `Character` 所有的的可能性都枚举出来是不现实的，所以使用 `default` 分支来包含所有上面没有匹配到字符的情况。由于这个 `default` 分支不需要执行任何动作，所以它只写了一条 `break` 语句。一旦落入到 `default` 分支中后，`break` 语句就完成了该分支的所有代码操作，代码继续向下，开始执行 `if let` 语句。 -### 贯穿 (Fallthrough) +### 贯穿（Fallthrough） 在 Swift 里，`switch` 语句不会从上一个 case 分支跳转到下一个 case 分支中。相反，只要第一个匹配到的 case 分支完成了它需要执行的语句，整个 `switch` 代码块完成了它的执行。相比之下，C 语言要求你显式地插入 `break` 语句到每个 case 分支的末尾来阻止自动落入到下一个 case 分支中。Swift 的这种避免默认落入到下一个分支中的特性意味着它的 `switch` 功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个 case 分支从而引发的错误。 @@ -696,7 +696,7 @@ print(description) 为了实现这个目的，你可以使用标签（*statement label*）来标记一个循环体或者条件语句，对于一个条件语句，你可以使用 `break` 加标签的方式，来结束这个被标记的语句。对于一个循环语句，你可以使用 `break` 或者 `continue` 加标签，来结束或者继续这条被标记语句的执行。 -声明一个带标签的语句是通过在该语句的关键词的同一行前面放置一个标签，作为这个语句的前导关键字(introducor keyword)，并且该标签后面跟随一个冒号。下面是一个针对 `while` 循环体的标签语法，同样的规则适用于所有的循环体和条件语句。 +声明一个带标签的语句是通过在该语句的关键词的同一行前面放置一个标签，作为这个语句的前导关键字（introducor keyword），并且该标签后面跟随一个冒号。下面是一个针对 `while` 循环体的标签语法，同样的规则适用于所有的循环体和条件语句。 ```swift label name: while condition { diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md index 0a377c73..7030fe99 100755 --- a/source/chapter2/06_Functions.md +++ b/source/chapter2/06_Functions.md @@ -145,7 +145,7 @@ greet(person: "Dave") > 注意 > -> 严格上来说，虽然没有返回值被定义，`greet(person:)` 函数依然返回了值。没有定义返回类型的函数会返回一个特殊的 `Void` 值。它其实是一个空的元组，没有任何元素，可以写成()。 +> 严格上来说，虽然没有返回值被定义，`greet(person:)` 函数依然返回了值。没有定义返回类型的函数会返回一个特殊的 `Void` 值。它其实是一个空的元组，没有任何元素，可以写成 `()`。 被调用时，一个函数的返回值可以被忽略： @@ -246,7 +246,7 @@ if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) { ## 函数参数标签和参数名称 -每个函数参数都有一个*参数标签( argument label )*以及一个*参数名称( parameter name )*。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。 +每个函数参数都有一个*参数标签（argument label）*以及一个*参数名称（parameter name）*。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。 ```swift func someFunction(firstParameterName: Int, secondParameterName: Int) { @@ -283,7 +283,7 @@ print(greet(person: "Bill", from: "Cupertino")) ### 忽略参数标签 -如果你不希望为某个参数添加一个标签，可以使用一个下划线(`_`)来代替一个明确的参数标签。 +如果你不希望为某个参数添加一个标签，可以使用一个下划线（`_`）来代替一个明确的参数标签。 ```swift func someFunction(_ firstParameterName: Int, secondParameterName: Int) { @@ -422,7 +422,7 @@ var mathFunction: (Int, Int) -> Int = addTwoInts ”定义一个叫做 `mathFunction` 的变量，类型是‘一个有两个 `Int` 型的参数并返回一个 `Int` 型的值的函数’，并让这个新变量指向 `addTwoInts` 函数”。 -`addTwoInts` 和 `mathFunction` 有同样的类型，所以这个赋值过程在 Swift 类型检查(type-check)中是允许的。 +`addTwoInts` 和 `mathFunction` 有同样的类型，所以这个赋值过程在 Swift 类型检查（type-check）中是允许的。 现在，你可以用 `mathFunction` 来调用被赋值的函数了： diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md index 01ac9ba7..d796419b 100755 --- a/source/chapter2/07_Closures.md +++ b/source/chapter2/07_Closures.md @@ -246,7 +246,7 @@ let strings = numbers.map { > 注意 > -> 字典 `digitNames` 下标后跟着一个叹号（`!`），因为字典下标返回一个可选值（optional value），表明该键不存在时会查找失败。在上例中，由于可以确定 `number % 10` 总是 `digitNames` 字典的有效下标，因此叹号可以用于强制解包 (force-unwrap) 存储在下标的可选类型的返回值中的 `String` 类型的值。 +> 字典 `digitNames` 下标后跟着一个叹号（`!`），因为字典下标返回一个可选值（optional value），表明该键不存在时会查找失败。在上例中，由于可以确定 `number % 10` 总是 `digitNames` 字典的有效下标，因此叹号可以用于强制解包（force-unwrap）存储在下标的可选类型的返回值中的 `String` 类型的值。 从 `digitNames` 字典中获取的字符串被添加到 `output` 的*前部*，逆序建立了一个字符串版本的数字。（在表达式 `number % 10` 中，如果 `number` 为 `16`，则返回 `6`，`58` 返回 `8`，`510` 返回 `0`。） diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md index 487f0a21..857f12e3 100755 --- a/source/chapter2/09_Classes_and_Structures.md +++ b/source/chapter2/09_Classes_and_Structures.md @@ -118,7 +118,7 @@ let someVideoMode = VideoMode() ### 属性访问 -通过使用*点语法*，你可以访问实例的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(`.`)连接： +通过使用*点语法*，你可以访问实例的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号（`.`）连接： ```swift print("The width of someResolution is \(someResolution.width)") diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md index 3200b289..d547a6c8 100755 --- a/source/chapter2/10_Properties.md +++ b/source/chapter2/10_Properties.md @@ -1,4 +1,4 @@ -# 属性 (Properties) +# 属性（Properties） --- > 1.0 diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md index 7e9daaec..e53f81c4 100755 --- a/source/chapter2/11_Methods.md +++ b/source/chapter2/11_Methods.md @@ -32,7 +32,7 @@ 结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活地在你创建的类型（类/结构体/枚举）上定义方法。 -## 实例方法 (Instance Methods) +## 实例方法（Instance Methods） *实例方法*是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](./06_Functions.md)。 @@ -117,7 +117,7 @@ if somePoint.isToTheRightOfX(1.0) { 结构体和枚举是*值类型*。默认情况下，值类型的属性不能在它的实例方法中被修改。 -但是，如果你确实需要在某个特定的方法中修改结构体或者枚举的属性，你可以为这个方法选择 `可变(mutating)`行为，然后就可以从其方法内部改变它的属性；并且这个方法做的任何改变都会在方法执行结束时写回到原始结构中。方法还可以给它隐含的 `self` 属性赋予一个全新的实例，这个新实例在方法结束时会替换现存实例。 +但是，如果你确实需要在某个特定的方法中修改结构体或者枚举的属性，你可以为这个方法选择 `可变（mutating）`行为，然后就可以从其方法内部改变它的属性；并且这个方法做的任何改变都会在方法执行结束时写回到原始结构中。方法还可以给它隐含的 `self` 属性赋予一个全新的实例，这个新实例在方法结束时会替换现存实例。 要使用 `可变`方法，将关键字 `mutating` 放到方法的 `func` 关键字之前就可以了： diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md index 85395f38..54f84358 100755 --- a/source/chapter2/14_Initialization.md +++ b/source/chapter2/14_Initialization.md @@ -173,7 +173,7 @@ let veryGreen = Color(0.0, 1.0, 0.0) ### 不带参数标签的构造器参数 -如果你不希望为构造器的某个参数提供参数标签，你可以使用下划线(`_`)来显式描述它的外部名，以此重写上面所说的默认行为。 +如果你不希望为构造器的某个参数提供参数标签，你可以使用下划线（`_`）来显式描述它的外部名，以此重写上面所说的默认行为。 下面是之前 `Celsius` 例子的扩展，跟之前相比添加了一个带有 `Double` 类型参数的构造器，其外部名用 `_` 代替： @@ -729,7 +729,7 @@ for item in breakfastList { 如果一个类、结构体或枚举类型的对象，在构造过程中有可能失败，则为其定义一个可失败构造器是很有用的。这里所指的“失败” 指的是，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。 -为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在 `init` 关键字后面添加问号 (`init?`)。 +为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在 `init` 关键字后面添加问号（`init?`）。 > 注意 > @@ -808,7 +808,7 @@ if anonymousCreature == nil { 你可以通过一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。如果提供的参数无法匹配任何枚举成员，则构造失败。 -下例中，定义了一个名为 `TemperatureUnit` 的枚举类型。其中包含了三个可能的枚举成员(`Kelvin`、`Celsius` 和 `Fahrenheit`)，以及一个根据 `Character` 值找出所对应的枚举成员的可失败构造器： +下例中，定义了一个名为 `TemperatureUnit` 的枚举类型。其中包含了三个可能的枚举成员（`Kelvin`、`Celsius` 和 `Fahrenheit`），以及一个根据 `Character` 值找出所对应的枚举成员的可失败构造器： ```swift enum TemperatureUnit { diff --git a/source/chapter2/22_Generics.md b/source/chapter2/22_Generics.md index 19e18bbc..6659ad90 100644 --- a/source/chapter2/22_Generics.md +++ b/source/chapter2/22_Generics.md @@ -338,7 +338,7 @@ func findIndex(of valueToFind: T, in array:[T]) -> Int? { 上面所写的函数无法通过编译。问题出在相等性检查上，即 "`if value == valueToFind`"。不是所有的 Swift 类型都可以用等式符（`==`）进行比较。比如说，如果你创建一个自定义的类或结构体来表示一个复杂的数据模型，那么 Swift 无法猜到对于这个类或结构体而言“相等”意味着什么。正因如此，这部分代码无法保证适用于每个可能的类型 `T`，当你试图编译这部分代码时会出现相应的错误。 -不过，所有的这些并不会让我们无从下手。Swift 标准库中定义了一个 `Equatable` 协议，该协议要求任何遵循该协议的类型必须实现等式符（`==`）及不等符(`!=`)，从而能对该类型的任意两个值进行比较。所有的 Swift 标准类型自动支持 `Equatable` 协议。 +不过，所有的这些并不会让我们无从下手。Swift 标准库中定义了一个 `Equatable` 协议，该协议要求任何遵循该协议的类型必须实现等式符（`==`）及不等符（`!=`），从而能对该类型的任意两个值进行比较。所有的 Swift 标准类型自动支持 `Equatable` 协议。 任何 `Equatable` 类型都可以安全地使用在 `findIndex(of:in:)` 函数中，因为其保证支持等式操作符。为了说明这个事实，当你定义一个函数时，你可以定义一个 `Equatable` 类型约束作为类型参数定义的一部分： @@ -746,7 +746,7 @@ extension Container { - 在尖括号中的泛型参数 `Indices`，必须是符合标准库中的 `Sequence` 协议的类型。 - 下标使用的单一的参数，`indices`，必须是 `Indices` 的实例。 -- 泛型 `where` 子句要求 Sequence（Indices）的迭代器，其所有的元素都是 `Int` 类型。这样就能确保在序列（Sequence）中的索引和容器(Container)里面的索引类型是一致的。 +- 泛型 `where` 子句要求 Sequence（Indices）的迭代器，其所有的元素都是 `Int` 类型。这样就能确保在序列（Sequence）中的索引和容器（Container）里面的索引类型是一致的。 综合一下，这些约束意味着，传入到 `indices` 下标，是一个整型的序列。 diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md index 82898153..776a17fc 100755 --- a/source/chapter3/02_Lexical_Structure.md +++ b/source/chapter3/02_Lexical_Structure.md @@ -28,14 +28,14 @@ - [字符串字面量](#string_literals) - [运算符](#operators) -Swift 的*“词法结构 (lexical structure)”* 描述了能构成该语言中有效符号 (token) 的字符序列。这些合法符号组成了语言中最底层的构建基块，并在之后的章节中用于描述语言的其他部分。一个合法符号由一个标识符 (identifier)、关键字 (keyword)、标点符号 (punctuation)、字面量 (literal) 或运算符 (operator) 组成。 +Swift 的*“词法结构（lexical structure）”* 描述了能构成该语言中有效符号（token）的字符序列。这些合法符号组成了语言中最底层的构建基块，并在之后的章节中用于描述语言的其他部分。一个合法符号由一个标识符（identifier）、关键字（keyword）、标点符号（punctuation）、字面量（literal）或运算符（operator）组成。 -通常情况下，通过考虑输入文本当中可能的最长子串，并且在随后将介绍的语法约束之下，根据随后将介绍的语法约束生成的，根据 Swift 源文件当中的字符来生成相应的“符号”。这种方法称为*“最长匹配 (longest match)”*，或者*“最大适合(maximal munch)”*。 +通常情况下，通过考虑输入文本当中可能的最长子串，并且在随后将介绍的语法约束之下，根据随后将介绍的语法约束生成的，根据 Swift 源文件当中的字符来生成相应的“符号”。这种方法称为*“最长匹配（longest match）”*，或者*“最大适合（maximal munch）”*。 ## 空白与注释 -空白 (whitespace) 有两个用途：分隔源文件中的符号以及帮助区分运算符属于前缀还是后缀（参见 [运算符](#operators)），在其他情况下空白则会被忽略。以下的字符会被当作空白：空格（U+0020）、换行符（U+000A）、回车符（U+000D）、水平制表符（U+0009）、垂直制表符（U+000B）、换页符（U+000C）以及空字符（U+0000）。 +空白（whitespace）有两个用途：分隔源文件中的符号以及帮助区分运算符属于前缀还是后缀（参见 [运算符](#operators)），在其他情况下空白则会被忽略。以下的字符会被当作空白：空格（U+0020）、换行符（U+000A）、回车符（U+000D）、水平制表符（U+0009）、垂直制表符（U+000B）、换页符（U+000C）以及空字符（U+0000）。 注释被编译器当作空白处理。单行注释由 `//` 开始直至遇到换行符（U+000A）或者回车符（U+000D）。多行注释由 `/*` 开始，以 `*/` 结束。注释允许嵌套，但注释标记必须匹配。 @@ -68,9 +68,9 @@ Swift 的*“词法结构 (lexical structure)”* 描述了能构成该语言中 ## 标识符 -*标识符(identifier)* 可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 (`_`)、基本多文种平面 (Basic Multilingual Plane) 中非字符数字组合的 Unicode 字符以及基本多文种平面以外的非个人专用区字符。在首字符之后，允许使用数字和组合 Unicode 字符。 +*标识符（identifier）* 可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线（`_`）、基本多文种平面（Basic Multilingual Plane）中非字符数字组合的 Unicode 字符以及基本多文种平面以外的非个人专用区字符。在首字符之后，允许使用数字和组合 Unicode 字符。 -使用保留字作为标识符，需要在其前后增加反引号 (`` ` ``)。例如，`class` 不是合法的标识符，但可以使用 `` `class` ``。反引号不属于标识符的一部分，`` `x` `` 和 `x` 表示同一标识符。 +使用保留字作为标识符，需要在其前后增加反引号（`` ` ``）。例如，`class` 不是合法的标识符，但可以使用 `` `class` ``。反引号不属于标识符的一部分，`` `x` `` 和 `x` 表示同一标识符。 闭包中如果没有明确指定参数名称，参数将被隐式命名为 `$0`、`$1`、`$2` 等等。这些命名在闭包作用域范围内是合法的标识符。 @@ -121,7 +121,7 @@ Swift 的*“词法结构 (lexical structure)”* 描述了能构成该语言中 * 用在语句中的关键字：`break`、`case`、`continue`、`default`、`defer`、`do`、`else`、`fallthrough`、`for`、`guard`、`if`、`in`、`repeat`、`return`、`switch`、`where` 以及 `while`。 * 用在表达式和类型中的关键字：`as`、`catch`、`dynamicType`、`false`、`is`、`nil`、`rethrows`、`super`、`self`、`Self`、`throw`、`throws`、`true`、`try`、`#column`、`#file`、`#function` 以及 `#line`。 * 用在模式中的关键字：`_`。 -* 以井字号 (`#`) 开头的关键字：`#available`、`#column`、`#else#elseif`、`#endif`、`#file`、`#function`、`#if`、`#line` 以及 `#selector`。 +* 以井字号（`#`）开头的关键字：`#available`、`#column`、`#else#elseif`、`#endif`、`#file`、`#function`、`#if`、`#line` 以及 `#selector`。 * 特定上下文中被保留的关键字： `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`。这些关键字在特定上下文之外可以被用做标识符。 以下符号被当作保留符号，不能用于自定义运算符： `(`、`)`、`{`、`}`、`[`、`]`、`.`、`,`、`:`、`;`、`=`、`@`、`#`、`&`（作为前缀运算符）、`->`、`` ` ``、`?`、`!`（作为后缀运算符）。 @@ -129,7 +129,7 @@ Swift 的*“词法结构 (lexical structure)”* 描述了能构成该语言中 ## 字面量 -*字面量 (literal)* 用来表示源码中某种特定类型的值，比如一个数字或字符串。 +*字面量（literal）* 用来表示源码中某种特定类型的值，比如一个数字或字符串。 下面是字面量的一些示例： @@ -158,13 +158,13 @@ true // 布尔值字面量 ### 整数字面量 -*整数字面量 (Integer Literals)* 表示未指定精度整数的值。整数字面量默认用十进制表示，可以加前缀来指定其他的进制。二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 +*整数字面量（Integer Literals）* 表示未指定精度整数的值。整数字面量默认用十进制表示，可以加前缀来指定其他的进制。二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。 十进制字面量包含数字 `0` 至 `9`。二进制字面量只包含 `0` 或 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F`（大小写均可）。 负整数的字面量在整数字面量前加负号 `-`，比如 `-42`。 -整型字面面可以使用下划线 (`_`) 来增加数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，这同样也会被系统所忽略，并不会影响字面量的值。 +整型字面面可以使用下划线（`_`）来增加数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，这同样也会被系统所忽略，并不会影响字面量的值。 除非特别指定，整数字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数](../chapter2/01_The_Basics.html#integers)。 @@ -217,17 +217,17 @@ true // 布尔值字面量 ### 浮点数字面量 -*浮点数字面量 (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`。 -负数的浮点数字面量由负号 (`-`) 和浮点数字面量组成，例如 `-42.5`。 +负数的浮点数字面量由负号（`-`）和浮点数字面量组成，例如 `-42.5`。 -浮点数字面量允许使用下划线 (`_`) 来增强数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，并不会影响字面量的值。 +浮点数字面量允许使用下划线（`_`）来增强数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，并不会影响字面量的值。 除非特别指定，浮点数字面量的默认推导类型为 Swift 标准库类型中的 `Double`，表示 64 位浮点数。Swift 标准库也定义了 `Float` 类型，表示 32 位浮点数。 @@ -268,7 +268,7 @@ true // 布尔值字面量 > `字符` > """ -与单行字符串字面量不同的是，多行字符串字面量可以包含不转义的双引号( " )，回车以及换行。它不能包含三个非转义的连续双引号。 +与单行字符串字面量不同的是，多行字符串字面量可以包含不转义的双引号（"），回车以及换行。它不能包含三个非转义的连续双引号。 """ 之后的回车或者换行开始多行字符串字面量，不是字符串的一部分。 """ 之前回车或者换行结束字面量，也不是字符串的一部分。要让多行字符串字面量的开始或结束带有换行，就在第一行或者最后一行写一个空行。 @@ -289,7 +289,7 @@ true // 布尔值字面量 * 单引号 `\'` * Unicode 标量 `\u{`n`}`，n 为一到八位的十六进制数字 -字符串字面量允许在反斜杠 (`\`) 后的括号 `()` 中插入表达式的值。插入表达式可以包含字符串字面量，但不能包含未转义的反斜线 (`\`)、回车符以及换行符。 +字符串字面量允许在反斜杠（`\`）后的括号 `()` 中插入表达式的值。插入表达式可以包含字符串字面量，但不能包含未转义的反斜线（`\`）、回车符以及换行符。 例如，以下所有字符串字面量的值都是相同的： @@ -341,9 +341,9 @@ let textB = "Hello world" Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/25_Advanced_Operators.html) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。 -自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号(Miscellaneous Symbols)* 以及印刷符号 (Dingbats) 之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。 +自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`，或者后面语法中规定的任一个 Unicode 字符（其中包含了*数学运算符*、*零散符号（Miscellaneous Symbols）* 以及印刷符号（Dingbats）之类的 Unicode 块）开始。在第一个字符之后，允许使用组合型 Unicode 字符。 -您也可以以点号 (`.`) 开头来定义自定义运算符。这些运算符可以包含额外的点，例如 `.+.`。如果某个运算符不是以点号开头的，那么它就无法再包含另外的点号了。例如，`+.+` 就会被看作为一个 `+` 运算符后面跟着一个 `.+` 运算符。 +您也可以以点号（`.`）开头来定义自定义运算符。这些运算符可以包含额外的点，例如 `.+.`。如果某个运算符不是以点号开头的，那么它就无法再包含另外的点号了。例如，`+.+` 就会被看作为一个 `+` 运算符后面跟着一个 `.+` 运算符。 虽然您可以用问号 `?` 来自定义运算符，但是这个运算符不能只包含单独的一个问号。此外，虽然运算符可以包含一个惊叹号 `!`，但是前缀运算符不能够以问号或者惊叹号开头。 diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md index 74d77277..90b55a46 100644 --- a/source/chapter3/03_Types.md +++ b/source/chapter3/03_Types.md @@ -173,7 +173,7 @@ 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`，返回类型为 `Int` 的函数类型。 函数类型若要抛出错误就必须使用 `throws` 关键字来标记，若要重抛错误则必须使用 `rethrows` 关键字来标记。`throws` 关键字是函数类型的一部分，非抛出函数是抛出函数函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。抛出和重抛函数的相关描述见章节 [抛出函数与方法](05_Declarations.html#throwing_functions_and_methods) 和 [重抛函数与方法](05_Declarations.html#rethrowing_functions_and_methods)。 @@ -197,7 +197,7 @@ func takesTwoFunctions(first: (Any) -> Void, second: (Any) -> Void) { 在上面代码里，`takesTwoFunctions(first:second:)` 的两个参数都是函数。 它们都没有标记为 `@escaping`, 因此它们都是非逃逸的。 -上述例子里的被标记为“错误”的四个函数调用会产生编译错误。因为第一个和第二个参数是非逃逸函数，它们不能够被当作变量被传递到另一个非闭包函数参数。与此相反, 标记“正确”的两个函数不回产生编译错误。这些函数调用不会违反限制， 因为 `外部(external)` 不是 `takesTwoFunctions(first:second:)` 里的一个参数。 +上述例子里的被标记为“错误”的四个函数调用会产生编译错误。因为第一个和第二个参数是非逃逸函数，它们不能够被当作变量被传递到另一个非闭包函数参数。与此相反, 标记“正确”的两个函数不回产生编译错误。这些函数调用不会违反限制， 因为 `外部（external）` 不是 `takesTwoFunctions(first:second:)` 里的一个参数。 如果你需要避免这个限制， 标记其中之一的参数为逃逸， 或者使用 `withoutActuallyEscaping(_:do:)` 函数临时地转换非逃逸函数的其中一个参数为逃逸函数。关于避免内存访问冲突，可以参阅[内存安全](../chapter2/24_Memory_Safety.html)。 diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md index cdecf973..f75e31c3 100644 --- a/source/chapter3/04_Expressions.md +++ b/source/chapter3/04_Expressions.md @@ -567,7 +567,7 @@ x = .AnotherValue ### 选择器表达式 -*选择器表达式*可以让你通过选择器来引用在 Objective-C 中方法(method)和属性(property)的 setter 和 getter 方法。 +*选择器表达式*可以让你通过选择器来引用在 Objective-C 中方法（method）和属性（property）的 setter 和 getter 方法。 > \#selector(方法名) \#selector(getter: 属性名) diff --git a/source/chapter3/06_Declarations.md b/source/chapter3/06_Declarations.md index 35d92fd8..6efcd365 100755 --- a/source/chapter3/06_Declarations.md +++ b/source/chapter3/06_Declarations.md @@ -64,7 +64,7 @@ - [声明修饰符](#declaration_modifiers) - [访问控制级别](#access_control_levels) -*声明 (declaration)* 用以向程序里引入新的名字或者结构。举例来说，可以使用声明来引入函数和方法，变量和常量，或者定义新的具有命名的枚举、结构、类和协议类型。还可以使用声明来扩展一个既有的具有命名的类型的行为，或者在程序里引入在其它地方声明的符号。 +*声明（declaration）* 用以向程序里引入新的名字或者结构。举例来说，可以使用声明来引入函数和方法，变量和常量，或者定义新的具有命名的枚举、结构、类和协议类型。还可以使用声明来扩展一个既有的具有命名的类型的行为，或者在程序里引入在其它地方声明的符号。 在 Swift 中，大多数声明在某种意义上讲也是定义，因为声明往往伴随着实现或初始化。由于协议并不提供实现，大多数协议成员仅仅只是声明而已。为了方便起见，也是因为这些区别在 Swift 中并不是很重要，“声明”这个术语同时包含了声明和定义两种含义。 @@ -90,7 +90,7 @@ ## 顶级代码 -Swift 的源文件中的顶级代码 (top-level code) 由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access_control_levels)。 +Swift 的源文件中的顶级代码（top-level code）由零个或多个语句、声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他具有命名的声明可以被同模块中的每一个源文件中的代码访问。可以使用一个访问级别修饰符来标记声明来覆盖这种默认行为，请参阅 [访问控制级别](#access_control_levels)。 > 顶级声明语法 > @@ -99,7 +99,7 @@ Swift 的源文件中的顶级代码 (top-level code) 由零个或多个语句 ## 代码块 -*代码块 (code block)* 可以将一些声明和控制结构组织在一起。它有如下的形式： +*代码块（code block）* 可以将一些声明和控制结构组织在一起。它有如下的形式： ```swift { @@ -117,7 +117,7 @@ Swift 的源文件中的顶级代码 (top-level code) 由零个或多个语句 ## 导入声明 -*导入声明 (import declaration)* 让你可以使用在其他文件中声明的内容。导入语句的基本形式是导入整个模块，它由 `import` 关键字和紧随其后的模块名组成： +*导入声明（import declaration）* 让你可以使用在其他文件中声明的内容。导入语句的基本形式是导入整个模块，它由 `import` 关键字和紧随其后的模块名组成： ```swift import 模块 @@ -146,7 +146,7 @@ import 模块.子模块 ## 常量声明 -*常量声明 (constant declaration)* 可以在程序中引入一个具有命名的常量。常量以关键字 `let` 来声明，遵循如下格式： +*常量声明（constant declaration）* 可以在程序中引入一个具有命名的常量。常量以关键字 `let` 来声明，遵循如下格式： ```swift let 常量名称: 类型 = 表达式 @@ -154,7 +154,7 @@ let 常量名称: 类型 = 表达式 常量声明在“常量名称”和用于初始化的“表达式”的值之间定义了一种不可变的绑定关系；当常量的值被设定之后，它就无法被更改。这意味着，如果常量以类对象来初始化，对象本身的内容是可以改变的，但是常量和该对象之间的绑定关系是不能改变的。 -当一个常量被声明为全局常量时，它必须拥有一个初始值。在类或者结构中声明一个常量时，它将作为*常量属性 (constant property)*。常量声明不能是计算型属性，因此也没有存取方法。 +当一个常量被声明为全局常量时，它必须拥有一个初始值。在类或者结构中声明一个常量时，它将作为*常量属性（constant property）*。常量声明不能是计算型属性，因此也没有存取方法。 如果常量名称是元组形式，元组中每一项的名称都会和初始化表达式中对应的值进行绑定。 @@ -171,7 +171,7 @@ print("The second number is \(secondNumber).") // 打印 “The second number is 42.” ``` -当常量名称的类型 (`:` 类型) 可以被推断出时，类型标注在常量声明中是可选的，正如 [类型推断](03_Types.html#type_inference) 中所描述的。 +当常量名称的类型（`:` 类型）可以被推断出时，类型标注在常量声明中是可选的，正如 [类型推断](03_Types.html#type_inference) 中所描述的。 声明一个常量类型属性要使用 `static` 声明修饰符。类型属性在 [类型属性](../chapter2/10_Properties.html#type_properties)中有介绍。 @@ -192,7 +192,7 @@ print("The second number is \(secondNumber).") ## 变量声明 -*变量声明 (variable declaration)* 可以在程序中引入一个具有命名的变量，它以关键字 `var` 来声明。 +*变量声明（variable declaration）* 可以在程序中引入一个具有命名的变量，它以关键字 `var` 来声明。 变量声明有几种不同的形式，可以声明不同种类的命名值和可变值，如存储型和计算型变量和属性，属性观察器，以及静态变量属性。所使用的声明形式取决于变量声明的适用范围和打算声明的变量类型。 @@ -211,9 +211,9 @@ print("The second number is \(secondNumber).") var 变量名称: 类型 = 表达式 ``` -可以在全局范围，函数内部，或者在类和结构的声明中使用这种形式来声明一个变量。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个存储型变量。当它在类或者结构中被声明时，它代表一个*存储型变量属性 (stored variable property)*。 +可以在全局范围，函数内部，或者在类和结构的声明中使用这种形式来声明一个变量。当变量以这种形式在全局范围或者函数内部被声明时，它代表一个存储型变量。当它在类或者结构中被声明时，它代表一个*存储型变量属性（stored variable property）*。 -用于初始化的表达式不可以在协议的声明中出现，在其他情况下，该表达式是可选的。如果没有初始化表达式，那么变量声明必须包含类型标注 (`:` *type*)。 +用于初始化的表达式不可以在协议的声明中出现，在其他情况下，该表达式是可选的。如果没有初始化表达式，那么变量声明必须包含类型标注（`:` *type*）。 如同常量声明，如果变量名称是元组形式，元组中每一项的名称都会和初始化表达式中对应的值进行绑定。 @@ -235,7 +235,7 @@ var 变量名称: 类型 { } ``` -可以在全局范围、函数内部，以及类、结构、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性 (computed property)*。 +可以在全局范围、函数内部，以及类、结构、枚举、扩展的声明中使用这种形式的声明。当变量以这种形式在全局范围或者函数内部被声明时，它表示一个计算型变量。当它在类、结构、枚举、扩展声明的上下文中被声明时，它表示一个*计算型属性（computed property）*。 getter 用来读取变量值，setter 用来写入变量值。setter 子句是可选的，getter 子句是必须的。不过也可以将这些子句都省略，直接返回请求的值，正如在 [只读计算型属性](../chapter2/10_Properties.html#computed_properties) 中描述的那样。但是如果提供了一个 setter 子句，就必须也提供一个 getter 子句。 @@ -333,7 +333,7 @@ var 变量名称: 类型 = 表达式 { ## 类型别名声明 -*类型别名 (type alias)* 声明可以在程序中为一个既有类型声明一个别名。类型别名声明语句使用关键字 `typealias` 声明，遵循如下的形式： +*类型别名（type alias）* 声明可以在程序中为一个既有类型声明一个别名。类型别名声明语句使用关键字 `typealias` 声明，遵循如下的形式： ```swift typealias 类型别名 = 现存类型 @@ -389,7 +389,7 @@ func sum(_ sequence: T) -> Int where T.Element == Int { ## 函数声明 -使用*函数声明 (function declaration)* 在程序中引入新的函数或者方法。在类、结构体、枚举，或者协议中声明的函数会作为方法。函数声明使用关键字 `func`，遵循如下的形式： +使用*函数声明（function declaration）* 在程序中引入新的函数或者方法。在类、结构体、枚举，或者协议中声明的函数会作为方法。函数声明使用关键字 `func`，遵循如下的形式： ```swift func 函数名称(参数列表) -> 返回类型 { @@ -409,7 +409,7 @@ func 函数名称(参数列表) { 函数可以使用元组类型作为返回类型来返回多个值。 -函数定义可以出现在另一个函数声明内。这种函数被称作*嵌套函数 (nested function)*。更多关于嵌套函数的讨论，请参阅 [嵌套函数](../chapter2/06_Functions.html#Nested_Functions)。 +函数定义可以出现在另一个函数声明内。这种函数被称作*嵌套函数（nested function）*。更多关于嵌套函数的讨论，请参阅 [嵌套函数](../chapter2/06_Functions.html#Nested_Functions)。 ### 参数名 @@ -448,9 +448,9 @@ f(x: 1, withY: 2, 3) // 参数 x 和 y 是有标签的，参数 z 则没有 2. 函数体内部，拷贝后的值被修改。 3. 函数返回后，拷贝后的值被赋值给原参数。 -这种行为被称为*拷入拷出 (copy-in copy-out)* 或*值结果调用 (call by value result)*。例如，当一个计算型属性或者一个具有属性观察器的属性被用作函数的输入输出参数时，其 getter 会在函数调用时被调用，而其 setter 会在函数返回时被调用。 +这种行为被称为*拷入拷出（copy-in copy-out）* 或*值结果调用（call by value result）*。例如，当一个计算型属性或者一个具有属性观察器的属性被用作函数的输入输出参数时，其 getter 会在函数调用时被调用，而其 setter 会在函数返回时被调用。 -作为一种优化手段，当参数值存储在内存中的物理地址时，在函数体内部和外部均会使用同一内存位置。这种优化行为被称为*引用调用 (call by reference)*，它满足了拷入拷出模式的所有要求，且消除了复制带来的开销。在代码中，要规范使用拷入拷出模式，不要依赖于引用调用。 +作为一种优化手段，当参数值存储在内存中的物理地址时，在函数体内部和外部均会使用同一内存位置。这种优化行为被称为*引用调用（call by reference）*，它满足了拷入拷出模式的所有要求，且消除了复制带来的开销。在代码中，要规范使用拷入拷出模式，不要依赖于引用调用。 不要使用传递给输入输出参数的值，即使原始值在当前作用域中依然可用。当函数返回时，你对原始值所做的更改会被拷贝的值所覆盖。不要依赖于引用调用的优化机制来试图避免这种覆盖。 @@ -600,7 +600,7 @@ Swift 定义了 `Never` 类型，它表示函数或者方法不会返回给它 ## 枚举声明 -在程序中使用*枚举声明 (enumeration declaration)* 来引入一个枚举类型。 +在程序中使用*枚举声明（enumeration declaration）* 来引入一个枚举类型。 枚举声明有两种基本形式，使用关键字 `enum` 来声明。枚举声明体包含零个或多个值，称为枚举用例，还可包含任意数量的声明，包括计算型属性、实例方法、类型方法、构造器、类型别名，甚至其他枚举、结构体和类。枚举声明不能包含析构器或者协议声明。 @@ -750,7 +750,7 @@ enum WeekendDay: String { ## 结构体声明 -使用*结构体声明 (structure declaration)* 可以在程序中引入一个结构体类型。结构体声明使用 `struct` 关键字，遵循如下的形式： +使用*结构体声明（structure declaration）* 可以在程序中引入一个结构体类型。结构体声明使用 `struct` 关键字，遵循如下的形式： ```swift struct 结构体名称: 采纳的协议 { @@ -792,7 +792,7 @@ struct 结构体名称: 采纳的协议 { ## 类声明 -可以在程序中使用*类声明 (class declaration)* 来引入一个类。类声明使用关键字 `class`，遵循如下的形式： +可以在程序中使用*类声明（class declaration）* 来引入一个类。类声明使用关键字 `class`，遵循如下的形式： ```swift class 类名: 超类, 采纳的协议 { @@ -837,7 +837,7 @@ class 类名: 超类, 采纳的协议 { ## 协议声明 -*协议声明 (protocol declaration)* 可以为程序引入一个命名的协议类型。协议声明只能在全局区域使用 `protocol` 关键字来进行声明，并遵循如下形式： +*协议声明（protocol declaration）* 可以为程序引入一个命名的协议类型。协议声明只能在全局区域使用 `protocol` 关键字来进行声明，并遵循如下形式： ```swift protocol 协议名称: 继承的协议 { @@ -873,7 +873,7 @@ protocol SomeProtocol: class { 协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../chapter2/21_Protocols.html#protocols_as_types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。 -可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托(代理)模式](../chapter2/21_Protocols.html#delegation) 中所述。 +可以使用协议来声明作为代理的类或者结构体应该实现的方法，正如 [委托（代理）模式](../chapter2/21_Protocols.html#delegation) 中所述。 > 协议声明语法 @@ -1082,7 +1082,7 @@ if let actualInstance = SomeStruct(input: "Hello") { ## 析构器声明 -*析构器声明 (deinitializer declaration)* 可以为类声明一个析构器。析构器没有参数，遵循如下格式： +*析构器声明（deinitializer declaration）* 可以为类声明一个析构器。析构器没有参数，遵循如下格式： ```swift deinit { @@ -1107,7 +1107,7 @@ deinit { ## 扩展声明 -*扩展声明 (extension declaration)* 可以扩展一个现存的类型的行为。扩展声明使用关键字 `extension`，遵循如下格式： +*扩展声明（extension declaration）* 可以扩展一个现存的类型的行为。扩展声明使用关键字 `extension`，遵循如下格式： ```swift extension 类型名称: 采纳的协议 { @@ -1145,7 +1145,7 @@ extension 类型名称 where 要求 { ## 下标声明 -*下标声明 (subscript declaration)* 用于为特定类型的对象添加下标支持，通常也用于为访问集合、列表和序列中的元素提供语法便利。下标声明使用关键字 `subscript`，形式如下： +*下标声明（subscript declaration）* 用于为特定类型的对象添加下标支持，通常也用于为访问集合、列表和序列中的元素提供语法便利。下标声明使用关键字 `subscript`，形式如下： ```swift subscript (参数列表) -> 返回类型 { @@ -1187,7 +1187,7 @@ subscript (参数列表) -> 返回类型 { ## 运算符声明 -*运算符声明 (operator declaration)* 会向程序中引入中缀、前缀或后缀运算符，使用关键字 `operator` 来声明。 +*运算符声明（operator declaration）* 会向程序中引入中缀、前缀或后缀运算符，使用关键字 `operator` 来声明。 可以声明三种不同的缀性：中缀、前缀和后缀。运算符的缀性指定了运算符与其运算对象的相对位置。 @@ -1244,7 +1244,7 @@ postfix operator 运算符名称 {} ## 优先级组声明 -*优先级组声明 (A precedence group declaration)* 会向程序的中缀运算符引入一个全新的优先级组。当没有用圆括号分组时，运算符优先级反应了运算符与它的操作数的关系的紧密程度。 +*优先级组声明（A precedence group declaration）* 会向程序的中缀运算符引入一个全新的优先级组。当没有用圆括号分组时，运算符优先级反应了运算符与它的操作数的关系的紧密程度。 优先级组的声明如下所示: ```swift @@ -1262,9 +1262,9 @@ precedencegroup 优先级组名称{ > > 使用较低和较高优先级组相互联系的优先级组必须保持单一层次关系，但它们不必是线性关系。这意味着优先级组也许会有未定义的相关优先级。这些优先级组的运算符在没有用圆括号分组的情况下是不能紧邻着使用的。 -Swift 定义了大量的优先级组来与标准库的运算符配合使用，例如相加(`+`)和相减(`-`)属于 `AdditionPrecedence` 组，相乘(`*`)和相除(`/`)属于 `MultiplicationPrecedence` 组，详细关于 Swift 标准库中一系列运算符和优先级组内容，参阅[Swift 标准库操作符参考](https://developer.apple.com/reference/swift/1851035-swift_standard_library_operators)。 +Swift 定义了大量的优先级组来与标准库的运算符配合使用，例如相加（`+`）和相减（`-`）属于 `AdditionPrecedence` 组，相乘（`*`）和相除（`/`）属于 `MultiplicationPrecedence` 组，详细关于 Swift 标准库中一系列运算符和优先级组内容，参阅[Swift 标准库操作符参考](https://developer.apple.com/reference/swift/1851035-swift_standard_library_operators)。 -运算符的结合性表示在没有圆括号分组的情况下，同样优先级的一系列运算符是如何被分组的。你可以指定运算符的结合性通过上下文关键字 `left`、`right` 或者 `none`,如果没有指定结合性，默认是 `none` 关键字。左关联性的运算符是从左至右分组的，例如，相减操作符(-)是左关联性的，所以表达式 `4 - 5 - 6` 被分组为 `(4 - 5) - 6`,得出结果-7。右关联性的运算符是从右往左分组的，指定为 `none` 结合性的运算符就没有结合性。同样优先级没有结合性的运算符不能相邻出现，例如 `<` 运算符是 `none` 结合性，那表示 `1 < 2 < 3` 就不是一个有效表达式。 +运算符的结合性表示在没有圆括号分组的情况下，同样优先级的一系列运算符是如何被分组的。你可以指定运算符的结合性通过上下文关键字 `left`、`right` 或者 `none`,如果没有指定结合性，默认是 `none` 关键字。左关联性的运算符是从左至右分组的，例如，相减操作符（-）是左关联性的，所以表达式 `4 - 5 - 6` 被分组为 `(4 - 5) - 6`,得出结果-7。右关联性的运算符是从右往左分组的，指定为 `none` 结合性的运算符就没有结合性。同样优先级没有结合性的运算符不能相邻出现，例如 `<` 运算符是 `none` 结合性，那表示 `1 < 2 < 3` 就不是一个有效表达式。 优先级组的赋值性表示在包含可选链操作时的运算符优先级。当设为 true 时，与优先级组对应的运算符在可选链操作中使用和标准库中赋值运算符同样的分组规则，当设为 false 或者不设置，该优先级组的运算符与不赋值的运算符遵循同样的可选链规则。 diff --git a/source/chapter3/10_Summary_of_the_Grammar.md b/source/chapter3/10_Summary_of_the_Grammar.md index 5c58e57d..3a92578e 100755 --- a/source/chapter3/10_Summary_of_the_Grammar.md +++ b/source/chapter3/10_Summary_of_the_Grammar.md @@ -31,13 +31,13 @@ > *语句* → [*声明*](../chapter3/05_Declarations.html#declaration) **;** _可选_ > *语句* → [*循环语句*](../chapter3/10_Statements.html#loop_statement) **;** _可选_ > *语句* → [*分支语句*](../chapter3/10_Statements.html#branch_statement) **;** _可选_ -> *语句* → [*标记语句(Labeled Statement)*](../chapter3/10_Statements.html#labeled_statement) +> *语句* → [*标记语句（Labeled Statement）*](../chapter3/10_Statements.html#labeled_statement) > *语句* → [*控制转移语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_ > *语句* → [*延迟语句*](TODO) **;** _可选_ > *语句* → [*执行语句*](TODO) **;** _可选_ -> *多条语句(Statements)* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ +> *多条语句（Statements）* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) _可选_ @@ -70,14 +70,14 @@ > *条件从句* → [*表达式*](TODO) > *条件从句* → [*表达式*](TODO) *,* [*表达式集*]() > *条件从句* → [*表达式集*](TODO) -> *条件从句* → [*可用条件 (availability-condition*)](TODO) *|* [*表达式集*]() +> *条件从句* → [*可用条件（availability-condition*）](TODO) *|* [*表达式集*]() > *条件集* → [*条件*](TODO) *|* [*条件*](TODO) *,* [*条件集*]() -> *条件* → [*可用条件(availability-condition)*](TODO) *|* [*个例条件(case-condition)*](TODO) *|* [*可选绑定条件(optional-binding-condition)*](TODO) -> *个例条件(case-condition)* → **case** [*模式*](TODO) [*构造器*](TODO) [*where 从句*](TODO)_可选_ -> *可选绑定条件(optional-binding-condition)* → [*可选绑定头(optional-binding-head)*](TODO) [*可选绑定连续集(optional-binding-continuation-list)*](TODO) _可选_ [*where 从句*](TODO) _可选_ -> *可选绑定头(optional-binding-head)* → **let** [*模式 构造器*](TODO) *|* **var** [*模式 构造器*](TODO) -> *可选绑定连续集(optional-binding-contiuation-list)* → [*可选绑定连续(optional-binding-contiuation)*](TODO) *|* [*可选绑定连续(optional-binding-contiuation)*](TODO) *，* [*可选绑定连续集(optional-binding-contiuation-list)*](TODO) -> *可选绑定连续(optional-binding-continuation)* → [*模式 构造器*](TODO) *|* [*可选绑定头(optional-binding-head)*](TODO) +> *条件* → [*可用条件（availability-condition）*](TODO) *|* [*个例条件（case-condition）*](TODO) *|* [*可选绑定条件（optional-binding-condition）*](TODO) +> *个例条件（case-condition）* → **case** [*模式*](TODO) [*构造器*](TODO) [*where 从句*](TODO)_可选_ +> *可选绑定条件（optional-binding-condition）* → [*可选绑定头（optional-binding-head）*](TODO) [*可选绑定连续集（optional-binding-continuation-list）*](TODO) _可选_ [*where 从句*](TODO) _可选_ +> *可选绑定头（optional-binding-head）* → **let** [*模式 构造器*](TODO) *|* **var** [*模式 构造器*](TODO) +> *可选绑定连续集（optional-binding-contiuation-list）* → [*可选绑定连续（optional-binding-contiuation）*](TODO) *|* [*可选绑定连续（optional-binding-contiuation）*](TODO) *，* [*可选绑定连续集（optional-binding-contiuation-list）*](TODO) +> *可选绑定连续（optional-binding-continuation）* → [*模式 构造器*](TODO) *|* [*可选绑定头（optional-binding-head）*](TODO) > Repeat-While 语句语法 @@ -96,8 +96,8 @@ > If 语句语法 > -> *if 语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else 从句(Clause)*](TODO) _可选_ -> *else 从句(Clause)* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if 语句*](../chapter3/10_Statements.html#if_statement) +> *if 语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else 从句（Clause）*](TODO) _可选_ +> *else 从句（Clause）* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if 语句*](../chapter3/10_Statements.html#if_statement) > Guard 语句语法 @@ -111,7 +111,7 @@ > > *switch 语句* → **switch** [*表达式*](../chapter3/04_Expressions.html#expression) **{** [*SwitchCase*](../chapter3/10_Statements.html#switch_cases) _可选_ **}** > *SwitchCase 集* → [*SwitchCase*](../chapter3/10_Statements.html#switch_case) [*SwitchCase 集*](../chapter3/10_Statements.html#switch_cases) _可选_ -> *SwitchCase* → [*case 标签*](../chapter3/10_Statements.html#case_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) | [*default 标签*](../chapter3/10_Statements.html#default_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) +> *SwitchCase* → [*case 标签*](../chapter3/10_Statements.html#case_label) [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) | [*default 标签*](../chapter3/10_Statements.html#default_label) [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) > *SwitchCase* → [*case 标签*](../chapter3/10_Statements.html#case_label) **;** | [*default 标签*](../chapter3/10_Statements.html#default_label) **;** > *case 标签* → **case** [*case 项集*](../chapter3/10_Statements.html#case_item_list) **:** > *case 项集* → [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ | [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ **,** [*case 项集*](../chapter3/10_Statements.html#case_item_list) @@ -123,13 +123,13 @@ > 标记语句语法 > -> *标记语句(Labeled Statement)* → [*语句标签*](../chapter3/10_Statements.html#statement_label) [*循环语句*](../chapter3/10_Statements.html#loop_statement) | [*语句标签*](../chapter3/10_Statements.html#statement_label) [*if 语句*](../chapter3/10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch 语句*](TODY) +> *标记语句（Labeled Statement）* → [*语句标签*](../chapter3/10_Statements.html#statement_label) [*循环语句*](../chapter3/10_Statements.html#loop_statement) | [*语句标签*](../chapter3/10_Statements.html#statement_label) [*if 语句*](../chapter3/10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch 语句*](TODY) > *语句标签* → [*标签名称*](../chapter3/10_Statements.html#label_name) **:** > *标签名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> 控制传递语句(Control Transfer Statement) 语法 +> 控制传递语句（Control Transfer Statement）语法 > > *控制传递语句* → [*break 语句*](../chapter3/10_Statements.html#break_statement) > *控制传递语句* → [*continue 语句*](../chapter3/10_Statements.html#continue_statement) @@ -162,42 +162,42 @@ > *return 语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ -> 可用条件(Availability Condition)语法 +> 可用条件（Availability Condition）语法 > -> *可用条件(availability-condition)* → **#available** **(** [*多可用参数*(availability-arguments)](TODO) **)** -> *多可用参数(availability- arguments)* → [*可用参数(availability-argument)*](TODO)|[*可用参数(availability-argument)*](TODO) , [多可用参数(availability-arguments)](TODO) -> *可用参数(availability- argument)* → [*平台名(platform-name)*](TODO) [*平台版本(platform-version)*](TODO) -> *可用参数(availability- argument)* → * +> *可用条件（availability-condition）* → **#available** **(** [*多可用参数*(availability-arguments)](TODO) **)** +> *多可用参数（availability- arguments）* → [*可用参数（availability-argument）*](TODO)|[*可用参数（availability-argument）*](TODO) , [多可用参数（availability-arguments）](TODO) +> *可用参数（availability- argument）* → [*平台名（platform-name）*](TODO) [*平台版本（platform-version）*](TODO) +> *可用参数（availability- argument）* → * > > *平台名* → **iOS** | **iOSApplicationExtension** > *平台名* → **OSX** | **macOSApplicationExtension** > *平台名* → **watchOS** > *平台名* → **tvOS** -> *平台版本* → [*十进制数(decimal-digits)*](TODO) -> *平台版本* → [*十进制数(decimal-digits)*](TODO) . [*十进制数(decimal-digits)*](TODO) -> *平台版本* → [*十进制数(decimal-digits)*](TODO) **.** [*十进制数(decimal-digits)*](TODO) **.** [*十进制数（decimal-digits)*](TODO)) +> *平台版本* → [*十进制数（decimal-digits）*](TODO) +> *平台版本* → [*十进制数（decimal-digits）*](TODO) . [*十进制数（decimal-digits）*](TODO) +> *平台版本* → [*十进制数（decimal-digits）*](TODO) **.** [*十进制数（decimal-digits）*](TODO) **.** [*十进制数（decimal-digits)*](TODO)) -> 抛出语句(Throw Statement)语法 +> 抛出语句（Throw Statement）语法 > -> *抛出语句(throw-statement)* → **throw** [*表达式(expression)*](TODO) +> *抛出语句（throw-statement）* → **throw** [*表达式（expression）*](TODO) -> 延迟语句 (defer-statement)语法 +> 延迟语句（defer-statement）语法 > -> *延迟语句(defer-statement)* → **defer** [*代码块*](TODO) +> *延迟语句（defer-statement）* → **defer** [*代码块*](TODO) -> 执行语句(do-statement)语法 +> 执行语句（do-statement）语法 > -> *执行语句(do-statement)* → **do** [*代码块*](TODO) [*catch-clauses*](TODO) _可选_ +> *执行语句（do-statement）* → **do** [*代码块*](TODO) [*catch-clauses*](TODO) _可选_ > *catch-clauses* → [*catch-clause*](TODO) [*catch-clauses*](TODO) _可选_ -> *catch-clauses* → **catch** [*模式(pattern)*](TODO) _可选_ [*where-clause*](TODO) _可选_ [*代码块(code-block)*](TODO) _可选_ +> *catch-clauses* → **catch** [*模式（pattern）*](TODO) _可选_ [*where-clause*](TODO) _可选_ [*代码块（code-block）*](TODO) _可选_ ## 泛型参数 -> 泛型形参从句(Generic Parameter Clause) 语法 +> 泛型形参从句（Generic Parameter Clause）语法 > > *泛型参数从句* → **<** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list) [*约束从句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>** > *泛型参数集* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list) @@ -220,7 +220,7 @@ > *泛型参数* → [*类型*](../chapter3/03_Types.html#type) -## 声明 (Declarations) +## 声明（Declarations） > 声明语法 > @@ -238,26 +238,26 @@ > *声明* → [*扩展声明*](../chapter3/05_Declarations.html#extension_declaration) > *声明* → [*下标声明*](../chapter3/05_Declarations.html#subscript_declaration) > *声明* → [*运算符声明*](../chapter3/05_Declarations.html#operator_declaration) -> *声明(Declarations)集* → [*声明*](../chapter3/05_Declarations.html#declaration) [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ +> *声明（Declarations）集* → [*声明*](../chapter3/05_Declarations.html#declaration) [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ -> 顶级(Top Level) 声明语法 +> 顶级（Top Level）声明语法 > -> *顶级声明* → [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ +> *顶级声明* → [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) _可选_ > 代码块语法 > -> *代码块* → **{** [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ **}** +> *代码块* → **{** [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) _可选_ **}** -> 导入(Import)声明语法 +> 导入（Import）声明语法 > -> *导入声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **import** [*导入类型*](../chapter3/05_Declarations.html#import_kind) _可选_ [*导入路径*](../chapter3/05_Declarations.html#import_path) +> *导入声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **import** [*导入类型*](../chapter3/05_Declarations.html#import_kind) _可选_ [*导入路径*](../chapter3/05_Declarations.html#import_path) > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func** > *导入路径* → [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) | [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) **.** [*导入路径*](../chapter3/05_Declarations.html#import_path) > *导入路径标识符* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator) @@ -266,7 +266,7 @@ > 常数声明语法 > -> *常量声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符(Modifiers)集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list) +> *常量声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符（Modifiers）集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list) > *模式构造器集* → [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) | [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) **,** [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list) > *模式构造器* → [*模式*](../ chapter3/07_Patterns.html#pattern) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ > *构造器* → **=** [*表达式*](../chapter3/04_Expressions.html#expression) @@ -275,34 +275,34 @@ > 变量声明语法 > -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*代码块*](../chapter3/05_Declarations.html#code_block) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter 块*](../chapter3/05_Declarations.html#getter_setter_block) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter 关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) -> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet 代码块*](../chapter3/05_Declarations.html#willSet_didSet_block) -> *变量声明头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符(Modifers)集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var** +> *变量声明* → [*变量声明头（Head）*](../chapter3/05_Declarations.html#variable_declaration_head) [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list) +> *变量声明* → [*变量声明头（Head）*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*代码块*](../chapter3/05_Declarations.html#code_block) +> *变量声明* → [*变量声明头（Head）*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter 块*](../chapter3/05_Declarations.html#getter_setter_block) +> *变量声明* → [*变量声明头（Head）*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter 关键字（Keyword）块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) +> *变量声明* → [*变量声明头（Head）*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet 代码块*](../chapter3/05_Declarations.html#willSet_didSet_block) +> *变量声明头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符（Modifers）集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var** > *变量名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) > *getter-setter 块* → **{** [*getter 从句*](../chapter3/05_Declarations.html#getter_clause) [*setter 从句*](../chapter3/05_Declarations.html#setter_clause) _可选_ **}** > *getter-setter 块* → **{** [*setter 从句*](../chapter3/05_Declarations.html#setter_clause) [*getter 从句*](../chapter3/05_Declarations.html#getter_clause) **}** -> *getter 从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block) -> *setter 从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter 名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) +> *getter 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block) +> *setter 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter 名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) > *setter 名称* → **(** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **)** -> *getter-setter 关键字(Keyword)块* → **{** [*getter 关键字(Keyword)从句*](../chapter3/05_Declarations.html#getter_keyword_clause) [*setter 关键字(Keyword)从句*](../chapter3/05_Declarations.html#setter_keyword_clause) _可选_ **}** -> *getter-setter 关键字(Keyword)块* → **{** [*setter 关键字(Keyword)从句*](../chapter3/05_Declarations.html#setter_keyword_clause) [*getter 关键字(Keyword)从句*](../chapter3/05_Declarations.html#getter_keyword_clause) **}** -> *getter 关键字(Keyword)从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **get** -> *setter 关键字(Keyword)从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **set** +> *getter-setter 关键字（Keyword）块* → **{** [*getter 关键字（Keyword）从句*](../chapter3/05_Declarations.html#getter_keyword_clause) [*setter 关键字（Keyword）从句*](../chapter3/05_Declarations.html#setter_keyword_clause) _可选_ **}** +> *getter-setter 关键字（Keyword）块* → **{** [*setter 关键字（Keyword）从句*](../chapter3/05_Declarations.html#setter_keyword_clause) [*getter 关键字（Keyword）从句*](../chapter3/05_Declarations.html#getter_keyword_clause) **}** +> *getter 关键字（Keyword）从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **get** +> *setter 关键字（Keyword）从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **set** > *willSet-didSet 代码块* → **{** [*willSet 从句*](../chapter3/05_Declarations.html#willSet_clause) [*didSet 从句*](../chapter3/05_Declarations.html#didSet_clause) _可选_ **}** > *willSet-didSet 代码块* → **{** [*didSet 从句*](../chapter3/05_Declarations.html#didSet_clause) [*willSet 从句*](../chapter3/05_Declarations.html#willSet_clause) **}** -> *willSet 从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **willSet** [*setter 名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) -> *didSet 从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ +> *willSet 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **willSet** [*setter 名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) +> *didSet 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **didSet** [*setter 名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block) > 类型别名声明语法 > -> *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) -> *类型别名头(Head)* → [*属性*](TODO) _可选_ [*访问级别修改符(access-level-modifier)*](TODO) **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name) +> *类型别名声明* → [*类型别名头（Head）*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) +> *类型别名头（Head）* → [*属性*](TODO) _可选_ [*访问级别修改符（access-level-modifier）*](TODO) **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name) > *类型别名名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) > *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type) @@ -310,20 +310,20 @@ > 函数声明语法 > -> *函数声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature) [*函数体*](../chapter3/05_Declarations.html#function_body) -> *函数头* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **func** +> *函数声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名（Signature）*](../chapter3/05_Declarations.html#function_signature) [*函数体*](../chapter3/05_Declarations.html#function_body) +> *函数头* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明描述符（Specifiers）集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **func** > *函数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator) -> *函数签名(Signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** _可选_ [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ +> *函数签名（Signature）* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** _可选_ [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ -> *函数签名(Signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ -> *函数结果* → **->** [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) +> *函数签名（Signature）* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ +> *函数结果* → **->** [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) > *函数体* → [*代码块*](../chapter3/05_Declarations.html#code_block) > *参数从句* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) _可选_ > *参数从句* → **(** **)** | **(** [*参数集*](../chapter3/05_Declarations.html#parameter_list) **...** _可选_ **)** > *参数集* → [*参数*](../chapter3/05_Declarations.html#parameter) | [*参数*](../chapter3/05_Declarations.html#parameter) **,** [*参数集*](../chapter3/05_Declarations.html#parameter_list) > *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](../chapter3/05_Declarations.html#parameter_name) _可选_ [*本地参数名*](../chapter3/05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](../chapter3/03_Types.html#type_annotation) [*默认参数从句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_ > *参数* → **inout** _可选_ **var** [*外部参数名*](../chapter3/05_Declarations.html#parameter_name) [*本地参数名*](../chapter3/05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](../chapter3/03_Types.html#type_annotation) [*默认参数从句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_ -> *参数* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) +> *参数* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) > *外部参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** > *本地参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_** > *默认参数从句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression) @@ -332,117 +332,117 @@ > 枚举声明语法 > -> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*联合式枚举*](../chapter3/05_Declarations.html#union_style_enum) -> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*原始值式枚举(raw-value-style-enum)*](TODO) -> *联合式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句(type-inheritance-clause)*](TODO) _可选_ **{** [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}** +> *枚举声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ [*联合式枚举*](../chapter3/05_Declarations.html#union_style_enum) +> *枚举声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ [*原始值式枚举（raw-value-style-enum）*](TODO) +> *联合式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句（type-inheritance-clause）*](TODO) _可选_ **{** [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}** > *联合样式枚举成员* → [*union-style-enum-member*](../chapter3/05_Declarations.html#union_style_enum_member) [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ -> *联合样式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*联合式(Union Style)的枚举 case 从句*](../chapter3/05_Declarations.html#union_style_enum_case_clause) -> *联合式(Union Style)的枚举 case 从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*联合式(Union Style)的枚举 case 集*](../chapter3/05_Declarations.html#union_style_enum_case_list) -> *联合式(Union Style)的枚举 case 集* → [*联合式(Union Style)的 case*](../chapter3/05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的 case*](../chapter3/05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举 case 集*](../chapter3/05_Declarations.html#union_style_enum_case_list) -> *联合式(Union Style)的枚举 case* → [*枚举的 case 名*](../chapter3/05_Declarations.html#enum_case_name) [*元组类型*](../chapter3/03_Types.html#tuple_type) _可选_ +> *联合样式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*联合式（Union Style）的枚举 case 从句*](../chapter3/05_Declarations.html#union_style_enum_case_clause) +> *联合式（Union Style）的枚举 case 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*联合式（Union Style）的枚举 case 集*](../chapter3/05_Declarations.html#union_style_enum_case_list) +> *联合式（Union Style）的枚举 case 集* → [*联合式（Union Style）的 case*](../chapter3/05_Declarations.html#union_style_enum_case) | [*联合式（Union Style）的 case*](../chapter3/05_Declarations.html#union_style_enum_case) **,** [*联合式（Union Style）的枚举 case 集*](../chapter3/05_Declarations.html#union_style_enum_case_list) +> *联合式（Union Style）的枚举 case* → [*枚举的 case 名*](../chapter3/05_Declarations.html#enum_case_name) [*元组类型*](../chapter3/03_Types.html#tuple_type) _可选_ > *枚举名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) > *枚举的 case 名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) > *原始值式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](../chapter3/03_Types.html#type_identifier) **{** [*原始值式枚举成员集*](../chapter3/05_Declarations.html#raw_value_style_enum_members) _可选_ **}** > *原始值式枚举成员集* → [*原始值式枚举成员*](../chapter3/05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员集*](../chapter3/05_Declarations.html#raw_value_style_enum_members) _可选_ > *原始值式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*原始值式枚举 case 从句*](../chapter3/05_Declarations.html#raw_value_style_enum_case_clause) -> *原始值式枚举 case 从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举 case 集*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list) +> *原始值式枚举 case 从句* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举 case 集*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list) > *原始值式枚举 case 集* → [*原始值式枚举 case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举 case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举 case 集*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list) > *原始值式枚举 case* → [*枚举的 case 名*](../chapter3/05_Declarations.html#enum_case_name) [*原始值赋值*](../chapter3/05_Declarations.html#raw_value_assignment) _可选_ > *原始值赋值* → **=** [*字面量*](../chapter3/02_Lexical_Structure.html#literal) -> *原始值字面量(raw-value-literal)* → [*数值字面量*](TODO) | [*字符串字面量*](TODO) | [*布尔字面量*](TODO) +> *原始值字面量（raw-value-literal）* → [*数值字面量*](TODO) | [*字符串字面量*](TODO) | [*布尔字面量*](TODO) > 结构体声明语法 > -> *结构体声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ **struct** [*结构体名称*](../chapter3/05_Declarations.html#struct_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](../chapter3/05_Declarations.html#struct_body) +> *结构体声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) _可选_ **struct** [*结构体名称*](../chapter3/05_Declarations.html#struct_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](../chapter3/05_Declarations.html#struct_body) > *结构体名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *结构体主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> *结构体主体* → **{** [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** > 类声明语法 > -> *类声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) **class** [*类名*](../chapter3/05_Declarations.html#class_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类主体*](../chapter3/05_Declarations.html#class_body) +> *类声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器（access-level-modifier）*](TODO) **class** [*类名*](../chapter3/05_Declarations.html#class_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类主体*](../chapter3/05_Declarations.html#class_body) > *类名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *类主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> *类主体* → **{** [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** -> 协议(Protocol)声明语法 +> 协议（Protocol）声明语法 > -> *协议声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_[*访问级别修改器(access-level-modifier)*](TODO) **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body) +> *协议声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_[*访问级别修改器（access-level-modifier）*](TODO) **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body) > *协议名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) -> *协议主体* → **{** [*协议成员声明(Declarations)集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ **}** +> *协议主体* → **{** [*协议成员声明（Declarations）集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ **}** > *协议成员声明* → [*协议属性声明*](../chapter3/05_Declarations.html#protocol_property_declaration) > *协议成员声明* → [*协议方法声明*](../chapter3/05_Declarations.html#protocol_method_declaration) > *协议成员声明* → [*协议构造器声明*](../chapter3/05_Declarations.html#protocol_initializer_declaration) > *协议成员声明* → [*协议下标声明*](../chapter3/05_Declarations.html#protocol_subscript_declaration) > *协议成员声明* → [*协议关联类型声明*](../chapter3/05_Declarations.html#protocol_associated_type_declaration) -> *协议成员声明(Declarations)集* → [*协议成员声明*](../chapter3/05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ +> *协议成员声明（Declarations）集* → [*协议成员声明*](../chapter3/05_Declarations.html#protocol_member_declaration) [*协议成员声明（Declarations）集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ > 协议属性声明语法 > -> *协议属性声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter 关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) +> *协议属性声明* → [*变量声明头（Head）*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter 关键字（Keyword）块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) > 协议方法声明语法 > -> *协议方法声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature) +> *协议方法声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名（Signature）*](../chapter3/05_Declarations.html#function_signature) > 协议构造器声明语法 > -> *协议构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) +> *协议构造器声明* → [*构造器头（Head）*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) > 协议下标声明语法 > -> *协议下标声明* → [*下标头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) +> *协议下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 关键字（Keyword）块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) > 协议关联类型声明语法 > -> *协议关联类型声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) _可选_ +> *协议关联类型声明* → [*类型别名头（Head）*](../chapter3/05_Declarations.html#typealias_head) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) _可选_ > 构造器声明语法 > -> *构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*构造器主体*](../chapter3/05_Declarations.html#initializer_body) -> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init** -> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init ?** -> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_ **init !** +> *构造器声明* → [*构造器头（Head）*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*构造器主体*](../chapter3/05_Declarations.html#initializer_body) +> *构造器头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init** +> *构造器头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init ?** +> *构造器头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集（declaration-modifiers）*](TODO) _可选_ **init !** > *构造器主体* → [*代码块*](../chapter3/05_Declarations.html#code_block) > 析构器声明语法 > -> *析构器声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](../chapter3/05_Declarations.html#code_block) +> *析构器声明* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](../chapter3/05_Declarations.html#code_block) -> 扩展(Extension)声明语法 +> 扩展（Extension）声明语法 > > *扩展声明* → [*访问级别修改器*](TODO) _可选_ **extension** [*类型标识*](../chapter3/03_Types.html#type_identifier) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](../chapter3/05_Declarations.html#extension_body) -> *extension-body* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** +> *extension-body* → **{** [*声明（Declarations）集*](../chapter3/05_Declarations.html#declarations) _可选_ **}** > 下标声明语法 > -> *下标声明* → [*下标头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*代码块*](../chapter3/05_Declarations.html#code_block) -> *下标声明* → [*下标头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 块*](../chapter3/05_Declarations.html#getter_setter_block) -> *下标声明* → [*下标头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) -> *下标头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) -> *下标结果(Result)* → **->** [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) +> *下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*代码块*](../chapter3/05_Declarations.html#code_block) +> *下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 块*](../chapter3/05_Declarations.html#getter_setter_block) +> *下标声明* → [*下标头（Head）*](../chapter3/05_Declarations.html#subscript_head) [*下标结果（Result）*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter 关键字（Keyword）块*](../chapter3/05_Declarations.html#getter_setter_keyword_block) +> *下标头（Head）* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器（declaration-modifiers）*](TODO) _可选_ **subscript** [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) +> *下标结果（Result）* → **->** [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) @@ -461,19 +461,19 @@ > 声明修改器语法 > -> *声明修改器* → **类** | **便捷(convenience)** | **动态(dynamic)** | **final** | **中置(infix)** | **lazy** | **可变(mutating)** | **不可变(nonmutating)** | **可选(optional)** | **改写(override)** | **后置** | **前置** | **required** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **弱(weak)** -> *声明修改器* → [*访问级别声明器(access-level-modifier)*](TODO) +> *声明修改器* → **类** | **便捷（convenience）** | **动态（dynamic）** | **final** | **中置（infix）** | **lazy** | **可变（mutating）** | **不可变（nonmutating）** | **可选（optional）** | **改写（override）** | **后置** | **前置** | **required** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **弱（weak）** +> *声明修改器* → [*访问级别声明器（access-level-modifier）*](TODO) > *声明修改集* → [*声明修改器*](TODO) [*声明修改器集*](TODO) _可选_ -> *访问级别修改器* → **内部的** | **内部的(set)** -> *访问级别修改器* → **私有的** | **私有的(set)** +> *访问级别修改器* → **内部的** | **内部的（set）** +> *访问级别修改器* → **私有的** | **私有的（set）** > *访问级别修改器* → **公共的** -| **公共的(set)** +| **公共的（set）** > *访问级别修改器集* →[*访问级别修改器*](TODO) [*访问级别修改器集*](TODO) _可选_ ## 模式 -> 模式(Patterns) 语法 +> 模式（Patterns）语法 > > *模式* → [*通配符模式*](../chapter3/07_Patterns.html#wildcard_pattern) [*类型注解*](../chapter3/03_Types.html#type_annotation) _可选_ > *模式* → [*标识符模式*](../chapter3/07_Patterns.html#identifier_pattern) [*类型注解*](../chapter3/03_Types.html#type_annotati Value Bindingon ) _可选_ @@ -499,7 +499,7 @@ -> 值绑定(Value Binding)模式语法 +> 值绑定（Value Binding）模式语法 > > *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../chapter3/07_Patterns.html#pattern) @@ -526,7 +526,7 @@ > 类型转换模式语法 > -> *类型转换模式(type-casting-pattern)* → [*is 模式*](../chapter3/07_Patterns.html#is_pattern) | [*as 模式*](../chapter3/07_Patterns.html#as_pattern) +> *类型转换模式（type-casting-pattern）* → [*is 模式*](../chapter3/07_Patterns.html#is_pattern) | [*as 模式*](../chapter3/07_Patterns.html#as_pattern) > *is 模式* → **is** [*类型*](../chapter3/03_Types.html#type) > *as 模式* → [*模式*](../chapter3/07_Patterns.html#pattern) **as** [*类型*](../chapter3/03_Types.html#type) @@ -544,13 +544,13 @@ > *属性* → **@** [*属性名*](../chapter3/06_Attributes.html#attribute_name) [*属性参数从句*](../chapter3/06_Attributes.html#attribute_argument_clause) _可选_ > *属性名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) > *属性参数从句* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** -> *属性(Attributes)集* → [*属性*](../chapter3/06_Attributes.html#attribute) [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ +> *属性（Attributes）集* → [*属性*](../chapter3/06_Attributes.html#attribute) [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ > *平衡令牌集* → [*平衡令牌*](../chapter3/06_Attributes.html#balanced_token) [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ > *平衡令牌* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)** > *平衡令牌* → **[** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **]** > *平衡令牌* → **{** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **}** > *平衡令牌* → **任意标识符、关键字、字面量或运算符** -> *平衡令牌* → **任意标点除了(, )、[, ]、{, 或 }** +> *平衡令牌* → **任意标点除了(、)、[、]、{ 或 }** ## 表达式 @@ -565,8 +565,8 @@ > 前置表达式语法 > > *前置表达式* → [*前置运算符*](../chapter3/02_Lexical_Structure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) -> *前置表达式* → [*写入写出(in-out)表达式*](../chapter3/04_Expressions.html#in_out_expression) -> *写入写出(in-out)表达式* → **&** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) +> *前置表达式* → [*写入写出（in-out）表达式*](../chapter3/04_Expressions.html#in_out_expression) +> *写入写出（in-out）表达式* → **&** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) > try 表达式语法 @@ -653,14 +653,14 @@ > 闭包表达式语法 > -> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}** -> *闭包签名(Signational)* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名(Signational)* → [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** -> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) **in** -> *捕获(Capature)集* → **[** [*捕获(Capature)说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]** -> *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** +> *闭包表达式* → **{** [*闭包签名（Signational）*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句（Statements）*](../chapter3/10_Statements.html#statements) **}** +> *闭包签名（Signational）* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** +> *闭包签名（Signational）* → [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** +> *闭包签名（Signational）* → [*捕获（Capature）集*](../chapter3/04_Expressions.html#capture_list) [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** +> *闭包签名（Signational）* → [*捕获（Capature）集*](../chapter3/04_Expressions.html#capture_list) [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in** +> *闭包签名（Signational）* → [*捕获（Capature）集*](../chapter3/04_Expressions.html#capture_list) **in** +> *捕获（Capature）集* → **[** [*捕获（Capature）说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]** +> *捕获（Capature）说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)** @@ -670,7 +670,7 @@ -> 圆括号表达式(Parenthesized Expression)语法 +> 圆括号表达式（Parenthesized Expression）语法 > > *圆括号表达式* → **(** [*表达式元素集*](../chapter3/04_Expressions.html#expression_element_list) _可选_ **)** > *表达式元素集* → [*表达式元素*](../chapter3/04_Expressions.html#expression_element) | [*表达式元素*](../chapter3/04_Expressions.html#expression_element) **,** [*表达式元素集*](../chapter3/04_Expressions.html#expression_element_list) @@ -694,16 +694,16 @@ > *后置表达式* → [*后置 self 表达式*](../chapter3/04_Expressions.html#postfix_self_expression) > *后置表达式* → [*动态类型表达式*](../chapter3/04_Expressions.html#dynamic_type_expression) > *后置表达式* → [*下标表达式*](../chapter3/04_Expressions.html#subscript_expression) -> *后置表达式* → [*强制取值(Forced Value)表达式*](../chapter3/04_Expressions.html#forced_value_expression) -> *后置表达式* → [*可选链(Optional Chaining)表达式*](../chapter3/04_Expressions.html#optional_chaining_expression) +> *后置表达式* → [*强制取值（Forced Value）表达式*](../chapter3/04_Expressions.html#forced_value_expression) +> *后置表达式* → [*可选链（Optional Chaining）表达式*](../chapter3/04_Expressions.html#optional_chaining_expression) > 函数调用表达式语法 > > *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) -> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包(Trailing Closure)*](../chapter3/04_Expressions.html#trailing_closure) -> *后置闭包(Trailing Closure)* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression) +> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包（Trailing Closure）*](../chapter3/04_Expressions.html#trailing_closure) +> *后置闭包（Trailing Closure）* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression) @@ -738,9 +738,9 @@ -> 强制取值(Forced Value)语法 +> 强制取值（Forced Value）语法 > -> *强制取值(Forced Value)表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!** +> *强制取值（Forced Value）表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!** @@ -753,29 +753,29 @@ > 标识符语法 > -> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ -> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ +> *标识符* → [*标识符头（Head）*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ +> *标识符* → [*标识符头（Head）*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ > *标识符* → [*隐式参数名*](../chapter3/02_Lexical_Structure.html#implicit_parameter_name) > *标识符集* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **,** [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) -> *标识符头(Head)* → Upper- or lowercase letter A through Z -> *标识符头(Head)* → _ -> *标识符头(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA -> *标识符头(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF -> *标识符头(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF -> *标识符头(Head)* → U+1E00–U+1FFF -> *标识符头(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F -> *标识符头(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793 -> *标识符头(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF -> *标识符头(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF -> *标识符头(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44 -> *标识符头(Head)* → U+FE47–U+FFFD -> *标识符头(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD -> *标识符头(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD -> *标识符头(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD -> *标识符头(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD +> *标识符头（Head）* → Upper- or lowercase letter A through Z +> *标识符头（Head）* → _ +> *标识符头（Head）* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA +> *标识符头（Head）* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF +> *标识符头（Head）* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF +> *标识符头（Head）* → U+1E00–U+1FFF +> *标识符头（Head）* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F +> *标识符头（Head）* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793 +> *标识符头（Head）* → U+2C00–U+2DFF or U+2E80–U+2FFF +> *标识符头（Head）* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF +> *标识符头（Head）* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44 +> *标识符头（Head）* → U+FE47–U+FFFD +> *标识符头（Head）* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD +> *标识符头（Head）* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD +> *标识符头（Head）* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD +> *标识符头（Head）* → U+D0000–U+DFFFD or U+E0000–U+EFFFD > *标识符字符* → 数值 0 到 9 > *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F -> *标识符字符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) +> *标识符字符* → [*标识符头（Head）*](../chapter3/02_Lexical_Structure.html#identifier_head) > *标识符字符集* → [*标识符字符*](../chapter3/02_Lexical_Structure.html#identifier_character) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_ > *隐式参数名* → **$** [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits) @@ -889,7 +889,7 @@ > 类型注解语法 > -> *类型注解* → **:** [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) +> *类型注解* → **:** [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type) @@ -905,7 +905,7 @@ > *元组类型* → **(** [*元组类型主体*](../chapter3/03_Types.html#tuple_type_body) _可选_ **)** > *元组类型主体* → [*元组类型的元素集*](../chapter3/03_Types.html#tuple_type_element_list) **...** _可选_ > *元组类型的元素集* → [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) | [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) **,** [*元组类型的元素集*](../chapter3/03_Types.html#tuple_type_element_list) -> *元组类型的元素* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](../chapter3/03_Types.html#type) | **inout** _可选_ [*元素名*](../chapter3/03_Types.html#element_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) +> *元组类型的元素* → [*属性（Attributes）集*](../chapter3/06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](../chapter3/03_Types.html#type) | **inout** _可选_ [*元素名*](../chapter3/03_Types.html#element_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) > *元素名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) @@ -934,7 +934,7 @@ -> 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法 +> 隐式解析可选类型（Implicitly Unwrapped Optional Type）语法 > > *隐式解析可选类型* → [*类型*](../chapter3/03_Types.html#type) **!** @@ -948,7 +948,7 @@ -> 元(Metatype)类型语法 +> 元（Metatype）类型语法 > > *元类型* → [*类型*](../chapter3/03_Types.html#type) **.** **Type** | [*类型*](../chapter3/03_Types.html#type) **.** **Protocol** @@ -956,8 +956,8 @@ > 类型继承从句语法 > -> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) -> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) +> *类型继承从句* → **:** [*类条件（class-requirement）)*](TODO) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) +> *类型继承从句* → **:** [*类条件（class-requirement）)*](TODO) > *类型继承从句* → **:** [*类型继承集*](TODO) > *类型继承集* → [*类型标识符*](../chapter3/03_Types.html#type_identifier) | [*类型标识符*](../chapter3/03_Types.html#type_identifier) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) > *类条件* → **class** diff --git a/source/chapter4/05_Value_and_Reference_Types.md b/source/chapter4/05_Value_and_Reference_Types.md index 9f3bc0a0..25d5c473 100644 --- a/source/chapter4/05_Value_and_Reference_Types.md +++ b/source/chapter4/05_Value_and_Reference_Types.md @@ -12,8 +12,8 @@ ### Swift 里面的类型分为两种： -* **值类型(Value Types)**：每个实例都保留了一分独有的数据拷贝，一般以结构体 `（struct）`、` 枚举（enum）` 或者 `元组（tuple）`的形式出现。 -* **引用类型(Reference Type)**：每个实例共享同一份数据来源，一般以 `类（class）`的形式出现。 +* **值类型（Value Types）**：每个实例都保留了一分独有的数据拷贝，一般以结构体 `（struct）`、` 枚举（enum）` 或者 `元组（tuple）`的形式出现。 +* **引用类型（Reference Type）**：每个实例共享同一份数据来源，一般以 `类（class）`的形式出现。 在这篇博文里面，我们会介绍两种类型各自的优点，以及应该怎么选择使用。 @@ -67,7 +67,7 @@ * 要用==运算符来比较实例身份的时候 * 你希望有创建一个共享的、可变对象的时候 -在 Swift 里面，数组(Array)、字符串(String)、字典(Dictionary)都属于值类型。它们就像 C 语言里面简单的 int 值，是一个个独立的数据个体。你不需要花任何功夫来防范其他代码在暗地里修改它们。更重要的是，你可以在线程之间安全的传递变量，而不需要特地去同步。在 Swift 高安全性的精神下，这个模式会帮助你用 Swift 写出更可控的代码。 +在 Swift 里面，数组（Array）、字符串（String）、字典（Dictionary）都属于值类型。它们就像 C 语言里面简单的 int 值，是一个个独立的数据个体。你不需要花任何功夫来防范其他代码在暗地里修改它们。更重要的是，你可以在线程之间安全的传递变量，而不需要特地去同步。在 Swift 高安全性的精神下，这个模式会帮助你用 Swift 写出更可控的代码。 ----------------- 本章节不是老码的原创，老码认真的阅读了苹果的官方博客，且自己的练习总结，如果小伙伴们费了吃奶的劲还是看不懂，请找度娘谷歌，还是看不懂请到老码[官方微博](http://weibo.com/u/5241713117)咆哮。