replace all _ with -

source/chapter2/02_Basic_Operators.md

@@ -18,7 +18,7 @@ Swift 还提供了 C 语言没有的区间运算符，例如 `a..<b` 或 `a...b`
 
 受运算符影响的值叫*操作数*，在表达式 `1 + 2` 中，加号 `+` 是二元运算符，它的两个操作数是值 `1` 和 `2`。
 
-## 赋值运算符 {#assignment_operator}
+## 赋值运算符 {#assignment-operator}
 
 *赋值运算符*（`a = b`），表示用 `b` 的值来初始化或更新 `a` 的值：
 
@@ -46,7 +46,7 @@ if x = y {
 
 通过将 `if x = y` 标记为无效语句，Swift 能帮你避免把 （`==`）错写成（`=`）这类错误的出现。
 
-## 算术运算符 {#arithmetic_operators}
+## 算术运算符 {#arithmetic-operators}
 
 Swift 中所有数值类型都支持了基本的四则*算术运算符*：
 
@@ -70,7 +70,7 @@ Swift 中所有数值类型都支持了基本的四则*算术运算符*：
 "hello, " + "world"  // 等于 "hello, world"
 ```
 
-### 求余运算符 {#remainder_operator}
+### 求余运算符 {#remainder-operator}
 
 *求余运算符*（`a % b`）是计算 `b` 的多少倍刚刚好可以容入 `a`，返回多出来的那部分（余数）。
 
@@ -114,7 +114,7 @@ Swift 中所有数值类型都支持了基本的四则*算术运算符*：
 
 在对负数 `b` 求余时，`b` 的符号会被忽略。这意味着 `a % b` 和 `a % -b` 的结果是相同的。
 
-### 一元负号运算符 {#unary_minus_operator}
+### 一元负号运算符 {#unary-minus-operator}
 
 数值的正负号可以使用前缀 `-`（即*一元负号符*）来切换：
 
@@ -126,7 +126,7 @@ let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"
 
 一元负号符（`-`）写在操作数之前，中间没有空格。
 
-### 一元正号运算符 {#unary_plus_operator}
+### 一元正号运算符 {#unary-plus-operator}
 
 *一元正号符*（`+`）不做任何改变地返回操作数的值：
 
@@ -137,7 +137,7 @@ let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6
 
 虽然一元正号符什么都不会改变，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数，如此你的代码会具有对称美。
 
-## 组合赋值运算符 {#compound_assignment_operators}
+## 组合赋值运算符 {#compound-assignment-operators}
 
 如同 C 语言，Swift 也提供把其他运算符和赋值运算（`=`）组合的*组合赋值运算符*，组合加运算（`+=`）是其中一个例子：
 
@@ -155,7 +155,7 @@ a += 2
 
 更多 Swift 标准库运算符的信息，请看[运算符声明](https://developer.apple.com/documentation/swift/operator_declarations)。
 ‌
-## 比较运算符（Comparison Operators） {#comparison_operators}
+## 比较运算符（Comparison Operators） {#comparison-operators}
 
 所有标准 C 语言中的*比较运算符*都可以在 Swift 中使用：
 
@@ -216,7 +216,7 @@ if name == "world" {
 > 
 > Swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符。
 
-## 三元运算符（Ternary Conditional Operator） {#ternary_conditional_operator}
+## 三元运算符（Ternary Conditional Operator） {#ternary-conditional-operator}
 
 *三元运算符*的特殊在于它是有三个操作数的运算符，它的形式是 `问题 ? 答案 1 : 答案 2`。它简洁地表达根据 `问题`成立与否作出二选一的操作。如果 `问题` 成立，返回 `答案 1` 的结果；反之返回 `答案 2` 的结果。
 
@@ -257,7 +257,7 @@ if hasHeader {
 
 三元运算为二选一场景提供了一个非常便捷的表达形式。不过需要注意的是，滥用三元运算符会降低代码可读性。所以我们应避免在一个复合语句中使用多个三元运算符。
 
-## 空合运算符（Nil Coalescing Operator） {#nil_coalescing_operator}
+## 空合运算符（Nil Coalescing Operator） {#nil-coalescing-operator}
 
 *空合运算符*（`a ?? b`）将对可选类型 `a` 进行空判断，如果 `a` 包含一个值就进行解包，否则就返回一个默认值 `b`。表达式 `a` 必须是 Optional 类型。默认值 `b` 的类型必须要和 `a` 存储值的类型保持一致。
 
@@ -294,11 +294,11 @@ colorNameToUse = userDefinedColorName ?? defaultColorName
 // userDefinedColorName 非空，因此 colorNameToUse 的值为 "green"
 ```
 
-## 区间运算符（Range Operators） {#range_operators}
+## 区间运算符（Range Operators） {#range-operators}
 
 Swift 提供了几种方便表达一个区间的值的*区间运算符*。
 
-### 闭区间运算符 {#closed_range_operator}
+### 闭区间运算符 {#closed-range-operator}
 
 *闭区间运算符*（`a...b`）定义一个包含从 `a` 到 `b`（包括 `a` 和 `b`）的所有值的区间。`a` 的值不能超过 `b`。
 
@@ -317,7 +317,7 @@ for index in 1...5 {
 
 关于 `for-in` 循环，请看[控制流](./05_Control_Flow.md)。
 
-### 半开区间运算符 {#half-open_range_operator}
+### 半开区间运算符 {#half-open-range-operator}
 
 *半开区间运算符*（`a..<b`）定义一个从 `a` 到 `b` 但不包括 `b` 的区间。
 之所以称为*半开区间*，是因为该区间包含第一个值而不包括最后的值。
@@ -338,7 +338,7 @@ for i in 0..<count {
 
 数组有 4 个元素，但 `0..<count` 只数到3（最后一个元素的下标），因为它是半开区间。关于数组，请查阅[数组](./04_Collection_Types.md#arrays)。
 
-### 单侧区间 {#one-sided_ranges}
+### 单侧区间 {#one-sided-ranges}
 
 闭区间操作符有另一个表达形式，可以表达往一侧无限延伸的区间 —— 例如，一个包含了数组从索引 2 到结尾的所有值的区间。在这些情况下，你可以省略掉区间操作符一侧的值。这种区间叫做单侧区间，因为操作符只有一侧有值。例如：
 
@@ -376,7 +376,7 @@ range.contains(4)   // true
 range.contains(-1)  // true
 ```
 
-## 逻辑运算符（Logical Operators） {#logical_operators}
+## 逻辑运算符（Logical Operators） {#logical-operators}
 
 *逻辑运算符*的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
 
@@ -440,7 +440,7 @@ if hasDoorKey || knowsOverridePassword {
 // 输出“Welcome!”
 ```
 
-### 逻辑运算符组合计算 {#combining_logical_operators}
+### 逻辑运算符组合计算 {#combining-logical-operators}
 
 我们可以组合多个逻辑运算符来表达一个复合逻辑：
 
@@ -463,7 +463,7 @@ if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
 > 
 > Swift 逻辑操作符 `&&` 和 `||` 是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。
 
-### 使用括号来明确优先级 {#explicit_parentheses}
+### 使用括号来明确优先级 {#explicit-parentheses}
 
 为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使它看起来逻辑更明确：