中文逗号、句号使用修正 (#773)

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

* 修正逗号使用

* 修正一处代码空格错误

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

* 修正示例代码错误

source/chapter2/01_The_Basics.md

@@ -197,7 +197,7 @@ Swift 中的注释与 C 语言的注释非常相似。单行注释以双正斜
 你也可以进行多行注释，其起始标记为单个正斜杠后跟随一个星号（`/*`），终止标记为一个星号后跟随单个正斜杠（`*/`）:
 
 ```swift
-/* 这是一个,
+/* 这是一个，
 多行注释 */
 ```
 
@@ -742,7 +742,7 @@ func canThrowAnError() throws {
 }
 ```
 
-一个函数可以通过在声明中添加`throws`关键词来抛出错误消息。当你的函数能抛出错误消息时, 你应该在表达式中前置`try`关键词。
+一个函数可以通过在声明中添加`throws`关键词来抛出错误消息。当你的函数能抛出错误消息时，你应该在表达式中前置`try`关键词。
 
 ```swift
 do {
@@ -753,7 +753,7 @@ do {
 }
 ```
 
-一个`do`语句创建了一个新的包含作用域,使得错误能被传播到一个或多个`catch`从句。
+一个`do`语句创建了一个新的包含作用域，使得错误能被传播到一个或多个`catch`从句。
 
 这里有一个错误处理如何用来应对不同错误条件的例子。
 

source/chapter2/02_Basic_Operators.md

@@ -72,7 +72,7 @@ let (x, y) = (1, 2)
 
 ```swift
 if x = y {
-	// 此句错误, 因为 x = y 并不返回任何值
+	// 此句错误，因为 x = y 并不返回任何值
 }
 ```
 

source/chapter2/03_Strings_and_Characters.md

@@ -133,9 +133,9 @@ It also ends with a line break.
 ```swift
 let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
 // "Imageination is more important than knowledge" - Enistein
-let dollarSign = "\u{24}"             // $, Unicode 标量 U+0024
-let blackHeart = "\u{2665}"           // ♥, Unicode 标量 U+2665
-let sparklingHeart = "\u{1F496}"      // 💖, Unicode 标量 U+1F496
+let dollarSign = "\u{24}"             // $，Unicode 标量 U+0024
+let blackHeart = "\u{2665}"           // ♥，Unicode 标量 U+2665
+let sparklingHeart = "\u{1F496}"      // 💖，Unicode 标量 U+1F496
 ```
 
 由于多行字符串字面量使用了三个双引号，而不是一个，所以你可以在多行字符串字面量里直接使用双引号（`"`）而不必加上转义符（`\`）。要在多行字符串字面量中使用 `"""` 的话，就需要使用至少一个转义符（`\`）：
@@ -394,7 +394,7 @@ var word = "cafe"
 print("the number of characters in \(word) is \(word.count)")
 // 打印输出 "the number of characters in cafe is 4"
 
-word += "\u{301}"    // 拼接一个重音, U+0301
+word += "\u{301}"    // 拼接一个重音，U+0301
 
 print("the number of characters in \(word) is \(word.count)")
 // 打印输出 "the number of characters in café is 4"

source/chapter2/04_Collection_Types.md

@@ -413,7 +413,7 @@ for genre in favoriteGenres {
 
 更多关于`for-in`循环的信息，参见[For 循环](./05_Control_Flow.html#for_loops)。
 
-Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中的值可以使用`sorted()`方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符'<'对元素进行比较的结果来确定.
+Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中的值可以使用`sorted()`方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符'<'对元素进行比较的结果来确定。
 
 ```swift
 for genre in favoriteGenres.sorted() {
@@ -622,7 +622,7 @@ if let airportName = airports["DUB"] {
 
 ```swift
 airports["APL"] = "Apple Internation"
-// "Apple Internation" 不是真的 APL 机场, 删除它
+// "Apple Internation" 不是真的 APL 机场，删除它
 airports["APL"] = nil
 // APL 现在被移除了
 ```

source/chapter2/06_Functions.md

@@ -204,7 +204,7 @@ print("min is \(bounds.min) and max is \(bounds.max)")
 如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的（ `optional` ） 元组返回类型反映整个元组可以是`nil`的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 `(Int, Int)?` 或 `(String, Int, Bool)?`
 
 >注意
-可选元组类型如 `(Int, Int)?` 与元组包含可选类型如 `(Int?, Int?)` 是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
+可选元组类型如 `(Int, Int)?` 与元组包含可选类型如 `(Int?, Int?)` 是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
 
 前面的 `minMax(array:)` 函数返回了一个包含两个 `Int` 值的元组。但是函数不会对传入的数组执行任何安全检查，如果 `array` 参数是一个空数组，如上定义的 `minMax(array:)` 在试图访问 `array[0]` 时会触发一个运行时错误(runtime error)。
 

source/chapter2/08_Enumerations.md

@@ -32,7 +32,7 @@
 
 *枚举*为一组相关的值定义了一个共同的类型，使你可以在你的代码中以类型安全的方式来使用这些值。
 
-如果你熟悉 C 语言，你会知道在 C 语言中，枚举会为一组整型值分配相关联的名称。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
+如果你熟悉 C 语言，你会知道在 C 语言中，枚举会为一组整型值分配相关联的名称。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。
 
 此外，枚举成员可以指定*任意*类型的关联值存储到枚举成员中，就像其他语言中的联合体（unions）和变体（variants）。你可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。
 

source/chapter2/09_Classes_and_Structures.md

@@ -145,7 +145,7 @@ print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
 所有结构体都有一个自动生成的*成员逐一构造器*，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中：
 
 ```swift
-let vga = Resolution(width:640, height: 480)
+let vga = Resolution(width: 640, height: 480)
 ```
 
 与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](./14_Initialization.html)章节会对构造器进行更详细的讨论。

source/chapter2/10_Properties.md

@@ -41,7 +41,7 @@
 
 可以在定义存储属性的时候指定默认值，请参考[默认构造器](./14_Initialization.html#default_initializers)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程中常量属性的修改](./14_Initialization.html#assigning_constant_properties_during_initialization)一节。
 
-下面的例子定义了一个名为 `FixedLengthRange` 的结构体，该结构体用于描述整数的范围，且这个范围值在被创建后不能被修改.
+下面的例子定义了一个名为 `FixedLengthRange` 的结构体，该结构体用于描述整数的范围，且这个范围值在被创建后不能被修改。
 
 ```swift
 struct FixedLengthRange {
@@ -77,7 +77,7 @@ rangeOfFourItems.firstValue = 6
 <a name="lazy_stored_properties"></a>
 ### 延迟存储属性
 
-*延迟存储属*性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 `lazy` 来标示一个延迟存储属性。
+*延迟存储属性*是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用 `lazy` 来标示一个延迟存储属性。
 
 > 注意
 > 必须将延迟存储属性声明成变量（使用 `var` 关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
@@ -285,9 +285,9 @@ stepCounter.totalSteps = 896
 
 `didSet` 观察器在 `totalSteps` 的值改变后被调用，它把新值和旧值进行对比，如果总步数增加了，就输出一个消息表示增加了多少步。`didSet` 没有为旧值提供自定义名称，所以默认值 `oldValue` 表示旧值的参数名。
 
->注意
->
->如果将属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考[输入输出参数](../chapter3/05_Declarations.html#in-out_parameters)
+> 注意
+> 
+> 如果将属性通过 in-out 方式传入函数，`willSet` 和 `didSet` 也会调用。这是因为 in-out 参数采用了拷入拷出模式：即在函数内部使用的是参数的 copy，函数结束后，又对参数重新赋值。关于 in-out 参数详细的介绍，请参考[输入输出参数](../chapter3/05_Declarations.html#in-out_parameters)
 
 <a name="global_and_local_variables"></a>
 ## 全局变量和局部变量

source/chapter2/11_Methods.md

@@ -95,7 +95,7 @@ func increment() {
 ```swift
 struct Point {
     var x = 0.0, y = 0.0
-    func isToTheRightOfX(x: Double) -> Bool {
+    func isToTheRightOfX(_ x: Double) -> Bool {
         return self.x > x
     }
 }
@@ -120,7 +120,7 @@ if somePoint.isToTheRightOfX(1.0) {
 ```swift
 struct Point {
     var x = 0.0, y = 0.0
-    mutating func moveByX(deltaX: Double, y deltaY: Double) {
+    mutating func moveByX(_ deltaX: Double, y deltaY: Double) {
         x += deltaX
         y += deltaY
     }

source/chapter2/14_Initialization.md

@@ -291,7 +291,7 @@ let twoByTwo = Size(width: 2.0, height: 2.0)
 
 对于值类型，你可以使用 `self.init` 在自定义的构造器中引用相同类型中的其它构造器。并且你只能在构造器内部调用 `self.init`。
 
-请注意，如果你为某个值类型定义了一个自定义的构造器，你将无法访问到默认构造器（如果是结构体，还将无法访问逐一成员构造器）。这种限制可以防止你为值类型增加了一个额外的且十分复杂的构造器之后,仍然有人错误的使用自动生成的构造器
+请注意，如果你为某个值类型定义了一个自定义的构造器，你将无法访问到默认构造器（如果是结构体，还将无法访问逐一成员构造器）。这种限制可以防止你为值类型增加了一个额外的且十分复杂的构造器之后，仍然有人错误的使用自动生成的构造器
 
 > 注意
 假如你希望默认构造器、逐一成员构造器以及你自己的自定义构造器都能用来创建实例，可以将自定义的构造器写到扩展（`extension`）中，而不是写在值类型的原始定义中。想查看更多内容，请查看[扩展](./21_Extensions.html)章节。
@@ -736,7 +736,7 @@ if let valueMaintained = Int(exactly: wholeNumber) {
 // 打印 "12345.0 conversion to Int maintains value of 12345"
  
 let valueChanged = Int(exactly: pi)
-// valueChanged 是 Int? 类型, 不是 Int 类型
+// valueChanged 是 Int? 类型，不是 Int 类型
  
 if valueChanged == nil {
     print("\(pi) conversion to Int does not maintain value")

source/chapter2/15_Deinitialization.md

@@ -84,7 +84,7 @@ class Player {
 }
 ```
 
-每个`Player`实例在初始化的过程中，都从`Bank`对象获取指定数量的硬币。如果没有足够的硬币可用，`Player`实例可能会收到比指定数量少的硬币.
+每个`Player`实例在初始化的过程中，都从`Bank`对象获取指定数量的硬币。如果没有足够的硬币可用，`Player`实例可能会收到比指定数量少的硬币。
 
 `Player`类定义了一个`win(coins:)`方法，该方法从`Bank`对象获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构器，这个析构器在`Player`实例释放前被调用。在这里，析构器的作用只是将玩家的所有硬币都返还给`Bank`对象：
 

source/chapter2/17_Optional_Chaining.md

@@ -59,7 +59,7 @@ class Residence {
 
 `Residence`有一个`Int`类型的属性`numberOfRooms`，其默认值为`1`。`Person`具有一个可选的`residence`属性，其类型为`Residence?`。
 
-假如你创建了一个新的`Person`实例,它的`residence`属性由于是是可选型而将初始化为`nil`,在下面的代码中,`john`有一个值为`nil`的`residence`属性：
+假如你创建了一个新的`Person`实例，它的`residence`属性由于是是可选型而将初始化为`nil`,在下面的代码中，`john`有一个值为`nil`的`residence`属性：
 
 ```swift
 let john = Person()

source/chapter2/23_Generics.md

@@ -692,5 +692,5 @@ extension Container {
 - 下标使用的单一的参数，`indices`，必须是 `Indices` 的实例。
 - 泛型 `where` 子句要求 Sequence（Indices）的迭代器，其所有的元素都是 `Int` 类型。这样就能确保在序列（Sequence）中的索引和容器(Container)里面的索引类型是一致的。
 
-综合一下，这些约束意味着，传入到 `indices` 下标，是一个整型的序列.
+综合一下，这些约束意味着，传入到 `indices` 下标，是一个整型的序列。
 (译者：原来的 `Container` 协议，`subscript` 必须是 `Int` 型的，扩展中新的 `subscript`，允许下标是一个的序列，而非单一的值。)