翻译细节与 markdown 统一格式修改 (#779)

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

* 修正逗号使用

* 修正一处代码空格错误

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

* 修正示例代码错误

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

* 修正标点

* 修正标点

* 添加 Swift 3.1 的更新

* 修改 Swift 3.0.1 位置

* 添加 Swift 4.0.3 更新

* 添加 Swift 4.1 更新

* 修正示例代码

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

* 修正示例代码

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

* 修正示例代码

* 修正示例代码

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

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

* 优化 markdown 引用格式的使用

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

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

* 中英文空格分隔

* 移除行末空格

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

* 修正 markdown 无序列表使用

source/chapter1/01_about_swift.md

@@ -8,10 +8,14 @@
 > 2.0
 > 翻译+校对：[xtymichael](https://github.com/xtymichael)
 
-> 3.0 翻译+校对：[shanks](http://codebuild.me)，2016-10-06
+> 3.0
-> 3.0.1 review : 2016-11-09
+> 翻译+校对：[shanks](http://codebuild.me)，2016-10-06
 
-> 3.1 校对: [SketchK](https://github.com/SketchK) 2017-04-08
+> 3.0.1
+> review : 2016-11-09
+
+> 3.1
+> 校对: [SketchK](https://github.com/SketchK) 2017-04-08
 
 > 4.0
 > 翻译：[rain2540](https://github.com/rain2540) 2017-09-21

source/chapter1/03_a_swift_tour.md

@@ -10,13 +10,15 @@
 > 翻译+校对：[xtymichael](https://github.com/xtymichael)
 
 > 2.2
-> 翻译：[175](https://github.com/Brian175)，2016-04-09 校对：[SketchK](https://github.com/SketchK)，2016-05-11
+> 翻译：[175](https://github.com/Brian175)，2016-04-09
-> 
+> 校对：[SketchK](https://github.com/SketchK)，2016-05-11
+
 > 3.0
 > 翻译+校对：[shanks](http://codebuild.me)，2016-10-06
 
-> 3.0.1 review: 2016-11-09
+> 3.0.1
-> 
+> review: 2016-11-09
+
 > 3.1 校对: [SketchK](https://github.com/SketchK) 2017-04-08
 
 > 4.0
@@ -157,7 +159,7 @@ print(teamScore)
 
 在 `if` 语句中，条件必须是一个布尔表达式——这意味着像 `if score { ... }` 这样的代码将报错，而不会隐形地与 0 做对比。
 
-你可以一起使用 `if` 和 `let` 一起来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者是 `nil` 以表示值缺失。在类型后面加一个问号（`?ß`）来标记这个变量的值是可选的。
+你可以一起使用 `if` 和 `let` 一起来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者是 `nil` 以表示值缺失。在类型后面加一个问号（`?`）来标记这个变量的值是可选的。
 
 ```swift
 var optionalString: String? = "Hello"

source/chapter2/01_The_Basics.md

@@ -11,13 +11,13 @@
 > 2.1
 > 翻译：[Prayer](https://github.com/futantan)
 > 校对：[shanks](http://codebuild.me)，[overtrue](https://github.com/overtrue)
-> 
+
 > 2.2
 > 校对：[SketchK](https://github.com/SketchK) 
-> 
+
 > 3.0
 > 校对：[CMB](https://github.com/chenmingbiao)，版本时间2016-09-13
-> 
+
 > 3.0.1, 2016-11-11，shanks
 
 > 4.0
@@ -95,7 +95,8 @@ var currentLoginAttempt = 0
 var x = 0.0, y = 0.0, z = 0.0
 ```
 
-> 注意：
+> 注意
+> 
 > 如果你的代码中有不需要改变的值，请使用 `let` 关键字将它声明为常量。只将需要改变的值声明为变量。
 
 <a name="type_annotations"></a>

source/chapter2/04_Collection_Types.md

@@ -13,7 +13,7 @@
 
 > 2.2
 > 校对：[SketchK](https://github.com/SketchK) 2016-05-11
->
+
 > 3.0
 > 校对：[shanks](http://codebuild.me) ，2016-10-09
 > 3.0.1，shanks，2016-11-12

source/chapter2/06_Functions.md

@@ -18,6 +18,7 @@
 > 3.0
 > 翻译: [crayygy](https://github.com/crayygy) 2016-09-12
 > 校对: [shanks](http://codebuild.me) 2016-09-27
+
 > 3.0.1，shanks，2016-11-12
 
 > 4.0
@@ -164,8 +165,9 @@ printWithoutCounting(string: "hello, world")
 
 第一个函数 `printAndCount(string:)`，输出一个字符串并返回 `Int` 类型的字符数。第二个函数 `printWithoutCounting(string:)` 调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。
 
->注意:
+> 注意
-返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，将导致编译时错误。
+> 
+> 返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，将导致编译时错误。
 
 <a name="functions_with_multiple_return_values"></a>
 ### 多重返回值函数

source/chapter2/07_Closures.md

@@ -11,12 +11,13 @@
 > 2.1
 > 翻译：[100mango](https://github.com/100mango), [magicdict](https://github.com/magicdict)
 > 校对：[shanks](http://codebuild.me)
->
+
 > 2.2
 > 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-12
->
+
 > 3.0
 > 翻译：[Lanford](https://github.com/LanfordCai) 2016-09-19
+
 > 3.0.1，shanks，2016-11-12
 
 > 4.0
@@ -39,6 +40,7 @@
 闭包可以捕获和存储其所在上下文中任意常量和变量的引用。被称为*包裹*常量和变量。 Swift 会为你管理在捕获过程中涉及到的所有内存操作。
 
 > 注意
+> 
 > 如果你不熟悉捕获（capturing）这个概念也不用担心，你可以在[值捕获](#capturing_values)章节对其进行详细了解。
 
 在[函数](./06_Functions.md)章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：

source/chapter2/11_Methods.md

@@ -10,9 +10,10 @@
 
 > 2.1
 > 翻译：[DianQK](https://github.com/DianQK)，[Realank](https://github.com/Realank) 校对：[shanks](http://codebuild.me)，2016-01-18
-> 
+
 > 2.2
 > 校对：[SketchK](https://github.com/SketchK) 2016-05-13
+
 > 3.0.1，shanks，2016-11-13
 
 > 4.0

source/chapter2/13_Inheritance.md

@@ -7,9 +7,10 @@
 
 > 2.0，2.1
 > 翻译+校对：[shanks](http://codebuild.me)
-> 
+
 > 2.2
 > 校对：[SketchK](https://github.com/SketchK) 2016-05-13
+
 > 3.0.1，shanks，2016-11-13
 
 > 4.0

source/chapter2/15_Deinitialization.md

@@ -10,9 +10,10 @@
 
 > 2.1
 > 校对：[shanks](http://codebuild.me)，2015-10-31
-> 
+
 > 2.2
 > 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-14
+
 > 3.0.1，shanks，2016-11-13
 
 > 4.0

source/chapter2/16_Optional_Chaining.md

@@ -11,9 +11,10 @@
 
 > 2.1
 > 校对：[shanks](http://codebuild.me)，2015-10-31
->
+
 > 2.2
 > 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-15
+
 > 3.0.1，shanks，2016-11-13
 
 > 4.0
@@ -41,7 +42,7 @@
 <a name="optional_chaining_as_an_alternative_to_forced_unwrapping"></a>
 ## 使用可选链式调用代替强制展开
 
-通过在想调用的属性、方法、或下标的可选值后面放一个问号（`?`），可以定义一个可选链。这一点很像在可选值后面放一个叹号（`!`）来强制展开它的值。它们的主要区别在于当可选值为空时可选链式调用只会调用失败，然而强制展开将会触发运行时错误。
+通过在想调用的属性、方法，或下标的可选值后面放一个问号（`?`），可以定义一个可选链。这一点很像在可选值后面放一个叹号（`!`）来强制展开它的值。它们的主要区别在于当可选值为空时可选链式调用只会调用失败，然而强制展开将会触发运行时错误。
 
 为了反映可选链式调用可以在空值（`nil`）上调用的事实，不论这个调用的属性、方法及下标返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来判断你的可选链式调用是否调用成功，如果调用有返回值则说明调用成功，返回 `nil` 则说明调用失败。
 
@@ -236,7 +237,7 @@ john.residence?.address = createAddress()
 没有任何打印消息，可以看出 `createAddress()` 函数并未被执行。
 
 <a name="calling_methods_through_optional_chaining"></a>
-## 通过可选链式调用调用方法
+## 通过可选链式调用来调用方法
 
 可以通过可选链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
 

source/chapter2/17_Error_Handling.md

@@ -4,12 +4,13 @@
 > 2.1
 > 翻译+校对：[lyojo](https://github.com/lyojo) [ray16897188](https://github.com/ray16897188) 2015-10-23
 > 校对：[shanks](http://codebuild.me) 2015-10-24
->
+
 > 2.2
 > 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-15
->
+
 > 3.0
 > 翻译+校对：[shanks](http://codebuild.me) 2016-09-24
+
 > 3.0.1，shanks，2016-11-13
 
 > 4.0

source/chapter2/18_Type_Casting.md

@@ -208,7 +208,7 @@ for thing in things {
         print("an (x, y) point at \(x), \(y)")
     case let movie as Movie:
         print("a movie called '\(movie.name)', dir. \(movie.director)")
-    case let stringConverter as String -> String:
+    case let stringConverter as (String) -> String:
         print(stringConverter("Michael"))
     default:
         print("something else")

source/chapter2/21_Protocols.md

@@ -371,7 +371,7 @@ class SnakesAndLadders: DiceGame {
 	var square = 0
 	var board: [Int]
 	init() {
-		board = [Int](count: finalSquare + 1, repeatedValue: 0)
+		board = [Int](repeating: 0, count: finalSquare + 1)
 		board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
 		board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
 	}
@@ -804,6 +804,7 @@ for object in objects {
 `CounterDataSource` 协议定义了一个可选方法 `increment(forCount:)` 和一个可选属性 `fiexdIncrement`，它们使用了不同的方法来从数据源中获取适当的增量值。
 
 > 注意
+> 
 > 严格来讲，`CounterDataSource` 协议中的方法和属性都是可选的，因此遵循协议的类可以不实现这些要求，尽管技术上允许这样做，不过最好不要这样写。
 
 `Counter` 类含有 `CounterDataSource?` 类型的可选属性 `dataSource`，如下所示：

source/chapter2/22_Generics.md

@@ -373,14 +373,14 @@ let stringIndex = findIndex(of: "Andrea", in: ["Mike", "Malcolm", "Andrea"])
 <a name="associated_types_in_action"></a>
 ### 关联类型实践
 
-下面例子定义了一个 `Container` 协议，该协议定义了一个关联类型 `ItemType`：
+下面例子定义了一个 `Container` 协议，该协议定义了一个关联类型 `Item`：
 
 ```swift
 protocol Container {
-    associatedtype ItemType
+    associatedtype Item
-    mutating func append(_ item: ItemType)
+    mutating func append(_ item: Item)
     var count: Int { get }
-    subscript(i: Int) -> ItemType { get }
+    subscript(i: Int) -> Item { get }
 }
 ```
 
@@ -396,7 +396,7 @@ protocol Container {
 
 为了定义这三个条件，`Container` 协议需要在不知道容器中元素的具体类型的情况下引用这种类型。`Container` 协议需要指定任何通过 `append(_:)` 方法添加到容器中的元素和容器中的元素是相同类型，并且通过容器下标返回的元素的类型也是这种类型。
 
-为了达到这个目的，`Container` 协议声明了一个关联类型 `ItemType`，写作 `associatedtype ItemType`。这个协议无法定义 `ItemType` 是什么类型的别名，这个信息将留给遵从协议的类型来提供。尽管如此，`ItemType` 别名提供了一种方式来引用 `Container` 中元素的类型，并将之用于 `append(_:)` 方法和下标，从而保证任何 `Container` 的行为都能够正如预期地被执行。
+为了达到这个目的，`Container` 协议声明了一个关联类型 `Item`，写作 `associatedtype Item`。这个协议无法定义 `Item` 是什么类型的别名，这个信息将留给遵从协议的类型来提供。尽管如此，`Item` 别名提供了一种方式来引用 `Container` 中元素的类型，并将之用于 `append(_:)` 方法和下标，从而保证任何 `Container` 的行为都能够正如预期地被执行。
 
 下面是先前的非泛型的 `IntStack` 类型，这一版本采纳并符合了 `Container` 协议：
 
@@ -411,7 +411,7 @@ struct IntStack: Container {
         return items.removeLast()
     }
     // Container 协议的实现部分
-    typealias ItemType = Int
+    typealias Item = Int
     mutating func append(_ item: Int) {
         self.push(item)
     }
@@ -426,9 +426,9 @@ struct IntStack: Container {
 
 `IntStack` 结构体实现了 `Container` 协议的三个要求，其原有功能也不会和这些要求相冲突。
 
-此外，`IntStack` 在实现 `Container` 的要求时，指定 `ItemType` 为 `Int` 类型，即 `typealias ItemType = Int`，从而将 `Container` 协议中抽象的 `ItemType` 类型转换为具体的 `Int` 类型。
+此外，`IntStack` 在实现 `Container` 的要求时，指定 `Item` 为 `Int` 类型，即 `typealias Item = Int`，从而将 `Container` 协议中抽象的 `Item` 类型转换为具体的 `Int` 类型。
 
-由于 Swift 的类型推断，你实际上不用在 `IntStack` 的定义中声明 `ItemType` 为 `Int`。因为 `IntStack` 符合 `Container` 协议的所有要求，Swift 只需通过 `append(_:)` 方法的 `item` 参数类型和下标返回值的类型，就可以推断出 `ItemType` 的具体类型。事实上，如果你在上面的代码中删除了 `typealias ItemType = Int` 这一行，一切仍旧可以正常工作，因为 Swift 清楚地知道 `ItemType` 应该是哪种类型。
+由于 Swift 的类型推断，你实际上不用在 `IntStack` 的定义中声明 `Item` 为 `Int`。因为 `IntStack` 符合 `Container` 协议的所有要求，Swift 只需通过 `append(_:)` 方法的 `item` 参数类型和下标返回值的类型，就可以推断出 `Item` 的具体类型。事实上，如果你在上面的代码中删除了 `typealias Item = Int` 这一行，一切仍旧可以正常工作，因为 Swift 清楚地知道 `Item` 应该是哪种类型。
 
 你也可以让泛型 `Stack` 结构体遵从 `Container` 协议：
 
@@ -455,7 +455,7 @@ struct Stack<Element>: Container {
 }
 ```
 
-这一次，占位类型参数 `Element` 被用作 `append(_:)` 方法的 `item` 参数和下标的返回类型。Swift 可以据此推断出 `Element` 的类型即是 `ItemType` 的类型。
+这一次，占位类型参数 `Element` 被用作 `append(_:)` 方法的 `item` 参数和下标的返回类型。Swift 可以据此推断出 `Element` 的类型即是 `Item` 的类型。
 
 <a name="extending_an_existing_type_to_specify_an_associated_type"></a>
 ### 通过扩展一个存在的类型来指定关联类型
@@ -468,7 +468,7 @@ Swift 的 `Array` 类型已经提供 `append(_:)` 方法，一个 `count` 属性
 extension Array: Container {}
 ```
 
-如同上面的泛型 `Stack` 结构体一样，`Array` 的 `append(_:)` 方法和下标确保了 Swift 可以推断出 `ItemType` 的类型。定义了这个扩展后，你可以将任意 `Array` 当作 `Container` 来使用。
+如同上面的泛型 `Stack` 结构体一样，`Array` 的 `append(_:)` 方法和下标确保了 Swift 可以推断出 `Item` 的类型。定义了这个扩展后，你可以将任意 `Array` 当作 `Container` 来使用。
 
 <a name="using_type_annotations_to_constrain_an_associated_type"></a>
 ### 给关联类型添加约束
@@ -551,7 +551,7 @@ extension IntStack: SuffixableContainer {
 ```swift
 func allItemsMatch<C1: Container, C2: Container>
     (_ someContainer: C1, _ anotherContainer: C2) -> Bool
-    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable {
+    where C1.Item == C2.Item, C1.Item: Equatable {
         
         // 检查两个容器含有相同数量的元素
         if someContainer.count != anotherContainer.count {
@@ -576,8 +576,8 @@ func allItemsMatch<C1: Container, C2: Container>
 
 - `C1` 必须符合 `Container` 协议（写作 `C1: Container`）。
 - `C2` 必须符合 `Container` 协议（写作 `C2: Container`）。
-- `C1` 的 `ItemType` 必须和 `C2` 的 `ItemType`类型相同（写作 `C1.ItemType == C2.ItemType`）。
+- `C1` 的 `Item` 必须和 `C2` 的 `Item` 类型相同（写作 `C1.Item == C2.Item`）。
-- `C1` 的 `ItemType` 必须符合 `Equatable` 协议（写作 `C1.ItemType: Equatable`）。
+- `C1` 的 `Item` 必须符合 `Equatable` 协议（写作 `C1.Item: Equatable`）。
 
 第三个和第四个要求被定义为一个 `where` 子句，写在关键字 `where` 后面，它们也是泛型函数类型参数列表的一部分。
 

source/chapter2/23_Automatic_Reference_Counting.md

@@ -272,7 +272,8 @@ unit4A = nil
 上面的两段代码展示了变量 `john` 和 `unit4A` 在被赋值为 `nil` 后，`Person` 实例和 `Apartment` 实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。
 
  > 注意
- 在使用垃圾收集的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才被销毁。但是在 ARC 中，一旦值的最后一个强引用被移除，就会被立即销毁，这导致弱引用并不适合上面的用途。
+ > 
+ > 在使用垃圾收集的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才被销毁。但是在 ARC 中，一旦值的最后一个强引用被移除，就会被立即销毁，这导致弱引用并不适合上面的用途。
  
 <a name="unowned_references"></a>
 ### 无主引用
@@ -281,7 +282,7 @@ unit4A = nil
 
 无主引用通常都被期望拥有值。不过 ARC 无法在实例被销毁后将无主引用设为 `nil`，因为非可选类型的变量不允许被赋值为 `nil`。
 
-> 重要
+> 重点
 > 
 > 使用无主引用，你*必须*确保引用始终指向一个未销毁的实例。
 > 
@@ -354,9 +355,7 @@ john = nil
 最后的代码展示了在 `john` 变量被设为 `nil` 后 `Customer` 实例和 `CreditCard` 实例的构造函数都打印出了“销毁”的信息。
 
 > 注意
-> 
 > 上面的例子展示了如何使用安全的无主引用。对于需要禁用运行时的安全检查的情况（例如，出于性能方面的原因），Swift 还提供了不安全的无主引用。与所有不安全的操作一样，你需要负责检查代码以确保其安全性。
->
 > 你可以通过 `unowned(unsafe)` 来声明不安全无主引用。如果你试图在实例被销毁后，访问该实例的不安全无主引用，你的程序会尝试访问该实例之前所在的内存地址，这是一个不安全的操作。
 
 <a name="unowned_references_and_implicitly_unwrapped_optional_properties"></a>
@@ -431,7 +430,7 @@ class HTMLElement {
     let name: String
     let text: String?
 
-    lazy var asHTML: Void -> String = {
+    lazy var asHTML: () -> String = {
         if let text = self.text {
             return "<\(self.name)>\(text)</\(self.name)>"
         } else {
@@ -530,7 +529,7 @@ lazy var someClosure: (Int, String) -> String = {
 }
 ```
 
-如果闭包没有指明参数列表或者返回类型，即它们会通过上下文推断，那么可以把捕获列表和关键字`in`放在闭包最开始的地方：
+如果闭包没有指明参数列表或者返回类型，它们会通过上下文推断，那么可以把捕获列表和关键字 `in` 放在闭包最开始的地方：
 
 ```swift
 lazy var someClosure: Void -> String = {

source/chapter2/25_Access_Control.md

@@ -7,11 +7,11 @@
 
 > 2.0
 > 翻译+校对：[mmoaay](https://github.com/mmoaay)
->
+
 > 2.1
 > 翻译：[Prayer](https://github.com/futantan)
 > 校对：[shanks](http://codebuild.me)，2015-11-01
->
+
 > 2.2 
 > 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-17
 
@@ -147,7 +147,7 @@ var someInternalConstant = 0 // 隐式 internal
 
 一个类型的访问级别也会影响到类型*成员*（属性、方法、构造器、下标）的默认访问级别。如果你将类型指定为 `private` 或者 `fileprivate` 级别，那么该类型的所有成员的默认访问级别也会变成 `private` 或者 `fileprivate` 级别。如果你将类型指定为公开或者 `internal` （或者不明确指定访问级别，而使用默认的 `internal` ），那么该类型的所有成员的默认访问级别将是内部访问。
 
-> 重要
+> 重点
 > 
 > 上面提到，一个 `public` 类型的所有成员的访问级别默认为 `internal` 级别，而不是 `public` 级别。如果你想将某个成员指定为 `public` 级别，那么你必须显式指定。这样做的好处是，在你定义公共接口的时候，可以明确地选择哪些接口是需要公开的，哪些是内部使用的，避免不小心将内部使用的接口公开。
 

source/chapter3/04_Expressions.md

@@ -180,9 +180,12 @@ sum = (try someThrowingFunction()) + anotherThrowingFunction() // 错误：try
 有 4 种类型转换运算符：`is`、`as`、`as? ` 和 `as!`。它们有如下的形式：
 
 > `表达式` is `类型`
-`表达式` as `类型`  
+> 
-`表达式` as? `类型`  
+> `表达式` as `类型`
-`表达式` as! `类型`  
+> 
+> `表达式` as? `类型`
+> 
+> `表达式` as! `类型`
 
 `is` 运算符在运行时检查表达式能否向下转化为指定的类型，如果可以则返回 `ture`，否则返回 `false`。
 
@@ -599,6 +602,7 @@ let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (Str
 由于选择器是在编译时创建的，因此编译器可以检查方法或者属性是否存在，以及是否在运行时暴露给了 Objective-C 。
 
 > 注意
+> 
 > 虽然方法名或者属性名是个表达式，但是它不会被求值。
 
 更多关于如何在 Swift 代码中使用选择器来与 Objective-C API 进行交互的信息，请参阅 [Using Swift with Cocoa and Objective-C (Swift 3)](https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 中[Objective-C Selectors](https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-ID59)部分。

source/chapter3/06_Declarations.md

@@ -188,6 +188,7 @@ print("The second number is \(secondNumber).")
 变量声明有几种不同的形式，可以声明不同种类的命名值和可变值，如存储型和计算型变量和属性，属性观察器，以及静态变量属性。所使用的声明形式取决于变量声明的适用范围和打算声明的变量类型。
 
 > 注意
+> 
 > 也可以在协议声明中声明属性，详情请参阅 [协议属性声明](#protocol_property_declaration)。
 
 可以在子类中重写继承来的变量属性，使用 `override` 声明修饰符标记属性的声明即可，详情请参阅 [重写](../chapter2/13_Inheritance.md#overriding)。
@@ -274,6 +275,7 @@ var 变量名称: 类型 = 表达式 {
 要声明一个类型变量属性，用 `static` 声明修饰符标记该声明。类可以改用 `class` 声明修饰符标记类的类型计算型属性从而允许子类重写超类的实现。类型属性在 [类型属性](../chapter2/10_Properties.md#type_properties) 章节有详细讨论。
 
 > 注意
+> 
 > 在一个类声明中，使用关键字 `static` 与同时使用 `class` 和 `final` 去标记一个声明的效果相同。
 
 <a name="grammer_of_a_variable_declaration"></a>
@@ -830,6 +832,7 @@ protocol 协议名称: 继承的协议 {
 协议类型可以继承自任意数量的其它协议。当一个协议类型继承自其它协议的时候，来自其它协议的所有要求会聚合在一起，而且采纳当前协议的类型必须符合所有的这些要求。关于如何使用协议继承的例子，请参阅 [协议继承](../chapter2/22_Protocols.md#protocol_inheritance)。
 
 > 注意
+> 
 > 也可以使用协议合成类型来聚合多个协议的一致性要求，请参阅 [协议合成类型](03_Types.md#protocol_composition_type) 和 [协议合成](../chapter2/22_Protocols.md#protocol_composition)。
 
 可以通过类型的扩展声明来采纳协议，从而为之前声明的类型添加协议一致性。在扩展中，必须实现所有采纳协议的要求。如果该类型已经实现了所有的要求，可以让这个扩展声明的主体留空。
@@ -847,6 +850,7 @@ protocol SomeProtocol: class {
 任何继承自标记有 `class` 关键字的协议的协议也仅能被类类型采纳。
 
 > 注意
+> 
 > 如果协议已经用 `objc` 特性标记了，`class` 要求就隐式地应用于该协议，无需显式使用 `class` 关键字。
 
 协议类型是命名的类型，因此它们可以像其他命名类型一样使用，正如 [协议作为类型](../chapter2/22_Protocols.md#protocols_as_types) 所讨论的。然而，不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。
@@ -992,6 +996,7 @@ convenience init(参数列表) {
 和方法、属性和下标一样，需要使用 `override` 声明修饰符标记重写的指定构造器。
 
 > 注意
+> 
 > 如果使用 `required` 声明修饰符标记一个构造器，在子类中重写这种构造器时，无需使用 `override` 修饰符。
 
 就像函数和方法，构造器也可以抛出或者重抛错误，你可以在构造器参数列表的圆括号之后使用 `throws` 或 `rethrows` 关键字来表明相应的抛出行为。
@@ -1085,6 +1090,7 @@ extension 类型名称: 采纳的协议 {
 	声明语句
 }
 ```
+
 ```swift
 extension 类型名称 where 要求 {
 	声明语句
@@ -1223,9 +1229,11 @@ precedencegroup 优先级组名称{
     assignment: 赋值性
 }
 ```
+
 较低优先级组和较高优先级组的名称说明了新建的优先级组是依赖于现存的优先级组的。`lowerThan` 优先级组的属性只可以引用当前模块外的优先级组。当两个运算符为同一个操作数竞争时，比如表达式 `2 + 3 * 5`,优先级更高的运算符将优先参与运算。 
 
 > 注意
+> 
 > 使用较低和较高优先级组相互联系的优先级组必须保持单一层次关系，但它们不必是线性关系。这意味着优先级组也许会有未定义的相关优先级。这些优先级组的运算符在没有用圆括号分组的情况下是不能紧邻着使用的。
 
 Swift 定义了大量的优先级组来与标准库的运算符配合使用，例如相加(`+`)和相减(`-`)属于 `AdditionPrecedence` 组，相乘(`*`)和相除(`/`)属于 `MultiplicationPrecedence` 组，详细关于 Swift 标准库中一系列运算符和优先级组内容，参阅[Swift 标准库操作符参考](https://developer.apple.com/reference/swift/1851035-swift_standard_library_operators)。

source/v1.0.md

@@ -8,7 +8,7 @@
 > 关于文档中翻译错误，逻辑错误以及疑难问题答疑，请关注["@老码团队"](http://weibo.com/u/5241713117
 )官方微博，会有技术人员统一收集答疑
 
-# The Swift Programming Language 中文版####
+# The Swift Programming Language 中文版
 
 ###这一次，让中国和世界同步