markdown 格式和标点符号的一些修正 (#780)

* 修正全角逗号、句号的使用

* 修正逗号使用

* 修正一处代码空格错误

* 修正斜体范围，引用的空格使用

* 修正示例代码错误

* 修正标点，修正示例代码

* 修正标点

* 修正标点

* 添加 Swift 3.1 的更新

* 修改 Swift 3.0.1 位置

* 添加 Swift 4.0.3 更新

* 添加 Swift 4.1 更新

* 修正示例代码

* 修正 markdown 引用语法，优化翻译语句

* 修正示例代码

* 修正标点使用，优化翻译语句

* 修正示例代码

* 修正示例代码

* 优化翻译语句，修正示例代码语法

* 更新示例代码以符合 Swift 4.1

* 优化 markdown 引用格式的使用

* 优化 markdown 行内代码块使用，代码块与正文使用空格分隔

* 人工校验 markdown 行内代码块使用

* 中英文空格分隔

* 移除行末空格

* 人工校验 markdown 行内代码块使用

* 修正 markdown 无序列表使用

* 统一 markdown 行间代码块的使用

* 人工修正顿号与句号的使用

* 人工修改双引号的使用

* 行内代码块使用“`代码块`”格式

source/chapter2/01_The_Basics.md

@@ -58,7 +58,7 @@
 
 Swift 是一门开发 iOS, macOS, watchOS 和 tvOS 应用的新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。
 
-Swift 包含了 C 和 Objective-C 上所有基础数据类型，`Int` 表示整型值； `Double` 和 `Float` 表示浮点型值； `Bool` 是布尔型值；`String` 是文本型数据。 Swift 还提供了三个基本的集合类型，`Array` ，`Set` 和 `Dictionary` ，详见[集合类型](./04_Collection_Types.html)。
+Swift 包含了 C 和 Objective-C 上所有基础数据类型，`Int` 表示整型值； `Double` 和 `Float` 表示浮点型值； `Bool` 是布尔型值；`String` 是文本型数据。 Swift 还提供了三个基本的集合类型，`Array`、`Set` 和 `Dictionary` ，详见[集合类型](./04_Collection_Types.html)。
 
 就像 C 语言一样，Swift 使用变量来进行存储并通过变量名来关联值。在 Swift 中，广泛的使用着值不可变的变量，它们就是常量，而且比 C 语言的常量更强大。在 Swift 中，如果你要处理的值不需要改变，那使用常量可以让你的代码更加安全并且更清晰地表达你的意图。
 
@@ -233,7 +233,7 @@ let cat = "🐱"; print(cat)
 
 整数就是没有小数部分的数字，比如 `42` 和 `-23` 。整数可以是 `有符号`（正、负、零）或者 `无符号`（正、零）。
 
-Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是 `UInt8`，32位有符号整数类型是 `Int32` 。就像 Swift 的其他类型一样，整数类型采用大写命名法。
+Swift 提供了8、16、32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是 `UInt8`，32位有符号整数类型是 `Int32` 。就像 Swift 的其他类型一样，整数类型采用大写命名法。
 
 <a name="integer_bounds"></a>
 ### 整数范围
@@ -272,7 +272,7 @@ Swift 也提供了一个特殊的无符号类型 `UInt`，长度与当前平台
 <a name="floating-point_numbers"></a>
 ## 浮点数
 
-浮点数是有小数部分的数字，比如 `3.14159` ，`0.1` 和 `-273.15`。
+浮点数是有小数部分的数字，比如 `3.14159`、`0.1` 和 `-273.15`。
 
 浮点类型比整数类型表示的范围更大，可以存储比 `Int` 类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：
 
@@ -820,7 +820,7 @@ assert(age >= 0, "A person's age cannot be less than zero")
 
 ```swift
 assert(age >= 0)
-``` 
+```
 
 如果代码已经检查了条件，你可以使用 `assertionFailure(_:file:line:)` 函数来表明断言失败了，例如：
 

source/chapter2/03_Strings_and_Characters.md

@@ -227,6 +227,7 @@ for character in "Dog!🐶" {
 ```swift
 let exclamationMark: Character = "!"
 ```
+
 字符串可以通过传递一个值类型为 `Character` 的数组作为自变量来初始化：
 
 ```swift

source/chapter2/04_Collection_Types.md

@@ -194,7 +194,7 @@ shoppingList[0] = "Six eggs"
 // 其中的第一项现在是 "Six eggs" 而不是 "Eggs"
 ```
 
-还可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。下面的例子把 `"Chocolate Spread"`，`"Cheese"`，和 `"Butter"` 替换为 `"Bananas"` 和 `"Apples"`：
+还可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。下面的例子把 `"Chocolate Spread"`、`"Cheese"` 和 `"Butter"` 替换为 `"Bananas"` 和 `"Apples"`：
 
 ```swift
 shoppingList[4...6] = ["Bananas", "Apples"]
@@ -223,6 +223,7 @@ let mapleSyrup = shoppingList.remove(at: 0)
 // shoppingList 现在只有6项，而且不包括 Maple Syrup
 // mapleSyrup 常量的值等于被移除数据项的值 "Maple Syrup"
 ```
+
 > 注意
 > 
 > 如果我们试着对索引越界的数据进行检索或者设置新值的操作，会引发一个运行期错误。我们可以使用索引值和数组的 `count` 属性进行比较来在使用某个索引之前先检验是否有效。除了当 `count` 等于 0 时（说明这是个空数组），最大索引值一直是 `count - 1`，因为数组都是零起索引。
@@ -295,7 +296,7 @@ Swift 的所有基本类型(比如 `String`,`Int`,`Double` 和 `Bool`)默认都
 > 
 > 你可以使用你自定义的类型作为集合的值的类型或者是字典的键的类型，但你需要使你的自定义类型符合 Swift 标准库中的 `Hashable` 协议。符合 `Hashable` 协议的类型需要提供一个类型为 `Int` 的可读属性 `hashValue`。由类型的 `hashValue` 属性返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。
 > 
-> 因为 `Hashable` 协议符合 `Equatable` 协议，所以遵循该协议的类型也必须提供一个"是否相等"运算符(`==`)的实现。这个 `Equatable` 协议要求任何符合 `==` 实现的实例间都是一种相等的关系。也就是说，对于 `a,b,c` 三个值来说，`==` 的实现必须满足下面三种情况：
+> 因为 `Hashable` 协议符合 `Equatable` 协议，所以遵循该协议的类型也必须提供一个“是否相等”运算符(`==`)的实现。这个 `Equatable` 协议要求任何符合 `==` 实现的实例间都是一种相等的关系。也就是说，对于 `a,b,c` 三个值来说，`==` 的实现必须满足下面三种情况：
 
 > * `a == a`(自反性)
 > * `a == b` 意味着 `b == a`(对称性)
@@ -608,7 +609,7 @@ airports["LHR"] = "London"
 
 ```swift
 airports["LHR"] = "London Heathrow"
-// "LHR"对应的值 被改为 "London Heathrow
+// “LHR”对应的值被改为“London Heathrow”
 ```
 
 作为另一种下标方法，字典的 `updateValue(_:forKey:)` 方法可以设置或者更新特定键对应的值。就像上面所示的下标示例，`updateValue(_:forKey:)` 方法在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值。和上面的下标方法不同的，`updateValue(_:forKey:)` 这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。

source/chapter2/05_Control_Flow.md

@@ -110,7 +110,7 @@ print("\(base) to the power of \(power) is \(answer)")
 
 在某些情况下，你可能不想使用闭区间，包括两个端点。想象一下，你在一个手表上绘制分钟的刻度线。总共 `60` 个刻度，从 `0` 分开始。使用半开区间运算符（`..<`）来表示一个左闭右开的区间。有关区间的更多信息，请参阅[区间运算符](./02_Basic_Operators.html#range_operators)。
 
-```
+```swift
 let minutes = 60
 for tickMark in 0..<minutes {
     // 每一分钟都渲染一个刻度线（60次）
@@ -119,7 +119,7 @@ for tickMark in 0..<minutes {
 
 一些用户可能在其 UI 中可能需要较少的刻度。他们可以每5分钟作为一个刻度。使用 `stride(from:to:by:)` 函数跳过不需要的标记。
 
-```
+```swift
 let minuteInterval = 5
 for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {
     // 每5分钟渲染一个刻度线 (0, 5, 10, 15 ... 45, 50, 55)
@@ -128,7 +128,7 @@ for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {
 
 可以在闭区间使用 `stride(from:through:by:)` 起到同样作用：
 
-```
+```swift
 let hours = 12
 let hourInterval = 3
 for tickMark in stride(from: 3, through: hours, by: hourInterval) {
@@ -151,7 +151,7 @@ for tickMark in stride(from: 3, through: hours, by: hourInterval) {
 
 下面是 `while` 循环的一般格式：
 
-```
+```swift
 while condition {
 	statements
 }
@@ -234,7 +234,7 @@ repeat {
 
 还是*蛇和梯子*的游戏，使用 `repeat-while` 循环来替代 `while` 循环。`finalSquare`、`board`、`square` 和 `diceRoll` 的值初始化同 `while` 循环时一样：
 
-``` swift
+```swift
 let finalSquare = 25
 var board = [Int](repeating: 0, count: finalSquare + 1)
 board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
@@ -398,6 +398,7 @@ default:
 不像 C 语言里的 `switch` 语句，在 Swift 中，`switch` 语句不会一起匹配 `"a"` 和 `"A"`。相反的，上面的代码会引起编译期错误：`case "a": 不包含任何可执行语句 `——这就避免了意外地从一个 case 分支贯穿到另外一个，使得代码更安全、也更直观。
 
 为了让单个 case 同时匹配 `a` 和 `A`，可以将这个两个值组合成一个复合匹配，并且用逗号分开：
+
 ```swift
 let anotherCharacter: Character = "a"
 switch anotherCharacter {
@@ -408,6 +409,7 @@ default:
 }
 // 输出 "The letter A
 ```
+
 为了可读性，符合匹配可以写成多行形式，详情请参考[复合匹配](#compound_cases)
 
 > 注意
@@ -563,7 +565,6 @@ default:
 }
 
 // 输出 "On an axis, 9 from the origin"
-
 ```
 
 上面的 case 有两个模式：`(let distance, 0)` 匹配了在 x 轴上的值，`(0, let distance)` 匹配了在 y 轴上的值。两个模式都绑定了 `distance`，并且 `distance` 在两种模式下，都是整型——这意味着分支体内的代码，只要 case 匹配，都可以获取到 `distance` 值

source/chapter2/06_Functions.md

@@ -34,7 +34,7 @@
 - [函数类型](#Function_Types)
 - [嵌套函数](#Nested_Functions)
 
-*函数*是一段完成特定任务的独立代码片段。你可以通过给函数命名来标识某个函数的功能，这个名字可以被用来在需要的时候"调用"这个函数来完成它的任务。
+*函数*是一段完成特定任务的独立代码片段。你可以通过给函数命名来标识某个函数的功能，这个名字可以被用来在需要的时候“调用”这个函数来完成它的任务。
 
 Swift 统一的函数语法非常的灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外部参数名的 Objective-C 风格函数。参数可以提供默认值，以简化函数调用。参数也可以既当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值将被修改。
 

source/chapter2/08_Enumerations.md

@@ -223,7 +223,7 @@ enum ASCIIControlCharacter: Character {
 
 枚举类型 `ASCIIControlCharacter` 的原始值类型被定义为 `Character`，并设置了一些比较常见的 ASCII 控制字符。`Character` 的描述详见[字符串和字符](./03_Strings_and_Characters.html)部分。
 
-原始值可以是字符串，字符，或者任意整型值或浮点型值。每个原始值在枚举声明中必须是唯一的。
+原始值可以是字符串、字符，或者任意整型值或浮点型值。每个原始值在枚举声明中必须是唯一的。
 
 > 注意
 > 

source/chapter2/14_Initialization.md

@@ -743,7 +743,7 @@ for item in breakfastList {
 
 例如，实现针对数字类型转换的可失败构造器。确保数字类型之间的转换能保持精确的值，使用这个 `init(exactly:)` 构造器。如果类型转换不能保持值不变，则这个构造器构造失败。
 
-```
+```swift
 let wholeNumber: Double = 12345.0
 let pi = 3.14159
  
@@ -808,7 +808,7 @@ if anonymousCreature == nil {
 
 你可以通过一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。如果提供的参数无法匹配任何枚举成员，则构造失败。
 
-下例中，定义了一个名为 `TemperatureUnit` 的枚举类型。其中包含了三个可能的枚举成员(`Kelvin`，`Celsius`，和 `Fahrenheit`)，以及一个根据 `Character` 值找出所对应的枚举成员的可失败构造器：
+下例中，定义了一个名为 `TemperatureUnit` 的枚举类型。其中包含了三个可能的枚举成员(`Kelvin`、`Celsius` 和 `Fahrenheit`)，以及一个根据 `Character` 值找出所对应的枚举成员的可失败构造器：
 
 ```swift
 enum TemperatureUnit {
@@ -990,7 +990,7 @@ class UntitledDocument: Document {
     }
 }
 ```
- 
+
 在这个例子中，如果在调用父类的可失败构造器 `init?(name:)` 时传入的是空字符串，那么强制解包操作会引发运行时错误。不过，因为这里是通过非空的字符串常量来调用它，所以并不会发生运行时错误。
 
 <a name="the_init!_failable_initializer"></a>

source/chapter2/16_Optional_Chaining.md

@@ -388,7 +388,7 @@ if let johnsStreet = john.residence?.address?.street {
 上面的例子展示了如何在一个可选值上通过可选链式调用来获取它的属性值。我们还可以在一个可选值上通过可选链式调用来调用方法，并且可以根据需要继续在方法的可选返回值上进行可选链式调用。
 
 在下面的例子中，通过可选链式调用来调用 `Address` 的 `buildingIdentifier()` 方法。这个方法返回 `String?` 类型的值。如上所述，通过可选链式调用来调用该方法，最终的返回值依旧会是 `String?` 类型：
- 
+
 ```swift
 if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
     print("John's building identifier is \(buildingIdentifier).")

source/chapter2/18_Type_Casting.md

@@ -230,6 +230,7 @@ for thing in things {
 > `Any` 类型可以表示所有类型的值，包括可选类型。Swift 会在你用 `Any` 类型来表示一个可选值的时候，给你一个警告。如果你确实想使用 `Any` 类型来承载可选值，你可以使用 `as` 操作符显式转换为 `Any`，如下所示：
 > 
 > 
+
 ```swift
 let optionalNumber: Int? = 3
 things.append(optionalNumber)        // 警告

source/chapter2/20_Extensions.md

@@ -137,6 +137,7 @@ struct Rect {
     var size = Size()
 }
 ```
+
 因为结构体 `Rect` 未提供定制的构造器，因此它会获得一个逐一成员构造器。又因为它为所有存储型属性提供了默认值，它又会获得一个默认构造器。详情请参阅[默认构造器](./14_Initialization.html#default_initializers)。这些构造器可以用于构造新的 `Rect` 实例：
 
 ```swift

source/chapter2/21_Protocols.md

@@ -705,7 +705,7 @@ beginConcert(in: seattle)
 // Prints "Hello, Seattle!"
 ```
 
-`beginConcert(in:)` 方法接受一个类型为 `Location & Named` 的参数，这意味着"任何 Location 的子类，并且遵循 Named 协议"。例如，City 就满足这样的条件。
+`beginConcert(in:)` 方法接受一个类型为 `Location & Named` 的参数，这意味着“任何 Location 的子类，并且遵循 Named 协议”。例如，City 就满足这样的条件。
 
 将 birthdayPerson 传入 `beginConcert(in:)` 函数是不合法的，因为 Person 不是一个 Location 的子类。就像，如果你新建一个类继承与 Location，但是没有遵循 Named 协议，你用这个类的实例去调用 `beginConcert(in:)` 函数也是不合法的。
 
@@ -967,6 +967,7 @@ extension Collection where Element: Equatable {
 let equalNumbers = [100, 100, 100, 100, 100]
 let differentNumbers = [100, 100, 200, 100, 200]
 ```
+
 由于数组遵循 `Collection` 而且整数遵循 `Equatable`，`equalNumbers` 和 `differentNumbers` 都可以使用 `allEqual()` 方法。
 
 

source/chapter2/22_Generics.md

@@ -103,7 +103,6 @@ func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
     a = b
     b = temporaryA
 }
-
 ```
 
 `swapTwoValues(_:_:)` 的函数主体和 `swapTwoInts(_:_:)` 函数是一样的，它们只在第一行有点不同，如下所示：

source/chapter2/25_Access_Control.md

@@ -174,7 +174,7 @@ private class SomePrivateClass {                // 显式 private 类
     func somePrivateMethod() {}                  // 隐式 private 类成员
 }
 
-```
+```swift
 <a name="tuple_types"></a>
 ### 元组类型
 
@@ -434,7 +434,7 @@ extension SomeStruct: SomeProtocol {
 <a name="type_aliases"></a>
 ## 类型别名
 
-你定义的任何类型别名都会被当作不同的类型，以便于进行访问控制。类型别名的访问级别不可高于其表示的类型的访问级别。例如，`private` 级别的类型别名可以作为 `private`，`file-private`，`internal`，`public` 或者 `open` 类型的别名，但是 `public` 级别的类型别名只能作为 `public` 类型的别名，不能作为 `internal`，`file-private`，或 `private` 类型的别名。
+你定义的任何类型别名都会被当作不同的类型，以便于进行访问控制。类型别名的访问级别不可高于其表示的类型的访问级别。例如，`private` 级别的类型别名可以作为 `private`、`file-private`、`internal`、`public` 或者 `open` 类型的别名，但是 `public` 级别的类型别名只能作为 `public` 类型的别名，不能作为 `internal`、`file-private` 或 `private` 类型的别名。
 
 > 注意
 > 

source/chapter2/26_Advanced_Operators.md

@@ -380,6 +380,7 @@ let negative = -positive
 let alsoPositive = -negative
 // alsoPositive 是一个值为 (3.0, 4.0) 的 Vector2D 实例
 ```
+
 <a name="compound_assignment_operators"></a>
 ### 复合赋值运算符
 
@@ -433,6 +434,7 @@ if twoThree == anotherTwoThree {
 }
 // 打印 “These two vectors are equivalent.”
 ```
+
 Swift 为以下自定义类型提等价运算符供合成实现：
 
 - 只拥有遵循 `Equatable` 协议存储属性的结构体；