fix all anchor format

source/chapter2/05_Control_Flow.md

@@ -6,8 +6,7 @@ Swift 还提供了 `for-in` 循环，用来更简单地遍历数组（Array）
 
 Swift 的 `switch` 语句比许多类 C 语言要更加强大。case 还可以匹配很多不同的模式，包括范围匹配，元组（tuple）和特定类型匹配。`switch` 语句的 case 中匹配的值可以声明为临时常量或变量，在 case 作用域内使用，也可以配合 `where` 来描述更复杂的匹配条件。
 
-<a name="for_in_loops"></a>
-## For-In 循环
+## For-In 循环 {#for_in_loops}
 
 你可以使用 `for-in` 循环来遍历一个集合中的所有元素，例如数组中的元素、范围内的数字或者字符串中的字符。
 
@@ -98,16 +97,14 @@ for tickMark in stride(from: 3, through: hours, by: hourInterval) {
 }
 ```
 
-<a name="while_loops"></a>
-## While 循环
+## While 循环 {#while_loops}
 
 `while` 循环会一直运行一段语句直到条件变成 `false`。这类循环适合使用在第一次迭代前，迭代次数未知的情况下。Swift 提供两种 `while` 循环形式：
 
 * `while` 循环，每次在循环开始时计算条件是否符合；
 * `repeat-while` 循环，每次在循环结束时计算条件是否符合。
 
-<a name="while"></a>
-### While
+### While {#while}
 
 `while` 循环从计算一个条件开始。如果条件为 `true`，会重复运行一段语句，直到条件变为 `false`。
 
@@ -177,8 +174,7 @@ print("Game over!")
 
 `while` 循环比较适合本例中的这种情况，因为在 `while` 循环开始时，我们并不知道游戏要跑多久，只有在达成指定条件时循环才会结束。
 
-<a name="repeat_while"></a>
-### Repeat-While
+### Repeat-While {#repeat_while}
 
 `while` 循环的另外一种形式是 `repeat-while`，它和 `while` 的区别是在判断循环条件之前，先执行一次循环的代码块。然后重复循环直到条件为 `false`。
 
@@ -226,15 +222,13 @@ print("Game over!")
 
 循环条件（`while square < finalSquare`）和 `while` 方式相同，但是只会在循环结束后进行计算。在这个游戏中，`repeat-while` 表现得比 `while` 循环更好。`repeat-while` 方式会在条件判断 `square` 没有超出后直接运行 `square += board[square]`，这种方式可以比起前面 `while` 循环的版本，可以省去数组越界的检查。
 
-<a name="conditional_statement"></a>
-## 条件语句
+## 条件语句 {#conditional_statement}
 
 根据特定的条件执行特定的代码通常是十分有用的。当错误发生时，你可能想运行额外的代码；或者，当值太大或太小时，向用户显示一条消息。要实现这些功能，你就需要使用*条件语句*。
 
 Swift 提供两种类型的条件语句：`if` 语句和 `switch` 语句。通常，当条件较为简单且可能的情况很少时，使用 `if` 语句。而 `switch` 语句更适用于条件较复杂、有更多排列组合的时候。并且 `switch` 在需要用到模式匹配（pattern-matching）的情况下会更有用。
 
-<a name="if"></a>
-### If
+### If {#if}
 
 `if` 语句最简单的形式就是只包含一个条件，只有该条件为 `true` 时，才执行相关代码：
 
@@ -291,8 +285,7 @@ if temperatureInFahrenheit <= 32 {
 
 在这个例子中，由于既不冷也不热，所以不会触发 `if` 或 `else if` 分支，也就不会打印任何消息。
 
-<a name="switch"></a>
-### Switch
+### Switch {#switch}
 
 `switch` 语句会尝试把某个值与若干个模式（pattern）进行匹配。根据第一个匹配成功的模式，`switch` 语句会执行对应的代码。当有可能的情况较多时，通常用 `switch` 语句替换 `if` 语句。
 
@@ -333,8 +326,7 @@ default:
 
 在这个例子中，第一个 case 分支用于匹配第一个英文字母 `a`，第二个 case 分支用于匹配最后一个字母 `z`。因为 `switch` 语句必须有一个 case 分支用于覆盖所有可能的字符，而不仅仅是所有的英文字母，所以 switch 语句使用 `default` 分支来匹配除了 `a` 和 `z` 外的所有值，这个分支保证了 swith 语句的完备性。
 
-<a name="no_implicit_fallthrough"></a>
-#### 不存在隐式的贯穿
+#### 不存在隐式的贯穿 {#no_implicit_fallthrough}
 
 与 C 和 Objective-C 中的 `switch` 语句不同，在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止 `switch` 语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用 `break` 语句。这使得 `switch` 语句更安全、更易用，也避免了漏写 `break` 语句导致多个语言被执行的错误。
 
@@ -377,8 +369,7 @@ default:
 > 
 > 如果想要显式贯穿 case 分支，请使用 `fallthrough` 语句，详情请参考[贯穿](#fallthrough)。
 
-<a name="interval_matching"></a>
-#### 区间匹配
+#### 区间匹配 {#interval_matching}
 
 case 分支的模式也可以是一个值的区间。下面的例子展示了如何使用区间匹配来输出任意数字对应的自然语言格式：
 
@@ -406,8 +397,7 @@ print("There are \(naturalCount) \(countedThings).")
 
 在上例中，`approximateCount` 在一个 `switch` 声明中被评估。每一个 `case` 都与之进行比较。因为 `approximateCount` 落在了 12 到 100 的区间，所以 `naturalCount` 等于 `"dozens of"` 值，并且此后的执行跳出了 `switch` 语句。
 
-<a name="tuples"></a>
-#### 元组
+#### 元组 {#tuples}
 
 我们可以使用元组在同一个 `switch` 语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（`_`）来匹配所有可能的值。
 
@@ -436,8 +426,7 @@ default:
 
 不像 C 语言，Swift 允许多个 case 匹配同一个值。实际上，在这个例子中，点 (0, 0)可以匹配所有_四个 case_。但是，如果存在多个匹配，那么只会执行第一个被匹配到的 case 分支。考虑点 (0, 0)会首先匹配 `case (0, 0)`，因此剩下的能够匹配的分支都会被忽视掉。
 
-<a name="value_bindings"></a>
-#### 值绑定（Value Bindings）
+#### 值绑定（Value Bindings） {#value_bindings}
 
 case 分支允许将匹配的值声明为临时常量或变量，并且在 case 分支体内使用 —— 这种行为被称为*值绑定*（value binding），因为匹配的值在 case 分支体内，与临时的常量或变量绑定。
 
@@ -466,8 +455,7 @@ case let (x, y):
 
 请注意，这个 `switch` 语句不包含默认分支。这是因为最后一个 case ——`case let(x, y)` 声明了一个可以匹配余下所有值的元组。这使得 `switch` 语句已经完备了，因此不需要再书写默认分支。
 
-<a name="where"></a>
-#### Where
+#### Where {#where}
 
 case 分支的模式可以使用 `where` 语句来判断额外的条件。
 
@@ -494,8 +482,7 @@ case let (x, y):
 
 就像是值绑定中的例子，由于最后一个 case 分支匹配了余下所有可能的值，`switch` 语句就已经完备了，因此不需要再书写默认分支。
 
-<a name="compound_cases"></a>
-#### 复合型 Cases
+#### 复合型 Cases {#compound_cases}
 
 当多个条件可以使用同一种方法来处理时，可以将这几种可能放在同一个 `case` 后面，并且用逗号隔开。当 case 后面的任意一种模式匹配的时候，这条分支就会被匹配。并且，如果匹配列表过长，还可以分行书写：
 
@@ -530,8 +517,7 @@ default:
 
 上面的 case 有两个模式：`(let distance, 0)` 匹配了在 x 轴上的值，`(0, let distance)` 匹配了在 y 轴上的值。两个模式都绑定了 `distance`，并且 `distance` 在两种模式下，都是整型——这意味着分支体内的代码，只要 case 匹配，都可以获取到 `distance` 值。
 
-<a name="control_transfer_statements"></a>
-## 控制转移语句
+## 控制转移语句 {#control_transfer_statements}
 
 控制转移语句改变你代码的执行顺序，通过它可以实现代码的跳转。Swift 有五种控制转移语句：
 
@@ -543,8 +529,7 @@ default:
 
 我们将会在下面讨论 `continue`、`break` 和 `fallthrough` 语句。`return` 语句将会在[函数](./06_Functions.md)章节讨论，`throw` 语句会在[错误抛出](./18_Error_Handling.md#throwing_errors)章节讨论。
 
-<a name="continue"></a>
-### Continue
+### Continue {#continue}
 
 `continue` 语句告诉一个循环体立刻停止本次循环，重新开始下次循环。就好像在说“本次循环我已经执行完了”，但是并不会离开整个循环体。
 
@@ -567,18 +552,15 @@ print(puzzleOutput)
 
 在上面的代码中，只要匹配到元音字母或者空格字符，就调用 `continue` 语句，使本次循环结束，重新开始下次循环。这种行为使 `switch` 匹配到元音字母和空格字符时不做处理，而不是让每一个匹配到的字符都被打印。
 
-<a name="break"></a>
-### Break
+### Break {#break}
 
 `break` 语句会立刻结束整个控制流的执行。`break` 可以在 `switch` 或循环语句中使用，用来提前结束 `switch` 或循环语句。
 
-<a name="break_in_a_loop_statement"></a>
-#### 循环语句中的 break
+#### 循环语句中的 break {#break_in_a_loop_statement}
 
 当在一个循环体中使用 `break` 时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号（`}`）后的第一行代码。不会再有本次循环的代码被执行，也不会再有下次的循环产生。
 
-<a name="break_in_a_switch_statement"></a>
-#### Switch 语句中的 break
+#### Switch 语句中的 break {#break_in_a_switch_statement}
 
 当在一个 `switch` 代码块中使用 `break` 时，会立即中断该 `switch` 代码块的执行，并且跳转到表示 `switch` 代码块结束的大括号（`}`）后的第一行代码。
 
@@ -619,8 +601,7 @@ if let integerValue = possibleIntegerValue {
 
 在上面的例子中，想要把 `Character` 所有的的可能性都枚举出来是不现实的，所以使用 `default` 分支来包含所有上面没有匹配到字符的情况。由于这个 `default` 分支不需要执行任何动作，所以它只写了一条 `break` 语句。一旦落入到 `default` 分支中后，`break` 语句就完成了该分支的所有代码操作，代码继续向下，开始执行 `if let` 语句。
 
-<a name="fallthrough"></a>
-### 贯穿（Fallthrough）
+### 贯穿（Fallthrough） {#fallthrough}
 
 在 Swift 里，`switch` 语句不会从上一个 case 分支跳转到下一个 case 分支中。相反，只要第一个匹配到的 case 分支完成了它需要执行的语句，整个 `switch` 代码块完成了它的执行。相比之下，C 语言要求你显式地插入 `break` 语句到每个 case 分支的末尾来阻止自动落入到下一个 case 分支中。Swift 的这种避免默认落入到下一个分支中的特性意味着它的 `switch` 功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个 case 分支从而引发的错误。
 
@@ -650,8 +631,7 @@ print(description)
 > 
 > `fallthrough` 关键字不会检查它下一个将会落入执行的 case 中的匹配条件。`fallthrough` 简单地使代码继续连接到下一个 case 中的代码，这和 C 语言标准中的 `switch` 语句特性是一样的。
 
-<a name="labeled_statements"></a>
-### 带标签的语句
+### 带标签的语句 {#labeled_statements}
 
 在 Swift 中，你可以在循环体和条件语句中嵌套循环体和条件语句来创造复杂的控制流结构。并且，循环体和条件语句都可以使用 `break` 语句来提前结束整个代码块。因此，显式地指明 `break` 语句想要终止的是哪个循环体或者条件语句，会很有用。类似地，如果你有许多嵌套的循环体，显式指明 `continue` 语句想要影响哪一个循环体也会非常有用。
 
@@ -722,8 +702,7 @@ print("Game over!")
 > 
 > 同时请注意，当调用 `continue gameLoop` 去跳转到下一次循环迭代时，这里使用 `gameLoop` 标签并不是严格必须的。因为在这个游戏中，只有一个循环体，所以 `continue` 语句会影响到哪个循环体是没有歧义的。然而，`continue` 语句使用 `gameLoop` 标签也是没有危害的。这样做符合标签的使用规则，同时参照旁边的 `break gameLoop`，能够使游戏的逻辑更加清晰和易于理解。
 
-<a name="early_exit"></a>
-## 提前退出
+## 提前退出 {#early_exit}
 
 像 `if` 语句一样，`guard` 的执行取决于一个表达式的布尔值。我们可以使用 `guard` 语句来要求条件必须为真时，以执行 `guard` 语句后的代码。不同于 `if` 语句，一个 `guard` 语句总是有一个 `else` 从句，如果条件不为真则执行 `else` 从句中的代码。
 
@@ -757,8 +736,7 @@ greet(person: ["name": "Jane", "location": "Cupertino"])
 
 相比于可以实现同样功能的 `if` 语句，按需使用 `guard` 语句会提升我们代码的可读性。它可以使你的代码连贯的被执行而不需要将它包在 `else` 块中，它可以使你在紧邻条件判断的地方，处理违规的情况。
 
-<a name="checking_api_availability"></a>
-## 检测 API 可用性
+## 检测 API 可用性 {#checking_api_availability}
 
 Swift 内置支持检查 API 可用性，这可以确保我们不会在当前部署机器上，不小心地使用了不可用的 API。