feat: proofreading

Author: Shinolr

swift-6-beta.docc/ReferenceManual/Declarations.md

@@ -28,7 +28,7 @@
 
 ## 顶级代码
 
-Swift 源文件中的顶级代码由零个或多个语句、声明和表达式组成。默认情况下，在源文件顶层声明的变量、常量和其他具名声明可以被同一模块中每个源文件的代码访问。你可以使用访问级别修饰符来覆盖此默认行为，具体说明见 <doc:Declarations#Access-Control-Levels>。
+Swift 源文件中的顶级代码由零个或多个语句、声明和表达式组成。默认情况下，在源文件顶层声明的变量、常量和其他具名声明可以被同一模块中每个源文件的代码访问。你可以使用访问级别修饰符来重写此默认行为，具体说明见 <doc:Declarations#Access-Control-Levels>。
 
 有两种类型的顶级代码：顶级声明和可执行的顶级代码。顶级声明仅由声明组成，允许出现在所有 Swift 源文件中。可执行的顶级代码包含语句和表达式，而不仅仅是声明，仅允许作为程序的顶级入口点。
 
@@ -245,7 +245,7 @@ var <#variable name#>: <#type#> = <#expression#> {
 
 你可以为任何存储属性添加属性观察者。你还可以通过在子类中重写属性，为任何继承自父类的属性（无论是存储的还是计算的）添加属性观察者，参见 <doc:Inheritance#Overriding-Property-Observers>。
 
-构造器*表达式*在类或结构体声明的上下文中是可选的，但在其他地方是必须的。如果能通过构造器*表达式*推断出类型，则*类型*标注是可选的。通常，表达式的类型推断发生在首次读取属性时。如果在读取属性之前，初值已经被覆盖，则推断发生在首次写入属性时。
+构造器*表达式*在类或结构体声明的上下文中是可选的，但在其他地方是必须的。如果能通过构造器*表达式*推断出类型，则*类型*标注是可选的。通常，表达式的类型推断发生在首次读取属性时。如果在读取属性之前，初值已经被重写，则推断发生在首次写入属性时。
 
 <!--
   - test: `overwriting-property-without-writing`
@@ -376,7 +376,7 @@ newAndOld.x = 200
 
 ### 类型变量属性
 
-要声明一个类型变量属性，请使用 `static` 声明修饰符标记声明。类可以使用 `class` 声明修饰符标记类型计算属性，以允许子类覆盖超类的实现。类型属性的讨论请参见 <doc:Properties#Type-Properties>。
+要声明一个类型变量属性，请使用 `static` 声明修饰符标记声明。类可以使用 `class` 声明修饰符标记类型计算属性，以允许子类重写超类的实现。类型属性的讨论请参见 <doc:Properties#Type-Properties>。
 
 > 变量声明的语法:
 >
@@ -604,7 +604,7 @@ f(x: 1, y: 2) // x 和 y 都带有标签
   Tracking bug is <rdar://problem/35301593>
 -->
 
-你可以使用以下形式（选其一），覆盖参数标签的默认行为：
+你可以使用以下形式（选其一），重写参数标签的默认行为：
 
 ```swift
 <#argument label#> <#parameter name#>: <#parameter type#>
@@ -867,7 +867,7 @@ func someFunction(a: borrowing A, b: consuming B) { ... }
 someFunction(a: someA, b: someB)
 ```
 
-明确使用 `borrowing` 或 `consuming` 表示你希望更严格地控制运行时所有权管理的开销。因为复制可能导致意外的运行时所有权操作，所以标记为这两种修饰符的参数在没有使用显式的 `copy` 关键字的情况下不能被复制：
+显式使用 `borrowing` 或 `consuming` 表示你希望更严格地控制运行时所有权管理的开销。因为复制可能导致意外的运行时所有权操作，所以标记为这两种修饰符的参数在没有使用显式的 `copy` 关键字的情况下不能被复制：
 
 ```swift
 func borrowingFunction1(a: borrowing A) {
@@ -1114,7 +1114,7 @@ func <#function name#>(<#parameters#>) throws(<#error type#>) -> <#return type#>
 
 调用抛出函数或方法的必须被包裹在一个 `try` 或 `try!` 表达式中（即，在 `try` 或 `try!` 操作符的作用域内）。
 
-函数的类型包括它是否会抛出错误以及它抛出的错误类型。这个子类型关系意味着，例如，你可以在需要抛出错误的上下文中使用不抛出错误的函数。有关抛出错误函数类型的更多信息，请参阅 <doc:Types#Function-Type>。有关处理具有明确类型的错误的示例，请参阅 <doc:ErrorHandling#Specifying-the-Error-Type>。
+函数的类型包括它是否会抛出错误以及它抛出的错误类型。这个子类型关系意味着，例如，你可以在需要抛出错误的上下文中使用不抛出错误的函数。有关抛出错误函数类型的更多信息，请参阅 <doc:Types#Function-Type>。有关处理具有显式类型的错误的示例，请参阅 <doc:ErrorHandling#Specifying-the-Error-Type>。
 
 你不能仅根据函数是否会抛出错误来重载一个函数。不过，你可以根据函数的*参数*是否会抛出错误来重载函数。
 
@@ -1200,7 +1200,7 @@ func someFunction(callback: () throws -> Void) rethrows {
   ```
 -->
 
-抛出方法不能覆盖再抛出方法，抛出方法也不能满足再抛出方法的协议要求。也就是说，再抛出方法可以覆盖抛出方法，再抛出方法可以满足抛出方法的协议要求。
+抛出方法不能重写再抛出方法，抛出方法也不能满足再抛出方法的协议要求。也就是说，再抛出方法可以重写抛出方法，再抛出方法可以满足抛出方法的协议要求。
 
 在泛型代码中，抛出特定错误类型是再抛出的替代方案。例如：
 
@@ -2021,21 +2021,21 @@ protocol SubProtocolB: SomeProtocol where SomeType: Equatable { }
 
 ## 构造器声明
 
-*构造器声明*在你的程序中引入了一个类、结构体或枚举的构造器。构造器声明使用 `init` 关键字声明，并有两种基本形式。
+*构造器声明*在你的程序中引入了一个类、结构体或枚举的构造器。构造器声明使用 `init` 关键字声明，有两种基本形式。
 
-结构体、枚举和类类型可以有任意数量的构造器，但类构造器的规则和相关行为是不同的。与结构体和枚举不同，类有两种类型的构造器：指定构造器和便利构造器，参见 <doc:Initialization>。
+结构体、枚举和类类型可以有任意数量的构造器，但是类的构造器具有不同的规则和行为。与结构体和枚举不同，类有两种类型的构造器：指定构造器和便利构造器，参见 <doc:Initialization>。
 
-以下形式声明了结构体、枚举和类的指定构造器的构造器：
+以下形式声明了结构体和枚举的构造器，以及类的指定构造器：：
 
 ```swift
 init(<#parameters#>) {
     <#statements#>
 }
 ```
 
-类的指定构造器直接初始化类的所有属性。它不能调用同一类的其他构造器，如果该类有一个超类，则必须调用超类的一个指定构造器。如果该类从其超类继承了任何属性，则在当前类中设置或修改这些属性之前，必须调用超类的一个指定构造器。
+类的指定构造器直接初始化类的所有属性。它不能调用当前类的其他构造器，如果该类有一个超类，则必须调用超类的一个指定构造器。如果该类从其超类继承了任何属性，则在当前类中设置或修改这些属性之前，必须调用超类的一个指定构造器。
 
-只能在类声明的上下文中声明，因此不能通过扩展声明添加到类中。
+指定构造器只能在类声明中声明，因此不能通过扩展声明添加到类中。
 
 结构体和枚举中的构造器可以调用其他已声明的构造器，以委托部分或全部初始化过程。
 
@@ -2047,7 +2047,7 @@ convenience init(<#parameters#>) {
 }
 ```
 
-便利构造器可以将初始化过程委托给另一个便利构造器或类的某个指定构造器。也就是说，初始化过程必须以调用一个指定构造器结束，该构造器最终初始化类的属性。便利构造器不能调用超类的构造器。
+便利构造器可以将构造过程委托给另一个便利构造器或一个指定构造器。但是，类的构造过程必须以一个将类中所有属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器
 
 你可以使用 `required` 声明修饰符标记指定和便利构造器，以要求每个子类实现该构造器。子类对该构造器的实现也必须标记为 `required` 声明修饰符。
 
@@ -2129,7 +2129,7 @@ if let actualInstance = SomeStruct(input: "Hello") {
 
 初始化失败会通过构造器委托传播。具体来说，如果一个可失败的构造器委托给一个失败并返回 `nil` 的构造器，那么委托的构造器也会失败并隐式返回 `nil`。如果一个不可失败的构造器委托给一个失败并返回 `nil` 的 `init!` 可失败构造器，那么会引发运行时错误（就像你使用`!`运算符来解包一个值为 `nil`的可选值一样）。
 
-可失败的指定构造器可以在子类中被任何类型的指定构造器重写。一个不可失败的指定构造器只能在子类中被不可失败的指定构造器重写。
+可失败的指定构造器可以在子类中被任何类型的指定构造器重写。不可失败的指定构造器只能在子类中被不可失败的指定构造器重写。
 
 有关更多信息以及可失败构造器的示例，请参见 <doc:Initialization#Failable-Initializers>。
 
@@ -2294,12 +2294,12 @@ extension String: TitledLoggable {
   ```
 -->
 
-`Pair` 结构在其泛型类型分别遵循 `Loggable` 或 `TitledLoggable` 时，也会相应地遵循 `Loggable` 和 `TitledLoggable`。在下面的示例中，`oneAndTwo` 是 `Pair<String>` 的一个实例，由于 `String` 遵循 `TitledLoggable`，因此 `oneAndTwo` 也遵循 `TitledLoggable`。当直接调用 `oneAndTwo` 的 `log()` 方法时，将使用包含标题字符串的特定版本。
+`Pair` 结构体在其泛型类型分别遵循 `Loggable` 或 `TitledLoggable` 时，也会相应地遵循 `Loggable` 和 `TitledLoggable`。在下面的示例中，`oneAndTwo` 是 `Pair<String>` 的一个实例，由于 `String` 遵循 `TitledLoggable`，因此 `oneAndTwo` 也遵循 `TitledLoggable`。当直接调用 `oneAndTwo` 的 `log()` 方法时，将使用包含标题字符串的特定版本。
 
 ```swift
 let oneAndTwo = Pair(first: "one", second: "two")
 oneAndTwo.log()
-// 打印
+// 打印 "Pair of 'String': (one, two)"
 ```
 
 <!--
@@ -2428,9 +2428,9 @@ extension Array: Serializable where Element: SerializableInArray {
 
 当一个具体类型有条件地遵循一个协议时，该类型隐式地遵循任何具有相同要求的父协议。
 
-如果你需要一个类型有条件地遵循两个继承自单一父协议的协议，请明确声明对父协议的遵循。这可以避免以不同的要求隐式地两次遵循父协议。
+如果你需要一个类型有条件地遵循两个继承自单一父协议的协议，请显式声明对父协议的遵循。这可以避免以不同的要求隐式地两次遵循父协议。
 
-以下示例明确声明了 `Array` 对 `Loggable` 的条件遵循，以避免在声明其对 `TitledLoggable` 和新的 `MarkedLoggable` 协议的条件遵循时发生冲突。
+以下示例显式声明了 `Array` 对 `Loggable` 的条件遵循，以避免在声明其对 `TitledLoggable` 和新的 `MarkedLoggable` 协议的条件遵循时发生冲突。
 
 ```swift
 protocol MarkedLoggable: Loggable {
@@ -2478,7 +2478,7 @@ extension Array: MarkedLoggable where Element: MarkedLoggable { }
   ```
 -->
 
-在没有扩展明确声明对 `Loggable` 的条件遵循时，其他 `Array` 扩展会隐式创建这些声明，从而导致错误：
+在没有扩展显式声明对 `Loggable` 的条件遵循时，其他 `Array` 扩展会隐式创建这些声明，从而导致错误：
 
 ```swift
 extension Array: Loggable where Element: TitledLoggable { }
@@ -2596,9 +2596,9 @@ subscript (<#parameters#>) -> <#return type#> {
 
 与计算属性一样，下标声明支持读取和写入所访问元素的值。getter 用于读取值，setter 用于写入值。setter 子句是可选的，当只需要 getter 时，可以省略两个子句，直接返回请求的值。也就是说，如果提供了 setter 子句，则必须同时提供 getter 子句。
 
-*setter 名称*和括号是可选的。如果你提供了 setter 名称，它将用作 setter 的参数名称。如果你不提供 setter 名称，setter 的默认参数名称是 `value`。setter 的参数类型与*返回类型* 同。
+*setter 名称*和括号是可选的。如果你提供了 setter 名称，它将用作 setter 的参数名称。如果你不提供 setter 名称，setter 的默认参数名称是 `value`。setter 的参数类型与*返回类型*相同。
 
-你可以在声明它的类型中重载下标声明，只要*参数*或*返回类型*与你正在重载的不同。你还可以覆盖从超类继承的下标声明。当你这样做时，必须使用 `override` 声明修饰符标记被覆盖的下标声明。
+你可以在声明其类型的地方重载下标声明，只要*参数*或*返回类型*与要重载的下标不同。你也可以重写从超类继承的下标声明。在这样做时，必须使用 `override` 声明修饰符标记被重写的下标声明。
 
 下标参数遵循与函数参数相同的规则，但有两个例外。默认情况下，使用下标的参数没有参数标签，这与函数、方法和构造器不同。然而，你可以使用与函数、方法和构造器相同的语法提供显式参数标签。此外，下标不能有 in-out 参数。下标参数可以具有默认值，参见 <doc:Declarations#Special-Kinds-of-Parameters>。
 
@@ -2681,7 +2681,7 @@ infix operator <#operator name#>: <#precedence group#>
 prefix operator <#operator name#>
 ```
 
-*前缀运算符* 是一种一元运算符，它直接写在操作数之前，例如表达式 `!a` 中的前缀逻辑非运算符（`!`）。
+*前缀运算符*是一种一元运算符，它直接写在操作数之前，例如表达式 `!a` 中的前缀逻辑非运算符（`!`）。
 
 前缀运算符声明不指定优先级。前缀运算符是非结合的。
 
@@ -2695,7 +2695,7 @@ postfix operator <#operator name#>
 
 与前缀运算符一样，后缀运算符声明不指定优先级。后缀运算符是非结合的。
 
-声明新运算符后，可以通过声明一个与运算符同名的静态方法来实现它。这个静态方法是运算符参数之一的类型的成员——例如，一个将 `Double` 与 `Int` 相乘的运算符可以在 `Double` 或 `Int` 结构上实现为静态方法。如果你要实现一个前缀或后缀运算符，还必须在方法声明中添加相应的 `prefix` 或 `postfix` 声明修饰符。要查看如何创建和实现新运算符的示例，请参阅 <doc:AdvancedOperators#Custom-Operators>。
+在声明一个新运算符后，你通过声明一个与运算符同名的静态方法来实现它。这个静态方法是运算符作为参数所接受的类型之一的成员——例如，一个将 `Double` 乘以 `Int` 的运算符是作为 `Double` 或 `Int` 结构上的静态方法实现的。如果你在实现前缀或后缀运算符，你还必须在方法声明中标记相应的 `prefix` 或 `postfix` 声明修饰符。要查看如何创建和实现新运算符的示例，请参见 <doc:AdvancedOperators#Custom-Operators>。
 
 > 操作符声明的语法:
 >
@@ -2727,7 +2727,7 @@ precedencegroup <#precedence group name#> {
 > 注意:
 > 使用*低级组名称*和*高级组名称*相关联的优先级组必须适合于单一的关系层次结构，但它们*不*必形成线性层次结构。这意味着可以有相对优先级未定义的优先级组。来自这些优先级组的运算符不能在没有分组括号的情况下相互使用。
 
-Swift 定义了许多优先级组，以配合 Swift 标准库提供的运算符。例如，加法 (`+`) 和减法 (`-`) 运算符属于 `AdditionPrecedence` 组，而乘法 (`*`) 和除法 (`/`) 运算符属于 `MultiplicationPrecedence` 组。有关 Swift 标准库提供的优先级组的完整列表，请参见 [运算符声明](https://developer.apple.com/documentation/swift/operator_declarations)。
+Swift 定义了许多优先级组，以配合 Swift 标准库提供的运算符。例如，加法 (`+`) 和减法 (`-`) 运算符属于 `AdditionPrecedence` 组，而乘法 (`*`) 和除法 (`/`) 运算符属于 `MultiplicationPrecedence` 组。有关 Swift 标准库提供的优先级组的完整列表，请参见[运算符声明](https://developer.apple.com/documentation/swift/operator_declarations)。
 
 运算符的*结合性*指定了在没有分组括号的情况下，具有相同优先级的运算符序列是如何分组的。通过写入上下文敏感的关键字之一来指定运算符的结合性：`left`、`right` 或 `none` ——如果你省略结合性，默认值为 `none`。左结合的运算符从左到右分组。例如，减法运算符（`-`）是左结合的，因此表达式`4 - 5 - 6` 被分组为 `(4 - 5) - 6`，并计算为 `-7`。右结合的运算符从右到左分组，而指定为 `none` 的运算符则完全不结合。相同优先级的非结合运算符不能相邻出现。例如，`<` 运算符的结合性为 `none`，这意味着 `1 < 2 < 3` 不是一个有效的表达式。
 
@@ -2756,7 +2756,7 @@ Swift 定义了许多优先级组，以配合 Swift 标准库提供的运算符
 
 ## 声明修饰符
 
-*声明修饰符*是一些关键字或上下文相关的关键字，用于修改声明的行为或含义。你可以通过在声明的属性（如果有的话）和引入声明的关键字之间编写适当的关键字或上下文相关的关键字来指定声明修饰符。
+*声明修饰符* 是用于修改声明行为或意义的关键字或上下文相关关键字。你通过在声明的属性（如果有的话）和引入声明的关键字之间写入相应的关键字或上下文相关关键字来指定声明修饰符。
 
 - `class`：将此修饰符应用于类的成员，以指示该成员是类本身的成员，而不是类实例的成员。具有此修饰符且没有 `final` 修饰符的超类成员可以被子类重写。
 
@@ -2786,7 +2786,7 @@ Swift 定义了许多优先级组，以配合 Swift 标准库提供的运算符
 
 - `unowned`：将此修饰符应用于存储变量、常量或存储属性，以指示该变量或属性对作为其值存储的对象具有一个无主引用。如果在对象被释放后尝试访问该变量或属性，将会引发运行时错误。与弱引用类似，属性或值的类型必须是类类型；与弱引用不同，类型是非可选的。有关 `unowned` 修饰符的示例和更多信息，请参见 <doc:AutomaticReferenceCounting#Unowned-References>。
 
-- `unowned(safe)`：`unowned` 的明确拼写。
+- `unowned(safe)`：`unowned` 的显式拼写。
 
 - `unowned(unsafe)`：将此修饰符应用于存储变量、常量或存储属性，以指示该变量或属性对作为其值存储的对象具有一个无主引用。如果在对象被释放后尝试访问该变量或属性，你将访问对象曾经所在位置的内存，这是一种不安全的内存操作。与弱引用类似，属性或值的类型必须是类类型；与弱引用不同，该类型是非可选的。有关 `unowned` 修饰符的示例和更多信息，请参见 <doc:AutomaticReferenceCounting#Unowned-References>。