Changed inner links and empty string defect

Author: chenranj

swift-6.docc/LanguageGuide/AccessControl.md

@@ -36,7 +36,7 @@ Swift 为代码中的实体提供了六种不同的**访问级别**。这些访
 
 open 是最高（限制最少）的访问级别，而 private 是最低（限制最多）的访问级别。
 
-open 仅适用于类及类的成员，它与 public 的不同之处在于 open 允许模块外的代码进行继承和重写，如下文 <doc:AccessControl#Subclassing> 中所述。将类显式指定为 open 表明你已考虑到其他模块的代码将该类用作父类的影响，并为此相应地设计了类的代码。
+open 仅适用于类及类的成员，它与 public 的不同之处在于 open 允许模块外的代码进行继承和重写，如下文 <doc:AccessControl#子类> 中所述。将类显式指定为 open 表明你已考虑到其他模块的代码将该类用作父类的影响，并为此相应地设计了类的代码。
 
 ### 访问级别的指导原则
 
@@ -103,7 +103,7 @@ private func somePrivateFunction() {}
   ```
 -->
 
-除非专门指定，否则默认的访问级别是 `internal`，如在 <doc:AccessControl#Default-Access-Levels> 中所述。这意味着在不使用修饰符显式指定访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 的访问级别仍然是 `internal`：
+除非专门指定，否则默认的访问级别是 `internal`，如在 <doc:AccessControl#默认访问级别> 中所述。这意味着在不使用修饰符显式指定访问级别的情况下，`SomeInternalClass` 和 `someInternalConstant` 的访问级别仍然是 `internal`：
 
 ```swift
 class SomeInternalClass {}              // 隐式指定为 internal
@@ -279,7 +279,7 @@ func someFunction() -> (SomeInternalClass, SomePrivateClass) {
   ```
 -->
 
-该函数的返回类型是一个元组类型，由上面 <doc:AccessControl#Custom-Types> 中定义的两个自定义类组成。其中一个类被定义为 `internal`，另一个类被定义为 `private`。因此，这个元组类型的访问级别是 `private`（组成元组的类型中最严格的访问级别）。
+该函数的返回类型是一个元组类型，由上面 <doc:AccessControl#自定义类型> 中定义的两个自定义类组成。其中一个类被定义为 `internal`，另一个类被定义为 `private`。因此，这个元组类型的访问级别是 `private`（组成元组的类型中最严格的访问级别）。
 
 因为函数的返回类型是 `private`，所以你必须在函数声明中使用 `private` 修饰符指定函数的访问级别，这样才能使函数声明有效：
 
@@ -785,13 +785,13 @@ public struct TrackedString {
 
 ## 构造器
 
-自定义构造器的访问级别可以低于或等于它所初始化的类型。唯一的例外是必要构造器（如 <doc:Initialization#Required-Initializers> 中定义的）。必要构造器必须具有与其所属类相同的访问级别。
+自定义构造器的访问级别可以低于或等于它所初始化的类型。唯一的例外是必要构造器（如 <doc:Initialization#必要构造器> 中定义的）。必要构造器必须具有与其所属类相同的访问级别。
 
 与函数和方法的参数一样，构造器的参数类型的访问级别不能比构造器自身的访问级别更严格。
 
 ### 默认构造器
 
-如 <doc:Initialization#Default-Initializers> 中所述，Swift 会为结构体和类自动生成一个不带参数的**默认构造器**，只要它们为所有存储型属性设置了默认初始值，并且未提供自定义的构造器。
+如 <doc:Initialization#默认构造器> 中所述，Swift 会为结构体和类自动生成一个不带参数的**默认构造器**，只要它们为所有存储型属性设置了默认初始值，并且未提供自定义的构造器。
 
 默认构造器的访问级别与它所初始化的类型相同，除非该类型被定义为 `public`。对于 `public` 类型，默认构造器的访问级别将为 `internal`。如果你想让 `public` 类型在另一个模块中可以通过无参数构造器进行初始化，则必须在类型定义中显式提供一个 `public` 访问级别的无参数构造器。
 

swift-6.docc/LanguageGuide/AdvancedOperators.md

@@ -345,7 +345,7 @@ unsignedOverflow = unsignedOverflow &- 1
 
 ![](overflowUnsignedSubtraction)
 
-有符号整数也会发生溢出。所有有符号整数的加法和减法都以按位方式执行，符号位作为被加或被减数字的一部分包含在内，如 <doc:AdvancedOperators#Bitwise-Left-and-Right-Shift-Operators> 中所述。
+有符号整数也会发生溢出。所有有符号整数的加法和减法都以按位方式执行，符号位作为被加或被减数字的一部分包含在内，如 <doc:AdvancedOperators#按位左移和右移运算符> 中所述。
 
 ```swift
 var signedOverflow = Int8.min
@@ -717,11 +717,11 @@ if twoThree == anotherTwoThree {
   ```
 -->
 
-在许多简单的情况下，你可以要求 Swift 为你提供等价运算符的合成实现，如 <doc:Protocols#Adopting-a-Protocol-Using-a-Synthesized-Implementation> 中所述。
+在许多简单的情况下，你可以要求 Swift 为你提供等价运算符的合成实现，如 <doc:Protocols#使用合成实现来遵循协议> 中所述。
 
 ## 自定义运算符
 
-除了 Swift 提供的标准运算符外，你还可以声明和实现自己的 **自定义运算符**。有关可用于定义自定义运算符的字符列表，请参见 <doc:LexicalStructure#Operators>。
+除了 Swift 提供的标准运算符外，你还可以声明和实现自己的 **自定义运算符**。有关可用于定义自定义运算符的字符列表，请参见 <doc:LexicalStructure#运算符>。
 
 新运算符使用 `operator` 关键字在全局级别声明，并用 `prefix`、`infix` 或 `postfix` 修饰符标记：
 
@@ -775,7 +775,7 @@ let afterDoubling = +++toBeDoubled
 
 ### 自定义中缀运算符的优先级
 
-每个自定义中缀运算符都属于一个优先级组。优先级组指定了一个运算符相对于其他中缀运算符的优先级，以及运算符的结合性。有关这些特性如何影响中缀运算符与其他中缀运算符交互的解释，请参见 <doc:AdvancedOperators#Precedence-and-Associativity>。
+每个自定义中缀运算符都属于一个优先级组。优先级组指定了一个运算符相对于其他中缀运算符的优先级，以及运算符的结合性。有关这些特性如何影响中缀运算符与其他中缀运算符交互的解释，请参见 <doc:AdvancedOperators#优先级和结合性>。
 
 没有被明确放入优先级组的自定义中缀运算符会被赋予一个默认优先级组，其优先级紧高于三元条件运算符的优先级。
 
@@ -812,7 +812,7 @@ let plusMinusVector = firstVector +- secondVector
   ```
 -->
 
-这个运算符将两个向量的 `x` 值相加，并从第一个向量的 `y` 值中减去第二个向量的 `y` 值。由于它本质上是一个"加法"运算符，因此它被赋予了与加法中缀运算符（如 `+` 和 `-`)相同的优先级组。有关 Swift 标准库提供的运算符的信息，包括运算符优先级组和结合性设置的完整列表，请参见 [Operator Declarations](https://developer.apple.com/documentation/swift/operator_declarations)。有关优先级组的更多信息以及定义自己的运算符和优先级组的语法，请参见 <doc:Declarations#Operator-Declaration>。
+这个运算符将两个向量的 `x` 值相加，并从第一个向量的 `y` 值中减去第二个向量的 `y` 值。由于它本质上是一个"加法"运算符，因此它被赋予了与加法中缀运算符（如 `+` 和 `-`)相同的优先级组。有关 Swift 标准库提供的运算符的信息，包括运算符优先级组和结合性设置的完整列表，请参见 [Operator Declarations](https://developer.apple.com/documentation/swift/operator_declarations)。有关优先级组的更多信息以及定义自己的运算符和优先级组的语法，请参见 <doc:Declarations#操作符声明>。
 
 > 注意： 在定义前缀或后缀运算符时，你不需要指定优先级。但是，如果你对同一个操作数同时应用前缀和后缀运算符，后缀运算符会先被应用。
 

swift-6.docc/LanguageGuide/AutomaticReferenceCounting.md

@@ -150,7 +150,7 @@ reference3 = nil
 
 然而，可能会出现这样的情况：一个类的实例 *永远* 不会到达它有零个强引用的时刻。如果两个类实例彼此持有强引用，使得每个实例都使对方保持活跃，就可能发生这种情况。这被称为 *强引用循环* 。
 
-你可以通过将类之间的某些关系定义为弱引用或无主引用，而不是强引用，来解决强引用循环。这个过程在<doc:AutomaticReferenceCounting#Resolving-Strong-Reference-Cycles-Between-Class-Instances>中描述。然而，在学习如何解决强引用循环之前，了解这种循环是如何产生的是很有用的。
+你可以通过将类之间的某些关系定义为弱引用或无主引用，而不是强引用，来解决强引用循环。这个过程在<doc:AutomaticReferenceCounting#解决类实例之间的强引用循环>中描述。然而，在学习如何解决强引用循环之前，了解这种循环是如何产生的是很有用的。
 
 这里有一个例子，展示了如何意外创建强引用循环。这个例子定义了两个名为 `Person` 和 `Apartment` 的类，用于模拟一个公寓楼及其居民:
 
@@ -770,9 +770,9 @@ class City {
 
 为了建立两个类之间的相互依赖关系，`City` 的初始化器接受一个 `Country` 实例，并将这个实例存储在其 `country` 属性中。
 
-`City` 的初始化器是在 `Country` 的初始化器内部调用的。然而，`Country` 的初始化器在新的 `Country` 实例完全初始化之前，不能将 `self` 传递给 `City` 初始化器，如<doc:Initialization#Two-Phase-Initialization>中所述。
+`City` 的初始化器是在 `Country` 的初始化器内部调用的。然而，`Country` 的初始化器在新的 `Country` 实例完全初始化之前，不能将 `self` 传递给 `City` 初始化器，如<doc:Initialization#两段式构造过程>中所述。
 
-为了应对这个要求，你将 `Country` 的 `capitalCity` 属性声明为隐式解包可选属性，通过在其类型注解末尾加上感叹号(`City!`)来表示。这意味着 `capitalCity` 属性有一个默认值 `nil`，像任何其他可选类型一样，但可以在不需要解包其值的情况下访问，如<doc:TheBasics#Implicitly-Unwrapped-Optionals>中所述。
+为了应对这个要求，你将 `Country` 的 `capitalCity` 属性声明为隐式解包可选属性，通过在其类型注解末尾加上感叹号(`City!`)来表示。这意味着 `capitalCity` 属性有一个默认值 `nil`，像任何其他可选类型一样，但可以在不需要解包其值的情况下访问，如<doc:TheBasics#隐式解包可选>中所述。
 
 因为 `capitalCity` 有一个默认的 `nil` 值，一旦 `Country` 实例在其初始化器中设置了 `name` 属性，新的 `Country` 实例就被认为是完全初始化的。这意味着 `Country` 初始化器可以在 `name` 属性被设置后，立即开始引用和传递隐式的 `self` 属性。因此，当 `Country` 初始化器设置自己的 `capitalCity` 属性时，`Country` 初始化器可以将 `self` 作为参数之一传递给 `City` 初始化器。
 
@@ -926,7 +926,7 @@ print(paragraph!.asHTML())
 
 ![](closureReferenceCycle01)
 
-实例的 `asHTML` 属性持有对其闭包的强引用。然而，因为闭包在其主体内引用了 `self`(作为引用 `self.name` 和 `self.text` 的方式)，闭包 *捕获* 了 self，这意味着它持有对 `HTMLElement` 实例的强引用。两者之间创建了一个强引用循环。(关于在闭包中捕获值的更多信息，请参见<doc:Closures#Capturing-Values>。)
+实例的 `asHTML` 属性持有对其闭包的强引用。然而，因为闭包在其主体内引用了 `self`(作为引用 `self.name` 和 `self.text` 的方式)，闭包 *捕获* 了 self，这意味着它持有对 `HTMLElement` 实例的强引用。两者之间创建了一个强引用循环。(关于在闭包中捕获值的更多信息，请参见<doc:Closures#值捕获>。)
 
 > 注意：即使闭包多次引用 `self`，它也只捕获对 `HTMLElement` 实例的一个强引用。
 
@@ -1018,7 +1018,7 @@ lazy var someClosure = {
 
 > 注意：如果被捕获的引用永远不会变为 `nil`，它应该始终被捕获为无主引用，而不是弱引用。
 
-无主引用是解决<doc:AutomaticReferenceCounting#Strong-Reference-Cycles-for-Closures> 中 `HTMLElement` 示例强引用循环的适当捕获方法。以下是如何编写 `HTMLElement` 类以避免循环:
+无主引用是解决<doc:AutomaticReferenceCounting#闭包的强引用循环> 中 `HTMLElement` 示例强引用循环的适当捕获方法。以下是如何编写 `HTMLElement` 类以避免循环:
 
 ```swift
 class HTMLElement {
@@ -1118,7 +1118,7 @@ paragraph = nil
   ```
 -->
 
-关于捕获列表的更多信息，请参见<doc:Expressions#Capture-Lists>。
+关于捕获列表的更多信息，请参见<doc:Expressions#捕获列表>。
 
 <!--
 This source file is part of the Swift.org open source project

swift-6.docc/LanguageGuide/BasicOperators.md

@@ -4,7 +4,7 @@
 
 *运算符*是一种特殊的符号或短语，用于检查、更改或组合值。例如，加法运算符（`+`）将两个数字相加，如 `let i = 1 + 2`，逻辑与运算符（`&&`）组合两个布尔值，如 `if enteredDoorCode && passedRetinaScan`。
 
-Swift 支持类似 C 等你已所熟知的语言中的运算符，并改进了几个功能，以消除常见的编码错误。赋值运算符（`=`）不返回值，以防止它被误用时等于运算符（`==`）被意外使用。算术运算符（`+`、`-`、`*`、`/`、`%` 等）检测并禁止值溢出，以避免在处理超出存储它们的类型允许值范围的较大或较小数字时出现意外结果。你可以选择使用 Swift 的溢出运算符来处理值溢出行为，如 <doc:AdvancedOperators#Overflow-Operators> 中所述。
+Swift 支持类似 C 等你已所熟知的语言中的运算符，并改进了几个功能，以消除常见的编码错误。赋值运算符（`=`）不返回值，以防止它被误用时等于运算符（`==`）被意外使用。算术运算符（`+`、`-`、`*`、`/`、`%` 等）检测并禁止值溢出，以避免在处理超出存储它们的类型允许值范围的较大或较小数字时出现意外结果。你可以选择使用 Swift 的溢出运算符来处理值溢出行为，如 <doc:AdvancedOperators#溢出运算符> 中所述。
 
 Swift 还提供了 C 语言中没有的区间运算符，如 `a..<b` 和 `a...b`，作为表达值范围的快捷方式。
 
@@ -141,7 +141,7 @@ Swift 为所有数值类型支持四种标准*算术运算符*：
   ```
 -->
 
-Swift 的算术运算符与 C 和 Objective-C 中的不同，默认情况下不允许值溢出。您可以选择使用 Swift 的溢出运算符（如 `a &+ b`）来启用值溢出行为。请参阅 <doc:AdvancedOperators#Overflow-Operators>。
+Swift 的算术运算符与 C 和 Objective-C 中的不同，默认情况下不允许值溢出。您可以选择使用 Swift 的溢出运算符（如 `a &+ b`）来启用值溢出行为。请参阅 <doc:AdvancedOperators#溢出运算符>。
 
 加法运算符也支持 `String` 拼接：
 
@@ -319,7 +319,7 @@ Swift 支持以下比较运算符：
 
 > 注意: Swift 还提供了两个*标识运算符*（`===` 和 `!==`），
 > 你可以用它们来测试两个对象引用是否指向同一个对象实例。
-> 更多信息请参阅 <doc:ClassesAndStructures#Identity-Operators>。
+> 更多信息请参阅 <doc:ClassesAndStructures#恒等运算符>。
 
 每个比较运算符都返回一个 `Bool` 值来指示语句是否为真：
 
@@ -756,7 +756,7 @@ for i in 0..<count {
 -->
 
 注意数组包含四个元素，但 `0..<count` 只计数到 `3`（数组中最后一个元素的索引），因为它是一个半开区间。
-有关数组的更多信息，请参阅 <doc:CollectionTypes#Arrays>。
+有关数组的更多信息，请参阅 <doc:CollectionTypes#数组>。
 
 ### 单侧区间
 

swift-6.docc/LanguageGuide/ClassesAndStructures.md

@@ -588,7 +588,7 @@ if tenEighty === alsoTenEighty {
 
 当你定义自己的自定义结构体和类时，
 你有责任决定什么才算作两个实例相等。
-定义自己的 `==` 和 `!=` 运算符实现的过程在 <doc:AdvancedOperators#Equivalence-Operators> 中有描述。
+定义自己的 `==` 和 `!=` 运算符实现的过程在 <doc:AdvancedOperators#等价运算符> 中有描述。
 
 <!--
   - test: `classesDontGetEqualityByDefault`