From 16386d375c3520414a81b132d032afed08043df0 Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 10:48:05 +0800
Subject: [PATCH 001/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E9=97=AD=E5=8C=85?=
 =?UTF-8?q?=E8=A1=A8=E8=BE=BE=E5=BC=8FClosure=20Expressions?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

旧版本： sorted function
Swift2.0:  sort(_:) method
---
 source/chapter2/07_Closures.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 093a113d..9ccd932e 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -41,7 +41,7 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
 
 闭包表达式是一种利用简洁语法构建内联闭包的方式。
 闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
-下面闭包表达式的例子通过使用几次迭代展示了`sorted`函数定义和语法优化的方式。
+下面闭包表达式的例子通过使用几次迭代展示了`sort(_:)`方法定义和语法优化的方式。
 每一次迭代都用更简洁的方式描述了相同的功能。
 
 <a name="the_sorted_function"></a>

From 3d24bfd965fbf7642b1a611c63243f695e85dd07 Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 11:38:52 +0800
Subject: [PATCH 002/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0sort=E5=87=BD?=
 =?UTF-8?q?=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1.修订润色,将Sorted修改为Sort.
2.增添缺少的The original array is not modified by the sort(_:) method翻译
---
 source/chapter2/07_Closures.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 093a113d..728c9416 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -45,10 +45,10 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
 每一次迭代都用更简洁的方式描述了相同的功能。
 
 <a name="the_sorted_function"></a>
-### sorted 函数（The Sorted Function）
+### sort 函数（The Sort Function）
 
-Swift 标准库提供了`sorted`函数，会根据您提供的基于输出类型排序的闭包函数将已知类型数组中的值进行排序。
-一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
+Swift 标准库提供了名为`sort`的函数，会根据您提供的用于排序的闭包函数将已知类型数组中的值进行排序。
+一旦排序完成，`sort(_:)`方法会返回一个与原数组大小相同,包含同类型元素且元素已正确排序的新数组。原数组不会被`sort(_:)`方法修改。
 
 下面的闭包表达式示例使用`sorted`函数对一个`String`类型的数组进行字母逆序排序，以下是初始数组值：
 

From 9e6fb79df5170676b6092187a90c0c35d5fd53b0 Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 12:44:34 +0800
Subject: [PATCH 003/228] =?UTF-8?q?=E5=AE=8C=E6=88=90=E4=BF=AE=E8=AE=A2=20?=
 =?UTF-8?q?sort=E5=87=BD=E6=95=B0=20=E5=B0=8F=E8=8A=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/07_Closures.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 093a113d..2a006e82 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -50,26 +50,26 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
 Swift 标准库提供了`sorted`函数，会根据您提供的基于输出类型排序的闭包函数将已知类型数组中的值进行排序。
 一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
 
-下面的闭包表达式示例使用`sorted`函数对一个`String`类型的数组进行字母逆序排序，以下是初始数组值：
+下面的闭包表达式示例使用`sort(_:)`方法对一个String类型的数组进行字母逆序排序，以下是初始数组值：
 
 ```swift
 let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 ```
 
-`sorted`函数需要传入两个参数：
+`sort(_:)`方法需要传入两个参数：
 
 * 已知类型的数组
-* 闭包函数，该闭包函数需要传入与数组类型相同的两个值，并返回一个布尔类型值来告诉`sorted`函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回`true`，反之返回`false`。
+* 闭包函数，该闭包函数需要传入与数组元素类型相同的两个值，并返回一个布尔类型值来表明当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回`true`，反之返回`false`。
 
 该例子对一个`String`类型的数组进行排序，因此排序闭包函数类型需为`(String, String) -> Bool`。
 
-提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`sort`函数的第二个参数传入：
+提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`ssort(_:)`方法的参数传入：
 
 ```swift
 func backwards(s1: String, s2: String) -> Bool {
     return s1 > s2
 }
-var reversed = sorted(names, backwards)
+var reversed = names.sort(backwards)
 // reversed 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
 ```
 

From aa8a3a6ac6c762bf0507d3845fdbd09eb4111ab8 Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 13:07:00 +0800
Subject: [PATCH 004/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=97=AD=E5=8C=85?=
 =?UTF-8?q?=E8=A1=A8=E8=BE=BE=E5=BC=8F=E8=AF=AD=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/07_Closures.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 093a113d..bd3696ab 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -99,7 +99,7 @@ var reversed = sorted(names, backwards)
 下面的例子展示了之前`backwards`函数对应的闭包表达式版本的代码：
 
 ```swift
-reversed = sorted(names, { (s1: String, s2: String) -> Bool in
+reversed = names.sort({ (s1: String, s2: String) -> Bool in
     return s1 > s2
 })
 ```
@@ -114,10 +114,10 @@ reversed = sorted(names, { (s1: String, s2: String) -> Bool in
 因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：
 
 ```swift
-reversed = sorted(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
+reversed = names.sort( { (s1: String, s2: String) -> Bool in return s1 > s2 } )
 ```
 
-这说明`sorted`函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包（相比于`backwards`版本的代码）。
+这说明`sort(_:)`方法的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包（相比于`backwards`版本的代码）
 
 <a name="inferring_type_from_context"></a>
 ### 根据上下文推断类型（Inferring Type From Context）

From 5e33251e5d9f7c6d4505456f9f75dc7a25975b9b Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 13:45:37 +0800
Subject: [PATCH 005/228] =?UTF-8?q?=E4=BF=AE=E8=AE=A2Inferring=20Type=20Fr?=
 =?UTF-8?q?om=20Context?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1.修订sort方法
2.增加未翻译部分
---
 source/chapter2/07_Closures.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 093a113d..da022838 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -122,16 +122,18 @@ reversed = sorted(names, { (s1: String, s2: String) -> Bool in return s1 > s2 }
 <a name="inferring_type_from_context"></a>
 ### 根据上下文推断类型（Inferring Type From Context）
 
-因为排序闭包函数是作为`sorted`函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
+因为排序闭包函数是作为`sort(_:)`方法的参数进行传入的，Swift可以推断其参数和返回值的类型。
 `sorted`期望第二个参数是类型为`(String, String) -> Bool`的函数，因此实际上`String`,`String`和`Bool`类型并不需要作为闭包表达式定义中的一部分。
 因为所有的类型都可以被正确推断，返回箭头 (`->`) 和围绕在参数周围的括号也可以被省略：
 
 ```swift
-reversed = sorted(names, { s1, s2 in return s1 > s2 } )
+reversed = names.sort( { s1, s2 in return s1 > s2 } )
 ```
 
 实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
 
+然而您仍然可以明确写出有着完整格式的闭包。如果完整格式的闭包能够提高代码的可读性我,我们建议采取这种形式。而在`sort(_:)`方法这个例子里,闭包的目的就是排序,读者能够推测除这个闭包是用于字符串处理的,因为这个闭包是为了处理字符串数组的排序。
+
 <a name="implicit_returns_from_single_expression_closures"></a>
 ### 单表达式闭包隐式返回（Implicit Return From Single-Expression Clossures）
 

From 56a3be66b2039d2b0ae8cad791ec7aa39a2b4eec Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 13:51:07 +0800
Subject: [PATCH 006/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9Inferring=20Type=20Fr?=
 =?UTF-8?q?om=20Context?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/07_Closures.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index da022838..806f321e 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -132,7 +132,7 @@ reversed = names.sort( { s1, s2 in return s1 > s2 } )
 
 实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
 
-然而您仍然可以明确写出有着完整格式的闭包。如果完整格式的闭包能够提高代码的可读性我,我们建议采取这种形式。而在`sort(_:)`方法这个例子里,闭包的目的就是排序,读者能够推测除这个闭包是用于字符串处理的,因为这个闭包是为了处理字符串数组的排序。
+然而您仍然可以明确写出有着完整格式的闭包。如果完整格式的闭包能够提高代码的可读性,则可以采用完整格式的闭包。而在`sort(_:)`方法这个例子里,闭包的目的就是排序,读者能够推测除这个闭包是用于字符串处理的,因为这个闭包是为了处理字符串数组的排序。
 
 <a name="implicit_returns_from_single_expression_closures"></a>
 ### 单表达式闭包隐式返回（Implicit Return From Single-Expression Clossures）

From 359d9acb94c95d8ccb9262be90e83a02e160018c Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 14:05:44 +0800
Subject: [PATCH 007/228] =?UTF-8?q?=E4=BF=AE=E8=AE=A2Implicit=20Return=20F?=
 =?UTF-8?q?rom=20Single-Expression=20Clossures?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/07_Closures.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 806f321e..f3324d16 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -140,10 +140,10 @@ reversed = names.sort( { s1, s2 in return s1 > s2 } )
 单行表达式闭包可以通过隐藏`return`关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
 
 ```swift
-reversed = sorted(names, { s1, s2 in s1 > s2 } )
+reversed = names.sort( { s1, s2 in s1 > s2 } )
 ```
 
-在这个例子中，`sorted`函数的第二个参数函数类型明确了闭包必须返回一个`Bool`类型值。
+在这个例子中，`sort(_:)`方法的第二个参数函数类型明确了闭包必须返回一个`Bool`类型值。
 因为闭包函数体只包含了一个单一表达式 (`s1 > s2`)，该表达式返回`Bool`类型值，因此这里没有歧义，`return`关键字可以省略。
 
 <a name="shorthand_argument_names"></a>

From cf51cad41a96f6f868d39394ddbdcfb4fdcf15cc Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sun, 28 Jun 2015 14:26:25 +0800
Subject: [PATCH 008/228] =?UTF-8?q?=E4=BF=AE=E8=AE=A2sorted,()?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1.sorted -> sort
2.() -> Void
---
 source/chapter2/07_Closures.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index f3324d16..7f7969de 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -155,7 +155,7 @@ Swift 自动为内联函数提供了参数名称缩写功能，您可以直接
 `in`关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：
 
 ```swift
-reversed = sorted(names, { $0 > $1 } )
+reversed = names.sort( { $0 > $1 } )
 ```
 
 在这个例子中，`$0`和`$1`表示闭包中第一个和第二个`String`类型的参数。
@@ -165,11 +165,11 @@ reversed = sorted(names, { $0 > $1 } )
 
 实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。
 Swift 的`String`类型定义了关于大于号 (`>`) 的字符串实现，其作为一个函数接受两个`String`类型的参数并返回`Bool`类型的值。
-而这正好与`sorted`函数的第二个参数需要的函数类型相符合。
+而这正好与`sort(_:)`方法的第二个参数需要的函数类型相符合。
 因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
 
 ```swift
-reversed = sorted(names, >)
+reversed = names.sort(>)
 ```
 
 更多关于运算符表达式的内容请查看 [运算符函数](../chapter2/24_Advanced_Operators.html#operator_functions)。
@@ -182,7 +182,7 @@ reversed = sorted(names, >)
 尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
 
 ```swift
-func someFunctionThatTakesAClosure(closure: () -> ()) {
+func someFunctionThatTakesAClosure(closure: () -> Void) {
     // 函数体部分
 }
 
@@ -203,7 +203,7 @@ someFunctionThatTakesAClosure() {
 在上例中作为`sorted`函数参数的字符串排序闭包可以改写为：
 
 ```swift
-reversed = sorted(names) { $0 > $1 }
+reversed = names.sort() { $0 > $1 }
 ```
 
 当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。
@@ -283,7 +283,7 @@ Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的
 每次调用`incrementor`时，其会以`amount`作为增量增加`runningTotal`的值。
 
 ```swift
-func makeIncrementor(forIncrement amount: Int) -> () -> Int {
+func makeIncrementor(forIncrement amount: Int) -> Void -> Int {
     var runningTotal = 0
     func incrementor() -> Int {
         runningTotal += amount
@@ -293,7 +293,7 @@ func makeIncrementor(forIncrement amount: Int) -> () -> Int {
 }
 ```
 
-`makeIncrementor`返回类型为`() -> Int`。
+`makeIncrementor`返回类型为`Void -> Int`。
 这意味着其返回的是一个函数，而不是一个简单类型值。
 该函数在每次调用时不接受参数只返回一个`Int`类型的值。
 关于函数返回其他函数的内容，请查看[函数类型作为返回类型](../chapter2/06_Functions.html#function_types_as_return_types)。

From e49e55db0080a6a231b8a8531c2290a1bcc4b993 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Sun, 28 Jun 2015 16:38:24 +0800
Subject: [PATCH 009/228] patterns updated test

---
 source/chapter3/07_Patterns.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 3448a392..49a3ff9b 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -16,6 +16,8 @@
 
 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
 
+swift中有2种模式的基本类型：
+
 在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。
 
 你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。
@@ -179,4 +181,4 @@ default:
 ```
 
 > 表达式模式语法  
-> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
\ No newline at end of file
+> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression)  

From 4a35d8c35bc50df741ebe2e03ed7b34c316d31cd Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Sun, 28 Jun 2015 17:19:15 +0800
Subject: [PATCH 010/228] updated 17:18, 6/28/2015

---
 source/chapter3/07_Patterns.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 49a3ff9b..b9fcb902 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -16,7 +16,11 @@
 
 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
 
-swift中有2种模式的基本类型：
+swift中有2个基本的模式种类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。
+
+第一类模式用于析构简单变量，常量和可选绑定中的值。此类模式包括通配符模式，标识符模式，以及任何包含了它们的值绑定模式或者元祖模式。你可以为这些模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。
+
+第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
 
 在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。
 

From cc27f4fccb441d372800758af9c3e3fc6373f30f Mon Sep 17 00:00:00 2001
From: chenYuheng <yuheng@tataufo.com>
Date: Sun, 28 Jun 2015 21:09:11 +0800
Subject: [PATCH 011/228] =?UTF-8?q?1.=E4=BF=AE=E6=94=B9=E4=BA=86=E8=8E=B7?=
 =?UTF-8?q?=E5=8F=96rawValue=E7=9A=84=E6=96=B9=E6=B3=95=E5=90=8D=E7=A7=B0?=
 =?UTF-8?q?=202.=E4=BF=AE=E6=94=B9=E4=BA=86=E9=83=A8=E5=88=86=E5=92=8C?=
 =?UTF-8?q?=E6=96=87=E6=9C=AC=E6=84=8F=E6=80=9D=E4=B8=8D=E7=AC=A6=E7=9A=84?=
 =?UTF-8?q?=E7=BF=BB=E8=AF=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/19_Nested_Types.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/19_Nested_Types.md
index 0db7d1da..bd03302e 100755
--- a/source/chapter2/19_Nested_Types.md
+++ b/source/chapter2/19_Nested_Types.md
@@ -41,7 +41,7 @@ struct BlackjackCard {
         case .Jack, .Queen, .King:
             return Values(first: 10, second: nil)
         default:
-            return Values(first: self.toRaw(), second: nil)
+            return Values(first: self.rawValue, second: nil)
             }
        }
     }
@@ -49,7 +49,7 @@ struct BlackjackCard {
     // BlackjackCard 的属性和方法
     let rank: Rank, suit: Suit
     var description: String {
-    var output = "suit is \(suit.toRaw()),"
+    	var output = "suit is \(suit.rawValue),"
         output += " value is \(rank.values.first)"
         if let second = rank.values.second {
             output += " or \(second)"
@@ -63,12 +63,12 @@ struct BlackjackCard {
 
 枚举型的`Rank`用来描述扑克牌从`Ace`~10,`J`,`Q`,`K`,13张牌，并分别用一个`Int`类型的值表示牌的面值。(这个`Int`类型的值不适用于`Ace`,`J`,`Q`,`K`的牌)。
 
-如上文所提到的，枚举型`Rank`在自己内部定义了一个嵌套结构体`Values`。这个结构体包含两个变量，只有`Ace`有两个数值，其余牌都只有一个数值。结构体`Values`中定义的两个属性：
+如上文所提到的，枚举型`Rank`在自己内部定义了一个嵌套结构体`Values`。在这个结构体中，只有`Ace`有两个数值，其余牌都只有一个数值。结构体`Values`中定义的两个属性：
 
 `first`, 为` Int`
 `second`, 为 `Int?`, 或 “optional `Int`”
 
-`Rank`定义了一个计算属性`values`，这个计算属性会根据牌的面值，用适当的数值去初始化`Values`实例，并赋值给`values`。对于`J`,`Q`,`K`,`Ace`会使用特殊数值，对于数字面值的牌使用`Int`类型的值。
+`Rank`定义了一个计算属性`values`，它将会返回一个结构体`Values`的实例。这个计算属性会根据牌的面值，用适当的数值去初始化`Values`实例，并赋值给`values`。对于`J`,`Q`,`K`,`Ace`会使用特殊数值，对于数字面值的牌使用`Int`类型的值。
 
 `BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。
 
@@ -88,9 +88,9 @@ println("theAceOfSpades: \(theAceOfSpades.description)")
 在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名：
 
 ```swift
-let heartsSymbol = BlackjackCard.Suit.Hearts.toRaw()
+let heartsSymbol = BlackjackCard.Suit.Hearts.rawValue
 // 红心的符号 为 "♡"
 ```
 
-对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由被定义的上下文来限定。
+对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由定义它们的上下文来限定。
 

From d849ef96b352481439d9a41e8cf1b30ee137553c Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Sun, 28 Jun 2015 21:20:53 +0800
Subject: [PATCH 012/228] patterns_21:20_06/28/2015

---
 source/chapter3/07_Patterns.md | 70 ++++++++++++++++++++++++++--------
 1 file changed, 54 insertions(+), 16 deletions(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index b9fcb902..28e2a23a 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -11,6 +11,7 @@
 - [值绑定模式（Value-Binding Pattern）](#value-binding_pattern)
 - [元组模式（Tuple Pattern）](#tuple_pattern)
 - [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern)
+- [可选模式（Optional Patterns）](#optional_patterns)
 - [类型转换模式（Type-Casting Patterns）](#type-casting_patterns)
 - [表达式模式（Expression Pattern）](#expression_pattern)
 
@@ -18,20 +19,17 @@
 
 swift中有2个基本的模式种类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。
 
-第一类模式用于析构简单变量，常量和可选绑定中的值。此类模式包括通配符模式，标识符模式，以及任何包含了它们的值绑定模式或者元祖模式。你可以为这些模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。
+第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。
 
 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
 
-在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在它们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。
-
-你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。
-
 > 模式(Patterns) 语法  
 > *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
 > *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_  
 > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)  
 > *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
 > *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern)  
+> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) [*类型注解*](..\chapter3\03_Types.html#optional_type) _可选_  
 > *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern)  
 > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)  
 
@@ -42,7 +40,7 @@ swift中有2个基本的模式种类：一类能成功和任何值的类型相
 
 ```swift
 for _ in 1...3 {
-    // Do something three times.
+// Do something three times.
 }
 ```
 
@@ -75,9 +73,9 @@ let someValue = 42
 ```swift
 let point = (3, 2)
 switch point {
-    // Bind x and y to the elements of point.
+// Bind x and y to the elements of point.
 case let (x, y):
-    println("The point is at (\(x), \(y)).")
+println("The point is at (\(x), \(y)).")
 }
 // prints "The point is at (3, 2).”
 ```
@@ -100,7 +98,7 @@ case let (x, y):
 let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
 // This code isn't valid.
 for (x, 0) in points {
-    /* ... */
+/* ... */
 }
 ```
 
@@ -127,6 +125,46 @@ let (a): Int = 2 // a: Int = 2
 > 枚举用例模式语法  
 > *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_  
 
+
+
+<a name="optional_pattern"></a>
+## 可选模式（Optional Pattern）
+
+可选模式 封装在一个`Some(T)`
+
+可选模式由一个标识符模式和紧随其后的一个问号组成，在某种情况下表现为枚举用例模式。
+
+由于可选模式是`optionan`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖，下面的两种写法一样的：
+
+```swift
+let someOptional: Int? = 42
+// Match using an enumeration case pattern
+if case .Some(let x) = someOptional {
+    print(x)
+}
+
+// Match using an optional pattern
+if case let x? = someOptional {
+    print(x)
+}
+```
+
+可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便的方式，只为数组中的非空元素执行循环。
+
+```swift
+let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
+// Match only non-nil values
+for case let number? in arrayOfOptinalInts {
+    print("Found a \(number)")
+}
+//Found a 2
+//Found a 3
+//Found a 5
+
+```
+> 可选模式语法  
+> *optional-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) ?
+
 <a name="type-casting_patterns"></a>
 ## 类型转换模式（Type-Casting Patterns）
 
@@ -157,11 +195,11 @@ let (a): Int = 2 // a: Int = 2
 let point = (1, 2)
 switch point {
 case (0, 0):
-    println("(0, 0) is at the origin.")
+println("(0, 0) is at the origin.")
 case (-2...2, -2...2):
-    println("(\(point.0), \(point.1)) is near the origin.")
+println("(\(point.0), \(point.1)) is near the origin.")
 default:
-    println("The point is at (\(point.0), \(point.1)).")
+println("The point is at (\(point.0), \(point.1)).")
 }
 // prints "(1, 2) is near the origin.”
 ```
@@ -171,15 +209,15 @@ default:
 ```swift
 // Overload the ~= operator to match a string with an integer
 func ~=(pattern: String, value: Int) -> Bool {
-    return pattern == "\(value)"
+return pattern == "\(value)"
 }
 switch point {
 case ("0", "0"):
-    println("(0, 0) is at the origin.")
+println("(0, 0) is at the origin.")
 case ("-2...2", "-2...2"):
-    println("(\(point.0), \(point.1)) is near the origin.")
+println("(\(point.0), \(point.1)) is near the origin.")
 default:
-    println("The point is at (\(point.0), \(point.1)).")
+println("The point is at (\(point.0), \(point.1)).")
 }
 // prints "(1, 2) is near the origin.”
 ```

From bb0859adf1bd74421cc3d5791294bd2f79e415bd Mon Sep 17 00:00:00 2001
From: Channe <ichanne@qq.com>
Date: Mon, 29 Jun 2015 10:28:59 +0800
Subject: [PATCH 013/228] =?UTF-8?q?ARC=E7=AB=A0=E8=8A=82=E6=9B=B4=E6=96=B0?=
 =?UTF-8?q?=E5=88=B0Swift2.0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ARC章节更新到Swift2.0
---
 .../16_Automatic_Reference_Counting.md        | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index ff926895..42175064 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -41,10 +41,10 @@ class Person {
     let name: String
     init(name: String) {
         self.name = name
-        println("\(name) is being initialized")
+        print("\(name) is being initialized")
     }
     deinit {
-        println("\(name) is being deinitialized")
+        print("\(name) is being deinitialized")
     }
 }
 ```
@@ -109,7 +109,7 @@ class Person {
     let name: String
     init(name: String) { self.name = name }
     var apartment: Apartment?
-    deinit { println("\(name) is being deinitialized") }
+    deinit { print("\(name) is being deinitialized") }
 }
 ```
 
@@ -118,7 +118,7 @@ class Apartment {
     let number: Int
     init(number: Int) { self.number = number }
     var tenant: Person?
-    deinit { println("Apartment #\(number) is being deinitialized") }
+    deinit { print("Apartment #\(number) is being deinitialized") }
 }
 ```
 
@@ -201,7 +201,7 @@ class Person {
     let name: String
     init(name: String) { self.name = name }
     var apartment: Apartment?
-    deinit { println("\(name) is being deinitialized") }
+    deinit { print("\(name) is being deinitialized") }
 }
 ```
 
@@ -210,7 +210,7 @@ class Apartment {
     let number: Int
     init(number: Int) { self.number = number }
     weak var tenant: Person?
-    deinit { println("Apartment #\(number) is being deinitialized") }
+    deinit { print("Apartment #\(number) is being deinitialized") }
 }
 ```
 
@@ -281,7 +281,7 @@ class Customer {
     init(name: String) {
         self.name = name
     }
-    deinit { println("\(name) is being deinitialized") }
+    deinit { print("\(name) is being deinitialized") }
 }
 ```
 
@@ -293,7 +293,7 @@ class CreditCard {
         self.number = number
         self.customer = customer
     }
-    deinit { println("Card #\(number) is being deinitialized") }
+    deinit { print("Card #\(number) is being deinitialized") }
 }
 ```
 
@@ -347,7 +347,7 @@ john = nil
 ```swift
 class Country {
     let name: String
-    let capitalCity: City!
+    var capitalCity: City!
     init(name: String, capitalName: String) {
         self.name = name
         self.capitalCity = City(name: capitalName, country: self)
@@ -378,7 +378,7 @@ class City {
 
 ```swift
 var country = Country(name: "Canada", capitalName: "Ottawa")
-println("\(country.name)'s capital city is called \(country.capitalCity.name)")
+print("\(country.name)'s capital city is called \(country.capitalCity.name)")
 // prints "Canada's capital city is called Ottawa"
 ```
 
@@ -403,7 +403,7 @@ class HTMLElement {
     let name: String
     let text: String?
 
-    lazy var asHTML: () -> String = {
+    lazy var asHTML: Void -> String = {
         if let text = self.text {
             return "<\(self.name)>\(text)</\(self.name)>"
         } else {
@@ -417,7 +417,7 @@ class HTMLElement {
     }
 
     deinit {
-        println("\(name) is being deinitialized")
+        print("\(name) is being deinitialized")
     }
 
 }
@@ -440,7 +440,7 @@ class HTMLElement {
 
 ```swift
 var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
-println(paragraph!.asHTML())
+print(paragraph!.asHTML())
 // prints"hello, world"
 ```
 
@@ -488,7 +488,7 @@ lazy var someClosure: (Int, String) -> String = {
 如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以捕获列表放在闭包开始的地方，跟着是关键字`in`：
 
 ```swift
-lazy var someClosure: () -> String = {
+lazy var someClosure: Void -> String = {
     [unowned self] in
     // closure body goes here
 }
@@ -511,7 +511,7 @@ class HTMLElement {
     let name: String
     let text: String?
 
-    lazy var asHTML: () -> String = {
+    lazy var asHTML: Void -> String = {
         [unowned self] in
         if let text = self.text {
             return "<\(self.name)>\(text)</\(self.name)>"
@@ -526,7 +526,7 @@ class HTMLElement {
     }
 
     deinit {
-        println("\(name) is being deinitialized")
+        print("\(name) is being deinitialized")
     }
 
 }
@@ -538,7 +538,7 @@ class HTMLElement {
 
 ```swift
 var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
-println(paragraph!.asHTML())
+print(paragraph!.asHTML())
 // prints "<p>hello, world</p>"
 ```
 

From ca44d06f29216c2bb9027a64cafb1f6c9d2939fa Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 12:57:36 +0800
Subject: [PATCH 014/228] patterns_12:57_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 38 +++++++++++++++-------------------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 28e2a23a..0795f26f 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -11,15 +11,15 @@
 - [值绑定模式（Value-Binding Pattern）](#value-binding_pattern)
 - [元组模式（Tuple Pattern）](#tuple_pattern)
 - [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern)
-- [可选模式（Optional Patterns）](#optional_patterns)
-- [类型转换模式（Type-Casting Patterns）](#type-casting_patterns)
+- [可选模式（Optional Patterns）](#optional_pattern)
+- [类型转换模式（Type-Casting Patterns）](#type-casting_pattern)
 - [表达式模式（Expression Pattern）](#expression_pattern)
 
-模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
+模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从复合值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
 
-swift中有2个基本的模式种类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。
+swift语言中模式有2个基本的分类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。
 
-第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）来限制它们只能匹配某种特定类型的值。
+第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。
 
 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
 
@@ -28,9 +28,9 @@ swift中有2个基本的模式种类：一类能成功和任何值的类型相
 > *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_  
 > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)  
 > *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
-> *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern)  
+> *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern)  
 > *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) [*类型注解*](..\chapter3\03_Types.html#optional_type) _可选_  
-> *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern)  
+> *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern)  
 > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)  
 
 <a name="wildcard_pattern"></a>
@@ -75,7 +75,7 @@ let point = (3, 2)
 switch point {
 // Bind x and y to the elements of point.
 case let (x, y):
-println("The point is at (\(x), \(y)).")
+print("The point is at (\(x), \(y)).")
 }
 // prints "The point is at (3, 2).”
 ```
@@ -125,16 +125,12 @@ let (a): Int = 2 // a: Int = 2
 > 枚举用例模式语法  
 > *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_  
 
-
-
 <a name="optional_pattern"></a>
 ## 可选模式（Optional Pattern）
 
-可选模式 封装在一个`Some(T)`
+可选模式与封装在一个`Optional(T)`或者一个`ExplicitlyUnwrappedOptional(T)`枚举中的`Some(T)`成员值相匹配。可选模式由一个标识符模式和紧随其后的一个问号组成，在某些情况下表现为枚举用例模式。
 
-可选模式由一个标识符模式和紧随其后的一个问号组成，在某种情况下表现为枚举用例模式。
-
-由于可选模式是`optionan`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖，下面的两种写法一样的：
+由于可选模式是`optional`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖（syntactic sugar），下面的两种写法一样的：
 
 ```swift
 let someOptional: Int? = 42
@@ -149,7 +145,7 @@ if case let x? = someOptional {
 }
 ```
 
-可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便的方式，只为数组中的非空元素执行循环。
+可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。
 
 ```swift
 let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
@@ -195,11 +191,11 @@ for case let number? in arrayOfOptinalInts {
 let point = (1, 2)
 switch point {
 case (0, 0):
-println("(0, 0) is at the origin.")
+print("(0, 0) is at the origin.")
 case (-2...2, -2...2):
-println("(\(point.0), \(point.1)) is near the origin.")
+print("(\(point.0), \(point.1)) is near the origin.")
 default:
-println("The point is at (\(point.0), \(point.1)).")
+print("The point is at (\(point.0), \(point.1)).")
 }
 // prints "(1, 2) is near the origin.”
 ```
@@ -213,11 +209,11 @@ return pattern == "\(value)"
 }
 switch point {
 case ("0", "0"):
-println("(0, 0) is at the origin.")
+print("(0, 0) is at the origin.")
 case ("-2...2", "-2...2"):
-println("(\(point.0), \(point.1)) is near the origin.")
+print("(\(point.0), \(point.1)) is near the origin.")
 default:
-println("The point is at (\(point.0), \(point.1)).")
+print("The point is at (\(point.0), \(point.1)).")
 }
 // prints "(1, 2) is near the origin.”
 ```

From 8f6eb4e2f6df46c44fdb69e7fe35716c395b5359 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 13:05:40 +0800
Subject: [PATCH 015/228] patterns_13:05_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 0795f26f..0b4f0bf5 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -1,4 +1,4 @@
-> 翻译：[honghaoz](https://github.com/honghaoz)  
+> 翻译：[honghaoz](https://github.com/honghaoz), [ray16897188](https://github.com/ray16897188)  
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
 # 模式（Patterns）
@@ -144,8 +144,7 @@ if case let x? = someOptional {
     print(x)
 }
 ```
-
-可选模式在`for-in`语句提供了在一个元素是可选类型的数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。
+如果一个数组的元素是可选类型，可选模式为`for-in`语句提供了在该数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。
 
 ```swift
 let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]

From 84a31ca36b8a3679346d8f28a50078e6c24798b8 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 13:21:25 +0800
Subject: [PATCH 016/228] patterns_13:21_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 0b4f0bf5..4e9e8660 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -158,7 +158,7 @@ for case let number? in arrayOfOptinalInts {
 
 ```
 > 可选模式语法  
-> *optional-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) ?
+> *可选模式* → [*标识符模式*](..\chapter3\03_Types.html#type_identifier) ?
 
 <a name="type-casting_patterns"></a>
 ## 类型转换模式（Type-Casting Patterns）

From 5946afca2ea7a1da97e5d390ee02e264a5b65826 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 11:27:13 +0800
Subject: [PATCH 017/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E7=A4=BA=E4=BE=8B?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81=EF=BC=8Cprintln()=20->=20println()?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 1484694f..570f1de2 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -79,13 +79,13 @@ directionToHead = .East
 directionToHead = .South
 switch directionToHead {
 case .North:
-    println("Lots of planets have a north")
+    print("Lots of planets have a north")
 case .South:
-    println("Watch out for penguins")
+    print("Watch out for penguins")
 case .East:
-    println("Where the sun rises")
+    print("Where the sun rises")
 case .West:
-    println("Where the skies are blue")
+    print("Where the skies are blue")
 }
 // 输出 "Watch out for penguins”
 ```
@@ -104,9 +104,9 @@ case .West:
 let somePlanet = Planet.Earth
 switch somePlanet {
 case .Earth:
-    println("Mostly harmless")
+    print("Mostly harmless")
 default:
-    println("Not a safe place for humans")
+    print("Not a safe place for humans")
 }
 // 输出 "Mostly harmless”
 ```
@@ -164,9 +164,9 @@ productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
 ```swift
 switch productBarcode {
 case .UPCA(let numberSystem, let identifier, let check):
-    println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
+    print("UPC-A with value of \(numberSystem), \(identifier), \(check).")
 case .QRCode(let productCode):
-    println("QR code with value of \(productCode).")
+    print("QR code with value of \(productCode).")
 }
 // 输出 "QR code with value of ABCDEFGHIJKLMNOP.”
 ```
@@ -176,9 +176,9 @@ case .QRCode(let productCode):
 ```swift
 switch productBarcode {
 case let .UPCA(numberSystem, identifier, check):
-    println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
+    print("UPC-A with value of \(numberSystem), \(identifier), \(check).")
 case let .QRCode(productCode):
-    println("QR code with value of \(productCode).")
+    print("QR code with value of \(productCode).")
 }
 // 输出 "QR code with value of ABCDEFGHIJKLMNOP."
 ```
@@ -237,15 +237,14 @@ let positionToFind = 9
 if let somePlanet = Planet(rawValue: positionToFind) {
     switch somePlanet {
     case .Earth:
-        println("Mostly harmless")
+        print("Mostly harmless")
     default:
-        println("Not a safe place for humans")
+        print("Not a safe place for humans")
     }
 } else {
-    println("There isn't a planet at position \(positionToFind)")
+    print("There isn't a planet at position \(positionToFind)")
 }
 // 输出 "There isn't a planet at position 9
 ```
 
 这个范例使用可选绑定（optional binding），通过原始值`9`试图访问一个行星。`if let somePlanet = Planet(rawValue: 9)`语句获得一个可选`Planet`，如果可选`Planet`可以被获得，把`somePlanet`设置成该可选`Planet`的内容。在这个范例中，无法检索到位置为`9`的行星，所以`else`分支被执行。
-

From 385123a16b04c630bb2fffd067ad6ecbe0379763 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 15:32:05 +0800
Subject: [PATCH 018/228] =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=9E=9A=E4=B8=BE?=
 =?UTF-8?q?=EF=BC=8D=E6=A6=82=E8=BF=B0=E9=83=A8=E5=88=86=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 570f1de2..23c960a3 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -11,13 +11,13 @@
 - [相关值（Associated Values）](#associated_values)
 - [原始值（Raw Values）](#raw_values)
 
-枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。
+*枚举*定义了一个通用类型的一组相关值，使你可以在你的代码中以一种安全的方式来使用这些值。
 
-如果你熟悉 C 语言，你就会知道，在 C 语言中枚举指定相关名称为一组整型值。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果一个值（被认为是“原始”值）被提供给每个枚举成员，则该值可以是一个字符串，一个字符，或是一个整型值或浮点值。
+如果你熟悉 C 语言，你就会知道，在 C 语言中枚举将枚举名和一个整形值相对应。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
 
 此外，枚举成员可以指定任何类型的相关值存储到枚举成员值中，就像其他语言中的联合体（unions）和变体（variants）。你可以定义一组通用的相关成员作为枚举的一部分，每一组都有不同的一组与它相关的适当类型的数值。
 
-在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多传统上只被类（class）所支持的特征，例如计算型属性（computed properties），用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始成员值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。
+在 Swift 中，枚举类型是一等公民（first-class）。它们采用了很多传统上只被类（class）所支持的特征，例如计算型属性（computed properties），用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。
 
 欲了解更多相关功能，请参见[属性（Properties）](10_Properties.html)，[方法（Methods）](11_Methods.html)，[构造过程（Initialization）](14_Initialization.html)，[扩展（Extensions）](20_Extensions.html)和[协议（Protocols）](21_Protocols.html)。
 

From 13de9fc77b4b29e8729b46535d0e9c3c7119062b Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 15:49:49 +0800
Subject: [PATCH 019/228] =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=9E=9A=E4=B8=BE?=
 =?UTF-8?q?=E8=AF=AD=E6=B3=95=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 23c960a3..f5f74e3a 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -13,7 +13,7 @@
 
 *枚举*定义了一个通用类型的一组相关值，使你可以在你的代码中以一种安全的方式来使用这些值。
 
-如果你熟悉 C 语言，你就会知道，在 C 语言中枚举将枚举名和一个整形值相对应。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
+如果你熟悉 C 语言，你就会知道，在 C 语言中枚举将枚举名和一个整型值相对应。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
 
 此外，枚举成员可以指定任何类型的相关值存储到枚举成员值中，就像其他语言中的联合体（unions）和变体（variants）。你可以定义一组通用的相关成员作为枚举的一部分，每一组都有不同的一组与它相关的适当类型的数值。
 
@@ -24,7 +24,7 @@
 <a name="enumeration_syntax"></a>
 ## 枚举语法
 
-使用`enum`关键词并且把它们的整个定义放在一对大括号内：
+使用`enum`关键词来创建枚举并且把它们的整个定义放在一对大括号内：
 
 ```swift
 enum SomeEnumeration {
@@ -46,7 +46,7 @@ enum CompassPoint {
 一个枚举中被定义的值（例如 `North`，`South`，`East`和`West`）是枚举的***成员值***（或者***成员***）。`case`关键词表明新的一行成员值将被定义。
 
 > 注意：  
-> 不像 C 和 Objective-C 一样，Swift 的枚举成员在被创建时不会被赋予一个默认的整数值。在上面的`CompassPoints`例子中，`North`，`South`，`East`和`West`不是隐式的等于`0`，`1`，`2`和`3`。相反的，这些不同的枚举成员在`CompassPoint`的一种显示定义中拥有各自不同的值。  
+> 和 C 和 Objective-C 不同，Swift 的枚举成员在被创建时不会被赋予一个默认的整型值。在上面的`CompassPoints`例子中，`North`，`South`，`East`和`West`不会隐式地赋值为了`0`，`1`，`2`和`3`。相反的，这些不同的枚举成员在`CompassPoint`的一种显示定义中拥有各自不同的值。  
 
 多个成员值可以出现在同一行上，用逗号隔开：
 
@@ -62,13 +62,13 @@ enum Planet {
 var directionToHead = CompassPoint.West
 ```
 
-`directionToHead`的类型被推断当它被`CompassPoint`的一个可能值初始化。一旦`directionToHead`被声明为一个`CompassPoint`，你可以使用更短的点（.）语法将其设置为另一个`CompassPoint`的值：
+`directionToHead`的类型可以在它被`CompassPoint`的一个可能值初始化时推断出来。一旦`directionToHead`被声明为一个`CompassPoint`，你可以使用一个缩写语法（.）将其设置为另一个`CompassPoint`的值：
 
 ```swift
 directionToHead = .East
 ```
 
-`directionToHead`的类型已知时，当设定它的值时，你可以不再写类型名。使用显式类型的枚举值可以让代码具有更好的可读性。
+当`directionToHead`的类型已知时，再次为其赋值可以省略枚举名。使用显式类型的枚举值可以让代码具有更好的可读性。
 
 <a name="matching_enumeration_values_with_a_switch_statement"></a>
 ## 匹配枚举值和`Switch`语句

From 42b2f0d17bfb8efc8c49a9f8e56c6c72dcf4bbd6 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 16:01:04 +0800
Subject: [PATCH 020/228] =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=9E=9A=E4=B8=BE-?=
 =?UTF-8?q?=E5=8C=B9=E9=85=8D=E6=9E=9A=E4=B8=BE=E5=80=BC=E5=92=8CSwitch?=
 =?UTF-8?q?=E8=AF=AD=E5=8F=A5=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index f5f74e3a..7c8f60d5 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -73,7 +73,7 @@ directionToHead = .East
 <a name="matching_enumeration_values_with_a_switch_statement"></a>
 ## 匹配枚举值和`Switch`语句
 
-你可以匹配单个枚举值和`switch`语句：
+你可以使用`switch`语句匹配单个枚举值：
 
 ```swift
 directionToHead = .South
@@ -90,15 +90,15 @@ case .West:
 // 输出 "Watch out for penguins”
 ```
 
-你可以如此理解这段代码：
+你可以这样理解这段代码：
 
-“考虑`directionToHead`的值。当它等于`.North`，打印`“Lots of planets have a north”`。当它等于`.South`，打印`“Watch out for penguins”`。”
+“判断`directionToHead`的值。当它等于`.North`，打印`“Lots of planets have a north”`。当它等于`.South`，打印`“Watch out for penguins”`。”
 
-等等依次类推。
+等等以此类推。
 
-正如在[控制流（Control Flow）](05_Control_Flow.html)中介绍，当考虑一个枚举的成员们时，一个`switch`语句必须全面。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。全面性的要求确保了枚举成员不会被意外遗漏。
+正如在[控制流（Control Flow）](05_Control_Flow.html)中介绍的那样，在判断一个枚举类型的值时，`switch`语句必须穷举所有情况。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。强制性全部穷举的要求确保了枚举成员不会被意外遗漏。
 
-当不需要匹配每个枚举成员的时候，你可以提供一个默认`default`分支来涵盖所有未明确被提出的任何成员：
+当不需要匹配每个枚举成员的时候，你可以提供一个默认`default`分支来涵盖所有未明确被提出的枚举成员：
 
 ```swift
 let somePlanet = Planet.Earth

From 13ef8f1bd68840a46fb63ea0188817be10899fa6 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 16:28:11 +0800
Subject: [PATCH 021/228] =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=9E=9A=E4=B8=BE-?=
 =?UTF-8?q?=E7=9B=B8=E5=85=B3=E5=80=BC=EF=BC=88Associated=20Values?=
 =?UTF-8?q?=EF=BC=89=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 34 +++++++++++++++---------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 7c8f60d5..a9f72ce4 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -43,7 +43,7 @@ enum CompassPoint {
 }
 ```
 
-一个枚举中被定义的值（例如 `North`，`South`，`East`和`West`）是枚举的***成员值***（或者***成员***）。`case`关键词表明新的一行成员值将被定义。
+一个枚举中被定义的值（例如 `North`，`South`，`East`和`West`）是枚举的*成员值*（或者*成员*）。`case`关键词表明新的一行成员值将被定义。
 
 > 注意：  
 > 和 C 和 Objective-C 不同，Swift 的枚举成员在被创建时不会被赋予一个默认的整型值。在上面的`CompassPoints`例子中，`North`，`South`，`East`和`West`不会隐式地赋值为了`0`，`1`，`2`和`3`。相反的，这些不同的枚举成员在`CompassPoint`的一种显示定义中拥有各自不同的值。  
@@ -114,11 +114,11 @@ default:
 <a name="associated_values"></a>
 ## 相关值（Associated Values）
 
-上一小节的例子演示了一个枚举的成员是如何被定义（分类）的。你可以为`Planet.Earth`设置一个常量或则变量，并且在之后查看这个值。不管怎样，如果有时候能够把其他类型的相关值和成员值一起存储起来会很有用。这能让你存储成员值之外的自定义信息，并且当你每次在代码中使用该成员时允许这个信息产生变化。
+上一小节的例子演示了如何定义（分类）枚举的成员。你可以为`Planet.Earth`设置一个常量或者变量，并且在赋值之后查看这个值。不管怎样，如果有时候能够把其他类型的*相关值*和成员值一起存储起来会很有用。这能让你存储成员值之外的自定义信息，并且当你每次在代码中使用该成员时允许这个信息产生变化。
 
 你可以定义 Swift 的枚举存储任何类型的相关值，如果需要的话，每个成员的数据类型可以是各不相同的。枚举的这种特性跟其他语言中的可辨识联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。
 
-例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品。有些商品上标有 UPC-A 格式的一维码，它使用数字 0 到 9。每一个条形码都有一个代表“数字系统”的数字，该数字后接 10 个代表“标识符”的数字。最后一个数字是“检查”位，用来验证代码是否被正确扫描：
+例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品。有些商品上标有 UPC-A 格式的一维t条形码，它使用数字 0 到 9。每一个条形码都有一个代表“数字系统”的数字，该数字后接 5 个代表“生产代码”的数字，接下来是5位“产品代码”。最后一个数字是“检查”位，用来验证代码是否被正确扫描：
 
 <img width="252" height="120" alt="" src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/barcode_UPC_2x.png">
 
@@ -128,28 +128,28 @@ default:
 
 对于库存跟踪系统来说，能够把 UPC-A 码作为三个整型值的元组，和把 QR 码作为一个任何长度的字符串存储起来是方便的。
 
-在 Swift 中，用来定义两种商品条码的枚举是这样子的：
+在 Swift 中，使用如下方式定义两种商品条码的枚举：
 
 ```swift
 enum Barcode {
-  case UPCA(Int, Int, Int)
+  case UPCA(Int, Int, Int, Int)
   case QRCode(String)
 }
 ```
 
 以上代码可以这么理解：
 
-“定义一个名为`Barcode`的枚举类型，它可以是`UPCA`的一个相关值（`Int`，`Int`，`Int`），或者`QRCode`的一个字符串类型（`String`）相关值。”
+“定义一个名为`Barcode`的枚举类型，它可以是`UPCA`的一个相关值（`Int`，`Int`，`Int`，`Int`），或者是`QRCode`的一个字符串类型（`String`）相关值。”
 
 这个定义不提供任何`Int`或`String`的实际值，它只是定义了，当`Barcode`常量和变量等于`Barcode.UPCA`或`Barcode.QRCode`时，相关值的类型。
 
 然后可以使用任何一种条码类型创建新的条码，如：
 
 ```swift
-var productBarcode = Barcode.UPCA(8, 85909_51226, 3)
+var productBarcode = Barcode.UPCA(8, 85909, 51226, 3)
 ```
 
-以上例子创建了一个名为`productBarcode`的新变量，并且赋给它一个`Barcode.UPCA`的相关元组值`(8, 8590951226, 3)`。提供的“标识符”值在整数字中有一个下划线，使其便于阅读条形码。
+以上例子创建了一个名为`productBarcode`的变量，并且赋给它一个`Barcode.UPCA`的相关元组值`(8, 85909, 51226, 3)`。
 
 同一个商品可以被分配给一个不同类型的条形码，如：
 
@@ -163,24 +163,24 @@ productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
 
 ```swift
 switch productBarcode {
-case .UPCA(let numberSystem, let identifier, let check):
-    print("UPC-A with value of \(numberSystem), \(identifier), \(check).")
+case .UPCA(let numberSystem, let manufacturer, let product, let check):
+    print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
 case .QRCode(let productCode):
-    print("QR code with value of \(productCode).")
+    print("QR code: \(productCode).")
 }
-// 输出 "QR code with value of ABCDEFGHIJKLMNOP.”
+// 输出 "QR code: ABCDEFGHIJKLMNOP."
 ```
 
 如果一个枚举成员的所有相关值被提取为常量，或者它们全部被提取为变量，为了简洁，你可以只放置一个`var`或者`let`标注在成员名称前：
 
 ```swift
 switch productBarcode {
-case let .UPCA(numberSystem, identifier, check):
-    print("UPC-A with value of \(numberSystem), \(identifier), \(check).")
+case let .UPCA(numberSystem, manufacturer, product, check):
+    print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).")
 case let .QRCode(productCode):
-    print("QR code with value of \(productCode).")
+    print("QR code: \(productCode).")
 }
-// 输出 "QR code with value of ABCDEFGHIJKLMNOP."
+// 输出 "QR code: ABCDEFGHIJKLMNOP."
 ```
 
 <a name="raw_values"></a>
@@ -228,7 +228,7 @@ let possiblePlanet = Planet(rawValue: 7)
 // possiblePlanet is of type Planet? and equals Planet.Uranus
 ```
 
-然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个***可选***的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
+然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
 
 如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`：
 

From cb01035cd29a9dc3d3c7089def576d28e086d9e7 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 17:23:03 +0800
Subject: [PATCH 022/228] =?UTF-8?q?=E5=AE=8C=E6=88=90=20=E6=9E=9A=E4=B8=BE?=
 =?UTF-8?q?-=E5=8E=9F=E5=A7=8B=E5=80=BC(Raw=20Values)=E6=A0=A1=E5=AF=B9=20?=
 =?UTF-8?q?=E5=90=AB=E6=9C=89=E4=B8=80=E4=B8=AAtodo=20=E5=9F=BA=E6=9C=AC?=
 =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=9E=9A=E4=B8=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index a9f72ce4..0ba75399 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -19,7 +19,7 @@
 
 在 Swift 中，枚举类型是一等公民（first-class）。它们采用了很多传统上只被类（class）所支持的特征，例如计算型属性（computed properties），用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。
 
-欲了解更多相关功能，请参见[属性（Properties）](10_Properties.html)，[方法（Methods）](11_Methods.html)，[构造过程（Initialization）](14_Initialization.html)，[扩展（Extensions）](20_Extensions.html)和[协议（Protocols）](21_Protocols.html)。
+欲了解更多相关信息，请参见[属性（Properties）](10_Properties.html)，[方法（Methods）](11_Methods.html)，[构造过程（Initialization）](14_Initialization.html)，[扩展（Extensions）](20_Extensions.html)和[协议（Protocols）](21_Protocols.html)。
 
 <a name="enumeration_syntax"></a>
 ## 枚举语法
@@ -186,9 +186,9 @@ case let .QRCode(productCode):
 <a name="raw_values"></a>
 ## 原始值（Raw Values）
 
-在[Associated Values](#raw_values)小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的相关值。作为相关值的替代，枚举成员可以被默认值（称为原始值）预先填充，其中这些原始值具有相同的类型。
+在[Associated Values](#raw_values)小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的相关值。作为相关值的另一种选择，枚举成员可以被默认值（称为原始值）赋值，其中这些原始值具有相同的类型。
 
-这里是一个枚举成员存储原始 ASCII 值的例子：
+这里是一个枚举成员存储 ASCII 码的例子：
 
 ```swift
 enum ASCIIControlCharacter: Character {
@@ -198,11 +198,11 @@ enum ASCIIControlCharacter: Character {
 }
 ```
 
-在这里，称为`ASCIIControlCharacter`的枚举的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符[`Strings and Characters`](03_Strings_and_Characters.html)部分。
+在这里，`ASCIIControlCharacter`的枚举类型的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符[`Strings and Characters`](03_Strings_and_Characters.html)部分。
 
-注意，原始值和相关值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。相关值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。
+注意，原始值和相关值是不相同的。原始值是当你开始定义枚举的时候被预先赋予的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。相关值在你在创建一个基于枚举成员的常量或变量时才会被设置，并且每次当你创建的时候，它的值可以是不同的。
 
-原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。当整型值被用于原始值，如果其他枚举成员没有值时，它们会自动递增。
+原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。当使用整型值作为原始值时，如果其他枚举成员没有值，它们会自动递增。
 
 下面的枚举是对之前`Planet`这个枚举的一个细化，利用原始整型值来表示每个 planet 在太阳系中的顺序：
 
@@ -212,7 +212,7 @@ enum Planet: Int {
 }
 ```
 
-自动递增意味着`Planet.Venus`的原始值是`2`，依次类推。
+自动递增意味着`Planet.Venus`的原始值是`2`，以此类推。
 
 使用枚举成员的`rawValue`属性可以访问该枚举成员的原始值：
 
@@ -220,15 +220,22 @@ enum Planet: Int {
 let earthsOrder = Planet.Earth.rawValue
 // earthsOrder is 3
 ```
+### 使用原始值来初始化(Initializing from a Raw Value)
 
-通过参数为`rawValue`构造函数创建特定原始值的枚举。这个例子通过原始值`7`识别`Uranus`：
+如果你使用原始值的方式创建一个枚举类型，这个枚举将自动获得一个包含原始值参数(参数名为rawValue)的构造器并返回相应的枚举类型或者nil。你可以使用这个构造器来创建新的枚举成员。
+
+下面这个例子通过原始值`7`创建了`Uranus`枚举类型：
 
 ```swift
 let possiblePlanet = Planet(rawValue: 7)
 // possiblePlanet is of type Planet? and equals Planet.Uranus
 ```
 
-然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
+然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或称为“可选的`Planet`”。
+
+> 注意：  
+> 使用原始值构造器是可失败构造器，因为并不是所有的原始值都会返回一个对应的枚举成员。欲了解更多相关信息，请参见[可失败构造器（Failable Initializers）](留空)
+<!--TODO 链接未定义-->
 
 如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`：
 
@@ -247,4 +254,4 @@ if let somePlanet = Planet(rawValue: positionToFind) {
 // 输出 "There isn't a planet at position 9
 ```
 
-这个范例使用可选绑定（optional binding），通过原始值`9`试图访问一个行星。`if let somePlanet = Planet(rawValue: 9)`语句获得一个可选`Planet`，如果可选`Planet`可以被获得，把`somePlanet`设置成该可选`Planet`的内容。在这个范例中，无法检索到位置为`9`的行星，所以`else`分支被执行。
+这个范例使用可选绑定（optional binding），通过原始值`9`试图取得一个行星的引用。`if let somePlanet = Planet(rawValue: 9)`语句获得一个可选`Planet`，如果可选`Planet`可以被获得，把`somePlanet`设置成该可选`Planet`的内容。在这个范例中，无法检索到位置为`9`的行星，所以`else`分支被执行。

From 27f3736b2538b045f6be7667f51960531a1c91c4 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 18:25:08 +0800
Subject: [PATCH 023/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9todo=E6=A0=BC?=
 =?UTF-8?q?=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 0ba75399..c0d7c949 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -234,8 +234,8 @@ let possiblePlanet = Planet(rawValue: 7)
 然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或称为“可选的`Planet`”。
 
 > 注意：  
-> 使用原始值构造器是可失败构造器，因为并不是所有的原始值都会返回一个对应的枚举成员。欲了解更多相关信息，请参见[可失败构造器（Failable Initializers）](留空)
-<!--TODO 链接未定义-->
+> 使用原始值构造器是可失败构造器，因为并不是所有的原始值都会返回一个对应的枚举成员。欲了解更多相关信息，请参见[可失败构造器（Failable Initializers）](TODO)
+
 
 如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`：
 

From 74cff1433f7989959cc8b1421ac8fb26812d77a4 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 19:38:02 +0800
Subject: [PATCH 024/228] patterns_19:37_06/29/2015
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改了print函数的缩进格式
---
 source/chapter3/07_Patterns.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 4e9e8660..6fd48bf8 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -75,7 +75,7 @@ let point = (3, 2)
 switch point {
 // Bind x and y to the elements of point.
 case let (x, y):
-print("The point is at (\(x), \(y)).")
+    print("The point is at (\(x), \(y)).")
 }
 // prints "The point is at (3, 2).”
 ```
@@ -190,11 +190,11 @@ for case let number? in arrayOfOptinalInts {
 let point = (1, 2)
 switch point {
 case (0, 0):
-print("(0, 0) is at the origin.")
+    print("(0, 0) is at the origin.")
 case (-2...2, -2...2):
-print("(\(point.0), \(point.1)) is near the origin.")
+    print("(\(point.0), \(point.1)) is near the origin.")
 default:
-print("The point is at (\(point.0), \(point.1)).")
+    print("The point is at (\(point.0), \(point.1)).")
 }
 // prints "(1, 2) is near the origin.”
 ```
@@ -208,11 +208,11 @@ return pattern == "\(value)"
 }
 switch point {
 case ("0", "0"):
-print("(0, 0) is at the origin.")
+    print("(0, 0) is at the origin.")
 case ("-2...2", "-2...2"):
-print("(\(point.0), \(point.1)) is near the origin.")
+    print("(\(point.0), \(point.1)) is near the origin.")
 default:
-print("The point is at (\(point.0), \(point.1)).")
+    print("The point is at (\(point.0), \(point.1)).")
 }
 // prints "(1, 2) is near the origin.”
 ```

From edca3127080b9109087d11a83440c90eb43a03f2 Mon Sep 17 00:00:00 2001
From: justaway <bug_free@163.com>
Date: Mon, 29 Jun 2015 20:23:03 +0800
Subject: [PATCH 025/228] =?UTF-8?q?=E5=AE=8C=E6=88=90'=E8=AF=8D=E6=B3=95?=
 =?UTF-8?q?=E7=BB=93=E6=9E=84'=E7=9A=84=E6=A0=A1=E5=AF=B9=E5=92=8C?=
 =?UTF-8?q?=E6=9B=B4=E6=96=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter3/02_Lexical_Structure.md | 517 +++++++++++++-----------
 1 file changed, 279 insertions(+), 238 deletions(-)

diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index ca1ac6a9..0fd074a2 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -1,238 +1,279 @@
-> 翻译：[superkam](https://github.com/superkam)  
-> 校对：[numbbbbb](https://github.com/numbbbbb)
-
-# 词法结构
------------------
-
-本页包含内容：
-
-- [空白与注释（*Whitespace and Comments*）](#whitespace_and_comments)
-- [标识符（*Identifiers*）](#identifiers)
-- [关键字（*Keywords*）](#keywords)
-- [字面量（*Literals*）](#literals)
-- [运算符（*Operators*）](#operators)
-
-Swift 的“词法结构（*lexical structure*）”描述了如何在该语言中用字符序列构建合法标记，组成该语言中最底层的代码块，并在之后的章节中用于描述语言的其他部分。
-
-通常，标记在随后介绍的语法约束下，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配项（*longest match*）”，或者“最大适合”（*maximal munch*）。
-
-<a name="whitespace_and_comments"></a>
-## 空白与注释
-
-空白（*whitespace*）有两个用途：分隔源文件中的标记和区分运算符属于前缀还是后缀，（参见 [运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_871)）在其他情况下则会被忽略。以下的字符会被当作空白：空格（*space*）（U+0020）、换行符（*line feed*）（U+000A）、回车符（*carriage return*）（U+000D）、水平 tab（*horizontal tab*）（U+0009）、垂直 tab（*vertical tab*）（U+000B）、换页符（*form feed*）（U+000C）以及空（*null*）（U+0000）。
-
-注释（*comments*）被编译器当作空白处理。单行注释由 `//` 开始直到该行结束。多行注释由 `/*` 开始，以 `*/` 结束。可以嵌套注释，但注意注释标记必须匹配。
-
-<a name="identifiers"></a>
-## 标识符
-
-标识符（*identifiers*）可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 `_`、基本多语言面（*Basic Multilingual Plane*）中的 Unicode 非组合字符以及基本多语言面以外的非专用区（*Private Use Area*）字符。首字符之后，标识符允许使用数字和 Unicode 字符组合。
-
-使用保留字（*reserved word*）作为标识符，需要在其前后增加反引号 <code>\`</code>。例如，<code>class</code> 不是合法的标识符，但可以使用 <code>\`class\`</code>。反引号不属于标识符的一部分，<code>\`x\`</code> 和 `x` 表示同一标识符。
-
-闭包（*closure*）中如果没有明确指定参数名称，参数将被隐式命名为 <code>$0</code>、<code>$1</code>、<code>$2</code>... 这些命名在闭包作用域内是合法的标识符。
-
-> 标识符语法  
-> *标识符* → [*标识符头(Head)*](LexicalStructure.html#identifier_head) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_  
-> *标识符* → **`** [*标识符头(Head)*](LexicalStructure.html#identifier_head) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_ **`**  
-> *标识符* → [*隐式参数名*](LexicalStructure.html#implicit_parameter_name)  
-> *标识符列表* → [*标识符*](LexicalStructure.html#identifier) | [*标识符*](LexicalStructure.html#identifier) **,** [*标识符列表*](LexicalStructure.html#identifier_list)  
-> *标识符头(Head)* → Upper- or lowercase letter A through Z  
-> *标识符头(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA  
-> *标识符头(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF  
-> *标识符头(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF  
-> *标识符头(Head)* → U+1E00–U+1FFF  
-> *标识符头(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F  
-> *标识符头(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793  
-> *标识符头(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF  
-> *标识符头(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF  
-> *标识符头(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44  
-> *标识符头(Head)* → U+FE47–U+FFFD  
-> *标识符头(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD  
-> *标识符头(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD  
-> *标识符头(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD  
-> *标识符头(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD  
-> *标识符字符* → 数值 0 到 9  
-> *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F  
-> *标识符字符* → [*标识符头(Head)*](LexicalStructure.html#identifier_head)  
-> *标识符字符列表* → [*标识符字符*](LexicalStructure.html#identifier_character) [*标识符字符列表*](LexicalStructure.html#identifier_characters) _可选_  
-> *隐式参数名* → **$** [*十进制数字列表*](LexicalStructure.html#decimal_digits)  
-
-<a name="keywords"></a>
-## 关键字
-
-被保留的关键字（*keywords*）不允许用作标识符，除非被反引号转义，参见 [标识符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_796)。
-
-* **用作声明的关键字：** *class*、*deinit*、*enum*、*extension*、*func*、*import*、*init*、*let*、*protocol*、*static*、*struct*、*subscript*、*typealias*、*var*
-* **用作语句的关键字：** *break*、*case*、*continue*、*default*、*do*、*else*、*fallthrough*、*if*、*in*、*for*、*return*、*switch*、*where*、*while*
-* **用作表达和类型的关键字：** *as*、*dynamicType*、*is*、*new*、*super*、*self*、*Self*、*Type*、*\_\_COLUMN\_\_*、*\_\_FILE\_\_*、*\_\_FUNCTION\_\_*、*\_\_LINE\_\_*
-* **特定上下文中被保留的关键字：** *associativity*、*didSet*、*get*、*infix*、*inout*、*left*、*mutating*、*none*、*nonmutating*、*operator*、*override*、*postfix*、
-  *precedence*、*prefix*、*right*、*set*、*unowned*、*unowned(safe)*、*unowned(unsafe)*、*weak*、*willSet*，这些关键字在特定上下文之外可以被用于标识符。
-
-<a name="literals"></a>
-## 字面量
-
-字面值表示整型、浮点型数字或文本类型的值，举例如下：
-
-```swift
-42                 // 整型字面量
-3.14159            // 浮点型字面量
-"Hello, world!"    // 文本型字面量
-```
-
-> 字面量语法  
-> *字面量* → [*整型字面量*](LexicalStructure.html#integer_literal) | [*浮点数字面量*](LexicalStructure.html#floating_point_literal) | [*字符串字面量*](LexicalStructure.html#string_literal)  
-
-### 整型字面量
-
-整型字面量（*integer literals*）表示未指定精度整型数的值。整型字面量默认用十进制表示，可以加前缀来指定其他的进制，二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。
-
-十进制字面量包含数字 `0` 至 `9`。二进制字面量只包含 `0` 或 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F` （大小写均可）。
-
-负整数的字面量在数字前加减号 `-`，比如 `-42`。
-
-允许使用下划线 `_` 来增加数字的可读性，下划线不会影响字面量的值。整型字面量也可以在数字前加 `0`，同样不会影响字面量的值。
-
-```swift
-1000_000     // 等于 1000000
-005          // 等于 5
-```
-
-除非特殊指定，整型字面量的默认类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_411)。
-
-> 整型字面量语法  
-> *整型字面量* → [*二进制字面量*](LexicalStructure.html#binary_literal)  
-> *整型字面量* → [*八进制字面量*](LexicalStructure.html#octal_literal)  
-> *整型字面量* → [*十进制字面量*](LexicalStructure.html#decimal_literal)  
-> *整型字面量* → [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal)  
-> *二进制字面量* → **0b** [*二进制数字*](LexicalStructure.html#binary_digit) [*二进制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可选_  
-> *二进制数字* → 数值 0 到 1  
-> *二进制字面量字符* → [*二进制数字*](LexicalStructure.html#binary_digit) | **_**  
-> *二进制字面量字符列表* → [*二进制字面量字符*](LexicalStructure.html#binary_literal_character) [*二进制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可选_  
-> *八进制字面量* → **0o** [*八进字数字*](LexicalStructure.html#octal_digit) [*八进制字符列表*](LexicalStructure.html#octal_literal_characters) _可选_  
-> *八进字数字* → 数值 0 到 7  
-> *八进制字符* → [*八进字数字*](LexicalStructure.html#octal_digit) | **_**  
-> *八进制字符列表* → [*八进制字符*](LexicalStructure.html#octal_literal_character) [*八进制字符列表*](LexicalStructure.html#octal_literal_characters) _可选_  
-> *十进制字面量* → [*十进制数字*](LexicalStructure.html#decimal_digit) [*十进制字符列表*](LexicalStructure.html#decimal_literal_characters) _可选_  
-> *十进制数字* → 数值 0 到 9  
-> *十进制数字列表* → [*十进制数字*](LexicalStructure.html#decimal_digit) [*十进制数字列表*](LexicalStructure.html#decimal_digits) _可选_  
-> *十进制字符* → [*十进制数字*](LexicalStructure.html#decimal_digit) | **_**  
-> *十进制字符列表* → [*十进制字符*](LexicalStructure.html#decimal_literal_character) [*十进制字符列表*](LexicalStructure.html#decimal_literal_characters) _可选_  
-> *十六进制字面量* → **0x** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可选_  
-> *十六进制数字* → 数值 0 到 9, a through f, or A through F  
-> *十六进制字符* → [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) | **_**  
-> *十六进制字面量字符列表* → [*十六进制字符*](LexicalStructure.html#hexadecimal_literal_character) [*十六进制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可选_  
-
-### 浮点型字面量
-
-浮点型字面量（*floating-point literals*）表示未指定精度浮点数的值。
-
-浮点型字面量默认用十进制表示（无前缀），也可以用十六进制表示（加前缀 `0x`）。
-
-十进制浮点型字面量（*decimal floating-point literals*）由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点 `.` 后跟十进制数字串组成。指数部分由大写或小写字母 `e` 后跟十进制数字串组成，这串数字表示 `e` 之前的数量乘以 10 的几次方。例如：`1.25e2` 表示 `1.25 ⨉ 10^2`，也就是 `125.0`；同样，`1.25e－2` 表示 `1.25 ⨉ 10^－2`，也就是 `0.0125`。
-
-十六进制浮点型字面量（*hexadecimal floating-point literals*）由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 `15 ⨉ 2^2`，也就是 `60`；同样，`0xFp-2` 表示 `15 ⨉ 2^-2`，也就是 `3.75`。
-
-与整型字面量不同，负的浮点型字面量由一元运算符减号 `-` 和浮点型字面量组成，例如 `-42.0`。这代表一个表达式，而不是一个浮点整型字面量。
-
-允许使用下划线 `_` 来增强可读性，下划线不会影响字面量的值。浮点型字面量也可以在数字前加 `0`，同样不会影响字面量的值。
-
-```swift
-10_000.56     // 等于 10000.56
-005000.76     // 等于 5000.76
-```
-
-除非特殊指定，浮点型字面量的默认类型为 Swift 标准库类型中的 `Double`，表示64位浮点数。Swift 标准库也定义 `Float` 类型，表示32位浮点数。
-
-> 浮点型字面量语法  
-> *浮点数字面量* → [*十进制字面量*](LexicalStructure.html#decimal_literal) [*十进制分数*](LexicalStructure.html#decimal_fraction) _可选_ [*十进制指数*](LexicalStructure.html#decimal_exponent) _可选_  
-> *浮点数字面量* → [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) [*十六进制分数*](LexicalStructure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](LexicalStructure.html#hexadecimal_exponent)  
-> *十进制分数* → **.** [*十进制字面量*](LexicalStructure.html#decimal_literal)  
-> *十进制指数* → [*浮点数e*](LexicalStructure.html#floating_point_e) [*正负号*](LexicalStructure.html#sign) _可选_ [*十进制字面量*](LexicalStructure.html#decimal_literal)  
-> *十六进制分数* → **.** [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal) _可选_  
-> *十六进制指数* → [*浮点数p*](LexicalStructure.html#floating_point_p) [*正负号*](LexicalStructure.html#sign) _可选_ [*十六进制字面量*](LexicalStructure.html#hexadecimal_literal)  
-> *浮点数e* → **e** | **E**  
-> *浮点数p* → **p** | **P**  
-> *正负号* → **+** | **-**  
-
-### 文本型字面量
-
-文本型字面量（*string literal*）由双引号中的字符串组成，形式如下：
-
-```swift
-"characters"
-```
-
-文本型字面量中不能包含未转义的双引号 `"`、未转义的反斜线`\`、回车符（*carriage return*）或换行符（*line feed*）。
-
-可以在文本型字面量中使用的转义特殊符号如下：
-
-* 空字符（Null Character）`\0`
-* 反斜线（Backslash）`\\`
-* 水平 Tab （Horizontal Tab）`\t`
-* 换行符（Line Feed）`\n`
-* 回车符（Carriage Return）`\r`
-* 双引号（Double Quote）`\"`
-* 单引号（Single Quote）`\'`
-
-字符也可以用以下方式表示：
-
-* `\x` 后跟两位十六进制数字
-* `\u` 后跟四位十六进制数字
-* `\U` 后跟八位十六进制数字
-
-后跟的数字表示一个 Unicode 码点。
-
-文本型字面量允许在反斜线小括号 `\()` 中插入表达式的值。插入表达式（*interpolated expression*）不能包含未转义的双引号 `"`、反斜线 `\`、回车符或者换行符。表达式值的类型必须在 *String* 类中有对应的初始化方法。
-
-例如，以下所有文本型字面量的值相同：
-
-```swift
-"1 2 3"
-"1 2 \(3)"
-"1 2 \(1 + 2)"
-var x = 3; "1 2 \(x)"
-```
-
-文本型字面量的默认类型为 `String`。组成字符串的字符类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368)。
-
-> 字符型字面量语法  
-> *字符串字面量* → **"** [*引用文本*](LexicalStructure.html#quoted_text) **"**  
-> *引用文本* → [*引用文本条目*](LexicalStructure.html#quoted_text_item) [*引用文本*](LexicalStructure.html#quoted_text) _可选_  
-> *引用文本条目* → [*转义字符*](LexicalStructure.html#escaped_character)  
-> *引用文本条目* → **\(** [*表达式*](..\chapter3\04_Expressions.html#expression) **)**  
-> *引用文本条目* → 除了"­, \­, U+000A, or U+000D的所有Unicode的字符  
-> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**  
-> *转义字符* → **\x** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit)  
-> *转义字符* → **\u** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit)  
-> *转义字符* → **\U** [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit) [*十六进制数字*](LexicalStructure.html#hexadecimal_digit)  
-
-<a name="operators"></a>
-## 运算符
-
-Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-XID_70) 和 [高级运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_28) 中进行了阐述。这里将描述哪些字符能用作运算符。
-
-运算符由一个或多个以下字符组成：
-`/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`~`、`.`。也就是说，标记 `=`, `->`、`//`、`/*`、`*/`、`.` 以及一元前缀运算符 `&` 属于保留字，这些标记不能被重写或用于自定义运算符。
-
-运算符两侧的空白被用来区分该运算符是否为前缀运算符（*prefix operator*）、后缀运算符（*postfix operator*）或二元运算符（*binary operator*）。规则总结如下：
-
-* 如果运算符两侧都有空白或两侧都无空白，将被看作二元运算符。例如：`a+b` 和 `a + b` 中的运算符 `+` 被看作二元运算符。
-* 如果运算符只有左侧空白，将被看作前缀一元运算符。例如 `a ++b` 中的 `++` 被看作前缀一元运算符。
-* 如果运算符只有右侧空白，将被看作后缀一元运算符。例如 `a++ b` 中的 `++` 被看作后缀一元运算符。
-* 如果运算符左侧没有空白并紧跟 `.`，将被看作后缀一元运算符。例如 `a++.b` 中的 `++` 被看作后缀一元运算符（同理， `a++ . b` 中的 `++` 是后缀一元运算符而 `a ++ .b` 中的 `++` 不是）.
-
-鉴于这些规则，运算符前的字符 `(`、`[` 和 `{` ；运算符后的字符 `)`、`]` 和 `}` 以及字符 `,`、`;` 和 `:` 都将用于空白检测。
-
-以上规则需注意一点，如果运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选类型（*optional type*）修饰，左侧必须无空白。如果用于条件运算符 `? :`，必须两侧都有空白。
-
-在特定构成中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 被看作单字符标记，而不会被误解为移位运算符 `>>`。
-
-要学习如何自定义新的运算符，请参考 [自定义操作符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48) 和 [运算符声明](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644)。学习如何重写现有运算符，请参考 [运算符方法](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43)。
-
-> 运算符语法语法  
-> *运算符* → [*运算符字符*](LexicalStructure.html#operator_character) [*运算符*](LexicalStructure.html#operator) _可选_  
-> *运算符字符* → **/** | **=** | **-** | **+** | **!** | **&#42;** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.**  
-> *二元运算符* → [*运算符*](LexicalStructure.html#operator)  
-> *前置运算符* → [*运算符*](LexicalStructure.html#operator)  
-> *后置运算符* → [*运算符*](LexicalStructure.html#operator)  
+> 翻译：[superkam](https://github.com/superkam)  
+> 校对：[numbbbbb](https://github.com/numbbbbb)
+
+# 词法结构
+-----------------
+
+本页包含内容：
+
+- [空白与注释（*Whitespace and Comments*）](#whitespace_and_comments)
+- [标识符（*Identifiers*）](#identifiers)
+- [关键字（*Keywords*）](#keywords)
+- [字面量（*Literals*）](#literals)
+- [运算符（*Operators*）](#operators)
+
+Swift 的“词法结构（*lexical structure*）”描述了能构成该语言中合法标记（*tokens*）的字符序列。这些合法标记组成了语言中最底层的构建基块，并在之后的章节中用于描述语言的其他部分。
+
+通常情况下，标记是在随后将介绍的语法约束下，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配项（*longest match*）”，或者“最大适合”（*maximal munch*）。
+
+<a id="whitespace_and_comments"></a>
+## 空白与注释
+
+空白（*whitespace*）有两个用途：分隔源文件中的标记和帮助区分运算符属于前缀还是后缀（参见 [运算符](#operators)），在其他情况下则会被忽略。以下的字符会被当作空白：空格（*space*）（U+0020）、换行符（*line feed*）（U+000A）、回车符（*carriage return*）（U+000D）、水平制表符（*horizontal tab*）（U+0009）、垂直制表符（*vertical tab*）（U+000B）、换页符（*form feed*）（U+000C）以及空（*null*）（U+0000）。
+
+注释（*comments*）被编译器当作空白处理。单行注释由 `//` 开始直至遇到换行符（*line feed*）（U+000A）或者回车符（*carriage return*）（U+000D）。多行注释由 `/*` 开始，以 `*/` 结束。注释允许嵌套，但注释标记必须匹配。
+
+<a id="identifiers"></a>
+## 标识符
+
+标识符（*identifiers*）可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 `_`、基本多文种平面（*Basic Multilingual Plane*）中的 Unicode 非组合字符以及基本多文种平面以外的非专用区（*Private Use Area*）字符。首字符之后，允许使用数字和 Unicode 字符组合。
+
+使用保留字（*reserved word*）作为标识符，需要在其前后增加反引号 `` `。例如，`class` 不是合法的标识符，但可以使用 <code>\`class\`</code>。反引号不属于标识符的一部分，<code>\`x\`</code> 和 `x` 表示同一标识符。
+
+闭包（*closure*）中如果没有明确指定参数名称，参数将被隐式命名为 `$0`、`$1`、`$2`等等。 这些命名在闭包作用域范围内是合法的标识符。
+
+> 标识符语法  
+<a id="identifier"></a>
+> *标识符* → [*头部标识符*](#identifier_head) [*标识符字符组*](#identifier_characters)<sub>可选</sub> 
+> *标识符* → \`[*头部标识符*](#identifier_head) [*标识符字符组*](#identifier_characters)<sub>可选</sub>\`  
+> *标识符* → [*隐式参数名*](#implicit_parameter_name)  
+> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier_list) 
+<a id="identifier_head"></a>
+> *头部标识符* → 大写或小写字母 A - Z  
+> *头部标识符* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA  
+> *头部标识符* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF  
+> *头部标识符* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF  
+> *头部标识符* → U+1E00–U+1FFF  
+> *头部标识符* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F  
+> *头部标识符* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793  
+> *头部标识符* → U+2C00–U+2DFF or U+2E80–U+2FFF  
+> *头部标识符* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF  
+> *头部标识符* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44  
+> *头部标识符* → U+FE47–U+FFFD  
+> *头部标识符* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD  
+> *头部标识符* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD  
+> *头部标识符* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD  
+> *头部标识符* → U+D0000–U+DFFFD or U+E0000–U+EFFFD  
+> *标识符字符* → 数值 0 - 9  
+> *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F  
+> *标识符字符* → [*头部标识符*](#identifier_head)
+<a id="identifier_characters"></a>
+> *标识符字符组* → [*标识符字符*](#identifier_character) [*标识符字符列表*](#identifier_characters)<sub>可选</sub>  
+<a id="implicit_parameter_name></a>
+> *隐式参数名* → **$** [*十进制数字列表*](#decimal_digits)  
+
+<a id="keywords"></a>
+## 关键字和符号
+
+下面这些被保留的关键字（*keywords*）不允许用作标识符，除非被反引号转义，具体描述请参考 [标识符](#identifiers)。
+
+* **用在声明中的关键字：** *class*、*deinit*、*enum*、*extension*、*func*、*import*、*init*、*let*、*protocol*、*static*、*struct*、*subscript*、*typealias*、*var*
+* **用在语句中的关键字：** *break*、*case*、*continue*、*default*、*do*、*else*、*fallthrough*、*if*、*in*、*for*、*return*、*switch*、*where*、*while*
+* **用在表达式和类型中的关键字：** *as*、*dynamicType*、*is*、*new*、*super*、*self*、*Self*、*Type*、*\_\_COLUMN\_\_*、*\_\_FILE\_\_*、*\_\_FUNCTION\_\_*、*\_\_LINE\_\_*
+* **用在模式中的关键字：** *\_*
+* **特定上下文中被保留的关键字：** *associativity*、*didSet*、*get*、*infix*、*inout*、*left*、*mutating*、*none*、*nonmutating*、*operator*、*override*、*postfix*、*precedence*、*prefix*、*right*、*set*、*unowned*、*unowned(safe)*、*unowned(unsafe)*、*weak*、*willSet*，这些关键字在特定上下文之外可以被用于标识符。
+  
+以下标记被当作保留符号，不能用于自定义操作符：`(`、`)`、`{`、`}`、`[`、`]`、`.`、`,`、`:`、`;`、`=`、`@`、`#`、`&（作为前缀操作符）`、`->`、`` `、`?` 和 `!(作为后缀操作符)`。
+
+<a id="literals"></a>
+## 字面量
+
+字面量是用来表示源码中某种特定类型的值，比如一个数字或字符串。
+
+下面是字面量的一些示例：
+
+```swift
+42                 // 整型字面量
+3.14159            // 浮点型字面量
+"Hello, world!"    // 字符串型字面量
+true			   // 布尔型字面量
+```
+
+字面量本身并不包含类型信息。事实上，一个字面量会被解析为拥有无限的精度，然后 Swift 的类型推导会尝试去推导出这个字面量的类型。比如，在 `let x: Int8 = 42` 这个声明中，Swift 使用了显式类型注解（`: Int8`）来推导出 `42` 这个整型字面量的类型是 `Int8`。如果没有可用的类型信息， Swift 则会从标准库中定义的字面量类型中推导出一个默认的类型。整型字面量的默认类型是 `Int`，浮点型字面量的默认类型是 `Double`，字符串型字面量的默认类型是 `String`，布尔型字面量的默认类型是 `Bool`。比如，在 `let str = "Hello, world"` 这个声明中，字符串 `"Hello, world"`的默认推导类型就是 `String`。
+
+当为一个字面量值指定了类型注解的时候，这个注解的类型必须能通过这个字面量值实例化后得到。也就是说，这个类型必须遵守这些 Swift 标准库协议中的一个：整型字面量的`IntegerLiteralConvertible`协议、符点型字面量的`FloatingPointLiteralConvertible`协议、字符串字面量的`StringLiteralConvertible`协议以及布尔型字面量的`BooleanLiteralConvertible`协议。比如，`Int8` 遵守了 `IntegerLiteralConvertible`协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整型字面量 `42` 的类型注解。
+
+> 字面量语法  
+> *字面量* → [*数字型字面量*](#numeric_literal) | [*字符串型字面量*](#string_literal) | [*布尔型字面量*](#boolean_literal) | [*nil型字面量*](#nil_literal)
+<a id="numeric_literal"></a>
+> *数字型字面量* → -<sub>可选</sub>[*整型字面量*](#integer_literal) | -<sub>可选</sub>[*符点型字面量*](#floating_point_literal)
+> *布尔型字面量* → **true** | **false**
+> *nil型字面量* → **nil**
+
+### 整型字面量
+
+整型字面量（*integer literals*）表示未指定精度整型数的值。整型字面量默认用十进制表示，可以加前缀来指定其他的进制，二进制字面量加 `0b`，八进制字面量加 `0o`，十六进制字面量加 `0x`。
+
+十进制字面量包含数字 `0` 至 `9`。二进制字面量只包含 `0` 或 `1`，八进制字面量包含数字 `0` 至 `7`，十六进制字面量包含数字 `0` 至 `9` 以及字母 `A` 至 `F` （大小写均可）。
+
+负整数的字面量在整型字面量前加减号 `-`，比如 `-42`。
+
+整型字面面可以使用下划线 `_` 来增加数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，并不会影响字面量的值。
+
+除非特别指定，整型字面量的默认推导类型为 Swift 标准库类型中的 `Int`。Swift 标准库还定义了其他不同长度以及是否带符号的整数类型，请参考 [整数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-ID323)。
+
+> 整型字面量语法  
+> *整型字面量* → [*二进制字面量*](#binary_literal)  
+> *整型字面量* → [*八进制字面量*](#octal_literal)  
+> *整型字面量* → [*十进制字面量*](#decimal_literal)  
+> *整型字面量* → [*十六进制字面量*](#hexadecimal_literal)  
+<a id="binary_literal"></a>
+> *二进制字面量* → **0b** [*二进制数字*](#binary_digit) [*二进制字面量字符组*](#binary_literal_characters)<sub>可选</sub>  
+> *二进制数字* → 数值 0 到 1  
+> *二进制字面量字符* → [*二进制数字*](#binary_digit) | _
+> *二进制字面量字符组* → [*二进制字面量字符*](#binary_literal_character) [*二进制字面量字符组*](#binary_literal_characters)<sub>可选</sub>  
+<a id="octal_literal></a>
+> *八进制字面量* → **0o** [*八进字数字*](#octal_digit) [*八进制字符列表*](#octal_literal_characters)<sub>可选</sub>
+> *八进字数字* → 数值 0 到 7  
+> *八进制字符* → [*八进字数字*](#octal_digit) | _
+> *八进制字符组* → [*八进制字符*](#octal_literal_character) [*八进制字符列表*](#octal_literal_characters)<sub>可选</sub>
+<a id="decimal_literal"></a>
+> *十进制字面量* → [*十进制数字*](#decimal_digit) [*十进制字符组*](#decimal_literal_characters)<sub>可选</sub>
+> *十进制数字* → 数值 0 到 9  
+> *十进制数字列表* → [*十进制数字*](#decimal_digit) [*十进制数字列表*](#decimal_digits)<sub>可选</sub>  
+> *十进制字符* → [*十进制数字*](#decimal_digit) | _ 
+> *十进制字符列表* → [*十进制字符*](#decimal_literal_character) [*十进制字符列表*](#decimal_literal_characters)<sub>可选</sub> 
+<a id="hexadecimal_literal"></a>
+> *十六进制字面量* → **0x** [*十六进制数字*](#hexadecimal_digit) [*十六进制字面量字符列表*](#hexadecimal_literal_characters)<sub>可选</sub>  
+> *十六进制数字* → 数值 0 到 9, 字母 a 到 f, 或 A 到 F  
+> *十六进制字符* → [*十六进制数字*](#hexadecimal_digit) | _ 
+> *十六进制字面量字符列表* → [*十六进制字符*](#hexadecimal_literal_character) [*十六进制字面量字符列表*](#hexadecimal_literal_characters)<sub>可选</sub>  
+
+### 浮点型字面量
+
+浮点型字面量（*floating-point literals*）表示未指定精度浮点数的值。
+
+浮点型字面量默认用十进制表示（无前缀），也可以用十六进制表示（加前缀 `0x`）。
+
+十进制浮点型字面量（*decimal floating-point literals*）由十进制数字串后跟小数部分或指数部分（或两者皆有）组成。十进制小数部分由小数点 `.` 后跟十进制数字串组成。指数部分由大写或小写字母 `e` 为前缀后跟十进制数字串组成，这串数字表示 `e` 之前的数量乘以 10 的几次方。例如：`1.25e2` 表示 `1.25 ⨉ 10^2`，也就是 `125.0`；同样，`1.25e－2` 表示 `1.25 ⨉ 10^－2`，也就是 `0.0125`。
+
+十六进制浮点型字面量（*hexadecimal floating-point literals*）由前缀 `0x` 后跟可选的十六进制小数部分以及十六进制指数部分组成。十六进制小数部分由小数点后跟十六进制数字串组成。指数部分由大写或小写字母 `p` 为前缀后跟十进制数字串组成，这串数字表示 `p` 之前的数量乘以 2 的几次方。例如：`0xFp2` 表示 `15 ⨉ 2^2`，也就是 `60`；同样，`0xFp-2` 表示 `15 ⨉ 2^-2`，也就是 `3.75`。
+
+负的浮点型字面量由一元运算符减号 `-` 和浮点型字面量组成，例如 `-42.5`。
+
+浮点型字面量允许使用下划线 `_` 来增强数字的可读性，下划线会被系统忽略，因此不会影响字面量的值。同样地，也可以在数字前加 `0`，并不会影响字面量的值。
+
+除非特别指定，浮点型字面量的默认推导类型为 Swift 标准库类型中的 `Double`，表示64位浮点数。Swift 标准库也定义了 `Float` 类型，表示32位浮点数。
+
+> 浮点型字面量语法  
+> *浮点数字面量* → [*十进制字面量*](#decimal_literal) [*十进制分数*](#decimal_fraction)<sub>可选</sub> [*十进制指数*](#decimal_exponent)<sub>可选</sub>  
+> *浮点数字面量* → [*十六进制字面量*](#hexadecimal_literal) [*十六进制分数*](#hexadecimal_fraction)<sub>可选</sub> [*十六进制指数*](#hexadecimal_exponent)
+<a id="decimal_fraction"></a>
+> *十进制分数* → **.** [*十进制字面量*](#decimal_literal)  
+> *十进制指数* → [*浮点数e*](#floating_point_e) [*正负号*](#sign)<sub>可选</sub> [*十进制字面量*](#decimal_literal)  
+<a id="hexadecimal_literal"></a>
+> *十六进制分数* → **.** [*十六进制数字*](#hexadecimal_digit) [*十六进制字面量字符列表*](#hexadecimal_literal_characters)<sub>可选</sub>  
+> *十六进制指数* → [*浮点数p*](#floating_point_p) [*正负号*](#sign)<sub>可选</sub> [*十进制字面量*](#decimal_literal)  
+<a id="floating_point_e"></a>
+> *浮点数e* → **e** | **E**  
+> *浮点数p* → **p** | **P**  
+> *正负号* → **+** | **-**  
+
+
+### 字符串型字面量
+
+字符串型字面量（*string literal*）由被包在双引号中的一串字符组成，形式如下：
+
+```
+"characters"
+```
+
+字符串型字面量中不能包含未转义的双引号 （`"`）、未转义的反斜线（`\`）、回车符（*carriage return*）或换行符（*line feed*）。
+
+可以在字符串字面量中使用的转义特殊符号如下：
+
+* 空字符（Null Character）`\0`
+* 反斜线（Backslash）`\\`
+* 水平制表符（Horizontal Tab）`\t`
+* 换行符（Line Feed）`\n`
+* 回车符（Carriage Return）`\r`
+* 双引号（Double Quote）`\"`
+* 单引号（Single Quote）`\'`
+* Unicode标量 `\u{n}`，n为一到八位的十六进制数字
+
+字符串字面量允许在反斜杠小括号 `\()` 中插入表达式的值。插入表达式（*interpolated expression*）不能包含未转义的双引号 `"`、未转义的反斜线 `\`、回车符或者换行符。表达式结果的类型必须在 *String* 类中有对应的初始化方法。
+
+例如，以下所有字符串字面量的值都是相同的：
+
+```
+"1 2 3"
+"1 2 \(3)"
+"1 2 \(1 + 2)"
+let x = 3; "1 2 \(x)"
+```
+
+字符串字面量的默认推导类型为 `String`。组成字符串的字符默认推导类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368)。
+
+> 字符型字面量语法  
+> *字符串字面量* → **"** [*引用文本*](#quoted_text)<sub>可选</sub> **"**  
+<a id="quoted_text"></a>
+> *引用文本* → [*引用文本条目*](#quoted_text_item) [*引用文本*](#quoted_text) <sub>可选</sub>  
+> *引用文本条目* → [*转义字符*](#escaped_character)  
+> *引用文本条目* → **\(** [*表达式*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/doc/uid/TP40014097-CH32-ID383) **)**  
+> *引用文本条目* → **除了"­, \­, U+000A, 或者 U+000D的所有Unicode的字符**  
+> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'** 
+> *转义字符* → **\u {** [*unicode标量数字*](#unicode_scalar_digits) **}** 
+> *unicode标量数字* → 一到八位的十六进制数字
+
+<a id="operators"></a>
+## 运算符
+
+Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-XID_70) 和 [高级运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_28) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。
+
+自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、 `-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`, 或者后面语法中规定的任一个 Unicode 字符开始。在第一个字符之后，允许使用组合型 Unicode 字符。也可以使用两个或者多个的点号来自定义运算符（比如, `....`）。虽然可以自定义包含问号`?`的运算符，但是这个运算符不能只包含单独的一个问号。
+
+	注意：
+	以下这些标记 =, ->, //, /*, */, ., <（前缀运算符）, &, and ?, ?（中缀运算符）, >（后缀运算符）, ! 以及 ? 是被系统保留的。这些标记不能被重载，也不能用于自定义操作符。
+
+运算符两侧的空白被用来区分该运算符是否为前缀运算符（*prefix operator*）、后缀运算符（*postfix operator*）或二元运算符（*binary operator*）。规则总结如下：
+
+* 如果运算符两侧都有空白或两侧都无空白，将被看作二元运算符。例如：`a+b` 和 `a + b` 中的运算符 `+` 被看作二元运算符。
+* 如果运算符只有左侧空白，将被看作前缀一元运算符。例如 `a ++b` 中的 `++` 被看作前缀一元运算符。
+* 如果运算符只有右侧空白，将被看作后缀一元运算符。例如 `a++ b` 中的 `++` 被看作后缀一元运算符。
+* 如果运算符左侧没有空白并紧跟 `.`，将被看作后缀一元运算符。例如 `a++.b` 中的 `++` 被看作后缀一元运算符（即上式被视为 `a++ .b` 而非 `a ++ .b`）。
+
+鉴于这些规则，运算符前的字符 `(`、`[` 和 `{` ；运算符后的字符 `)`、`]` 和 `}` 以及字符 `,`、`;` 和 `:` 都被视为空白。
+
+以上规则需注意一点，如果预定义运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选链（*optional-chaining*）操作符，左侧必须无空白。如果用于条件运算符 `? :`，必须两侧都有空白。
+
+在某些特定的构造中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的标记，因而不会被误解析为 `>>` 运算符的一部分。
+
+要学习如何自定义运算符，请参考 [自定义操作符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48) 和 [运算符声明](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644)。要学习如何重载运算符，请参考 [运算符方法](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43)。
+
+> 运算符语法语法  
+> *运算符* → [*头部运算符*](#operator_head) [*运算符字符组*](#operator_characters)<sub>可选</sub>  
+> *运算符* → [*头部点运算符*](#dot_operator_head) [*点运算符字符组*](#dot_operator_characters)<sub>可选</sub>
+<a id="operator_head"></a>
+> *头部运算符* → **/** | **=** | **+** | **!** |**\*** | **%** |**<** | **>** |**&** | **|** |**/** | **~** | **?** |
+> *头部运算符* → U+00A1–U+00A7
+> *头部运算符* → U+00A9 or U+00AB
+> *头部运算符* → U+00AC or U+00AE
+> *头部运算符* → U+00B0–U+00B1, U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7
+> *头部运算符* → U+2016–U+2017 or U+2020–U+2027
+> *头部运算符* → U+2030–U+203E
+> *头部运算符* → U+2041–U+2053
+> *头部运算符* → U+2055–U+205E
+> *头部运算符* → U+2190–U+23FF
+> *头部运算符* → U+2500–U+2775
+> *头部运算符* → U+2794–U+2BFF
+> *头部运算符* → U+2E00–U+2E7F
+> *头部运算符* → U+3001–U+3003
+> *头部运算符* → U+3008–U+3030 
+<a id="operator_character"></a>
+> *运算符字符* → [*头部运算符*](#operator_head)
+> *运算符字符* → U+0300–U+036F
+> *运算符字符* → U+1DC0–U+1DFF
+> *运算符字符* → U+20D0–U+20FF
+> *运算符字符* → U+FE00–U+FE0F
+> *运算符字符* → U+FE20–U+FE2F
+> *运算符字符* → U+E0100–U+E01EF
+<a id="operator_characters"></a>
+> *运算符字符组* → [*运算符字符*](#operator_character) [*运算符字符组*](#operator_characters)<sub>可选</sub>
+<a id="dot_operator_head"></a>
+> *头部点运算符* → **..**
+> *头部点运算符字符* → . | [*运算符字符*](#operator_character)
+> *头部点运算符字符组* → [*点运算符字符*](#dot_operator_character) [*点运算符字符组*](#dot_operator_characters)<sub>可选</sub>
+ 
+> *二元运算符* → [*运算符*](#operator)  
+> *前置运算符* → [*运算符*](#operator)  
+> *后置运算符* → [*运算符*](#operator)  

From a0303ee3074e02743b66ce49d8c13fa7282ad578 Mon Sep 17 00:00:00 2001
From: justaway <bug_free@163.com>
Date: Mon, 29 Jun 2015 20:36:57 +0800
Subject: [PATCH 026/228] =?UTF-8?q?=E9=87=8D=E6=96=B0=E8=B0=83=E6=95=B4?=
 =?UTF-8?q?=E6=A0=BC=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter3/02_Lexical_Structure.md | 98 ++++++++++++-------------
 1 file changed, 49 insertions(+), 49 deletions(-)

diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 0fd074a2..76f1ae44 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -34,11 +34,11 @@ Swift 的“词法结构（*lexical structure*）”描述了能构成该语言
 
 > 标识符语法  
 <a id="identifier"></a>
-> *标识符* → [*头部标识符*](#identifier_head) [*标识符字符组*](#identifier_characters)<sub>可选</sub> 
+> *标识符* → [*头部标识符*](#identifier_head) [*标识符字符组*](#identifier_characters)<sub>可选</sub>  
 > *标识符* → \`[*头部标识符*](#identifier_head) [*标识符字符组*](#identifier_characters)<sub>可选</sub>\`  
 > *标识符* → [*隐式参数名*](#implicit_parameter_name)  
-> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier_list) 
-<a id="identifier_head"></a>
+> *标识符列表* → [*标识符*](#identifier) | [*标识符*](#identifier) **,** [*标识符列表*](#identifier_list)    
+<a id="identifier_head"></a>        
 > *头部标识符* → 大写或小写字母 A - Z  
 > *头部标识符* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA  
 > *头部标识符* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF  
@@ -57,9 +57,9 @@ Swift 的“词法结构（*lexical structure*）”描述了能构成该语言
 > *标识符字符* → 数值 0 - 9  
 > *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F  
 > *标识符字符* → [*头部标识符*](#identifier_head)
-<a id="identifier_characters"></a>
+<a id="identifier_characters"></a>        
 > *标识符字符组* → [*标识符字符*](#identifier_character) [*标识符字符列表*](#identifier_characters)<sub>可选</sub>  
-<a id="implicit_parameter_name></a>
+<a id="implicit_parameter_name"></a>    
 > *隐式参数名* → **$** [*十进制数字列表*](#decimal_digits)  
 
 <a id="keywords"></a>
@@ -94,10 +94,10 @@ true			   // 布尔型字面量
 当为一个字面量值指定了类型注解的时候，这个注解的类型必须能通过这个字面量值实例化后得到。也就是说，这个类型必须遵守这些 Swift 标准库协议中的一个：整型字面量的`IntegerLiteralConvertible`协议、符点型字面量的`FloatingPointLiteralConvertible`协议、字符串字面量的`StringLiteralConvertible`协议以及布尔型字面量的`BooleanLiteralConvertible`协议。比如，`Int8` 遵守了 `IntegerLiteralConvertible`协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整型字面量 `42` 的类型注解。
 
 > 字面量语法  
-> *字面量* → [*数字型字面量*](#numeric_literal) | [*字符串型字面量*](#string_literal) | [*布尔型字面量*](#boolean_literal) | [*nil型字面量*](#nil_literal)
-<a id="numeric_literal"></a>
-> *数字型字面量* → -<sub>可选</sub>[*整型字面量*](#integer_literal) | -<sub>可选</sub>[*符点型字面量*](#floating_point_literal)
-> *布尔型字面量* → **true** | **false**
+> *字面量* → [*数字型字面量*](#numeric_literal) | [*字符串型字面量*](#string_literal) | [*布尔型字面量*](#boolean_literal) | [*nil型字面量*](#nil_literal)    
+<a id="numeric_literal"></a>    
+> *数字型字面量* → -<sub>可选</sub>[*整型字面量*](#integer_literal) | -<sub>可选</sub>[*符点型字面量*](#floating_point_literal)    
+> *布尔型字面量* → **true** | **false**    
 > *nil型字面量* → **nil**
 
 ### 整型字面量
@@ -120,23 +120,23 @@ true			   // 布尔型字面量
 <a id="binary_literal"></a>
 > *二进制字面量* → **0b** [*二进制数字*](#binary_digit) [*二进制字面量字符组*](#binary_literal_characters)<sub>可选</sub>  
 > *二进制数字* → 数值 0 到 1  
-> *二进制字面量字符* → [*二进制数字*](#binary_digit) | _
+> *二进制字面量字符* → [*二进制数字*](#binary_digit) | _    
 > *二进制字面量字符组* → [*二进制字面量字符*](#binary_literal_character) [*二进制字面量字符组*](#binary_literal_characters)<sub>可选</sub>  
-<a id="octal_literal></a>
-> *八进制字面量* → **0o** [*八进字数字*](#octal_digit) [*八进制字符列表*](#octal_literal_characters)<sub>可选</sub>
+<a id="octal_literal"></a>    
+> *八进制字面量* → **0o** [*八进字数字*](#octal_digit) [*八进制字符列表*](#octal_literal_characters)<sub>可选</sub>    
 > *八进字数字* → 数值 0 到 7  
-> *八进制字符* → [*八进字数字*](#octal_digit) | _
+> *八进制字符* → [*八进字数字*](#octal_digit) | _    
 > *八进制字符组* → [*八进制字符*](#octal_literal_character) [*八进制字符列表*](#octal_literal_characters)<sub>可选</sub>
-<a id="decimal_literal"></a>
-> *十进制字面量* → [*十进制数字*](#decimal_digit) [*十进制字符组*](#decimal_literal_characters)<sub>可选</sub>
+<a id="decimal_literal"></a>    
+> *十进制字面量* → [*十进制数字*](#decimal_digit) [*十进制字符组*](#decimal_literal_characters)<sub>可选</sub>    
 > *十进制数字* → 数值 0 到 9  
 > *十进制数字列表* → [*十进制数字*](#decimal_digit) [*十进制数字列表*](#decimal_digits)<sub>可选</sub>  
-> *十进制字符* → [*十进制数字*](#decimal_digit) | _ 
+> *十进制字符* → [*十进制数字*](#decimal_digit) | _     
 > *十进制字符列表* → [*十进制字符*](#decimal_literal_character) [*十进制字符列表*](#decimal_literal_characters)<sub>可选</sub> 
-<a id="hexadecimal_literal"></a>
+<a id="hexadecimal_literal"></a>    
 > *十六进制字面量* → **0x** [*十六进制数字*](#hexadecimal_digit) [*十六进制字面量字符列表*](#hexadecimal_literal_characters)<sub>可选</sub>  
 > *十六进制数字* → 数值 0 到 9, 字母 a 到 f, 或 A 到 F  
-> *十六进制字符* → [*十六进制数字*](#hexadecimal_digit) | _ 
+> *十六进制字符* → [*十六进制数字*](#hexadecimal_digit) | _     
 > *十六进制字面量字符列表* → [*十六进制字符*](#hexadecimal_literal_character) [*十六进制字面量字符列表*](#hexadecimal_literal_characters)<sub>可选</sub>  
 
 ### 浮点型字面量
@@ -156,9 +156,9 @@ true			   // 布尔型字面量
 除非特别指定，浮点型字面量的默认推导类型为 Swift 标准库类型中的 `Double`，表示64位浮点数。Swift 标准库也定义了 `Float` 类型，表示32位浮点数。
 
 > 浮点型字面量语法  
-> *浮点数字面量* → [*十进制字面量*](#decimal_literal) [*十进制分数*](#decimal_fraction)<sub>可选</sub> [*十进制指数*](#decimal_exponent)<sub>可选</sub>  
+> *浮点数字面量* → [*十进制字面量*](#decimal_literal) [*十进制分数*](#decimal_fraction)<sub>可选</sub> [*十进制指数*](#decimal_exponent)<sub>可选</sub>      
 > *浮点数字面量* → [*十六进制字面量*](#hexadecimal_literal) [*十六进制分数*](#hexadecimal_fraction)<sub>可选</sub> [*十六进制指数*](#hexadecimal_exponent)
-<a id="decimal_fraction"></a>
+<a id="decimal_fraction"></a>    
 > *十进制分数* → **.** [*十进制字面量*](#decimal_literal)  
 > *十进制指数* → [*浮点数e*](#floating_point_e) [*正负号*](#sign)<sub>可选</sub> [*十进制字面量*](#decimal_literal)  
 <a id="hexadecimal_literal"></a>
@@ -211,7 +211,7 @@ let x = 3; "1 2 \(x)"
 > *引用文本条目* → [*转义字符*](#escaped_character)  
 > *引用文本条目* → **\(** [*表达式*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/doc/uid/TP40014097-CH32-ID383) **)**  
 > *引用文本条目* → **除了"­, \­, U+000A, 或者 U+000D的所有Unicode的字符**  
-> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'** 
+> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**     
 > *转义字符* → **\u {** [*unicode标量数字*](#unicode_scalar_digits) **}** 
 > *unicode标量数字* → 一到八位的十六进制数字
 
@@ -242,36 +242,36 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基
 
 > 运算符语法语法  
 > *运算符* → [*头部运算符*](#operator_head) [*运算符字符组*](#operator_characters)<sub>可选</sub>  
-> *运算符* → [*头部点运算符*](#dot_operator_head) [*点运算符字符组*](#dot_operator_characters)<sub>可选</sub>
-<a id="operator_head"></a>
+> *运算符* → [*头部点运算符*](#dot_operator_head) [*点运算符字符组*](#dot_operator_characters)<sub>可选</sub>    
+<a id="operator_head"></a>    
 > *头部运算符* → **/** | **=** | **+** | **!** |**\*** | **%** |**<** | **>** |**&** | **|** |**/** | **~** | **?** |
-> *头部运算符* → U+00A1–U+00A7
-> *头部运算符* → U+00A9 or U+00AB
-> *头部运算符* → U+00AC or U+00AE
-> *头部运算符* → U+00B0–U+00B1, U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7
-> *头部运算符* → U+2016–U+2017 or U+2020–U+2027
-> *头部运算符* → U+2030–U+203E
-> *头部运算符* → U+2041–U+2053
-> *头部运算符* → U+2055–U+205E
-> *头部运算符* → U+2190–U+23FF
-> *头部运算符* → U+2500–U+2775
-> *头部运算符* → U+2794–U+2BFF
-> *头部运算符* → U+2E00–U+2E7F
-> *头部运算符* → U+3001–U+3003
+> *头部运算符* → U+00A1–U+00A7    
+> *头部运算符* → U+00A9 or U+00AB    
+> *头部运算符* → U+00AC or U+00AE    
+> *头部运算符* → U+00B0–U+00B1, U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7    
+> *头部运算符* → U+2016–U+2017 or U+2020–U+2027    
+> *头部运算符* → U+2030–U+203E    
+> *头部运算符* → U+2041–U+2053    
+> *头部运算符* → U+2055–U+205E    
+> *头部运算符* → U+2190–U+23FF    
+> *头部运算符* → U+2500–U+2775    
+> *头部运算符* → U+2794–U+2BFF    
+> *头部运算符* → U+2E00–U+2E7F    
+> *头部运算符* → U+3001–U+3003    
 > *头部运算符* → U+3008–U+3030 
-<a id="operator_character"></a>
-> *运算符字符* → [*头部运算符*](#operator_head)
-> *运算符字符* → U+0300–U+036F
-> *运算符字符* → U+1DC0–U+1DFF
-> *运算符字符* → U+20D0–U+20FF
-> *运算符字符* → U+FE00–U+FE0F
-> *运算符字符* → U+FE20–U+FE2F
-> *运算符字符* → U+E0100–U+E01EF
-<a id="operator_characters"></a>
-> *运算符字符组* → [*运算符字符*](#operator_character) [*运算符字符组*](#operator_characters)<sub>可选</sub>
-<a id="dot_operator_head"></a>
-> *头部点运算符* → **..**
-> *头部点运算符字符* → . | [*运算符字符*](#operator_character)
+<a id="operator_character"></a>       
+> *运算符字符* → [*头部运算符*](#operator_head)    
+> *运算符字符* → U+0300–U+036F    
+> *运算符字符* → U+1DC0–U+1DFF    
+> *运算符字符* → U+20D0–U+20FF    
+> *运算符字符* → U+FE00–U+FE0F    
+> *运算符字符* → U+FE20–U+FE2F    
+> *运算符字符* → U+E0100–U+E01EF    
+<a id="operator_characters"></a>    
+> *运算符字符组* → [*运算符字符*](#operator_character) [*运算符字符组*]    (#operator_characters)<sub>可选</sub>    
+<a id="dot_operator_head"></a>    
+> *头部点运算符* → **..**    
+> *头部点运算符字符* → . | [*运算符字符*](#operator_character)    
 > *头部点运算符字符组* → [*点运算符字符*](#dot_operator_character) [*点运算符字符组*](#dot_operator_characters)<sub>可选</sub>
  
 > *二元运算符* → [*运算符*](#operator)  

From 8422ddf081bb33ab95006647e33ed46428e9ea3c Mon Sep 17 00:00:00 2001
From: chenYuheng <yuheng@tataufo.com>
Date: Mon, 29 Jun 2015 21:03:33 +0800
Subject: [PATCH 027/228] =?UTF-8?q?=E6=B3=9B=E5=9E=8B=E4=BF=AE=E6=94=B9?=
 =?UTF-8?q?=E4=BA=86=E9=83=A8=E5=88=86=E4=BB=A3=E7=A0=81=E6=9B=B4=E6=96=B0?=
 =?UTF-8?q?=E5=92=8C=E6=96=87=E6=9C=AC=E6=9B=B4=E6=96=B0=E7=9A=84=E5=9C=B0?=
 =?UTF-8?q?=E6=96=B9=EF=BC=8C=E8=BF=98=E5=89=A9=E4=B8=8B=E5=9B=9B=E4=B8=AA?=
 =?UTF-8?q?=E5=B0=8F=E8=8A=82=E6=B2=A1=E6=9C=89=E5=AE=8C=E6=88=90=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/23_Generics.md | 53 +++++++++++++++++-----------------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/source/chapter2/23_Generics.md b/source/chapter2/23_Generics.md
index c114a436..ec031e3e 100644
--- a/source/chapter2/23_Generics.md
+++ b/source/chapter2/23_Generics.md
@@ -27,7 +27,7 @@
 这里是一个标准的，非泛型函数`swapTwoInts`,用来交换两个Int值：
 
 ```swift
-func swapTwoInts(inout a: Int, inout b: Int) {
+func swapTwoInts(inout a: Int, inout _ b: Int) {
   let temporaryA = a
   a = b
   b = temporaryA
@@ -36,7 +36,7 @@ func swapTwoInts(inout a: Int, inout b: Int) {
 
 这个函数使用写入读出（in-out）参数来交换`a`和`b`的值，请参考[写入读出参数](../chapter2/06_Functions.html)。
 
-`swapTwoInts`函数可以交换`b`的原始值到`a`，也可以交换a的原始值到`b`，你可以调用这个函数交换两个`Int`变量值：
+`swapTwoInts(_:_:)`函数可以交换`b`的原始值到`a`，也可以交换a的原始值到`b`，你可以调用这个函数交换两个`Int`变量值：
 
 ```swift
 var someInt = 3
@@ -47,23 +47,23 @@ println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
 ```
 
 
-`swapTwoInts`函数是非常有用的，但是它只能交换`Int`值，如果你想要交换两个`String`或者`Double`，就不得不写更多的函数，如 `swapTwoStrings`和`swapTwoDoublesfunctions `，如同如下所示：
+`swapTwoInts(_:_:)`函数是非常有用的，但是它只能交换`Int`值，如果你想要交换两个`String`或者`Double`，就不得不写更多的函数，如 `swapTwoStrings`和`swapTwoDoubles(_:_:)`，如同如下所示：
 
 ```swift
-func swapTwoStrings(inout a: String, inout b: String) {
+func swapTwoStrings(inout a: String, inout _ b: String) {
     let temporaryA = a
     a = b
     b = temporaryA
 }
 
-func swapTwoDoubles(inout a: Double, inout b: Double) {
+func swapTwoDoubles(inout a: Double, inout _ b: Double) {
     let temporaryA = a
     a = b
     b = temporaryA
 }
 ```
 
-你可能注意到 `swapTwoInts`、 `swapTwoStrings`和`swapTwoDoubles`函数功能都是相同的，唯一不同之处就在于传入的变量类型不同，分别是`Int`、`String`和`Double`。
+你可能注意到 `swapTwoInts`、 `swapTwoStrings`和`swapTwoDoubles(_:_:)`函数功能都是相同的，唯一不同之处就在于传入的变量类型不同，分别是`Int`、`String`和`Double`。
 
 但实际应用中通常需要一个用处更强大并且尽可能的考虑到更多的灵活性单个函数，可以用来交换两个任何类型值，很幸运的是，泛型代码帮你解决了这种问题。（一个这种泛型函数后面已经定义好了。）
 
@@ -73,29 +73,29 @@ func swapTwoDoubles(inout a: Double, inout b: Double) {
 <a name="generic_functions"></a>
 ## 泛型函数
 
-`泛型函数`可以工作于任何类型，这里是一个上面`swapTwoInts`函数的泛型版本，用于交换两个值：
+`泛型函数`可以工作于任何类型，这里是一个上面`swapTwoInts(_:_:)`函数的泛型版本，用于交换两个值：
 
 ```swift
-func swapTwoValues<T>(inout a: T, inout b: T) {
+func swapTwoValues<T>(inout a: T, inout _ b: T) {
     let temporaryA = a
     a = b
     b = temporaryA
 }
 ```
 
-`swapTwoValues`函数主体和`swapTwoInts`函数是一样的，它只在第一行稍微有那么一点点不同于`swapTwoInts`，如下所示：
+`swapTwoValues(_:_:)`函数主体和`swapTwoInts(_:_:)`函数是一样的，它只在第一行稍微有那么一点点不同于`swapTwoInts`，如下所示：
 
 ```swift
-func swapTwoInts(inout a: Int, inout b: Int)
-func swapTwoValues<T>(inout a: T, inout b: T)
+func swapTwoInts(inout a: Int, inout _ b: Int)
+func swapTwoValues<T>(inout a: T, inout _ b: T)
 ```
 
 
-这个函数的泛型版本使用了占位类型名字（通常此情况下用字母`T`来表示）来代替实际类型名（如`Int`、`String`或`Double`）。占位类型名没有提示`T`必须是什么类型，但是它提示了`a`和`b`必须是同一类型`T`，而不管`T`表示什么类型。只有`swapTwoValues`函数在每次调用时所传入的实际类型才能决定`T`所代表的类型。
+这个函数的泛型版本使用了占位类型名字（通常此情况下用字母`T`来表示）来代替实际类型名（如`Int`、`String`或`Double`）。占位类型名没有提示`T`必须是什么类型，但是它提示了`a`和`b`必须是同一类型`T`，而不管`T`表示什么类型。只有`swapTwoValues(_:_:)`函数在每次调用时所传入的实际类型才能决定`T`所代表的类型。
 
-另外一个不同之处在于这个泛型函数名后面跟着的占位类型名字（T）是用尖括号括起来的（`<T>`）。这个尖括号告诉 Swift 那个`T`是`swapTwoValues`函数所定义的一个类型。因为`T`是一个占位命名类型，Swift 不会去查找命名为T的实际类型。
+另外一个不同之处在于这个泛型函数名后面跟着的占位类型名字（T）是用尖括号括起来的（`<T>`）。这个尖括号告诉 Swift 那个`T`是`swapTwoValues(_:_:)`函数所定义的一个类型。因为`T`是一个占位命名类型，Swift 不会去查找命名为T的实际类型。
 
-`swapTwoValues`函数除了要求传入的两个任何类型值是同一类型外，也可以作为`swapTwoInts`函数被调用。每次`swapTwoValues`被调用，T所代表的类型值都会传给函数。
+`swapTwoValues(_:_:)`函数除了要求传入的两个任何类型值是同一类型外，也可以作为`swapTwoInts`函数被调用。每次`swapTwoValues`被调用，T所代表的类型值都会传给函数。
 
 在下面的两个例子中,`T`分别代表`Int`和`String`：
 
@@ -103,26 +103,26 @@ func swapTwoValues<T>(inout a: T, inout b: T)
 var someInt = 3
 var anotherInt = 107
 swapTwoValues(&someInt, &anotherInt)
-// someInt is now 107, and anotherInt is now 3
+// someInt 现在等于 107, anotherInt 现在等于 3
 ```
 
 ```swift
 var someString = "hello"
 var anotherString = "world"
 swapTwoValues(&someString, &anotherString)
-// someString is now "world", and anotherString is now "hello"
+// someString 现在等于 "world", anotherString 现在等于 "hello"
 ```
 
 
 >注意
-上面定义的函数`swapTwoValues`是受`swap`函数启发而实现的。`swap`函数存在于 Swift 标准库，并可以在其它类中任意使用。如果你在自己代码中需要类似`swapTwoValues`函数的功能，你可以使用已存在的交换函数`swap`函数。
+上面定义的函数`swapTwoValues(_:_:)`是受`swap`函数启发而实现的。`swap`函数存在于 Swift 标准库，并可以在其它类中任意使用。如果你在自己代码中需要类似`swapTwoValues(_:_:)`函数的功能，你可以使用已存在的交换函数`swap(_:_:)`函数。
 
 <a name="type_parameters"></a>
 ## 类型参数
 
 在上面的`swapTwoValues`例子中，占位类型`T`是一种类型参数的示例。类型参数指定并命名为一个占位类型，并且紧随在函数名后面，使用一对尖括号括起来（如`<T>`）。
 
-一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如`swapTwoValues`函数中的参数`a`和`b`），或作为一个函数返回类型，或用作函数主体中的注释类型。在这种情况下，被类型参数所代表的占位类型不管函数任何时候被调用，都会被实际类型所替换（在上面`swapTwoValues`例子中，当函数第一次被调用时，`T`被`Int`替换，第二次调用时，被`String`替换。）。
+一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如`swapTwoValues(_:_:)`函数中的参数`a`和`b`），或作为一个函数返回类型，或用作函数主体中的注释类型。在这种情况下，被类型参数所代表的占位类型不管函数任何时候被调用，都会被实际类型所替换（在上面`swapTwoValues`例子中，当函数第一次被调用时，`T`被`Int`替换，第二次调用时，被`String`替换。）。
 
 你可支持多个类型参数，命名在尖括号中，用逗号分开。
 
@@ -131,10 +131,10 @@ swapTwoValues(&someString, &anotherString)
 
 在简单的情况下，泛型函数或泛型类型需要指定一个占位类型（如上面的`swapTwoValues`泛型函数，或一个存储单一类型的泛型集，如数组），通常用一单个字母`T`来命名类型参数。不过，你可以使用任何有效的标识符来作为类型参数名。
 
-如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift 字典（Dictionary）类型有两个类型参数，一个是键，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为`KeyType`和`ValueType`，用来记住它们在你的泛型代码中的作用。
+如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift 字典（Dictionary）类型有两个类型参数，一个是键，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为`Key`和`Value`，用来记住它们在你的泛型代码中的作用。
 
 >注意
-请始终使用大写字母开头的驼峰式命名法（例如`T`和`KeyType`）来给类型参数命名，以表明它们是类型的占位符，而非类型值。
+请始终使用大写字母开头的驼峰式命名法（例如`T`和`Key`）来给类型参数命名，以表明它们是类型的占位符，而非类型值。
 
 <a name="generic_types"></a>
 ## 泛型类型
@@ -145,7 +145,7 @@ swapTwoValues(&someString, &anotherString)
 这部分向你展示如何写一个泛型集类型--`Stack`（栈）。一个栈是一系列值域的集合，和`Array`（数组）类似，但其是一个比 Swift 的`Array`类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许在集合的末端添加新的项（如同*push*一个新值进栈）。同样的一个栈也只能从末端移除项（如同*pop*一个值出栈）。
 
 >注意
-栈的概念已被`UINavigationController`类使用来模拟试图控制器的导航结构。你通过调用`UINavigationController`的`pushViewController:animated:`方法来为导航栈添加（add）新的试图控制器；而通过`popViewControllerAnimated:`的方法来从导航栈中移除（pop）某个试图控制器。每当你需要一个严格的`后进先出`方式来管理集合，堆栈都是最实用的模型。
+栈的概念已被`UINavigationController`类使用来模拟试图控制器的导航结构。你通过调用`UINavigationController`的`pushViewController(_:animated:)`方法来为导航栈添加（add）新的试图控制器；而通过`popViewControllerAnimated(_:)`的方法来从导航栈中移除（pop）某个试图控制器。每当你需要一个严格的`后进先出`方式来管理集合，堆栈都是最实用的模型。
 
 下图展示了一个栈的压栈(push)/出栈(pop)的行为：
 
@@ -161,7 +161,7 @@ swapTwoValues(&someString, &anotherString)
 
 ```swift
 struct IntStack {
-    var items = Int[]()
+    var items = [Int]()
     mutating func push(item: Int) {
         items.append(item)
     }
@@ -196,10 +196,12 @@ struct Stack<T> {
 `T`定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，`T`在如下三个地方被用作节点：
 
 - 创建一个名为`items`的属性，使用空的T类型值数组对其进行初始化；
-- 指定一个包含一个参数名为`item`的`push`方法，该参数必须是T类型；
+- 指定一个包含一个参数名为`item`的`push(_:)`方法，该参数必须是T类型；
 - 指定一个`pop`方法的返回值，该返回值将是一个T类型值。
 
-当创建一个新单例并初始化时， 通过用一对紧随在类型名后的尖括号里写出实际指定栈用到类型，创建一个`Stack`实例，同创建`Array`和`Dictionary`一样：
+由于`Stack`是泛型类型，所以在 Swift 中其可以用来创建任何有效类型的栈，这种方式如同`Array`和`Dictionary`。
+
+你可以通过在尖括号里写出栈中需要存储的数据类型来创建并初始化一个`Stack`实例。比如，要创建一个`strings`的栈，你可以写成`Stack<String>()`：
 
 ```swift
 var stackOfStrings = Stack<String>()
@@ -218,13 +220,12 @@ stackOfStrings.push("cuatro")
 
 ```swift
 let fromTheTop = stackOfStrings.pop()
-// fromTheTop is equal to "cuatro", and the stack now contains 3 strings
+// fromTheTop 等于 "cuatro", 现在栈中还有3个string
 ```
 
 下图展示了如何从栈中pop一个值的过程：
 ![此处输入图片的描述](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPoppedOneString_2x.png)
 
-由于`Stack`是泛型类型，所以在 Swift 中其可以用来创建任何有效类型的栈，这种方式如同`Array`和`Dictionary`。
 
 <a name="type_constraints"></a>
 ##类型约束

From c34a6381a44cf131db0ab9fb0cdd212a9cf25908 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 22:52:22 +0800
Subject: [PATCH 028/228] patterns_22:52_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 6fd48bf8..54cf38d5 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -73,7 +73,7 @@ let someValue = 42
 ```swift
 let point = (3, 2)
 switch point {
-// Bind x and y to the elements of point.
+    // Bind x and y to the elements of point.
 case let (x, y):
     print("The point is at (\(x), \(y)).")
 }
@@ -92,7 +92,7 @@ case let (x, y):
 
 你可以使用类型注释来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型注释即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。
 
-当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式或者其他包含这两种模式的模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式：
+当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式：
 
 ```swift
 let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
@@ -204,7 +204,7 @@ default:
 ```swift
 // Overload the ~= operator to match a string with an integer
 func ~=(pattern: String, value: Int) -> Bool {
-return pattern == "\(value)"
+    return pattern == "\(value)"
 }
 switch point {
 case ("0", "0"):

From 50aa657d1b754a9d3690a24a1920509a344590ae Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 22:54:16 +0800
Subject: [PATCH 029/228] patterns_22:54_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 54cf38d5..c639a508 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -98,7 +98,7 @@ case let (x, y):
 let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
 // This code isn't valid.
 for (x, 0) in points {
-/* ... */
+    /* ... */
 }
 ```
 

From 989e827affcb5191750ac530c50cf7c5084b9d11 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 23:00:18 +0800
Subject: [PATCH 030/228] patterns_23:00_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index c639a508..06c6f3dd 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -19,7 +19,7 @@
 
 swift语言中模式有2个基本的分类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。
 
-第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard pattern），标识符模式（identifier pattern），以及任何包含了它们的值绑定模式（value binding pattern）或者元祖模式（tuple pattern）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。
+第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard patterns），标识符模式（identifier patterns），以及任何包含了它们的值绑定模式（value binding patterns）或者元祖模式（tuple patterns）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。
 
 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
 

From 7cf135d70087213fd6587b6559e6666fee2b37e5 Mon Sep 17 00:00:00 2001
From: justaway <bug_free@163.com>
Date: Mon, 29 Jun 2015 23:05:33 +0800
Subject: [PATCH 031/228] =?UTF-8?q?=E5=B0=86'Type=20Annoation'=E7=9A=84?=
 =?UTF-8?q?=E7=BF=BB=E8=AF=91=E7=94=B1'=E7=B1=BB=E5=9E=8B=E6=B3=A8?=
 =?UTF-8?q?=E8=A7=A3'=E6=94=B9=E4=B8=BA'=E7=B1=BB=E5=9E=8B=E6=A0=87?=
 =?UTF-8?q?=E6=B3=A8'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter3/02_Lexical_Structure.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 76f1ae44..3ac59140 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -89,9 +89,9 @@ Swift 的“词法结构（*lexical structure*）”描述了能构成该语言
 true			   // 布尔型字面量
 ```
 
-字面量本身并不包含类型信息。事实上，一个字面量会被解析为拥有无限的精度，然后 Swift 的类型推导会尝试去推导出这个字面量的类型。比如，在 `let x: Int8 = 42` 这个声明中，Swift 使用了显式类型注解（`: Int8`）来推导出 `42` 这个整型字面量的类型是 `Int8`。如果没有可用的类型信息， Swift 则会从标准库中定义的字面量类型中推导出一个默认的类型。整型字面量的默认类型是 `Int`，浮点型字面量的默认类型是 `Double`，字符串型字面量的默认类型是 `String`，布尔型字面量的默认类型是 `Bool`。比如，在 `let str = "Hello, world"` 这个声明中，字符串 `"Hello, world"`的默认推导类型就是 `String`。
+字面量本身并不包含类型信息。事实上，一个字面量会被解析为拥有无限的精度，然后 Swift 的类型推导会尝试去推导出这个字面量的类型。比如，在 `let x: Int8 = 42` 这个声明中，Swift 使用了显式类型标注（`: Int8`）来推导出 `42` 这个整型字面量的类型是 `Int8`。如果没有可用的类型信息， Swift 则会从标准库中定义的字面量类型中推导出一个默认的类型。整型字面量的默认类型是 `Int`，浮点型字面量的默认类型是 `Double`，字符串型字面量的默认类型是 `String`，布尔型字面量的默认类型是 `Bool`。比如，在 `let str = "Hello, world"` 这个声明中，字符串 `"Hello, world"`的默认推导类型就是 `String`。
 
-当为一个字面量值指定了类型注解的时候，这个注解的类型必须能通过这个字面量值实例化后得到。也就是说，这个类型必须遵守这些 Swift 标准库协议中的一个：整型字面量的`IntegerLiteralConvertible`协议、符点型字面量的`FloatingPointLiteralConvertible`协议、字符串字面量的`StringLiteralConvertible`协议以及布尔型字面量的`BooleanLiteralConvertible`协议。比如，`Int8` 遵守了 `IntegerLiteralConvertible`协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整型字面量 `42` 的类型注解。
+当为一个字面量值指定了类型标注的时候，这个注解的类型必须能通过这个字面量值实例化后得到。也就是说，这个类型必须遵守这些 Swift 标准库协议中的一个：整型字面量的`IntegerLiteralConvertible`协议、符点型字面量的`FloatingPointLiteralConvertible`协议、字符串字面量的`StringLiteralConvertible`协议以及布尔型字面量的`BooleanLiteralConvertible`协议。比如，`Int8` 遵守了 `IntegerLiteralConvertible`协议，因此它能在 `let x: Int8 = 42` 这个声明中作为整型字面量 `42` 的类型标注。
 
 > 字面量语法  
 > *字面量* → [*数字型字面量*](#numeric_literal) | [*字符串型字面量*](#string_literal) | [*布尔型字面量*](#boolean_literal) | [*nil型字面量*](#nil_literal)    

From 47fee2b7d510ae38c827f884f9b875e97349c630 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 23:29:12 +0800
Subject: [PATCH 032/228] patterns_23:29_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 06c6f3dd..9ee36996 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -11,25 +11,25 @@
 - [值绑定模式（Value-Binding Pattern）](#value-binding_pattern)
 - [元组模式（Tuple Pattern）](#tuple_pattern)
 - [枚举用例模式（Enumeration Case Pattern）](#enumeration_case_pattern)
-- [可选模式（Optional Patterns）](#optional_pattern)
-- [类型转换模式（Type-Casting Patterns）](#type-casting_pattern)
+- [可选模式（Optional Pattern）](#optional_pattern)
+- [类型转换模式（Type-Casting Pattern）](#type-casting_pattern)
 - [表达式模式（Expression Pattern）](#expression_pattern)
 
 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从复合值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
 
 swift语言中模式有2个基本的分类：一类能成功和任何值的类型相匹配，另一类在运行时（runtime）和某特定值匹配时可能会失败。
 
-第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard patterns），标识符模式（identifier patterns），以及任何包含了它们的值绑定模式（value binding patterns）或者元祖模式（tuple patterns）。你可以为这类模式指定一个类型注释（type annotation）从而限制它们只能匹配某种特定类型的值。
+第一类模式用于解构简单变量，常量和可选绑定中的值。此类模式包括通配符模式（wildcard patterns），标识符模式（identifier patterns），以及任何包含了它们的值绑定模式（value binding patterns）或者元祖模式（tuple patterns）。你可以为这类模式指定一个类型标注（type annotation）从而限制它们只能匹配某种特定类型的值。
 
-第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式，可选模式，表达式模式和类型转换模式。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
+第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式（enumeration case patterns），可选模式（optional patterns），表达式模式（expression patterns）和类型转换模式（type-casting patterns）。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
 
 > 模式(Patterns) 语法  
-> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
-> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_  
+> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_  
+> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_  
 > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)  
-> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
+> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_  
 > *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern)  
-> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern) [*类型注解*](..\chapter3\03_Types.html#optional_type) _可选_  
+> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern)
 > *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern)  
 > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)  
 
@@ -40,7 +40,7 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类
 
 ```swift
 for _ in 1...3 {
-// Do something three times.
+    // Do something three times.
 }
 ```
 
@@ -90,7 +90,7 @@ case let (x, y):
 
 元组模式是逗号分隔的列表，包含一个或多个模式，并包含在一对圆括号中。元组模式匹配相应元组类型的值。
 
-你可以使用类型注释来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型注释即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。
+你可以使用类型标注来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。
 
 当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式：
 
@@ -199,7 +199,7 @@ default:
 // prints "(1, 2) is near the origin.”
 ```
 
-你可以重载`~=`操作符来提供自定义的表达式行为。例如，你可以重写上面的例子，以实现用字符串表达的点来比较`point`表达式。
+你可以重载`~=`操作符来提供自定义的表达式匹配行为。比如你可以重写上面的例子，拿`point`表达式去比较字符串形式的点。
 
 ```swift
 // Overload the ~= operator to match a string with an integer
@@ -209,8 +209,6 @@ func ~=(pattern: String, value: Int) -> Bool {
 switch point {
 case ("0", "0"):
     print("(0, 0) is at the origin.")
-case ("-2...2", "-2...2"):
-    print("(\(point.0), \(point.1)) is near the origin.")
 default:
     print("The point is at (\(point.0), \(point.1)).")
 }

From 84cae57c8b0870c99e8f9763e3ce9ca4a6f52346 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Mon, 29 Jun 2015 23:33:12 +0800
Subject: [PATCH 033/228] patterns_23:33_06/29/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 9ee36996..d7c3313d 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -29,7 +29,7 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类
 > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)  
 > *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_  
 > *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern)  
-> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern)
+> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern)  
 > *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern)  
 > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)  
 

From 4f4622ea41afe0b477950ac5f4f1837d93a921e6 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Tue, 30 Jun 2015 01:43:13 +0800
Subject: [PATCH 034/228] patterns_01:42_06/30/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 38 +++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index d7c3313d..f56513a8 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -36,7 +36,7 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类
 <a name="wildcard_pattern"></a>
 ## 通配符模式（Wildcard Pattern）
 
-通配符模式匹配并忽略任何值，包含一个下划线（_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了`1...3`的循环，并忽略了每次循环的值：
+通配符模式由一个下划线（_）构成，且匹配并忽略任何值。当你不在乎被匹配的值时可以使用该模式。例如，下面这段代码在闭区间`1...3`中循环，每次循环时忽略该区间内的当前值：
 
 ```swift
 for _ in 1...3 {
@@ -50,7 +50,7 @@ for _ in 1...3 {
 <a name="identifier_pattern"></a>
 ## 标识符模式（Identifier Pattern）
 
-标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量申明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。
+标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量声明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。
 
 ```swift
 let someValue = 42
@@ -58,7 +58,7 @@ let someValue = 42
 
 当匹配成功时，`42`被绑定（赋值）给常量`someValue`。
 
-当一个变量或常量申明的左边是标识符模式时，此时，标识符模式是隐式的值绑定模式（value-binding pattern）。
+如果一个变量或常量声明的左边的模式是一个标识符模式，那么这个标识符模式是一个隐式的值绑定模式（value-binding pattern）。
 
 > 标识符模式语法  
 > *标识符模式* → [*标识符*](LexicalStructure.html#identifier)  
@@ -66,9 +66,9 @@ let someValue = 42
 <a name="value-binding_pattern"></a>
 ## 值绑定模式（Value-Binding Pattern）
 
-值绑定模式绑定匹配的值到一个变量或常量。当绑定匹配值给常量时，用关键字`let`,绑定给变量时，用关键字`var`。
+值绑定模式把匹配到的值绑定给一个变量或常量名。把绑定匹配到的值绑定给常量时，用关键字`let`,绑定给变量时，用关键字`var`。
 
-标识符模式包含在值绑定模式中，绑定新的变量或常量到匹配的值。例如，你可以分解一个元组的元素，并把每个元素绑定到相应的标识符模式中。
+在值绑定模式中的标识符模式会把新命名的变量或常量与匹配值做绑定。例如，你可以拆开一个元组的元素，然后把每个元素绑定到其相应一个的标识符模式中。
 
 ```swift
 let point = (3, 2)
@@ -80,7 +80,7 @@ case let (x, y):
 // prints "The point is at (3, 2).”
 ```
 
-在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。因为这种行为，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配的值是一样的。
+在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。正是由于这么做，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配到的值是一样的。
 
 > 值绑定(Value Binding)模式语法  
 > *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern)  
@@ -88,11 +88,11 @@ case let (x, y):
 <a name="tuple_pattern"></a>
 ## 元组模式（Tuple Pattern）
 
-元组模式是逗号分隔的列表，包含一个或多个模式，并包含在一对圆括号中。元组模式匹配相应元组类型的值。
+元组模式是逗号分隔的，有零个或多个模式的列表，并被一对圆括号括起来。元组模式匹配相应元组类型的值。
 
-你可以使用类型标注来限制一个元组模式来匹配某种元组类型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`，只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是`String`，则被匹配。
+你可以使用类型标注来限制一个元组模式来匹配某些种元组类型。例如，在常量声明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式可以和任何有两个元素，且第一个元素类型是`String`的元组类型匹配。
 
-当元组模式被用在`for-in`语句或者变量或常量申明时，它可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。例如，下面这段代码是不正确的，因为`(x, 0)`中的元素`0`是一个表达式模式：
+当元组模式被用在`for-in`语句或者变量或常量声明时，它仅可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。比如下面这段代码就不正确，因为`(x, 0)`中的元素`0`是一个表达式模式：
 
 ```swift
 let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
@@ -102,7 +102,7 @@ for (x, 0) in points {
 }
 ```
 
-对于只包含一个元素的元组，括号是不起作用的。模式匹配那个单个元素的类型。例如，下面是等效的：
+对于只包含一个元素的元组，括号是不起作用的。模式只匹配这个单个元素的类型。举例来说，下面3条语句是等效的：
 
 ```swift
 let a = 2        // a: Int = 2
@@ -118,7 +118,7 @@ let (a): Int = 2 // a: Int = 2
 <a name="enumeration_case_pattern"></a>
 ## 枚举用例模式（Enumeration Case Pattern）
 
-枚举用例模式匹配现有的枚举类型的某种用例。枚举用例模式仅在`switch`语句中的`case`标签中出现。
+一个枚举用例模式匹配现有的某个枚举类型的某个用例（case）。枚举用例模式出现在`switch`语句中的case标签中，以及`if`，`while`，`guard`和`for-in`语句的case条件中。
 
 如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`.
 
@@ -128,9 +128,9 @@ let (a): Int = 2 // a: Int = 2
 <a name="optional_pattern"></a>
 ## 可选模式（Optional Pattern）
 
-可选模式与封装在一个`Optional(T)`或者一个`ExplicitlyUnwrappedOptional(T)`枚举中的`Some(T)`成员值相匹配。可选模式由一个标识符模式和紧随其后的一个问号组成，在某些情况下表现为枚举用例模式。
+可选模式与封装在一个`Optional(T)`或者一个`ExplicitlyUnwrappedOptional(T)`枚举中的`Some(T)`用例相匹配。可选模式由一个标识符模式和紧随其后的一个问号组成，在某些情况下表现为枚举用例模式。
 
-由于可选模式是`optional`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖（syntactic sugar），下面的两种写法一样的：
+由于可选模式是`optional`和`ImplicitlyUnwrappedOptional`枚举用例模式的语法糖（syntactic sugar），下面的2种写法是一样的：
 
 ```swift
 let someOptional: Int? = 42
@@ -144,7 +144,7 @@ if case let x? = someOptional {
     print(x)
 }
 ```
-如果一个数组的元素是可选类型，可选模式为`for-in`语句提供了在该数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环。
+如果一个数组的元素是可选类型，可选模式为`for-in`语句提供了一种在该数组中迭代的简便方式，只为数组中的非空`non-nil`元素执行循环体。
 
 ```swift
 let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
@@ -163,14 +163,14 @@ for case let number? in arrayOfOptinalInts {
 <a name="type-casting_patterns"></a>
 ## 类型转换模式（Type-Casting Patterns）
 
-有两种类型转换模式，`is`模式和`as`模式。这两种模式均只出现在`switch`语句中的`case`标签中。`is`模式和`as`模式有以下形式：
+有两种类型转换模式，`is`模式和`as`模式。这两种模式只出现在`switch`语句中的case标签中。`is`模式和`as`模式有以下形式：
 
 > is `type`  
 > `pattern` as `type`
 
-`is`模式匹配一个值，如果这个值的类型在运行时（runtime）和`is`模式右边的指定类型（或者那个类型的子类）是一致的。`is`模式和`is`操作符一样，它们都进行类型转换，但是抛弃了返回的类型。
+`is`模式仅当一个值的类型在运行时（runtime）和`is`模式右边的指定类型一致 - 或者是该类型的子类 - 的情况下，才会匹配这个值。`is`模式和`is`操作符有相似表现，它们都进行类型转换，却舍弃返回的类型。
 
-`as`模式匹配一个值，如果这个值的类型在运行时（runtime）和`as`模式右边的指定类型（或者那个类型的子类）是一致的。一旦匹配成功，匹配的值的类型被转换成`as`模式左边指定的模式。
+`as`模式仅当一个值的类型在运行时（runtime）和`as`模式右边的指定类型一致 - 或者是该类型的子类 - 的情况下，才会匹配这个值。如果匹配成功，被匹配的值的类型被转换成`as`模式左边指定的模式。
 
 关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。
 
@@ -182,9 +182,9 @@ for case let number? in arrayOfOptinalInts {
 <a name="expression_pattern"></a>
 ## 表达式模式（Expression Pattern）
 
-表达式模式代表了一个表达式的值。这个模式只出现在`switch`语句中的`case`标签中。
+一个表达式模式代表了一个表达式的值。表达式模式只出现在`switch`语句中的`case`标签中。
 
-由表达式模式所代表的表达式用Swift标准库中的`~=`操作符与输入表达式的值进行比较。如果`~=`操作符返回`true`，则匹配成功。默认情况下，`~=`操作符使用`==`操作符来比较两个相同类型的值。它也可以匹配一个整数值与一个`Range`对象中的整数范围，正如下面这个例子所示：
+由表达式模式所代表的表达式与使用了Swift标准库中`~=`操作符的输入表达式的值进行比较。如果`~=`操作符返回`true`，则匹配成功。默认情况下，`~=`操作符使用`==`操作符来比较两个相同类型的值。它也可以将一个整型数值与一个`Range`对象中的一段整数区间做匹配，正如下面这个例子所示：
 
 ```swift
 let point = (1, 2)

From 93186d21113d21e6a1d89410c96e02d61e8e7633 Mon Sep 17 00:00:00 2001
From: ray16897188 <atlantis.ray@gmail.com>
Date: Tue, 30 Jun 2015 01:46:46 +0800
Subject: [PATCH 035/228] patterns_01:46_06/30/2015_Preliminary

---
 source/chapter3/07_Patterns.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index f56513a8..fb93956d 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -90,7 +90,7 @@ case let (x, y):
 
 元组模式是逗号分隔的，有零个或多个模式的列表，并被一对圆括号括起来。元组模式匹配相应元组类型的值。
 
-你可以使用类型标注来限制一个元组模式来匹配某些种元组类型。例如，在常量声明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式可以和任何有两个元素，且第一个元素类型是`String`的元组类型匹配。
+你可以使用类型标注去限制一个元组模式能匹配哪些种元组类型。例如，在常量声明`let (x, y): (Int, Int) = (1, 2)`中的元组模式`(x, y): (Int, Int)`只匹配两个元素都是`Int`这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型标注即可。例如，在`let (x: String, y)`中的元组模式可以和任何有两个元素，且第一个元素类型是`String`的元组类型匹配。
 
 当元组模式被用在`for-in`语句或者变量或常量声明时，它仅可以包含通配符模式，标识符模式，可选模式或者其他包含这些模式的元祖模式。比如下面这段代码就不正确，因为`(x, 0)`中的元素`0`是一个表达式模式：
 

From a84a65fd553a64a7371668b66d6109d97d22ad7f Mon Sep 17 00:00:00 2001
From: Cai Yi <warden.caiyi@outlook.com>
Date: Tue, 30 Jun 2015 10:52:06 +0800
Subject: [PATCH 036/228] Update 08_Generic_Parameters_and_Arguments.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

翻译swift2.0版本的泛型参数章节，对之前版本进行校验
---
 .../08_Generic_Parameters_and_Arguments.md    | 60 ++++++++++---------
 1 file changed, 33 insertions(+), 27 deletions(-)

diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index 06a078b0..9bb891a4 100755
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -1,5 +1,5 @@
 > 翻译：[fd5788](https://github.com/fd5788)  
-> 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
+> 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai), [wardenNScaiyi](https:github.com/wardenNScaiyi)
 
 # 泛型参数
 ---------
@@ -9,28 +9,29 @@
 - [泛型形参子句](#generic_parameter)
 - [泛型实参子句](#generic_argument)
 
-本节涉及泛型类型、泛型函数以及泛型构造器的参数，包括形参和实参。声明泛型类型、函数或构造器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型构造器时，就用具体的类型实参替代之。
+本节涉及泛型类型、泛型函数以及泛型初始化器（**initializer**）的参数，包括形参和实参。声明泛型类型、函数或初始化器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型初始化器时，就用具体的类型实参替代之。
 
 关于 Swift 语言的泛型概述，见[泛型](../charpter2/22_Generics.md)(第二部分第22章)。
 
 <a name="generic_parameter"></a>
 ## 泛型形参子句
 
-泛型形参子句指定泛型类型或函数的类型形参，以及这些参数的关联约束和要求。泛型形参子句用尖括号（<>）包住，并且有以下两种形式：
+泛型形参子句指定泛型类型或函数的类型形参，以及这些参数的关联约束和关联类型要求（**requirement**）。泛型形参子句用尖括号（<>）包住，并且有以下两种形式：
 
-> <`generic parameter list`>  
-> <`generic parameter list` where `requirements`>
+> <`泛型形参列表`>  
+> <`泛型形参列表` where `关联类型要求`>
 
-泛型形参列表中泛型形参用逗号分开，每一个采用以下形式：
+泛型形参列表中泛型形参用逗号分开，其中每一个采用以下形式：
 
-> `type parameter` : `constrain`
+> `类型形参` : `约束`
 
-泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如T，U，V，KeyType，ValueType等）的名字而已。你可以在泛型类型、函数的其余部分或者构造器声明，以及函数或构造器的签名中使用它。
+泛型形参由两部分组成：类型形参及其后的可选约束。类型形参只是占位符类型（如 T，U，V，Key，Value 等）的名字而已。你可以在泛型类型、函数的其余部分或者初始化器声明，包括函数或初始化器的签名中使用它（与其任何相关类型）。
+
+约束用于指明该类型形参继承自某个类或者遵守某个协议或协议的一部分。例如，在下面的泛型函数中，泛型形参`T: Comparable`表示任何用于替代类型形参`T`的类型实参必须满足`Comparable`协议。
 
-约束用于指明该类型形参继承自某个类或者遵守某个协议或协议的一部分。例如，在下面的泛型中，泛型形参`T: Comparable`表示任何用于替代类型形参`T`的类型实参必须满足`Comparable`协议。
 
 ```swift
-func simpleMin<T: Comparable>(x: T, y: T) -> T {
+func simpleMax<T: Comparable>(x: T, _ y: T) -> T {
     if x < y {
         return y
     }
@@ -38,28 +39,30 @@ func simpleMin<T: Comparable>(x: T, y: T) -> T {
 }
 ```
 
-如，`Int`和`Double`均满足`Comparable`协议，该函数接受任何一种类型。与泛型类型相反，调用泛型函数或构造器时不需要指定泛型实参子句。类型实参由传递给函数或构造器的实参推断而出。
 
-```swift
-simpleMin(17, 42) // T is inferred to be Int
-simpleMin(3.14159, 2.71828) // T is inferred to be Double
+
+如，`Int`和`Double`均满足`Comparable`协议，该函数接受任何一种类型。与泛型类型相反，调用泛型函数或初始化器时不需要指定泛型实参子句。类型实参由传递给函数或初始化器的实参推断而出。
+
+
+```
+simpleMax(17, 42) // T被推断出为Int类型
+simpleMax(3.14159, 2.71828) // T被推断出为Double类型
 ```
 
 ## Where 子句
 
-要想对类型形参及其关联类型指定额外要求，可以在泛型形参列表之后添加`where`子句。`where`子句由关键字`where`及其后的用逗号分割的多个要求组成。
+要想对类型形参及其关联类型指定额外关联类型要求，可以在泛型形参列表之后添加`where`子句。`where`子句由关键字`where`及其后的用逗号分割的多个关联类型要求组成。
 
-`where`子句中的要求用于指明该类型形参继承自某个类或遵守某个协议或协议的一部分。尽管`where`子句有助于表达类型形参上的简单约束（如`T: Comparable`等同于`T where T: Comparable`，等等），但是依然可以用来对类型形参及其关联约束提供更复杂的约束。如，`<T where T: C, T: P>`表示泛型类型`T`继承自类`C`且遵守协议`P`。
+`where`子句中的关联关系用于指明该类型形参继承自某个类或遵守某个协议或协议的一部分。尽管`where`子句提供了语法糖使其有助于表达类型形参上的简单约束（如`T: Comparable`等同于`T where T: Comparable`，等等），但是依然可以用来对类型形参及其关联类型提供更复杂的约束。如，`<T where T: C, T: P>`表示泛型类型`T`继承自类`C`且遵守协议`P`。
 
-如上所述，可以强制约束类型形参的关联类型遵守某个协议。`<T: Generator where T.Element: Equatable>`表示`T`遵守`Generator`协议，而且`T`的关联类型`T.Element`遵守`Eauatable`协议（`T`有关联类型是因为`Generator`声明了`Element`，而`T`遵守`Generator`协议）。
+如上所述，可以强制约束类型形参的关联类型遵守某个协议。例如`<T: Generator where T.Element: Equatable>`表示`T`遵守`Generator`协议，而且`T`的关联类型`T.Element`遵守`Eauatable`协议（`T`有关联类型`Element`是因为`Generator`声明了`Element`，而`T`遵守`Generator`协议）。
 
-也可以用操作符`==`来指定两个类型等效的要求。例如，有这样一个约束：`T`和`U`遵守`Generator`协议，同时要求它们的关联类型等同，可以这样来表达：`<T: Generator, U: Generator where T.Element == U.Element>`。
+也可以用操作符`==`来指定两个类型等效的关联关系。例如，有这样一个约束：`T`和`U`遵守`Generator`协议，同时要求它们的关联类型等同，可以这样来表达：`<T: Generator, U: Generator where T.Element == U.Element>`。
 
-当然，替代类型形参的类型实参必须满足所有类型形参所要求的约束和要求。
+当然，替代类型形参的类型实参必须满足所有类型形参的约束和关联类型要求。
 
-泛型函数或构造器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或要求，抑或二者皆不同。当调用重载的泛型函数或构造器时，编译器会用这些约束来决定调用哪个重载函数或构造器。
+泛型函数或初始化器可以重载，但在泛型形参子句中的类型形参必须有不同的约束或关联类型要求，抑或二者皆不同。当调用重载的泛型函数或始化器时，编译器会用这些约束来决定调用哪个重载函数或始化器。
 
-泛型类可以生成一个子类，但是这个子类也必须是泛型类。
 
 > 泛型形参子句语法  
 > *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**  
@@ -80,27 +83,30 @@ simpleMin(3.14159, 2.71828) // T is inferred to be Double
 
 泛型实参子句指定_泛型类型_的类型实参。泛型实参子句用尖括号（<>）包住，形式如下：
 
-> <`generic argument list`>
+> <`泛型实参列表`>
 
 泛型实参列表中类型实参有逗号分开。类型实参是实际具体类型的名字，用来替代泛型类型的泛型形参子句中的相应的类型形参。从而得到泛型类型的一个特化版本。如，Swift标准库的泛型字典类型定义如下：
 
+
 ```swift
 struct Dictionary<KeyTypel: Hashable, ValueType>: Collection, DictionaryLiteralConvertible {
+
     /* .. */
+
 }
 ```
 
-泛型`Dictionary`类型的特化版本，`Dictionary<String, Int>`就是用具体的`String`和`Int`类型替代泛型类型`KeyType: Hashable`和`ValueType`产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何`where`子句所指定的额外的要求。上面的例子中，类型形参`KeyType`要求满足`Hashable`协议，因此`String`也必须满足`Hashable`协议。
+泛型`Dictionary`类型的特化版本，`Dictionary<String, Int>`就是用具体的`String`和`Int`类型替代泛型类型`KeyType: Hashable`和`ValueType`产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何`where`子句所指定的额外的关联类型要求。上面的例子中，类型形参`Key`类型要求满足`Hashable`协议，因此`String`也必须满足`Hashable`协议。
 
-可以用本身就是泛型类型的特化版本的类型实参替代类型形参（假设已满足合适的约束和要求）。例如，为了生成一个元素类型是整型数组的数组，可以用数组的特化版本`Array<Int>`替代泛型类型`Array<T>`的类型形参`T`来实现。
+可以用本身就是泛型类型的特化版本的类型实参替代类型形参（假设已满足合适的约束和关联类型要求）。例如，为了生成一个元素类型是整型数组的数组，可以用数组的特化版本`Array<Int>`替代泛型类型`Array<T>`的类型形参 `T` 来实现。
 
-```swift
+```
 let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 ```
 
-如[泛型形参子句](#generic_parameter)所述，不能用泛型实参子句来指定泛型函数或构造器的类型实参。
+如[泛型形参子句](#generic_parameter)所述，不能用泛型实参子句来指定泛型函数或初始化器的类型实参。
 
 > 泛型实参子句语法  
 > *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>**  
 > *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list)  
-> *泛型参数* → [*类型*](..\chapter3\03_Types.html#type)  
\ No newline at end of file
+> *泛型参数* → [*类型*](..\chapter3\03_Types.html#type)  

From 59faefec310c75f2e2f0c5f7e7a592494d7f8f1e Mon Sep 17 00:00:00 2001
From: Perry <perry@PerrydeMac-mini.local>
Date: Tue, 30 Jun 2015 15:38:09 +0800
Subject: [PATCH 037/228] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E4=B8=A4=E6=AE=B5?=
 =?UTF-8?q?=EF=BC=8C=E4=BF=AE=E6=AD=A3=E9=83=A8=E5=88=86=E6=96=87=E6=A1=88?=
 =?UTF-8?q?=E7=BB=86=E8=8A=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/24_Access_Control.md | 125 ++++++++++++++++-----------
 1 file changed, 74 insertions(+), 51 deletions(-)

diff --git a/source/chapter2/24_Access_Control.md b/source/chapter2/24_Access_Control.md
index f2094f60..fa4e21b2 100644
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@@ -12,6 +12,7 @@
   -  [默认访问级别](#default_access_levels)
   -  [单目标应用程序的访问级别](#access_levels_for_single-target_apps)
   -  [Framework的访问级别](#access_levels_for_frameworks)
+  -  [单元测试目标的访问级别](#access_levels_for_unit_test_targets)
 - [访问控制语法](#access_control_syntax)
 - [自定义类型](#custom_types)
   -  [元组类型](#tuple_types)
@@ -33,45 +34,47 @@
 - [泛型](#generics)
 - [类型别名](#type_aliases)
 
-访问控制可以限定你在源文件或模块中访问代码的级别，也就是说可以控制哪些代码你可以访问，哪些代码你不能访问。这个特性可以让我们隐藏功能实现的一些细节，并且可以明确的指定我们提供给其他人的接口中哪些部分是他们可以使用的，哪些是他们看不到的。
+*访问控制*可以限定其他源文件或模块中代码对你代码的访问级别。这个特性可以让我们隐藏功能实现的一些细节，并且可以明确的申明我们提供给其他人的接口中哪些部分是他们可以访问和使用的。
 
-你可以明确的给类、结构体、枚举、设置访问级别，也可以给属性、函数、初始化方法、基本类型、下标索引等设置访问级别。协议也可以被限定在一定的范围内使用，包括协议里的全局常量、变量和函数。
+你可以明确地给单个类型（类、结构体、枚举）设置访问级别，也可以给这些类型的属性、函数、初始化方法、基本类型、下标索引等设置访问级别。协议也可以被限定在一定的范围内使用，包括协议里的全局常量、变量和函数。
 
-在提供了不同访问级别的同时，Swift 并没有规定我们要在任何时候都要在代码中明确指定访问级别。其实，如果我们作为独立开发者在开发我们自己的 app，而不是在开发一些`Framework`的时候，我们完全可以不用明确的指定代码的访问级别。
+在提供了不同访问级别的同时，Swift还为某些典型场景提供了默认的访问级别，这样就不需要我们在每段代码中都申明显式访问级别。其实，如果只是开发一个单目标应用程序，我们完全可以不用申明代码的显式访问级别。
 
-> 注意：为方便起见，在代码中可以设置访问级别的它们（属性、基本类型、函数等）在下面的章节中我们称之为“实体”。
+> 注意：简单起见，代码中可以设置访问级别的特性（属性、基本类型、函数等），在下面的章节中我们会以“实体”代替。
 
 <a name="modules_and_source_files"></a>
 ## 模块和源文件
 Swift 中的访问控制模型基于模块和源文件这两个概念。
 
-模块指的是`Framework`或`App bundle`。在 Swift 中，可以用`import`关键字引入自己的工程。  
+*模块*指的是以独立单元构建和发布的`Framework`或`Application`。在Swift 中的一个模块可以使用`import`关键字引入另外一个模块。
 
-在 Swift 中，`Framework`或`App bundle`被作为模块处理。如果你是为了实现某个通用的功能，或者是为了封装一些常用方法而将代码打包成`Framework`，这个`Framework`在 Swift 中就被称为模块。不论它被引入到某个 App 工程或者其他的`Framework`，它里面的一切（属性、函数等）都属于这个模块。  
+在 Swift 中，Xcode的每个构建目标（比如`Framework`或`app bundle`）都被当作模块处理。如果你是为了实现某个通用的功能，或者是为了封装一些常用方法而将代码打包成独立的`Framework`，这个`Framework`在 Swift 中就被称为模块。当它被引入到某个 app 工程或者另外一个`Framework`时，它里面的一切（属性、函数等）仍然属于这个独立的模块。  
 
-源文件指的是 Swift 中的`Swift File`，就是编写 Swift 代码的文件，它通常属于一个模块。通常一个源文件包含一个`类`，在`类`中又包含`函数`、`属性`等类型。
+*源文件*指的是 Swift 中的`Swift File`，就是编写 Swift 源代码的文件，它通常属于一个模块。尽管一般我们将不同的`类` 分别定义在不同的源文件中，但是同一个源文件可以包含多个`类`和`函数` 的定义。
 
 <a name="access_levels"></a>
 ## 访问级别
-Swift 提供了三种不同的访问级别。这些访问级别相对于源文件中定义的实体，同时也相对于这些源文件所属的模块。
+Swift 为代码中的实体提供了三种不同的访问级别。这些访问级别不仅与源文件中定义的实体相关，同时也与源文件所属的模块相关。
 
-- `Public`：可以访问自己模块或应用中源文件里的任何实体，别人也可以访问引入该模块中源文件里的所有实体。通常情况下，某个接口或`Framework`是可以被任何人使用时，你可以将其设置为`public`级别。
-- `Internal`：可以访问自己模块或应用中源文件里的任何实体，但是别人不能访问该模块中源文件里的实体。通常情况下，某个接口或`Framework`作为内部结构使用时，你可以将其设置为`internal`级别。
-- `Private`：只能在当前源文件中使用的实体，称为私有实体。使用`private`级别，可以用作隐藏某些功能的实现细节。
+- `public`：可以访问自己模块中源文件里的任何实体，别人也可以通过引入该模块来访问源文件里的所有实体。通常情况下，`Framework` 中的某个接口是可以被任何人使用时，你可以将其设置为`public`级别。
+- `internal`：可以访问自己模块中源文件里的任何实体，但是别人不能访问该模块中源文件里的实体。通常情况下，某个接口或`Framework`作为内部结构使用时，你可以将其设置为`internal`级别。
+- `private`：只能在当前源文件中使用的实体，称为私有实体。使用`private`级别，可以用作隐藏某些功能的实现细节。
 
-`Public`为最高级访问级别，`Private`为最低级访问级别。
+`public`为最高级访问级别，`private`为最低级访问级别。
+
+> 注意：Swift中的`private`访问和其他语言中的`private`访问不太一样，它的范围限于整个源文件，而不是声明。这就意味着，一个`类` 可以访问定义该`类` 的源文件中定义的所有`private`实体，但是如果一个`类` 的扩展是定义在独立的源文件中，那么就不能访问这个`类` 的`private`成员。
 
 <a name="guiding_principle_of_access_levels"></a>
 ### 访问级别的使用原则
-在 Swift 中，访问级别有如下使用原则：访问级别统一性。
+Swift 中的访问级别遵循一个使用原则：访问级别统一性。
 比如说：
 
-- 一个`public`访问级别的变量，不能将它的类型定义为`internal`和`private`的类型。因为变量可以被任何人访问，但是定义它的类型不可以，所以这样就会出现错误。
-- 函数的访问级别不能高于它的参数、返回类型的访问级别。因为如果函数定义为`public`而参数或者返回类型定义为`internal`或`private`，就会出现函数可以被任何人访问，但是它的参数和返回类型不可以，同样会出现错误。
+- 一个`public`访问级别的变量，不能将它的类型定义为`internal`和`private`。因为变量可以被任何人访问，但是定义它的类型不可以，所以这样就会出现错误。
+- 函数的访问级别不能高于它的参数、返回类型的访问级别。因为如果函数定义为`public`而参数或者返回类型定义为`internal`或`private`，就会出现函数可以被任何人访问，但是它的参数和返回类型确不可以，同样会出现错误。
 
 <a name="default_access_levels"></a>
 ### 默认访问级别
-代码中的所有实体，如果你不明确的定义其访问级别，那么它们默认为`internal`级别。在大多数情况下，我们不需要明确的设置实体的访问级别，因为我们大多数时候都是在开发一个 App bundle。
+如果你不为代码中的所有实体定义显式访问级别，那么它们默认为`internal`级别。在大多数情况下，我们不需要设置实体的显式访问级别。因为我们一般都是在开发一个`app bundle`。
 
 <a name="access_levels_for_single-target_apps"></a>
 ### 单目标应用程序的访问级别
@@ -79,9 +82,14 @@ Swift 提供了三种不同的访问级别。这些访问级别相对于源文
 
 <a name="access_levels_for_frameworks"></a>
 ### Framework的访问级别
-当你开发`Framework`时，就需要把一些实体定义为`public`级别，以便其他人导入该`Framework`后可以正常使用其功能。这些被你定义为`public`的实体，就是这个`Framework`的API。
+当你开发`Framework`时，就需要把一些对外的接口定义为`public`级别，以便其他人导入该`Framework`后可以正常使用其功能。这些被你定义为`public`的接口，就是这个`Framework`的API。
 
-> 注意：`Framework`的内部实现细节依然可以使用默认的`internal`级别，或者也可以定义为`private`级别。只有你想将它作为 API 的实体，才将其定义为`public`级别。
+> 注意：`Framework`的内部实现细节依然可以使用默认的`internal`级别，或者也可以定义为`private`级别。只有当你想把它作为 API 的一部分的时候，才将其定义为`public`级别。
+
+<a name="access_levels_for_unit_test_targets"></a>
+### 单元测试目标的访问级别
+
+当你的app有单元测试目标时，为了方便测试，测试模块需要能访问到你app中的代码。默认情况下只有`public`级别的实体才可以被其他模块访问。然而，如果在引入一个生产模块时使用`@testable`注解，然后用带测试的方式编译这个生产模块，单元测试目标就可以访问所有`internal`级别的实体。
 
 <a name="access_control_syntax"></a>
 ## 访问控制语法
@@ -97,7 +105,7 @@ internal let someInternalConstant = 0
 private func somePrivateFunction() {}
 ```
 
-除非有特殊的说明，否则实体都使用默认的访问级别`internal`，可以查阅**默认访问级别**这一节。这意味着`SomeInternalClass`和`someInternalConstant`不用明确的使用修饰符声明访问级别，但是他们任然拥有隐式的访问级别`internal`：
+除非有特殊的说明，否则实体都使用默认的访问级别`internal`，可以查阅**[默认访问级别](#default_access_levels)**这一节。这意味着在不使用修饰符声明显式访问级别的情况下，`SomeInternalClass`和`someInternalConstant`仍然拥有隐式的访问级别`internal`：
 
 ```swift
 class SomeInternalClass {}              // 隐式访问级别 internal
@@ -105,40 +113,40 @@ var someInternalConstant = 0            // 隐式访问级别 internal
 ```
 <a name="custom_types"></a>
 ## 自定义类型
-如果你想为一个自定义类型指定一个明确的访问级别，那么你要明确一点。那就是你要确保新类型的访问级别和它实际的作用域相匹配。比如说，如果某个类里的属性、函数、返回值它们的作用域仅在当前的源文件中，那么你就可以将这个类申明为`private`类，而不需要申明为`public`或者`internal`类。
+如果想为一个自定义类型申明显式访问级别，那么要明确一点。那就是你要确保新类型的访问级别和它实际的作用域相匹配。比如说，如果你定义了一个`private`类，那这个类就只能在定义它的源文件中当作属性类型、函数参数或者返回类型使用。
 
-类的访问级别也可以影响到类成员（属性、函数、初始化方法等）的默认访问级别。如果你将类申明为`private`类，那么该类的所有成员的默认访问级别也会成为`private`。如果你将类申明为`public`或者`internal`类（或者不明确的指定访问级别，而使用默认的`internal`访问级别），那么该类的所有成员的访问级别是`internal`。
+类的访问级别也可以影响到类成员（属性、函数、初始化方法等）的默认访问级别。如果你将类申明为`private`类，那么该类的所有成员的默认访问级别也会成为`private`。如果你将类申明为`public`或者`internal`类（或者不明确的申明访问级别，而使用默认的`internal`访问级别），那么该类的所有成员的访问级别是`internal`。
 
-> 注意：上面提到，一个`public`类的所有成员的访问级别默认为`internal`级别，而不是`public`级别。如果你想将某个成员申明为`public`级别，那么你必须使用修饰符明确的申明该成员。这样做的好处是，在你定义公共接口API的时候，可以明确的选择哪些属性或方法是需要公开的，哪些是内部使用的，可以避免将内部使用的属性方法公开成公共API的错误。
+> 注意：上面提到，一个`public`类的所有成员的访问级别默认为`internal`级别，而不是`public`级别。如果你想将某个成员申明为`public`级别，那么你必须使用修饰符明确的声明该成员。这样做的好处是，在你定义公共接口API的时候，可以明确的选择哪些属性或方法是需要公开的，哪些是内部使用的，可以避免将内部使用的属性方法公开成公共API的错误。
 
 ```swift
-public class SomePublicClass {          // 显示的 public 类
-   	public var somePublicProperty = 0    // 显示的 public 类成员
+public class SomePublicClass {          // 显式的 public 类
+   	public var somePublicProperty = 0    // 显式的 public 类成员
    	var someInternalProperty = 0         // 隐式的 internal 类成员
-   	private func somePrivateMethod() {}  // 显示的 private 类成员
+   	private func somePrivateMethod() {}  // 显式的 private 类成员
 }
 
 class SomeInternalClass {               // 隐式的 internal 类
    	var someInternalProperty = 0         // 隐式的 internal 类成员
-   	private func somePrivateMethod() {}  // 显示的 private 类成员
+   	private func somePrivateMethod() {}  // 显式的 private 类成员
 }
 
-private class SomePrivateClass {        // 显示的 private 类
+private class SomePrivateClass {        // 显式的 private 类
    	var somePrivateProperty = 0          // 隐式的 private 类成员
    	func somePrivateMethod() {}          // 隐式的 private 类成员
 }
 ```
 <a name="tuple_types"></a>
 ### 元组类型
-元组的访问级别使用是所有类型的访问级别使用中最为严谨的。比如说，如果你构建一个包含两种不同类型元素的元组，其中一个元素类型的访问级别为`internal`，另一个为`private`级别，那么这个元组的访问级别为`private`。也就是说元组的访问级别遵循它里面元组中最低级的访问级别。
+元组的访问级别使用是所有类型的访问级别使用中最为严谨的。比如说，如果你构建一个包含两种不同类型元素的元组，其中一个元素类型的访问级别为`internal`，另一个为`private`级别，那么这个元组的访问级别为`private`。也就是说元组的访问级别与元组中访问级别最低的类型一致。
 
 > 注意：元组不同于类、结构体、枚举、函数那样有单独的定义。元组的访问级别是在它被使用时自动推导出的，而不是明确的申明。
 
 <a name="function_types"></a>
 ### 函数类型
-函数的访问级别需要根据该函数的参数类型访问级别、返回类型访问级别得出。如果根据参数类型和返回类型得出的函数访问级别不符合上下文，那么就需要明确的申明该函数的访问级别。
+函数的访问级别需要根据该函数的参数类型和返回类型的访问级别得出。如果根据参数类型和返回类型得出的函数访问级别不符合默认上下文，那么就需要明确地申明该函数的访问级别。
 
-下面的例子中定义了一个全局函数名为`someFunction`，并且没有明确的申明其访问级别。你也许会认为该函数应该拥有默认的访问级别`internal`，但事实并非如此。事实上，如果按下面这种写法，编译器是无法编译通过的：
+下面的例子定义了一个名为`someFunction`全局函数，并且没有明确地申明其访问级别。也许你会认为该函数应该拥有默认的访问级别`internal`，但事实并非如此。事实上，如果按下面这种写法，带埋是无法编译通过的：
 
 ```swift
 func someFunction() -> (SomeInternalClass, SomePrivateClass) {
@@ -146,9 +154,9 @@ func someFunction() -> (SomeInternalClass, SomePrivateClass) {
 }
 ```
 
-我们可以看到，这个函数的返回类型是一个元组，该元组中包含两个自定义的类（可查阅**自定义类型**）。其中一个类的访问级别是`internal`，另一个的访问级别是`private`，所以根据元组访问级别的原则，该元组的访问级别是`private`（元组的访问级别遵循它里面元组中最低级的访问级别）。
+我们可以看到，这个函数的返回类型是一个元组，该元组中包含两个自定义的类（可查阅**[自定义类型](#custom_types)**）。其中一个类的访问级别是`internal`，另一个的访问级别是`private`，所以根据元组访问级别的原则，该元组的访问级别是`private`（元组的访问级别与元组中访问级别最低的类型一致）。
 
-因为该函数返回类型的访问级别是`private`，所以你必须使用`private`修饰符，明确的申请该函数：
+因为该函数返回类型的访问级别是`private`，所以你必须使用`private`修饰符，明确的声明该函数：
 
 ```swift
 private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
@@ -160,7 +168,7 @@ private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
 
 <a name="enumeration_types"></a>
 ### 枚举类型
-枚举中成员的访问级别继承自该枚举，你不能为枚举中的成员指定访问级别。
+枚举中成员的访问级别继承自该枚举，你不能为枚举中的成员单独申明不同的访问级别。
 
 比如下面的例子，枚举`CompassPoint`被明确的申明为`public`级别，那么它的成员`North`，`South`，`East`，`West`的访问级别同样也是`public`：
 
@@ -175,11 +183,11 @@ public enum CompassPoint {
 
 <a name="raw_values_and_associated_values"></a>
 ### 原始值和关联值
-用于枚举定义中的任何原始值，或关联的值类型必须有一个访问级别，至少要高于枚举的访问级别。比如说，你不能在一个`internal`访问级别的枚举中定义`private`级别的原始值类型。
+枚举定义中的任何原始值或关联值的类型都必须有一个访问级别，这个级别至少要不低于枚举的访问级别。比如说，你不能在一个`internal`访问级别的枚举中定义`private`级别的原始值类型。
 
 <a name="nested_types"></a>
 ### 嵌套类型
-如果在`private`级别的类型中定义嵌套类型，那么该嵌套类型就自动拥有`private`访问级别。如果在`public`或者`internal`级别的类型中定义嵌套类型，那么该嵌套类型自动拥有`internal`访问级别。如果想让嵌套类型拥有`public`访问级别，那么需要对该嵌套类型进行明确的访问级别申明。
+如果在`private`级别的类型中定义嵌套类型，那么该嵌套类型就自动拥有`private`访问级别。如果在`public`或者`internal`级别的类型中定义嵌套类型，那么该嵌套类型自动拥有`internal`访问级别。如果想让嵌套类型拥有`public`访问级别，那么需要明确地申明该嵌套类型的访问级别。
 
 <a name="subclassing"></a>
 ## 子类
@@ -217,7 +225,7 @@ internal class B: A {
 
 <a name="constants_variables_properties_subscripts"></a>
 ## 常量、变量、属性、下标
-常量、变量、属性不能拥有比它们的类型更高的访问级别。比如说，你定义一个`public`级别的属性，但是它的类型是`private`级别的，这是编译器不允许的。同样，下标也不能拥有比索引类型或返回类型更高的访问级别。  
+常量、变量、属性不能拥有比它们的类型更高的访问级别。比如说，你定义一个`public`级别的属性，但是它的类型是`private`级别的，这是编译器所不允许的。同样，下标也不能拥有比索引类型或返回类型更高的访问级别。  
 
 如果常量、变量、属性、下标索引的定义类型是`private`级别的，那么它们必须要明确的申明访问级别为`private`：
 
@@ -229,11 +237,11 @@ private var privateInstance = SomePrivateClass()
 ### Getter和Setter
 常量、变量、属性、下标索引的`Getters`和`Setters`的访问级别继承自它们所属成员的访问级别。
 
-`Setter`的访问级别可以低于对应的`Getter`的访问级别，这样就可以控制变量、属性或下标索引的读写权限。在`var`或`subscript`定义作用域之前，你可以通过`private(set)`或`internal(set)`先为它门的写权限申明一个较低的访问级别。
+`Setter`的访问级别可以低于对应的`Getter`的访问级别，这样就可以控制变量、属性或下标索引的读写权限。在`var`或`subscript`定义作用域之前，你可以通过`private(set)`或`internal(set)`先为它们的写权限申明一个较低的访问级别。
 
-> 注意：这个规定适用于用作存储的属性或用作计算的属性。即使你不明确的申明存储属性的`Getter`、`Setter`，Swift也会隐式的为其创建`Getter`和`Setter`，用于对该属性进行读取操作。使用`private(set)`和`internal(set)`可以改变Swift隐式创建的`Setter`的访问级别。在计算属性中也是同样的。  
+> 注意：这个规定适用于用作存储的属性或用作计算的属性。即使你不明确地申明存储属性的`Getter`、`Setter`，Swift也会隐式的为其创建`Getter`和`Setter`，用于对该属性进行读取操作。使用`private(set)`和`internal(set)`可以改变Swift隐式创建的`Setter`的访问级别。这对计算属性也同样适用。  
 
-下面的例子中定义了一个结构体名为`TrackedString`，它记录了`value`属性被修改的次数：
+下面的例子中定义了一个名为`TrackedString`的结构体，它记录了`value`属性被修改的次数：
 
 ```swift
 struct TrackedString {
@@ -247,11 +255,11 @@ struct TrackedString {
 ```
 
 
-`TrackedString`结构体定义了一个用于存储的属性名为`value`，类型为`String`，并将初始化值设为`""`（即一个空字符串）。该结构体同时也定义了另一个用于存储的属性名为`numberOfEdits`，类型为`Int`，它用于记录属性`value`被修改的次数。这个功能的实现通过属性`value`的`didSet`方法实现，每当给`value`赋新值时就会调用`didSet`方法，给`numberOfEdits`加一。   
+`TrackedString`结构体定义了一个用于存储`String`类型的属性`value`，并将初始化值设为`""`（即一个空字符串）。该结构体同时也定义了另一个用于存储`Int`类型的属性名`numberOfEdits`，它用于记录属性`value`被修改的次数。这个功能的实现通过属性`value`的`didSet`方法实现，每当给`value`赋新值时就会调用`didSet`方法，然后将`numberOfEdits`的值加一。   
 
-结构体`TrackedString`和它的属性`value`均没有明确的申明访问级别，所以它们都拥有默认的访问级别`internal`。但是该结构体的`numberOfEdits`属性使用`private(set)`修饰符进行申明，这意味着`numberOfEdits`属性只能在定义该结构体的源文件中赋值。`numberOfEdits`属性的`Getter`依然是默认的访问级别`internal`，但是`Setter`的访问级别是`private`，这表示该属性只有在当前的源文件中是可读可写的，在当前源文件所属的模块中它只是一个可读的属性。  
+结构体`TrackedString`和它的属性`value`均没有申明显式访问级别，所以它们都拥有默认的访问级别`internal`。但是该结构体的`numberOfEdits`属性使用`private(set)`修饰符进行申明，这意味着`numberOfEdits`属性只能在定义该结构体的源文件中赋值。`numberOfEdits`属性的`Getter`依然是默认的访问级别`internal`，但是`Setter`的访问级别是`private`，这表示该属性只有在当前的源文件中是可读写的，而在当前源文件所属的模块中它只是一个可读的属性。  
 
-如果你实例化`TrackedString`结构体，并且多次对`value`属性的值进行修改，你就会看到`numberOfEdits`的值会随着修改次数更改：
+如果你实例化`TrackedString`结构体，并且多次对`value`属性的值进行修改，你就会看到`numberOfEdits`的值会随着修改次数进行变化：
 
 ```swift
 var stringToEdit = TrackedString()
@@ -264,9 +272,23 @@ println("The number of edits is \(stringToEdit.numberOfEdits)")
 
 虽然你可以在其他的源文件中实例化该结构体并且获取到`numberOfEdits`属性的值，但是你不能对其进行赋值。这样就能很好的告诉使用者，你只管使用，而不需要知道其实现细节。
 
+如果有必要你可以为`Getter`和`Setter`方法设定显式访问级别。下面的例子就是明确申明了`public`访问级别的`TrackedString`结构体。结构体的成员（包括`numberOfEdits`属性）拥有默认的访问级别`internal`。你可以结合`public`和`private(set)`修饰符把结构体中的`numberOfEdits`属性`Getter`方法的访问级别设置为`public`，而`Setter`方法的访问级别设置为`private`：
+
+```swift
+public struct TrackedString {
+    public private(set) var numberOfEdits = 0
+    public var value: String = "" {
+        didSet {
+            numberOfEdits++
+        }
+    }
+    public init() {}
+}
+```
+
 <a name="initializers"></a>
 ## 初始化
-我们可以给自定义的初始化方法指定访问级别，但是必须要低于或等于它所属类的访问级别。但如果该初始化方法是必须要使用的话，那它的访问级别就必须和所属类的访问级别相同。
+我们可以给自定义的初始化方法申明访问级别，但是要不高于它所属类的访问级别。但[必要构造器](TODO)例外，它的访问级别必须和所属类的访问级别相同。
 
 如同函数或方法参数，初始化方法参数的访问级别也不能低于初始化方法的访问级别。
 
@@ -284,7 +306,7 @@ Swift为结构体、类都提供了一个默认的无参初始化方法，用于
 
 <a name="protocols"></a>
 ## 协议
-如果你想为一个协议明确的申明访问级别，那么有一点需要注意，就是你要确保该协议只在你申明的访问级别作用域中使用。  
+如果想为一个协议明确的申明访问级别，那么需要注意一点，就是你要确保该协议只在你申明的访问级别作用域中使用。  
 
 协议中的每一个必须要实现的函数都具有和该协议相同的访问级别。这样才能确保该协议的使用者可以实现它所提供的函数。
 
@@ -298,17 +320,17 @@ Swift为结构体、类都提供了一个默认的无参初始化方法，用于
 ### 协议一致性
 类可以采用比自身访问级别低的协议。比如说，你可以定义一个`public`级别的类，可以让它在其他模块中使用，同时它也可以采用一个`internal`级别的协议，并且只能在定义了该协议的模块中使用。
 
-采用了协议的类的访问级别遵循它本身和采用协议中最低的访问级别。也就是说如果一个类是`public`级别，采用的协议是`internal`级别，那个采用了这个协议后，该类的访问级别也是`internal`。
+采用了协议的类的访问级别取它本身和所采用协议中最低的访问级别。也就是说如果一个类是`public`级别，采用的协议是`internal`级别，那么采用了这个协议后，该类的访问级别也是`internal`。
 
-如果你采用了协议，那么实现了协议必须的方法后，该方法的访问级别遵循协议的访问级别。比如说，一个`public`级别的类，采用了`internal`级别的协议，那么该类实现协议的方法至少也得是`internal`。
+如果你采用了协议，那么实现了协议所必须的方法后，该方法的访问级别遵循协议的访问级别。比如说，一个`public`级别的类，采用了`internal`级别的协议，那么该类实现协议的方法至少也得是`internal`。
 
-> 注意：在Swift中和Objective-C中一样，协议的一致性保证了一个类不可能在同一个程序中用不同的方法采用同一个协议。
+> 注意：Swift和Objective-C一样，协议的一致性保证了一个类不可能在同一个程序中用不同的方法采用同一个协议。
 
 <a name="extensions"></a>
 ## 扩展
 你可以在条件允许的情况下对类、结构体、枚举进行扩展。扩展成员应该具有和原始类成员一致的访问级别。比如你扩展了一个公共类型，那么你新加的成员应该具有和原始成员一样的默认的`internal`访问级别。
 
-或者，你可以明确申明扩展的访问级别（比如使用`private extension`）给该扩展内所有成员指定一个新的默认访问级别。这个新的默认访问级别仍然可以被单独成员所指定的访问级别所覆盖。
+或者，你可以明确申明扩展的访问级别（比如使用`private extension`）给该扩展内所有成员申明一个新的默认访问级别。这个新的默认访问级别仍然可以被单独成员所申明的访问级别所覆盖。
 
 <a name="adding_protocol_conformance_with_an_extension"></a>
 ### 协议的扩展
@@ -316,12 +338,13 @@ Swift为结构体、类都提供了一个默认的无参初始化方法，用于
 
 <a name="generics"></a>
 ## 泛型
-泛型类型或泛型函数的访问级别遵循泛型类型、函数本身、泛型类型参数三者中访问级别最低的级别。
+泛型类型或泛型函数的访问级别取泛型类型、函数本身、泛型类型参数三者中的最低访问级别。
 
 <a name="type_aliases"></a>
 ## 类型别名
-任何被你定义的类型别名都会被视作为不同的类型，这些类型用于访问控制。一个类型别名的访问级别可以低于或等于这个类型的访问级别。比如说，一个`private`级别的类型别名可以设定给一个`public`、`internal`、`private`的类型，但是一个`public`级别的类型别名只能设定给一个`public`级别的类型，不能设定给`internal`或`private`的类类型。
+任何你定义的类型别名都会被当作不同的类型，以便于进行访问控制。一个类型别名的访问级别不可高于原类型的访问级别。比如说，一个`private`级别的类型别名可以设定给一个`public`、`internal`、`private`的类型，但是一个`public`级别的类型别名只能设定给一个`public`级别的类型，不能设定给`internal`或`private` 级别的类型。
+
+> 注意：这条规则也适用于为满足协议一致性而给相关类型命名别名的情况。
 
-> 注意：这条规则也适用于为满足协议一致性而给相关类型命名别名。
 
 

From 657e4589990b434b3f7b3121242547ba8683fc8f Mon Sep 17 00:00:00 2001
From: Siyu Yang <yangsiyu1992@gmail.com>
Date: Tue, 30 Jun 2015 16:09:11 +0800
Subject: [PATCH 038/228] =?UTF-8?q?=E5=AE=8C=E6=88=90Chapter2=5FType=5FCas?=
 =?UTF-8?q?ting=E9=83=A8=E5=88=86=E6=A0=A1=E5=AF=B9=E5=8F=8A=E6=9B=B4?=
 =?UTF-8?q?=E6=96=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/20_Type_Casting.md | 101 +++++++++++++++--------------
 1 file changed, 52 insertions(+), 49 deletions(-)

diff --git a/source/chapter2/20_Type_Casting.md b/source/chapter2/20_Type_Casting.md
index cea8fe3d..dc72a95f 100644
--- a/source/chapter2/20_Type_Casting.md
+++ b/source/chapter2/20_Type_Casting.md
@@ -1,5 +1,5 @@
 > 翻译：[xiehurricane](https://github.com/xiehurricane)
-> 校对：[happyming](https://github.com/happyming)
+> 校对：[happyming](https://github.com/happyming) [yangsiy](https://github.com/yangsiy)
 
 # 类型转换（Type Casting）
 -----------------
@@ -14,16 +14,16 @@
 
 _类型转换_可以判断实例的类型，也可以将实例看做是其父类或者子类的实例。
 
-类型转换在 Swift 中使用`is` 和 `as`操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
+类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
 
-你也可以用来检查一个类是否实现了某个协议，就像在 [Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。
+你也可以用它来检查一个类是否实现了某个协议，就像在 [Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。
 
 <a name="defining_a_class_hierarchy_for_type_casting"></a>
 ## 定义一个类层次作为例子
 
-你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型转换的例子。
+你可以将类型转换用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型转换的例子。
 
-第一个代码片段定义了一个新的基础类`MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个`init name`初始化器。（它假定所有的媒体项都有个名称。）
+第一个代码片段定义了一个新的基础类 `MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个 `init name` 初始化器。（假定所有的媒体项都有个名称。）
 
 ```swift
 class MediaItem {
@@ -34,7 +34,7 @@ class MediaItem {
 }
 ```
 
-下一个代码段定义了 `MediaItem` 的两个子类。第一个子类`Movie`，在父类（或者说基类）的基础上增加了一个 `director`（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 `artist`（艺术家） 属性，和相应的初始化器：
+下一个代码段定义了 `MediaItem` 的两个子类。第一个子类 `Movie` 封装了与电影相关的额外信息，在父类（或者说基类）的基础上增加了一个 `director`（导演）属性，和相应的初始化器。第二个子类 `Song`，在父类的基础上增加了一个 `artist`（艺术家）属性，和相应的初始化器：
 
 ```swift
 class Movie: MediaItem {
@@ -54,7 +54,7 @@ class Song: MediaItem {
 }
 ```
 
-最后一个代码段创建了一个数组常量 `library`，包含两个`Movie`实例和三个`Song`实例。`library`的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出`Movie` 和 `Song` 有共同的父类 `MediaItem` ，所以它推断出 `[MediaItem]` 类作为 `library` 的类型。
+最后一个代码段创建了一个数组常量 `library`，包含两个 `Movie` 实例和三个 `Song` 实例。`library` 的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift的类型检测器能够推理出 `Movie` 和 `Song` 有共同的父类 `MediaItem`，所以它推断出 `[MediaItem]` 类作为 `library` 的类型。
 
 ```swift
 let library = [
@@ -67,14 +67,14 @@ let library = [
 // the type of "library" is inferred to be [MediaItem]
 ```
 
-在幕后`library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的，但是，若你迭代它，取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。
+在幕后 `library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的。但是，若你迭代它，依次取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型。为了让它们作为原本的类型工作，你需要检查它们的类型或者向下转换它们到其它类型，就像下面描述的一样。
 
 <a name="checking_type"></a>
 ## 检查类型（Checking Type）
 
-用类型检查操作符(`is`)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true` ，否则返回 `false` 。
+用类型检查操作符(`is`)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 `true`，否则返回 `false`。
 
-下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组`library` 中 `Movie` 和 `Song` 类型的实例数量。
+下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组 `library` 中 `Movie` 和 `Song` 类型的实例数量。
 
 ```swift
 var movieCount = 0
@@ -88,38 +88,38 @@ for item in library {
     }
 }
 
-println("Media library contains \(movieCount) movies and \(songCount) songs")
+print("Media library contains \(movieCount) movies and \(songCount) songs")
 // prints "Media library contains 2 movies and 3 songs"
 ```
 
-示例迭代了数组 `library` 中的所有项。每一次， `for`-`in` 循环设置
+示例迭代了数组 `library` 中的所有项。每一次，`for`-`in` 循环设置
 `item` 为数组中的下一个 `MediaItem`。
 
-若当前 `MediaItem` 是一个 `Movie` 类型的实例， `item is Movie` 返回
+若当前 `MediaItem` 是一个 `Movie` 类型的实例，`item is Movie` 返回
 `true`，相反返回 `false`。同样的，`item is
-Song`检查item是否为`Song`类型的实例。在循环结束后，`movieCount` 和 `songCount`的值就是被找到属于各自的类型的实例数量。
+Song` 检查item是否为 `Song` 类型的实例。在循环结束后，`movieCount` 和 `songCount` 的值就是被找到属于各自的类型的实例数量。
 
 <a name="downcasting"></a>
 ## 向下转型（Downcasting）
 
-某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型转换操作符(`as`)
+某类型的一个常量或变量可能在幕后实际上属于一个子类。当确定是这种情况时，你可以尝试向下转到它的子类型，用类型转换操作符(`as?` 或 `as!`)
 
-因为向下转型可能会失败，类型转型操作符带有两种不同形式。可选形式（ optional form） `as?` 返回一个你试图下转成的类型的可选值（optional value）。强制形式 `as` 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。
+因为向下转型可能会失败，类型转型操作符带有两种不同形式。条件形式（conditional form） `as?` 返回一个你试图向下转成的类型的可选值（optional value）。强制形式 `as!` 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。
 
-当你不确定向下转型可以成功时，用类型转换的可选形式(`as?`)。可选形式的类型转换总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil` 。这使你能够检查向下转型是否成功。
+当你不确定向下转型可以成功时，用类型转换的条件形式(`as?`)。条件形式的类型转换总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil`。这使你能够检查向下转型是否成功。
 
-只有你可以确定向下转型一定会成功时，才使用强制形式。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。
+只有你可以确定向下转型一定会成功时，才使用强制形式(`as!`)。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。
 
-下面的例子，迭代了`library`里的每一个 `MediaItem` ，并打印出适当的描述。要这样做，`item`需要真正作为`Movie` 或 `Song`的类型来使用。不仅仅是作为 `MediaItem`。为了能够使用`Movie` 或 `Song`的 `director` 或 `artist`属性，这是必要的。
+下面的例子，迭代了 `library` 里的每一个 `MediaItem`，并打印出适当的描述。要这样做，`item` 需要真正作为 `Movie` 或 `Song` 的类型来使用，不仅仅是作为 `MediaItem`。为了能够在描述中使用 `Movie` 或 `Song` 的 `director` 或 `artist` 属性，这是必要的。
 
-在这个示例中，数组中的每一个`item`可能是 `Movie` 或 `Song`。   事前你不知道每个`item`的真实类型，所以这里使用可选形式的类型转换 （`as?`）去检查循环里的每次下转。
+在这个示例中，数组中的每一个 `item` 可能是 `Movie` 或 `Song`。事前你不知道每个 `item` 的真实类型，所以这里使用条件形式的类型转换(`as?`)去检查循环里的每次下转。
 
 ```swift
 for item in library {
     if let movie = item as? Movie {
-        println("Movie: '\(movie.name)', dir. \(movie.director)")
+        print("Movie: '\(movie.name)', dir. \(movie.director)")
     } else if let song = item as? Song {
-        println("Song: '\(song.name)', by \(song.artist)")
+        print("Song: '\(song.name)', by \(song.artist)")
     }
 }
 
@@ -131,18 +131,19 @@ for item in library {
 ```
 
 示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem`
-类型的实例，它可能是一个`Movie`；同样，它可能是一个 `Song`，或者仅仅是基类
-`MediaItem`。因为不确定，`as?`形式在试图下转时将返还一个可选值。 `item as Movie` 的返回值是`Movie?`类型或 “optional `Movie`”。
+类型的实例，它可能是一个 `Movie`；同样，它也可能是一个 `Song`，或者仅仅是基类
+`MediaItem`。因为不确定，`as?`形式在试图下转时将返回一个可选值。`item as? Movie` 的返回值是 `Movie?` 或 “可选 `Movie`”类型。
 
 当向下转型为 `Movie` 应用在两个 `Song`
-实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 `Movie`真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”，可以这样解读：
+实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 `Movie` 真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”，可以这样解读：
 
-“尝试将 `item` 转为 `Movie`类型。若成功，设置一个新的临时常量 `movie`  来存储返回的可选`Movie`”
+“尝试将 `item` 转为 `Movie` 类型。若成功，设置一个新的临时常量 `movie` 来存储返回的可选 `Movie`”
 
-若向下转型成功，然后`movie`的属性将用于打印一个`Movie`实例的描述，包括它的导演的名字`director`。当`Song`被找到时，一个相近的原理被用来检测 `Song` 实例和打印它的描述。
+若向下转型成功，然后 `movie` 的属性将用于打印一个 `Movie` 实例的描述，包括它的导演的名字 `director` 。相近的原理被用来检测 `Song` 实例，当 `Song` 被找到时则打印它的描述（包含 `artist` 的名字）。
 
 > 注意：
-转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
+
+>转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
 
 <a name="type_casting_for_any_and_anyobject"></a>
 ## `Any`和`AnyObject`的类型转换
@@ -153,11 +154,12 @@ Swift为不确定类型提供了两种特殊类型别名：
 * `Any`可以表示任何类型，包括方法类型（function types）。
 
 > 注意：
-只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
+
+>只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
 
 ### `AnyObject`类型
 
-当需要在工作中使用 Cocoa APIs，它一般接收一个`[AnyObject]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。
+当在工作中使用 Cocoa APIs，我们一般会接收一个`[AnyObject]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以从 API 提供的信息中清晰地确定数组中对象的类型。
 
 在这些情况下，你可以使用强制形式的类型转换(`as`)来下转在数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解析（optional unwrapping）。
 
@@ -171,23 +173,23 @@ let someObjects: [AnyObject] = [
 ]
 ```
 
-因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as`)下转并解包到不可选的`Movie`类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。
+因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as!`)下转并解包到不可选的`Movie`类型：
 
 ```swift
 for object in someObjects {
-    let movie = object as Movie
-    println("Movie: '\(movie.name)', dir. \(movie.director)")
+    let movie = object as! Movie
+    print("Movie: '\(movie.name)', dir. \(movie.director)")
 }
 // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
 // Movie: 'Moon', dir. Duncan Jones
 // Movie: 'Alien', dir. Ridley Scott
 ```
 
-为了变为一个更短的形式，下转`someObjects`数组为`[Movie]`类型来代替下转每一项方式。
+为了变为一个更短的形式，下转`someObjects`数组为`[Movie]`类型来代替下转数组中每一项的方式。
 
 ```swift
 for movie in someObjects as! [Movie] {
-    println("Movie: '\(movie.name)', dir. \(movie.director)")
+    print("Movie: '\(movie.name)', dir. \(movie.director)")
 }
 // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
 // Movie: 'Moon', dir. Duncan Jones
@@ -196,7 +198,7 @@ for movie in someObjects as! [Movie] {
 
 ### `Any`类型
 
-这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括非`class`类型。它创建了一个可以存储`Any`类型的数组 `things`。
+这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括方法类型和非 `class` 类型。它创建了一个可以存储`Any`类型的数组 `things`。
 
 ```swift
 var things = [Any]()
@@ -211,33 +213,33 @@ things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))
 things.append({ (name: String) -> String in "Hello, \(name)" })
 ```
 
-`things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，Ivan Reitman 导演的电影“Ghostbusters”。
+`things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，电影“Ghostbusters”，和一个获取 `String` 值并返回另一个 `String` 值的闭包表达式。
 
-你可以在 `switch` `cases`里用`is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject`的常量或变量的类型。 下面的示例迭代 `things`数组中的每一项的并用`switch`语句查找每一项的类型。这几种`switch`语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值：
+你可以在 `switch` 表达式的cases中使用 `is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject` 的常量或变量的类型。下面的示例迭代 `things` 数组中的每一项的并用`switch`语句查找每一项的类型。这几种 `switch` 语句的情形绑定它们匹配的值到一个规定类型的常量，让它们的值可以被打印：
 
 ```swift
 for thing in things {
     switch thing {
     case 0 as Int:
-        println("zero as an Int")
+        print("zero as an Int")
     case 0 as Double:
-        println("zero as a Double")
+        print("zero as a Double")
     case let someInt as Int:
-        println("an integer value of \(someInt)")
+        print("an integer value of \(someInt)")
     case let someDouble as Double where someDouble > 0:
-        println("a positive double value of \(someDouble)")
+        print("a positive double value of \(someDouble)")
     case is Double:
-        println("some other double value that I don't want to print")
+        print("some other double value that I don't want to print")
     case let someString as String:
-        println("a string value of \"\(someString)\"")
+        print("a string value of \"\(someString)\"")
     case let (x, y) as (Double, Double):
-        println("an (x, y) point at \(x), \(y)")
+        print("an (x, y) point at \(x), \(y)")
     case let movie as Movie:
-        println("a movie called '\(movie.name)', dir. \(movie.director)")
+        print("a movie called '\(movie.name)', dir. \(movie.director)")
     case let stringConverter as String -> String:
-        println(stringConverter("Michael"))
+        print(stringConverter("Michael"))
     default:
-        println("something else")
+        print("something else")
     }
 }
 
@@ -253,4 +255,5 @@ for thing in things {
 
 
 > 注意：
-在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。
+
+>在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 `switch` case 语句的内容中这种检查总是安全的。

From 19f3bd8ca1d42e302044e3af17ea7d677100af85 Mon Sep 17 00:00:00 2001
From: KYawn <K.Yawn@icloud.com>
Date: Tue, 30 Jun 2015 18:12:21 +0800
Subject: [PATCH 039/228] swift 2.0 chapter3 01 and 06

---
 .../01_About_the_Language_Reference.md        |  24 ++-
 source/chapter3/06_Attributes.md              | 183 ++++++++++++------
 2 files changed, 135 insertions(+), 72 deletions(-)

diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md
index aafce2d3..f2f2ef11 100755
--- a/source/chapter3/01_About_the_Language_Reference.md
+++ b/source/chapter3/01_About_the_Language_Reference.md
@@ -1,5 +1,5 @@
 > 翻译：[dabing1022](https://github.com/dabing1022)  
-> 校对：[numbbbbb](https://github.com/numbbbbb)
+> 校对：[numbbbbb](https://github.com/numbbbbb), [KYawn](https://github.com/KYawn)
 
 
 # 关于语言附注
@@ -11,28 +11,32 @@
 
 本书的这一节描述了Swift编程语言的形式语法。这里描述的语法是为了帮助您更详细的了解该语言，而不是让您直接实现一个解析器或编译器。
 
-
-Swift语言相对小点，这是由于在Swift代码中几乎无处不在的许多常见的的类型，函数以及运算符都由Swift标准库来定义。虽然这些类型，函数和运算符不是Swift语言本身的一部分，但是它们被广泛用于这本书的讨论和代码范例。
+Swift语言相对小一点，这是由于在Swift代码中几乎所有常见的类型、函数以及运算符都已经在Swift标准库中定义了。虽然这些类型、函数和运算符并不是Swift语言自身的一部分，但是它们被广泛应用于本书的讨论和代码范例中。
 
 <a name="how_to_read_the_grammar"></a>
 ## 如何阅读语法
 
-用来描述Swift编程语言形式语法的记法遵循下面几个约定：
+用来描述Swift编程语言形式语法的标记遵循下面几个约定：
 
--  箭头（→）用来标记语法产式，可以被理解为“可以包含”。
--  句法范畴由*斜体*文字表示，并出现在一个语法产式规则两侧。
--  义词和标点符号由粗体固定宽度的文本显示和只出现在一个语法产式规则的右边。
+-  箭头（→）用来标记语法产式，可以理解为“可以包含”。
+-  *斜体*文字用来表示句法分类，并出现在一个语法产式规则两侧。
+-  义词和标点符号由粗体固定宽度的文本标记，而且只出现在一个语法产式规则的右侧。
 -  选择性的语法产式由竖线（|）分隔。当可选用的语法产式太多时，为了阅读方便，它们将被拆分为多行语法产式规则。
--  在少数情况下，常规字体文字用来描述语法产式规则的右边。
--  可选的句法范畴和文字用尾标`opt`来标记。
+-  少数情况下，常规字体文字用来描述语法产式规则的右边。
+-  可选的句法分类和文字用尾标`opt`来标记。
 
 举个例子，getter-setter的语法块的定义如下：
 
 > GRAMMAR OF A GETTER-SETTER BLOCK  
 > *getter-setter-block* → {­ [*getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) [­*setter-clause*­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause)*opt* ­}­ | {­ [*setter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause) [­*getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause)­}­
 
-这个定义表明，一个getter-setter方法​​块可以由一个getter子句后跟一个可选的setter子句构成，用大括号括起来，或者由一个setter子句后跟一个getter子句构成，用大括号括起来。上述的文法产生等价于下面的两个产生，明确阐明如何二中择一：
+这个定义表明，一个getter-setter方法​​块可以由一个getter子句后跟一个可选的setter子句构成，然后用大括号括起来，或者由一个setter子句后跟一个getter子句构成，然后用大括号括起来。下面的两个语法产式等价于上述的语法产式，并明确指出了如何取舍：
 
 > GRAMMAR OF A GETTER-SETTER BLOCK  
 > getter-setter-block → {­ [*getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) [*­setter-clause*­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause)*opt* ­}­­  
 > getter-setter-block → {­ [*setter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause) [*­getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause)­}­
+
+
+
+
+
diff --git a/source/chapter3/06_Attributes.md b/source/chapter3/06_Attributes.md
index 2ffa3872..e6063258 100755
--- a/source/chapter3/06_Attributes.md
+++ b/source/chapter3/06_Attributes.md
@@ -1,5 +1,5 @@
 > 翻译：[Hawstein](https://github.com/Hawstein)  
-> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
+> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai), [KYawn](https://github.com/KYawn)
 
 # 特性
 -----------------
@@ -9,7 +9,7 @@
 - [声明特性](#declaration_attributes)
 - [类型特性](#type_attributes)
 
-特性提供了关于声明和类型的更多信息。在Swift中有两类特性，用于修饰声明的以及用于修饰类型的。例如，`required`特性，当应用于一个类的指定或便利初始化器声明时，表明它的每个子类都必须实现那个初始化器。再比如`noreturn`特性，当应用于函数或方法类型时，表明该函数或方法不会返回到它的调用者。
+特性提供了关于声明和类型的更多信息。在Swift中有两类特性，用于修饰声明的以及用于修饰类型的。
 
 通过以下方式指定一个特性：符号`@`后面跟特性名，如果包含参数，则把参数带上：
 
@@ -23,30 +23,44 @@
 
 声明特性只能应用于声明。然而，你也可以将`noreturn`特性应用于函数或方法类型。
 
-`availability`
+`autoclosure`
 
+这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以声明返回表达式自身类型的没有参数的方法类型，也可以用于函数参数的声明。含有`autoclosure`特性的声明同时也具有`noescape`的特性，除非传递可选参数`escaping`.关于怎样使用`autoclosure`特性的例子，参见[函数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/doc/uid/TP40014097-CH31-ID449).
 
-将`availability`特性用于声明时，将表示该声明的生命周期会依赖于特定的平台和操作系统版本。
-`availability`特性总会与参数列表一同出现，该参数列表至少有两个参数，参数之间由逗号分隔。第一个参数由以下这些平台名字中的一个起头：iOS, iOSApplicationExtension, OSX, or OSXApplicationExtension。当然，你也可以用一个星号(*)来表示，该声明在上面提到的所有平台上都是有效的。剩下的参数，可以以任何顺序出现，并且可以附加关于声明生命周期的附加信息，包括重要的里程碑。
+`available`
 
-- `unavailable`参数表示该声明在特定的平台上是无效的
+将`available`特性用于声明时，意味着该声明的生命周期会依赖于特定的平台和操作系统版本。
 
+`available`特性经常与参数列表一同出现，该参数列表至少有两个参数，参数之间由逗号分隔。这些参数由以下这些平台名字中的一个起头：
 
-- `introduced`参数表示：特定的平台上，该声明被使用的第一个版本。格式如下:<p>`introduced=version number`<p>这里的`version number`由一个正的十进制整数或浮点数构成。
+- `iOS`
+- `iOSApplicationExtension`
+- `OSX`
+- `OSXApplicationExtension`
+- `watchOS`
 
-- `deprecated`参数表示：特定的平台上，该声明被建议弃用的第一个版本。格式如下：
+当然，你也可以用一个星号(*)来表示，该声明在上面提到的所有平台上都是有效的。
+
+剩下的参数，可以以任何顺序出现，并且可以添加关于声明生命周期的附加信息，包括重要的里程碑。
+
+- `unavailable`参数表示：该声明在特定的平台上是无效的
+
+- `introduced`参数表示：该声明第一次被引入时所在平台的版本。格式如下：
+<p>`introduced=version number`<p>这里的`version number`由一个正的十进制整数或浮点数构成。
+
+- `deprecated`参数表示：该声明第一次被建议弃用时所在平台的版本。格式如下：
 <p>`deprecated=version number`<p>这里的`version number`由一个正的十进制整数或浮点数构成。
 
-- `obsoleted`参数表示：特定的平台上，该声明被弃用的第一个版本。格式如下：
-<p>`deprecated=version number`<p>这里的`version number`由一个正的十进制整数或浮点数构成。
+- `obsoleted`参数表示：该声明第一次被弃用时所在平台的版本。当一个声明被弃用时，它就从此平台中被移除，不能再被使用。格式如下：
+<p>`obsoleted=version number`<p>这里的`version number`由一个正的十进制整数或浮点数构成。
 
-- `message`参数用来提供文本信息，并在因使用建议弃用或者被弃用的声明而遇到警告或错误时，由编译器抛出。格式如下：
+- `message`参数用来提供文本信息。当使用建议弃用或者被弃用的声明时，编译器会抛出错误或警告信息。格式如下：
 <p>`message=message`<p>这里的`message`由一个字符串文字构成。
 
-- `renamed`参数用来提供文本信息，用以表示被重命名的声明的新名字。当使用这个重命名的声明遇到错误时，该新名字会被编译器显示出来。格式如下：
+- `renamed`参数用来提供文本信息，用以表示被重命名的声明的新名字。当使用这个重命名的声明遇到错误时，编译器会显示出该新名字。格式如下：
 <p>`renamed=new name`<p>这里的`new name`由一个字符串文字构成。
 
-你可以将`renamed`参数和`unavailable`参数以及类型别名声明组合使用，以向用户表示：在你的代码中，一个声明已经被重命名。当一个声明的名字在一个框架或者库的不同发布版本间发生变化时，这会相当管用。
+你可以将`renamed`参数和`unavailable`参数以及类型别名声明组合使用，以向用户表示：在你的代码中，一个声明已经被重命名。当一个声明的名字在一个框架或者库的不同发布版本间发生变化时，这会相当有用。
 
 ```swift
 // First release
@@ -58,50 +72,34 @@ protocol MyRenamedProtocol {
     // protocol definition
 }
  
-@availability(*, unavailable, renamed="MyRenamedProtocol")
+@available(*, unavailable, renamed="MyRenamedProtocol")
 typealias MyProtocol = MyRenamedProtocol
 ```
 
 
-你可以在一个单独的声明上使用多个`availability`特性，以详细说明该声明在不同平台上的有效性。编译器只有在当前的目标平台和`availability`特性中指定的平台匹配时，才会使用`availability`特性
+你可以在一个单独的声明上使用多个`available`特性，以详细说明该声明在不同平台上的有效性。编译器只有在当前的目标平台和`available`特性中指定的平台匹配时，才会使用`available`特性
 
-`autoclosure`
+如果`available`特性除了平台名称参数外，只指定了一个`introduced `参数，那么可以使用以下简写语法代替：
 
-这个属性通过把表达式自动封装成不带参数的闭包来延迟表达式的计算。这个属性使用在函数参数声明或者不带参数但是返回表达式类型的方法类型上。含有```autoclosure```属性的声明同时也具有```noescape```的特性，除非传递一个可选的参数属性```escaping```，请看[函数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/doc/uid/TP40014097-CH31-ID449)。
+@available(`platform name` `version number`, *)
 
-`noescape`
-
-在函数或者方法声明上使用该属性表示参数将不会被存储用作后续的计算，其用来确保不会超出函数调用的声明周期。使用```noescape```声明属性的函数类型不需要显式的使用```self```,对于其属性或者方法来说。
-
-`noreturn`
-
-该特性用于修饰函数或方法声明，表明该函数或方法的对应类型，`T`，是`@noreturn T`。你可以用这个特性修饰函数或方法的类型，这样一来，函数或方法就不会返回到它的调用者中去。
-
-对于一个没有用`noreturn`特性标记的函数或方法，你可以将它重写(override)为用该特性标记的。相反，对于一个已经用`noreturn`特性标记的函数或方法，你则不可以将它重写为没使用该特性标记的。相同的规则试用于当你在一个comforming类型中实现一个协议方法时。
-
-`NSApplicationMain`
-在类上使用该属性表示该类是应用程序委托类，使用该属性与调用```NSApplicationMain```函数并且把该类的名字作为委托类的名字传递给函数的效果相同。
-
-如果你不想使用这个属性，可以提供一个```main.swift```文件，并且提供一个```main```函数去调用```NSApplicationMain```函数。比如，如果你的应用程序使用一个派生于```NSApplication```的自定义子类作为主要类，你可以调用```NSApplicationMain```函数而不是使用该属性。
-
-
-`NSCopying`
-
-该特性用于修饰一个类的存储型变量属性。该特性将使属性的setter与属性值的一个副本合成，由`copyWithZone`方法返回，而不是属性本身的值。该属性的类型必需遵循`NSCopying`协议。
-
-`NSCopying`特性的行为与Objective-C中的`copy`特性相似。
-
-`NSManaged`
-
-该特性用于修饰`NSManagedObject`子类中的存储型变量属性，表明属性的存储和实现由Core Data在运行时基于相关实体描述动态提供。
+`available`特性的简写语法可以简明地表达出多个平台的可用性。尽管这两种形式在功能上是相同的，但请尽可能地使用简明语法形式。
+```swift
+@available(iOS 8.0, OSX 10.10, *)
+class MyClass {
+    // class definition
+}
+```
 
 `objc`
 
-该特性用于修饰任意可以在Objective-C中表示的声明，比如，非嵌套类，协议，类和协议中的属性和方法（包含getter和setter），初始化器，析构器，以及下标。`objc`特性告诉编译器该声明可以在Objective-C代码中使用。
+该特性用于修饰任何可以在Objective-C中表示的声明。比如，非嵌套类、协议、非泛型枚举（仅限整型值类型）、类和协议的属性和方法（包括`getter`和`setter`）、构造器、析构器以及下标。`objc`特性告诉编译器这个声明可以在Objective-C代码中使用。
 
-如果你将`objc`特性应用于一个类或协议，它也会隐式地应用于那个类或协议的成员。对于标记了`objc`特性的类，编译器会隐式地为它的子类添加`objc`特性。标记了`objc`特性的协议不能继承自没有标记`objc`的协议。
+如果你将`objc`特性应用于一个类或协议，它也会隐式地应用于那个类的成员或协议。对于标记了`objc`特性的类，编译器会隐式地为它的子类添加`objc`特性。标记了`objc`特性的协议不能继承没有标记`objc`的协议。
 
-`objc`特性有一个可选的参数，由标记符组成。当你想把`objc`所修饰的实体以一个不同的名字暴露给Objective-C，你就可以使用这个特性参数。你可以使用这个参数来命名类，协议，方法，getters，setters，以及初始化器。下面的例子把`ExampleClass`中`enabled`属性的getter暴露给Objective-C，名字是`isEnabled`，而不是它原来的属性名。
+如果你将`objc`特性应用于枚举，每一个枚举的`case`都会以枚举名称和`case`名称组合的方式暴露在Objective-C代码中。例如：一个名为`Venus`的`case`在`Planet`枚举中，这个`case`暴露在Objective-C代码中时叫做`PlanetVenus`。
+
+`objc`特性有一个可选的参数，由标记符组成。当你想把`objc`所修饰的实体以一个不同的名字暴露给Objective-C时，你就可以使用这个特性参数。你可以使用这个参数来命名类，协议，方法，getters，setters，以及构造器。下面的例子把`ExampleClass`中`enabled`属性的getter暴露给Objective-C，名字是`isEnabled`，而不是它原来的属性名。
 
 ```swift
 @objc
@@ -114,17 +112,64 @@ class ExampleClass {
 }
 ```
 
-`optional`
+`noescape`
 
-用该特性修饰协议的属性，方法或下标成员，表示实现这些成员并不需要一致性类型（conforming type）。
+在函数或者方法声明上使用该特性，它表示参数将不会被存储用作后续的计算，其用来确保不会超出函数调用的生命周期。对于其属性或方法来说，使用`noescape`声明属性的函数类型不需要显式的使用`self.`。
 
-你只能用`optional`特性修饰那些标记了`objc`特性的协议。因此，只有类类型可以adopt和comform to那些包含可选成员需求的协议。更多关于如何使用`optional`特性以及如何访问可选协议成员的指导，例如，当你不确定一个conforming类型是否实现了它们，请见：[可选协议需求]()。
+`nonobjc`
 
-`required`
+该特性用于方法、属性、下标、或构造器的声明，这些声明本是可以在Objective-C代码中表示的。使用`nonobjc`特性告诉编译器这个声明不能在Objective-C代码中使用。
 
-用该特性修饰一个类的指定或便利初始化器，表示该类的所有子类都必需实现该初始化器。
+可以使用`nonobjc`特性解决标有`objc`的类中桥接方法的循环问题，该特性还允许标有`objc`的类的构造器和方法进行重载(overload)。
 
-加了该特性的指定初始化器必需显式地实现，而便利初始化器既可显式地实现，也可以在子类实现了超类所有指定初始化器后继承而来（或者当子类使用便利初始化器重写了指定初始化器）。
+标有`nonobjc`特性的方法不能重写(override)一个标有`objc`特性的方法。然而，标有`objc`特性的方法可以重写标有`nonobjc`特性的方法。同样，标有`nonobjc`特性的方法不能满足一个需要标有`@objc`特性的方法的协议。
+
+`noreturn`
+
+该特性用于修饰函数或方法声明，表明该函数或方法的对应类型，`T`，是`@noreturn T`。你可以用这个特性修饰函数或方法的类型，这样一来，函数或方法就不会返回到它的调用者中去。
+
+对于一个没有用`noreturn`特性标记的函数或方法，你可以将它重写为用该特性标记的。相反，对于一个已经用`noreturn`特性标记的函数或方法，你则不可以将它重写为没使用该特性标记的。当你在一个comforming类型中实现一个协议方法时，该规则同样适用。
+
+`NSApplicationMain`
+
+在类上使用该特性表示该类是应用程序委托类，使用该特性与调用`NSApplicationMain(_:_:)`函数并且把该类的名字作为委托类的名字传递给函数的效果相同。
+
+如果你不想使用这个特性，可以提供一个`main.swift`文件，并且提供一个`main`函数去调用`NSApplicationMain(_:_:)`函数。比如，如果你的应用程序使用一个派生于`NSApplication`的自定义子类作为主要类，你可以调用`NSApplicationMain`函数而不是使用该特性。
+
+`NSCopying`
+
+该特性用于修饰一个类的存储型变量属性。该特性将使属性的setter与属性值的一个副本合成，这个值由`copyWithZone(_:)`方法返回，而不是属性本身的值。该属性的类型必需遵循`NSCopying`协议。
+
+`NSCopying`特性的原理与Objective-C中的`copy`特性相似。
+
+`NSManaged`
+
+该特性用于修饰`NSManagedObject`子类中的存储型变量属性，表明属性的存储和实现由Core Data在运行时基于相关实体描述动态提供。
+
+`testable`
+
+该特性用于`import`声明可以测试的编译模块，它能访问任何标有`internal`权限标识符的实体，这和将它声明为`public`权限标识符有同样的效果。
+
+`UIApplicationMain`
+
+在类上使用该特性表示该类是应用程序委托类，使用该特性与调用`UIApplicationMain(_:_:)`函数并且把该类的名字作为委托类的名字传递给函数的效果相同。
+
+如果你不想使用这个特性，可以提供一个`main.swift`文件，并且提供一个`main`函数去调用`UIApplicationMain(_:_:)`函数。比如，如果你的应用程序使用一个派生于`UIApplication`的自定义子类作为主要类，你可以调用`UIApplicationMain`函数而不是使用该特性。
+
+`warn_unused_result`
+
+该特性应用于方法或函数声明，当方法或函数被调用，但其结果未被使用时，该特性会让编译器会产生警告。
+
+你可以使用这个特性提供一个警告信息，这个警告信息是关于不正确地使用未变异的方法的，这个方法也有一个对应的变异方法。
+
+`warn_unused_result`有下面两个可选的参数。
+
+- `message`参数用来提供警告信息，并在因当方法或函数被调用，但其结果未被使用时，显示警告信息。格式如下：
+<p>`message=message`<p>这里的`message`由一个字符串文字构成。
+
+- `mutable_variant`参数用于提供变异方法的名称，如果未变异方法以一个可变的值被调用而且其结果并未被使用时，应该使用此变异方法。格式如下（方法名有字符串构成）：<p>`mutable_variant=method name`<p>
+
+比如，Swift标准库提供了变异方法`sortInPlace()`和未变异方法`sort()`集合，它们的元素生成器符合`Comparable`协议。如果你调用了`sort()`方法，而没有使用它的结果，很有可能，你打算使用变异方法`sortInPlace()`替代。
 
 ### Interface Builder使用的声明特性
 
@@ -137,22 +182,36 @@ Interface Builder特性是Interface Builder用来与Xcode同步的声明特性
 
 类型特性只能用于修饰类型。然而，你也可以用`noreturn`特性去修饰函数或方法声明。
 
-`auto_closure`
+`convention`
 
-这个特性通过自动地将表达式封闭到一个无参数闭包中来延迟表达式的求值。使用该特性修饰无参的函数或方法类型，返回表达式的类型。一个如何使用`auto_closure`特性的例子，见[函数类型]()
+该特性用于函数的类型，它指出函数调用的约定。
+
+`convention`特性有下面几个可选的参数。
+
+- `swift`参数用于表明一个Swift函数引用。这是Swift中标准的函数值调用约定。
+
+- `block`参数用于表明一个Objective-C兼容的块引用。函数值表示为一个块对象的引用，这是一个`id-`兼容的Objective-C对象，对象中嵌入了调用函数。调用函数使用C的调用约定。
+
+- `c`参数用于表明一个C函数引用。函数值没有上下文，这个函数也使用C的调用约定。
+
+使用C函数调用约定的函数也可用作使用Objective-C块调用约定的函数，同时使用Objective-C块调用约定的函数也可用作使用Swift函数调用约定的函数。然而，只有非泛型的全局函数和本地函数或者不使用任何本地变量的闭包可以被用作使用C函数调用约定的函数。
 
 `noreturn`
 
 该特性用于修饰函数或方法的类型，表明该函数或方法不会返回到它的调用者中去。你也可以用它标记函数或方法的声明，表示函数或方法的相应类型，`T`，是`@noreturn T`。
 
-> 特性语法  
-> *特性* → **@** [*特性名*](..\chapter3\06_Attributes.html#attribute_name) [*特性参数子句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可选_  
-> *特性名* → [*标识符*](LexicalStructure.html#identifier)  
-> *特性参数子句* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
-> *特性(Attributes)列表* → [*特色*](..\chapter3\06_Attributes.html#attribute) [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_  
-> *平衡令牌列表* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_  
-> *平衡令牌* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
-> *平衡令牌* → **[** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **]**  
-> *平衡令牌* → **{** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **}**  
+> 特性语法
+> *特性* → **@** [*特性名*](#attribute_name) [*特性参数子句*](#attribute_argument_clause) <sub>_可选_</sub>  
+> *特性名* → [*标识符*](02_Lexical_Structure.html#identifiers)  
+> *特性参数子句* → **(** [*平衡令牌列表*](#balanced_tokens) <sub>_可选_</sub> **)**  
+> *特性(Attributes)列表* → [*特色*](#attribute) [*特性(Attributes)列表*](#attributes) <sub>_可选_</sub>  
+> *平衡令牌列表* → [*平衡令牌*](#balanced_token) [*平衡令牌列表*](#balanced_tokens) <sub>_可选_</sub>  
+> *平衡令牌* → **(** [*平衡令牌列表*](#balanced_tokens) <sub>_可选_</sub> **)**  
+> *平衡令牌* → **[** [*平衡令牌列表*](#balanced_tokens) <sub>_可选_</sub> **]**  
+> *平衡令牌* → **{** [*平衡令牌列表*](#balanced_tokens) <sub>_可选_</sub> **}**  
 > *平衡令牌* → **任意标识符, 关键字, 字面量或运算符**  
 > *平衡令牌* → **任意标点除了(, ), [, ], {, 或 }**
+
+
+
+

From 134c3898ee2a331fe3b156f34c6ac1a62a8c0006 Mon Sep 17 00:00:00 2001
From: shanksyang <shanks@weedo.hk>
Date: Tue, 30 Jun 2015 19:24:53 +0800
Subject: [PATCH 040/228] Swift2.0 pre-release,12_subscript

---
 source/chapter2/12_Subscripts.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index 7bef609e..d9e4db4e 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -11,9 +11,9 @@
 - [下标脚本用法](#subscript_usage)
 - [下标脚本选项](#subscript_options)
 
-*下标脚本* 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问对象、集合或序列的快捷方式，不需要再调用实例的特定的赋值和访问方法。举例来说，用下标脚本访问一个数组(Array)实例中的元素可以这样写 `someArray[index]` ，访问字典(Dictionary)实例中的元素可以这样写 `someDictionary[key]`。
+*下标脚本* 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问集合（collection），列表（list）或序列（sequence的快捷方式，使用下标脚本的索引设置和获取值，不需要再调用实例的特定的赋值和访问方法。举例来说，用下标脚本访问一个数组(Array)实例中的元素可以这样写 `someArray[index]` ，访问字典(Dictionary)实例中的元素可以这样写 `someDictionary[key]`。
 
-对于同一个目标可以定义多个下标脚本，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。
+对于同一个目标可以定义多个下标脚本，通过索引值类型的不同来进行重载，下标脚本不限于单个纬度，你可以定义多个入参的下标脚本满足自定义类型的需求。
 
 > 译者：这里附属脚本重载在本小节中原文并没有任何演示  
 
@@ -63,7 +63,7 @@ println("3的6倍是\(threeTimesTable[6])")
 你可以通过下标脚本来得到结果，比如`threeTimesTable[6]`。这条语句访问了`threeTimesTable`的第六个元素，返回`6`的`3`倍即`18`。
 
 >注意：  
-> `TimesTable`例子是基于一个固定的数学公式。它并不适合开放写权限来对`threeTimesTable[someIndex]`进行赋值操作，这也是为什么附属脚本只定义为只读的原因。  
+> `TimesTable`例子是基于一个固定的数学公式。它并不适合对`threeTimesTable[someIndex]`进行赋值操作，这也是为什么附属脚本只定义为只读的原因。  
 
 <a name="subscript_usage"></a>
 ## 下标脚本用法
@@ -77,7 +77,7 @@ var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
 numberOfLegs["bird"] = 2
 ```
 
-上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`Dictionary<String, Int>`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
+上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`[String:Int]`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
 
 更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](../chapter2/04_Collection_Types.html)
 
@@ -118,7 +118,7 @@ struct Matrix {
 }
 ```
 
-`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考[创建并且构造一个数组](../chapter2/04_Collection_Types.html)。
+`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。通过传入数组长度和初始值0.0到数组的一个构造器，将`Matrix`中每个元素初始值0.0。关于数组的构造方法和析构方法请参考[创建并且构造一个数组](../chapter2/04_Collection_Types.html)。
 
 你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例：
 
@@ -151,7 +151,7 @@ matrix[1, 0] = 3.2
  3.2, 0.0]
 ```
 
-`Matrix`下标脚本的`getter`和`setter`中同时调用了下标脚本入参的`row`和`column`是否有效的判断。为了方便进行断言，`Matrix`包含了一个名为`indexIsValid`的成员方法，用来确认入参的`row`或`column`值是否会造成数组越界：
+`Matrix`下标脚本的`getter`和`setter`中同时调用了下标脚本入参的`row`和`column`是否有效的判断。为了方便进行断言，`Matrix`包含了一个名为`indexIsValidForRow(_:column:)`的成员方法，用来确认入参的`row`或`column`值是否会造成数组越界：
 
 ```swift
 func indexIsValidForRow(row: Int, column: Int) -> Bool {

From 55ae3656be806f6ccbffce0764d7c628190b69ff Mon Sep 17 00:00:00 2001
From: chenYuheng <yuheng@tataufo.com>
Date: Tue, 30 Jun 2015 22:35:04 +0800
Subject: [PATCH 041/228] =?UTF-8?q?=E6=96=B0=E6=B7=BB=E5=8A=A0=E4=BA=86Ext?=
 =?UTF-8?q?ending=20a=20Generic=20Type=E5=B0=8F=E8=8A=82=E7=9A=84=E7=BF=BB?=
 =?UTF-8?q?=E8=AF=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/23_Generics.md | 30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/source/chapter2/23_Generics.md b/source/chapter2/23_Generics.md
index ec031e3e..d139812e 100644
--- a/source/chapter2/23_Generics.md
+++ b/source/chapter2/23_Generics.md
@@ -1,5 +1,5 @@
 
-> 翻译：[takalard](https://github.com/takalard)
+> 翻译：[takalard](https://github.com/takalard) [SergioChan](https://github.com/SergioChan)
 > 校对：[lifedim](https://github.com/lifedim)
 
 # 泛型
@@ -13,6 +13,7 @@
 - [类型参数](#type_parameters)
 - [命名类型参数](#naming_type_parameters)
 - [泛型类型](#generic_types)
+- [扩展一个泛型类型](#extending_a_generic_type)
 - [类型约束](#type_constraints)
 - [关联类型](#associated_types)
 - [`Where`语句](#where_clauses)
@@ -226,6 +227,33 @@ let fromTheTop = stackOfStrings.pop()
 下图展示了如何从栈中pop一个值的过程：
 ![此处输入图片的描述](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPoppedOneString_2x.png)
 
+<a name="extending_a_generic_type"></a>
+## 扩展一个泛型类型
+
+当你扩展一个泛型类型的时候，你并不需要在扩展的定义中提供类型参数列表。更加方便的是，原始类型定义中声明的类型参数列表在扩展里是可以使用的，并且这些来自原始类型中的参数名称会被用作原始定义中类型参数的引用。
+
+下面的例子扩展了泛型`Stack`类型，为其添加了一个名为`topItem`的只读计算属性，它将会返回当前栈顶端的元素而不会将其从栈中移除。
+
+```swift
+extension Stack {
+	var topItem: T? {
+    	return items.isEmpty ? nil : items[items.count - 1]
+    }
+}
+```
+
+`topItem`属性会返回一个`T`类型的可选值。当栈为空的时候，`topItem`将会返回`nil`；当栈不为空的时候，`topItem`会返回`items`数组中的最后一个元素。
+
+注意这里的扩展并没有定义一个类型参数列表。相反的，`Stack`类型已有的类型参数名称，`T`，被用在扩展中当做`topItem`计算属性的可选类型。
+
+`topItem`计算属性现在可以被用来返回任意`Stack`实例的顶端元素而无需移除它：
+
+```swift
+if let topItem = stackOfStrings.topItem {
+	print("The top item on the stack is \(topItem).")
+}
+// 打印 "The top item on the stack is tres."
+```
 
 <a name="type_constraints"></a>
 ##类型约束

From 3e3fba64dce43dc4a1ed5dbfb3015580ee9de701 Mon Sep 17 00:00:00 2001
From: chenYuheng <yuheng@tataufo.com>
Date: Tue, 30 Jun 2015 22:50:24 +0800
Subject: [PATCH 042/228] =?UTF-8?q?=E5=AE=8C=E6=88=90Generic-Type=20Constr?=
 =?UTF-8?q?aint=E5=B0=8F=E8=8A=82=E7=9A=84=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/23_Generics.md | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/source/chapter2/23_Generics.md b/source/chapter2/23_Generics.md
index d139812e..c5c113af 100644
--- a/source/chapter2/23_Generics.md
+++ b/source/chapter2/23_Generics.md
@@ -43,7 +43,7 @@ func swapTwoInts(inout a: Int, inout _ b: Int) {
 var someInt = 3
 var anotherInt = 107
 swapTwoInts(&someInt, &anotherInt)
-println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
+print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
 // 输出 "someInt is now 107, and anotherInt is now 3"
 ```
 
@@ -252,13 +252,13 @@ extension Stack {
 if let topItem = stackOfStrings.topItem {
 	print("The top item on the stack is \(topItem).")
 }
-// 打印 "The top item on the stack is tres."
+// 输出 "The top item on the stack is tres."
 ```
 
 <a name="type_constraints"></a>
 ##类型约束
 
-`swapTwoValues`函数和`Stack`类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
+`swapTwoValues(_:_:)`函数和`Stack`类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
 
 例如，Swift 的`Dictionary`类型对作用于其键的类型做了些限制。在[字典](../chapter2/04_Collection_Types.html)的描述中，字典的键类型必须是*可哈希*，也就是说，必须有一种方法可以使其被唯一的表示。`Dictionary`之所以需要其键是可哈希是为了以便于其检查其是否已经包含某个特定键的值。如无此需求，`Dictionary`既不会告诉是否插入或者替换了某个特定键的值，也不能查找到已经存储在字典里面的给定键值。
 
@@ -272,7 +272,7 @@ if let topItem = stackOfStrings.topItem {
 
 ```swift
 func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
-    // function body goes here
+    // 这里是函数主体
 }
 ```
 
@@ -280,11 +280,11 @@ func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
 
 ### 类型约束行为
 
-这里有个名为`findStringIndex`的非泛型函数，该函数功能是去查找包含一给定`String`值的数组。若查找到匹配的字符串，`findStringIndex`函数返回该字符串在数组中的索引值（`Int`），反之则返回`nil`：
+这里有个名为`findStringIndex`的非泛型函数，该函数功能是去查找包含一给定`String`值的数组。若查找到匹配的字符串，`findStringIndex(_:_:)`函数返回该字符串在数组中的索引值（`Int`），反之则返回`nil`：
 
 ```swift
-func findStringIndex(array: [String], valueToFind: String) -> Int? {
-    for (index, value) in enumerate(array) {
+func findStringIndex(array: [String], _ valueToFind: String) -> Int? {
+    for (index, value) in array.enumerate() {
         if value == valueToFind {
             return index
         }
@@ -294,12 +294,12 @@ func findStringIndex(array: [String], valueToFind: String) -> Int? {
 ```
 
 
-`findStringIndex`函数可以作用于查找一字符串数组中的某个字符串:
+`findStringIndex(_:_:)`函数可以作用于查找一字符串数组中的某个字符串:
 
 ```swift
 let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
 if let foundIndex = findStringIndex(strings, "llama") {
-    println("The index of llama is \(foundIndex)")
+    print("The index of llama is \(foundIndex)")
 }
 // 输出 "The index of llama is 2"
 ```
@@ -309,8 +309,8 @@ if let foundIndex = findStringIndex(strings, "llama") {
 这里展示如何写一个你或许期望的`findStringIndex`的泛型版本`findIndex`。请注意这个函数仍然返回`Int`，是不是有点迷惑呢，而不是泛型类型?那是因为函数返回的是一个可选的索引数，而不是从数组中得到的一个可选值。需要提醒的是，这个函数不会编译，原因在例子后面会说明：
 
 ```swift
-func findIndex<T>(array: [T], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
+func findIndex<T>(array: [T], _ valueToFind: T) -> Int? {
+    for (index, value) in array.enumerate() {
         if value == valueToFind {
             return index
         }
@@ -323,11 +323,11 @@ func findIndex<T>(array: [T], valueToFind: T) -> Int? {
 
 不过，所有的这些并不会让我们无从下手。Swift 标准库中定义了一个`Equatable`协议，该协议要求任何遵循的类型实现等式符（==）和不等符（!=）对任何两个该类型进行比较。所有的 Swift 标准类型自动支持`Equatable`协议。
 
-任何`Equatable`类型都可以安全的使用在`findIndex`函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个`Equatable`类型约束作为类型参数定义的一部分：
+任何`Equatable`类型都可以安全的使用在`findIndex(_:_:)`函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个`Equatable`类型约束作为类型参数定义的一部分：
 
 ```swift
-func findIndex<T: Equatable>(array: T[], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
+func findIndex<T: Equatable>(array: [T], _ valueToFind: T) -> Int? {
+    for (index, value) in array.enumerate() {
         if value == valueToFind {
             return index
         }
@@ -339,7 +339,7 @@ func findIndex<T: Equatable>(array: T[], valueToFind: T) -> Int? {
 
 `findIndex`中这个单个类型参数写做：`T: Equatable`，也就意味着“任何T类型都遵循`Equatable`协议”。
 
-`findIndex`函数现在则可以成功的编译过，并且作用于任何遵循`Equatable`的类型，如`Double`或`String`:
+`findIndex(_:_:)`函数现在则可以成功的编译过，并且作用于任何遵循`Equatable`的类型，如`Double`或`String`:
 
 ```swift
 let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)

From 2380574b4e4d8685a605d223c9d0f12d60408c26 Mon Sep 17 00:00:00 2001
From: chenYuheng <yuheng@tataufo.com>
Date: Wed, 1 Jul 2015 00:02:17 +0800
Subject: [PATCH 043/228] =?UTF-8?q?=E5=AE=8C=E6=88=90Generics=E7=AB=A0?=
 =?UTF-8?q?=E8=8A=82=E7=9A=84=E4=BF=AE=E6=94=B9=E5=92=8C=E6=96=B0=E5=A2=9E?=
 =?UTF-8?q?=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/23_Generics.md | 46 +++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/source/chapter2/23_Generics.md b/source/chapter2/23_Generics.md
index c5c113af..2fa90bc5 100644
--- a/source/chapter2/23_Generics.md
+++ b/source/chapter2/23_Generics.md
@@ -355,7 +355,7 @@ let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
 
 ### 关联类型行为
 
-这里是一个`Container`协议的例子，定义了一个ItemType关联类型：
+这里是一个`Container`协议的例子，定义了一个`ItemType`关联类型：
 
 ```swift
 protocol Container {
@@ -368,19 +368,19 @@ protocol Container {
 
 `Container`协议定义了三个任何容器必须支持的兼容要求：
 
-- 必须可以通过`append`方法添加一个新item到容器里；
-- 必须可以通过使用`count`属性获取容器里items的数量，并返回一个`Int`值；
-- 必须可以通过容器的`Int`索引值下标可以检索到每一个item。
+- 必须可以通过`append(_:)`方法添加一个新元素到容器里；
+- 必须可以通过使用`count`属性获取容器里元素的数量，并返回一个`Int`值；
+- 必须可以通过容器的`Int`索引值下标可以检索到每一个元素。
 
-这个协议没有指定容器里item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循`Container`类型所必须支持的功能点。一个遵循的类型在满足这三个条件的情况下也可以提供其他额外的功能。
+这个协议没有指定容器里的元素是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循`Container`类型所必须支持的功能点。一个遵循的类型在满足这三个条件的情况下也可以提供其他额外的功能。
 
-任何遵循`Container`协议的类型必须指定存储在其里面的值类型，必须保证只有正确类型的items可以加进容器里，必须明确可以通过其下标返回item类型。
+任何遵循`Container`协议的类型必须指定存储在其里面的值类型，必须保证只有正确类型的元素可以加进容器里，必须明确可以通过其下标返回元素类型。
 
-为了定义这三个条件，`Container`协议需要一个方法指定容器里的元素将会保留，而不需要知道特定容器的类型。`Container`协议需要指定任何通过`append`方法添加到容器里的值和容器里元素是相同类型，并且通过容器下标返回的容器元素类型的值的类型是相同类型。
+为了定义这三个条件，`Container`协议需要一个方法指定容器里的元素将会保留，而不需要知道特定容器的类型。`Container`协议需要指定任何通过`append(_:)`方法添加到容器里的值和容器里元素是相同类型，并且通过容器下标返回的容器元素类型的值的类型是相同类型。
 
-为了达到此目的，`Container`协议声明了一个ItemType的关联类型，写作`typealias ItemType`。这个协议不会定义`ItemType`是什么的别名，这个信息将由任何遵循协议的类型来提供。尽管如此，`ItemType`别名提供了一种识别Container中Items类型的方法，并且用于`append`方法和`subscript`方法的类型定义，以便保证任何`Container`期望的行为能够被执行。
+为了达到此目的，`Container`协议声明了一个`ItemType`的关联类型，写作`typealias ItemType`。这个协议不会定义`ItemType`是什么的别名，这个信息将由任何遵循协议的类型来提供。尽管如此，`ItemType`别名提供了一种识别`Container`中元素类型的方法，并且用于`append(_:)`方法和`subscript`方法的类型定义，以便保证任何`Container`期望的行为能够被执行。
 
-这里是一个早前IntStack类型的非泛型版本，遵循Container协议：
+这里是一个早前`IntStack`类型的非泛型版本，遵循`Container`协议：
 
 ```swift
 struct IntStack: Container {
@@ -398,7 +398,7 @@ struct IntStack: Container {
         self.push(item)
     }
     var count: Int {
-    return items.count
+    	return items.count
     }
     subscript(i: Int) -> Int {
         return items[i]
@@ -409,9 +409,9 @@ struct IntStack: Container {
 
 `IntStack`类型实现了`Container`协议的所有三个要求，在`IntStack`类型的每个包含部分的功能都满足这些要求。
 
-此外，`IntStack`指定了`Container`的实现，适用的ItemType被用作`Int`类型。对于这个`Container`协议实现而言，定义 `typealias ItemType = Int`，将抽象的`ItemType`类型转换为具体的`Int`类型。
+此外，`IntStack`指定了`Container`的实现，适用的`ItemType`被用作`Int`类型。对于这个`Container`协议实现而言，定义 `typealias ItemType = Int`，将抽象的`ItemType`类型转换为具体的`Int`类型。
 
-感谢Swift类型参考，你不用在`IntStack`定义部分声明一个具体的`Int`的`ItemType`。由于`IntStack`遵循`Container`协议的所有要求，只要通过简单的查找`append`方法的item参数类型和下标返回的类型，Swift就可以推断出合适的`ItemType`来使用。确实，如果上面的代码中你删除了 `typealias ItemType = Int`这一行，一切仍旧可以工作，因为它清楚的知道ItemType使用的是何种类型。
+感谢Swift类型参考，你不用在`IntStack`定义部分声明一个具体的`Int`的`ItemType`。由于`IntStack`遵循`Container`协议的所有要求，只要通过简单的查找`append(_:)`方法的`item`参数类型和下标返回的类型，Swift就可以推断出合适的`ItemType`来使用。确实，如果上面的代码中你删除了 `typealias ItemType = Int`这一行，一切仍旧可以工作，因为它清楚的知道`ItemType`使用的是何种类型。
 
 你也可以生成遵循`Container`协议的泛型`Stack`类型：
 
@@ -430,7 +430,7 @@ struct Stack<T>: Container {
         self.push(item)
     }
     var count: Int {
-    return items.count
+    	return items.count
     }
     subscript(i: Int) -> T {
         return items[i]
@@ -438,20 +438,20 @@ struct Stack<T>: Container {
 }
 ```
 
-这个时候，占位类型参数`T`被用作`append`方法的item参数和下标的返回类型。Swift 因此可以推断出被用作这个特定容器的`ItemType`的`T`的合适类型。
+这个时候，占位类型参数`T`被用作`append(_:)`方法的`item`参数和下标的返回类型。Swift 因此可以推断出被用作这个特定容器的`ItemType`的`T`的合适类型。
 
 
 ### 扩展一个存在的类型为一指定关联类型
 
 在[使用扩展来添加协议兼容性](../chapter2/21_Protocols.html)中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
 
-Swift的`Array`已经提供`append`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[使用扩展来声明协议的采纳](../chapter2/21_Protocols.html)中有描述这样一个实现一个空扩展的行为：
+Swift的`Array`已经提供`append(_:)`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[使用扩展来声明协议的采纳](../chapter2/21_Protocols.html)中有描述这样一个实现一个空扩展的行为：
 
 ```swift
 extension Array: Container {}
 ```
 
-如同上面的泛型`Stack`类型一样，`Array的append`方法和下标保证`Swift`可以推断出`ItemType`所使用的适用的类型。定义了这个扩展后，你可以将任何`Array`当作`Container`来使用。
+如同上面的泛型`Stack`类型一样，`Array`的`append(_:)`方法和下标保证`Swift`可以推断出`ItemType`所使用的适用的类型。定义了这个扩展后，你可以将任何`Array`当作`Container`来使用。
 
 <a name="where_clauses"></a>
 ## Where 语句
@@ -509,15 +509,15 @@ func allItemsMatch<
 
 第三个和第四个要求结合起来的意思是`anotherContainer`中的元素也可以通过 `!=` 操作来检查，因为它们在`someContainer`中元素确实是相同的类型。
 
-这些要求能够使`allItemsMatch`函数比较两个容器，即便它们是不同的容器类型。
+这些要求能够使`allItemsMatch(_:_:)`函数比较两个容器，即便它们是不同的容器类型。
 
-`allItemsMatch`首先检查两个容器是否拥有同样数目的items，如果它们的元素数目不同，没有办法进行匹配，函数就会`false`。
+`allItemsMatch(_:_:)`首先检查两个容器是否拥有同样数目的items，如果它们的元素数目不同，没有办法进行匹配，函数就会`false`。
 
-检查完之后，函数通过`for-in`循环和半闭区间操作（..）来迭代`someContainer`中的所有元素。对于每个元素，函数检查是否`someContainer`中的元素不等于对应的`anotherContainer`中的元素，如果这两个元素不等，则这两个容器不匹配，返回`false`。
+检查完之后，函数通过`for-in`循环和半闭区间操作（`..<`）来迭代`someContainer`中的所有元素。对于每个元素，函数检查是否`someContainer`中的元素不等于对应的`anotherContainer`中的元素，如果这两个元素不等，则这两个容器不匹配，返回`false`。
 
 如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回`true`。
 
-这里演示了allItemsMatch函数运算的过程：
+这里演示了`allItemsMatch(_:_:)`函数运算的过程：
 
 ```swift
 var stackOfStrings = Stack<String>()
@@ -528,14 +528,14 @@ stackOfStrings.push("tres")
 var arrayOfStrings = ["uno", "dos", "tres"]
 
 if allItemsMatch(stackOfStrings, arrayOfStrings) {
-    println("All items match.")
+    print("All items match.")
 } else {
-    println("Not all items match.")
+    print("Not all items match.")
 }
 // 输出 "All items match."
 ```
 
- 上面的例子创建一个`Stack`单例来存储`String`，然后压了三个字符串进栈。这个例子也创建了一个`Array`单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组是不同的类型，但它们都遵循`Container`协议，而且它们都包含同样的类型值。因此你可以调用`allItemsMatch`函数，用这两个容器作为它的参数。在上面的例子中，`allItemsMatch`函数正确的显示了所有的这两个容器的`items`匹配。
+ 上面的例子创建一个`Stack`单例来存储`String`，然后压了三个字符串进栈。这个例子也创建了一个`Array`单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组是不同的类型，但它们都遵循`Container`协议，而且它们都包含同样的类型值。因此你可以调用`allItemsMatch(_:_:)`函数，用这两个容器作为它的参数。在上面的例子中，`allItemsMatch(_:_:)`函数正确的显示了这两个容器的所有元素都是相互匹配的。
 
   [1]: ../chapter2/06_Functions.html
   [2]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPushPop_2x.png

From 03fb94ea6dc3530c2d6233139e96f9239b730081 Mon Sep 17 00:00:00 2001
From: Siyu Yang <yangsiyu1992@gmail.com>
Date: Tue, 30 Jun 2015 21:02:54 +0800
Subject: [PATCH 044/228] Chapter2_Properties Section1_Stored_Properties
 finished

---
 source/chapter2/10_Properties.md | 42 +++++++++++++++++---------------
 1 file changed, 22 insertions(+), 20 deletions(-)

diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index bf305032..4070c1c2 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -1,5 +1,5 @@
 > 翻译：[shinyzhu](https://github.com/shinyzhu)  
-> 校对：[pp-prog](https://github.com/pp-prog)
+> 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
 
 # 属性 (Properties)
 ---
@@ -12,16 +12,16 @@
 - [全局变量和局部变量（Global and Local Variables）](#global_and_local_variables)
 - [类型属性（Type Properties）](#type_properties)
 
-**属性**将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，计算属性计算（而不是存储）一个值。计算属性可以用于类、结构体和枚举里，存储属性只能用于类和结构体。
+*属性*将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，而计算属性计算（不是存储）一个值。计算属性可以用于类、结构体和枚举，存储属性只能用于类和结构体。
 
-存储属性和计算属性通常用于特定类型的实例，但是，属性也可以直接用于类型本身，这种属性称为类型属性。
+存储属性和计算属性通常与特定类型的实例关联。但是，属性也可以直接作用于类型本身，这种属性称为类型属性。
 
-另外，还可以定义属性观察器来监控属性值的变化，以此来触发一个自定义的操作。属性观察器可以添加到自己写的存储属性上，也可以添加到从父类继承的属性上。
+另外，还可以定义属性观察器来监控属性值的变化，以此来触发一个自定义的操作。属性观察器可以添加到自己定义的存储属性上，也可以添加到从父类继承的属性上。
 
 <a name="stored_properties"></a>
 ## 存储属性
 
-简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量，存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
+简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
 
 可以在定义存储属性的时候指定默认值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[默认属性值](../chapter2/14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[在初始化阶段修改常量存储属性](../chapter2/14_Initialization.html#modifying_constant_properties_during_initialization)一节。
 
@@ -38,12 +38,12 @@ rangeOfThreeItems.firstValue = 6
 // 该区间现在表示整数6，7，8
 ```
 
-`FixedLengthRange`的实例包含一个名为`firstValue`的变量存储属性和一个名为`length`的常量存储属性。在上面的例子中，`length`在创建实例的时候被赋值，因为它是一个常量存储属性，所以之后无法修改它的值。
+`FixedLengthRange`的实例包含一个名为`firstValue`的变量存储属性和一个名为`length`的常量存储属性。在上面的例子中，`length`在创建实例的时候被初始化，因为它是一个常量存储属性，所以之后无法修改它的值。
 
 <a name="stored_properties_of_constant_structure_instances"></a>
-### 常量和存储属性
+### 常量结构体的存储属性
 
-如果创建了一个结构体的实例并赋值给一个常量，则无法修改实例的任何属性，即使定义了变量存储属性：
+如果创建了一个结构体的实例并将其赋值给一个常量，则无法修改该实例的任何属性，即使定义了变量存储属性：
 
 ```swift
 let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
@@ -52,11 +52,11 @@ rangeOfFourItems.firstValue = 6
 // 尽管 firstValue 是个变量属性，这里还是会报错
 ```
 
-因为`rangeOfFourItems`声明成了常量（用`let`关键字），即使`firstValue`是一个变量属性，也无法再修改它了。
+因为`rangeOfFourItems`被声明成了常量（用`let`关键字），即使`firstValue`是一个变量属性，也无法再修改它了。
 
 这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
 
-属于*引用类型*的类（class）则不一样，把一个引用类型的实例赋给一个常量后，仍然可以修改实例的变量属性。
+属于*引用类型*的类（class）则不一样。把一个引用类型的实例赋给一个常量后，仍然可以修改该实例的变量属性。
 
 <a name="lazy_stored_properties"></a>
 ### 延迟存储属性
@@ -64,11 +64,11 @@ rangeOfFourItems.firstValue = 6
 延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用`lazy`来标示一个延迟存储属性。
 
 > 注意：  
-> 必须将延迟存储属性声明成变量（使用`var`关键字），因为属性的值在实例构造完成之前可能无法得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。  
+> 必须将延迟存储属性声明成变量（使用`var`关键字），因为属性的初始值可能在实例构造完成之后才会得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。  
 
-延迟属性很有用，当属性的值依赖于在实例的构造过程结束前无法知道具体值的外部因素时，或者当属性的值需要复杂或大量计算时，可以只在需要的时候来计算它。
+延迟属性很有用，当属性的值依赖于在实例的构造过程结束后才会知道具体值的外部因素时，或者当获得属性的初始值需要复杂或大量计算时，可以只在需要的时候计算它。
 
-下面的例子使用了延迟存储属性来避免复杂类的不必要的初始化。例子中定义了`DataImporter`和`DataManager`两个类，下面是部分代码：
+下面的例子使用了延迟存储属性来避免复杂类中不必要的初始化。例子中定义了`DataImporter`和`DataManager`两个类，下面是部分代码：
 
 ```swift
 class DataImporter {
@@ -94,25 +94,27 @@ manager.data.append("Some more data")
 
 `DataManager`类包含一个名为`data`的存储属性，初始值是一个空的字符串（`String`）数组。虽然没有写出全部代码，`DataManager`类的目的是管理和提供对这个字符串数组的访问。
 
-`DataManager`的一个功能是从文件导入数据，该功能由`DataImporter`类提供，`DataImporter`需要消耗不少时间完成初始化：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
+`DataManager`的一个功能是从文件导入数据。该功能由`DataImporter`类提供，`DataImporter`完成初始化需要消耗不少时间：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
 
-`DataManager`也可能不从文件中导入数据。所以当`DataManager`的实例被创建时，没必要创建一个`DataImporter`的实例，更明智的是当用到`DataImporter`的时候才去创建它。
+`DataManager`也可能不从文件中导入数据就完成了管理数据的功能。所以当`DataManager`的实例被创建时，没必要创建一个`DataImporter`的实例，更明智的是当第一次用到`DataImporter`的时候才去创建它。
 
 由于使用了`lazy`，`importer`属性只有在第一次被访问的时候才被创建。比如访问它的属性`fileName`时：
 
 ```swift
-println(manager.importer.fileName)
+print(manager.importer.fileName)
 // DataImporter 实例的 importer 属性现在被创建了
 // 输出 "data.txt”
-```
+```
+
+> 注意：  
+> 如果一个被标记为`lazy`的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。
 
 <a name="stored_properties_and_instance_variables"></a>
 ### 存储属性和实例变量
 
-如果您有过 Objective-C 经验，应该知道Objective-C为类实例存储值和引用提供两种方法。对于属性来说，也可以使用实例变量作为属性值的后端存储。
+如果您有过 Objective-C 经验，应该知道 Objective-C 为类实例存储值和引用提供两种方法。对于属性来说，也可以使用实例变量作为属性值的后端存储。
 
-Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。
-一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。
+Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。
 
 <a name="computed_properties"></a>
 ## 计算属性

From 1c9b0ceae795d53130c64b1a364b90053e766750 Mon Sep 17 00:00:00 2001
From: Siyu Yang <yangsiyu1992@gmail.com>
Date: Tue, 30 Jun 2015 22:14:26 +0800
Subject: [PATCH 045/228] Chapter2_Properties Section2_Computed_Properties
 finished

---
 source/chapter2/10_Properties.md | 62 ++++++++++++++++----------------
 1 file changed, 30 insertions(+), 32 deletions(-)

diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 4070c1c2..4e645540 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -119,7 +119,7 @@ Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属
 <a name="computed_properties"></a>
 ## 计算属性
 
-除存储属性外，类、结构体和枚举可以定义*计算属性*，计算属性不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值。
+除存储属性外，类、结构体和枚举可以定义*计算属性*。计算属性不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。
 
 ```swift
 struct Point {
@@ -132,38 +132,38 @@ struct Rect {
     var origin = Point()
     var size = Size()
     var center: Point {
-    get {
-        let centerX = origin.x + (size.width / 2)
-        let centerY = origin.y + (size.height / 2)
-        return Point(x: centerX, y: centerY)
-    }
-    set(newCenter) {
-        origin.x = newCenter.x - (size.width / 2)
-        origin.y = newCenter.y - (size.height / 2)
-    }
+        get {
+            let centerX = origin.x + (size.width / 2)
+            let centerY = origin.y + (size.height / 2)
+            return Point(x: centerX, y: centerY)
+        }
+        set(newCenter) {
+            origin.x = newCenter.x - (size.width / 2)
+            origin.y = newCenter.y - (size.height / 2)
+        }
     }
 }
 var square = Rect(origin: Point(x: 0.0, y: 0.0),
     size: Size(width: 10.0, height: 10.0))
 let initialSquareCenter = square.center
 square.center = Point(x: 15.0, y: 15.0)
-println("square.origin is now at (\(square.origin.x), \(square.origin.y))")
+print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
 // 输出 "square.origin is now at (10.0, 10.0)”
 ```
 
-这个例子定义了 3 个几何形状的结构体：
+这个例子定义了 3 个结构体来描述几何形状：
 
 - `Point`封装了一个`(x, y)`的坐标
-- `Size`封装了一个`width`和`height`
+- `Size`封装了一个`width`和一个`height`
 - `Rect`表示一个有原点和尺寸的矩形
 
-`Rect`也提供了一个名为`center`的计算属性。一个矩形的中心点可以从原点和尺寸来算出，所以不需要将它以显式声明的`Point`来保存。`Rect`的计算属性`center`提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
+`Rect`也提供了一个名为`center`的计算属性。一个矩形的中心点可以从原点（`origin`）和尺寸（`size`）算出，所以不需要将它以显式声明的`Point`来保存。`Rect`的计算属性`center`提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
 
-例子中接下来创建了一个名为`square`的`Rect`实例，初始值原点是`(0, 0)`，宽度高度都是`10`。如图所示蓝色正方形。
+上述例子中创建了一个名为`square`的`Rect`实例，初始值原点是`(0, 0)`，宽度高度都是`10`。如下图中蓝色正方形所示。
 
-`square`的`center`属性可以通过点运算符（`square.center`）来访问，这会调用 getter 来获取属性的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的`Point`来表示`square`的中心点。如代码所示，它正确返回了中心点`(5, 5)`。
+`square`的`center`属性可以通过点运算符（`square.center`）来访问，这会调用该属性的 getter 来获取它的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的`Point`来表示`square`的中心点。如代码所示，它正确返回了中心点`(5, 5)`。
 
-`center`属性之后被设置了一个新的值`(15, 15)`，表示向右上方移动正方形到如图所示橙色正方形的位置。设置属性`center`的值会调用 setter 来修改属性`origin`的`x`和`y`的值，从而实现移动正方形到新的位置。
+`center`属性之后被设置了一个新的值`(15, 15)`，表示向右上方移动正方形到如下图橙色正方形所示的位置。设置属性`center`的值会调用它的 setter 来修改属性`origin`的`x`和`y`的值，从而实现移动正方形到新的位置。
 
 <img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/computedProperties_2x.png" alt="Computed Properties sample" width="388" height="387" />
 
@@ -177,15 +177,15 @@ struct AlternativeRect {
     var origin = Point()
     var size = Size()
     var center: Point {
-    get {
-        let centerX = origin.x + (size.width / 2)
-        let centerY = origin.y + (size.height / 2)
-        return Point(x: centerX, y: centerY)
-    }
-    set {
-        origin.x = newValue.x - (size.width / 2)
-        origin.y = newValue.y - (size.height / 2)
-    }
+        get {
+            let centerX = origin.x + (size.width / 2)
+            let centerY = origin.y + (size.height / 2)
+            return Point(x: centerX, y: centerY)
+        }
+        set {
+            origin.x = newValue.x - (size.width / 2)
+            origin.y = newValue.y - (size.height / 2)
+        }
     }
 }
 ```
@@ -195,26 +195,24 @@ struct AlternativeRect {
 
 只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
 
-> 注意：
->
+> 注意：  
 > 必须使用`var`关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。
 
-
 只读计算属性的声明可以去掉`get`关键字和花括号：
 
 ```swift
 struct Cuboid {
     var width = 0.0, height = 0.0, depth = 0.0
     var volume: Double {
-    return width * height * depth
+    	return width * height * depth
     }
 }
 let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
-println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
+print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
 // 输出 "the volume of fourByFiveByTwo is 40.0"
 ```
 
-这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性，还有一个名为`volume`的只读计算属性用来返回立方体的体积。设置`volume`的值毫无意义，因为通过`width`、`height`和`depth`就能算出`volume`。然而，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。
+这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性。结构体还有一个名为`volume`的只读计算属性用来返回立方体的体积。设置`volume`的值毫无意义，因为无法确定修改`width`、`height`和`depth`三者中的哪些值来匹配新的`volume`，从而造成歧义。然而，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。
 
 <a name="property_observers"></a>
 ## 属性观察器

From 44f55a7a860abee52f81980f6c5d2615daccf6ab Mon Sep 17 00:00:00 2001
From: Siyu Yang <yangsiyu1992@gmail.com>
Date: Wed, 1 Jul 2015 10:35:21 +0800
Subject: [PATCH 046/228] Chapter2_Properties Section3_Property_Observers
 finished

---
 source/chapter2/10_Properties.md | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 4e645540..43e53c0c 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -222,34 +222,33 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
 可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。属性重载请参考[继承](chapter/13_Inheritance.html)一章的[重载](chapter/13_Inheritance.html#overriding)。
 
 > 注意：  
-> 不需要为无法重载的计算属性添加属性观察器，因为可以通过 setter 直接监控和响应值的变化。  
+> 不需要为非重载的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。  
 
 可以为属性添加如下的一个或全部观察器：
 
-- `willSet`在设置新的值之前调用
+- `willSet`在新的值被设置之前调用
 - `didSet`在新的值被设置之后立即调用
 
-`willSet`观察器会将新的属性值作为固定参数传入，在`willSet`的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称`newValue`表示。
+`willSet`观察器会将新的属性值作为常量参数传入，在`willSet`的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称`newValue`表示。
 
 类似地，`didSet`观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。
 
-> 注意：
->
+> 注意：  
 > `willSet`和`didSet`观察器在属性初始化过程中不会被调用，它们只会当属性的值在初始化之外的地方被设置时被调用。
 
-这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数，可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
+这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
 
 ```swift
 class StepCounter {
     var totalSteps: Int = 0 {
-    willSet(newTotalSteps) {
-        println("About to set totalSteps to \(newTotalSteps)")
-    }
-    didSet {
-        if totalSteps > oldValue  {
-            println("Added \(totalSteps - oldValue) steps")
+        willSet(newTotalSteps) {
+            print("About to set totalSteps to \(newTotalSteps)")
+        }
+        didSet {
+            if totalSteps > oldValue  {
+                print("Added \(totalSteps - oldValue) steps")
+            }
         }
-    }
     }
 }
 let stepCounter = StepCounter()
@@ -270,10 +269,10 @@ stepCounter.totalSteps = 896
 
 例子中的`willSet`观察器将表示新值的参数自定义为`newTotalSteps`，这个观察器只是简单的将新的值输出。
 
-`didSet`观察器在`totalSteps`的值改变后被调用，它把新的值和旧的值进行对比，如果总的步数增加了，就输出一个消息表示增加了多少步。`didSet`没有提供自定义名称，所以默认值`oldValue`表示旧值的参数名。
+`didSet`观察器在`totalSteps`的值改变后被调用，它把新的值和旧的值进行对比，如果总的步数增加了，就输出一个消息表示增加了多少步。`didSet`没有为旧的值提供自定义名称，所以默认值`oldValue`表示旧值的参数名。
 
 > 注意：  
-> 如果在`didSet`观察器里为属性赋值，这个值会替换观察器之前设置的值。  
+> 如果在一个属性的`didSet`观察器里为它赋值，这个值会替换该观察器之前设置的值。  
 
 <a name="global_and_local_variables"></a>
 ##全局变量和局部变量

From 2779cda3e9eff07d8f9159fb57b7eabc5bf0ccf4 Mon Sep 17 00:00:00 2001
From: Siyu Yang <yangsiyu1992@gmail.com>
Date: Wed, 1 Jul 2015 15:56:14 +0800
Subject: [PATCH 047/228] Chapter2_Properties Section4&5 finished

---
 source/chapter2/10_Properties.md | 77 +++++++++++++++++---------------
 1 file changed, 40 insertions(+), 37 deletions(-)

diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 43e53c0c..12f80f0b 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -277,11 +277,11 @@ stepCounter.totalSteps = 896
 <a name="global_and_local_variables"></a>
 ##全局变量和局部变量
 
-计算属性和属性观察器所描述的模式也可以用于*全局变量*和*局部变量*，全局变量是在函数、方法、闭包或任何类型之外定义的变量，局部变量是在函数、方法或闭包内部定义的变量。
+计算属性和属性观察器所描述的模式也可以用于*全局变量*和*局部变量*。全局变量是在函数、方法、闭包或任何类型之外定义的变量。局部变量是在函数、方法或闭包内部定义的变量。
 
 前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它提供特定类型的存储空间，并允许读取和写入。
 
-另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器，计算型变量跟计算属性一样，返回一个计算的值而不是存储值，声明格式也完全一样。
+另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义观察器。计算型变量跟计算属性一样，返回一个计算的值而不是存储值，声明格式也完全一样。
 
 > 注意：  
 > 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`lazy`特性。  
@@ -296,9 +296,7 @@ stepCounter.totalSteps = 896
 
 类型属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
 
-对于值类型（指结构体和枚举）可以定义存储型和计算型类型属性，对于类（class）则只能定义计算型类型属性。
-
-值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样定义成变量属性。
+值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样只能定义成变量属性。
 
 > 注意：  
 > 跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类型属性赋值。  
@@ -306,26 +304,30 @@ stepCounter.totalSteps = 896
 <a name="type_property_syntax"></a>
 ###类型属性语法
 
-在 C 或 Objective-C 中，静态常量和静态变量的定义是通过特定类型加上`global`关键字。在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
+在 C 或 Objective-C 中，与某个类型关联的静态常量和静态变量，是作为全局（*global*）静态变量定义的。但是在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
 
-使用关键字`static`来定义值类型的类型属性，关键字`class`来为类（class）定义类型属性。下面的例子演示了存储型和计算型类型属性的语法：
+使用关键字`static`来定义类型属性。在为类（class）定义计算型类型属性时，可以使用关键字`class`来支持子类对父类的实现进行重写。下面的例子演示了存储型和计算型类型属性的语法：
 
 ```swift
 struct SomeStructure {
     static var storedTypeProperty = "Some value."
     static var computedTypeProperty: Int {
-    // 这里返回一个 Int 值
+        return 1
     }
 }
 enum SomeEnumeration {
     static var storedTypeProperty = "Some value."
     static var computedTypeProperty: Int {
-    // 这里返回一个 Int 值
+        return 6
     }
 }
-class SomeClass {
-    class var computedTypeProperty: Int {
-    // 这里返回一个 Int 值
+class SomeClass {
+    static var storedTypeProperty = "Some value."
+    static var computedTypeProperty: Int {
+        return 27
+    }
+    class var overrideableComputedTypeProperty: Int {
+        return 107
     }
 }
 ```
@@ -336,17 +338,18 @@ class SomeClass {
 <a name="querying_and_setting_type_properties"></a>
 ###获取和设置类型属性的值
 
-跟实例的属性一样，类型属性的访问也是通过点运算符来进行，但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如：
+跟实例的属性一样，类型属性的访问也是通过点运算符来进行。但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如：
 
-```swift
-println(SomeClass.computedTypeProperty)
-// 输出 "42"
-
-println(SomeStructure.storedTypeProperty)
-// 输出 "Some value."
+```swift
+print(SomeStructure.storedTypeProperty)
+// 输出 "Some value."
 SomeStructure.storedTypeProperty = "Another value."
-println(SomeStructure.storedTypeProperty)
-// 输出 "Another value.”
+print(SomeStructure.storedTypeProperty)
+// 输出 "Another value.”
+print(SomeEnumeration.computedTypeProperty)
+// 输出 "6"
+print(SomeClass.computedTypeProperty)
+// 输出 "27"
 ```
 
 下面的例子定义了一个结构体，使用两个存储型类型属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。
@@ -355,23 +358,23 @@ println(SomeStructure.storedTypeProperty)
 
 <img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/staticPropertiesVUMeter_2x.png" alt="Static Properties VUMeter" width="243" height="357" />
 
-上面所描述的声道模型使用`AudioChannel`结构体来表示：
+上面所描述的声道模型使用`AudioChannel`结构体的实例来表示：
 
 ```swift
 struct AudioChannel {
     static let thresholdLevel = 10
     static var maxInputLevelForAllChannels = 0
     var currentLevel: Int = 0 {
-    didSet {
-        if currentLevel > AudioChannel.thresholdLevel {
-            // 将新电平值设置为阀值
-            currentLevel = AudioChannel.thresholdLevel
+        didSet {
+            if currentLevel > AudioChannel.thresholdLevel {
+                // 将新电平值设置为阀值
+                currentLevel = AudioChannel.thresholdLevel
+            }
+            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
+                // 存储当前电平值作为新的最大输入电平
+                AudioChannel.maxInputLevelForAllChannels = currentLevel
+            }
         }
-        if currentLevel > AudioChannel.maxInputLevelForAllChannels {
-            // 存储当前电平值作为新的最大输入电平
-            AudioChannel.maxInputLevelForAllChannels = currentLevel
-        }
-    }
     }
 }
 ```
@@ -382,10 +385,10 @@ struct AudioChannel {
 
 `AudioChannel`也定义了一个名为`currentLevel`的实例存储属性，表示当前声道现在的电平值，取值为 0 到 10。
 
-属性`currentLevel`包含`didSet`属性观察器来检查每次新设置后的属性值，有如下两个检查：
+属性`currentLevel`包含`didSet`属性观察器来检查每次新设置后的属性值，它有如下两个检查：
 
 - 如果`currentLevel`的新值大于允许的阈值`thresholdLevel`，属性观察器将`currentLevel`的值限定为阈值`thresholdLevel`。
-- 如果修正后的`currentLevel`值大于任何之前任意`AudioChannel`实例中的值，属性观察器将新值保存在静态属性`maxInputLevelForAllChannels`中。
+- 如果前一个修正后的`currentLevel`值大于任何之前任意`AudioChannel`实例中的值，属性观察器将新值保存在静态类型属性`maxInputLevelForAllChannels`中。
 
 > 注意：  
 > 在第一个检查过程中，`didSet`属性观察器将`currentLevel`设置成了不同的值，但这时不会再次调用属性观察器。  
@@ -401,9 +404,9 @@ var rightChannel = AudioChannel()
 
 ```swift
 leftChannel.currentLevel = 7
-println(leftChannel.currentLevel)
+print(leftChannel.currentLevel)
 // 输出 "7"
-println(AudioChannel.maxInputLevelForAllChannels)
+print(AudioChannel.maxInputLevelForAllChannels)
 // 输出 "7"
 ```
 
@@ -411,8 +414,8 @@ println(AudioChannel.maxInputLevelForAllChannels)
 
 ```swift
 rightChannel.currentLevel = 11
-println(rightChannel.currentLevel)
+print(rightChannel.currentLevel)
 // 输出 "10"
-println(AudioChannel.maxInputLevelForAllChannels)
+print(AudioChannel.maxInputLevelForAllChannels)
 // 输出 "10"
 ```

From 5ff10629b56f82ebc8833d305fe5e648b2203e02 Mon Sep 17 00:00:00 2001
From: Siyu Yang <yangsiyu1992@gmail.com>
Date: Wed, 1 Jul 2015 16:32:30 +0800
Subject: [PATCH 048/228] Chapter2_Properties Section3 minor_fix

---
 source/chapter2/10_Properties.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 12f80f0b..3ee6921e 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -233,8 +233,9 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
 
 类似地，`didSet`观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。
 
-> 注意：  
-> `willSet`和`didSet`观察器在属性初始化过程中不会被调用，它们只会当属性的值在初始化之外的地方被设置时被调用。
+> 注意：  
+> 父类的属性在子类的构造器中被赋值时，它在父类中的`willSet`和`didSet`观察器会被调用。  
+> 有关构造器代理的更多信息，请参考[值类型的构造器代理](chapter/14_Initialization.html#initializer_delegation_for_value_types)和[构造器链](chapter/14_Initialization.html#initialization_chain)。
 
 这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
 

From 39d551ae824fa292952e8d345b1a2a11ef68d0d7 Mon Sep 17 00:00:00 2001
From: Siyu Yang <yangsiyu1992@gmail.com>
Date: Wed, 1 Jul 2015 16:35:59 +0800
Subject: [PATCH 049/228] Chapter2_Type_Casting quote_format minor_fix

---
 source/chapter2/20_Type_Casting.md | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/source/chapter2/20_Type_Casting.md b/source/chapter2/20_Type_Casting.md
index dc72a95f..83929634 100644
--- a/source/chapter2/20_Type_Casting.md
+++ b/source/chapter2/20_Type_Casting.md
@@ -141,9 +141,8 @@ for item in library {
 
 若向下转型成功，然后 `movie` 的属性将用于打印一个 `Movie` 实例的描述，包括它的导演的名字 `director` 。相近的原理被用来检测 `Song` 实例，当 `Song` 被找到时则打印它的描述（包含 `artist` 的名字）。
 
-> 注意：
-
->转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
+> 注意：  
+> 转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
 
 <a name="type_casting_for_any_and_anyobject"></a>
 ## `Any`和`AnyObject`的类型转换
@@ -153,9 +152,8 @@ Swift为不确定类型提供了两种特殊类型别名：
 * `AnyObject`可以代表任何class类型的实例。
 * `Any`可以表示任何类型，包括方法类型（function types）。
 
-> 注意：
-
->只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
+> 注意：  
+> 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
 
 ### `AnyObject`类型
 
@@ -254,6 +252,5 @@ for thing in things {
 ```
 
 
-> 注意：
-
->在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 `switch` case 语句的内容中这种检查总是安全的。
+> 注意：  
+> 在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 `switch` case 语句的内容中这种检查总是安全的。

From 3aa84c3a90a3ce4c1129709bbd1805c909de86ec Mon Sep 17 00:00:00 2001
From: Channe <ichanne@qq.com>
Date: Wed, 1 Jul 2015 19:30:38 +0800
Subject: [PATCH 050/228] =?UTF-8?q?ARC=E4=B8=AD=E8=8B=B1=E6=96=87=E9=80=90?=
 =?UTF-8?q?=E5=AD=97=E6=AF=94=E5=AF=B9=E7=BF=BB=E8=AF=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

2.0英文版与原翻译版逐字比对，修改、润色部分翻译
---
 .../16_Automatic_Reference_Counting.md        | 113 +++++++++---------
 1 file changed, 59 insertions(+), 54 deletions(-)

diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index 42175064..b0efa8b9 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -13,7 +13,7 @@
 - [闭包引起的循环强引用](#strong_reference_cycles_for_closures)
 - [解决闭包引起的循环强引用](#resolving_strong_reference_cycles_for_closures)
 
-Swift 使用自动引用计数（ARC）这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。
+Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。
 
 然而，在少数情况下，ARC 为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用 ARC 来管理你的应用程序的内存。
 
@@ -23,13 +23,15 @@ Swift 使用自动引用计数（ARC）这一机制来跟踪和管理你的应
 <a name="how_arc_works"></a>
 ## 自动引用计数的工作机制
 
-当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
+当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。
+
+此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
 
 然而，当 ARC 收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。
 
-为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，ARC都不会销毁这个实例。
+为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为1，ARC都不会销毁这个实例。
 
-为了使之成为可能，无论你将实例赋值给属性，常量或者是变量，属性，常量或者变量，都会对此实例创建强引用。之所以称之为强引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被销毁的。
+为了使上述成为可能，无论你将实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称之为“强”引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被销毁的。
 
 <a name="arc_in_action"></a>
 ## 自动引用计数实践
@@ -49,9 +51,9 @@ class Person {
 }
 ```
 
-`Person`类有一个构造函数，此构造函数为实例的`name`属性赋值并打印出信息，以表明初始化过程生效。`Person`类同时也拥有析构函数，同样会在实例被销毁的时候打印出信息。
+`Person`类有一个构造函数，此构造函数为实例的`name`属性赋值，并打印一条消息以表明初始化过程生效。`Person`类也拥有一个析构函数，这个析构函数会在实例被销毁时打印一条消息。
 
-接下来的代码片段定义了三个类型为`Person?`的变量，用来按照代码片段中的顺序，为新的`Person`实例建立多个引用。由于这些变量是被定义为可选类型（Person?，而不是Person），它们的值会被自动初始化为`nil`，目前还不会引用到`Person`类的实例。
+接下来的代码片段定义了三个类型为`Person?`的变量，用来按照代码片段中的顺序，为新的`Person`实例建立多个引用。由于这些变量是被定义为可选类型（`Person?`，而不是`Person`），它们的值会被自动初始化为`nil`，目前还不会引用到`Person`类的实例。
 
 ```swift
 var reference1: Person?
@@ -59,7 +61,7 @@ var reference2: Person?
 var reference3: Person?
 ```
 
-现在你可以创建`Person`类的新实例，并且将它赋值给三个变量其中的一个：
+现在你可以创建`Person`类的新实例，并且将它赋值给三个变量中的一个：
 
 ```swift
 reference1 = Person(name: "John Appleseed")
@@ -68,25 +70,25 @@ reference1 = Person(name: "John Appleseed")
 
 应当注意到当你调用`Person`类的构造函数的时候，"John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。
 
-由于`Person`类的新实例被赋值给了`reference1`变量，所以`reference1`到`Person`类的新实例之间建立了一个强引用。正是因为这个强引用，ARC 会保证`Person`实例被保持在内存中不被销毁。
+由于`Person`类的新实例被赋值给了`reference1`变量，所以`reference1`到`Person`类的新实例之间建立了一个强引用。正是因为这一个强引用，ARC 会保证`Person`实例被保持在内存中不被销毁。
 
-如果你将同样的`Person`实例也赋值给其他两个变量，该实例又会多出两个强引用：
+如果你将同一个`Person`实例也赋值给其他两个变量，该实例又会多出两个强引用：
 
 ```swift
 reference2 = reference1
 reference3 = reference1
 ```
 
-现在这个`Person`实例已经有三个强引用了。
+现在这一个`Person`实例已经有三个强引用了。
 
-如果你通过给两个变量赋值`nil`的方式断开两个强引用（）包括最先的那个强引用），只留下一个强引用，`Person`实例不会被销毁：
+如果你通过给其中两个变量赋值`nil`的方式断开两个强引用（包括最先的那个强引用），只留下一个强引用，`Person`实例不会被销毁：
 
 ```swift
 reference1 = nil
 reference2 = nil
-```
-
-ARC 会在第三个，也即最后一个强引用被断开的时候，销毁`Person`实例，这也意味着你不再使用这个`Person`实例：
+```
+
+在你清楚地表明不再使用这个`Person`实例时，即第三个也就是最后一个强引用被断开时，ARC 会销毁它。
 
 ```swift
 reference3 = nil
@@ -98,9 +100,9 @@ reference3 = nil
 
 在上面的例子中，ARC 会跟踪你所新创建的`Person`实例的引用数量，并且会在`Person`实例不再被需要时销毁它。
 
-然而，我们可能会写出这样的代码，一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用，并让对方不被销毁。这就是所谓的循环强引用。
+然而，我们可能会写出一个类实例的强引用数永远不能变成0的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，就是这种情况。这就是所谓的循环强引用。
 
-你可以通过定义类之间的关系为弱引用或者无主引用，以此替代强引用，从而解决循环强引用的问题。具体的过程在[解决类实例之间的循环强引用](#resolving_strong_reference_cycles_between_class_instances)中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。
+你可以通过定义类之间的关系为弱引用或无主引用，以替代强引用，从而解决循环强引用的问题。具体的过程在[解决类实例之间的循环强引用](#resolving_strong_reference_cycles_between_class_instances)中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。
 
 下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：`Person`和`Apartment`，用来建模公寓和它其中的居民:
 
@@ -128,14 +130,14 @@ class Apartment {
 
 这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓`Person`和`Apartment`的实例是否像预期的那样被销毁。
 
-接下来的代码片段定义了两个可选类型的变量`john`和`number73`,并分别被设定为下面的`Apartment`和`Person`的实例。这两个变量都被初始化为`nil`，并为可选的：
+接下来的代码片段定义了两个可选类型的变量`john`和`number73`，并分别被设定为下面的`Apartment`和`Person`的实例。这两个变量都被初始化为`nil`，这正是可选的优点：
 
 ```swift
 var john: Person?
 var number73: Apartment?
 ```
 
-现在你可以创建特定的`Person`和`Apartment`实例并将类实例赋值给`john`和`number73`变量：
+现在你可以创建特定的`Person`和`Apartment`实例并将赋值给`john`和`number73`变量：
 
 ```swift
 john = Person(name: "John Appleseed")
@@ -156,15 +158,15 @@ number73!.tenant = john
 在将两个实例联系在一起之后，强引用的关系如图所示：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle02_2x.png)
-
-不幸的是，将这两个实例关联在一起之后，一个循环强引用被创建了。`Person`实例现在有了一个指向`Apartment`实例的强引用，而`Apartment`实例也有了一个指向`Person`实例的强引用。因此，当你断开`john`和`number73`变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
+
+不幸的是，这两个实例关联后会产生一个循环强引用。`Person`实例现在有了一个指向`Apartment`实例的强引用，而`Apartment`实例也有了一个指向`Person`实例的强引用。因此，当你断开`john`和`number73`变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
 
 ```swift
 john = nil
 number73 = nil
 ```
 
-注意，当你把这两个变量设为`nil`时，没有任何一个析构函数被调用。强引用循环阻止了`Person`和`Apartment`类实例的销毁，并在你的应用程序中造成了内存泄漏。
+注意，当你把这两个变量设为`nil`时，没有任何一个析构函数被调用。循环强引用会一直阻止`Person`和`Apartment`类实例的销毁，这就在你的应用程序中造成了内存泄漏。
 
 在你将`john`和`number73`赋值为`nil`后，强引用关系如下图：
 
@@ -179,20 +181,20 @@ Swift 提供了两种办法用来解决你在使用类的属性时所遇到的
 
 弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。
 
-对于生命周期中会变为`nil`的实例使用弱引用。相反的，对于初始化赋值后再也不会被赋值为`nil`的实例，使用无主引用。
+对于生命周期中会变为`nil`的实例使用弱引用。相反地，对于初始化赋值后再也不会被赋值为`nil`的实例，使用无主引用。
 
 ### 弱引用
+
+弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或者变量时，在前面加上`weak`关键字表明这是一个弱引用。
 
-弱引用不会牢牢保持住引用的实例，并且不会阻止 ARC 销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上`weak`关键字表明这是一个弱引用。
-
-在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以阻止循环强引用。如果引用总是有值，则可以使用无主引用，在[无主引用](#2)中有描述。在上面`Apartment`的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。
+在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以避免循环强引用。如果引用总是有值，则可以使用无主引用，在[无主引用](#2)中有描述。在上面`Apartment`的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。
 
 > 注意:  
 > 弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。  
 
-因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。可选类型是在 Swift 语言中推荐的用来表示可能没有值的类型。
+因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。在 Swift 中，推荐使用可选类型描述可能没有值的类型。
 
-因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其赋值为`nil`。你可以像其他可选值一样，检查弱引用的值是否存在，你永远也不会遇到被销毁了而不存在的实例。
+因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其赋值为`nil`。你可以像其他可选值一样，检查弱引用的值是否存在，你将永远不会访问已销毁的实例的引用。
 
 下面的例子跟上面`Person`和`Apartment`的例子一致，但是有一个重要的区别。这一次，`Apartment`的`tenant`属性被声明为弱引用：
 
@@ -214,7 +216,7 @@ class Apartment {
 }
 ```
 
-然后跟之前一样，建立两个变量（john和number73）之间的强引用，并关联两个实例：
+然后跟之前一样，建立两个变量（`john`和`number73`）之间的强引用，并关联两个实例：
 
 ```swift
 var john: Person?
@@ -264,11 +266,11 @@ number73 = nil
 
 > 注意:  
 >如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。  
-> 还需要注意的是如果你试图访问实例已经被销毁的无主引用，程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。  
+> 还需要注意的是如果你试图访问实例已经被销毁的无主引用，Swift 确保程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。  
 
-下面的例子定义了两个类，`Customer`和`CreditCard`，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系会潜在的创造循环强引用。
+下面的例子定义了两个类，`Customer`和`CreditCard`，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系可能会造成循环强引用。
 
-`Customer`和`CreditCard`之间的关系与前面弱引用例子中`Apartment`和`Person`的关系截然不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，`Customer`类有一个可选类型的`card`属性，但是`CreditCard`类有一个非可选类型的`customer`属性。
+`Customer`和`CreditCard`之间的关系与前面弱引用例子中`Apartment`和`Person`的关系略微不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，`Customer`类有一个可选类型的`card`属性，但是`CreditCard`类有一个非可选类型的`customer`属性。
 
 此外，只能通过将一个`number`值和`customer`实例传递给`CreditCard`构造函数的方式来创建`CreditCard`实例。这样可以确保当创建`CreditCard`实例时总是有一个`customer`实例与之关联。
 
@@ -287,15 +289,18 @@ class Customer {
 
 ```swift
 class CreditCard {
-    let number: Int
+    let number: UInt64
     unowned let customer: Customer
-    init(number: Int, customer: Customer) {
+    init(number: UInt64, customer: Customer) {
         self.number = number
         self.customer = customer
     }
     deinit { print("Card #\(number) is being deinitialized") }
 }
-```
+```
+
+> 注意: 
+> `CreditCard`类的`number`属性被定义为`UInt64`类型而不是`Int`类型，以确保`number`属性的存储量在32位和64位系统上都能足够容纳16位的卡号。
 
 下面的代码片段定义了一个叫`john`的可选类型`Customer`变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为`nil`。
 
@@ -336,13 +341,13 @@ john = nil
 
 `Person`和`Apartment`的例子展示了两个属性的值都允许为`nil`，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。
 
-`Customer`和`CreditCard`的例子展示了一个属性的值允许为`nil`，而另一个属性的值不允许为`nil`，并会潜在的产生循环强引用。这种场景最适合通过无主引用来解决。
+`Customer`和`CreditCard`的例子展示了一个属性的值允许为`nil`，而另一个属性的值不允许为`nil`，这也可能会产生循环强引用。这种场景最适合通过无主引用来解决。
 
-然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后不能为`nil`。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。
+然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为`nil`。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。
 
 这使两个属性在初始化完成后能被直接访问（不需要可选展开），同时避免了循环引用。这一节将为你展示如何建立这种关系。
 
-下面的例子定义了两个类，`Country`和`City`，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，而每一个城市必须属于一个国家。为了实现这种关系，`Country`类拥有一个`capitalCity`属性，而`City`类有一个`country`属性：
+下面的例子定义了两个类，`Country`和`City`，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，每个城市必须属于一个国家。为了实现这种关系，`Country`类拥有一个`capitalCity`属性，而`City`类有一个`country`属性：
 
 ```swift
 class Country {
@@ -370,7 +375,7 @@ class City {
 
 `Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化完后，`Country`的构造函数才能把`self`传给`City`的构造函数。（[在两段式构造过程中有具体描述](14_Initialization.html)）
 
-为了满足这种需求，通过在类型结尾处加上感叹号（City!）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（[在隐式解析可选类型中有描述](01_The_Basics.html)）
+为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（[在隐式解析可选类型中有描述](01_The_Basics.html)）
 
 由于`capitalCity`默认值为`nil`，一旦`Country`的实例在构造函数中给`name`属性赋值后，整个初始化过程就完成了。这代表一旦`name`属性被赋值后，`Country`的构造函数就能引用并传递隐式的`self`。`Country`的构造函数在赋值`capitalCity`时，就能将`self`作为参数传递给`City`的构造函数。
 
@@ -387,13 +392,13 @@ print("\(country.name)'s capital city is called \(country.capitalCity.name)")
 <a name="strong_reference_cycles_for_closures"></a>
 ##闭包引起的循环强引用
 
-前面我们看到了循环强引用环是在两个类实例属性互相保持对方的强引用时产生的，还知道了如何用弱引用和无主引用来打破循环强引用。
+前面我们看到了循环强引用是在两个类实例属性互相保持对方的强引用时产生的，还知道了如何用弱引用和无主引用来打破这些循环强引用。
 
-循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如`self.someProperty`，或者闭包中调用了实例的某个方法，例如`self.someMethod`。这两种情况都导致了闭包 “捕获" `self`，从而产生了循环强引用。
+循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了这个类实例。这个闭包体中可能访问了实例的某个属性，例如`self.someProperty`，或者闭包中调用了实例的某个方法，例如`self.someMethod`。这两种情况都导致了闭包 “捕获" `self`，从而产生了循环强引用。
 
 循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你也把一个引用赋值给了这个闭包。实质上，这跟之前的问题是一样的－两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。
 
-Swift 提供了一种优雅的方法来解决这个问题，称之为闭包占用列表（closuer capture list）。同样的，在学习如何用闭包占用列表破坏循环强引用之前，先来了解一下循环强引用是如何产生的，这对我们是很有帮助的。
+Swift 提供了一种优雅的方法来解决这个问题，称之为闭包捕获列表（closuer capture list）。同样的，在学习如何用闭包捕获列表破坏循环强引用之前，先来了解一下这里的循环强引用是如何产生的，这对我们很有帮助。
 
 下面的例子为你展示了当一个闭包引用了`self`后是如何产生一个循环强引用的。例子中定义了一个叫`HTMLElement`的类，用一种简单的模型表示 HTML 中的一个单独的元素：
 
@@ -425,9 +430,9 @@ class HTMLElement {
 
 `HTMLElement`类定义了一个`name`属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。`HTMLElement`还定义了一个可选属性`text`，用来设置和展现 HTML 元素的文本。
 
-除了上面的两个属性，`HTMLElement`还定义了一个`lazy`属性`asHTML`。这个属性引用了一个闭包，将`name`和`text`组合成 HTML 字符串片段。该属性是`() -> String`类型，或者可以理解为“一个没有参数，返回`String`的函数”。
+除了上面的两个属性，`HTMLElement`还定义了一个`lazy`属性`asHTML`。这个属性引用了一个将`name`和`text`组合成 HTML 字符串片段的闭包。该属性是`Void -> String`类型，或者可以理解为“一个没有参数，返回`String`的函数”。
 
-默认情况下，闭包赋值给了`asHTML`属性，这个闭包返回一个代表 HTML 标签的字符串。如果`text`值存在，该标签就包含可选值`text`；如果`text`不存在，该标签就不包含文本。对于段落元素，根据`text`是"some text"还是`nil`，闭包会返回"`<p>some text</p>`"或者"`<p />`"。
+默认情况下，闭包赋值给了`asHTML`属性，这个闭包返回一个代表 HTML 标签的字符串。如果`text`值存在，该标签就包含可选值`text`；如果`text`不存在，该标签就不包含文本。对于段落元素，根据`text`是`"some text"`还是`nil`，闭包会返回"`<p>some text</p>`"或者"`<p />`"。
 
 可以像实例方法那样去命名、使用`asHTML`属性。然而，由于`asHTML`是闭包而不是实例方法，如果你想改变特定元素的 HTML 处理的话，可以用自定义的闭包来取代默认值。
 
@@ -470,38 +475,38 @@ paragraph = nil
 在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。
 
 >注意:  
-Swift 有如下要求：只要在闭包内使用`self`的成员，就要用`self.someProperty`或者`self.someMethod`（而不只是`someProperty`或`someMethod`）。这提醒你可能会不小心就捕获了`self`。
+Swift 有如下要求：只要在闭包内使用`self`的成员，就要用`self.someProperty`或者`self.someMethod`（而不只是`someProperty`或`someMethod`）。这提醒你可能会一不小心就捕获了`self`。
 
-###定义捕获列表
+###定义捕获列表
 
-捕获列表中的每个元素都是由`weak`或者`unowned`关键字和实例的引用（如`self`或`someInstance`）成对组成。每一对都在方括号中，通过逗号分开。
+捕获列表中的每一项都由一对元素组成，一个元素是`weak`或`unowned`关键字，另一个元素是类实例的引用（如`self`）或初始化过的变量（如`delegate = self.delegate!`）。这些项在方括号中用逗号分开。
 
-捕获列表放置在闭包参数列表和返回类型之前：
+如果闭包有参数列表和返回类型，把捕获列表放在它们前面：
 
 ```swift
 lazy var someClosure: (Int, String) -> String = {
-    [unowned self] (index: Int, stringToProcess: String) -> String in
+    [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
     // closure body goes here
 }
 ```
 
-如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以捕获列表放在闭包开始的地方，跟着是关键字`in`：
+如果闭包没有指明参数列表或者返回类型，即它们会通过上下文推断，那么可以把捕获列表和关键字`in`放在闭包最开始的地方：
 
 ```swift
 lazy var someClosure: Void -> String = {
-    [unowned self] in
+    [unowned self, weak delegate = self.delegate!] in
     // closure body goes here
 }
 ```
 
 ###弱引用和无主引用
 
-当闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。
+在闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。
 
-相反的，当捕获引用有时可能会是`nil`时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为`nil`。这使我们可以在闭包内检查它们是否存在。
+相反的，在被捕获的引用可能会变为`nil`时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为`nil`。这使我们可以在闭包体内检查它们是否存在。
 
 >注意:  
-如果捕获的引用绝对不会置为`nil`，应该用无主引用，而不是弱引用。
+如果被捕获的引用绝对不会变为`nil`，应该用无主引用，而不是弱引用。
 
 前面的`HTMLElement`例子中，无主引用是正确的解决循环强引用的方法。这样编写`HTMLElement`类来避免循环强引用：
 
@@ -532,7 +537,7 @@ class HTMLElement {
 }
 ```
 
-上面的`HTMLElement`实现和之前的实现一致，只是在`asHTML`闭包中多了一个捕获列表。这里，捕获列表是`[unowned self]`，表示“用无主引用而不是强引用来捕获`self`”。
+上面的`HTMLElement`实现和之前的实现一致，除了在`asHTML`闭包中多了一个捕获列表。这里，捕获列表是`[unowned self]`，表示“用无主引用而不是强引用来捕获`self`”。
 
 和之前一样，我们可以创建并打印`HTMLElement`实例：
 

From aee32488e24d7688817ef3bc538b0167a9ce469f Mon Sep 17 00:00:00 2001
From: chenYuheng <yuheng@tataufo.com>
Date: Wed, 1 Jul 2015 21:44:44 +0800
Subject: [PATCH 051/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=80=E5=A4=84pri?=
 =?UTF-8?q?ntln=E7=9A=84=E6=9B=B4=E6=96=B0=EF=BC=8C=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=B5=8C=E5=A5=97=E7=B1=BB=E5=9E=8B=E7=9A=84=E4=BF=AE=E6=94=B9?=
 =?UTF-8?q?=E5=92=8C=E6=9B=B4=E6=96=B0=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/19_Nested_Types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/19_Nested_Types.md
index bd03302e..46c4a6bc 100755
--- a/source/chapter2/19_Nested_Types.md
+++ b/source/chapter2/19_Nested_Types.md
@@ -76,7 +76,7 @@ struct BlackjackCard {
 
 ```swift
 let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades)
-println("theAceOfSpades: \(theAceOfSpades.description)")
+print("theAceOfSpades: \(theAceOfSpades.description)")
 // 打印出 "theAceOfSpades: suit is ♠, value is 1 or 11"
 ```
 

From f12bd074fd4c792fb6bd1c8d933ed60684a4038d Mon Sep 17 00:00:00 2001
From: shanksyang <shanks@weedo.hk>
Date: Thu, 2 Jul 2015 20:20:44 +0800
Subject: [PATCH 052/228] =?UTF-8?q?swift=202.0,=2013=5FInheritance,?=
 =?UTF-8?q?=E7=BB=A7=E6=89=BF=E9=83=A8=E5=88=86=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/13_Inheritance.md | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index 3ab4e7a4..fc2f5918 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -11,11 +11,11 @@
 - [重写（Overriding）](#overriding)
 - [防止重写](#preventing_overrides)
 
-一个类可以*继承（inherit）*另一个类的方法（methods），属性（property）和其它特性。当一个类继承其它类时，继承类叫*子类（subclass）*，被继承类叫*超类（或父类，superclass）*。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。
+一个类可以*继承（inherit）*另一个类的方法（methods），属性（properties）和其它特性。当一个类继承其它类时，继承类叫*子类（subclass）*，被继承类叫*超类（或父类，superclass）*。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。
 
 在 Swift 中，类可以调用和访问超类的方法，属性和下标脚本（subscripts），并且可以重写（override）这些方法，属性和下标脚本来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。
 
-可以为类中继承来的属性添加属性观察器（property observer），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。
+可以为类中继承来的属性添加属性观察器（property observers），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。
 
 <a name="defining_a_base_class"></a>
 ## 定义一个基类（Base class）
@@ -27,7 +27,7 @@ Swift 中的类并不是从一个通用的基类继承而来。如果你不为
 
 下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了一个名为`currentSpeed `，默认值是0.0的存储属性(属性类型推断为`Double `)。`currentSpeed `属性的值被一个`String` 类型的只读计算型属性`description`使用，用来创建车辆的描述。
 
-`Vehicle`基类也定义了一个名为`makeNoise`的方法。这个方法实际上不为`Vehicle`实例做任何事，但之后将会被`Vehicle`的子类定制
+`Vehicle`基类也定义了一个名为`makeNoise`的方法。这个方法实际上不为`Vehicle`实例做任何事，但之后将会被`Vehicle`的子类定制：
 
 ```swift
 class Vehicle {
@@ -41,7 +41,7 @@ class Vehicle {
 }
 ```
 
-您可以用初始化语法创建一个`Vehicle `的新实例，即 `TypeName`后面跟一个空括号：
+您可以用初始化语法创建一个`Vehicle `的新实例，即类名后面跟一个空括号：
 ```swift
 let someVehicle = Vehicle()
 ```
@@ -51,7 +51,9 @@ let someVehicle = Vehicle()
 ```swift
 println("Vehicle: \(someVehicle.description)")
 // Vehicle: traveling at 0.0 miles per hour
-```
+```
+
+`Vehicle`类定义了一个通用特性的车辆类，实际上没什么用处。为了让它变得更加有用，需要改进它能够描述一个更加具体的车辆类。
 
 <a name="subclassing"></a>
 ## 子类生成（Subclassing）
@@ -66,17 +68,13 @@ class SomeClass: SomeSuperclass {
 }
 ```
 
-下一个例子，定义一个更具体的车辆类叫`Bicycle`。这个新类是在 `Vehicle`类的基础上创建起来。因此你需要将`Vehicle`类放在 `Bicycle`类后面，用冒号分隔。
-
-我们可以将这读作：
-
-“定义一个新的类叫`Bicycle `，它继承了`Vehicle`的特性”；
-
+下一个例子，定义一个叫`Bicycle`的子类，继承成父类`Vehicle`
+
 ```swift
 class Bicycle: Vehicle {
     var hasBasket = false
 }
-```
+```
 
 新的`Bicycle`类自动获得`Vehicle`类的所有特性，比如 `currentSpeed `和`description`属性，还有它的`makeNoise`方法。
 
@@ -161,7 +159,7 @@ train.makeNoise()
 
 ### 重写属性
 
-你可以重写继承来的实例属性或类属性，提供自己定制的getter和setter，或添加属性观察器使重写的属性观察属性值什么时候发生改变。
+你可以重写继承来的实例属性或类属性，提供自己定制的getter和setter，或添加属性观察器使重写的属性可以观察属性值什么时候发生改变。
 
 #### 重写属性的Getters和Setters
 
@@ -228,7 +226,7 @@ println("AutomaticCar: \(automatic.description)")
 
 你可以通过把方法，属性或下标脚本标记为*`final`*来防止它们被重写，只需要在声明关键字前加上`final`特性即可。（例如：`final var`, `final func`, `final class func`, 以及 `final subscript`）
 
-如果你重写了`final`方法，属性或下标脚本，在编译时会报错。在扩展中，你添加到类里的方法，属性或下标脚本也可以在扩展的定义里标记为 final。
+如果你重写了`final`方法，属性或下标脚本，在编译时会报错。在类扩展中的方法，属性或下标脚本也可以在扩展的定义里标记为 final。
 
-你可以通过在关键字`class`前添加`final`特性（`final class`）来将整个类标记为 final 的，这样的类是不可被继承的，否则会报编译错误。
+你可以通过在关键字`class`前添加`final`特性（`final class`）来将整个类标记为 final 的，这样的类是不可被继承的，任何子类试图继承此类时，在编译时会报错。
 

From d324bae47d7151ff9a5fe37119a7b502e0685f1c Mon Sep 17 00:00:00 2001
From: justaway <bug_free@163.com>
Date: Fri, 3 Jul 2015 00:35:54 +0800
Subject: [PATCH 053/228] =?UTF-8?q?'25=5FAdvanced=5FOperators'=E4=B8=AD?=
 =?UTF-8?q?=E7=9A=84=E6=8C=89=E4=BD=8D=E5=8F=96=E5=8F=8D=E5=B0=8F=E8=8A=82?=
 =?UTF-8?q?=E7=BF=BB=E8=AF=91=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/25_Advanced_Operators.md | 26 ++++++++++++------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index 9e1e26a7..1badc3b8 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -12,37 +12,37 @@
 - [运算符函数(Operator Functions)](#operator_functions)
 - [自定义运算符](#custom_operators)
 
-除了[基本操作符](02_Basic_Operators.html)中所讲的运算符，Swift还有许多复杂的高级运算符，包括了C语言和Objective-C中的位运算符和移位运算。
+除了在之前介绍过的[基本运算符](02_Basic_Operators.html)，Swift 中还有许多可以对数值进行复杂操作的高级运算符。这些高级运算符包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。
 
-不同于C语言中的数值计算，Swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的？好吧，你可以使用Swift为你准备的另一套默认允许溢出的数值运算符，如可溢出的加号为`&+`。所有允许溢出的运算符都是以`&`开始的。
+与C语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符(`&+`)。所有的这些溢出运算符都是以 `&` 开头的。
 
-自定义的结构，类和枚举，是否可以使用标准的运算符来定义操作？当然可以！在Swift中，你可以为你创建的所有类型定制运算符的操作。
+在定义自有的结构体、类和枚举时，最好也同时为它们提供标准swift运算符的实现。Swift简化了运算符的自定义实现，也使判断不同类型所对应的行为更为简单。
 
-可定制的运算符并不限于那些预设的运算符，你可以自定义中置，前置，后置及赋值运算符，当然还有优先级和结合性。这些运算符在代码中可以像预设的运算符一样使用，你也可以扩展已有的类型以支持你自定义的运算符。
+我们不用被预定义的运算符所限制。在 Swift 当中可以自由地定义中缀、前缀、后缀和赋值运算符，以及相应的优先级与结合性。这些运算符在代码中可以像预设的运算符一样使用，我们甚至可以扩展已有的类型以支持自定义的运算符。
 
 <a name="bitwise_operators"></a>
 ## 位运算符
 
-位操作符可以操作数据结构中原始数据的每个比特位。位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用，位操作符在同外部资源的数据进行交互的时候也很有用，比如在使用用户协议进行通信的时候，运用位运算符来对原始数据进行编码和解码。
+位运算符(`Bitwise operators`)可以操作一个数据结构中每个独立的比特位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。
 
-Swift支持如下所有C语言的位运算符：
+Swift 支持C语言中的全部位运算符，具体如下：
 
-### 按位取反运算符
+### 按位取反运算符(`bitwise NOT operator`)
 
-按位取反运算符`~`对一个操作数的每一位都取反。
+按位取反运算符(`~`) 可以对一个数值的全部比特位进行取反：
 
-![Art/bitwiseNOT_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseNOT_2x.png "Art/bitwiseNOT_2x.png")
+![Art/bitwiseNOT_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseNOT_2x.png)
 
-这个运算符是前置的，所以请不加任何空格地写在操作数之前。
+按位取反操作符是一个前置运算符，需要直接放在操作数的之前，并且它们之间不能添加任何空格。
 
-```swift
+```
 let initialBits: UInt8 = 0b00001111
 let invertedBits = ~initialBits  // 等于 0b11110000
 ```
 
-`UInt8`是8位无符整型，可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值`00001111`(前4位为`0`，后4位为`1`)，它的十进制值为`15`。
+`UInt8` 类型的整数有 8 个比特位，可以存储 0 ~ 255之间的任意整数。这个例子初始化了一个 `UInt8` 类型的整数，其二进制值为 `00001111`，它的前 4 位都为`0`，后 4 位都为`1`。这个值等价于十进制的 `15` 。
 
-使用按位取反运算`~`对`initialBits`操作，然后赋值给`invertedBits`这个新常量。这个新常量的值等于所有位都取反的`initialBits`，即`1`变成`0`，`0`变成`1`，变成了`11110000`，十进制值为`240`。
+接着使用按位取反运算符创建了一个名为 `invertedBits` 的常量，这个常量的值与全部比特位取反后的 `initialBits` 相等。即所有的 `0` 都变成了 `1`，同时所有的 `1` 都变成 `0`。`invertedBits` 的二进制值为 `11110000`，等价于无符号十进制数的 `240`。
 
 ### 按位与运算符
 

From c274e371837228e412be7a375806fb1552425bb4 Mon Sep 17 00:00:00 2001
From: justaway <bug_free@163.com>
Date: Fri, 3 Jul 2015 12:32:00 +0800
Subject: [PATCH 054/228] =?UTF-8?q?'25=5FAdvanced=5FOperators'=E7=BF=BB?=
 =?UTF-8?q?=E8=AF=91=E5=88=B0=E6=BA=A2=E5=87=BA=E8=BF=90=E7=AE=97=E7=AC=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/25_Advanced_Operators.md | 94 +++++++++++++-----------
 1 file changed, 50 insertions(+), 44 deletions(-)

diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index 1badc3b8..4dd48634 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -23,13 +23,13 @@
 <a name="bitwise_operators"></a>
 ## 位运算符
 
-位运算符(`Bitwise operators`)可以操作一个数据结构中每个独立的比特位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。
+位运算符(`Bitwise operators`)可以操作一个数据结构中每个独立的位。它们通常被用在底层开发中，比如图形编程和创建设备驱动。位运算符在处理外部资源的原始数据时也十分有用，比如对自定义通信协议传输的数据进行编码和解码。
 
 Swift 支持C语言中的全部位运算符，具体如下：
 
 ### 按位取反运算符(`bitwise NOT operator`)
 
-按位取反运算符(`~`) 可以对一个数值的全部比特位进行取反：
+按位取反运算符(`~`) 可以对一个数值的全部位进行取反：
 
 ![Art/bitwiseNOT_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseNOT_2x.png)
 
@@ -40,47 +40,47 @@ let initialBits: UInt8 = 0b00001111
 let invertedBits = ~initialBits  // 等于 0b11110000
 ```
 
-`UInt8` 类型的整数有 8 个比特位，可以存储 0 ~ 255之间的任意整数。这个例子初始化了一个 `UInt8` 类型的整数，其二进制值为 `00001111`，它的前 4 位都为`0`，后 4 位都为`1`。这个值等价于十进制的 `15` 。
+`UInt8` 类型的整数有 8 个比特位，可以存储 0 ~ 255之间的任意整数。这个例子初始化了一个 `UInt8` 类型的整数，并赋值为二进制的 `00001111`，它的前 4 位都为`0`，后 4 位都为`1`。这个值等价于十进制的 `15` 。
 
-接着使用按位取反运算符创建了一个名为 `invertedBits` 的常量，这个常量的值与全部比特位取反后的 `initialBits` 相等。即所有的 `0` 都变成了 `1`，同时所有的 `1` 都变成 `0`。`invertedBits` 的二进制值为 `11110000`，等价于无符号十进制数的 `240`。
+接着使用按位取反运算符创建了一个名为 `invertedBits` 的常量，这个常量的值与全部位取反后的 `initialBits` 相等。即所有的 `0` 都变成了 `1`，同时所有的 `1` 都变成 `0`。`invertedBits` 的二进制值为 `11110000`，等价于无符号十进制数的 `240`。
 
-### 按位与运算符
+### 按位与运算符(Bitwise AND Operator)
 
-按位与运算符对两个数进行操作，然后返回一个新的数，这个数的每个位都需要两个输入数的同一位都为1时才为1。
+按位与运算符(`&`)可以对两个数的比特位进行合并。它返回一个新的数，只有当两个操作数的对应位*都*为 `1` 的时候，该数的对应位才为 `1`。
 
 ![Art/bitwiseAND_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseAND_2x.png "Art/bitwiseAND_2x.png")
 
-以下代码，`firstSixBits`和`lastSixBits`中间4个位都为1。对它俩进行按位与运算后，就得到了`00111100`，即十进制的`60`。
+在下面的示例当中，`firstSixBits` 和 `lastSixBits` 中间 4 个位的值都为 1 。按位与运算符对它们进行了运算，得到二进制数值 `00111100`，等价于无符号十进制数的 `60`：
 
-```swift
+```
 let firstSixBits: UInt8 = 0b11111100
 let lastSixBits: UInt8  = 0b00111111
 let middleFourBits = firstSixBits & lastSixBits  // 等于 00111100
 ```
 
-### 按位或运算
+### 按位或运算符(Bitwise OR Operator)
 
-按位或运算符`|`比较两个数，然后返回一个新的数，这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1，或都为1)。
+按位或运算符(`|`)可以对两个数的比特位进行比较。它返回一个新的数，只要两个操作数的对应位中有*任意*一个为 `1` 时，该数的对应位就为 `1`。
 
 ![Art/bitwiseOR_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseOR_2x.png "Art/bitwiseOR_2x.png")
 
-如下代码，`someBits`和`moreBits`在不同位上有`1`。按位或运行的结果是`11111110`，即十进制的`254`。
+在下面的示例当中，`someBits` 和 `moreBits` 将不同的位设置为 `1`。接位或运算符对它们进行了运算，得到二进制数值 `11111110`，等价于无符号十进制数的 `254`：
 
-```swift
+```
 let someBits: UInt8 = 0b10110010
 let moreBits: UInt8 = 0b01011110
 let combinedbits = someBits | moreBits  // 等于 11111110
 ```
 
-### 按位异或运算符
+### 按位异或运算符(Bitwise XOR Opoerator)
 
-按位异或运算符`^`比较两个数，然后返回一个数，这个数的每个位设为`1`的条件是两个输入数的同一位不同，如果相同就设为`0`。
+按位异或运算符(`^`)可以对两个数的比特位进行比较。它返回一个新的数，当两个操作数的对应位不相同时，该数的对应位就为 `1`：
 
 ![Art/bitwiseXOR_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitwiseXOR_2x.png "Art/bitwiseXOR_2x.png")
 
-以下代码，`firstBits`和`otherBits`都有一个`1`跟另一个数不同的。所以按位异或的结果是把它这些位置为`1`，其他都置为`0`。
+在下面的示例当中，`firstBits` 和 `otherBits` 都有一个自己设置为 `1` 而对方设置为 `0` 的位。 按位异或运算符将这两个位都设置为 `1`，同时将其它位都设置为 `0`：
 
-```swift
+```
 let firstBits: UInt8 = 0b00010100
 let otherBits: UInt8 = 0b00000101
 let outputBits = firstBits ^ otherBits  // 等于 00010001
@@ -88,21 +88,27 @@ let outputBits = firstBits ^ otherBits  // 等于 00010001
 
 ### 按位左移/右移运算符
 
-左移运算符`<<`和右移运算符`>>`会把一个数的所有比特位按以下定义的规则向左或向右移动指定位数。
+按位左移运算符(`<<`)和按位右移运算符(`>>`)可以对一个数进行指定位数的左移和右移，但是需要遵守下面定义的规则。
 
-按位左移和按位右移的效果相当把一个整数乘于或除于一个因子为`2`的整数。向左移动一个整型的比特位相当于把这个数乘于`2`，向右移一位就是除于`2`。
+对一个数进行按位左移或按位右移，相当于对这个数进行乘以 2 或除以 2 的运算。将一个整数左移一位，等价于将这个数乘以 2，同样地，将一个整数右移一位，等价于将这个数除以 2。
 
-#### 无符整型的移位操作
+#### 无符号整型的移位操作
 
-对无符整型的移位的效果如下：
+对无符号整型进行移位的规则如下：
 
-已经存在的比特位向左或向右移动指定的位数。被移出整型存储边界的的位数直接抛弃，移动留下的空白位用零`0`来填充。这种方法称为逻辑移位。
+1. 已经存在的比特位按指定的位数进行左移和右移。
+2. 任何移动超出整型存储边界的位都会被丢弃。
+3. 用 0 来填充移动后产生的空白位。
 
-以下这张把展示了 `11111111 << 1`(`11111111`向左移1位)，和 `11111111 >> 1`(`11111111`向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的`0`是被填充进来的。
+这种方法称为逻辑移位(`logical shift`)。
+
+以下这张图展示了 `11111111 << 1`(即把 `11111111` 向左移动 1 位)，和 `11111111 >> 1`(即把 `11111111` 向右移动 1 位) 的结果。蓝色的部分是被移位的，灰色的部分是被抛弃的，橙色的部分则是被填充进来的。
 
 ![Art/bitshiftUnsigned_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftUnsigned_2x.png "Art/bitshiftUnsigned_2x.png")
 
-```swift
+下面的代码演示了 Swift 中的移位操作：
+
+```
 let shiftBits: UInt8 = 4   // 即二进制的00000100
 shiftBits << 1             // 00001000
 shiftBits << 2             // 00010000
@@ -111,62 +117,62 @@ shiftBits << 6             // 00000000
 shiftBits >> 2             // 00000001
 ```
 
-你可以使用移位操作进行其他数据类型的编码和解码。
+可以使用移位操作对其他的数据类型进行编码和解码：
 
-```swift
+```
 let pink: UInt32 = 0xCC6699
 let redComponent = (pink & 0xFF0000) >> 16    // redComponent 是 0xCC, 即 204
 let greenComponent = (pink & 0x00FF00) >> 8   // greenComponent 是 0x66, 即 102
 let blueComponent = pink & 0x0000FF           // blueComponent 是 0x99, 即 153
 ```
 
-这个例子使用了一个`UInt32`的命名为`pink`的常量来存储层叠样式表`CSS`中粉色的颜色值，`CSS`颜色`#CC6699`在Swift用十六进制`0xCC6699`来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(CC)，绿(66)，蓝(99)三个部分。
+这个示例使用了一个命名为 `pink` 的 `UInt32` 型常量来存储层叠样式表(`CSS`)中粉色的颜色值。该 `CSS` 的十六进制颜色值 `#CC6699`， 在 Swift 中表示为 `0xCC6699`。然后利用按位与运算符(`&`)和按位右移运算符(`>>`)从这个颜色值中分解出红(`CC`)、绿(`66`)以及蓝(`99`)三个部分。
 
-对`0xCC6699`和`0xFF0000`进行按位与`&`操作就可以得到红色部分。`0xFF0000`中的`0`了遮盖了`OxCC6699`的第二和第三个字节，这样`6699`被忽略了，只留下`0xCC0000`。
+红色部分是通过对 `0xCC6699` 和 `0xFF0000` 进行按位与运算后得到的。`0xFF0000` 中的 `0` 部分作为*掩码*，掩盖了 `OxCC6699` 中的第二和第三个字节，使得数值中的 `6699` 被忽略，只留下 `0xCC0000`。
 
-然后，按向右移动16位，即 `>> 16`。十六进制中每两个字符是8比特位，所以移动16位的结果是把`0xCC0000`变成`0x0000CC`。这和`0xCC`是相等的，就是十进制的`204`。
+然后，再将这个数按向右移动 16 位(`>> 16`)。十六进制中每两个字符表示 8 个比特位，所以移动 16 位后 `0xCC0000` 就变为 `0x0000CC`。这个数和`0xCC`是等同的，也就是十进制数值的 `204`。
 
-同样的，绿色部分来自于`0xCC6699`和`0x00FF00`的按位操作得到`0x006600`。然后向右移动8位，得到`0x66`，即十进制的`102`。
+同样的，绿色部分通过对 `0xCC6699` 和 `0x00FF00` 进行按位与运算得到 `0x006600`。然后将这个数向右移动 8 位，得到 `0x66`，也就是十进制数值的 `102`。
 
-最后，蓝色部分对`0xCC6699`和`0x0000FF`进行按位与运算，得到`0x000099`，无需向右移位了，所以结果就是`0x99`，即十进制的`153`。
+最后，蓝色部分通过对 `0xCC6699` 和 `0x0000FF` 进行按位与运算得到 `0x000099`。并且不需要进行向右移位，所以结果为 `0x99` ，也就是十进制数值的 `153`。
 
-#### 有符整型的移位操作
+#### 有符号整型的移位操作
 
-有符整型的移位操作相对复杂得多，因为正负号也是用二进制位表示的。(这里举的例子虽然都是8位的，但它的原理是通用的。)
+对比无符号整型来说，有符整型的移位操作相对复杂得多，这种复杂性源于有符号整数的二进制表现形式。(为了简单起见，以下的示例都是基于 8 位有符号整数的，但是其中的原理对任何位数的有符号整数都是通用的。)
 
-有符整型通过第1个比特位(称为符号位)来表达这个整数是正数还是负数。`0`代表正数，`1`代表负数。
+有符号整数使用第 1 个比特位(通常被称为符号位)来表示这个数的正负。符号位为 `0` 代表正数，为 `1` 代表负数。
 
-其余的比特位(称为数值位)存储其实值。有符正整数和无符正整数在计算机里的存储结果是一样的，下来我们来看`+4`内部的二进制结构。
+其余的比特位(通常被称为数值位)存储了这个数的真实值。有符号正整数和无符号数的存储方式是一样的，都是从 `0`  开始算起。这是值为 `4` 的 `Int8` 型整数的二进制位表现形式：
 
 ![Art/bitshiftSignedFour_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedFour_2x.png "Art/bitshiftSignedFour_2x.png")
 
-符号位为`0`，代表正数，另外7比特位二进制表示的实际值就刚好是`4`。
+符号位为 `0`，说明这是一个正数，另外 7 位则代表了十进制数值 `4` 的二进制表示。
 
-负数呢，跟正数不同。负数存储的是2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128。
+负数的存储方式略有不同。它存储的是 `2` 的 n 次方减去它的真实值绝对值，这里的 n 为数值位的位数。一个 8 位的数有 7 个数值位，所以是 2 的 7 次方，即 128。
 
-我们来看`-4`存储的二进制结构。
+这是值为 `-4` 的 `Int8` 型整数的二进制位表现形式：
 
 ![Art/bitshiftSignedMinusFour_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedMinusFour_2x.png "Art/bitshiftSignedMinusFour_2x.png")
 
-现在符号位为`1`，代表负数，7个数值位要表达的二进制值是124，即128 - 4。
+这次的符号位为 `1`，说明这是一个负数，另外 7 个位则代表了数值 `124`(即 `128 - 4`) 的二进制表示。
 
 ![Art/bitshiftSignedMinusFourValue_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedMinusFourValue_2x.png "Art/bitshiftSignedMinusFourValue_2x.png")
 
-负数的编码方式称为二进制补码表示。这种表示方式看起来很奇怪，但它有几个优点。
+负数的表示通常被称为二进制补码(`two's complement`)表示法。用这种方法来表示负数乍看起来有点奇怪，但它有几个优点。
 
-首先，只需要对全部8个比特位(包括符号)做标准的二进制加法就可以完成 `-1 + -4` 的操作，忽略加法过程产生的超过8个比特位表达的任何信息。
+首先，如果想对 `-1` 和 `-4` 进行加法操作，我们只需要将这两个数的全部 8 个比特位进行相加，并且将计算结果中超出 8 位的数值丢弃：
 
 ![Art/bitshiftSignedAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSignedAddition_2x.png "Art/bitshiftSignedAddition_2x.png")
 
-第二，由于使用二进制补码表示，我们可以和正数一样对负数进行按位左移右移的，同样也是左移1位时乘于`2`，右移1位时除于`2`。要达到此目的，对有符整型的右移有一个特别的要求：
+其次，使用二进制补码可以使负数的按位左移和右移操作得到跟正数同样的效果，即每向左移一位就将自身的数值乘以 2，每向右一位就将自身的数值除以 2。要达到此目的，对有符号整数的右移有一个额外的规则：
 
-对有符整型按位右移时，不使用0填充空白位，而是根据符号位(正数为`0`，负数为`1`)填充空白位。
+* 当对正整数进行按位右移操作时，遵循与无符号整数相同的规则，但是对于移位产生的空白位使用*符号位*进行填充，而不是用 0。
 
 ![Art/bitshiftSigned_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/bitshiftSigned_2x.png "Art/bitshiftSigned_2x.png")
 
-这就确保了在右移的过程中，有符整型的符号不会发生变化。这称为算术移位。
+这个行为可以确保有符号整数的符号位不会因为右移操作而改变，这通常被称为算术移位(`arithmetic shift`)。
 
-正因为正数和负数特殊的存储方式，向右移位使它接近于`0`。移位过程中保持符号会不变，负数在接近`0`的过程中一直是负数。
+由于正数和负数的特殊存储方式，在对它们进行右移的时候，会使它们越来越接近 0。在移位的过程中保持符号位不变，意味着负整数在接近 `0` 的过程中会一直保持为负。
 
 <a name="overflow_operators"></a>
 ## 溢出运算符

From 479e3a39174309a9a990c7c83ab32bfc591a0569 Mon Sep 17 00:00:00 2001
From: justaway <bug_free@163.com>
Date: Fri, 3 Jul 2015 16:28:19 +0800
Subject: [PATCH 055/228] =?UTF-8?q?'25=5FAdvanced=5FOperators'=E7=BF=BB?=
 =?UTF-8?q?=E8=AF=91=E5=88=B0=E4=BC=98=E5=85=88=E7=BA=A7=E5=92=8C=E7=BB=93?=
 =?UTF-8?q?=E5=90=88=E6=80=A7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/25_Advanced_Operators.md | 106 ++++++++++-------------
 1 file changed, 45 insertions(+), 61 deletions(-)

diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index 4dd48634..b641866b 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -177,95 +177,79 @@ let blueComponent = pink & 0x0000FF           // blueComponent 是 0x99, 即 153
 <a name="overflow_operators"></a>
 ## 溢出运算符
 
-默认情况下，当你往一个整型常量或变量赋于一个它不能承载的大数时，Swift不会让你这么干的，它会报错。这样，在操作过大或过小的数的时候就很安全了。
+在默认情况下，当向一个整数赋超过它容量的值时，Swift 默认会报错，而不是生成一个无效的数。这个行为给我们操作过大或着过小的数的时候提供了额外的安全性。
 
-例如，`Int16`整型能承载的整数范围是`-32768`到`32767`，如果给它赋上超过这个范围的数，就会报错：
+例如，`Int16` 型整数能容纳的有符号整数范围是 `-32768` 到 `32767`，当为一个 `Int16` 型变量赋的值超过这个范围时，系统就会报错：
 
-```swift
+```
 var potentialOverflow = Int16.max
-// potentialOverflow 等于 32767, 这是 Int16 能承载的最大整数
+// potentialOverflow 的值是 32767, 这是 Int16 能容纳的最大整数
+
 potentialOverflow += 1
-// 噢, 出错了
+// 这里会报错
 ```
 
-对过大或过小的数值进行错误处理让你的数值边界条件更灵活。
+为过大或者过小的数值提供错误处理，能让我们在处理边界值时更加灵活。
 
-当然，你有意在溢出时对有效位进行截断，你可采用溢出运算，而非错误处理。Swfit为整型计算提供了5个`&`符号开头的溢出运算符。
+然而，也可以选择让系统在数值溢出的时候采取截断操作，而非报错。可以使用 Swift 提供的三个溢出操作符(`overflow operators`)来让系统支持整数溢出运算。这些操作符都是以 `&` 开头的：
 
-- 溢出加法 `&+`
-- 溢出减法 `&-`
-- 溢出乘法 `&*`
-- 溢出除法 `&/`
-- 溢出求余 `&%`
+* 溢出加法 `&+`
+* 溢出减法 `&-`
+* 溢出乘法 `&*`
 
-### 值的上溢出
+### 数值溢出
 
-下面例子使用了溢出加法`&+`来解剖的无符整数的上溢出
+数值有可能出现上溢或者下溢。
 
-```swift
-var willOverflow = UInt8.max
-// willOverflow 等于UInt8的最大整数 255
-willOverflow = willOverflow &+ 1
-// 此时 willOverflow 等于 0
+这个示例演示了当我们对一个无符号整数使用溢出加法(`&+`)进行上溢运算时会发生什么：
+```
+var unsignedOverflow = UInt8.max
+// unsignedOverflow 等于 UInt8 所能容纳的最大整数 255
+
+unsignedOverflow = unsignedOverflow &+ 1
+// 此时 unsignedOverflow 等于 0
 ```
 
-`willOverflow`用`Int8`所能承载的最大值`255`(二进制`11111111`)，然后用`&+`加1。然后`UInt8`就无法表达这个新值的二进制了，也就导致了这个新值上溢出了，大家可以看下图。溢出后，新值在`UInt8`的承载范围内的那部分是`00000000`，也就是`0`。
+`unsignedOverflow` 被初始化为 `UInt8` 所能容纳的最大整数(`255`，以二进制表示即 `11111111`)。然后使用了溢出加法运算符(`&+`)对其进行加 1 操作。这使得它的二进制表示正好超出 `UInt8` 所能容纳的位数，也就导致了数值的溢出，如下图所示。数值溢出后，留在 `UInt8` 边界内的值是 `00000000`，也就是十进制数值的 0。
 
 ![Art/overflowAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowAddition_2x.png "Art/overflowAddition_2x.png")
 
-### 值的下溢出
+同样地，当我们对一个无符号整数使用溢出减法(`&-`)进行下溢运算时也会产生类似的现象：
 
-数值也有可能因为太小而越界。举个例子：
+```
+var unsignedOverflow = UInt8.min
+// unsignedOverflow 等于 UInt8 所能容纳的最小整数 0
 
-`UInt8`的最小值是`0`(二进制为`00000000`)。使用`&-`进行溢出减1，就会得到二进制的`11111111`即十进制的`255`。
-
-![Art/overflowUnsignedSubtraction_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowUnsignedSubtraction_2x.png "Art/overflowUnsignedSubtraction_2x.png")
-
-Swift代码是这样的:
-
-```swift
-var willUnderflow = UInt8.min
-// willUnderflow 等于UInt8的最小值0
-willUnderflow = willUnderflow &- 1
-// 此时 willUnderflow 等于 255
+unsignedOverflow = unsignedOverflow &- 1
+// 此时 unsignedOverflow 等于 255
 ```
 
-有符整型也有类似的下溢出，有符整型所有的减法也都是对包括在符号位在内的二进制数进行二进制减法的，这在 "按位左移/右移运算符" 一节提到过。最小的有符整数是`-128`，即二进制的`10000000`。用溢出减法减去去1后，变成了`01111111`，即UInt8所能承载的最大整数`127`。
+`UInt8` 型整数能容纳的最小值是 0，以二进制表示即 `00000000`。当使用溢出减法运算符对其进行减 1 操作时，数值会产生下溢并被截断为 `11111111`， 也就是十进制数值的 255。
+
+![Art/overflowUnsignedSubtraction_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowUnsignedSubtraction_2x.png "Art/overflowAddition_2x.png")
+
+溢出也会发生在有符号整型数值上。在对有符号整型数值进行溢出加法或溢出减法运算时，符号位也需要参与计算，正如[按位左移/右移运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-ID34)所描述的。
+
+```
+var signedOverflow = Int8.min
+// signedOverflow 等于 Int8 所能容纳的最小整数 -128
+
+signedOverflow = signedOverflow &- 1
+// 此时 signedOverflow 等于 127
+```
+
+`Int8` 型整数能容纳的最小值是 -128，以二进制表示即 `10000000`。当使用溢出减法操作符对其进行减 1 操作时，符号位被翻转，得到二进制数值 `01111111`，也就是十进制数值的 `127`，这个值也是 `Int8` 型整数所能容纳的最大值。
 
 ![Art/overflowSignedSubtraction_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/overflowSignedSubtraction_2x.png "Art/overflowSignedSubtraction_2x.png")
 
-来看看Swift代码：
-
-```swift
-var signedUnderflow = Int8.min
-// signedUnderflow 等于最小的有符整数 -128
-signedUnderflow = signedUnderflow &- 1
-// 此时 signedUnderflow 等于 127
-```
-
-### 除零溢出
-
-一个数除以0 `i / 0`，或者对0求余数 `i % 0`，就会产生一个错误。
-
-```swift
-let x = 1
-let y = x / 0
-```
-
-使用它们对应的可溢出的版本的运算符`&/`和`&%`进行除0操作时就会得到`0`值。
-
-```swift
-let x = 1
-let y = x &/ 0
-// y 等于 0
-```
+对于无符号与有符号整型数值来说，当出现上溢时，它们会从数值所能容纳的最大数变成最小的数。同样地，当发生下溢时，它们会从所能容纳的最小数变成最大的数。
 
 <a name="precedence_and_associativity"></a>
 ## 优先级和结合性
 
-运算符的优先级使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。
+运算符的优先级(`precedence`)使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。
 
-结合性定义相同优先级的运算符在一起时是怎么组合或关联的，是和左边的一组呢，还是和右边的一组。意思就是，到底是和左边的表达式结合呢，还是和右边的表达式结合？
+结合性(`associativity`)定义相同优先级的运算符在一起时是怎么组合或关联的，是和左边的一组呢，还是和右边的一组。意思就是，到底是和左边的表达式结合呢，还是和右边的表达式结合？
 
 在混合表达式中，运算符的优先级和结合性是非常重要的。举个例子，为什么下列表达式的结果为`4`？
 

From d41d1c550bb1b7954e3154878a4b87203e475ef1 Mon Sep 17 00:00:00 2001
From: littledogboy <littledogboy@126.com>
Date: Fri, 3 Jul 2015 23:08:18 +0800
Subject: [PATCH 056/228] =?UTF-8?q?statement=E7=BF=BB=E8=AF=91=E5=AE=8C?=
 =?UTF-8?q?=E6=AF=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

statement翻译完毕，一代目翻译
---
 source/chapter3/10_Statements.md | 217 ++++++++++++++++++++++++++-----
 1 file changed, 183 insertions(+), 34 deletions(-)

diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index c9bf88f9..7a98a9b1 100755
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -1,5 +1,5 @@
-> 翻译：[coverxit](https://github.com/coverxit)  
-> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai)
+> 翻译：[coverxit](https://github.com/coverxit),[littledogboy](https://github.com/littledogboy)  
+> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),[littledogboy](https://github.com/littledogboy)
 
 # 语句
 -----------------
@@ -11,7 +11,7 @@
 - [带标签的语句](#labeled_statement)
 - [控制传递语句](#control_transfer_statements)
 
-在 Swift 中，有两种类型的语句：简单语句和控制流语句。简单语句是最常见的，用于构造表达式和声明。控制流语句则用于控制程序执行的流程，Swift 中有三种类型的控制流语句：循环语句、分支语句和控制传递语句。
+在 Swift 中，有两种类型的语句：简单语句和控制流语句。简单语句是最常见的，用于构造表达式或者声明。控制流语句则用于控制程序执行的流程，Swift 中有三种类型的控制流语句：循环语句、分支语句和控制传递语句。
 
 循环语句用于重复执行代码块；分支语句用于执行满足特定条件的代码块；控制传递语句则用于修改代码的执行顺序。在稍后的叙述中，将会详细地介绍每一种类型的控制流语句。
 
@@ -23,7 +23,8 @@
 > *语句* → [*循环语句*](..\chapter3\10_Statements.html#loop_statement) **;** _可选_  
 > *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_  
 > *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)  
-> *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_  
+> *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_  
+> *语句* → [*XXX语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_     
 > *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_  
 
 <a name="loop_statements"></a>
@@ -41,7 +42,7 @@
 
 ### For 语句
 
-`for`语句允许在重复执行代码块的同时，递增一个计数器。
+`for`语句只有在循环条件为真时重复执行代码块，此时计数器递增。
 
 `for`语句的形式如下：
 
@@ -53,12 +54,12 @@
 
 `for`语句的执行流程如下：
 
-1. *initialzation* 只会被执行一次，通常用于声明和初始化在接下来的循环中需要使用的变量。
-2. 计算 *condition* 表达式：
-	如果为`true`，*statements* 将会被执行，然后转到第3步。如果为`false`，*statements* 和 *increment* 都不会被执行，`for`至此执行完毕。
+1. *initialzation* *循环变量* 只会被执行一次，通常用于声明和初始化在接下来的循环中需要使用的变量。
+2. 判断 *condition* 循环条件：
+	如果为`true`，*statements* *循环体* 将会被执行，然后转到第3步。如果为`false`，*statements* 和 *increment* *循环增量* 都不会被执行，`for`至此执行完毕。
 3. 计算 *increment* 表达式，然后转到第2步。
 
-定义在 *initialzation* 中的变量仅在`for`语句的作用域以内有效。*condition* 表达式的值的类型必须遵循`LogicValue`协议。
+在 *initialzation* 中定义的变量仅在`for`循环的作用域内有效。*condition* 表达式的值的类型必须遵循`BooleanType `协议。
 
 > For 循环语法  
 > *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
@@ -82,7 +83,7 @@
 
 ### While 语句
 
-`while`语句允许重复执行代码块。
+`while`语句当循环条件为真时，允许重复执行代码块。
 
 `while`语句的形式如下：
 
@@ -98,34 +99,37 @@
 
 由于 *condition* 的值在 *statements* 执行前就已计算出，因此`while`语句中的 *statements* 可能会被执行若干次，也可能不会被执行。
 
-*condition* 表达式的值的类型必须遵循`LogicValue`协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
+*condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
 
 > While 循环语法  
 > *while语句* → **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *while条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)  
+> *while条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)   
+> *表达式* → [*表达式*](..\chapter3\04_Expressions.html#expression)   
+> *表达式* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [条件列表](TODO)    
+> *表达式* →
 
-### Do-While 语句
+### Repeat-While 语句
 
-`do-while`语句允许代码块被执行一次或多次。
+`repeat-while`语句允许代码块被执行一次或多次。
 
-`do-while`语句的形式如下：
+`repeat-while`语句的形式如下：
 
-> do {  
+> repeat {  
 > 	`statements`  
 > } while `condition`  
 
-`do-while`语句的执行流程如下：
+`repeat-while`语句的执行流程如下：
 
 1. 执行 *statements*，然后转到第2步。
 2. 计算 *condition* 表达式：
-	如果为`true`，转到第1步。如果为`false`，`do-while`至此执行完毕。
+	如果为`true`，转到第1步。如果为`false`，`repeat-while`至此执行完毕。
 
-由于 *condition* 表达式的值是在 *statements* 执行后才计算出，因此`do-while`语句中的 *statements* 至少会被执行一次。
+由于 *condition* 表达式的值是在 *statements* 执行后才计算出，因此`repeat-while`语句中的 *statements* 至少会被执行一次。
 
-*condition* 表达式的值的类型必须遵循`LogicValue`协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
+*condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
 
-> Do-While 循环语法  
-> *do-while语句* → **do** [*代码块*](..\chapter3\05_Declarations.html#code_block) **while** [*while条件*](..\chapter3\10_Statements.html#while_condition)  
+> Repeat-While 循环语法  
+> * repeat-while语句* → **repeat** [*代码块*](..\chapter3\05_Declarations.html#code_block) **while** [*while条件*](..\chapter3\10_Statements.html#while_condition)  
 
 <a name="branch_statements"></a>
 ## 分支语句
@@ -152,10 +156,10 @@
 
 第二种形式是在第一种形式的基础上添加 *else 语句*，当只有一个 else 语句时，像下面这样：
 
-> if `condition` {
-> 	`statements to execute if condition is true`
-> } else {
-> 	`statements to execute if condition is false`
+> if `condition` {    
+> 	`statements to execute if condition is true`    
+> } else {           
+> 	`statements to execute if condition is false`    
 > }
 
 同时，else 语句也可包含`if`语句，从而形成一条链来测试更多的条件，像下面这样：
@@ -174,7 +178,28 @@
 > If语句语法  
 > *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else子句(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_  
 > *if条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)  
-> *else子句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)  
+> *else子句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)     
+
+### Guard 语句    
+    
+`guard` 语句用来转移程序控制出该作用域，假如一个或者多个多个条件不成立。
+ `guard` 语句的格式如下：    
+ > guard `condition` else {    
+   `statements`    
+ >}    
+ 
+ `guard`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
+ 
+ 在`guard`语句中声明的常量或者变量，可使用范围为从声明开始到作用域结束,常量和变量的值从可选绑定声明中分配。
+ 
+ `guard`语句需要有`else`子句，并且必须调用被`noreturn`属性标记的函数,或者使用下面的语句把程序执行转移到guard语句的作用域外。    
+ 
+ *  `return`
+ *  `break`
+ *  `continue`
+ *  `throw`    
+ 
+执行转移语句详情参见[执行转移语句](TODO)
 
 ### Switch 语句
 
@@ -226,11 +251,13 @@ case let (x, y) where x == y:
 > *case标签* → **case** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) **:**  
 > *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](..\chapter3\10_Statements.html#case_item_list)  
 > *default标签* → **default** **:**  
-> *guard-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression)  
-> *guard-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *where-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression)  
+> *where-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
 <a name="labeled_statement"></a>
-<a name="control_transfer_statements"></a> 带标签的语句
+<a name="control_transfer_statements"></a>
+
+## 带标签的语句
 
 你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
 
@@ -242,7 +269,8 @@ case let (x, y) where x == y:
 > *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*switch语句*](..\chapter3\10_Statements.html#switch_statement)  
 > *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:**  
 > *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-
+
+<a name="control_transfer_statement"></a>
 ## 控制传递语句
 
 通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。
@@ -251,7 +279,8 @@ case let (x, y) where x == y:
 > *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement)  
 > *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement)  
 > *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement)  
-> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement)  
+> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement)     
+> *控制传递语句* → [*throw语句*](..\chapter3\10_Statements.html#throw_statement)  
 
 <a name="break_statement"></a>
 ### Break 语句
@@ -303,8 +332,9 @@ case let (x, y) where x == y:
 关于在`switch`语句中使用`fallthrough`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[控制传递语句](../chapter2/05_Control_Flow.html#control_transfer_statements)。
 
 > Fallthrough 语句语法  
-> *fallthrough语句* → **fallthrough**  
+> *fallthrough语句* → **fallthrough**  
 
+<a name="return_statement"></a>
 ### Return 语句
 
 `return`语句用于在函数或方法的实现中将控制权传递给调用者，接着程序将会从调用者的位置继续向下执行。
@@ -319,4 +349,123 @@ case let (x, y) where x == y:
 而当只写`return`时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为`Void`或`()`）
 
 > Return 语句语法  
-> *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_  
+> *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_     
+
+<a name="availability_statement"></a>
+### Availability 语句    
+
+可用性条件，被当做`if` ，`while` 语句的条件，并且 `guard` 语句在运行时会基于特定的语法格式查询接口的可用性。    
+
+avaliability 语句的形式如下：
+> if #available(`platform name version`,` ...`, *) {    
+>   `statements to execute if the APIs are available`    
+> } else {    
+>  `fallback statements to execute if the APIs are unavailable`   
+> }    
+
+可用性条件执行一个代码块时，取决于在运行时你想要使用的接口是否可用。
+当编译器检查到代码块中的接口是可用的，则从可用性条件中获取相应信息。    
+
+可用性条件使用逗号分隔平台名称和版本列表。使用`iOS`，`OSX`，以及`watchOS`为平台名称，包括相应的版本号。*参数是必需的。在任何平台上代码块主体都被可用性条件保护起来，由目标规定的最小部署目标执行。        
+   
+与布尔类型条件不同，不能用逻辑运算符 **&&** 和 **||** 合并可用性条件。 
+
+> 可用性条件语法    
+> *可用性条件* → **#available** ( [availability-arguments­](TODO) )    
+> *可用性条件* → [availability-argument­](TODO) |  [availability-argument](TODO)­ ,­ [availability-arguments­](TODO)    
+> *可用性条件* → [平台名称](TODO)  [版本号](TODO)    
+> *可用性条件* →   **\***    
+> *平台名称* →  **iOS** |  **iOSApplicationExtension**  
+> *平台名称* → **OSX**  |  **OSXApplicationExtension­**   
+> *平台名称* → **watchOS**     
+> *版本号* → [十进制数字](TODO)     
+> *版本号* → [十进制数字](TODO)  **.** [十进制数字](TODO)  
+> *版本号* → [十进制数字](TODO)  **.** [十进制数字](TODO) **.** [十进制数字](TODO)
+    
+
+<a name="throw_statement"></a>
+### Throw 语句    
+`throw`语句出现在抛出函数或者抛出方法体内，或者类型被`throws`关键字标记的表达式体内。   
+ 
+`throw`语句使程序结束执行当前的作用域，并在封闭作用域中传播错误。抛出的错误会一直传播，直到被`do`语句的`catch`子句处理掉。    
+
+`throw`语句由`throw`关键字 跟一个表达式组成 ，如下所示。    
+
+> throw `expression`    
+
+表达式值的类型必须遵循 `LogicValue`协议     
+
+关于如何使用`throw`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。    
+
+> throw 语句语法    
+> *抛出语句* → **throw**  *[表达式­](TODO)*    
+
+<a name="defer_statement"></a>
+### Defer 语句
+
+ `defer` 语句用于转移程序控制出延迟语句作用域之前执行代码。    
+ 
+在 `defer` 语句中的语句无论程序控制如何转移都会执行。这意味着 `defer` 语句可以被使用在以下这些情况，像手动得执行资源管理，关闭文件描述，或者即使抛出了错误也需要去实现执行一些动作。    
+
+如果多个 `defer` 语句出现在同一范围内，那么它们执行的顺序与它们出现的顺序相反。最后执行的 `defer` 语句为给定范围内的第一个，这意味着最后的延迟语句中的语句涉及的资源可以被其他 `defer`语句清理掉。    
+
+> 1  func f( ) {    
+> 2  defer { print("First") }    
+> 3  defer { print("Second") }    
+> 4  defer { print("Third") }    
+> 5  }    
+> 6  f()    
+> 7  // prints "Third"    
+> 8  // prints "Second"    
+> 9  // prints "First"    
+
+
+`defer` 语句中的语句无法转移程序控制权出延迟语句。    
+
+> defer 语句语法        
+> *延迟语句*  → **defer** *[代码块](TODO)*    
+
+
+<a name="do_statement"></a>
+### Do 语句    
+
+`do` 语句用于引入一个新的作用域,该作用域中可以含有一个或多个`catch`子句,catch子句中定义了一些匹配错误情况的模式。`do` 语句作用域内定义的常量和变量，只能在do语句作用域内访问。    
+
+> do {    
+>    try `expression`    
+>    `statements`    
+> } catch `pattern 1` {    
+    `statements`    
+> } catch `pattern 2` where condition {    
+    `statements`    
+> }    
+
+
+如同`switch`语句,编译器会判断`catch`子句是否被遗漏。如果这样的决定被执行，则视为错误被处理。否则，错误会自动传播出包含作用域,被一个封闭的`catch`语句或抛出函数处理，包含函数必须以`throws`关键字声明。    
+
+为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，catch子句会匹配和结合任何错误本地命名常量错误。有关可在catch子句中使用了图纹的更多信息，请参阅模式。    
+
+为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，`catch`子句会匹配和约束任何局部变量命名的`error`。有关在`catch`子句中使用模式的更多信息，详见[模式](TODO)。    
+
+关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。       
+
+> do 语句语法  → **do** *[代码块](TODO) [catch子句](TODO)*    
+> catch子句  → *[catch子句](TODO) [catch子句](TODO)*    
+> catch子句  → **catch** **[模式](TODO)** *可选的* [where子句]() *可选的* [代码块](TODO)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+

From 4c3a75e7907fff00972feb106509e209e08fcc3d Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 19:02:28 +0800
Subject: [PATCH 057/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E7=A4=BA=E4=BE=8B?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81=20println()=20->=20print()?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 52 ++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index d17abb5d..dad93021 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -1,4 +1,4 @@
-> 翻译：[geek5nan](https://github.com/geek5nan)  
+> 翻译：[geek5nan](https://github.com/geek5nan)
 > 校对：[dabing1022](https://github.com/dabing1022)
 
 # 协议
@@ -164,9 +164,9 @@ class LinearCongruentialGenerator: RandomNumberGenerator {
 	}
 }
 let generator = LinearCongruentialGenerator()
-println("Here's a random number: \(generator.random())")
+print("Here's a random number: \(generator.random())")
 // 输出 : "Here's a random number: 0.37464991998171"
-println("And another one: \(generator.random())")
+print("And another one: \(generator.random())")
 // 输出 : "And another one: 0.729023776863283"
 ```
 
@@ -178,7 +178,7 @@ println("And another one: \(generator.random())")
 如果协议中的实例方法打算改变其`遵循者`实例的类型，那么在协议定义时需要在方法前加`mutating`关键字，才能使`结构体，枚举`来采用并满足协议中对方法的规定。
 
 
->注意: 
+>注意:
 >用`类`实现协议中的`mutating`方法时，不用写`mutating`关键字;用`结构体`，`枚举`实现协议中的`mutating`方法时，必须写`mutating`关键字。
 
 如下所示，`Togglable`协议含有名为`toggle`的突变实例方法。根据名称推测，`toggle`方法应该是用于切换或恢复其`遵循者`实例或其属性的类型。
@@ -255,7 +255,7 @@ class SomeSuperClass {
     }
 }
 
- 
+
 class SomeSubClass: SomeSuperClass, SomeProtocol {
     // "required" from SomeProtocol conformance; "override" from SomeSuperClass
     required override init() {
@@ -277,7 +277,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 
 尽管`协议`本身并不实现任何功能，但是`协议`可以被当做类型来使用。
 
-使用场景:  
+使用场景:
 
 * `协议类型`作为函数、方法或构造器中的参数类型或返回值类型
 * `协议类型`作为常量、变量或属性的类型
@@ -314,7 +314,7 @@ class Dice {
 ```swift
 var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
 for _ in 1...5 {
-	println("Random dice roll is \(d6.roll())")
+	print("Random dice roll is \(d6.roll())")
 }
 //输出结果
 //Random dice roll is 3
@@ -333,7 +333,7 @@ for _ in 1...5 {
 
 委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的所属类型(*译者注:只要求外部数据源`遵循`某协议*)。
 
-下文是两个基于骰子游戏的协议: 
+下文是两个基于骰子游戏的协议:
 
 ```swift
 protocol DiceGame {
@@ -349,7 +349,7 @@ protocol DiceGameDelegate {
 ```
 
 `DiceGame`协议可以在任意含有骰子的游戏中实现，`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
-	
+
 如下所示，`SnakesAndLadders`是`Snakes and Ladders`(译者注:[Control Flow](2)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程:
 
 ```swift
@@ -403,16 +403,16 @@ class DiceGameTracker: DiceGameDelegate {
     func gameDidStart(game: DiceGame) {
         numberOfTurns = 0
         if game is SnakesAndLadders {
-            println("Started a new game of Snakes and Ladders")
+            print("Started a new game of Snakes and Ladders")
         }
-        println("The game is using a \(game.dice.sides)-sided dice")
+        print("The game is using a \(game.dice.sides)-sided dice")
     }
     func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {
         ++numberOfTurns
-        println("Rolled a \(diceRoll)")
+        print("Rolled a \(diceRoll)")
     }
     func gameDidEnd(game: DiceGame) {
-        println("The game lasted for \(numberOfTurns) turns")
+        print("The game lasted for \(numberOfTurns) turns")
     }
 }
 ```
@@ -468,7 +468,7 @@ extension Dice: TextRepresentable {
 
 ```swift
 let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
-println(d12.asText())
+print(d12.asText())
 // 输出 "A 12-sided dice"
 ```
 
@@ -480,7 +480,7 @@ extension SnakesAndLadders: TextRepresentable {
 		return "A game of Snakes and Ladders with \(finalSquare) squares"
 	}
 }
-println(game.asText())
+print(game.asText())
 // 输出 "A game of Snakes and Ladders with 25 squares"
 ```
 
@@ -504,7 +504,7 @@ extension Hamster: TextRepresentable {}
 ```swift
 let simonTheHamster = Hamster(name: "Simon")
 let somethingTextRepresentable: TextRepresentable = simonTheHamster
-println(somethingTextRepresentable.asText())
+print(somethingTextRepresentable.asText())
 // 输出 "A hamster named Simon"
 ```
 
@@ -523,7 +523,7 @@ let things: [TextRepresentable] = [game,d12,simonTheHamster]
 
 ```swift
 for thing in things {
-	println(thing.asText())
+	print(thing.asText())
 }
 // A game of Snakes and Ladders with 25 squares
 // A 12-sided dice
@@ -583,7 +583,7 @@ extension SnakesAndLadders: PrettyTextRepresentable {
 任意`SankesAndLadders`的实例都可以使用`asPrettyText()`方法。
 
 ```swift
-println(game.asPrettyText())
+print(game.asPrettyText())
 // A game of Snakes and Ladders with 25 squares:
 // ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
 ```
@@ -624,7 +624,7 @@ struct Person: Named, Aged {
     var age: Int
 }
 func wishHappyBirthday(celebrator: protocol<Named, Aged>) {
-    println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
+    print("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
 }
 let birthdayPerson = Person(name: "Malcolm", age: 21)
 wishHappyBirthday(birthdayPerson)
@@ -642,9 +642,9 @@ wishHappyBirthday(birthdayPerson)
 
 使用`is`和`as`操作符来检查协议的一致性或转化协议类型。检查和转化的语法和之前相同(*详情查看[Typy Casting章节](5)*):
 
-* `is`操作符用来检查实例是否`遵循`了某个`协议`。 
+* `is`操作符用来检查实例是否`遵循`了某个`协议`。
 * `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil`
-* `as`用以强制向下转型。  
+* `as`用以强制向下转型。
 
 ```swift
 @objc protocol HasArea {
@@ -697,9 +697,9 @@ let objects: [AnyObject] = [
 ```swift
 for object in objects {
     if let objectWithArea = object as? HasArea {
-        println("Area is \(objectWithArea.area)")
+        print("Area is \(objectWithArea.area)")
     } else {
-        println("Something that doesn't have an area")
+        print("Something that doesn't have an area")
     }
 }
 // Area is 12.5663708
@@ -754,7 +754,7 @@ for object in objects {
 `count`属性用于存储当前的值，`increment`方法用来为`count`赋值。
 
 `increment`方法通过`可选链`，尝试从两种`可选成员`中获取`count`。
-	
+
 1. 由于`dataSource`可能为`nil`，因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用`incrementForCount`方法。
 
 2. 即使`dataSource`存在，但是也无法保证其是否实现了`incrementForCount`方法，因此在`incrementForCount`方法后边也加有`?`标记
@@ -776,7 +776,7 @@ var counter = Counter()
 counter.dataSource = ThreeSource()
 for _ in 1...4 {
     counter.increment()
-    println(counter.count)
+    print(counter.count)
 }
 // 3
 // 6
@@ -807,7 +807,7 @@ counter.count = -4
 counter.dataSource = TowardsZeroSource()
 for _ in 1...5 {
     counter.increment()
-    println(counter.count)
+    print(counter.count)
 }
 // -3
 // -2

From 148004f1624d156827b1d01b61de68142f41cc11 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 19:24:30 +0800
Subject: [PATCH 058/228] =?UTF-8?q?=E6=B7=BB=E5=8A=A02.0=E6=96=B0=E5=A2=9E?=
 =?UTF-8?q?=E9=83=A8=E5=88=86=E7=9A=84=E8=8B=B1=E6=96=87=EF=BC=8C=E5=B9=B6?=
 =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E6=B7=BB=E5=8A=A0=E9=83=A8=E5=88=86=E7=9A=84?=
 =?UTF-8?q?md=E6=A0=BC=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 76 +++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index dad93021..3e31a805 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -815,3 +815,79 @@ for _ in 1...5 {
 // 0
 // 0
 ```
+
+## Protocol Extensions
+
+Protocols can be extended to provide method and property implementations to conforming types. This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function.
+
+For example, the `RandomNumberGenerator` protocol can be extended to provide a `randomBool()` method, which uses the result of the required `random()` method to return a random `Bool` value:
+
+```swift
+extension RandomNumberGenerator {
+    func randomBool() -> Bool {
+        return random() > 0.5
+    }
+}
+```
+
+By creating an extension on the protocol, all conforming types automatically gain this method implementation without any additional modification.
+
+```swift
+let generator = LinearCongruentialGenerator()
+print("Here's a random number: \(generator.random())")
+// prints "Here's a random number: 0.37464991998171"
+print("And here's a random Boolean: \(generator.randomBool())")
+// prints "And here's a random Boolean: true"
+```
+
+### Providing Default Implementations
+
+You can use protocol extensions to provide a default implementation to any method or property requirement of that protocol. If a conforming type provides its own implementation of a required method or property, that implementation will be used instead of the one provided by the extension.
+
+> NOTE
+> Protocol requirements with default implementations provided by extensions are distinct from optional protocol requirements. Although conforming types don’t have to provide their own implementation of either, requirements with default implementations can be called without optional chaining.
+
+For example, the `PrettyTextRepresentable` protocol, which inherits the `TextRepresentable` protocol can provide a default implementation of its required `asPrettyText()` method to simply return the result of the `asText()` method:
+
+```swift
+extension PrettyTextRepresentable  {
+    func asPrettyText() -> String {
+        return asText()
+    }
+}
+```
+
+### Adding Constraints to Protocol Extensions
+
+When you define a protocol extension, you can specify constraints that conforming types must satisfy before the methods and properties of the extension are available. You write these constraints after the name of the protocol you’re extending using a `where` clause, as described in ([Where 子句](TODO)).:
+
+For instance, you can define an extension to the `CollectionType` protocol that applies to any collection whose elements conform to the `TextRepresentable protocol` from the example above.
+
+```swift
+extension CollectionType where Generator.Element : TextRepresentable {
+    func asList() -> String {
+        return "(" + ", ".join(map({$0.asText()})) + ")"
+    }
+}
+```
+
+The `asList()` method takes the textual representation of each element in the collection and concatenates them into a comma-separated list.
+
+Consider the `Hamster` structure from before, which conforms to the `TextRepresentable` protocol, and an array of `Hamster` values:
+
+```swift
+let murrayTheHamster = Hamster(name: "Murray")
+let morganTheHamster = Hamster(name: "Morgan")
+let mauriceTheHamster = Hamster(name: "Maurice")
+let hamsters = [murrayTheHamster, morganTheHamster, mauriceTheHamster]
+```
+
+Because `Array` conforms to `CollectionType`, and the array’s elements conform to the `TextRepresentable` protocol, the array can use the `asList()` method to get a textual representation of its contents:
+
+```swift
+print(hamsters.asList())
+// prints "(A hamster named Murray, A hamster named Morgan, A hamster named Maurice)"
+```
+
+> NOTE
+> If a conforming type satisfies the requirements for multiple constrained extensions that provide implementations for the same method or property, Swift will use the implementation corresponding to the most specialized constraints.

From 97aaac1c2ca019f2a704e6f7c06cc112219e5b1b Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 19:34:04 +0800
Subject: [PATCH 059/228] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=96=B0=E5=86=85?=
 =?UTF-8?q?=E5=AE=B9=E7=9A=84=E7=9B=AE=E5=BD=95=E8=B7=B3=E8=BD=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 3e31a805..6589399d 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -21,6 +21,8 @@
 - [协议合成（Protocol Composition）](#protocol_composition)
 - [检验协议的一致性（Checking for Protocol Conformance）](#checking_for_protocol_conformance)
 - [对可选协议的规定（Optional Protocol Requirements）](#optional_protocol_requirements)
+- [协议扩展（Protocol Extensions）](#protocol_extensions)
+
 
 `协议(Protocol)`用于定义完成某项任务或功能所必须的方法和属性，协议实际上并不提供这些功能或任务的具体`实现(Implementation)`--而只用来描述这些实现应该是什么样的。类，结构体，枚举通过提供协议所要求的方法，属性的具体实现来`采用(adopt)`协议。任意能够满足协议要求的类型被称为协议的`遵循者`。
 
@@ -816,7 +818,8 @@ for _ in 1...5 {
 // 0
 ```
 
-## Protocol Extensions
+<a name="protocol_extensions"></a>
+## 协议扩展
 
 Protocols can be extended to provide method and property implementations to conforming types. This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function.
 

From 145e4fadc8f9130070db76106f825f00fb718176 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 10:39:54 +0800
Subject: [PATCH 060/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E6=A6=82=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 6589399d..c8cdb814 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -24,9 +24,7 @@
 - [协议扩展（Protocol Extensions）](#protocol_extensions)
 
 
-`协议(Protocol)`用于定义完成某项任务或功能所必须的方法和属性，协议实际上并不提供这些功能或任务的具体`实现(Implementation)`--而只用来描述这些实现应该是什么样的。类，结构体，枚举通过提供协议所要求的方法，属性的具体实现来`采用(adopt)`协议。任意能够满足协议要求的类型被称为协议的`遵循者`。
-
-`协议`可以要求其`遵循者`提供特定的实例属性，实例方法，类方法，操作符或下标脚本等。
+`协议`定义了一个蓝图，规定了用来实现某一特定工作或者功能所必需的方法和属性。类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能。任意能够满足协议要求的类型被称为`遵循(conform)`这个协议。
 
 <a name="protocol_syntax"></a>
 ## 协议的语法

From 1b59383d6cafc0dd517b1edac2b0adbb32428273 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 10:47:56 +0800
Subject: [PATCH 061/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90Proto?=
 =?UTF-8?q?col=20Syntax?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index c8cdb814..e489cbe4 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -29,7 +29,7 @@
 <a name="protocol_syntax"></a>
 ## 协议的语法
 
-`协议`的定义方式与`类，结构体，枚举`的定义都非常相似，如下所示:
+协议的定义方式与类，结构体，枚举的定义非常相似:
 
 ```swift
 protocol SomeProtocol {
@@ -37,7 +37,7 @@ protocol SomeProtocol {
 }
 ```
 
-在类型名称后加上`协议名称`，中间以冒号`:`分隔即可实现协议；实现多个协议时，各协议之间用逗号`,`分隔，如下所示:
+要使类遵循某个协议，需要在类型名称后加上协议名称，中间以冒号`:`分隔，作为类型定义的一部分。遵循多个协议时，各协议之间用逗号`,`分隔:
 
 ```swift
 struct SomeStructure: FirstProtocol, AnotherProtocol {
@@ -45,7 +45,7 @@ struct SomeStructure: FirstProtocol, AnotherProtocol {
 }
 ```
 
-如果一个类在含有`父类`的同时也采用了协议，应当把`父类`放在所有的`协议`之前，如下所示:
+如果类在遵循协议的同时拥有父类，应该将父类名放在协议名之前，以逗号分隔:
 
 ```swift
 class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {

From 7e04e8d625c0c6600e85522796631c3eb768b533 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 10:49:38 +0800
Subject: [PATCH 062/228] =?UTF-8?q?=E6=9B=B4=E6=94=B9Property=20Requiremen?=
 =?UTF-8?q?ts=E7=BF=BB=E8=AF=91->=20=E5=B1=9E=E6=80=A7=E8=A6=81=E6=B1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index e489cbe4..215a500f 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -7,7 +7,7 @@
 本页包含内容：
 
 - [协议的语法（Protocol Syntax）](#protocol_syntax)
-- [对属性的规定（Property Requirements）](#property_requirements)
+- [属性要求（Property Requirements）](#property_requirements)
 - [对方法的规定（Method Requirements）](#method_requirements)
 - [对突变方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
 - [对构造器的规定（Initializer Requirements）](#initializer_requirements)
@@ -54,7 +54,7 @@ class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
 ```
 
 <a name="property_requirements"></a>
-## 对属性的规定
+## 属性要求
 
 协议可以规定其`遵循者`提供特定名称与类型的`实例属性(instance property)`或`类属性(type property)`，而不管其是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外也可以指定属性是只读的还是可读写的。
 

From 9918eaf60898e77b648ea9498f2d1e4a0e44a235 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 15:04:44 +0800
Subject: [PATCH 063/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=AF=B9=E5=B1=9E=E6=80=A7=E7=9A=84=E8=A7=84=E5=AE=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 57 +++++++++++++++++----------------
 1 file changed, 29 insertions(+), 28 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 215a500f..ae226e8c 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -7,7 +7,7 @@
 本页包含内容：
 
 - [协议的语法（Protocol Syntax）](#protocol_syntax)
-- [属性要求（Property Requirements）](#property_requirements)
+- [对属性的规定（Property Requirements）](#property_requirements)
 - [对方法的规定（Method Requirements）](#method_requirements)
 - [对突变方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
 - [对构造器的规定（Initializer Requirements）](#initializer_requirements)
@@ -29,7 +29,7 @@
 <a name="protocol_syntax"></a>
 ## 协议的语法
 
-协议的定义方式与类，结构体，枚举的定义非常相似:
+协议的定义方式与类，结构体，枚举的定义非常相似。
 
 ```swift
 protocol SomeProtocol {
@@ -37,7 +37,7 @@ protocol SomeProtocol {
 }
 ```
 
-要使类遵循某个协议，需要在类型名称后加上协议名称，中间以冒号`:`分隔，作为类型定义的一部分。遵循多个协议时，各协议之间用逗号`,`分隔:
+要使类遵循某个协议，需要在类型名称后加上协议名称，中间以冒号`:`分隔，作为类型定义的一部分。遵循多个协议时，各协议之间用逗号`,`分隔。
 
 ```swift
 struct SomeStructure: FirstProtocol, AnotherProtocol {
@@ -45,7 +45,7 @@ struct SomeStructure: FirstProtocol, AnotherProtocol {
 }
 ```
 
-如果类在遵循协议的同时拥有父类，应该将父类名放在协议名之前，以逗号分隔:
+如果类在遵循协议的同时拥有父类，应该将父类名放在协议名之前，以逗号分隔。
 
 ```swift
 class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
@@ -54,13 +54,13 @@ class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
 ```
 
 <a name="property_requirements"></a>
-## 属性要求
+## 对属性的规定
 
-协议可以规定其`遵循者`提供特定名称与类型的`实例属性(instance property)`或`类属性(type property)`，而不管其是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外也可以指定属性是只读的还是可读写的。
+协议可以规定其`遵循者`提供特定名称和类型的`实例属性(instance property)`或`类属性(type property)`，而不指定是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外还必须指明是只读的还是可读可写的。
 
-如果协议要求属性是可读写的，那么这个属性不能是常量`存储型属性`或只读`计算型属性`；如果协议要求属性是只读的(gettable)，那么`计算型属性`或`存储型属性`都能满足协议对属性的规定，在你的代码中，即使为只读属性实现了写方法(settable)也依然有效。
+如果协议要求属性是可读可写的，那么这个属性不能是常量或只读的计算属性。如果协议只要求属性是只读的(gettable)，那个属性不仅可以是只读的，如果你代码需要的话，也可以是可写的。
 
-协议中的属性经常被加以`var`前缀声明其为变量属性，在声明后加上`{ set get }`来表示属性是可读写的，只读的属性则写作`{ get }`，如下所示:
+协议中的通常用var来声明属性，在类型声明后加上`{ set get }`来表示属性是可读可写的，只读属性则用`{ get }`来表示。
 
 ```swift
 protocol SomeProtocol {
@@ -68,16 +68,17 @@ protocol SomeProtocol {
 	var doesNotNeedToBeSettable: Int { get }
 }
 ```
-
-如下所示，通常在协议的定义中使用`class`前缀表示该属性为类成员；在枚举和结构体实现协议时中，需要使用`static`关键字作为前缀。
+<!--TODO-->
+在协议中定义类属性(type property)时，使用`static`关键字作为前缀。
+通常在协议的定义中使用`class`前缀表示该属性为类成员；在枚举和结构体实现协议时中，需要使用`static`关键字作为前缀。
 
 ```swift
 protocol AnotherProtocol {
-	class var someTypeProperty: Int { get set }
+	static var someTypeProperty: Int { get set }
 }
 ```
 
-如下所示，这是一个含有一个实例属性要求的协议:
+如下所示，这是一个含有一个实例属性要求的协议。
 
 ```swift
 protocol FullyNamed {
@@ -85,9 +86,9 @@ protocol FullyNamed {
 }
 ```
 
-`FullyNamed`协议定义了任何拥有`fullName`的类型。它并不指定具体类型，而只是要求类型必须提供一个`fullName`。任何`FullyNamed`类型都得有一个只读的`fullName`属性，类型为`String`。
+`FullyNamed`协议除了要求协议的遵循者提供fullName属性外，对协议对遵循者的类型并没有特别的要求。这个协议表示，任何遵循`FullyNamed`协议的类型，都具有一个可读的`String`类型实例属性`fullName`。
 
-如下所示，这是一个实现了`FullyNamed`协议的简单结构体:
+下面是一个遵循`FullyNamed`协议的简单结构体。
 
 ```swift
 struct Person: FullyNamed{
@@ -97,29 +98,29 @@ let john = Person(fullName: "John Appleseed")
 //john.fullName 为 "John Appleseed"
 ```
 
-这个例子中定义了一个叫做`Person`的结构体，用来表示具有指定名字的人。从第一行代码中可以看出，它采用了`FullyNamed`协议。
+这个例子中定义了一个叫做`Person`的结构体，用来表示具有名字的人。从第一行代码中可以看出，它遵循了`FullyNamed`协议。
 
-`Person`结构体的每一个实例都有一个叫做`fullName`，`String`类型的存储型属性，这正好匹配了`FullyNamed`协议的要求，也就意味着，`Person`结构体完整的`遵循`了协议。(如果协议要求未被完全满足,在编译时会报错)
+`Person`结构体的每一个实例都有一个叫做`fullName`，`String`类型的存储型属性。这正好满足了`FullyNamed`协议的要求，也就意味着，`Person`结构体完整的`遵循`了协议。(如果协议要求未被完全满足,在编译时会报错)
 
-这有一个更为复杂的类，它采用并实现了`FullyNamed`协议，如下所示:
+下面是一个更为复杂的类，它采用并遵循了`FullyNamed`协议:
 
 ```swift
 class Starship: FullyNamed {
-	var prefix: String?
-	var name: String
-	init(name: String, prefix: String? = nil ) {
-		self.name = name
-		self.prefix = prefix
-	}
-	var fullName: String {
-	return (prefix != nil ? prefix! + " " : " ") + name
-	}
+    var prefix: String?
+    var name: String
+    init(name: String, prefix: String? = nil) {
+        self.name = name
+        self.prefix = prefix
+    }
+    var fullName: String {
+        return (prefix != nil ? prefix! + " " : "") + name
+    }
 }
 var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
-// ncc1701.fullName == "USS Enterprise"
+// ncc1701.fullName is "USS Enterprise"
 ```
 
-`Starship`类把`fullName`属性实现为只读的`计算型属性`。每一个`Starship`类的实例都有一个名为`name`的必备属性和一个名为`prefix`的可选属性。 当`prefix`存在时，将`prefix`插入到`name`之前来为`Starship`构建`fullName`，`prefix`不存在时，则将直接用`name`构建`fullName`
+Starship类把`fullName`属性实现为只读的计算型属性。每一个`Starship`类的实例都有一个名为`name`的属性和一个名为`prefix`的可选属性。 当`prefix`存在时，将`prefix`插入到`name`之前来为Starship构建`fullName`，`prefix`不存在时，则将直接用`name`构建`fullName`。
 
 <a name="method_requirements"></a>
 ## 对方法的规定

From 19e6b93d7897782d7d1cc418f65f64170ba07459 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 15:40:11 +0800
Subject: [PATCH 064/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=AF=B9=E6=96=B9=E6=B3=95=E7=9A=84=E8=A7=84=E5=AE=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index ae226e8c..78d6e9bf 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -9,7 +9,7 @@
 - [协议的语法（Protocol Syntax）](#protocol_syntax)
 - [对属性的规定（Property Requirements）](#property_requirements)
 - [对方法的规定（Method Requirements）](#method_requirements)
-- [对突变方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
+- [对Mutating方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
 - [对构造器的规定（Initializer Requirements）](#initializer_requirements)
 - [协议类型（Protocols as Types）](#protocols_as_types)
 - [委托(代理)模式（Delegation）](#delegation)
@@ -68,9 +68,8 @@ protocol SomeProtocol {
 	var doesNotNeedToBeSettable: Int { get }
 }
 ```
-<!--TODO-->
-在协议中定义类属性(type property)时，使用`static`关键字作为前缀。
-通常在协议的定义中使用`class`前缀表示该属性为类成员；在枚举和结构体实现协议时中，需要使用`static`关键字作为前缀。
+
+在协议中定义类属性(type property)时，总是使用`static`关键字作为前缀。当协议的遵循者是类时，可以使用`class`或`static`关键字来声明类属性，但是在协议的定义中，仍然要使用`static`关键字。
 
 ```swift
 protocol AnotherProtocol {
@@ -125,20 +124,17 @@ Starship类把`fullName`属性实现为只读的计算型属性。每一个`Star
 <a name="method_requirements"></a>
 ## 对方法的规定
 
-`协议`可以要求其`遵循者`实现某些指定的`实例方法`或`类方法`。这些方法作为协议的一部分，像普通的方法一样清晰的放在协议的定义中，而不需要大括号和方法体。
+协议可以要求其遵循者实现某些指定的实例方法或类方法。这些方法作为协议的一部分，像普通的方法一样放在协议的定义中，但是不需要大括号和方法体。可以在协议中定义具有可变参数的方法，和普通方法的定义方式相同。但是在协议的方法定义中，不支持参数默认值。
 
->注意：
->协议中的方法支持`变长参数(variadic parameter)`，不支持`参数默认值(default value)`。
-
-如下所示，协议中类方法的定义与类属性的定义相似，在协议定义的方法前置`class`关键字来表示。当在`枚举`或`结构体`实现类方法时，需要使用`static`关键字来代替。
+正如对属性的规定中所说的，在协议中定义类方法的时候，总是使用`static`关键字作为前缀。当协议的遵循者是类的时候，虽然你可以在类的实现中使用`class`或者`static`来实现类方法，但是在协议中声明类方法，仍然要使用`static`关键字。
 
 ```swift
 protocol SomeProtocol {
-	class func someTypeMethod()
+	static func someTypeMethod()
 }
 ```
 
-如下所示，定义了含有一个实例方法的的协议。
+下面的例子定义了含有一个实例方法的协议。
 
 ```swift
 protocol RandomNumberGenerator {
@@ -146,7 +142,7 @@ protocol RandomNumberGenerator {
 }
 ```
 
-`RandomNumberGenerator`协议要求其`遵循者`必须拥有一个名为`random`， 返回值类型为`Double`的实例方法。 (尽管这里并未指明，但是我们假设返回值在[0，1]区间内)。
+`RandomNumberGenerator`协议要求其遵循者必须拥有一个名为`random`， 返回值类型为`Double`的实例方法。尽管这里并未指明，但是我们假设返回值在[0，1)区间内。
 
 `RandomNumberGenerator`协议并不在意每一个随机数是怎样生成的，它只强调这里有一个随机数生成器。
 
@@ -172,7 +168,7 @@ print("And another one: \(generator.random())")
 ```
 
 <a name="mutating_method_requirements"></a>
-## 对突变方法的规定
+## 对Mutating方法的规定
 
 有时不得不在方法中更改实例的所属类型。在基于`值类型(value types)`(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改实例及其属性的所属类型。这一过程在[Modifyting Value Types from Within Instance Methods](1)章节中有详细描述。
 

From c6b818a4e11333805eb7cdd7a42c3e3bef8889ee Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 16:19:41 +0800
Subject: [PATCH 065/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9Mutating?=
 =?UTF-8?q?=E6=96=B9=E6=B3=95=E7=9A=84=E8=A7=84=E5=AE=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 78d6e9bf..24a56bfa 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -170,15 +170,17 @@ print("And another one: \(generator.random())")
 <a name="mutating_method_requirements"></a>
 ## 对Mutating方法的规定
 
-有时不得不在方法中更改实例的所属类型。在基于`值类型(value types)`(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改实例及其属性的所属类型。这一过程在[Modifyting Value Types from Within Instance Methods](1)章节中有详细描述。
+有时需要在方法中改变它的实例。例如，值类型(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改它所属的实例及其实例属性的值。这一过程在[Modifyting Value Types from Within Instance Methods](TODO)章节中有详细描述。
 
-如果协议中的实例方法打算改变其`遵循者`实例的类型，那么在协议定义时需要在方法前加`mutating`关键字，才能使`结构体，枚举`来采用并满足协议中对方法的规定。
+如果你在协议中定义了一个方法旨在改变遵循该协议的实例，那么在协议定义时需要在方法前加`mutating`关键字。这使得结构和枚举遵循协议并满足此方法要求。
 
 
 >注意:
->用`类`实现协议中的`mutating`方法时，不用写`mutating`关键字;用`结构体`，`枚举`实现协议中的`mutating`方法时，必须写`mutating`关键字。
+>用类实现协议中的`mutating`方法时，不用写`mutating`关键字;用结构体，枚举实现协议中的`mutating`方法时，必须写`mutating`关键字。
 
-如下所示，`Togglable`协议含有名为`toggle`的突变实例方法。根据名称推测，`toggle`方法应该是用于切换或恢复其`遵循者`实例或其属性的类型。
+如下所示，`Togglable`协议含有名为`toggle`的实例方法。根据名称推测，`toggle()`方法将通过改变实例属性，来切换遵循该协议的实例的状态。
+
+`toggle()`方法在定义的时候，使用`mutating`关键字标记，这表明当它被调用时该方法将会改变协议遵循者实例的状态。
 
 ```swift
 protocol Togglable {
@@ -186,9 +188,9 @@ protocol Togglable {
 }
 ```
 
-当使用`枚举`或`结构体`来实现`Togglabl`协议时，需要提供一个带有`mutating`前缀的`toggle`方法。
+当使用`枚举`或`结构体`来实现`Togglable`协议时，需要提供一个带有`mutating`前缀的`toggle`方法。
 
-如下所示，`OnOffSwitch`枚举`遵循`了`Togglable`协议，`On`，`Off`两个成员用于表示当前状态。枚举的`toggle`方法被标记为`mutating`，用以匹配`Togglabel`协议的规定。
+下面定义了一个名为`OnOffSwitch`的枚举类型。这个枚举类型在两种状态之间进行切换，用枚举成员`On`和`Off`表示。枚举类型的`toggle`方法被标记为`mutating`以满足`Togglable`协议的要求。
 
 ```swift
 enum OnOffSwitch: Togglable {
@@ -218,7 +220,7 @@ protocol SomeProtocol {
 }
 ```
 
-**协议构造器规定在类中的实现**
+### 协议构造器规定在类中的实现
 
 你可以在遵循该协议的类中实现构造器，并指定其为类的特定构造器或者便捷构造器。在这两种情况下，你都必须给构造器实现标上"required"修饰符：
 

From 59883d153ae163ce6e7f08f9dbc1960a818cf868 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 16:20:42 +0800
Subject: [PATCH 066/228] =?UTF-8?q?Protocols=20-=20=E4=BF=AE=E6=94=B9?=
 =?UTF-8?q?=E4=BA=8C=E7=BA=A7=E6=A0=87=E9=A2=98markdown=E8=AF=AD=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 24a56bfa..e4cd628a 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -263,7 +263,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 }
 ```
 
-**可失败构造器的规定**
+### 可失败构造器的规定
 
 可以通过给协议```Protocols```中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
 

From 0a097be9a2b6e2abd9a870de34019d5291e05e91 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 09:27:05 +0800
Subject: [PATCH 067/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9=E6=9E=84?=
 =?UTF-8?q?=E9=80=A0=E5=99=A8=E7=9A=84=E8=A7=84=E5=AE=9A=20=E7=BB=BC?=
 =?UTF-8?q?=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index e4cd628a..01e68099 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -212,7 +212,7 @@ lightSwitch.toggle()
 <a name="initializer_requirements"></a>
 ## 对构造器的规定
 
-协议可以要求它的遵循类型实现特定的构造器。你可以像书写普通的构造器那样，在协议的定义里写下构造器的需求，但不需要写花括号和构造器的实体：
+协议可以要求它的遵循者实现指定的构造器。你可以像书写普通的构造器那样，在协议的定义里写下构造器的声明，但不需要写花括号和构造器的实体：
 
 ```swift
 protocol SomeProtocol {

From ffe3303ba48f216c7b703bf8b5527f905350baf5 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 09:50:10 +0800
Subject: [PATCH 068/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9=E6=9E=84?=
 =?UTF-8?q?=E9=80=A0=E5=99=A8=E7=9A=84=E8=A7=84=E5=AE=9A=20=E5=8D=8F?=
 =?UTF-8?q?=E8=AE=AE=E6=9E=84=E9=80=A0=E5=99=A8=E8=A7=84=E5=AE=9A=E5=9C=A8?=
 =?UTF-8?q?=E7=B1=BB=E4=B8=AD=E7=9A=84=E5=AE=9E=E7=8E=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 01e68099..8aeb1373 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -222,7 +222,7 @@ protocol SomeProtocol {
 
 ### 协议构造器规定在类中的实现
 
-你可以在遵循该协议的类中实现构造器，并指定其为类的特定构造器或者便捷构造器。在这两种情况下，你都必须给构造器实现标上"required"修饰符：
+你可以在遵循该协议的类中实现构造器，并指定其为类的指定构造器(designated initializer)或者便利构造器(convenience initializer)。在这两种情况下，你都必须给构造器实现标上"required"修饰符：
 
 ```swift
 class SomeClass: SomeProtocol {
@@ -234,11 +234,12 @@ class SomeClass: SomeProtocol {
 
 使用`required`修饰符可以保证：所有的遵循该协议的子类，同样能为构造器规定提供一个显式的实现或继承实现。
 
-关于`required`构造器的更多内容，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_454">`required`构造器 </a>
+<!--TODO 参考链接-->
+关于`required`构造器的更多内容，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_454">`Required`构造器 </a>
 
+<!--TODO 参考链接-->
 >注意
->
->如果类已经被“final”修饰符所标示，你就不需要在协议构造器规定的实现中使用"required"修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_339">防止重写</a>
+>如果类已经被标记为`final`，那么不需要在协议构造器的实现中使用`required`修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_339">防止重写</a>
 
 如果一个子类重写了父类的指定构造器，并且该构造器遵循了某个协议的规定，那么该构造器的实现需要被同时标示`required`和`override`修饰符
 
@@ -250,13 +251,13 @@ protocol SomeProtocol {
 
 class SomeSuperClass {
     init() {
-        //协议定义
+        // 构造器的实现
     }
 }
 
 
 class SomeSubClass: SomeSuperClass, SomeProtocol {
-    // "required" from SomeProtocol conformance; "override" from SomeSuperClass
+    // 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
     required override init() {
         // 构造器实现
     }
@@ -265,7 +266,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 
 ### 可失败构造器的规定
 
-可以通过给协议```Protocols```中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
+可以通过给协议`Protocols`中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
 
 如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。
 如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。

From 68b6028ee15fc662b5a2e74f88434fb808d2728e Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 09:57:20 +0800
Subject: [PATCH 069/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9=E6=9E=84?=
 =?UTF-8?q?=E9=80=A0=E5=99=A8=E7=9A=84=E8=A7=84=E5=AE=9A=20=E5=8F=AF?=
 =?UTF-8?q?=E5=A4=B1=E8=B4=A5=E6=9E=84=E9=80=A0=E5=99=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 8aeb1373..5f3f5dc2 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -268,8 +268,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 
 可以通过给协议`Protocols`中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
 
-如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。
-如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。
+如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。
 
 
 <a name="protocols_as_types"></a>

From a51a21f2f32b9da931c3c1b2fd67df6e69b802f0 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 10:14:16 +0800
Subject: [PATCH 070/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90=20?=
 =?UTF-8?q?=E5=8D=8F=E8=AE=AE=E7=B1=BB=E5=9E=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 5f3f5dc2..455f0db2 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -274,15 +274,16 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 <a name="protocols_as_types"></a>
 ## 协议类型
 
-尽管`协议`本身并不实现任何功能，但是`协议`可以被当做类型来使用。
+尽管协议本身并不实现任何功能，但是协议可以被当做类型来使用。
 
-使用场景:
+协议可以像其他普通类型一样使用，使用场景:
 
-* `协议类型`作为函数、方法或构造器中的参数类型或返回值类型
-* `协议类型`作为常量、变量或属性的类型
-* `协议类型`作为数组、字典或其他容器中的元素类型
+* 作为函数、方法或构造器中的参数类型或返回值类型
+* 作为常量、变量或属性的类型
+* 作为数组、字典或其他容器中的元素类型
 
-> 注意: 协议是一种类型，因此协议类型的名称应与其他类型(Int，Double，String)的写法相同，使用驼峰式写法
+> 注意
+> 协议是一种类型，因此协议类型的名称应与其他类型(Int，Double，String)的写法相同，使用大写字母开头的驼峰式写法，例如(`FullyNamed`和`RandomNumberGenerator`)
 
 如下所示，这个示例中将协议当做类型来使用
 
@@ -300,18 +301,18 @@ class Dice {
 }
 ```
 
-例子中又一个`Dice`类，用来代表桌游中的拥有N个面的骰子。`Dice`的实例含有`sides`和`generator`两个属性，前者是整型，用来表示骰子有几个面，后者为骰子提供一个随机数生成器。
+例子中定义了一个`Dice`类，用来代表桌游中的拥有N个面的骰子。`Dice`的实例含有`sides`和`generator`两个属性，前者是整型，用来表示骰子有几个面，后者为骰子提供一个随机数生成器。
 
  `generator`属性的类型为`RandomNumberGenerator`，因此任何遵循了`RandomNumberGenerator`协议的类型的实例都可以赋值给`generator`，除此之外，无其他要求。
 
-`Dice`类中也有一个`构造器(initializer)`，用来进行初始化操作。构造器中含有一个名为`generator`，类型为`RandomNumberGenerator`的形参。在调用构造方法时创建`Dice`的实例时，可以传入任何遵循`RandomNumberGenerator`协议的实例给generator。
+`Dice`类中也有一个构造器(initializer)，用来进行初始化操作。构造器中含有一个名为`generator`，类型为`RandomNumberGenerator`的形参。在调用构造方法时创建`Dice`的实例时，可以传入任何遵循`RandomNumberGenerator`协议的实例给generator。
 
-`Dice`类也提供了一个名为`roll`的实例方法用来模拟骰子的面值。它先使用`generator`的`random`方法来创建一个[0-1]区间内的随机数种子，然后加工这个随机数种子生成骰子的面值。generator被认为是遵循了`RandomNumberGenerator`的类型，因而保证了`random`方法可以被调用。
+`Dice`类也提供了一个名为`roll`的实例方法用来模拟骰子的面值。它先使用`generator`的`random()`方法来创建一个[0,1)区间内的随机数，然后使用这个随机数生成正确的骰子面值。因为generator遵循了`RandomNumberGenerator`协议，因而保证了`random`方法可以被调用。
 
-如下所示，这里展示了如何使用`LinearCongruentialGenerator`的实例作为随机数生成器创建一个六面骰子:
+下面的例子展示了如何使用`LinearCongruentialGenerator`的实例作为随机数生成器创建一个六面骰子:
 
 ```swift
-var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
+var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
 for _ in 1...5 {
 	print("Random dice roll is \(d6.roll())")
 }

From a8ec9464bd88fea0caf9b12089a5e83daaa96460 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 10:51:06 +0800
Subject: [PATCH 071/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=A7=94=E6=89=98(=E4=BB=A3=E7=90=86)=E6=A8=A1=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 455f0db2..a5828e9f 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -327,13 +327,9 @@ for _ in 1...5 {
 <a name="delegation"></a>
 ## 委托(代理)模式
 
-委托是一种设计模式(*译者注: 想起了那年 UITableViewDelegate 中的奔跑，那是我逝去的Objective-C。。。*)，它允许`类`或`结构体`将一些需要它们负责的功能`交由(委托)`给其他的类型的实例。
+委托是一种设计模式，它允许`类`或`结构体`将一些需要它们负责的功能`交由(委托)`给其他的类型的实例。委托模式的实现很简单: 定义协议来封装那些需要被委托的函数和方法， 使其`遵循者`拥有这些被委托的`函数和方法`。委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的类型信息。
 
-委托模式的实现很简单: 定义`协议`来`封装`那些需要被委托的`函数和方法`， 使其`遵循者`拥有这些被委托的`函数和方法`。
-
-委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的所属类型(*译者注:只要求外部数据源`遵循`某协议*)。
-
-下文是两个基于骰子游戏的协议:
+下面的例子是两个基于骰子游戏的协议:
 
 ```swift
 protocol DiceGame {
@@ -348,7 +344,7 @@ protocol DiceGameDelegate {
 }
 ```
 
-`DiceGame`协议可以在任意含有骰子的游戏中实现，`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
+`DiceGame`协议可以在任意含有骰子的游戏中实现。`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
 
 如下所示，`SnakesAndLadders`是`Snakes and Ladders`(译者注:[Control Flow](2)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程:
 
@@ -385,15 +381,15 @@ class SnakesAndLadders: DiceGame {
 }
 ```
 
-这个版本的游戏封装到了`SnakesAndLadders`类中，该类采用了`DiceGame`协议，并且提供了`dice`属性和`play`实例方法用来`遵循`协议。(`dice`属性在构造之后就不在改变，且协议只要求`dice`为只读的，因此将`dice`声明为常量属性。)
+这个版本的游戏封装到了`SnakesAndLadders`类中，该类遵循了`DiceGame`协议，并且提供了相应的可读的`dice`属性和`play`实例方法。(`dice`属性在构造之后就不再改变，且协议只要求`dice`为只读的，因此将`dice`声明为常量属性。)
 
 在`SnakesAndLadders`类的`构造器(initializer)`初始化游戏。所有的游戏逻辑被转移到了`play`方法中，`play`方法使用协议规定的`dice`属性提供骰子摇出的值。
 
-> 注意:`delegate`并不是游戏的必备条件，因此`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性，`delegate`使用`nil`作为初始值。
+注意:`delegate`并不是游戏的必备条件，因此`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性。因为`delegate`是可选值，因此在初始化的时候被自动赋值为`nil`。随后，可以在游戏中为`delegate`设置适当的值。
 
 `DicegameDelegate`协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中，即`play()`方法内。分别在游戏开始时，新一轮开始时，游戏结束时被调用。
 
-因为`delegate`是一个遵循`DiceGameDelegate`的可选属性，因此在`play()`方法中使用了`可选链`来调用委托方法。 若`delegate`属性为`nil`， 则delegate所调用的方法失效。若`delegate`不为`nil`，则方法能够被调用
+因为`delegate`是一个遵循`DiceGameDelegate`的可选属性，因此在`play()`方法中使用了`可选链`来调用委托方法。 若`delegate`属性为`nil`， 则delegate所调用的方法失效，并不会产生错误。若`delegate`不为`nil`，则方法能够被调用
 
 如下所示，`DiceGameTracker`遵循了`DiceGameDelegate`协议
 

From 4a7fedf46e999e21a13a23b932ca5ab46af59d41 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:10:44 +0800
Subject: [PATCH 072/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=A7=94=E6=89=98(=E4=BB=A3=E7=90=86)=E6=A8=A1=E5=BC=8F=20?=
 =?UTF-8?q?=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index a5828e9f..0b9fc63b 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -383,7 +383,7 @@ class SnakesAndLadders: DiceGame {
 
 这个版本的游戏封装到了`SnakesAndLadders`类中，该类遵循了`DiceGame`协议，并且提供了相应的可读的`dice`属性和`play`实例方法。(`dice`属性在构造之后就不再改变，且协议只要求`dice`为只读的，因此将`dice`声明为常量属性。)
 
-在`SnakesAndLadders`类的`构造器(initializer)`初始化游戏。所有的游戏逻辑被转移到了`play`方法中，`play`方法使用协议规定的`dice`属性提供骰子摇出的值。
+游戏使用`SnakesAndLadders`类的`构造器(initializer)`初始化游戏。所有的游戏逻辑被转移到了协议中的`play`方法，`play`方法使用协议规定的`dice`属性提供骰子摇出的值。
 
 注意:`delegate`并不是游戏的必备条件，因此`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性。因为`delegate`是可选值，因此在初始化的时候被自动赋值为`nil`。随后，可以在游戏中为`delegate`设置适当的值。
 
@@ -413,7 +413,7 @@ class DiceGameTracker: DiceGameDelegate {
 }
 ```
 
-`DiceGameTracker`实现了`DiceGameDelegate`协议规定的三个方法，用来记录游戏已经进行的轮数。 当游戏开始时，`numberOfTurns`属性被赋值为0; 在每新一轮中递加; 游戏结束后，输出打印游戏的总轮数。
+`DiceGameTracker`实现了`DiceGameDelegate`协议规定的三个方法，用来记录游戏已经进行的轮数。 当游戏开始时，`numberOfTurns`属性被赋值为0; 在每新一轮中递增; 游戏结束后，输出打印游戏的总轮数。
 
 `gameDidStart`方法从`game`参数获取游戏信息并输出。`game`在方法中被当做`DiceGame`类型而不是`SnakeAndLadders`类型，所以方法中只能访问`DiceGame`协议中的成员。当然了，这些方法也可以在类型转换之后调用。在上例代码中，通过`is`操作符检查`game`是否为 `SnakesAndLadders`类型的实例，如果是，则打印出相应的内容。
 

From 857dcd619a4da1b190f721e8e5374e811bd90c33 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:27:43 +0800
Subject: [PATCH 073/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=9C=A8=E6=89=A9=E5=B1=95=E4=B8=AD=E6=B7=BB=E5=8A=A0=E5=8D=8F?=
 =?UTF-8?q?=E8=AE=AE=E6=88=90=E5=91=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 0b9fc63b..b09b6335 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -417,7 +417,7 @@ class DiceGameTracker: DiceGameDelegate {
 
 `gameDidStart`方法从`game`参数获取游戏信息并输出。`game`在方法中被当做`DiceGame`类型而不是`SnakeAndLadders`类型，所以方法中只能访问`DiceGame`协议中的成员。当然了，这些方法也可以在类型转换之后调用。在上例代码中，通过`is`操作符检查`game`是否为 `SnakesAndLadders`类型的实例，如果是，则打印出相应的内容。
 
-无论当前进行的是何种游戏，`game`都遵循`DiceGame`协议以确保`game`含有`dice`属性，因此在`gameDidStart`方法中可以通过传入的`game`参数来访问`dice`属性，进而打印出`dice`的`sides`属性的值。
+无论当前进行的是何种游戏，`game`都遵循`DiceGame`协议以确保`game`含有`dice`属性，因此在`gameDidStart(_:)`方法中可以通过传入的`game`参数来访问`dice`属性，进而打印出`dice`的`sides`属性的值。
 
 `DiceGameTracker`的运行情况，如下所示:
 
@@ -438,11 +438,12 @@ game.play()
 <a name="adding_protocol_conformance_with_an_extension"></a>
 ## 在扩展中添加协议成员
 
-即便无法修改源代码，依然可以通过`扩展(Extension)`来扩充已存在类型(*译者注: 类，结构体，枚举等*)。`扩展`可以为已存在的类型添加`属性`，`方法`，`下标脚本`，`协议`等成员。详情请在[扩展](4)章节中查看。
+即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(*译者注: 类，结构体，枚举等*)。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。详情请在[扩展](4)章节中查看。
 
-> 注意: 通过`扩展`为已存在的类型`遵循`协议时，该类型的所有实例也会随之添加协议中的方法
+> 注意
+> 通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法
 
-`TextRepresentable`协议含有一个`asText`，如下所示：
+例如`TextRepresentable`协议，任何想要表示一些文本内容的类型都可以遵循该协议。这些想要表示的内容可以是类型本身的描述，也可以是当前内容的版本:
 
 ```swift
 protocol TextRepresentable {
@@ -450,7 +451,7 @@ protocol TextRepresentable {
 }
 ```
 
-通过`扩展`为上一节中提到的`Dice`类遵循`TextRepresentable`协议
+可以通过扩展，为上一节中提到的`Dice`增加类遵循`TextRepresentable`协议的功能
 
 ```swift
 extension Dice: TextRepresentable {
@@ -459,8 +460,9 @@ extension Dice: TextRepresentable {
 	}
 }
 ```
+现在，通过扩展使得`Dice`类型遵循了一个新的协议，这和`Dice`类型在定义的时候声明为遵循`TextRepresentable`协议的效果相同。在扩展的时候，协议名称写在类型名之后，以冒号隔开，在大括号内写明新添加的协议内容。
 
-从现在起，`Dice`类型的实例可被当作`TextRepresentable`类型：
+现在所有`Dice`的实例都遵循了`TextRepresentable`协议:
 
 ```swift
 let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
@@ -468,7 +470,7 @@ print(d12.asText())
 // 输出 "A 12-sided dice"
 ```
 
-`SnakesAndLadders`类也可以通过`扩展`的方式来遵循协议：
+同样`SnakesAndLadders`类也可以通过`扩展`的方式来遵循`TextRepresentable`协议：
 
 ```swift
 extension SnakesAndLadders: TextRepresentable {

From 866097add001d2f7c9b7f3c912b4c86c33a0f088 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:31:06 +0800
Subject: [PATCH 074/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E9=80=9A=E8=BF=87=E6=89=A9=E5=B1=95=E8=A1=A5=E5=85=85=E5=8D=8F?=
 =?UTF-8?q?=E8=AE=AE=E5=A3=B0=E6=98=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index b09b6335..7ca35ac4 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -485,7 +485,7 @@ print(game.asText())
 <a name="declaring_protocol_adoption_with_an_extension"></a>
 ## 通过扩展补充协议声明
 
-当一个类型已经实现了协议中的所有要求，却没有声明时，可以通过`扩展`来补充协议声明:
+当一个类型已经实现了协议中的所有要求，却没有声明为遵循该协议时，可以通过扩展(空的扩展体)来补充协议声明:
 
 ```swift
 struct Hamster {
@@ -506,7 +506,8 @@ print(somethingTextRepresentable.asText())
 // 输出 "A hamster named Simon"
 ```
 
-> 注意: 即使满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出明显的协议声明
+> 注意
+> 即使满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出显式的协议声明
 
 <a name="collections_of_protocol_types"></a>
 ## 集合中的协议类型

From 17751155281e0bf8b0ce8183b8df28c487e8fefa Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:55:07 +0800
Subject: [PATCH 075/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E9=9B=86=E5=90=88=E4=B8=AD=E7=9A=84=E5=8D=8F=E8=AE=AE=E7=B1=BB?=
 =?UTF-8?q?=E5=9E=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 7ca35ac4..f9aaa911 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -512,13 +512,13 @@ print(somethingTextRepresentable.asText())
 <a name="collections_of_protocol_types"></a>
 ## 集合中的协议类型
 
-协议类型可以被集合使用，表示集合中的元素均为协议类型:
+协议类型可以在集合使用，表示集合中的元素均为协议类型，下面的例子创建了一个类型为`TextRepresentable`的数组:
 
 ```swift
 let things: [TextRepresentable] = [game,d12,simonTheHamster]
 ```
 
-如下所示，`things`数组可以被直接遍历，并调用其中元素的`asText()`函数:
+如下所示，`things`数组可以被直接遍历，并打印每个元素的文本表示:
 
 ```swift
 for thing in things {

From 6062b84363714e2573bfbb79500b7a5839478a28 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 21:24:35 +0800
Subject: [PATCH 076/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=8D=8F=E8=AE=AE=E7=9A=84=E7=BB=A7=E6=89=BF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index f9aaa911..0933d597 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -534,7 +534,7 @@ for thing in things {
 <a name="protocol_inheritance"></a>
 ## 协议的继承
 
-协议能够继承一到多个其他协议。语法与类的继承相似，多个协议间用逗号`，`分隔
+协议能够继承一个或多个其他协议，可以在继承的协议基础上增加新的内容要求。协议的继承语法与类的继承相似，多个被继承的协议间用逗号分隔:
 
 ```swift
 protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
@@ -550,9 +550,9 @@ protocol PrettyTextRepresentable: TextRepresentable {
 }
 ```
 
-遵循`PrettyTextRepresentable`协议的同时，也需要遵循`TextRepresentable`协议。
+例子中定义了一个新的协议`PrettyTextRepresentable`，它继承自`TextRepresentable`协议。任何遵循`PrettyTextRepresentable`协议的类型在满足该协议的要求时，也必须满足`TextRepresentable`协议的要求。在这个例子中，`PrettyTextRepresentable`协议要求其遵循者提供一个返回值为`String`类型的`asPrettyText`方法。
 
-如下所示，用`扩展`为`SnakesAndLadders`遵循`PrettyTextRepresentable`协议:
+如下所示，扩展`SnakesAndLadders`，让其遵循`PrettyTextRepresentable`协议:
 
 ```swift
 extension SnakesAndLadders: PrettyTextRepresentable {
@@ -573,11 +573,11 @@ extension SnakesAndLadders: PrettyTextRepresentable {
 }
 ```
 
-在`for in`中迭代出了`board`数组中的每一个元素:
+上述扩展使得`SnakesAndLadders`遵循了`PrettyTextRepresentable`协议，并为每个`SnakesAndLadders`类型提供了了协议要求的`asPrettyText()`方法。每个`PrettyTextRepresentable`类型同时也是`TextRepresentable`类型，所以在`asPrettyText`的实现中，可以调用`asText()`方法。之后在每一行加上换行符，作为输出的开始。然后遍历数组中的元素，输出一个几何图形来表示遍历的结果:
 
-* 当从数组中迭代出的元素的值大于0时，用`▲`表示
-* 当从数组中迭代出的元素的值小于0时，用`▼`表示
-* 当从数组中迭代出的元素的值等于0时，用`○`表示
+* 当从数组中取出的元素的值大于0时，用`▲`表示
+* 当从数组中取出的元素的值小于0时，用`▼`表示
+* 当从数组中取出的元素的值等于0时，用`○`表示
 
 任意`SankesAndLadders`的实例都可以使用`asPrettyText()`方法。
 

From 595647259c4fcb07c44d530de34c469e42de0464 Mon Sep 17 00:00:00 2001
From: justaway <bug_free@163.com>
Date: Sat, 4 Jul 2015 23:32:38 +0800
Subject: [PATCH 077/228] =?UTF-8?q?'25=5FAdvanced=5FOperators'=E7=BF=BB?=
 =?UTF-8?q?=E8=AF=91=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/25_Advanced_Operators.md | 134 ++++++++++++-----------
 1 file changed, 68 insertions(+), 66 deletions(-)

diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index b641866b..4d54288a 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -249,73 +249,73 @@ signedOverflow = signedOverflow &- 1
 
 运算符的优先级(`precedence`)使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。
 
-结合性(`associativity`)定义相同优先级的运算符在一起时是怎么组合或关联的，是和左边的一组呢，还是和右边的一组。意思就是，到底是和左边的表达式结合呢，还是和右边的表达式结合？
+结合性(`associativity`)定义了相同优先级的运算符是如何结合（或关联）的 —— 是与左边结合为一组，还是与右边结合为一组。可以将这意思理解为“它们是与左边的表达式结合的”或者“它们是与右边的表达式结合的”。
 
-在混合表达式中，运算符的优先级和结合性是非常重要的。举个例子，为什么下列表达式的结果为`4`？
+在复合表达式的运算顺序中，运算符的优先级和结合性是非常重要的。举例来说，为什么下面这个表达式的运算结果是 `4`？
 
 ```swift
 2 + 3 * 4 % 5
 // 结果是 4
 ```
 
-如果严格地从左计算到右，计算过程会是这样：
-
+如果严格地从左到右进行运算，则运算的过程是这样的：
 
 - 2 + 3 = 5
 - 5 * 4 = 20
-- 20 / 5 = 4 余 0
+- 20 % 5 = 0
 
-但是正确答案是`4`而不是`0`。优先级高的运算符要先计算，在Swift和C语言中，都是先乘除后加减的。所以，执行完乘法和求余运算才能执行加减运算。
+但是正确答案是 `4` 而不是 `0`。优先级高的运算符要先于优先级低的运算符进行计算。与C语言类似，在 Swift 当中，乘法运算符(`*`)与取余运算符(`%`)的优先级高于加法运算符(`+`)。因此，它们的计算顺序要先于加法运算。
 
-乘法和求余拥有相同的优先级，在运算过程中，我们还需要结合性，乘法和求余运算都是左结合的。这相当于在表达式中有隐藏的括号让运算从左开始。
+而乘法与取余的优先级相同。这时为了得到正确的运算顺序，还需要考虑结合性。乘法与取余运算都是左结合的。可以将这考虑成为这两部分表达式都隐式地加上了括号：
 
 ```swift
 2 + ((3 * 4) % 5)
 ```
 
-3 * 4 = 12，所以这相当于：
+`(3 * 4) = 12`，所以表达式相当于：
 
 
 ```swift
 2 + (12 % 5)
 ```
 
-12 % 5 = 2，所这又相当于
+`12 % 5 = 2`，所以表达式相当于：
 
 ```swift
 2 + 2
 ```
 
-计算结果为 4。
+此时可以容易地看出计算的结果为 `4`。
 
-查阅Swift运算符的优先级和结合性的完整列表，请看[表达式](../chapter3/04_Expressions.html)。
+如果想查看完整的 Swift 运算符优先级和结合性规则，请参考[表达式](../chapter3/04_Expressions.html)。
 
 > 注意：  
-Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。
+> 对于C语言和 Objective-C 来说，Swift 的运算符优先级和结合性规则是更加简洁和可预测的。但是，这也意味着它们于那些基于C的语言不是完全一致的。在对现有的代码进行移植的时候，要注意确保运算符的行为仍然是按照你所想的那样去执行。
 
 <a name="operator_functions"></a>
 ## 运算符函数
 
-让已有的运算符也可以对自定义的类和结构进行运算，这称为运算符重载。
+类和结构可以为现有的操作符提供自定义的实现，这通常被称为运算符重载(`overloading`)。
 
-这个例子展示了如何用`+`让一个自定义的结构做加法。算术运算符`+`是一个两目运算符，因为它有两个操作数，而且它必须出现在两个操作数之间。
+下面的例子展示了如何为自定义的结构实现加法操作符(`+`)。算术加法运算符是一个两目运算符(`binary operator`)，因为它可以对两个目标进行操作，同时它还是中缀(`infix`)运算符，因为它出现在两个目标中间。
 
-例子中定义了一个名为`Vector2D`的二维坐标向量 `(x，y)` 的结构，然后定义了让两个`Vector2D`的对象相加的运算符函数。
+例子中定义了一个名为 `Vector2D` 的结构体用来表示二维坐标向量`(x, y)`，紧接着定义了一个可以对两个 `Vector2D` 结构体进行相加的运算符函数(`operator function`)：
 
 ```swift
 struct Vector2D {
     var x = 0.0, y = 0.0
 }
-@infix func + (left: Vector2D, right: Vector2D) -> Vector2D {
+
+func + (left: Vector2D, right: Vector2D) -> Vector2D {
     return Vector2D(x: left.x + right.x, y: left.y + right.y)
 }
 ```
 
-该运算符函数定义了一个全局的`+`函数，这个函数需要两个`Vector2D`类型的参数，返回值也是`Vector2D`类型。需要定义和实现一个中置运算的时候，在关键字`func`之前写上属性 `@infix` 就可以了。
+该运算符函数被定义为一个全局函数，并且函数的名字与它要进行重载的 `+` 名字一致。因为算术加法运算符是双目运算符，所以这个运算符函数接收两个类型为 `Vector2D` 的输入参数，同时有一个 `Vector2D` 类型的返回值。
 
-在这个代码实现中，参数被命名为了`left`和`right`，代表`+`左边和右边的两个`Vector2D`对象。函数返回了一个新的`Vector2D`的对象，这个对象的`x`和`y`分别等于两个参数对象的`x`和`y`的和。
+在这个实现中，输入参数分别被命名为 `left` 和 `right`，代表在 `+` 运算符左边和右边的两个 `Vector2D` 对象。函数返回了一个新的 `Vector2D` 的对象，这个对象的 `x` 和 `y` 分别等于两个参数对象的 `x` 和 `y` 的值之和。
 
-这个函数是全局的，而不是`Vector2D`结构的成员方法，所以任意两个`Vector2D`对象都可以使用这个中置运算符。
+这个函数被定义成全局的，而不是 `Vector2D` 结构的成员方法，所以任意两个 `Vector2D` 对象都可以使用这个中缀运算符：
 
 ```swift
 let vector = Vector2D(x: 3.0, y: 1.0)
@@ -324,151 +324,153 @@ let combinedVector = vector + anotherVector
 // combinedVector 是一个新的Vector2D, 值为 (5.0, 5.0)
 ```
 
-这个例子实现两个向量 `(3.0，1.0)` 和 `(2.0，4.0)` 相加，得到向量 `(5.0，5.0)` 的过程。如下图示：
+这个例子实现两个向量 `(3.0，1.0)` 和 `(2.0，4.0)` 的相加，并得到新的向量 `(5.0，5.0)`。这个过程如下图示：
 
 ![Art/vectorAddition_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/vectorAddition_2x.png "Art/vectorAddition_2x.png")
 
-### 前置和后置运算符
+### 前缀和后缀运算符
 
-上个例子演示了一个双目中置运算符的自定义实现，同样我们也可以玩标准单目运算符的实现。单目运算符只有一个操作数，在操作数之前就是前置的，如`-a`; 在操作数之后就是后置的，如`i++`。
+上个例子演示了一个双目中缀运算符的自定义实现。类与结构体也能提供标准单目运算符(`unary operators`)的实现。单目运算符只有一个操作目标。当运算符出现在操作目标之前时，它就是前缀(`prefix`)的(比如 `-a`)，而当它出现在操作目标之后时，它就是后缀(`postfix`)的(比如 `i++`)。
 
-实现一个前置或后置运算符时，在定义该运算符的时候于关键字`func`之前标注 `@prefix` 或 `@postfix` 属性。
+要实现前缀或者后缀运算符，需要在声明运算符函数的时候在 `func` 关键字之前指定 `prefix` 或者 `postfix` 限定符：
 
 ```swift
-@prefix func - (vector: Vector2D) -> Vector2D {
+prefix func - (vector: Vector2D) -> Vector2D {
     return Vector2D(x: -vector.x, y: -vector.y)
 }
 ```
 
-这段代码为`Vector2D`类型提供了单目减运算`-a`，`@prefix`属性表明这是个前置运算符。
+这段代码为 `Vector2D` 类型实现了单目减运算符(`-a`)。由于单目减运算符是前缀运算符，所以这个函数需要加上 `prefix` 限定符。
 
-对于数值，单目减运算符可以把正数变负数，把负数变正数。对于`Vector2D`，单目减运算将其`x`和`y`都进进行单目减运算。
+对于简单数值，单目减运算符可以对它们的正负性进行改变。对于 `Vector2D` 来说，单目减运算将其 `x` 和 `y` 属性的正负性都进行了改变。
 
 ```swift
 let positive = Vector2D(x: 3.0, y: 4.0)
 let negative = -positive
-// negative 为 (-3.0, -4.0)
+// negative 是一个值为 (-3.0, -4.0) 的 Vector2D 实例
+
 let alsoPositive = -negative
-// alsoPositive 为 (3.0, 4.0)
+// alsoPositive 是一个值为 (3.0, 4.0) 的 Vector2D 实例
 ```
 
-### 组合赋值运算符
+### 复合赋值运算符
 
-组合赋值是其他运算符和赋值运算符一起执行的运算。如`+=`把加运算和赋值运算组合成一个操作。实现一个组合赋值符号需要使用`@assignment`属性，还需要把运算符的左参数设置成`inout`，因为这个参数会在运算符函数内直接修改它的值。
+复合赋值运算符(`Compound assignment operators`)将赋值运算符(`=`)与其它运算符进行结合。比如，将加法与赋值结合成加法赋值运算符(`+=`)。在实现的时候，需要把运算符的左参数设置成 `inout` 类型，因为这个参数的值会在运算符函数内直接被修改。
 
 ```swift
-@assignment func += (inout left: Vector2D, right: Vector2D) {
+func += (inout left: Vector2D, right: Vector2D) {
     left = left + right
 }
 ```
 
-因为加法运算在之前定义过了，这里无需重新定义。所以，加赋运算符函数使用已经存在的高级加法运算符函数来执行左值加右值的运算。
+因为加法运算在之前已经定义过了，所以在这里无需重新定义。在这里可以直接利用现有的加法运算符函数，用它来对左值和右值进行相加，并再次赋值给左值：
 
 ```swift
 var original = Vector2D(x: 1.0, y: 2.0)
 let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
 original += vectorToAdd
-// original 现在为 (4.0, 6.0)
+// original 的值现在为 (4.0, 6.0)
 ```
 
-你可以将 `@assignment` 属性和 `@prefix` 或 `@postfix` 属性起来组合，实现一个`Vector2D`的前置运算符。
+还可以将赋值与 `prefix` 或 `postfix` 限定符结合起来，下面的代码为 `Vector2D` 实例实现了前缀自增运算符(`++a`)：
 
 ```swift
-@prefix @assignment func ++ (inout vector: Vector2D) -> Vector2D {
+prefix func ++ (inout vector: Vector2D) -> Vector2D {
     vector += Vector2D(x: 1.0, y: 1.0)
     return vector
 }
 ```
 
-这个前置使用了已经定义好的高级加赋运算，将自己加上一个值为 `(1.0，1.0)` 的对象然后赋给自己，然后再将自己返回。
+这个前缀自增运算符使用了前面定义的加法赋值操作。它对 `Vector2D` 的 `x` 和 `y` 属性都进行了加 `1` 操作，再将结果返回：
 
 ```swift
 var toIncrement = Vector2D(x: 3.0, y: 4.0)
 let afterIncrement = ++toIncrement
-// toIncrement 现在是 (4.0, 5.0)
-// afterIncrement 现在也是 (4.0, 5.0)
+// toIncrement 的值现在为 (4.0, 5.0)
+// afterIncrement 的值同样为 (4.0, 5.0)
 ```
 
->注意：  
-默认的赋值符(=)是不可重载的。只有组合赋值符可以重载。三目条件运算符 `a？b：c` 也是不可重载。
+> 注意：
+> 不能对默认的赋值运算符(`=`)进行重载。只有组合赋值符可以被重载。同样地，也无法对三目条件运算符 `a ? b : c` 进行重载。
 
-### 比较运算符
+### 等价运算符
 
-Swift无所知道自定义类型是否相等或不等，因为等于或者不等于由你的代码说了算了。所以自定义的类和结构要使用比较符`==`或`!=`就需要重载。
+自定义的类和结构体没有对等价操作符(`equivalence operators`)进行默认实现，等价操作符通常被称为“相等”操作符(`==`)与“不等”操作符(`!=`)。对于自定义类型，Swift 无法判断其是否“相等”，因为“相等”的含义取决于这些自定义类型在你的代码中所扮演的角色。
 
-定义相等运算符函数跟定义其他中置运算符雷同：
+为了使用等价操作符来对自定义的类型进行判等操作，需要为其提供自定义实现，实现的方法与其它中缀运算符一样：
 
 ```swift
-@infix func == (left: Vector2D, right: Vector2D) -> Bool {
+func == (left: Vector2D, right: Vector2D) -> Bool {
     return (left.x == right.x) && (left.y == right.y)
 }
-
-@infix func != (left: Vector2D, right: Vector2D) -> Bool {
+func != (left: Vector2D, right: Vector2D) -> Bool {
     return !(left == right)
 }
 ```
 
-上述代码实现了相等运算符`==`来判断两个`Vector2D`对象是否有相等的值，相等的概念就是它们有相同的`x`值和相同的`y`值，我们就用这个逻辑来实现。接着使用`==`的结果实现了不相等运算符`!=`。
+上述代码实现了“相等”运算符(`==`)来判断两个 `Vector2D` 对象是否有相等。对于 `Vector2D` 类型来说，“相等”意味“两个实例的 `x`属性 和 `y` 属性都相等”，这也是代码中用来进行判等的逻辑。示例里同时也实现了“不等”操作符(`!=`)，它简单地将“相等”操作符进行取反后返回。
 
-现在我们可以使用这两个运算符来判断两个`Vector2D`对象是否相等。
+现在我们可以使用这两个运算符来判断两个 `Vector2D` 对象是否相等。
 
 ```swift
 let twoThree = Vector2D(x: 2.0, y: 3.0)
 let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
 if twoThree == anotherTwoThree {
-    println("这两个向量是相等的.")
+    print("These two vectors are equivalent.")
 }
-// prints "这两个向量是相等的."
+// prints "These two vectors are equivalent."
 ```
 
 ### 自定义运算符
 
-标准的运算符不够玩，那你可以声明一些个性的运算符，但个性的运算符只能使用这些字符 `/ = - + * % < > ! & | ^ . ~`。
+除了实现标准运算符，在 Swift 当中还可以声明和实现自定义运算符(`custom operators`)。可以用来自定义运算符的字符列表请参考[操作符](../chapter3/02_Lexical_Structure.html#operators)
 
-新的运算符声明需在全局域使用`operator`关键字声明，可以声明为前置，中置或后置的。
+新的运算符要在全局作用域内，使用 `operator` 关键字进行声明，同时还要指定 `prefix`、`infix` 或者 `postfix` 限定符：
 
 ```swift
 operator prefix +++ {}
 ```
 
-
-这段代码定义了一个新的前置运算符叫`+++`，此前Swift并不存在这个运算符。此处为了演示，我们让`+++`对`Vector2D`对象的操作定义为 `双自增` 这样一个独有的操作，这个操作使用了之前定义的加赋运算实现了自已加上自己然后返回的运算。
+上面的代码定义了一个新的名为 `+++` 的前缀运算符。对于这个运算符，在 Swift 中并没有意义，因为我们针对 `Vector2D` 的实例来定义它的意义。对这个示例来讲，`+++` 被实现为“前缀双自增”运算符。它使用了前面定义的复合加法操作符来让矩阵对自身进行相加，从而让 `Vector2D` 实例的 `x` 属性和 `y`属性的值翻倍：
 
 ```swift
-@prefix @assignment func +++ (inout vector: Vector2D) -> Vector2D {
+prefix func +++ (inout vector: Vector2D) -> Vector2D {
     vector += vector
     return vector
 }
 ```
 
-`Vector2D` 的 `+++` 的实现和 `++` 的实现很接近, 唯一不同的是前者是加自己, 后者是加值为 `(1.0, 1.0)` 的向量.
+`Vector2D` 的 `+++` 的实现和 `++` 的实现很相似, 唯一不同的是前者对自身进行相加, 而后者是与另一个值为 `(1.0, 1.0)` 的向量相加.
 
 ```swift
 var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
 let afterDoubling = +++toBeDoubled
-// toBeDoubled 现在是 (2.0, 8.0)
-// afterDoubling 现在也是 (2.0, 8.0)
+// toBeDoubled 现在的值为 (2.0, 8.0)
+// afterDoubling 现在的值也为 (2.0, 8.0)
 ```
 
-### 自定义中置运算符的优先级和结合性
+### 自定义中缀运算符的优先级和结合性
 
-可以为自定义的中置运算符指定优先级和结合性。可以回头看看[优先级和结合性](#PrecedenceandAssociativity)解释这两个因素是如何影响多种中置运算符混合的表达式的计算的。
+自定义的中缀(`infix`)运算符也可以指定优先级(`precedence`)和结合性(`associativity`)。[优先级和结合性](#PrecedenceandAssociativity)中详细阐述了这两个特性是如何对中缀运算符的运算产生影响的。
 
-结合性(associativity)的值可取的值有`left`，`right`和`none`。左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理，右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。
+结合性(`associativity`)可取的值有` left`，`right` 和 `none`。当左结合运算符跟其他相同优先级的左结合运算符写在一起时，会跟左边的操作数进行结合。同理，当右结合运算符跟其他相同优先级的右结合运算符写在一起时，会跟右边的操作数进行结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。
 
-结合性(associativity)的值默认为`none`，优先级(precedence)默认为`100`。
+结合性(`associativity`)的默认值是 `none`，优先级(`precedence`)如果没有指定，则默认为 `100`。
 
-以下例子定义了一个新的中置符`+-`，是左结合的`left`，优先级为`140`。
+以下例子定义了一个新的中缀运算符 `+-`，此操作符是左结合的，并且它的优先级为 `140`：
 
 ```swift
-operator infix +- { associativity left precedence 140 }
+infix operator +- { associativity left precedence 140 }
 func +- (left: Vector2D, right: Vector2D) -> Vector2D {
     return Vector2D(x: left.x + right.x, y: left.y - right.y)
 }
 let firstVector = Vector2D(x: 1.0, y: 2.0)
 let secondVector = Vector2D(x: 3.0, y: 4.0)
 let plusMinusVector = firstVector +- secondVector
-// plusMinusVector 此时的值为 (4.0, -2.0)
+// plusMinusVector 是一个 Vector2D 类型，并且它的值为 (4.0, -2.0)
 ```
 
-这个运算符把两个向量的`x`相加，把向量的`y`相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(`left`和`140`)。查阅完整的Swift默认结合性和优先级的设置，请移步[表达式](../chapter3/04_Expressions.html);
+这个运算符把两个向量的 `x` 值相加，同时用第一个向量的 `y` 值减去第二个向量的 `y` 值。因为它本质上是属于“加型”运算符，所以将它的结合性和优先级被设置为(`left` 和 `140`)，这与 `+` 和 `-` 等默认的中缀加型操作符是相同的。完整的 Swift 操作符默认结合性与优先级请参考[表达式](../chapter3/04_Expressions.html)。
+
+> 注意：
+> 当定义前缀与后缀操作符的时候，我们并没有指定优先级。然而，如果对同一个操作数同时使用前缀与后缀操作符，则后缀操作符会先被执行。

From 1b0ec3b5d9b4660568fe6498513d8a8d44281e9d Mon Sep 17 00:00:00 2001
From: littledogboy <littledogboy@126.com>
Date: Sun, 5 Jul 2015 10:35:26 +0800
Subject: [PATCH 078/228] =?UTF-8?q?statements=E7=BF=BB=E8=AF=91=E4=BA=8C?=
 =?UTF-8?q?=E4=BB=A3=E7=9B=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

添加了跳转。使部分语句变得更通顺。
---
 source/chapter3/10_Statements.md | 97 +++++++++++++++++++-------------
 1 file changed, 59 insertions(+), 38 deletions(-)

diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index 7a98a9b1..c122756a 100755
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -1,6 +1,7 @@
 > 翻译：[coverxit](https://github.com/coverxit),[littledogboy](https://github.com/littledogboy)  
 > 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),[littledogboy](https://github.com/littledogboy)
-
+
+<a name="statement_statements"></a>
 # 语句
 -----------------
 
@@ -39,7 +40,8 @@
 > *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement)  
 > *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement)  
 > *循环语句* → [*do-while语句*](..\chapter3\10_Statements.html#do_while_statement)  
-
+
+<a name="for_statements"></a>
 ### For 语句
 
 `for`语句只有在循环条件为真时重复执行代码块，此时计数器递增。
@@ -65,7 +67,9 @@
 > *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *for语句* → **for** **(** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **)** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)  
-
+
+
+<a name="for-in_statements"></a>
 ### For-In 语句
 
 `for-in`语句允许在重复执行代码块的同时，迭代集合（或遵循`Sequence`协议的任意类型）中的每一项。
@@ -80,7 +84,9 @@
 
 > For-In 循环语法  
 > *for-in语句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-
+
+
+<a name="while_statements"></a>
 ### While 语句
 
 `while`语句当循环条件为真时，允许重复执行代码块。
@@ -103,11 +109,21 @@
 
 > While 循环语法  
 > *while语句* → **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *while条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)   
-> *表达式* → [*表达式*](..\chapter3\04_Expressions.html#expression)   
-> *表达式* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [条件列表](TODO)    
-> *表达式* →
-
+> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)   
+> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression)   
+> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*条件列表*](TODO)    
+> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [*表达式*](..\chapter3\04_Expressions.html#expression)    
+> *条件列表* → [*条件条件*](TODO)  [*条件列表*](TODO)      
+> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [可选绑定条件](../chapter2/01_The_Basics.html#optional_binding)    
+> *case条件* → **case** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO) [where](DOTO)    
+> *可选绑定条件* → [可选绑定头](TODO) [持续可选绑定](TODO) [持续可选绑定列表](TODO)    
+> *可选绑定头* → **let** [*模式*](..\chapter3\07_Patterns.html#pattern)  [构造器](TODO)  **var**  [*模式*](..\chapter3\07_Patterns.html#pattern)  [构造器](TODO)    
+>  *可持续绑定列表* →  [*模式*](..\chapter3\07_Patterns.html#pattern) |  [构造器](TODO) [可选绑定头](TODO)
+> 
+
+
+
+<a name="while-while_statements"></a>
 ### Repeat-While 语句
 
 `repeat-while`语句允许代码块被执行一次或多次。
@@ -141,7 +157,9 @@
 > 分支语句语法  
 > *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement)  
 > *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement)  
-
+
+
+<a name="if_statements"></a>
 ### If 语句
 
 取决于一个或多个条件的值，`if`语句将决定执行哪一块代码。
@@ -176,21 +194,23 @@
 `if`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
 
 > If语句语法  
-> *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else子句(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_  
+> *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_  
 > *if条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)  
-> *else子句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)     
+> *else(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)     
 
+
+<a name="guard_statements"></a>
 ### Guard 语句    
     
-`guard` 语句用来转移程序控制出该作用域，假如一个或者多个多个条件不成立。
+`guard` 语句用来转移程序控制出其作用域，如果一个或者多个条件不成立。
  `guard` 语句的格式如下：    
  > guard `condition` else {    
    `statements`    
  >}    
  
- `guard`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
+ `guard`语句中条件值的类型必须遵循`LogicValue`协议。且条件可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
  
- 在`guard`语句中声明的常量或者变量，可使用范围为从声明开始到作用域结束,常量和变量的值从可选绑定声明中分配。
+ 在`guard`语句中声明的常量或者变量，可用范围从声明开始到作用域结束,常量和变量的值从可选绑定声明中分配。
  
  `guard`语句需要有`else`子句，并且必须调用被`noreturn`属性标记的函数,或者使用下面的语句把程序执行转移到guard语句的作用域外。    
  
@@ -199,8 +219,10 @@
  *  `continue`
  *  `throw`    
  
-执行转移语句详情参见[执行转移语句](TODO)
-
+执行转移语句详情参见[控制传递语句](TODO)
+
+
+<a name="switch_statements"></a>
 ### Switch 语句
 
 取决于`switch`语句的*控制表达式（control expression）*，`switch`语句将决定执行哪一块代码。
@@ -251,12 +273,11 @@ case let (x, y) where x == y:
 > *case标签* → **case** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) **:**  
 > *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](..\chapter3\10_Statements.html#case_item_list)  
 > *default标签* → **default** **:**  
-> *where-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression)  
+> *where-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard)  
 > *where-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
-<a name="labeled_statement"></a>
+<a name="labeled_statements"></a>
 <a name="control_transfer_statements"></a>
-
 ## 带标签的语句
 
 你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
@@ -270,7 +291,7 @@ case let (x, y) where x == y:
 > *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:**  
 > *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
 
-<a name="control_transfer_statement"></a>
+<a name="control_transfer_statements"></a>
 ## 控制传递语句
 
 通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。
@@ -282,7 +303,7 @@ case let (x, y) where x == y:
 > *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement)     
 > *控制传递语句* → [*throw语句*](..\chapter3\10_Statements.html#throw_statement)  
 
-<a name="break_statement"></a>
+<a name="break_statements"></a>
 ### Break 语句
 
 `break`语句用于终止循环或`switch`语句的执行。使用`break`语句时，可以只写`break`这个关键词，也可以在`break`后面跟上标签名（label name），像下面这样：
@@ -301,7 +322,7 @@ case let (x, y) where x == y:
 > Break 语句语法  
 > *break语句* → **break** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_  
 
-<a name="continue_statement"></a>
+<a name="continue_statements"></a>
 ### Continue 语句
 
 `continue`语句用于终止循环中当前迭代的执行，但不会终止该循环的执行。使用`continue`语句时，可以只写`continue`这个关键词，也可以在`continue`后面跟上标签名（label name），像下面这样：
@@ -322,7 +343,7 @@ case let (x, y) where x == y:
 > Continue 语句语法  
 > *continue语句* → **continue** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_  
 
-<a name="fallthrough_statement"></a>
+<a name="fallthrough_statements"></a>
 ### Fallthrough 语句
 
 `fallthrough`语句用于在`switch`语句中传递控制权。`fallthrough`语句会把控制权从`switch`语句中的一个 case 传递给下一个 case 。这种传递是无条件的，即使下一个 case 的模式与`switch`语句的控制表达式的值不匹配。
@@ -334,7 +355,7 @@ case let (x, y) where x == y:
 > Fallthrough 语句语法  
 > *fallthrough语句* → **fallthrough**  
 
-<a name="return_statement"></a>
+<a name="return_statements"></a>
 ### Return 语句
 
 `return`语句用于在函数或方法的实现中将控制权传递给调用者，接着程序将会从调用者的位置继续向下执行。
@@ -351,7 +372,7 @@ case let (x, y) where x == y:
 > Return 语句语法  
 > *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_     
 
-<a name="availability_statement"></a>
+<a name="availability_statements"></a>
 ### Availability 语句    
 
 可用性条件，被当做`if` ，`while` 语句的条件，并且 `guard` 语句在运行时会基于特定的语法格式查询接口的可用性。    
@@ -363,10 +384,10 @@ avaliability 语句的形式如下：
 >  `fallback statements to execute if the APIs are unavailable`   
 > }    
 
-可用性条件执行一个代码块时，取决于在运行时你想要使用的接口是否可用。
+可用性条件执行一个代码块时，取决于在运行时想要使用的接口是否可用。
 当编译器检查到代码块中的接口是可用的，则从可用性条件中获取相应信息。    
 
-可用性条件使用逗号分隔平台名称和版本列表。使用`iOS`，`OSX`，以及`watchOS`为平台名称，包括相应的版本号。*参数是必需的。在任何平台上代码块主体都被可用性条件保护起来，由目标规定的最小部署目标执行。        
+可用性条件使用逗号分隔平台名称和版本列表。使用`iOS`，`OSX`，以及`watchOS`为平台名称，包括相应的版本号。*参数是必需的。在任何平台上代码块主体都被可用性条件保护起来，由满足最低部署条件的目标设备运行。        
    
 与布尔类型条件不同，不能用逻辑运算符 **&&** 和 **||** 合并可用性条件。 
 
@@ -383,7 +404,7 @@ avaliability 语句的形式如下：
 > *版本号* → [十进制数字](TODO)  **.** [十进制数字](TODO) **.** [十进制数字](TODO)
     
 
-<a name="throw_statement"></a>
+<a name="throw_statements"></a>
 ### Throw 语句    
 `throw`语句出现在抛出函数或者抛出方法体内，或者类型被`throws`关键字标记的表达式体内。   
  
@@ -400,14 +421,14 @@ avaliability 语句的形式如下：
 > throw 语句语法    
 > *抛出语句* → **throw**  *[表达式­](TODO)*    
 
-<a name="defer_statement"></a>
+<a name="defer_statements"></a>
 ### Defer 语句
 
  `defer` 语句用于转移程序控制出延迟语句作用域之前执行代码。    
  
 在 `defer` 语句中的语句无论程序控制如何转移都会执行。这意味着 `defer` 语句可以被使用在以下这些情况，像手动得执行资源管理，关闭文件描述，或者即使抛出了错误也需要去实现执行一些动作。    
 
-如果多个 `defer` 语句出现在同一范围内，那么它们执行的顺序与它们出现的顺序相反。最后执行的 `defer` 语句为给定范围内的第一个，这意味着最后的延迟语句中的语句涉及的资源可以被其他 `defer`语句清理掉。    
+如果多个 `defer` 语句出现在同一范围内，那么它们执行的顺序与出现的顺序相反。给定作用域中的第一个`defer` 语句，会在最后执行，这意味着最后执行的延迟语句中的语句涉及的资源可以被其他 `defer`语句清理掉。    
 
 > 1  func f( ) {    
 > 2  defer { print("First") }    
@@ -420,13 +441,13 @@ avaliability 语句的形式如下：
 > 9  // prints "First"    
 
 
-`defer` 语句中的语句无法转移程序控制权出延迟语句。    
+`defer` 语句中的语句无法转移程序控制出延迟语句。    
 
 > defer 语句语法        
 > *延迟语句*  → **defer** *[代码块](TODO)*    
 
 
-<a name="do_statement"></a>
+<a name="do_statements"></a>
 ### Do 语句    
 
 `do` 语句用于引入一个新的作用域,该作用域中可以含有一个或多个`catch`子句,catch子句中定义了一些匹配错误情况的模式。`do` 语句作用域内定义的常量和变量，只能在do语句作用域内访问。    
@@ -441,17 +462,17 @@ avaliability 语句的形式如下：
 > }    
 
 
-如同`switch`语句,编译器会判断`catch`子句是否被遗漏。如果这样的决定被执行，则视为错误被处理。否则，错误会自动传播出包含作用域,被一个封闭的`catch`语句或抛出函数处理，包含函数必须以`throws`关键字声明。    
+如同`switch`语句,编译器会判断`catch`子句是否被遗漏。如果catch没有被遗漏，则认为错误被处理。否则，错误会自动传播出包含作用域,被一个封闭的`catch`语句或抛出函数处理掉，包含函数必须以`throws`关键字声明。    
 
-为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，catch子句会匹配和结合任何错误本地命名常量错误。有关可在catch子句中使用了图纹的更多信息，请参阅模式。    
+    
 
 为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，`catch`子句会匹配和约束任何局部变量命名的`error`。有关在`catch`子句中使用模式的更多信息，详见[模式](TODO)。    
 
 关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。       
 
-> do 语句语法  → **do** *[代码块](TODO) [catch子句](TODO)*    
-> catch子句  → *[catch子句](TODO) [catch子句](TODO)*    
-> catch子句  → **catch** **[模式](TODO)** *可选的* [where子句]() *可选的* [代码块](TODO)
+> do 语句语法  → **do** *[*代码块*](..\chapter3\05_Declarations.html#code_block) [catch](TODO)*    
+> catch  → *[catch子句](TODO) [catch子句](TODO)*    
+> catch  → **catch** *[*模式*](..\chapter3\07_Patterns.html#pattern)** *可选的* [*where*]() *可选的*  [*代码块*](..\chapter3\05_Declarations.html#code_block)
 
 
 

From f0cf0960da31fe2675511e425d3cba45df2575c1 Mon Sep 17 00:00:00 2001
From: miaosiqi <1336225019@qq.com>
Date: Sun, 5 Jul 2015 10:49:02 +0800
Subject: [PATCH 079/228] Update 09_Summary_of_the_Grammar.md

---
 source/chapter3/09_Summary_of_the_Grammar.md | 561 +++++++++++++------
 1 file changed, 380 insertions(+), 181 deletions(-)

diff --git a/source/chapter3/09_Summary_of_the_Grammar.md b/source/chapter3/09_Summary_of_the_Grammar.md
index 2e307e09..f6440c63 100755
--- a/source/chapter3/09_Summary_of_the_Grammar.md
+++ b/source/chapter3/09_Summary_of_the_Grammar.md
@@ -1,5 +1,5 @@
 > 翻译：[stanzhai](https://github.com/stanzhai)  
-> 校对：[xielingwang](https://github.com/xielingwang)
+> 校对：[xielingwang](https://github.com/xielingwang), [miaosiqi](https://github.com/miaosiqi)
 
 # 语法总结
 _________________
@@ -10,7 +10,7 @@ _________________
 * [泛型参数（Generic Parameters and Arguments）](#generic_parameters_and_arguments)
 * [声明（Declarations）](#declarations)
 * [模式（Patterns）](#patterns)
-* [特性（Attributes）](#attributes)
+* [属性（Attributes）](#attributes)
 * [表达式（Expressions）](#expressions)
 * [词法结构（Lexical Structure）](#lexical_structure)
 * [类型（Types）](#types)
@@ -25,6 +25,10 @@ _________________
 > *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_  
 > *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)  
 > *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_  
+> *语句* → [*延迟语句*](TODO) **;** _可选_ 
+
+> *语句* → [*执行语句*](TODO) **;** _可选_ 
+
 > *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_  
 
 <!-- -->
@@ -33,61 +37,89 @@ _________________
 > *循环语句* → [*for语句*](..\chapter3\10_Statements.html#for_statement)  
 > *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement)  
 > *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement)  
-> *循环语句* → [*do-while语句*](..\chapter3\10_Statements.html#do_while_statement)  
+> *循环语句* → [*repeat-while语句*](..\chapter3\10_Statements.html#do_while_statement)  
 
 <!-- -->
 
 > For 循环语法  
 > *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *for语句* → **for** **(** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **)** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)  
+> *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式集*](..\chapter3\04_Expressions.html#expression_list)  
 
 <!-- -->
 
 > For-In 循环语法  
-> *for-in语句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *for-in语句* → **for case** _可选_ [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*where从句*](TODO) _可选_
 
 <!-- -->
 
 > While 循环语法  
-> *while语句* → **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *while条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)  
+> *while语句* → **while** [*条件从句*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *条件从句* → [*表达式*](TODO)
+
+> *条件从句* → [*表达式*](TODO) *,* [*表达式集*]()
+
+>*条件从句* → [*表达式集*](TODO)
+
+> *条件从句* → [*可用条件 (availability-condition*)](TODO) *|* [*表达式集*]()
+
+> *条件集* → [*条件*](TODO) *|* [*条件*](TODO) *,* [*条件集*]()
+
+> *条件* → [*可用条件(availability-condition)*](TODO) *|* [*个例条件(case-condition)*](TODO) *|* [*可选绑定条件(optional-binding-condition)*](TODO)
+
+> *个例条件(case-condition)* → **case** [*模式*](TODO) [*构造器*](TODO) [*where从句*](TODO)_可选_ 
+
+> *可选绑定条件(optional-binding-condition)* → [*可选绑定头(optional-binding-head)*](TODO) [*可选绑定连续集(optional-binding-continuation-list)*](TODO) _可选_ [*where从句*](TODO) _可选_
+
+> *可选绑定头(optional-binding-head)* → **let** [*模式 构造器*](TODO) *|* **var**  [*模式 构造器*](TODO)
+
+> *可选绑定连续集(optional-binding-contiuation-list)* → [*可选绑定连续(optional-binding-contiuation)*](TODO) *|* [*可选绑定连续(optional-binding-contiuation)*](TODO) *，* [*可选绑定连续集(optional-binding-contiuation-list)*](TODO)
+
+> *可选绑定连续(optional-binding-continuation)* → [*模式 构造器*](TODO) *|* [*可选绑定头(optional-binding-head)*](TODO) 
 
 <!-- -->
-
-> Do-While 循环语法  
-> *do-while语句* → **do** [*代码块*](..\chapter3\05_Declarations.html#code_block) **while** [*while条件*](..\chapter3\10_Statements.html#while_condition)  
+> Repeat-While语句语法
+*repeat-while-statement* → **repeat** [*代码块*](TODO) **while** [*表达式*](TODO)  
 
 <!-- -->
 
 > 分支语句语法  
-> *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement)  
+> *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement) 
+
+> *分支语句* → [*guard语句*](TODO)  
+
 > *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement)  
 
 <!-- -->
 
 > If语句语法  
-> *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else子句(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_  
-> *if条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)  
-> *else子句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)  
+> *if语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else从句(Clause)*](TODO) _可选_  
+ 
+> *else从句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)  
 
+
+<!-- -->
+>Guard 语句语法
+>*guard语句* → **guard** [*条件从句*](TODO) **else** [*代码块*](TODO) 
+
+ 
 <!-- -->
 
 > Switch语句语法  
-> *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}**  
-> *SwitchCase列表* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_  
+> *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}**  
+> *SwitchCase集* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase集*](..\chapter3\10_Statements.html#switch_cases) _可选_  
 > *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default标签*](..\chapter3\10_Statements.html#default_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements)  
 > *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) **;** | [*default标签*](..\chapter3\10_Statements.html#default_label) **;**  
-> *case标签* → **case** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) **:**  
-> *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](..\chapter3\10_Statements.html#case_item_list)  
+> *case标签* → **case** [*case项集*](..\chapter3\10_Statements.html#case_item_list) **:**  
+> *case项集* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*where-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*where-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项集*](..\chapter3\10_Statements.html#case_item_list)  
 > *default标签* → **default** **:**  
-> *guard-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression)  
-> *guard-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *where从句* → **where** [*where表达式*](TODO)  
+> *where表达式* → [*表达式*](TODO)  
 
 <!-- -->
 
 > 标记语句语法  
-> *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*switch语句*](..\chapter3\10_Statements.html#switch_statement)  
+> *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*if语句*](..\chapter3\10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch语句*](TODY) 
 > *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:**  
 > *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
 
@@ -97,7 +129,8 @@ _________________
 > *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement)  
 > *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement)  
 > *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement)  
-> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement)  
+> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement) 
+> *控制传递语句* → [*throw语句*](TODO) 
 
 <!-- -->
 
@@ -119,27 +152,71 @@ _________________
 > Return 语句语法  
 > *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_  
 
+<!-- -->
+>可用条件(Availability Condition)语法
+
+>*可用条件(availability-condition)* → **#available** **(** [*多可用参数*(availability-arguments)](TODO) **)** 
+
+>*多可用参数(availability- arguments)* → [*可用参数(availability-argument)*](TODO)|[*可用参数(availability-argument)*](TODO) , [多可用参数(availability-arguments)](TODO)
+
+>*可用参数(availability- argument)* → [*平台名(platform-name)*](TODO) [*平台版本(platform-version)*](TODO)
+
+>*可用参数(availability- argument)* → *
+
+>*平台名* → **iOS** | **iOSApplicationExtension**
+
+>*平台名* → **OSX** | **OSXApplicationExtension**
+
+>*平台名* → **watchOS** 
+
+>*平台版本* → [*十进制数(decimal-digits)*](TODO)
+
+>*平台版本* → [*十进制数(decimal-digits)*](TODO) . [*十进制数(decimal-digits)*](TODO) 
+
+>*平台版本* → [*十进制数(decimal-digits)*](TODO) **.** [*十进制数(decimal-digits)*](TODO) **.** [*十进制数（decimal-digits)*](TODO))
+
+<!-- -->
+>抛出语句(Throw Statement)语法
+
+>*抛出语句(throw-statement)* → **throw** [*表达式(expression)*](TODO)
+
+<!-- -->
+>延迟语句 (defer-statement)语法
+
+>*延迟语句(defer-statement)* → **defer** [*代码块*](TODO)
+
+<!-- -->
+>执行语句(do-statement)语法
+
+>*执行语句(do-statement)* → **do** [*代码块*](TODO) [*catch-clauses*](TODO) _可选_
+
+>*catch-clauses* → [*catch-clause*](TODO) [*catch-clauses*](TODO) _可选_
+
+>*catch-clauses* → **catch** [*模式(pattern)*](TODO) _可选_  [*where-clause*](TODO) _可选_ [*代码块(code-block)*](TODO) _可选_
+
+
+
 <a name="generic_parameters_and_arguments"></a>
 ## 泛型参数
 
-> 泛型形参子句(Generic Parameter Clause) 语法  
-> *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**  
-> *泛型参数列表* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list)  
+> 泛型形参从句(Generic Parameter Clause) 语法  
+> *泛型参数从句* → **<** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list) [*约束从句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**  
+> *泛型参数集* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list)  
 > *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name)  
 > *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
 > *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)  
-> *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list)  
-> *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list)  
+> *约束从句* → **where** [*约束集*](GenericParametersAndArguments.html#requirement_list)  
+> *约束集* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束集*](GenericParametersAndArguments.html#requirement_list)  
 > *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement)  
 > *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
 > *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)  
-> *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
+> *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型*](..\chapter3\03_Types.html#type_identifier)  
 
 <!-- -->
 
-> 泛型实参子句语法  
-> *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>**  
-> *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list)  
+> 泛型实参从句语法  
+> *(泛型参数从句Generic Argument Clause)* → **<** [*泛型参数集*](GenericParametersAndArguments.html#generic_argument_list) **>**  
+> *泛型参数集* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数集*](GenericParametersAndArguments.html#generic_argument_list)  
 > *泛型参数* → [*类型*](..\chapter3\03_Types.html#type)  
 
 <a name="declarations"></a>
@@ -160,9 +237,8 @@ _________________
 > *声明* → [*扩展声明*](..\chapter3\05_Declarations.html#extension_declaration)  
 > *声明* → [*下标脚本声明*](..\chapter3\05_Declarations.html#subscript_declaration)  
 > *声明* → [*运算符声明*](..\chapter3\05_Declarations.html#operator_declaration)  
-> *声明(Declarations)列表* → [*声明*](..\chapter3\05_Declarations.html#declaration) [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_  
-> *声明描述符(Specifiers)列表* → [*声明描述符(Specifier)*](..\chapter3\05_Declarations.html#declaration_specifier) [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_  
-> *声明描述符(Specifier)* → **class** | **mutating** | **nonmutating** | **override** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **weak**  
+> *声明(Declarations)集* → [*声明*](..\chapter3\05_Declarations.html#declaration) [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_  
+ 
 
 <!-- -->
 
@@ -177,7 +253,7 @@ _________________
 <!-- -->
 
 > 导入(Import)声明语法  
-> *导入声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **import** [*导入类型*](..\chapter3\05_Declarations.html#import_kind) _可选_ [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
+> *导入声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **import** [*导入类型*](..\chapter3\05_Declarations.html#import_kind) _可选_ [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
 > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**  
 > *导入路径* → [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) | [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) **.** [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
 > *导入路径标识符* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
@@ -185,108 +261,117 @@ _________________
 <!-- -->
 
 > 常数声明语法  
-> *常量声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *模式构造器列表* → [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
+> *常量声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改符(Modifiers)集*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器集*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
+> *模式构造器集* → [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式构造器集*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
 > *模式构造器* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_  
 > *构造器* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
 <!-- -->
 
 > 变量声明语法  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
+> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*模式构造器集*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
 > *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
 > *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
 > *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)  
-> *变量声明头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var**  
+> *变量声明头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改符(Modifers)集*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var**  
 > *变量名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *getter-setter块* → **{** [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) _可选_ **}**  
-> *getter-setter块* → **{** [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) **}**  
-> *getter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **get** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *setter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **set** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *getter-setter块* → **{** [*getter从句*](..\chapter3\05_Declarations.html#getter_clause) [*setter从句*](..\chapter3\05_Declarations.html#setter_clause) _可选_ **}**  
+> *getter-setter块* → **{** [*setter从句*](..\chapter3\05_Declarations.html#setter_clause) [*getter从句*](..\chapter3\05_Declarations.html#getter_clause) **}**  
+> *getter从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **get** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *setter从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **set** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *setter名称* → **(** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **)**  
-> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可选_ **}**  
-> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) **}**  
-> *getter关键字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **get**  
-> *setter关键字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **set**  
-> *willSet-didSet代码块* → **{** [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) _可选_ **}**  
-> *willSet-didSet代码块* → **{** [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) **}**  
-> *willSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *didSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可选_ **}**  
+> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#getter_keyword_clause) **}**  
+> *getter关键字(Keyword)从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **get**  
+> *setter关键字(Keyword)从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **set**  
+> *willSet-didSet代码块* → **{** [*willSet从句*](..\chapter3\05_Declarations.html#willSet_clause) [*didSet从句*](..\chapter3\05_Declarations.html#didSet_clause) _可选_ **}**  
+> *willSet-didSet代码块* → **{** [*didSet从句*](..\chapter3\05_Declarations.html#didSet_clause) [*willSet从句*](..\chapter3\05_Declarations.html#willSet_clause) **}**  
+> *willSet从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *didSet从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 
 <!-- -->
 
 > 类型别名声明语法  
 > *类型别名声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment)  
-> *类型别名头(Head)* → **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name)  
+> *类型别名头(Head)* → [*属性*](TODO) _可选_ [*访问级别修改符(access-level-modifier)*](TODO) **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name)  
 > *类型别名名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
 > *类型别名赋值* → **=** [*类型*](..\chapter3\03_Types.html#type)  
 
 <!-- -->
 
 > 函数声明语法  
-> *函数声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature) [*函数体*](..\chapter3\05_Declarations.html#function_body)  
-> *函数头* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **func**  
+> *函数声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature) [*函数体*](..\chapter3\05_Declarations.html#function_body)  
+> *函数头* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)集*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **func**  
 > *函数名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
-> *函数签名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
-> *函数结果* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *函数签名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **throws** _可选_ [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ 
+
+> *函数签名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
+> *函数结果* → **->** [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
 > *函数体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *parameter-clauses* → [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可选_  
-> *参数子句* → **(** **)** | **(** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list) **...** _可选_ **)**  
-> *参数列表* → [*参数*](..\chapter3\05_Declarations.html#parameter) | [*参数*](..\chapter3\05_Declarations.html#parameter) **,** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list)  
-> *参数* → **inout** _可选_ **let** _可选_ **#** _可选_ [*参数名*](..\chapter3\05_Declarations.html#parameter_name) [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
-> *参数* → **inout** _可选_ **var** **#** _可选_ [*参数名*](..\chapter3\05_Declarations.html#parameter_name) [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
-> *参数* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
-> *参数名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | **_**  
+> *参数从句* → [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可选_  
+> *参数从句* → **(** **)** | **(** [*参数集*](..\chapter3\05_Declarations.html#parameter_list) **...** _可选_ **)**  
+> *参数集* → [*参数*](..\chapter3\05_Declarations.html#parameter) | [*参数*](..\chapter3\05_Declarations.html#parameter) **,** [*参数集*](..\chapter3\05_Declarations.html#parameter_list)  
+> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name) _可选_ [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数从句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → **inout** _可选_ **var** [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name) [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数从句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *外部参数名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | **_**  
 > *本地参数名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | **_**  
-> *默认参数子句* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *默认参数从句* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
 <!-- -->
 
 > 枚举声明语法  
-> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*联合式枚举*](..\chapter3\05_Declarations.html#union_style_enum) | [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*原始值式枚举*](..\chapter3\05_Declarations.html#raw_value_style_enum)  
-> *联合式枚举* → [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
-> *union-style-enum-members* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_  
-> *union-style-enum-member* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case子句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)  
-> *联合式(Union Style)的枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
-> *联合式(Union Style)的枚举case列表* → [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
-> *联合式(Union Style)的case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组类型*](..\chapter3\03_Types.html#tuple_type) _可选_  
+> *枚举声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*联合式枚举*](..\chapter3\05_Declarations.html#union_style_enum) 
+
+> *枚举声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*原始值式枚举(raw-value-style-enum)*](TODO)
+
+> *联合式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句(type-inheritance-clause)*](TODO) _可选_ **{** [*联合样式枚举成员*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
+
+> *联合样式枚举成员* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*联合样式枚举成员*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_  
+
+> *联合样式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case从句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)  
+
+> *联合式(Union Style)的枚举case从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*联合式(Union Style)的枚举case集*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
+> *联合式(Union Style)的枚举case集* → [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举case集*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
+> *联合式(Union Style)的枚举case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组类型*](..\chapter3\03_Types.html#tuple_type) _可选_  
 > *枚举名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
 > *枚举的case名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *原始值式枚举* → [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier) **{** [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_ **}**  
-> *原始值式枚举成员列表* → [*原始值式枚举成员*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_  
-> *原始值式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚举case子句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)  
-> *原始值式枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
-> *原始值式枚举case列表* → [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
+> *原始值式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier) **{** [*原始值式枚举成员集*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_ **}**  
+> *原始值式枚举成员集* → [*原始值式枚举成员*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员集*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_  
+> *原始值式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚举case从句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)  
+> *原始值式枚举case从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case集*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
+> *原始值式枚举case集* → [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case集*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
 > *原始值式枚举case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*原始值赋值*](..\chapter3\05_Declarations.html#raw_value_assignment) _可选_  
-> *原始值赋值* → **=** [*字面量*](..\chapter3\02_Lexical_Structure.html#literal)  
+> *原始值赋值* → **=** [*字面量*](..\chapter3\02_Lexical_Structure.html#literal) 
+> *原始值字面量(raw-value-literal)* → [*数值字面量*](TODO) | [*字符串字面量*](TODO) | [*布尔字面量*](TODO)
 
 <!-- -->
 
 > 结构体声明语法  
-> *结构体声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **struct** [*结构体名称*](..\chapter3\05_Declarations.html#struct_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](..\chapter3\05_Declarations.html#struct_body)  
+> *结构体声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ **struct** [*结构体名称*](..\chapter3\05_Declarations.html#struct_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](..\chapter3\05_Declarations.html#struct_body)  
 > *结构体名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *结构体主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *结构体主体* → **{** [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
 
 <!-- -->
 
 > 类声明语法  
-> *类声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **class** [*类名*](..\chapter3\05_Declarations.html#class_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类主体*](..\chapter3\05_Declarations.html#class_body)  
+> *类声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) **class** [*类名*](..\chapter3\05_Declarations.html#class_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类主体*](..\chapter3\05_Declarations.html#class_body)  
 > *类名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *类主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *类主体* → **{** [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
 
 <!-- -->
 
 > 协议(Protocol)声明语法  
-> *协议声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **protocol** [*协议名*](..\chapter3\05_Declarations.html#protocol_name) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](..\chapter3\05_Declarations.html#protocol_body)  
+> *协议声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_[*访问级别修改器(access-level-modifier)*](TODO)  **protocol** [*协议名*](..\chapter3\05_Declarations.html#protocol_name) [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](..\chapter3\05_Declarations.html#protocol_body)  
 > *协议名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *协议主体* → **{** [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_ **}**  
+> *协议主体* → **{** [*协议成员声明(Declarations)集*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_ **}**  
 > *协议成员声明* → [*协议属性声明*](..\chapter3\05_Declarations.html#protocol_property_declaration)  
 > *协议成员声明* → [*协议方法声明*](..\chapter3\05_Declarations.html#protocol_method_declaration)  
 > *协议成员声明* → [*协议构造器声明*](..\chapter3\05_Declarations.html#protocol_initializer_declaration)  
 > *协议成员声明* → [*协议下标脚本声明*](..\chapter3\05_Declarations.html#protocol_subscript_declaration)  
 > *协议成员声明* → [*协议关联类型声明*](..\chapter3\05_Declarations.html#protocol_associated_type_declaration)  
-> *协议成员声明(Declarations)列表* → [*协议成员声明*](..\chapter3\05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_  
+> *协议成员声明(Declarations)集* → [*协议成员声明*](..\chapter3\05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)集*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_  
 
 <!-- -->
 
@@ -296,12 +381,12 @@ _________________
 <!-- -->
 
 > 协议方法声明语法  
-> *协议方法声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature)  
+> *协议方法声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature)  
 
 <!-- -->
 
 > 协议构造器声明语法  
-> *协议构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)  
+> *协议构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause)  
 
 <!-- -->
 
@@ -311,25 +396,29 @@ _________________
 <!-- -->
 
 > 协议关联类型声明语法  
-> *协议关联类型声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment) _可选_  
+> *协议关联类型声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment) _可选_  
 
 <!-- -->
 
 > 构造器声明语法  
-> *构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*构造器主体*](..\chapter3\05_Declarations.html#initializer_body)  
-> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **convenience** _可选_ **init**  
+> *构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*构造器主体*](..\chapter3\05_Declarations.html#initializer_body)  
+> *构造器头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init**  
+> *构造器头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init ?**
+
+> *构造器头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init !**    
+
 > *构造器主体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 
 <!-- -->
 
 > 析构器声明语法  
-> *析构器声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *析构器声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 
 <!-- -->
 
 > 扩展(Extension)声明语法  
-> *扩展声明* → **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)  
-> *extension-body* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *扩展声明* → [*访问级别修改器*](TODO) _可选_ **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)  
+> *extension-body* → **{** [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
 
 <!-- -->
 
@@ -337,32 +426,51 @@ _________________
 > *下标脚本声明* → [*下标脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *下标脚本声明* → [*下标脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
 > *下标脚本声明* → [*下标脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-> *下标脚本头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **subscript** [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)  
-> *下标脚本结果(Result)* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *下标脚本头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause)  
+> *下标脚本结果(Result)* → **->** [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
 
 <!-- -->
 
 > 运算符声明语法  
 > *运算符声明* → [*前置运算符声明*](..\chapter3\05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](..\chapter3\05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](..\chapter3\05_Declarations.html#infix_operator_declaration)  
-> *前置运算符声明* → **运算符** **prefix** [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**  
-> *后置运算符声明* → **运算符** **postfix** [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**  
-> *中置运算符声明* → **运算符** **infix** [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** [*中置运算符属性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}**  
-> *中置运算符属性* → [*优先级子句*](..\chapter3\05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](..\chapter3\05_Declarations.html#associativity_clause) _可选_  
-> *优先级子句* → **precedence** [*优先级水平*](..\chapter3\05_Declarations.html#precedence_level)  
-> *优先级水平* → 数值 0 到 255  
-> *结和性子句* → **associativity** [*结和性*](..\chapter3\05_Declarations.html#associativity)  
+> *前置运算符声明* → **prefix** **运算符**  [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**  
+> *后置运算符声明* → **postfix** **运算符**  [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**  
+> *中置运算符声明* → **infix** **运算符**  [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** [*中置运算符属性集*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}**  
+> *中置运算符属性集* → [*优先级从句*](..\chapter3\05_Declarations.html#precedence_clause) _可选_ [*结和性从句*](..\chapter3\05_Declarations.html#associativity_clause) _可选_  
+> *优先级从句* → **precedence** [*优先级水平*](..\chapter3\05_Declarations.html#precedence_level)  
+> *优先级水平* → 数值 0 到 255，首末项包括在内 
+> *结和性从句* → **associativity** [*结和性*](..\chapter3\05_Declarations.html#associativity)  
 > *结和性* → **left** | **right** | **none**  
 
+<!-- -->
+声明修改器语法
+> *声明修改器* → **类** | **便捷(convenience)** | **动态(dynamic)** | **final** | **中置(infix)** | **lazy** | **可变(mutating)** | **不可变(nonmutating)** | **可选(optional)** | **改写(override)** | **后置** | **前置** | **required** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **弱(weak)**
+
+> *声明修改器* → [*访问级别声明器(access-level-modifier)*](TODO)
+
+> *声明修改集* → [*声明修改器*](TODO) [*声明修改器集*](TODO) _可选_
+
+> *访问级别修改器* → **内部的** | **内部的(set)** 
+
+> *访问级别修改器* → **私有的** | **私有的(set)** 
+
+> *访问级别修改器* → **公共的** 
+| **公共的(set)** 
+
+> *访问级别修改器集* →[*访问级别修改器*](TODO) [*访问级别修改器集*](TODO) _可选_ 
+
 <a name="patterns"></a>
 ## 模式
 
 > 模式(Patterns) 语法  
 > *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
-> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_  
+> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati Value Bindingon ) _可选_  
 > *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)  
 > *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
-> *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern)  
-> *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern)  
+ 
+> *模式* → [*枚举个例模式*](..\chapter3\07_Patterns.html#enum_case_pattern)  
+> *模式* → [*可选模式*](TODO) 
+> *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern)  
 > *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)  
 
 <!-- -->
@@ -383,19 +491,24 @@ _________________
 <!-- -->
 
 > 元组模式语法  
-> *元组模式* → **(** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可选_ **)**  
-> *元组模式元素列表* → [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)  
+> *元组模式* → **(** [*元组模式元素集*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可选_ **)**  
+> *元组模式元素集* → [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素集*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)  
 > *元组模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern)  
 
 <!-- -->
 
 > 枚举用例模式语法  
-> *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_  
+> *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_ 
+
+<!-- -->
+> 可选模式语法
+> *可选模式* → [*识别符模式*](TODO) **?**
+
 
 <!-- -->
 
 > 类型转换模式语法  
-> *type-casting-pattern* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern)  
+> *类型转换模式(type-casting-pattern)* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern)  
 > *is模式* → **is** [*类型*](..\chapter3\03_Types.html#type)  
 > *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*类型*](..\chapter3\03_Types.html#type)  
 
@@ -405,17 +518,17 @@ _________________
 > *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
 <a name="attributes"></a>
-## 特性
+## 属性
 
-> 特性语法  
-> *特色* → **@** [*特性名*](..\chapter3\06_Attributes.html#attribute_name) [*特性参数子句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可选_  
-> *特性名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *特性参数子句* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
-> *特性(Attributes)列表* → [*特色*](..\chapter3\06_Attributes.html#attribute) [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_  
-> *平衡令牌列表* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_  
-> *平衡令牌* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
-> *平衡令牌* → **[** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **]**  
-> *平衡令牌* → **{** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **}**  
+> 属性语法  
+> *属性* → **@** [*属性名*](..\chapter3\06_Attributes.html#attribute_name) [*属性参数从句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可选_  
+> *属性名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *属性参数从句* → **(** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
+> *属性(Attributes)集* → [*属性*](..\chapter3\06_Attributes.html#attribute) [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_  
+> *平衡令牌集* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_  
+> *平衡令牌* → **(** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
+> *平衡令牌* → **[** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **]**  
+> *平衡令牌* → **{** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **}**  
 > *平衡令牌* → **任意标识符, 关键字, 字面量或运算符**  
 > *平衡令牌* → **任意标点除了(, ), [, ], {, 或 }**
 
@@ -423,24 +536,29 @@ _________________
 ## 表达式
 
 > 表达式语法  
-> *表达式* → [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
-> *表达式列表* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*表达式*](..\chapter3\04_Expressions.html#expression) **,** [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)  
+> *表达式* → [*try-operator*](TODO) _可选_ [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) [*二元表达式集*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
+> *表达式集* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*表达式*](..\chapter3\04_Expressions.html#expression) **,** [*表达式集*](..\chapter3\04_Expressions.html#expression_list)  
 
 <!-- -->
 
 > 前置表达式语法  
 > *前置表达式* → [*前置运算符*](..\chapter3\02_Lexical_Structure.html#prefix_operator) _可选_ [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression)  
 > *前置表达式* → [*写入写出(in-out)表达式*](..\chapter3\04_Expressions.html#in_out_expression)  
-> *写入写出(in-out)表达式* → **&** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *写入写出(in-out)表达式* → **&** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) 
+
+<!-- -->
+> try表达式语法
+> *try-operator* → **try** | **try !**  
+
 
 <!-- -->
 
 > 二元表达式语法  
 > *二元表达式* → [*二元运算符*](..\chapter3\02_Lexical_Structure.html#binary_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*赋值运算符*](..\chapter3\04_Expressions.html#assignment_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*条件运算符*](..\chapter3\04_Expressions.html#conditional_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*赋值运算符*](..\chapter3\04_Expressions.html#assignment_operator) [*try运算符*](TODO) _可选_ [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*条件运算符*](..\chapter3\04_Expressions.html#conditional_operator) [*try运算符*](TODO) _可选_ [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
 > *二元表达式* → [*类型转换运算符*](..\chapter3\04_Expressions.html#type_casting_operator)  
-> *二元表达式列表* → [*二元表达式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
+> *二元表达式集* → [*二元表达式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表达式集*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
 
 <!-- -->
 
@@ -455,12 +573,20 @@ _________________
 <!-- -->
 
 > 类型转换运算符语法  
-> *类型转换运算符* → **is** [*类型*](..\chapter3\03_Types.html#type) | **as** **?** _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *类型转换运算符* → **is** [*类型*](..\chapter3\03_Types.html#type) 
+
+> *类型转换运算符* → **as** [*类型*](..\chapter3\03_Types.html#type) 
+
+> *类型转换运算符* → **as ?** [*类型*](..\chapter3\03_Types.html#type) 
+
+> *类型转换运算符* → **as !** [*类型*](..\chapter3\03_Types.html#type) 
+
+
 
 <!-- -->
 
 > 主表达式语法  
-> *主表达式* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
+> *主表达式* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
 > *主表达式* → [*字面量表达式*](..\chapter3\04_Expressions.html#literal_expression)  
 > *主表达式* → [*self表达式*](..\chapter3\04_Expressions.html#self_expression)  
 > *主表达式* → [*超类表达式*](..\chapter3\04_Expressions.html#superclass_expression)  
@@ -475,11 +601,11 @@ _________________
 > *字面量表达式* → [*字面量*](..\chapter3\02_Lexical_Structure.html#literal)  
 > *字面量表达式* → [*数组字面量*](..\chapter3\04_Expressions.html#array_literal) | [*字典字面量*](..\chapter3\04_Expressions.html#dictionary_literal)  
 > *字面量表达式* → **&#95;&#95;FILE&#95;&#95;** | **&#95;&#95;LINE&#95;&#95;** | **&#95;&#95;COLUMN&#95;&#95;** | **&#95;&#95;FUNCTION&#95;&#95;**  
-> *数组字面量* → **[** [*数组字面量项列表*](..\chapter3\04_Expressions.html#array_literal_items) _可选_ **]**  
-> *数组字面量项列表* → [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** [*数组字面量项列表*](..\chapter3\04_Expressions.html#array_literal_items)  
+> *数组字面量* → **[** [*数组字面量项集*](..\chapter3\04_Expressions.html#array_literal_items) _可选_ **]**  
+> *数组字面量项集* → [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** [*数组字面量项集*](..\chapter3\04_Expressions.html#array_literal_items)  
 > *数组字面量项* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
-> *字典字面量* → **[** [*字典字面量项列表*](..\chapter3\04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**  
-> *字典字面量项列表* → [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项列表*](..\chapter3\04_Expressions.html#dictionary_literal_items)  
+> *字典字面量* → **[** [*字典字面量项集*](..\chapter3\04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**  
+> *字典字面量项集* → [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项集*](..\chapter3\04_Expressions.html#dictionary_literal_items)  
 > *字典字面量项* → [*表达式*](..\chapter3\04_Expressions.html#expression) **:** [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
 <!-- -->
@@ -502,12 +628,12 @@ _________________
 
 > 闭包表达式语法  
 > *闭包表达式* → **{** [*闭包签名(Signational)*](..\chapter3\04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) **}**  
-> *闭包签名(Signational)* → [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*标识符列表*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*标识符列表*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) **in**  
-> *捕获(Capature)列表* → **[** [*捕获(Capature)说明符*](..\chapter3\04_Expressions.html#capture_specifier) [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
+> *闭包签名(Signational)* → [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*标识符集*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)集*](..\chapter3\04_Expressions.html#capture_list) [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)集*](..\chapter3\04_Expressions.html#capture_list) [*标识符集*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)集*](..\chapter3\04_Expressions.html#capture_list) **in**  
+> *捕获(Capature)集* → **[** [*捕获(Capature)说明符*](..\chapter3\04_Expressions.html#capture_specifier) [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
 > *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**  
 
 <!-- -->
@@ -518,8 +644,8 @@ _________________
 <!-- -->
 
 > 圆括号表达式(Parenthesized Expression)语法  
-> *圆括号表达式* → **(** [*表达式元素列表*](..\chapter3\04_Expressions.html#expression_element_list) _可选_ **)**  
-> *表达式元素列表* → [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) | [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) **,** [*表达式元素列表*](..\chapter3\04_Expressions.html#expression_element_list)  
+> *圆括号表达式* → **(** [*表达式元素集*](..\chapter3\04_Expressions.html#expression_element_list) _可选_ **)**  
+> *表达式元素集* → [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) | [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) **,** [*表达式元素集*](..\chapter3\04_Expressions.html#expression_element_list)  
 > *表达式元素* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **:** [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
 <!-- -->
@@ -557,7 +683,7 @@ _________________
 
 > 显式成员表达式语法  
 > *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit)  
-> *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
+> *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
 
 <!-- -->
 
@@ -572,7 +698,7 @@ _________________
 <!-- -->
 
 > 附属脚本表达式语法  
-> *附属脚本表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **[** [*表达式列表*](..\chapter3\04_Expressions.html#expression_list) **]**  
+> *附属脚本表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **[** [*表达式集*](..\chapter3\04_Expressions.html#expression_list) **]**  
 
 <!-- -->
 
@@ -588,11 +714,14 @@ _________________
 ## 词法结构
 
 > 标识符语法  
-> *标识符* → [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*标识符字符列表*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
-> *标识符* → **`** [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*标识符字符列表*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_ **`**  
+> *标识符* → [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*标识符字符集*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
+> *标识符* → [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*标识符字符集*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
 > *标识符* → [*隐式参数名*](..\chapter3\02_Lexical_Structure.html#implicit_parameter_name)  
-> *标识符列表* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **,** [*标识符列表*](..\chapter3\02_Lexical_Structure.html#identifier_list)  
-> *标识符头(Head)* → Upper- or lowercase letter A through Z  
+> *标识符集* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **,** [*标识符集*](..\chapter3\02_Lexical_Structure.html#identifier_list)  
+> *标识符头(Head)* → Upper- or lowercase letter A through Z
+
+> *标识符头(Head)* → _
+
 > *标识符头(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA  
 > *标识符头(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF  
 > *标识符头(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF  
@@ -610,13 +739,19 @@ _________________
 > *标识符字符* → 数值 0 到 9  
 > *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F  
 > *标识符字符* → [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head)  
-> *标识符字符列表* → [*标识符字符*](..\chapter3\02_Lexical_Structure.html#identifier_character) [*标识符字符列表*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
-> *隐式参数名* → **$** [*十进制数字列表*](..\chapter3\02_Lexical_Structure.html#decimal_digits)  
+> *标识符字符集* → [*标识符字符*](..\chapter3\02_Lexical_Structure.html#identifier_character) [*标识符字符集*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
+> *隐式参数名* → **$** [*十进制数字集*](..\chapter3\02_Lexical_Structure.html#decimal_digits)  
 
 <!-- -->
 
 > 字面量语法  
-> *字面量* → [*整型字面量*](..\chapter3\02_Lexical_Structure.html#integer_literal) | [*浮点数字面量*](..\chapter3\02_Lexical_Structure.html#floating_point_literal) | [*字符串字面量*](..\chapter3\02_Lexical_Structure.html#string_literal)  
+> *字面量* → [*数值型字面量*](..\chapter3\02_Lexical_Structure.html#integer_literal) | [*字符串字面量*](..\chapter3\02_Lexical_Structure.html#floating_point_literal) | [*布尔字面量*](..\chapter3\02_Lexical_Structure.html#string_literal) | [*空字面量*](TODO) 
+
+> *数值型字面量* → **-** _可选_ [*整形字面量*](TODO) | **-** _可选_ [*浮点型字面量*](TODO)
+
+> *布尔字面量* → **true** | **false**
+
+> *空字面量* → **nil**
 
 <!-- -->
 
@@ -625,23 +760,23 @@ _________________
 > *整型字面量* → [*八进制字面量*](..\chapter3\02_Lexical_Structure.html#octal_literal)  
 > *整型字面量* → [*十进制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)  
 > *整型字面量* → [*十六进制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)  
-> *二进制字面量* → **0b** [*二进制数字*](..\chapter3\02_Lexical_Structure.html#binary_digit) [*二进制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可选_  
+> *二进制字面量* → **0b** [*二进制数字*](..\chapter3\02_Lexical_Structure.html#binary_digit) [*二进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可选_  
 > *二进制数字* → 数值 0 到 1  
 > *二进制字面量字符* → [*二进制数字*](..\chapter3\02_Lexical_Structure.html#binary_digit) | **_**  
-> *二进制字面量字符列表* → [*二进制字面量字符*](..\chapter3\02_Lexical_Structure.html#binary_literal_character) [*二进制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可选_  
-> *八进制字面量* → **0o** [*八进字数字*](..\chapter3\02_Lexical_Structure.html#octal_digit) [*八进制字符列表*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可选_  
+> *二进制字面量字符集* → [*二进制字面量字符*](..\chapter3\02_Lexical_Structure.html#binary_literal_character) [*二进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可选_  
+> *八进制字面量* → **0o** [*八进制数字*](..\chapter3\02_Lexical_Structure.html#octal_digit) [*八进制字符集*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可选_  
 > *八进字数字* → 数值 0 到 7  
-> *八进制字符* → [*八进字数字*](..\chapter3\02_Lexical_Structure.html#octal_digit) | **_**  
-> *八进制字符列表* → [*八进制字符*](..\chapter3\02_Lexical_Structure.html#octal_literal_character) [*八进制字符列表*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可选_  
-> *十进制字面量* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十进制字符列表*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可选_  
+> *八进制字符* → [*八进制数字*](..\chapter3\02_Lexical_Structure.html#octal_digit) | **_**  
+> *八进制字符集* → [*八进制字符*](..\chapter3\02_Lexical_Structure.html#octal_literal_character) [*八进制字符集*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可选_  
+> *十进制字面量* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十进制字符集*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可选_  
 > *十进制数字* → 数值 0 到 9  
-> *十进制数字列表* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十进制数字列表*](..\chapter3\02_Lexical_Structure.html#decimal_digits) _可选_  
-> *十进制字符* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) | **_**  
-> *十进制字符列表* → [*十进制字符*](..\chapter3\02_Lexical_Structure.html#decimal_literal_character) [*十进制字符列表*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可选_  
-> *十六进制字面量* → **0x** [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
+> *十进制数字集* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十进制数字集*](..\chapter3\02_Lexical_Structure.html#decimal_digits) _可选_  
+> *十进制字面量字符* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) | **_**  
+> *十进制字面量字符集* → [*十进制字面量字符*](..\chapter3\02_Lexical_Structure.html#decimal_literal_character) [*十进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可选_  
+> *十六进制字面量* → **0x** [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
 > *十六进制数字* → 数值 0 到 9, a through f, or A through F  
 > *十六进制字符* → [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) | **_**  
-> *十六进制字面量字符列表* → [*十六进制字符*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_character) [*十六进制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
+> *十六进制字面量字符集* → [*十六进制字符*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_character) [*十六进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
 
 <!-- -->
 
@@ -650,7 +785,8 @@ _________________
 > *浮点数字面量* → [*十六进制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal) [*十六进制分数*](..\chapter3\02_Lexical_Structure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](..\chapter3\02_Lexical_Structure.html#hexadecimal_exponent)  
 > *十进制分数* → **.** [*十进制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)  
 > *十进制指数* → [*浮点数e*](..\chapter3\02_Lexical_Structure.html#floating_point_e) [*正负号*](..\chapter3\02_Lexical_Structure.html#sign) _可选_ [*十进制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)  
-> *十六进制分数* → **.** [*十六进制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal) _可选_  
+> *十六进制分数* → **.** [*十六进制数*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)   
+ [*十六进制字面量字符集*](TODO)_可选_  
 > *十六进制指数* → [*浮点数p*](..\chapter3\02_Lexical_Structure.html#floating_point_p) [*正负号*](..\chapter3\02_Lexical_Structure.html#sign) _可选_ [*十六进制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)  
 > *浮点数e* → **e** | **E**  
 > *浮点数p* → **p** | **P**  
@@ -658,22 +794,72 @@ _________________
 
 <!-- -->
 
-> 字符型字面量语法  
+> 字符串型字面量语法  
 > *字符串字面量* → **"** [*引用文本*](..\chapter3\02_Lexical_Structure.html#quoted_text) **"**  
 > *引用文本* → [*引用文本条目*](..\chapter3\02_Lexical_Structure.html#quoted_text_item) [*引用文本*](..\chapter3\02_Lexical_Structure.html#quoted_text) _可选_  
 > *引用文本条目* → [*转义字符*](..\chapter3\02_Lexical_Structure.html#escaped_character)  
-> *引用文本条目* → **\(** [*表达式*](..\chapter3\04_Expressions.html#expression) **)**  
+> *引用文本条目* → **(** [*表达式*](..\chapter3\04_Expressions.html#expression) **)**  
 > *引用文本条目* → 除了"­, \­, U+000A, or U+000D的所有Unicode的字符  
 > *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**  
-> *转义字符* → **\x** [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit)  
-> *转义字符* → **\u** [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit)  
-> *转义字符* → **\U** [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit)  
+> *转义字符* → **\u** **{** [*十六进制标量数字集*](TODO) **}**   
+> *unicode标量数字集* → Between one and eight hexadecimal digits
 
 <!-- -->
 
 > 运算符语法语法  
-> *运算符* → [*运算符字符*](..\chapter3\02_Lexical_Structure.html#operator_character) [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) _可选_  
-> *运算符字符* → **/** | **=** | **-** | **+** | **!** | **&#42;** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.**  
+> *运算符* → [*运算符头*](..\chapter3\02_Lexical_Structure.html#operator_character) [*运算符字符集*](..\chapter3\02_Lexical_Structure.html#operator) _可选_
+> *运算符* → [*点运算符头*](TODO) [*点运算符字符集*](TODO) _可选_  
+> *运算符字符* → **/** | **=** | **-** | **+** | **!** | **&#42;** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **?**  
+> *运算符头* → U+00A1–U+00A7
+
+> *运算符头* → U+00A9 or U+00AB
+
+> *运算符头* →  U+00AC or U+00AE
+
+> *运算符头* → U+00B0–U+00B1, U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7
+
+> *运算符头* → U+2016–U+2017 or U+2020–U+2027
+
+> *运算符头* → U+2030–U+203E
+
+> *运算符头* → U+2041–U+2053
+
+> *运算符头* → U+2055–U+205E
+
+> *运算符头* → U+2190–U+23FF
+
+> *运算符头* → U+2500–U+2775
+
+> *运算符头* → U+2794–U+2BFF
+
+> *运算符头* → U+2E00–U+2E7F
+
+> *运算符头* → U+3001–U+3003
+
+> *运算符头* → U+3008–U+3030
+
+> *运算符字符* → [*运算符头*](TODO)
+
+> *运算符字符* → U+0300–U+036F
+
+> *运算符字符* → U+1DC0–U+1DFF
+
+> *运算符字符* → U+20D0–U+20FF
+
+> *运算符字符* → U+FE00–U+FE0F
+
+> *运算符字符* → U+FE20–U+FE2F
+
+> *运算符字符* → U+E0100–U+E01EF
+
+> *运算符字符集* → [*运算符字符*](TODO) [*运算符字符集*](TODO)_可选_
+
+> *点运算符头* → **..** 
+
+> *点运算符字符* → **.** | [*运算符字符*](TODO)
+
+> *点运算符字符集* → [*点运算符字符*](TODO) [*点运算符字符集*](TODO) _可选_
+ 
 > *二元运算符* → [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
 > *前置运算符* → [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
 > *后置运算符* → [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
@@ -682,37 +868,42 @@ _________________
 ## 类型
 
 > 类型语法  
-> *类型* → [*数组类型*](..\chapter3\03_Types.html#array_type) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type)  
+> *类型* → [*数组类型*](..\chapter3\03_Types.html#array_type) | [*字典类型*](TODO) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识符*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type)  
 
 <!-- -->
 
 > 类型注解语法  
-> *类型注解* → **:** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *类型注解* → **:** [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
 
 <!-- -->
 
 > 类型标识语法  
-> *类型标识* → [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
-> *类名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *类型标识* → [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识符*](..\chapter3\03_Types.html#type_identifier)  
+> *类型名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
 
 <!-- -->
 
 > 元组类型语法  
 > *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)**  
-> *元组类型主体* → [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_  
-> *元组类型的元素列表* → [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list)  
-> *元组类型的元素* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](..\chapter3\03_Types.html#type) | **inout** _可选_ [*元素名*](..\chapter3\03_Types.html#element_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation)  
+> *元组类型主体* → [*元组类型的元素集*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_  
+> *元组类型的元素集* → [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元组类型的元素集*](..\chapter3\03_Types.html#tuple_type_element_list)  
+> *元组类型的元素* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](..\chapter3\03_Types.html#type) | **inout** _可选_ [*元素名*](..\chapter3\03_Types.html#element_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation)  
 > *元素名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
 
 <!-- -->
 
 > 函数类型语法  
-> *函数类型* → [*类型*](..\chapter3\03_Types.html#type) **->** [*类型*](..\chapter3\03_Types.html#type)  
+> *函数类型* → [*类型*](..\chapter3\03_Types.html#type)  **throws** _可选_ **->** [*类型*](..\chapter3\03_Types.html#type)  
+> *函数类型* → [*类型*](TODO)  **rethrows** **->** [*类型*](TODO) 
 
 <!-- -->
 
 > 数组类型语法  
-> *数组类型* → [*类型*](..\chapter3\03_Types.html#type) **[** **]** | [*数组类型*](..\chapter3\03_Types.html#array_type) **[** **]**  
+> *数组类型* → **[** [*类型*](..\chapter3\03_Types.html#array_type) **]**  
+
+<!-- -->
+> 字典类型语法
+> *字典类型* → **[** [*类型 **:** 类型*](TODO) **]**
 
 <!-- -->
 
@@ -727,9 +918,9 @@ _________________
 <!-- -->
 
 > 协议合成类型语法  
-> *协议合成类型* → **protocol** **<** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>**  
-> *协议标识符列表* → [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) | [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list)  
-> *协议标识符* → [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
+> *协议合成类型* → **protocol** **<** [*协议标识符集*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>**  
+> *协议标识符集* → [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) | [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*协议标识符集*](..\chapter3\03_Types.html#protocol_identifier_list)  
+> *协议标识符* → [*类型标识符*](..\chapter3\03_Types.html#type_identifier)  
 
 <!-- -->
 
@@ -738,6 +929,14 @@ _________________
 
 <!-- -->
 
-> 类型继承子句语法  
-> *类型继承子句* → **:** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)  
-> *类型继承列表* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)
+> 类型继承从句语法  
+
+> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) **,** [*类型继承集*](..\chapter3\03_Types.html#type_inheritance_list) 
+
+> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) 
+
+> *类型继承从句* → **:** [*类型继承集*](TODO)  
+
+> *类型继承集* → [*类型标识符*](..\chapter3\03_Types.html#type_identifier) | [*类型标识符*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承集*](..\chapter3\03_Types.html#type_inheritance_list)
+
+> *类条件* → **class** 

From c1d845819ebbaab72d98eb980b3ac905dd294170 Mon Sep 17 00:00:00 2001
From: DianQK <songsong@songsongdeMacBook-Air.local>
Date: Sun, 5 Jul 2015 15:59:10 +0800
Subject: [PATCH 080/228] update String and Characters

---
 source/chapter2/03_Strings_and_Characters.md | 826 ++++++++++++-------
 1 file changed, 540 insertions(+), 286 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 0a3edf6c..13d5dd3d 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -2,89 +2,67 @@
 > 校对：[Hawstein](https://github.com/Hawstein)
 
 # 字符串和字符（Strings and Characters）
------------------
+---
 
 本页包含内容：
 
-- [字符串字面量](#string_literals)
-- [初始化空字符串](#initializing_an_empty_string)
-- [字符串可变性](#string_mutability)
-- [字符串是值类型](#strings_are_value_types)
-- [使用字符](#working_with_characters)
-- [计算字符数量](#counting_characters)
-- [连接字符串和字符](#concatenating_strings_and_characters)
-- [字符串插值](#string_interpolation)
-- [比较字符串](#comparing_strings)
-- [字符串大小写](#uppercase_and_lowercase_strings)
-- [Unicode](#unicode)
+- [字符串字面量](#string_literals)
+- [初始化空字符串](#initializing_an_empty_string)
+- [字符串可变性](#string_mutability)
+- [字符串是值类型](#strings_are_value_types)
+- [使用字符](#working_with_characters)
+- [连接字符串和字符](#concatenating_strings_and_characters)
+- [字符串插值](#string_interpolation)
+- [Unicode](#unicode)
+- [计算字符数量](#counting_characters)
+- [访问和修改字符串](#accessing_and_modifying_a_string)
+- [比较字符串](#comparing_strings)
+- [字符串的 Unicode 表示形式](#unicode_representations_of_strings)
 
-`String`是例如"hello, world"，"海贼王"这样的有序的`Character`（字符）类型的值的集合，通过`String`类型来表示。
 
-Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
-创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。
-字符串连接操作只需要简单地通过`+`号将两个字符串相连即可。
+`String`是例如"hello, world"，"albatross"这样的有序的`Character`（字符）类型的值的集合，通过`String`类型来表示。
+Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本。
+创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。
+字符串连接操作只需要简单地通过`+`符号将两个字符串相连即可。
 与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
+尽管语法简易，但`String`类型是一种快速、现代化的字符串实现。
+每一个字符串都是由编码无关的 Unicode 字符组成，并支持访问字符的多种 Unicode 表示形式（representations）。
+你也可以在常量、变量、字面量和表达式中进行字符串插值操作，这可以帮助你轻松创建用于展示、存储和打印的自定义字符串。
 
-尽管语法简易，但`String`类型是一种快速、现代化的字符串实现。
-每一个字符串都是由独立编码的 Unicode 字符组成，并提供了以不同 Unicode 表示（representations）来访问这些字符的支持。
-
-Swift 可以在常量、变量、字面量和表达式中进行字符串插值操作，可以轻松创建用于展示、存储和打印的自定义字符串。
-
-> 注意：  
-Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作。所有`NSString` API 都可以调用您创建的任意`String`类型的值。除此之外，还可以使用本章介绍的`String`特性。您也可以在任意要求传入`NSString`实例作为参数的 API 中使用`String`类型的值作为替代。
->更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 [Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。  
+> 注意：  
+> Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。就像 [AnyObject](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TypeCasting.html#//apple_ref/doc/uid/TP40014097-CH22-ID343) 中提到的一样，在使用 Cocoa 中的 Foundation 框架时，您可以将创建的任何字符串的值转换成`NSString`，并调用任意的`NSString` API。您也可以在任意要求传入`NSString`实例作为参数的 API 中用`String`类型的值代替。
+> 更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 *[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)*。  
+
+
 
 <a name="string_literals"></a>
 ## 字符串字面量（String Literals）
 
-您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。
-字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
-
-字符串字面量可以用于为常量和变量提供初始值。
-
-```swift
-let someString = "Some string literal value"
-```
-
-> 注意：  
-`someString`常量通过字符串字面量进行初始化，Swift 因此推断该常量为`String`类型。
-
-字符串字面量可以包含以下特殊字符：
-
-* 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
-* Unicode 标量，写成`\u{n}`(u为小写)，其中`n`为任意的一到八位十六进制数。
-
-下面的代码为各种特殊字符的使用示例。
-`wiseWords`常量包含了两个转移特殊字符 (双括号)；
-`dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量：
-
-```swift
-let wiseWords = "\"我是要成为海贼王的男人\" - 路飞"
-// "我是要成为海贼王的男人" - 路飞
-let dollarSign = "\u{24}"             // $,  Unicode 标量 U+0024
-let blackHeart = "\u{2665}"           // ♥,  Unicode 标量 U+2665
-let sparklingHeart = "\u{1F496}"  // 💖, Unicode 标量 U+1F496
-```
+您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。   
+字符串字面量可以用于为常量和变量提供初始值：
+```let someString = "Some string literal value"```
+注意`someString`常量通过字符串字面量进行初始化，Swift 会推断该常量为`String`类型。
+> 注意：
+> 更多关于在字面量的特殊字符，请查看 [Special Characters in String Literals](#special_characters_in_string_literals) 。   
+
 
 <a name="initializing_an_empty_string"></a>
 ## 初始化空字符串 (Initializing an Empty String)
 
-为了构造一个很长的字符串，可以创建一个空字符串作为初始值。
-可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：
-
-```swift
-var emptyString = ""               // 空字符串字面量
-var anotherEmptyString = String()  // 初始化 String 实例
-// 两个字符串均为空并等价。
+要创建一个空字符串作为初始值，可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：   
+ 
+```
+var emptyString = ""               // 空字符串字面量
+var anotherEmptyString = String()  // 初始化方法
+// 两个字符串均为空并等价。
 ```
 
-您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：
-
-```swift
-if emptyString.isEmpty {
-    println("什么都没有")
-}
-// 打印输出："什么都没有"
+您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：   
+```
+if emptyString.isEmpty {
+    print("Nothing to see here")
+}
+// 打印输出："Nothing to see here"
 ```
 
 <a name="string_mutability"></a>
@@ -92,28 +70,28 @@ if emptyString.isEmpty {
 
 您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
 
-```swift
-var variableString = "Horse"
-variableString += " and carriage"
-// variableString 现在为 "Horse and carriage"
-let constantString = "Highlander"
-constantString += " and another Highlander"
-// 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。
+```
+var variableString = "Horse"
+variableString += " and carriage"
+// variableString 现在为 "Horse and carriage"
+let constantString = "Highlander"
+constantString += " and another Highlander"
+// 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。
 ```
 
-> 注意：  
-在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。
+> 注意：   
+> 在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改。
 
 <a name="strings_are_value_types"></a>
 ## 字符串是值类型（Strings Are Value Types）
 
-Swift 的`String`类型是值类型。
-如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。
+Swift 的`String`类型是值类型。
+如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。
 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。
-值类型在 [结构体和枚举是值类型](09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了说明。
+值类型在 [结构体和枚举是值类型](09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了详细描述。
 
-> 注意：  
-与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
+> 注意：  
+> 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
 
 Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。
 很明显无论该值来自于哪里，都是您独自拥有的。
@@ -124,85 +102,77 @@ Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字
 <a name="working_with_characters"></a>
 ## 使用字符（Working with Characters）
 
-Swift 的`String`类型表示特定序列的`Character`（字符） 类型值的集合。
-每一个字符值代表一个 Unicode 字符。
-您可利用`for-in`循环来遍历字符串中的每一个字符：
+您可通过`for-in`循环来遍历字符串中的`characters`属性来获取每一个字符的值：
 
-```swift
-for character in "Dog!🐶" {
-    println(character)
-}
-// D
-// o
-// g
-// !
-// 🐶
+```
+for character in "Dog!🐶".characters {
+    print(character)
+}
+// D
+// o
+// g
+// !
+// 🐶
 ```
 
 for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细描述。
 
-另外，通过标明一个`Character`类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量：
-
-```swift
-let yenSign: Character = "¥"
-```
-
-<a name="counting_characters"></a>
-## 计算字符数量 (Counting Characters)
-
-通过调用全局`count(_:)`函数，并将字符串作为参数进行传递，可以获取该字符串的字符数量。
-
-```swift
-let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
-println("unusualMenagerie has \(count(unusualMenagerie)) characters")
-// 打印输出："unusualMenagerie has 40 characters"
-```
-
-> 注意：  
-不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意`countElements`函数必须遍历字符串中的字符以精准计算字符串的长度。
-> 另外需要注意的是通过`countElements`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，`NSString`的`length`属性在被 Swift 的`String`访问时会成为`utf16count`。  
+另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量：
 
+```
+let exclamationMark: Charater = "!"
+```   
+字符串可以通过传递一个值类型为`Charater`的数组作为自变量来初始化：
+
+```
+let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
+let catString = String(catCharacters)
+print(catString)
+// 打印输出："Cat!🐱"
+```
+
 <a name="concatenating_strings_and_characters"></a>
 ## 连接字符串和字符 (Concatenating Strings and Characters)
 
-字符串可以通过加法运算符（`+`）相加在一起（或称“串联”）并创建一个新的字符串：
+字符串可以通过加法运算符（`+`）相加在一起（或称“连接”）创建一个新的字符串：
 
-```swift
-let string1 = "hello"
-let string2 = " there"
-var welcome = string1 +　string2
-// welcome 现在等于 "hello there"
+```
+let string1 = "hello"
+let string2 = " there"
+var welcome = string1 +　string2
+// welcome 现在等于 "hello there"
 ```
 
 您也可以通过加法赋值运算符 (`+=`) 将一个字符串添加到一个已经存在字符串变量上：
 
-```swift
-var instruction = "look over"
-instruction += string2
-// instruction 现在等于　"look over there"
+```
+var instruction = "look over"
+instruction += string2
+// instruction 现在等于　"look over there" 
+```   
 
-```
-你可以用将`append`方法将一个字符附加到一个字符串变量的尾部：
+您可以用`append`方法将一个字符附加到一个字符串变量的尾部：
 
-```swift
-let exclamationMark: Character = "!"
-welcome.append(exclamationMark)
-// welcome 现在等于 "hello there!"
+```
+let exclamationMark: Character = "!"
+welcome.append(exclamationMark)
+// welcome 现在等于 "hello there!"
 ```
 
-> 注意：  
-您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
-
+> 注意：  
+> 您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。   
+
+
 <a name="string_interpolation"></a>
 ## 字符串插值 (String Interpolation)
 
 字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。
-您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
+您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中：
 
-```swift
-let multiplier = 3
-let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"
-// message 是 "3 乘以 2.5 是 7.5"
+```
+let multiplier = 3
+let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
+// message 是 "3 times 2.5 is 7.5"
 ```
 
 在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串字面量中。
@@ -212,199 +182,483 @@ let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"
 该表达式计算`Double(multiplier) * 2.5`的值并将结果 (7.5) 插入到字符串中。
 在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
 
-> 注意：  
-插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。
+> 注意：  
+> 插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。   
+
 
-<a name="comparing_strings"></a>
-## 比较字符串 (Comparing Strings)
-
-Swift 提供了三种方式来比较字符串的值：字符串相等、前缀相等和后缀相等。
-
-<a name="string_equality"></a>
-### 字符串相等 (String Equality)
-
-如果两个字符串以同一顺序包含完全相同的字符，则认为两者字符串相等：
-
-```swift
-let quotation = "我们是一样一样滴."
-let sameQuotation = "我们是一样一样滴."
-if quotation == sameQuotation {
-    println("这两个字符串被认为是相同的")
-}
-// 打印输出："这两个字符串被认为是相同的"
-```
-
-<a name="prefix_and_suffix_equality"></a>
-### 前缀/后缀相等 (Prefix and Suffix Equality)
-
-通过调用字符串的`hasPrefix`/`hasSuffix`方法来检查字符串是否拥有特定前缀/后缀。
-两个方法均需要以字符串作为参数传入并传出`Boolean`值。
-两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
-
-下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
-
-```swift
-let romeoAndJuliet = [
-    "Act 1 Scene 1: Verona, A public place",
-    "Act 1 Scene 2: Capulet's mansion",
-    "Act 1 Scene 3: A room in Capulet's mansion",
-    "Act 1 Scene 4: A street outside Capulet's mansion",
-    "Act 1 Scene 5: The Great Hall in Capulet's mansion",
-    "Act 2 Scene 1: Outside Capulet's mansion",
-    "Act 2 Scene 2: Capulet's orchard",
-    "Act 2 Scene 3: Outside Friar Lawrence's cell",
-    "Act 2 Scene 4: A street in Verona",
-    "Act 2 Scene 5: Capulet's mansion",
-    "Act 2 Scene 6: Friar Lawrence's cell"
-]
-```
-
-您可以利用`hasPrefix`方法来计算话剧中第一幕的场景数：
-
-```swift
-var act1SceneCount = 0
-for scene in romeoAndJuliet {
-    if scene.hasPrefix("Act 1 ") {
-        ++act1SceneCount
-    }
-}
-println("There are \(act1SceneCount) scenes in Act 1")
-// 打印输出："There are 5 scenes in Act 1"
-```
-
-相似地，您可以用`hasSuffix`方法来计算发生在不同地方的场景数：
-
-```swift
-var mansionCount = 0
-var cellCount = 0
-for scene in romeoAndJuliet {
-    if scene.hasSuffix("Capulet's mansion") {
-        ++mansionCount
-    } else if scene.hasSuffix("Friar Lawrence's cell") {
-        ++cellCount
-    }
-}
-println("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
-// 打印输出："6 mansion scenes; 2 cell scenes"
-```
-
-<a name="uppercase_and_lowercase_strings"></a>
-### 大写和小写字符串（Uppercase and Lowercase Strings）
-
-您可以通过字符串的`uppercaseString`和`lowercaseString`属性来访问大写/小写版本的字符串。
-
-```swift
-import Foundation
-
-let normal = "Could you help me, please?"
-let shouty = normal.uppercaseString
-// shouty 值为 "COULD YOU HELP ME, PLEASE?"
-let whispered = normal.lowercaseString
-// whispered 值为 "could you help me, please?"
-```
-
-<a name="unicode"></a>
+<a name="unicode"></a>   
 ## Unicode
 
 Unicode 是一个国际标准，用于文本的编码和表示。
 它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
+Swift 的字符串和字符类型是完全兼容 Unicode 标准的。  
+
+<a name="unicode_scalars"></a>   
+### Unicode 标量（Unicode Scalars）   
 
-Swift 的字符串和字符类型是完全兼容 Unicode 标准的，它支持如下所述的一系列不同的 Unicode 编码。
+Swift 的`String`类型是基于 *Unicode 标量* 建立的。
+Unicode 标量是对应字符的唯一21位数字或者修饰符，例如`U+0061`表示小写的拉丁字母(`LATIN SMALL LETTER A`)("`a`")，`U+1F425`表示小鸡表情(`FRONT-FACING BABY CHICK`) ("`🐥`")   
+> 注意：   
+> Unicode *码位(code poing)* 的范围是`U+0000`到`U+D7FF`或者`U+E000`到`U+10FFFF`。Unicode 标量不包括 Unicode *代理项(surrogate pair)* 码位，其码位范围是`U+D800`到`U+DFFF`。
+
+注意不是所有的21位 Unicode 标量都代表一个字符，因为有一些标量是保留给未来分配的。已经代表一个典型字符的标量都有自己的名字，例如上面例子中的`LATIN SMALL LETTER A`和`FRONT-FACING BABY CHICK`。   
+
+<a name="special_characters_in_string_literals"></a>   
+### 字符串字面量的特殊字符 (Special Characters in String Literals)   
 
-<a name="unicode_terminology"></a>
-### Unicode 术语（Unicode Terminology）
+字符串字面量可以包含以下特殊字符：
 
-Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
-字符的 unicode 标量是一个唯一的21位数字(和名称)，例如`U+0061`表示小写的拉丁字母A ("a")，`U+1F425`表示小鸡表情 ("🐥")
+* 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
+* Unicode 标量，写成`\u{n}`(u为小写)，其中`n`为任意一到八位十六进制数且可用的 Unicode 位码。
 
-当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括`UTF-8`（以8位代码单元进行编码） 和`UTF-16`（以16位代码单元进行编码）。
+下面的代码为各种特殊字符的使用示例。
+`wiseWords`常量包含了两个双引号；
+`dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量：
+
+```
+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
+```   
+
+<a name="extended_grapheme_clusters"></a>  
+### 可扩展的字形群集(Extended Grapheme Clusters)   
+每一个 Swift 的`Character`类型代表一个可扩展的字形群。
+一个可扩展的字形群是一个或者更多可生成人类可读的字符 Unicode 标量的有序排列。   
+举个例子，字母 é 可以用单一的 Unicode 标量 é (`LATIN SMALL LETTER E WITH ACUTE`, 或者`U+00E9`)来表示。然而一个标准的字母 e (`LATIN SMALL LETTER E`或者`U+0065`) 加上一个急促重音(`COMBINING ACTUE ACCENT`)的标量(`U+0301`)，这样一对标量就表示了同样的字母 é。
+这个急促重音的标量形象的将 e 转换成了 é。   
+在这两种情况中，字母 é 代表了一个单一的 Swift 的字符串，同时代表了一个可扩展的字形群。
+在第一种情况，这个字形群包含一个单一标量；而在第二种情况，它是包含两个标量的字形群：   
+
+```
+let eAcute: Character = "\u{E9}"                         // é
+let combinedEAcute: Character = "\u{65}\u{301}"          // e 后面加上  ́
+// eAcute 是 é, combinedEAcute 是 é
+```   
+
+可扩展的字符群集是一个灵活的方法，用许多复杂的脚本字符表示单一字符。
+例如，来自朝鲜语字母表的韩语音节能表示为组合或分解的有序排列。
+在 Swift 都会表示为同一个单一的字符：   
+
+
+```
+let precomposed: Character = "\u{D55C}"                  // 한
+let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
+// precomposed 是 한, decomposed 是 한
+```   
+
+可拓展的字符群集可以使包围记号(例如`COMBINING ENCLOSING CIRCLE`或者`U+20DD`)的标量包围其他 Unicode 标量，作为一个单一的字符： 
+
+```
+let enclosedEAcute: Character = "\u{E9}\u{20DD}"
+// enclosedEAcute 是 é⃝
+```  
+
+局部的指示符号的 Unicode 标量可以组合成一个单一的字符，例如 `REGIONAL INDICATOR SYMBOL LETTER U`(`U+1F1FA`)和`REGIONAL INDICATOR SYMBOL LETTER S`(`U+1F1F8`)：   
+
+
+```
+let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
+// regionalIndicatorForUS 是 🇺🇸
+```
+
+<a name="counting_characters"></a>
+## 计算字符数量 (Counting Characters)
+
+调用字符串的`count`属性，就可以获取一个字符串的字符数量：
+
+
+```
+let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
+print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
+// 打印输出："unusualMenagerie has 40 characters"
+```
+
+注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。   
+例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 `COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是 é ，而不是 e ：
+
+```
+var word = "cafe"
+print("the number of characters in \(word) is \(word.characters.count)")
+// 打印输出 "the number of characters in cafe is 4"
+word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301
+print("the number of characters in \(word) is \(word.characters.count)")
+// 打印输出 "the number of characters in café is 4"
+```
+
+> 注意：  
+> 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`characters`属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
+> 另外需要注意的是通过`characters`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。   
+
+
+<a name="accessing_and_modifying_a_string"></a>   
+## 访问和修改字符串 (Accessing and Modifying a String)   
+你可以通字符串的属性和方法来访问和读取一个它，当然也可以用下标语法完成。   
+
+<a name="string_indices"></a>
+### 字符串索引 (String Indices)   
+每一个字符串都有一个关联的索引(*index*)类型，`String.index`，它对应着字符串中的每一个字符的位置。   
+前面提到，不同的字符可能会占用不同的内存空间数量，所以要知道字符的确定位置，就必须从字符串开头遍历每一个 Unicode 标量到字符串结尾。因此，Swift 的字符串不能用整数(integer)做索引。   
+使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后一个字符的末尾位置。如果字符串是空值，`startIndex`和`endIndex`是相等的。   
+通过调用`String.Index`的`predecessor()`方法，可以立即得到前面一个索引，调用`successor()`方法可以立即得到后面一个索引。任何一个字符串的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用`advance(start:n:)`函数来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误。   
+你可以使用下标语法来访问字符在字符串的确切索引。尝试获取出界的字符串索引，仍然抛出一个运行时错误。   
+
+```
+let greeting = "Guten Tag"
+greeting[greeting.startIndex]
+// G
+greeting[greeting.endIndex.predecessor()]
+// g
+greeting[greeting.startIndex.successor()]
+// u
+let index = advance(greeting.startIndex, 7)
+greeting[index]
+// a
+greeting[greeting.endIndex] // 错误
+greeting.endIndex.successor() // 错误
+```   
+
+使用`characters`属性的`indices`会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问分立的字符。  
+ 
+```
+for index in greeting.characters.indices {
+    print("\(greeting[index]) ", appendNewline: false)
+}
+// 打印输出 "G u t e n   T a g !"
+```   
+
+<a name="inserting_and_removing"></a>   
+### 插入和删除 (Inserting and Removing)   
+调用`insert(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符。   
+
+```
+var welcome = "hello"
+welcome.insert("!", atIndex: welcome.endIndex)
+// welcome now 现在等于 "hello!"   
+```   
+
+调用`splice(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符串。   
+
+```
+welcome.splice(" there".characters, atIndex: welcome.endIndex.predecessor())
+// welcome 现在等于 "hello there!"
+```    
+
+调用`removeAtIndex(_:)`方法可以在一个字符串的指定索引删除一个字符。   
+
+```
+welcome.removeAtIndex(welcome.endIndex.predecessor())
+// welcome 现在等于 "hello there"
+// 翻译的人解释：最后还有一个换行符，所以这里删除的是 !
+```   
+
+调用`removeRange(_:)`方法可以在一个字符串的指定索引删除一个子字符串。   
+
+```
+let range = advance(welcome.endIndex, -6)..<welcome.endIndex
+welcome.removeRange(range)
+// welcome 现在等于 "hello"
+```
+
+
+<a name="comparing_strings"></a>
+## 比较字符串 (Comparing Strings)
+
+Swift 提供了三种方式来比较文本值：字符串字符相等、前缀相等和后缀相等。
+
+<a name="string_and_character_equality"></a>
+### 字符串/字符相等 (String and Character Equality)   
+字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在 [Comparison Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-ID70)：
+
+```
+let quotation = "We're a lot alike, you and I."
+let sameQuotation = "We're a lot alike, you and I."
+if quotation == sameQuotation {
+    print("These two strings are considered equal")
+}
+// 打印输出 "These two strings are considered equal"
+```   
+
+如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。   
+例如，`LATIN SMALL LETTER E WITH ACUTE`(`U+00E9`)就是标准相等于`LATIN SMALL LETTER E`(`U+0065`)后面加上`COMBINING ACUTE ACCENT`(`U+0301`)。这两个字符群集都有效的表示字符 é ，所以它们被认为是标准相等的：   
+
+```
+// "Voulez-vous un café?" 使用 LATIN SMALL LETTER E WITH ACUTE
+let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
+// "Voulez-vous un café?" 使用 LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
+let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"
+if eAcuteQuestion == combinedEAcuteQuestion {
+    print("These two strings are considered equal")
+}
+// 打印输出 "These two strings are considered equal"
+```   
+
+相反，英语中的`LATIN CAPITAL LETTER A`(`U+0401`，或者`A`)不等于俄语中的`CYRILLIC CAPITAL LETTER A`(`U+0410`，或者`A`)。两个字符看着是一样的，但却有不同的语言意义：   
+
+```
+let latinCapitalLetterA: Character = "\u{41}"
+let cyrillicCapitalLetterA: Character = "\u{0410}"
+if latinCapitalLetterA != cyrillicCapitalLetterA {
+    print("These two characters are not equivalent")
+}
+// 打印 "These two characters are not equivalent"
+```   
+
+> 注意：
+> 在 Swift 中，字符串和字符并不区分区域。   
+
+
+<a name="prefix_and_suffix_equality"></a>
+### 前缀/后缀相等 (Prefix and Suffix Equality)
+
+通过调用字符串的`hasPrefix(_:)`/`hasSuffix(_:)`方法来检查字符串是否拥有特定前缀/后缀，两个方法均需要以字符串作为参数传入并传出`Boolean`值。   
+下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
+
+```
+let romeoAndJuliet = [
+    "Act 1 Scene 1: Verona, A public place",
+    "Act 1 Scene 2: Capulet's mansion",
+    "Act 1 Scene 3: A room in Capulet's mansion",
+    "Act 1 Scene 4: A street outside Capulet's mansion",
+    "Act 1 Scene 5: The Great Hall in Capulet's mansion",
+    "Act 2 Scene 1: Outside Capulet's mansion",
+    "Act 2 Scene 2: Capulet's orchard",
+    "Act 2 Scene 3: Outside Friar Lawrence's cell",
+    "Act 2 Scene 4: A street in Verona",
+    "Act 2 Scene 5: Capulet's mansion",
+    "Act 2 Scene 6: Friar Lawrence's cell"
+]
+```
+
+您可以调用`hasPrefix(_:)`方法来计算话剧中第一幕的场景数：
+
+```
+var act1SceneCount = 0
+for scene in romeoAndJuliet {
+    if scene.hasPrefix("Act 1 ") {
+        ++act1SceneCount
+    }
+}
+print("There are \(act1SceneCount) scenes in Act 1")
+// 打印输出 "There are 5 scenes in Act 1"
+```
+
+相似地，您可以用`hasSuffix(_:)`方法来计算发生在不同地方的场景数：
+
+```
+var mansionCount = 0
+var cellCount = 0
+for scene in romeoAndJuliet {
+    if scene.hasSuffix("Capulet's mansion") {
+        ++mansionCount
+    } else if scene.hasSuffix("Friar Lawrence's cell") {
+        ++cellCount
+    }
+}
+print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
+// 打印输出 "6 mansion scenes; 2 cell scenes"
+```   
+
+> 注意：
+> `hasPrefix(_:)`和`hasSuffix(_:)`方法都是在每个字符串中一个一个字符的比较其可扩展的字符群集是否标准相等，详细描述在[字符串/字符相等](#string_and_character_equality)。   
+
 
 <a name="unicode_representations_of_strings"></a>
-### 字符串的 Unicode 表示（Unicode Representations of Strings）
+## 字符串的 Unicode 表示形式（Unicode Representations of Strings）   
+当一个 Unicode 字符串被写进文本文件或者其他储存时，字符串中的 Unicode 标量会用 Unicode 定义的几种编码格式编码。每一个字符串中的小块编码都被称为代码单元。这些包括 UTF-8 编码格式（编码字符串为8位的代码单元）， UTF-16 编码格式（编码字符串位16位的代码单元），以及 UTF-32 编码格式（编码字符串32位的代码单元）。
 
-Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。
-
-您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。
+Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。
+您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 可扩展的字符群集的方式访问每一个字符值。
 该过程在 [使用字符](#working_with_characters) 中进行了描述。
 
 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
 
 * UTF-8 代码单元集合 (利用字符串的`utf8`属性进行访问)
 * UTF-16 代码单元集合 (利用字符串的`utf16`属性进行访问)
-* 21位的 Unicode 标量值集合 (利用字符串的`unicodeScalars`属性进行访问)
+* 21位的 Unicode 标量值集合，也就是字符串的 UTF-32 编码格式 (利用字符串的`unicodeScalars`属性进行访问)
 
-下面由`D``o``g``!`和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示：
+下面由`D``o``g``‼`(`DOUBLE EXCLAMATION MARK`, Unicode 标量 `U+203C`)和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示：
 
-```swift
-let dogString = "Dog!🐶"
-```
+```
+let dogString = "Dog‼🐶"
+```   
 
-<a name="UTF-8"></a>
-### UTF-8
 
+<a name="UTF-8_representation"></a>
+### UTF-8 表示   
 您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
-其为`UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
+其为`String.UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：   
+
+<body>
+<center>
+<table style='text-align:center'>
+ <tr height=77>
+  <td>Character</td>
+  <td>D<br>U+0044</td>
+  <td>o<br>U+006F</td>
+  <td>g<br>U+0067</td>
+  <td colspan=3>‼<br>U+1F436</td>
+  <td colspan=4>🐶<br>U+1F436</td>
+ </tr>
+ <tr height=77>
+  <td height=77>UTF-8<br>Code Unit</td>
+  <td>68</td>
+  <td>111</td>
+  <td>103</td>
+  <td>226</td>
+  <td>128</td>
+  <td>188</td>
+  <td>240</td>
+  <td>159</td>
+  <td>144</td>
+  <td>182</td>
+ </tr>
+ <tr>
+  <td height=77>Position</td>
+  <td>0</td>
+  <td>1</td>
+  <td>2</td>
+  <td>3</td>
+  <td>4</td>
+  <td>5</td>
+  <td>6</td>
+  <td>7</td>
+  <td>8</td>
+  <td>9</td>
+ </tr>
+</table>
+</center>
+</body>
 
-```swift
-for codeUnit in dogString.utf8 {
-    print("\(codeUnit) ")
-}
-print("\n")
-// 68 111 103 33 240 159 144 182
+```
+for codeUnit in dogString.utf8 {
+    print("\(codeUnit) ", appendNewline: false)
+}
+print("")
+// 68 111 103 226 128 188 240 159 144 182
 ```
 
-上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，它们的 UTF-8 表示与 ASCII 表示相同。
-后四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。
+上面的例子中，前三个10进制代码单元值 (68, 111, 103) 代表了字符`D`、`o`和 `g`，它们的 UTF-8 表示与 ASCII 表示相同。
+接下来的三个10进制代码单元值 (226, 128, 188) 是`DOUBLE EXCLAMATION MARK`的3字节 UTF-8 表示。
+最后的四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。   
 
-<a name="UTF-16"></a>
-### UTF-16
+
+<a name="UTF-16_representation"></a>
+### UTF-16 表示
 
 您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
-其为`UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
+其为`String.UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：   
+<body>
+<center>
+<table style='text-align:center'>
+ <tr height=77>
+  <td>Character</td>
+  <td>D<br>U+0044</td>
+  <td>o<br>U+006F</td>
+  <td>g<br>U+0067</td>
+  <td>‼<br>U+1F436</td>
+  <td colspan=2>🐶<br>U+1F436</td>
+ </tr>
+ <tr height=77>
+  <td height=77>UTF-16<br>Code Unit</td>
+  <td>68</td>
+  <td>111</td>
+  <td>103</td>
+  <td>8252</td>
+  <td>55357</td>
+  <td>56374</td>
+ </tr>
+ <tr>
+  <td height=77>Position</td>
+  <td>0</td>
+  <td>1</td>
+  <td>2</td>
+  <td>3</td>
+  <td>4</td>
+  <td>5</td>
+ </tr>
+</table>
+</center>
+</body>   
 
-```swift
-for codeUnit in dogString.utf16 {
-    print("\(codeUnit) ")
-}
-print("\n")
-// 68 111 103 33 55357 56374
+
+```
+for codeUnit in dogString.utf16 {
+    print("\(codeUnit) ", appendNewline: false)
+}
+print("")
+// 68 111 103 8252 55357 56374
 ```
 
-同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，它们的 UTF-16 代码单元和 UTF-8 完全相同。
-
-第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
+同样，前三个代码单元值 (68, 111, 103) 代表了字符`D`、`o`和`g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。   
+第四个代码单元值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量值`U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。    
+第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
 第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
 
-<a name="unicode_scalars"></a>
-### Unicode 标量 (Unicode Scalars)
+<a name="unicode_scalars_representation"></a>
+### Unicode 标量表示 (Unicode Scalars Representation)
 
 您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。
 其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。
 `UnicodeScalar`是21位的 Unicode 代码点。
 
-每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示。
+每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示：   
+
+<body>
+<center>
+<table style='text-align:center'>
+ <tr height=77>
+  <td>Character</td>
+  <td>D<br>U+0044</td>
+  <td>o<br>U+006F</td>
+  <td>g<br>U+0067</td>
+  <td>‼<br>U+1F436</td>
+  <td>🐶<br>U+1F436</td>
+ </tr>
+ <tr height=77>
+  <td height=77>UTF-16<br>Code Unit</td>
+  <td>68</td>
+  <td>111</td>
+  <td>103</td>
+  <td>8252</td>
+  <td>128054</td>
+ </tr>
+ <tr>
+  <td height=77>Position</td>
+  <td>0</td>
+  <td>1</td>
+  <td>2</td>
+  <td>3</td>
+  <td>4</td>
+ </tr>
+</table>
+</center>
+</body>   
 
-```swift
-for scalar in dogString.unicodeScalars {
-    print("\(scalar.value) ")
-}
-print("\n")
-// 68 111 103 33 128054
+
+```
+for scalar in dogString.unicodeScalars {
+    print("\(scalar.value) ", appendNewline: false)
+}
+print("")
+// 68 111 103 8252 128054
 ```
 
-同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`。
-第五位数值，128054，是一个十六进制1F436的十进制表示。
-其等同于`DOG FACE`的Unicode 标量 U+1F436。
+前三个代码单元值 (68, 111, 103) 仍然代表字符`D`、`o`和`g`。   
+第四个代码单元值 (8252) 仍然是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量`U+203C`。   
+第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于`DOG FACE`的Unicode 标量`U+1F436`。
 
 作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
 
-```swift
-for scalar in dogString.unicodeScalars {
-    println("\(scalar) ")
-}
-// D
-// o
-// g
-// !
+```
+for scalar in dogString.unicodeScalars {
+    print("\(scalar) ")
+}
+// D
+// o
+// g
+// ‼
 // 🐶
-```
+```    

From 727346de2e5c99201b63fd6081c453d130d47855 Mon Sep 17 00:00:00 2001
From: DianQK <songsong@songsongdeMacBook-Air.local>
Date: Sun, 5 Jul 2015 20:13:32 +0800
Subject: [PATCH 081/228] update Methods
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

add mark “swift” at String and Characters
update Methods
---
 source/chapter2/03_Strings_and_Characters.md |  68 ++++++------
 source/chapter2/11_Methods.md                | 109 +++++++++----------
 2 files changed, 85 insertions(+), 92 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 13d5dd3d..1ad844a4 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -51,14 +51,14 @@ Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 
 
 要创建一个空字符串作为初始值，可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：   
  
-```
+```swift
 var emptyString = ""               // 空字符串字面量
 var anotherEmptyString = String()  // 初始化方法
 // 两个字符串均为空并等价。
 ```
 
 您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：   
-```
+```swift
 if emptyString.isEmpty {
     print("Nothing to see here")
 }
@@ -70,7 +70,7 @@ if emptyString.isEmpty {
 
 您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
 
-```
+```swift
 var variableString = "Horse"
 variableString += " and carriage"
 // variableString 现在为 "Horse and carriage"
@@ -104,7 +104,7 @@ Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字
 
 您可通过`for-in`循环来遍历字符串中的`characters`属性来获取每一个字符的值：
 
-```
+```swift
 for character in "Dog!🐶".characters {
     print(character)
 }
@@ -119,12 +119,12 @@ for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细
 
 另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量：
 
-```
+```swift
 let exclamationMark: Charater = "!"
 ```   
 字符串可以通过传递一个值类型为`Charater`的数组作为自变量来初始化：
 
-```
+```swift
 let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
 let catString = String(catCharacters)
 print(catString)
@@ -136,7 +136,7 @@ print(catString)
 
 字符串可以通过加法运算符（`+`）相加在一起（或称“连接”）创建一个新的字符串：
 
-```
+```swift
 let string1 = "hello"
 let string2 = " there"
 var welcome = string1 +　string2
@@ -145,7 +145,7 @@ var welcome = string1 +　string2
 
 您也可以通过加法赋值运算符 (`+=`) 将一个字符串添加到一个已经存在字符串变量上：
 
-```
+```swift
 var instruction = "look over"
 instruction += string2
 // instruction 现在等于　"look over there" 
@@ -153,7 +153,7 @@ instruction += string2
 
 您可以用`append`方法将一个字符附加到一个字符串变量的尾部：
 
-```
+```swift
 let exclamationMark: Character = "!"
 welcome.append(exclamationMark)
 // welcome 现在等于 "hello there!"
@@ -169,7 +169,7 @@ welcome.append(exclamationMark)
 字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。
 您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中：
 
-```
+```swift
 let multiplier = 3
 let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
 // message 是 "3 times 2.5 is 7.5"
@@ -215,7 +215,7 @@ Unicode 标量是对应字符的唯一21位数字或者修饰符，例如`U+0061
 `wiseWords`常量包含了两个双引号；
 `dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量：
 
-```
+```swift
 let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
 // "Imageination is more important than knowledge" - Enistein
 let dollarSign = "\u{24}"             // $, Unicode 标量 U+0024
@@ -232,7 +232,7 @@ let sparklingHeart = "\u{1F496}"  // 💖, Unicode 标量 U+1F496
 在这两种情况中，字母 é 代表了一个单一的 Swift 的字符串，同时代表了一个可扩展的字形群。
 在第一种情况，这个字形群包含一个单一标量；而在第二种情况，它是包含两个标量的字形群：   
 
-```
+```swift
 let eAcute: Character = "\u{E9}"                         // é
 let combinedEAcute: Character = "\u{65}\u{301}"          // e 后面加上  ́
 // eAcute 是 é, combinedEAcute 是 é
@@ -243,7 +243,7 @@ let combinedEAcute: Character = "\u{65}\u{301}"          // e 后面加上  ́
 在 Swift 都会表示为同一个单一的字符：   
 
 
-```
+```swift
 let precomposed: Character = "\u{D55C}"                  // 한
 let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
 // precomposed 是 한, decomposed 是 한
@@ -251,7 +251,7 @@ let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
 
 可拓展的字符群集可以使包围记号(例如`COMBINING ENCLOSING CIRCLE`或者`U+20DD`)的标量包围其他 Unicode 标量，作为一个单一的字符： 
 
-```
+```swift
 let enclosedEAcute: Character = "\u{E9}\u{20DD}"
 // enclosedEAcute 是 é⃝
 ```  
@@ -259,7 +259,7 @@ let enclosedEAcute: Character = "\u{E9}\u{20DD}"
 局部的指示符号的 Unicode 标量可以组合成一个单一的字符，例如 `REGIONAL INDICATOR SYMBOL LETTER U`(`U+1F1FA`)和`REGIONAL INDICATOR SYMBOL LETTER S`(`U+1F1F8`)：   
 
 
-```
+```swift
 let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
 // regionalIndicatorForUS 是 🇺🇸
 ```
@@ -270,7 +270,7 @@ let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
 调用字符串的`count`属性，就可以获取一个字符串的字符数量：
 
 
-```
+```swift
 let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
 print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
 // 打印输出："unusualMenagerie has 40 characters"
@@ -279,7 +279,7 @@ print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
 注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。   
 例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 `COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是 é ，而不是 e ：
 
-```
+```swift
 var word = "cafe"
 print("the number of characters in \(word) is \(word.characters.count)")
 // 打印输出 "the number of characters in cafe is 4"
@@ -305,7 +305,7 @@ print("the number of characters in \(word) is \(word.characters.count)")
 通过调用`String.Index`的`predecessor()`方法，可以立即得到前面一个索引，调用`successor()`方法可以立即得到后面一个索引。任何一个字符串的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用`advance(start:n:)`函数来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误。   
 你可以使用下标语法来访问字符在字符串的确切索引。尝试获取出界的字符串索引，仍然抛出一个运行时错误。   
 
-```
+```swift
 let greeting = "Guten Tag"
 greeting[greeting.startIndex]
 // G
@@ -322,7 +322,7 @@ greeting.endIndex.successor() // 错误
 
 使用`characters`属性的`indices`会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问分立的字符。  
  
-```
+```swift
 for index in greeting.characters.indices {
     print("\(greeting[index]) ", appendNewline: false)
 }
@@ -333,7 +333,7 @@ for index in greeting.characters.indices {
 ### 插入和删除 (Inserting and Removing)   
 调用`insert(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符。   
 
-```
+```swift
 var welcome = "hello"
 welcome.insert("!", atIndex: welcome.endIndex)
 // welcome now 现在等于 "hello!"   
@@ -341,14 +341,14 @@ welcome.insert("!", atIndex: welcome.endIndex)
 
 调用`splice(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符串。   
 
-```
+```swift
 welcome.splice(" there".characters, atIndex: welcome.endIndex.predecessor())
 // welcome 现在等于 "hello there!"
 ```    
 
 调用`removeAtIndex(_:)`方法可以在一个字符串的指定索引删除一个字符。   
 
-```
+```swift
 welcome.removeAtIndex(welcome.endIndex.predecessor())
 // welcome 现在等于 "hello there"
 // 翻译的人解释：最后还有一个换行符，所以这里删除的是 !
@@ -356,7 +356,7 @@ welcome.removeAtIndex(welcome.endIndex.predecessor())
 
 调用`removeRange(_:)`方法可以在一个字符串的指定索引删除一个子字符串。   
 
-```
+```swift
 let range = advance(welcome.endIndex, -6)..<welcome.endIndex
 welcome.removeRange(range)
 // welcome 现在等于 "hello"
@@ -372,7 +372,7 @@ Swift 提供了三种方式来比较文本值：字符串字符相等、前缀
 ### 字符串/字符相等 (String and Character Equality)   
 字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在 [Comparison Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-ID70)：
 
-```
+```swift
 let quotation = "We're a lot alike, you and I."
 let sameQuotation = "We're a lot alike, you and I."
 if quotation == sameQuotation {
@@ -384,7 +384,7 @@ if quotation == sameQuotation {
 如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。   
 例如，`LATIN SMALL LETTER E WITH ACUTE`(`U+00E9`)就是标准相等于`LATIN SMALL LETTER E`(`U+0065`)后面加上`COMBINING ACUTE ACCENT`(`U+0301`)。这两个字符群集都有效的表示字符 é ，所以它们被认为是标准相等的：   
 
-```
+```swift
 // "Voulez-vous un café?" 使用 LATIN SMALL LETTER E WITH ACUTE
 let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
 // "Voulez-vous un café?" 使用 LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
@@ -397,7 +397,7 @@ if eAcuteQuestion == combinedEAcuteQuestion {
 
 相反，英语中的`LATIN CAPITAL LETTER A`(`U+0401`，或者`A`)不等于俄语中的`CYRILLIC CAPITAL LETTER A`(`U+0410`，或者`A`)。两个字符看着是一样的，但却有不同的语言意义：   
 
-```
+```swift
 let latinCapitalLetterA: Character = "\u{41}"
 let cyrillicCapitalLetterA: Character = "\u{0410}"
 if latinCapitalLetterA != cyrillicCapitalLetterA {
@@ -416,7 +416,7 @@ if latinCapitalLetterA != cyrillicCapitalLetterA {
 通过调用字符串的`hasPrefix(_:)`/`hasSuffix(_:)`方法来检查字符串是否拥有特定前缀/后缀，两个方法均需要以字符串作为参数传入并传出`Boolean`值。   
 下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
 
-```
+```swift
 let romeoAndJuliet = [
     "Act 1 Scene 1: Verona, A public place",
     "Act 1 Scene 2: Capulet's mansion",
@@ -434,7 +434,7 @@ let romeoAndJuliet = [
 
 您可以调用`hasPrefix(_:)`方法来计算话剧中第一幕的场景数：
 
-```
+```swift
 var act1SceneCount = 0
 for scene in romeoAndJuliet {
     if scene.hasPrefix("Act 1 ") {
@@ -447,7 +447,7 @@ print("There are \(act1SceneCount) scenes in Act 1")
 
 相似地，您可以用`hasSuffix(_:)`方法来计算发生在不同地方的场景数：
 
-```
+```swift
 var mansionCount = 0
 var cellCount = 0
 for scene in romeoAndJuliet {
@@ -481,7 +481,7 @@ Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式
 
 下面由`D``o``g``‼`(`DOUBLE EXCLAMATION MARK`, Unicode 标量 `U+203C`)和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示：
 
-```
+```swift
 let dogString = "Dog‼🐶"
 ```   
 
@@ -532,7 +532,7 @@ let dogString = "Dog‼🐶"
 </center>
 </body>
 
-```
+```swift
 for codeUnit in dogString.utf8 {
     print("\(codeUnit) ", appendNewline: false)
 }
@@ -584,7 +584,7 @@ print("")
 </body>   
 
 
-```
+```swift
 for codeUnit in dogString.utf16 {
     print("\(codeUnit) ", appendNewline: false)
 }
@@ -638,7 +638,7 @@ print("")
 </body>   
 
 
-```
+```swift
 for scalar in dogString.unicodeScalars {
     print("\(scalar.value) ", appendNewline: false)
 }
@@ -652,7 +652,7 @@ print("")
 
 作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
 
-```
+```swift
 for scalar in dogString.unicodeScalars {
     print("\(scalar) ")
 }
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index 2f925d5c..ab00d474 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -14,19 +14,19 @@
 结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。
 
 <a name="instance_methods"></a>
-## 实例方法(Instance Methods)
+## 实例方法 (Instance Methods)
 
 **实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](../charpter2/06_Functions.md)。
 
 实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。
 
-下面的例子，定义一个很简单的类`Counter`，`Counter`能被用来对一个动作发生的次数进行计数：
+下面的例子，定义一个很简单的`Counter`类，`Counter`能被用来对一个动作发生的次数进行计数：
 
 ```swift
 class Counter {
   var count = 0
   func increment() {
-    count++
+    ++count
   }
   func incrementBy(amount: Int) {
     count += amount
@@ -60,13 +60,13 @@ class Counter {
 <a name="local_and_external_parameter"></a>
 ### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)
 
-函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。
+函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。
 
-Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。和函数参数不同，对于方法的参数，Swift 使用不同的默认处理方式，这可以让方法命名规范更容易写。
+Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy(_:)`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。   
 
-具体来说，Swift  默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。
+具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称；默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。
 
-看看下面这个`Counter`的另一个版本（它定义了一个更复杂的`incrementBy`方法）：
+看看下面这个`Counter`的另一个版本（它定义了一个更复杂的`incrementBy(_:)`方法）：
 
 ```swift
 class Counter {
@@ -77,35 +77,28 @@ class Counter {
 }
 ```
 
-`incrementBy`方法有两个参数： `amount`和`numberOfTimes`。默认情况下，Swift 只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作局部名称又看作外部名称。下面调用这个方法：
+`incrementBy(_:numverOfTimes:)`方法有两个参数： `amount`和`numberOfTimes`。默认情况下，Swift 只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作局部名称又看作外部名称。下面调用这个方法：
 
 ```swift
 let counter = Counter()
 counter.incrementBy(5, numberOfTimes: 3)
-// counter value is now 15
+// counter 的值现在是 15
 ```
 
-你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。
+你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy(_numberOfTimes:)`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。   
+这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
 
-这种默认的行为能够有效的处理方法（method）,类似于在参数`numberOfTimes`前写一个井号（`#`）：
 
-```swift
-func incrementBy(amount: Int, #numberOfTimes: Int) {
-  count += amount * numberOfTimes
-}
-```
-
-这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
-
-<a name="modifying_external_parameter"></a>
+<a name="modifying_external_parameter_name_behavior_for_methods"></a>
 ### 修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)
 
 有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（`#`）作为第一个参数的前缀来把这个局部名称当作外部名称使用。
 
 相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（`_`）作为该参数的显式外部名称，这样做将覆盖默认行为。
+
 
-<a name="self_property"></a>
-## `self`属性(The self Property)
+<a name="the_self_property"></a>
+### self 属性(The self Property)
 
 类型的每一个实例都有一个隐含属性叫做`self`，`self`完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的`self`属性来引用当前实例。
 
@@ -132,14 +125,14 @@ struct Point {
 }
 let somePoint = Point(x: 4.0, y: 5.0)
 if somePoint.isToTheRightOfX(1.0) {
-  println("This point is to the right of the line where x == 1.0")
+  print("This point is to the right of the line where x == 1.0")
 }
-// 输出 "This point is to the right of the line where x == 1.0"（这个点在x等于1.0这条线的右边）
+// 打印输出: This point is to the right of the line where x == 1.0
 ```
 
 如果不使用`self`前缀，Swift 就认为两次使用的`x`都指的是名称为`x`的函数参数。
 
-<a name="modifying_value_types"></a>
+<a name="modifying_value_types_from_within_instance_methods"></a>
 ### 在实例方法中修改值类型(Modifying Value Types from Within Instance Methods)
 
 结构体和枚举是**值类型**。一般情况下，值类型的属性不能在它的实例方法中被修改。
@@ -158,21 +151,21 @@ struct Point {
 }
 var somePoint = Point(x: 1.0, y: 1.0)
 somePoint.moveByX(2.0, y: 3.0)
-println("The point is now at (\(somePoint.x), \(somePoint.y))")
-// 输出 "The point is now at (3.0, 4.0)"
+print("The point is now at (\(somePoint.x), \(somePoint.y))")
+// 打印输出: "The point is now at (3.0, 4.0)"
 ```
 
-上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX`，`moveByX`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字,这才让方法可以修改值类型的属性。
+上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX(_:y:)`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字，这才让方法可以修改值类型的属性。
 
-注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量](10_Properties.html#global_and_local_variables)
+注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量](10_Properties.html#global_and_local_variables)：
 
 ```swift
 let fixedPoint = Point(x: 3.0, y: 3.0)
 fixedPoint.moveByX(2.0, y: 3.0)
-// this will report an error
+// 这里将会抛出一个错误
 ```
 
-<a name="mutating_method_self"></a>
+<a name="assigning_to_self_within_a_mutating_method"></a>
 ### 在变异方法中给self赋值(Assigning to self Within a Mutating Method)
 
 变异方法能够赋给隐含属性`self`一个全新的实例。上面`Point`的例子可以用下面的方式改写：
@@ -186,7 +179,7 @@ struct Point {
 }
 ```
 
-新版的变异方法`moveByX`创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。
+新版的变异方法`moveByX(_:y:)`创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。
 
 枚举的变异方法可以把`self`设置为相同的枚举类型中不同的成员：
 
@@ -214,9 +207,9 @@ ovenLight.next()
 上面的例子中定义了一个三态开关的枚举。每次调用`next`方法时，开关在不同的电源状态（`Off`，`Low`，`High`）之前循环切换。
 
 <a name="type_methods"></a>
-## 类型方法(Type Methods)
+## 类型方法 (Type Methods)
 
-实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明类的类型方法，在方法的`func`关键字之前加上关键字`class`；声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。
+实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。类可能会用关键字`Class`来允许子类重写父类的实现方法。
 
 > 注意：  
 > 在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。  
@@ -241,23 +234,23 @@ SomeClass.someTypeMethod()
 游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。
 
 ```swift
-struct LevelTracker {
-  static var highestUnlockedLevel = 1
-  static func unlockLevel(level: Int) {
-    if level > highestUnlockedLevel { highestUnlockedLevel = level }
-  }
-  static func levelIsUnlocked(level: Int) -> Bool {
-    return level <= highestUnlockedLevel
-  }
-  var currentLevel = 1
-  mutating func advanceToLevel(level: Int) -> Bool {
-    if LevelTracker.levelIsUnlocked(level) {
-      currentLevel = level
-      return true
-    } else {
-      return false
-    }
-  }
+struct LevelTracker {
+    static var highestUnlockedLevel = 1
+    static func unlockLevel(level: Int) {
+        if level > highestUnlockedLevel { highestUnlockedLevel = level }
+    }
+    static func levelIsUnlocked(level: Int) -> Bool {
+        return level <= highestUnlockedLevel
+    }
+    var currentLevel = 1
+    mutating func advanceToLevel(level: Int) -> Bool {
+        if LevelTracker.levelIsUnlocked(level) {
+            currentLevel = level
+            return true
+        } else {
+            return false
+        }
+    }
 }
 ```
 
@@ -285,25 +278,25 @@ class Player {
 }
 ```
 
-`Player`类创建一个新的`LevelTracker`实例来监测这个用户的发展进度。它提供了`completedLevel`方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）。
+`Player`类创建一个新的`LevelTracker`实例来监测这个用户的进度。它提供了`completedLevel`方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）。
 
 你还可以为一个新的玩家创建一个`Player`的实例，然后看这个玩家完成等级一时发生了什么：
 
 ```swift
 var player = Player(name: "Argyrios")
 player.completedLevel(1)
-println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
-// 输出 "highest unlocked level is now 2"（最高等级现在是2）
+print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
+// 打印输出：highest unlocked level is now 2
 ```
 
-如果你创建了第二个玩家，并尝试让它开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：
+如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：
 
 ```swift
 player = Player(name: "Beto")
 if player.tracker.advanceToLevel(6) {
-  println("player is now on level 6")
+  print("player is now on level 6")
 } else {
-  println("level 6 has not yet been unlocked")
+  print("level 6 has not yet been unlocked")
 }
-// 输出 "level 6 has not yet been unlocked"（等级6还没被解锁）
+// 打印输出：level 6 has not yet been unlocked
 ```

From 566f12872d9a8db1e4b606cad8eea6bef2cbb398 Mon Sep 17 00:00:00 2001
From: shanksyang <shanks@weedo.hk>
Date: Tue, 7 Jul 2015 09:52:59 +0800
Subject: [PATCH 082/228] swift2.0, 21_Extensions, tranlation into Chinese

---
 source/chapter2/21_Extensions.md | 83 ++++++++++++++++----------------
 1 file changed, 41 insertions(+), 42 deletions(-)

diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index 3e085b4a..cbdf946a 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -13,22 +13,24 @@
 - [下标](#subscripts)
 - [嵌套类型](#nested_types)
 
-*扩展*就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与Objective-C不同的是，Swift 的扩展没有名字。）
+*扩展*就是向一个已有的类、结构体、枚举类型或者协议类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与 Objective-C 不同的是，Swift 的扩展没有名字。）
 
 Swift 中的扩展可以：
 
-- 添加计算型属性和计算静态属性
+- 添加计算型属性和计算型静态属性
 - 定义实例方法和类型方法
 - 提供新的构造器
 - 定义下标
 - 定义和使用新的嵌套类型
 - 使一个已有类型符合某个协议
 
+TODO：
+在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](#)获取更多的细节。
 
 >注意：  
-如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
-
+扩展可以对一个类型添加新的功能，但是不能重写已有的功能。
 <a name="extension_syntax"></a>
+
 ## 扩展语法（Extension Syntax）
 
 声明一个扩展使用关键字`extension`：
@@ -38,7 +40,6 @@ extension SomeType {
     // 加到SomeType的新功能写到这里
 }
 ```
-
 一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，协议的名字应该完全按照类或结构体的名字的方式进行书写：
 
 ```swift
@@ -49,10 +50,13 @@ extension SomeType: SomeProtocol, AnotherProctocol {
 
 按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](21_Protocols.html#adding_protocol_conformance_with_an_extension)
 
+>注意：  
+如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
+
 <a name="computed_properties"></a>
 ## 计算型属性（Computed Properties）
 
-扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持。
+扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持：
 
 ```swift
 extension Double {
@@ -84,7 +88,6 @@ println("A marathon is \(aMarathon) meters long")
 // 打印输出："A marathon is 42195.0 meters long"
 ```
 
-
 >注意：  
 扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。
 
@@ -93,14 +96,13 @@ println("A marathon is \(aMarathon) meters long")
 
 扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。  
 
-扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构函数。指定构造器和析构函数必须总是由原始的类实现来提供。
+扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供。
 
 > 注意：  
 如果你使用扩展向一个值类型添加一个构造器，在该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers）时，你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
 >
 正如在[值类型的构造器代理](14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
 
-
 下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值：
 
 ```swift
@@ -115,8 +117,7 @@ struct Rect {
     var size = Size()
 }
 ```
-
-因为结构体`Rect`提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的`Rect`实例：
+因为结构体`Rect`提供了其所有属性的默认值，所以正如[默认构造器](14_Initialization.html#default_initializers)中描述的，它可以自动接受一个默认构造器和一个逐一成员构造器。这些构造器可以用于构造新的`Rect`实例：
 
 ```swift
 let defaultRect = Rect()
@@ -135,8 +136,7 @@ extension Rect {
     }
 }
 ```
-
-这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中：
+这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的逐一成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中：
 
 ```swift
 let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
@@ -250,52 +250,51 @@ extension Int {
 扩展可以向已有的类、结构体和枚举添加新的嵌套类型：
 
 ```swift
-extension Character {
+extension Int {
     enum Kind {
-        case Vowel, Consonant, Other
+        case Negative, Zero, Positive
     }
     var kind: Kind {
-        switch String(self).lowercaseString {
-        case "a", "e", "i", "o", "u":
-            return .Vowel
-        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
-             "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
-            return .Consonant
+        switch self {
+        case 0:
+            return .Zero
+        case let x where x > 0:
+            return .Positive
         default:
-            return .Other
+            return .Negative
         }
     }
 }
 ```
 
-该例子向`Character`添加了新的嵌套枚举。这个名为`Kind`的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。
+该例子向`Int`添加了新的嵌套枚举。这个名为`Kind`的枚举表示特定整数的类型。具体来说，就是表示整数是正数，零或者负数。
 
-这个例子还向`Character`添加了一个新的计算实例属性，即`kind`，用来返回合适的`Kind`枚举成员。
+这个例子还向`Int`添加了一个新的计算实例属性，即`kind`，用来返回合适的`Kind`枚举成员。
+
+现在，这个嵌套枚举可以和一个`Int`值联合使用了：
 
-现在，这个嵌套枚举可以和一个`Character`值联合使用了：
 
 ```swift
-func printLetterKinds(word: String) {
-    println("'\(word)' is made up of the following kinds of letters:")
-    for character in word {
-        switch character.kind {
-        case .Vowel:
-            print("vowel ")
-        case .Consonant:
-            print("consonant ")
-        case .Other:
-            print("other ")
+func printIntegerKinds(numbers: [Int]) {
+    for number in numbers {
+        switch number.kind {
+        case .Negative:
+            print("- ", appendNewline: false)
+        case .Zero:
+            print("0 ", appendNewline: false)
+        case .Positive:
+            print("+ ", appendNewline: false)
         }
     }
-    print("\n")
+    print("")
 }
-printLetterKinds("Hello")
-// 'Hello' is made up of the following kinds of letters:
-// consonant vowel consonant consonant vowel
+printIntegerKinds([3, 19, -27, 0, -6, 0, 7])
+// prints "+ + - 0 - 0 +"
 ```
 
-函数`printLetterKinds`的输入是一个`String`值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的`kind`计算属性，并打印出合适的类别描述。所以`printLetterKinds`就可以用来打印一个完整单词中所有字母的类型，正如上述单词`"hello"`所展示的。
+函数`printIntegerKinds`的输入是一个`Int`数组值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的`kind`计算属性，并打印出合适的类别描述。
+
+>注意：
+由于已知`number.kind `是`Int.Kind`型，所以`Int.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `. Negative`代替`Int.Kind.Negative`。
 
->注意：  
-由于已知`character.kind`是`Character.Kind`型，所以`Character.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `.Vowel`代替`Character.Kind.Vowel`
 

From cf3676cd84f044b7782619b12d5e2da956ceed88 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 19:02:28 +0800
Subject: [PATCH 083/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E7=A4=BA=E4=BE=8B?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81=20println()=20->=20print()?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 52 ++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index d17abb5d..dad93021 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -1,4 +1,4 @@
-> 翻译：[geek5nan](https://github.com/geek5nan)  
+> 翻译：[geek5nan](https://github.com/geek5nan)
 > 校对：[dabing1022](https://github.com/dabing1022)
 
 # 协议
@@ -164,9 +164,9 @@ class LinearCongruentialGenerator: RandomNumberGenerator {
 	}
 }
 let generator = LinearCongruentialGenerator()
-println("Here's a random number: \(generator.random())")
+print("Here's a random number: \(generator.random())")
 // 输出 : "Here's a random number: 0.37464991998171"
-println("And another one: \(generator.random())")
+print("And another one: \(generator.random())")
 // 输出 : "And another one: 0.729023776863283"
 ```
 
@@ -178,7 +178,7 @@ println("And another one: \(generator.random())")
 如果协议中的实例方法打算改变其`遵循者`实例的类型，那么在协议定义时需要在方法前加`mutating`关键字，才能使`结构体，枚举`来采用并满足协议中对方法的规定。
 
 
->注意: 
+>注意:
 >用`类`实现协议中的`mutating`方法时，不用写`mutating`关键字;用`结构体`，`枚举`实现协议中的`mutating`方法时，必须写`mutating`关键字。
 
 如下所示，`Togglable`协议含有名为`toggle`的突变实例方法。根据名称推测，`toggle`方法应该是用于切换或恢复其`遵循者`实例或其属性的类型。
@@ -255,7 +255,7 @@ class SomeSuperClass {
     }
 }
 
- 
+
 class SomeSubClass: SomeSuperClass, SomeProtocol {
     // "required" from SomeProtocol conformance; "override" from SomeSuperClass
     required override init() {
@@ -277,7 +277,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 
 尽管`协议`本身并不实现任何功能，但是`协议`可以被当做类型来使用。
 
-使用场景:  
+使用场景:
 
 * `协议类型`作为函数、方法或构造器中的参数类型或返回值类型
 * `协议类型`作为常量、变量或属性的类型
@@ -314,7 +314,7 @@ class Dice {
 ```swift
 var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
 for _ in 1...5 {
-	println("Random dice roll is \(d6.roll())")
+	print("Random dice roll is \(d6.roll())")
 }
 //输出结果
 //Random dice roll is 3
@@ -333,7 +333,7 @@ for _ in 1...5 {
 
 委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的所属类型(*译者注:只要求外部数据源`遵循`某协议*)。
 
-下文是两个基于骰子游戏的协议: 
+下文是两个基于骰子游戏的协议:
 
 ```swift
 protocol DiceGame {
@@ -349,7 +349,7 @@ protocol DiceGameDelegate {
 ```
 
 `DiceGame`协议可以在任意含有骰子的游戏中实现，`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
-	
+
 如下所示，`SnakesAndLadders`是`Snakes and Ladders`(译者注:[Control Flow](2)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程:
 
 ```swift
@@ -403,16 +403,16 @@ class DiceGameTracker: DiceGameDelegate {
     func gameDidStart(game: DiceGame) {
         numberOfTurns = 0
         if game is SnakesAndLadders {
-            println("Started a new game of Snakes and Ladders")
+            print("Started a new game of Snakes and Ladders")
         }
-        println("The game is using a \(game.dice.sides)-sided dice")
+        print("The game is using a \(game.dice.sides)-sided dice")
     }
     func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {
         ++numberOfTurns
-        println("Rolled a \(diceRoll)")
+        print("Rolled a \(diceRoll)")
     }
     func gameDidEnd(game: DiceGame) {
-        println("The game lasted for \(numberOfTurns) turns")
+        print("The game lasted for \(numberOfTurns) turns")
     }
 }
 ```
@@ -468,7 +468,7 @@ extension Dice: TextRepresentable {
 
 ```swift
 let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
-println(d12.asText())
+print(d12.asText())
 // 输出 "A 12-sided dice"
 ```
 
@@ -480,7 +480,7 @@ extension SnakesAndLadders: TextRepresentable {
 		return "A game of Snakes and Ladders with \(finalSquare) squares"
 	}
 }
-println(game.asText())
+print(game.asText())
 // 输出 "A game of Snakes and Ladders with 25 squares"
 ```
 
@@ -504,7 +504,7 @@ extension Hamster: TextRepresentable {}
 ```swift
 let simonTheHamster = Hamster(name: "Simon")
 let somethingTextRepresentable: TextRepresentable = simonTheHamster
-println(somethingTextRepresentable.asText())
+print(somethingTextRepresentable.asText())
 // 输出 "A hamster named Simon"
 ```
 
@@ -523,7 +523,7 @@ let things: [TextRepresentable] = [game,d12,simonTheHamster]
 
 ```swift
 for thing in things {
-	println(thing.asText())
+	print(thing.asText())
 }
 // A game of Snakes and Ladders with 25 squares
 // A 12-sided dice
@@ -583,7 +583,7 @@ extension SnakesAndLadders: PrettyTextRepresentable {
 任意`SankesAndLadders`的实例都可以使用`asPrettyText()`方法。
 
 ```swift
-println(game.asPrettyText())
+print(game.asPrettyText())
 // A game of Snakes and Ladders with 25 squares:
 // ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
 ```
@@ -624,7 +624,7 @@ struct Person: Named, Aged {
     var age: Int
 }
 func wishHappyBirthday(celebrator: protocol<Named, Aged>) {
-    println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
+    print("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
 }
 let birthdayPerson = Person(name: "Malcolm", age: 21)
 wishHappyBirthday(birthdayPerson)
@@ -642,9 +642,9 @@ wishHappyBirthday(birthdayPerson)
 
 使用`is`和`as`操作符来检查协议的一致性或转化协议类型。检查和转化的语法和之前相同(*详情查看[Typy Casting章节](5)*):
 
-* `is`操作符用来检查实例是否`遵循`了某个`协议`。 
+* `is`操作符用来检查实例是否`遵循`了某个`协议`。
 * `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil`
-* `as`用以强制向下转型。  
+* `as`用以强制向下转型。
 
 ```swift
 @objc protocol HasArea {
@@ -697,9 +697,9 @@ let objects: [AnyObject] = [
 ```swift
 for object in objects {
     if let objectWithArea = object as? HasArea {
-        println("Area is \(objectWithArea.area)")
+        print("Area is \(objectWithArea.area)")
     } else {
-        println("Something that doesn't have an area")
+        print("Something that doesn't have an area")
     }
 }
 // Area is 12.5663708
@@ -754,7 +754,7 @@ for object in objects {
 `count`属性用于存储当前的值，`increment`方法用来为`count`赋值。
 
 `increment`方法通过`可选链`，尝试从两种`可选成员`中获取`count`。
-	
+
 1. 由于`dataSource`可能为`nil`，因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用`incrementForCount`方法。
 
 2. 即使`dataSource`存在，但是也无法保证其是否实现了`incrementForCount`方法，因此在`incrementForCount`方法后边也加有`?`标记
@@ -776,7 +776,7 @@ var counter = Counter()
 counter.dataSource = ThreeSource()
 for _ in 1...4 {
     counter.increment()
-    println(counter.count)
+    print(counter.count)
 }
 // 3
 // 6
@@ -807,7 +807,7 @@ counter.count = -4
 counter.dataSource = TowardsZeroSource()
 for _ in 1...5 {
     counter.increment()
-    println(counter.count)
+    print(counter.count)
 }
 // -3
 // -2

From 8ec0820b5ae2bb3597f45b3fd0ccf6202da16746 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 19:24:30 +0800
Subject: [PATCH 084/228] =?UTF-8?q?=E6=B7=BB=E5=8A=A02.0=E6=96=B0=E5=A2=9E?=
 =?UTF-8?q?=E9=83=A8=E5=88=86=E7=9A=84=E8=8B=B1=E6=96=87=EF=BC=8C=E5=B9=B6?=
 =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E6=B7=BB=E5=8A=A0=E9=83=A8=E5=88=86=E7=9A=84?=
 =?UTF-8?q?md=E6=A0=BC=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 76 +++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index dad93021..3e31a805 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -815,3 +815,79 @@ for _ in 1...5 {
 // 0
 // 0
 ```
+
+## Protocol Extensions
+
+Protocols can be extended to provide method and property implementations to conforming types. This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function.
+
+For example, the `RandomNumberGenerator` protocol can be extended to provide a `randomBool()` method, which uses the result of the required `random()` method to return a random `Bool` value:
+
+```swift
+extension RandomNumberGenerator {
+    func randomBool() -> Bool {
+        return random() > 0.5
+    }
+}
+```
+
+By creating an extension on the protocol, all conforming types automatically gain this method implementation without any additional modification.
+
+```swift
+let generator = LinearCongruentialGenerator()
+print("Here's a random number: \(generator.random())")
+// prints "Here's a random number: 0.37464991998171"
+print("And here's a random Boolean: \(generator.randomBool())")
+// prints "And here's a random Boolean: true"
+```
+
+### Providing Default Implementations
+
+You can use protocol extensions to provide a default implementation to any method or property requirement of that protocol. If a conforming type provides its own implementation of a required method or property, that implementation will be used instead of the one provided by the extension.
+
+> NOTE
+> Protocol requirements with default implementations provided by extensions are distinct from optional protocol requirements. Although conforming types don’t have to provide their own implementation of either, requirements with default implementations can be called without optional chaining.
+
+For example, the `PrettyTextRepresentable` protocol, which inherits the `TextRepresentable` protocol can provide a default implementation of its required `asPrettyText()` method to simply return the result of the `asText()` method:
+
+```swift
+extension PrettyTextRepresentable  {
+    func asPrettyText() -> String {
+        return asText()
+    }
+}
+```
+
+### Adding Constraints to Protocol Extensions
+
+When you define a protocol extension, you can specify constraints that conforming types must satisfy before the methods and properties of the extension are available. You write these constraints after the name of the protocol you’re extending using a `where` clause, as described in ([Where 子句](TODO)).:
+
+For instance, you can define an extension to the `CollectionType` protocol that applies to any collection whose elements conform to the `TextRepresentable protocol` from the example above.
+
+```swift
+extension CollectionType where Generator.Element : TextRepresentable {
+    func asList() -> String {
+        return "(" + ", ".join(map({$0.asText()})) + ")"
+    }
+}
+```
+
+The `asList()` method takes the textual representation of each element in the collection and concatenates them into a comma-separated list.
+
+Consider the `Hamster` structure from before, which conforms to the `TextRepresentable` protocol, and an array of `Hamster` values:
+
+```swift
+let murrayTheHamster = Hamster(name: "Murray")
+let morganTheHamster = Hamster(name: "Morgan")
+let mauriceTheHamster = Hamster(name: "Maurice")
+let hamsters = [murrayTheHamster, morganTheHamster, mauriceTheHamster]
+```
+
+Because `Array` conforms to `CollectionType`, and the array’s elements conform to the `TextRepresentable` protocol, the array can use the `asList()` method to get a textual representation of its contents:
+
+```swift
+print(hamsters.asList())
+// prints "(A hamster named Murray, A hamster named Morgan, A hamster named Maurice)"
+```
+
+> NOTE
+> If a conforming type satisfies the requirements for multiple constrained extensions that provide implementations for the same method or property, Swift will use the implementation corresponding to the most specialized constraints.

From f04c129bd4805b574f5654b81decd7e84e05d3db Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 29 Jun 2015 19:34:04 +0800
Subject: [PATCH 085/228] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=96=B0=E5=86=85?=
 =?UTF-8?q?=E5=AE=B9=E7=9A=84=E7=9B=AE=E5=BD=95=E8=B7=B3=E8=BD=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 3e31a805..6589399d 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -21,6 +21,8 @@
 - [协议合成（Protocol Composition）](#protocol_composition)
 - [检验协议的一致性（Checking for Protocol Conformance）](#checking_for_protocol_conformance)
 - [对可选协议的规定（Optional Protocol Requirements）](#optional_protocol_requirements)
+- [协议扩展（Protocol Extensions）](#protocol_extensions)
+
 
 `协议(Protocol)`用于定义完成某项任务或功能所必须的方法和属性，协议实际上并不提供这些功能或任务的具体`实现(Implementation)`--而只用来描述这些实现应该是什么样的。类，结构体，枚举通过提供协议所要求的方法，属性的具体实现来`采用(adopt)`协议。任意能够满足协议要求的类型被称为协议的`遵循者`。
 
@@ -816,7 +818,8 @@ for _ in 1...5 {
 // 0
 ```
 
-## Protocol Extensions
+<a name="protocol_extensions"></a>
+## 协议扩展
 
 Protocols can be extended to provide method and property implementations to conforming types. This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function.
 

From b19b7764795d0d75254c323242bab7bdd36bc2c6 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 10:39:54 +0800
Subject: [PATCH 086/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E6=A6=82=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 6589399d..c8cdb814 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -24,9 +24,7 @@
 - [协议扩展（Protocol Extensions）](#protocol_extensions)
 
 
-`协议(Protocol)`用于定义完成某项任务或功能所必须的方法和属性，协议实际上并不提供这些功能或任务的具体`实现(Implementation)`--而只用来描述这些实现应该是什么样的。类，结构体，枚举通过提供协议所要求的方法，属性的具体实现来`采用(adopt)`协议。任意能够满足协议要求的类型被称为协议的`遵循者`。
-
-`协议`可以要求其`遵循者`提供特定的实例属性，实例方法，类方法，操作符或下标脚本等。
+`协议`定义了一个蓝图，规定了用来实现某一特定工作或者功能所必需的方法和属性。类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能。任意能够满足协议要求的类型被称为`遵循(conform)`这个协议。
 
 <a name="protocol_syntax"></a>
 ## 协议的语法

From 9bc2388eb2787597459afa0cbf4ce2fa62377d7c Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 10:47:56 +0800
Subject: [PATCH 087/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90Proto?=
 =?UTF-8?q?col=20Syntax?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index c8cdb814..e489cbe4 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -29,7 +29,7 @@
 <a name="protocol_syntax"></a>
 ## 协议的语法
 
-`协议`的定义方式与`类，结构体，枚举`的定义都非常相似，如下所示:
+协议的定义方式与类，结构体，枚举的定义非常相似:
 
 ```swift
 protocol SomeProtocol {
@@ -37,7 +37,7 @@ protocol SomeProtocol {
 }
 ```
 
-在类型名称后加上`协议名称`，中间以冒号`:`分隔即可实现协议；实现多个协议时，各协议之间用逗号`,`分隔，如下所示:
+要使类遵循某个协议，需要在类型名称后加上协议名称，中间以冒号`:`分隔，作为类型定义的一部分。遵循多个协议时，各协议之间用逗号`,`分隔:
 
 ```swift
 struct SomeStructure: FirstProtocol, AnotherProtocol {
@@ -45,7 +45,7 @@ struct SomeStructure: FirstProtocol, AnotherProtocol {
 }
 ```
 
-如果一个类在含有`父类`的同时也采用了协议，应当把`父类`放在所有的`协议`之前，如下所示:
+如果类在遵循协议的同时拥有父类，应该将父类名放在协议名之前，以逗号分隔:
 
 ```swift
 class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {

From a77f878d9960f9af45e21c9a763053a12757fe52 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 10:49:38 +0800
Subject: [PATCH 088/228] =?UTF-8?q?=E6=9B=B4=E6=94=B9Property=20Requiremen?=
 =?UTF-8?q?ts=E7=BF=BB=E8=AF=91->=20=E5=B1=9E=E6=80=A7=E8=A6=81=E6=B1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index e489cbe4..215a500f 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -7,7 +7,7 @@
 本页包含内容：
 
 - [协议的语法（Protocol Syntax）](#protocol_syntax)
-- [对属性的规定（Property Requirements）](#property_requirements)
+- [属性要求（Property Requirements）](#property_requirements)
 - [对方法的规定（Method Requirements）](#method_requirements)
 - [对突变方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
 - [对构造器的规定（Initializer Requirements）](#initializer_requirements)
@@ -54,7 +54,7 @@ class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
 ```
 
 <a name="property_requirements"></a>
-## 对属性的规定
+## 属性要求
 
 协议可以规定其`遵循者`提供特定名称与类型的`实例属性(instance property)`或`类属性(type property)`，而不管其是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外也可以指定属性是只读的还是可读写的。
 

From 8345f80233d163ec9e1c953e0d29f8d0951602f2 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 15:04:44 +0800
Subject: [PATCH 089/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=AF=B9=E5=B1=9E=E6=80=A7=E7=9A=84=E8=A7=84=E5=AE=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 57 +++++++++++++++++----------------
 1 file changed, 29 insertions(+), 28 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 215a500f..ae226e8c 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -7,7 +7,7 @@
 本页包含内容：
 
 - [协议的语法（Protocol Syntax）](#protocol_syntax)
-- [属性要求（Property Requirements）](#property_requirements)
+- [对属性的规定（Property Requirements）](#property_requirements)
 - [对方法的规定（Method Requirements）](#method_requirements)
 - [对突变方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
 - [对构造器的规定（Initializer Requirements）](#initializer_requirements)
@@ -29,7 +29,7 @@
 <a name="protocol_syntax"></a>
 ## 协议的语法
 
-协议的定义方式与类，结构体，枚举的定义非常相似:
+协议的定义方式与类，结构体，枚举的定义非常相似。
 
 ```swift
 protocol SomeProtocol {
@@ -37,7 +37,7 @@ protocol SomeProtocol {
 }
 ```
 
-要使类遵循某个协议，需要在类型名称后加上协议名称，中间以冒号`:`分隔，作为类型定义的一部分。遵循多个协议时，各协议之间用逗号`,`分隔:
+要使类遵循某个协议，需要在类型名称后加上协议名称，中间以冒号`:`分隔，作为类型定义的一部分。遵循多个协议时，各协议之间用逗号`,`分隔。
 
 ```swift
 struct SomeStructure: FirstProtocol, AnotherProtocol {
@@ -45,7 +45,7 @@ struct SomeStructure: FirstProtocol, AnotherProtocol {
 }
 ```
 
-如果类在遵循协议的同时拥有父类，应该将父类名放在协议名之前，以逗号分隔:
+如果类在遵循协议的同时拥有父类，应该将父类名放在协议名之前，以逗号分隔。
 
 ```swift
 class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
@@ -54,13 +54,13 @@ class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
 ```
 
 <a name="property_requirements"></a>
-## 属性要求
+## 对属性的规定
 
-协议可以规定其`遵循者`提供特定名称与类型的`实例属性(instance property)`或`类属性(type property)`，而不管其是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外也可以指定属性是只读的还是可读写的。
+协议可以规定其`遵循者`提供特定名称和类型的`实例属性(instance property)`或`类属性(type property)`，而不指定是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外还必须指明是只读的还是可读可写的。
 
-如果协议要求属性是可读写的，那么这个属性不能是常量`存储型属性`或只读`计算型属性`；如果协议要求属性是只读的(gettable)，那么`计算型属性`或`存储型属性`都能满足协议对属性的规定，在你的代码中，即使为只读属性实现了写方法(settable)也依然有效。
+如果协议要求属性是可读可写的，那么这个属性不能是常量或只读的计算属性。如果协议只要求属性是只读的(gettable)，那个属性不仅可以是只读的，如果你代码需要的话，也可以是可写的。
 
-协议中的属性经常被加以`var`前缀声明其为变量属性，在声明后加上`{ set get }`来表示属性是可读写的，只读的属性则写作`{ get }`，如下所示:
+协议中的通常用var来声明属性，在类型声明后加上`{ set get }`来表示属性是可读可写的，只读属性则用`{ get }`来表示。
 
 ```swift
 protocol SomeProtocol {
@@ -68,16 +68,17 @@ protocol SomeProtocol {
 	var doesNotNeedToBeSettable: Int { get }
 }
 ```
-
-如下所示，通常在协议的定义中使用`class`前缀表示该属性为类成员；在枚举和结构体实现协议时中，需要使用`static`关键字作为前缀。
+<!--TODO-->
+在协议中定义类属性(type property)时，使用`static`关键字作为前缀。
+通常在协议的定义中使用`class`前缀表示该属性为类成员；在枚举和结构体实现协议时中，需要使用`static`关键字作为前缀。
 
 ```swift
 protocol AnotherProtocol {
-	class var someTypeProperty: Int { get set }
+	static var someTypeProperty: Int { get set }
 }
 ```
 
-如下所示，这是一个含有一个实例属性要求的协议:
+如下所示，这是一个含有一个实例属性要求的协议。
 
 ```swift
 protocol FullyNamed {
@@ -85,9 +86,9 @@ protocol FullyNamed {
 }
 ```
 
-`FullyNamed`协议定义了任何拥有`fullName`的类型。它并不指定具体类型，而只是要求类型必须提供一个`fullName`。任何`FullyNamed`类型都得有一个只读的`fullName`属性，类型为`String`。
+`FullyNamed`协议除了要求协议的遵循者提供fullName属性外，对协议对遵循者的类型并没有特别的要求。这个协议表示，任何遵循`FullyNamed`协议的类型，都具有一个可读的`String`类型实例属性`fullName`。
 
-如下所示，这是一个实现了`FullyNamed`协议的简单结构体:
+下面是一个遵循`FullyNamed`协议的简单结构体。
 
 ```swift
 struct Person: FullyNamed{
@@ -97,29 +98,29 @@ let john = Person(fullName: "John Appleseed")
 //john.fullName 为 "John Appleseed"
 ```
 
-这个例子中定义了一个叫做`Person`的结构体，用来表示具有指定名字的人。从第一行代码中可以看出，它采用了`FullyNamed`协议。
+这个例子中定义了一个叫做`Person`的结构体，用来表示具有名字的人。从第一行代码中可以看出，它遵循了`FullyNamed`协议。
 
-`Person`结构体的每一个实例都有一个叫做`fullName`，`String`类型的存储型属性，这正好匹配了`FullyNamed`协议的要求，也就意味着，`Person`结构体完整的`遵循`了协议。(如果协议要求未被完全满足,在编译时会报错)
+`Person`结构体的每一个实例都有一个叫做`fullName`，`String`类型的存储型属性。这正好满足了`FullyNamed`协议的要求，也就意味着，`Person`结构体完整的`遵循`了协议。(如果协议要求未被完全满足,在编译时会报错)
 
-这有一个更为复杂的类，它采用并实现了`FullyNamed`协议，如下所示:
+下面是一个更为复杂的类，它采用并遵循了`FullyNamed`协议:
 
 ```swift
 class Starship: FullyNamed {
-	var prefix: String?
-	var name: String
-	init(name: String, prefix: String? = nil ) {
-		self.name = name
-		self.prefix = prefix
-	}
-	var fullName: String {
-	return (prefix != nil ? prefix! + " " : " ") + name
-	}
+    var prefix: String?
+    var name: String
+    init(name: String, prefix: String? = nil) {
+        self.name = name
+        self.prefix = prefix
+    }
+    var fullName: String {
+        return (prefix != nil ? prefix! + " " : "") + name
+    }
 }
 var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
-// ncc1701.fullName == "USS Enterprise"
+// ncc1701.fullName is "USS Enterprise"
 ```
 
-`Starship`类把`fullName`属性实现为只读的`计算型属性`。每一个`Starship`类的实例都有一个名为`name`的必备属性和一个名为`prefix`的可选属性。 当`prefix`存在时，将`prefix`插入到`name`之前来为`Starship`构建`fullName`，`prefix`不存在时，则将直接用`name`构建`fullName`
+Starship类把`fullName`属性实现为只读的计算型属性。每一个`Starship`类的实例都有一个名为`name`的属性和一个名为`prefix`的可选属性。 当`prefix`存在时，将`prefix`插入到`name`之前来为Starship构建`fullName`，`prefix`不存在时，则将直接用`name`构建`fullName`。
 
 <a name="method_requirements"></a>
 ## 对方法的规定

From 762934aa5f5689d5f2451fdbcdd4895192cf3c59 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 15:40:11 +0800
Subject: [PATCH 090/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=AF=B9=E6=96=B9=E6=B3=95=E7=9A=84=E8=A7=84=E5=AE=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index ae226e8c..78d6e9bf 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -9,7 +9,7 @@
 - [协议的语法（Protocol Syntax）](#protocol_syntax)
 - [对属性的规定（Property Requirements）](#property_requirements)
 - [对方法的规定（Method Requirements）](#method_requirements)
-- [对突变方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
+- [对Mutating方法的规定（Mutating Method Requirements）](#mutating_method_requirements)
 - [对构造器的规定（Initializer Requirements）](#initializer_requirements)
 - [协议类型（Protocols as Types）](#protocols_as_types)
 - [委托(代理)模式（Delegation）](#delegation)
@@ -68,9 +68,8 @@ protocol SomeProtocol {
 	var doesNotNeedToBeSettable: Int { get }
 }
 ```
-<!--TODO-->
-在协议中定义类属性(type property)时，使用`static`关键字作为前缀。
-通常在协议的定义中使用`class`前缀表示该属性为类成员；在枚举和结构体实现协议时中，需要使用`static`关键字作为前缀。
+
+在协议中定义类属性(type property)时，总是使用`static`关键字作为前缀。当协议的遵循者是类时，可以使用`class`或`static`关键字来声明类属性，但是在协议的定义中，仍然要使用`static`关键字。
 
 ```swift
 protocol AnotherProtocol {
@@ -125,20 +124,17 @@ Starship类把`fullName`属性实现为只读的计算型属性。每一个`Star
 <a name="method_requirements"></a>
 ## 对方法的规定
 
-`协议`可以要求其`遵循者`实现某些指定的`实例方法`或`类方法`。这些方法作为协议的一部分，像普通的方法一样清晰的放在协议的定义中，而不需要大括号和方法体。
+协议可以要求其遵循者实现某些指定的实例方法或类方法。这些方法作为协议的一部分，像普通的方法一样放在协议的定义中，但是不需要大括号和方法体。可以在协议中定义具有可变参数的方法，和普通方法的定义方式相同。但是在协议的方法定义中，不支持参数默认值。
 
->注意：
->协议中的方法支持`变长参数(variadic parameter)`，不支持`参数默认值(default value)`。
-
-如下所示，协议中类方法的定义与类属性的定义相似，在协议定义的方法前置`class`关键字来表示。当在`枚举`或`结构体`实现类方法时，需要使用`static`关键字来代替。
+正如对属性的规定中所说的，在协议中定义类方法的时候，总是使用`static`关键字作为前缀。当协议的遵循者是类的时候，虽然你可以在类的实现中使用`class`或者`static`来实现类方法，但是在协议中声明类方法，仍然要使用`static`关键字。
 
 ```swift
 protocol SomeProtocol {
-	class func someTypeMethod()
+	static func someTypeMethod()
 }
 ```
 
-如下所示，定义了含有一个实例方法的的协议。
+下面的例子定义了含有一个实例方法的协议。
 
 ```swift
 protocol RandomNumberGenerator {
@@ -146,7 +142,7 @@ protocol RandomNumberGenerator {
 }
 ```
 
-`RandomNumberGenerator`协议要求其`遵循者`必须拥有一个名为`random`， 返回值类型为`Double`的实例方法。 (尽管这里并未指明，但是我们假设返回值在[0，1]区间内)。
+`RandomNumberGenerator`协议要求其遵循者必须拥有一个名为`random`， 返回值类型为`Double`的实例方法。尽管这里并未指明，但是我们假设返回值在[0，1)区间内。
 
 `RandomNumberGenerator`协议并不在意每一个随机数是怎样生成的，它只强调这里有一个随机数生成器。
 
@@ -172,7 +168,7 @@ print("And another one: \(generator.random())")
 ```
 
 <a name="mutating_method_requirements"></a>
-## 对突变方法的规定
+## 对Mutating方法的规定
 
 有时不得不在方法中更改实例的所属类型。在基于`值类型(value types)`(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改实例及其属性的所属类型。这一过程在[Modifyting Value Types from Within Instance Methods](1)章节中有详细描述。
 

From 40f1dc1e2853f1a525110da5661d9459d1a3e5d0 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 16:19:41 +0800
Subject: [PATCH 091/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9Mutating?=
 =?UTF-8?q?=E6=96=B9=E6=B3=95=E7=9A=84=E8=A7=84=E5=AE=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 78d6e9bf..24a56bfa 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -170,15 +170,17 @@ print("And another one: \(generator.random())")
 <a name="mutating_method_requirements"></a>
 ## 对Mutating方法的规定
 
-有时不得不在方法中更改实例的所属类型。在基于`值类型(value types)`(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改实例及其属性的所属类型。这一过程在[Modifyting Value Types from Within Instance Methods](1)章节中有详细描述。
+有时需要在方法中改变它的实例。例如，值类型(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改它所属的实例及其实例属性的值。这一过程在[Modifyting Value Types from Within Instance Methods](TODO)章节中有详细描述。
 
-如果协议中的实例方法打算改变其`遵循者`实例的类型，那么在协议定义时需要在方法前加`mutating`关键字，才能使`结构体，枚举`来采用并满足协议中对方法的规定。
+如果你在协议中定义了一个方法旨在改变遵循该协议的实例，那么在协议定义时需要在方法前加`mutating`关键字。这使得结构和枚举遵循协议并满足此方法要求。
 
 
 >注意:
->用`类`实现协议中的`mutating`方法时，不用写`mutating`关键字;用`结构体`，`枚举`实现协议中的`mutating`方法时，必须写`mutating`关键字。
+>用类实现协议中的`mutating`方法时，不用写`mutating`关键字;用结构体，枚举实现协议中的`mutating`方法时，必须写`mutating`关键字。
 
-如下所示，`Togglable`协议含有名为`toggle`的突变实例方法。根据名称推测，`toggle`方法应该是用于切换或恢复其`遵循者`实例或其属性的类型。
+如下所示，`Togglable`协议含有名为`toggle`的实例方法。根据名称推测，`toggle()`方法将通过改变实例属性，来切换遵循该协议的实例的状态。
+
+`toggle()`方法在定义的时候，使用`mutating`关键字标记，这表明当它被调用时该方法将会改变协议遵循者实例的状态。
 
 ```swift
 protocol Togglable {
@@ -186,9 +188,9 @@ protocol Togglable {
 }
 ```
 
-当使用`枚举`或`结构体`来实现`Togglabl`协议时，需要提供一个带有`mutating`前缀的`toggle`方法。
+当使用`枚举`或`结构体`来实现`Togglable`协议时，需要提供一个带有`mutating`前缀的`toggle`方法。
 
-如下所示，`OnOffSwitch`枚举`遵循`了`Togglable`协议，`On`，`Off`两个成员用于表示当前状态。枚举的`toggle`方法被标记为`mutating`，用以匹配`Togglabel`协议的规定。
+下面定义了一个名为`OnOffSwitch`的枚举类型。这个枚举类型在两种状态之间进行切换，用枚举成员`On`和`Off`表示。枚举类型的`toggle`方法被标记为`mutating`以满足`Togglable`协议的要求。
 
 ```swift
 enum OnOffSwitch: Togglable {
@@ -218,7 +220,7 @@ protocol SomeProtocol {
 }
 ```
 
-**协议构造器规定在类中的实现**
+### 协议构造器规定在类中的实现
 
 你可以在遵循该协议的类中实现构造器，并指定其为类的特定构造器或者便捷构造器。在这两种情况下，你都必须给构造器实现标上"required"修饰符：
 

From 7b3aafe60787abfc9758ba0b7607b679b1352fff Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Fri, 3 Jul 2015 16:20:42 +0800
Subject: [PATCH 092/228] =?UTF-8?q?Protocols=20-=20=E4=BF=AE=E6=94=B9?=
 =?UTF-8?q?=E4=BA=8C=E7=BA=A7=E6=A0=87=E9=A2=98markdown=E8=AF=AD=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 24a56bfa..e4cd628a 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -263,7 +263,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 }
 ```
 
-**可失败构造器的规定**
+### 可失败构造器的规定
 
 可以通过给协议```Protocols```中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
 

From 142c7111d7eb5d5868b89917ac96e2b832e6a3b9 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 09:27:05 +0800
Subject: [PATCH 093/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9=E6=9E=84?=
 =?UTF-8?q?=E9=80=A0=E5=99=A8=E7=9A=84=E8=A7=84=E5=AE=9A=20=E7=BB=BC?=
 =?UTF-8?q?=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index e4cd628a..01e68099 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -212,7 +212,7 @@ lightSwitch.toggle()
 <a name="initializer_requirements"></a>
 ## 对构造器的规定
 
-协议可以要求它的遵循类型实现特定的构造器。你可以像书写普通的构造器那样，在协议的定义里写下构造器的需求，但不需要写花括号和构造器的实体：
+协议可以要求它的遵循者实现指定的构造器。你可以像书写普通的构造器那样，在协议的定义里写下构造器的声明，但不需要写花括号和构造器的实体：
 
 ```swift
 protocol SomeProtocol {

From 4aaa9ecffc04eaeab8d48b0e786e572abef575db Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 09:50:10 +0800
Subject: [PATCH 094/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9=E6=9E=84?=
 =?UTF-8?q?=E9=80=A0=E5=99=A8=E7=9A=84=E8=A7=84=E5=AE=9A=20=E5=8D=8F?=
 =?UTF-8?q?=E8=AE=AE=E6=9E=84=E9=80=A0=E5=99=A8=E8=A7=84=E5=AE=9A=E5=9C=A8?=
 =?UTF-8?q?=E7=B1=BB=E4=B8=AD=E7=9A=84=E5=AE=9E=E7=8E=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 01e68099..8aeb1373 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -222,7 +222,7 @@ protocol SomeProtocol {
 
 ### 协议构造器规定在类中的实现
 
-你可以在遵循该协议的类中实现构造器，并指定其为类的特定构造器或者便捷构造器。在这两种情况下，你都必须给构造器实现标上"required"修饰符：
+你可以在遵循该协议的类中实现构造器，并指定其为类的指定构造器(designated initializer)或者便利构造器(convenience initializer)。在这两种情况下，你都必须给构造器实现标上"required"修饰符：
 
 ```swift
 class SomeClass: SomeProtocol {
@@ -234,11 +234,12 @@ class SomeClass: SomeProtocol {
 
 使用`required`修饰符可以保证：所有的遵循该协议的子类，同样能为构造器规定提供一个显式的实现或继承实现。
 
-关于`required`构造器的更多内容，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_454">`required`构造器 </a>
+<!--TODO 参考链接-->
+关于`required`构造器的更多内容，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_454">`Required`构造器 </a>
 
+<!--TODO 参考链接-->
 >注意
->
->如果类已经被“final”修饰符所标示，你就不需要在协议构造器规定的实现中使用"required"修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_339">防止重写</a>
+>如果类已经被标记为`final`，那么不需要在协议构造器的实现中使用`required`修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_339">防止重写</a>
 
 如果一个子类重写了父类的指定构造器，并且该构造器遵循了某个协议的规定，那么该构造器的实现需要被同时标示`required`和`override`修饰符
 
@@ -250,13 +251,13 @@ protocol SomeProtocol {
 
 class SomeSuperClass {
     init() {
-        //协议定义
+        // 构造器的实现
     }
 }
 
 
 class SomeSubClass: SomeSuperClass, SomeProtocol {
-    // "required" from SomeProtocol conformance; "override" from SomeSuperClass
+    // 因为遵循协议，需要加上"required"; 因为继承自父类，需要加上"override"
     required override init() {
         // 构造器实现
     }
@@ -265,7 +266,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 
 ### 可失败构造器的规定
 
-可以通过给协议```Protocols```中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
+可以通过给协议`Protocols`中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
 
 如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。
 如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。

From 351fb69fb62ade363b2cd37c110edcb9f237484d Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 09:57:20 +0800
Subject: [PATCH 095/228] =?UTF-8?q?Protocols=20-=20=E5=AF=B9=E6=9E=84?=
 =?UTF-8?q?=E9=80=A0=E5=99=A8=E7=9A=84=E8=A7=84=E5=AE=9A=20=E5=8F=AF?=
 =?UTF-8?q?=E5=A4=B1=E8=B4=A5=E6=9E=84=E9=80=A0=E5=99=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 8aeb1373..5f3f5dc2 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -268,8 +268,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 
 可以通过给协议`Protocols`中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
 
-如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。
-如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。
+如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。
 
 
 <a name="protocols_as_types"></a>

From 4ae7d891faf6b3c0b14801c302555e2a35490b38 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 10:14:16 +0800
Subject: [PATCH 096/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90=20?=
 =?UTF-8?q?=E5=8D=8F=E8=AE=AE=E7=B1=BB=E5=9E=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 5f3f5dc2..455f0db2 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -274,15 +274,16 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 <a name="protocols_as_types"></a>
 ## 协议类型
 
-尽管`协议`本身并不实现任何功能，但是`协议`可以被当做类型来使用。
+尽管协议本身并不实现任何功能，但是协议可以被当做类型来使用。
 
-使用场景:
+协议可以像其他普通类型一样使用，使用场景:
 
-* `协议类型`作为函数、方法或构造器中的参数类型或返回值类型
-* `协议类型`作为常量、变量或属性的类型
-* `协议类型`作为数组、字典或其他容器中的元素类型
+* 作为函数、方法或构造器中的参数类型或返回值类型
+* 作为常量、变量或属性的类型
+* 作为数组、字典或其他容器中的元素类型
 
-> 注意: 协议是一种类型，因此协议类型的名称应与其他类型(Int，Double，String)的写法相同，使用驼峰式写法
+> 注意
+> 协议是一种类型，因此协议类型的名称应与其他类型(Int，Double，String)的写法相同，使用大写字母开头的驼峰式写法，例如(`FullyNamed`和`RandomNumberGenerator`)
 
 如下所示，这个示例中将协议当做类型来使用
 
@@ -300,18 +301,18 @@ class Dice {
 }
 ```
 
-例子中又一个`Dice`类，用来代表桌游中的拥有N个面的骰子。`Dice`的实例含有`sides`和`generator`两个属性，前者是整型，用来表示骰子有几个面，后者为骰子提供一个随机数生成器。
+例子中定义了一个`Dice`类，用来代表桌游中的拥有N个面的骰子。`Dice`的实例含有`sides`和`generator`两个属性，前者是整型，用来表示骰子有几个面，后者为骰子提供一个随机数生成器。
 
  `generator`属性的类型为`RandomNumberGenerator`，因此任何遵循了`RandomNumberGenerator`协议的类型的实例都可以赋值给`generator`，除此之外，无其他要求。
 
-`Dice`类中也有一个`构造器(initializer)`，用来进行初始化操作。构造器中含有一个名为`generator`，类型为`RandomNumberGenerator`的形参。在调用构造方法时创建`Dice`的实例时，可以传入任何遵循`RandomNumberGenerator`协议的实例给generator。
+`Dice`类中也有一个构造器(initializer)，用来进行初始化操作。构造器中含有一个名为`generator`，类型为`RandomNumberGenerator`的形参。在调用构造方法时创建`Dice`的实例时，可以传入任何遵循`RandomNumberGenerator`协议的实例给generator。
 
-`Dice`类也提供了一个名为`roll`的实例方法用来模拟骰子的面值。它先使用`generator`的`random`方法来创建一个[0-1]区间内的随机数种子，然后加工这个随机数种子生成骰子的面值。generator被认为是遵循了`RandomNumberGenerator`的类型，因而保证了`random`方法可以被调用。
+`Dice`类也提供了一个名为`roll`的实例方法用来模拟骰子的面值。它先使用`generator`的`random()`方法来创建一个[0,1)区间内的随机数，然后使用这个随机数生成正确的骰子面值。因为generator遵循了`RandomNumberGenerator`协议，因而保证了`random`方法可以被调用。
 
-如下所示，这里展示了如何使用`LinearCongruentialGenerator`的实例作为随机数生成器创建一个六面骰子:
+下面的例子展示了如何使用`LinearCongruentialGenerator`的实例作为随机数生成器创建一个六面骰子:
 
 ```swift
-var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
+var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
 for _ in 1...5 {
 	print("Random dice roll is \(d6.roll())")
 }

From 6d6f53f5481a562b74cc43dc6726fc7f54b5499f Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 10:51:06 +0800
Subject: [PATCH 097/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=A7=94=E6=89=98(=E4=BB=A3=E7=90=86)=E6=A8=A1=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 455f0db2..a5828e9f 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -327,13 +327,9 @@ for _ in 1...5 {
 <a name="delegation"></a>
 ## 委托(代理)模式
 
-委托是一种设计模式(*译者注: 想起了那年 UITableViewDelegate 中的奔跑，那是我逝去的Objective-C。。。*)，它允许`类`或`结构体`将一些需要它们负责的功能`交由(委托)`给其他的类型的实例。
+委托是一种设计模式，它允许`类`或`结构体`将一些需要它们负责的功能`交由(委托)`给其他的类型的实例。委托模式的实现很简单: 定义协议来封装那些需要被委托的函数和方法， 使其`遵循者`拥有这些被委托的`函数和方法`。委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的类型信息。
 
-委托模式的实现很简单: 定义`协议`来`封装`那些需要被委托的`函数和方法`， 使其`遵循者`拥有这些被委托的`函数和方法`。
-
-委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的所属类型(*译者注:只要求外部数据源`遵循`某协议*)。
-
-下文是两个基于骰子游戏的协议:
+下面的例子是两个基于骰子游戏的协议:
 
 ```swift
 protocol DiceGame {
@@ -348,7 +344,7 @@ protocol DiceGameDelegate {
 }
 ```
 
-`DiceGame`协议可以在任意含有骰子的游戏中实现，`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
+`DiceGame`协议可以在任意含有骰子的游戏中实现。`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
 
 如下所示，`SnakesAndLadders`是`Snakes and Ladders`(译者注:[Control Flow](2)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程:
 
@@ -385,15 +381,15 @@ class SnakesAndLadders: DiceGame {
 }
 ```
 
-这个版本的游戏封装到了`SnakesAndLadders`类中，该类采用了`DiceGame`协议，并且提供了`dice`属性和`play`实例方法用来`遵循`协议。(`dice`属性在构造之后就不在改变，且协议只要求`dice`为只读的，因此将`dice`声明为常量属性。)
+这个版本的游戏封装到了`SnakesAndLadders`类中，该类遵循了`DiceGame`协议，并且提供了相应的可读的`dice`属性和`play`实例方法。(`dice`属性在构造之后就不再改变，且协议只要求`dice`为只读的，因此将`dice`声明为常量属性。)
 
 在`SnakesAndLadders`类的`构造器(initializer)`初始化游戏。所有的游戏逻辑被转移到了`play`方法中，`play`方法使用协议规定的`dice`属性提供骰子摇出的值。
 
-> 注意:`delegate`并不是游戏的必备条件，因此`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性，`delegate`使用`nil`作为初始值。
+注意:`delegate`并不是游戏的必备条件，因此`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性。因为`delegate`是可选值，因此在初始化的时候被自动赋值为`nil`。随后，可以在游戏中为`delegate`设置适当的值。
 
 `DicegameDelegate`协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中，即`play()`方法内。分别在游戏开始时，新一轮开始时，游戏结束时被调用。
 
-因为`delegate`是一个遵循`DiceGameDelegate`的可选属性，因此在`play()`方法中使用了`可选链`来调用委托方法。 若`delegate`属性为`nil`， 则delegate所调用的方法失效。若`delegate`不为`nil`，则方法能够被调用
+因为`delegate`是一个遵循`DiceGameDelegate`的可选属性，因此在`play()`方法中使用了`可选链`来调用委托方法。 若`delegate`属性为`nil`， 则delegate所调用的方法失效，并不会产生错误。若`delegate`不为`nil`，则方法能够被调用
 
 如下所示，`DiceGameTracker`遵循了`DiceGameDelegate`协议
 

From 2f47ecc766ae5480b166bf5d4f03b947d694c5a5 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:10:44 +0800
Subject: [PATCH 098/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=A7=94=E6=89=98(=E4=BB=A3=E7=90=86)=E6=A8=A1=E5=BC=8F=20?=
 =?UTF-8?q?=E6=A0=A1=E5=AF=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index a5828e9f..0b9fc63b 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -383,7 +383,7 @@ class SnakesAndLadders: DiceGame {
 
 这个版本的游戏封装到了`SnakesAndLadders`类中，该类遵循了`DiceGame`协议，并且提供了相应的可读的`dice`属性和`play`实例方法。(`dice`属性在构造之后就不再改变，且协议只要求`dice`为只读的，因此将`dice`声明为常量属性。)
 
-在`SnakesAndLadders`类的`构造器(initializer)`初始化游戏。所有的游戏逻辑被转移到了`play`方法中，`play`方法使用协议规定的`dice`属性提供骰子摇出的值。
+游戏使用`SnakesAndLadders`类的`构造器(initializer)`初始化游戏。所有的游戏逻辑被转移到了协议中的`play`方法，`play`方法使用协议规定的`dice`属性提供骰子摇出的值。
 
 注意:`delegate`并不是游戏的必备条件，因此`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性。因为`delegate`是可选值，因此在初始化的时候被自动赋值为`nil`。随后，可以在游戏中为`delegate`设置适当的值。
 
@@ -413,7 +413,7 @@ class DiceGameTracker: DiceGameDelegate {
 }
 ```
 
-`DiceGameTracker`实现了`DiceGameDelegate`协议规定的三个方法，用来记录游戏已经进行的轮数。 当游戏开始时，`numberOfTurns`属性被赋值为0; 在每新一轮中递加; 游戏结束后，输出打印游戏的总轮数。
+`DiceGameTracker`实现了`DiceGameDelegate`协议规定的三个方法，用来记录游戏已经进行的轮数。 当游戏开始时，`numberOfTurns`属性被赋值为0; 在每新一轮中递增; 游戏结束后，输出打印游戏的总轮数。
 
 `gameDidStart`方法从`game`参数获取游戏信息并输出。`game`在方法中被当做`DiceGame`类型而不是`SnakeAndLadders`类型，所以方法中只能访问`DiceGame`协议中的成员。当然了，这些方法也可以在类型转换之后调用。在上例代码中，通过`is`操作符检查`game`是否为 `SnakesAndLadders`类型的实例，如果是，则打印出相应的内容。
 

From b6efe9fd4c1aa7052479bd94231c3c2d06fc6973 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:27:43 +0800
Subject: [PATCH 099/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=9C=A8=E6=89=A9=E5=B1=95=E4=B8=AD=E6=B7=BB=E5=8A=A0=E5=8D=8F?=
 =?UTF-8?q?=E8=AE=AE=E6=88=90=E5=91=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 0b9fc63b..b09b6335 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -417,7 +417,7 @@ class DiceGameTracker: DiceGameDelegate {
 
 `gameDidStart`方法从`game`参数获取游戏信息并输出。`game`在方法中被当做`DiceGame`类型而不是`SnakeAndLadders`类型，所以方法中只能访问`DiceGame`协议中的成员。当然了，这些方法也可以在类型转换之后调用。在上例代码中，通过`is`操作符检查`game`是否为 `SnakesAndLadders`类型的实例，如果是，则打印出相应的内容。
 
-无论当前进行的是何种游戏，`game`都遵循`DiceGame`协议以确保`game`含有`dice`属性，因此在`gameDidStart`方法中可以通过传入的`game`参数来访问`dice`属性，进而打印出`dice`的`sides`属性的值。
+无论当前进行的是何种游戏，`game`都遵循`DiceGame`协议以确保`game`含有`dice`属性，因此在`gameDidStart(_:)`方法中可以通过传入的`game`参数来访问`dice`属性，进而打印出`dice`的`sides`属性的值。
 
 `DiceGameTracker`的运行情况，如下所示:
 
@@ -438,11 +438,12 @@ game.play()
 <a name="adding_protocol_conformance_with_an_extension"></a>
 ## 在扩展中添加协议成员
 
-即便无法修改源代码，依然可以通过`扩展(Extension)`来扩充已存在类型(*译者注: 类，结构体，枚举等*)。`扩展`可以为已存在的类型添加`属性`，`方法`，`下标脚本`，`协议`等成员。详情请在[扩展](4)章节中查看。
+即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(*译者注: 类，结构体，枚举等*)。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。详情请在[扩展](4)章节中查看。
 
-> 注意: 通过`扩展`为已存在的类型`遵循`协议时，该类型的所有实例也会随之添加协议中的方法
+> 注意
+> 通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法
 
-`TextRepresentable`协议含有一个`asText`，如下所示：
+例如`TextRepresentable`协议，任何想要表示一些文本内容的类型都可以遵循该协议。这些想要表示的内容可以是类型本身的描述，也可以是当前内容的版本:
 
 ```swift
 protocol TextRepresentable {
@@ -450,7 +451,7 @@ protocol TextRepresentable {
 }
 ```
 
-通过`扩展`为上一节中提到的`Dice`类遵循`TextRepresentable`协议
+可以通过扩展，为上一节中提到的`Dice`增加类遵循`TextRepresentable`协议的功能
 
 ```swift
 extension Dice: TextRepresentable {
@@ -459,8 +460,9 @@ extension Dice: TextRepresentable {
 	}
 }
 ```
+现在，通过扩展使得`Dice`类型遵循了一个新的协议，这和`Dice`类型在定义的时候声明为遵循`TextRepresentable`协议的效果相同。在扩展的时候，协议名称写在类型名之后，以冒号隔开，在大括号内写明新添加的协议内容。
 
-从现在起，`Dice`类型的实例可被当作`TextRepresentable`类型：
+现在所有`Dice`的实例都遵循了`TextRepresentable`协议:
 
 ```swift
 let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
@@ -468,7 +470,7 @@ print(d12.asText())
 // 输出 "A 12-sided dice"
 ```
 
-`SnakesAndLadders`类也可以通过`扩展`的方式来遵循协议：
+同样`SnakesAndLadders`类也可以通过`扩展`的方式来遵循`TextRepresentable`协议：
 
 ```swift
 extension SnakesAndLadders: TextRepresentable {

From c15b677a7cabc2fc39fe42fd61fb61ccc2d36de1 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:31:06 +0800
Subject: [PATCH 100/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E9=80=9A=E8=BF=87=E6=89=A9=E5=B1=95=E8=A1=A5=E5=85=85=E5=8D=8F?=
 =?UTF-8?q?=E8=AE=AE=E5=A3=B0=E6=98=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index b09b6335..7ca35ac4 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -485,7 +485,7 @@ print(game.asText())
 <a name="declaring_protocol_adoption_with_an_extension"></a>
 ## 通过扩展补充协议声明
 
-当一个类型已经实现了协议中的所有要求，却没有声明时，可以通过`扩展`来补充协议声明:
+当一个类型已经实现了协议中的所有要求，却没有声明为遵循该协议时，可以通过扩展(空的扩展体)来补充协议声明:
 
 ```swift
 struct Hamster {
@@ -506,7 +506,8 @@ print(somethingTextRepresentable.asText())
 // 输出 "A hamster named Simon"
 ```
 
-> 注意: 即使满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出明显的协议声明
+> 注意
+> 即使满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出显式的协议声明
 
 <a name="collections_of_protocol_types"></a>
 ## 集合中的协议类型

From 5487f33360fea3f5997320035b2e7b7159478e66 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 20:55:07 +0800
Subject: [PATCH 101/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E9=9B=86=E5=90=88=E4=B8=AD=E7=9A=84=E5=8D=8F=E8=AE=AE=E7=B1=BB?=
 =?UTF-8?q?=E5=9E=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 7ca35ac4..f9aaa911 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -512,13 +512,13 @@ print(somethingTextRepresentable.asText())
 <a name="collections_of_protocol_types"></a>
 ## 集合中的协议类型
 
-协议类型可以被集合使用，表示集合中的元素均为协议类型:
+协议类型可以在集合使用，表示集合中的元素均为协议类型，下面的例子创建了一个类型为`TextRepresentable`的数组:
 
 ```swift
 let things: [TextRepresentable] = [game,d12,simonTheHamster]
 ```
 
-如下所示，`things`数组可以被直接遍历，并调用其中元素的`asText()`函数:
+如下所示，`things`数组可以被直接遍历，并打印每个元素的文本表示:
 
 ```swift
 for thing in things {

From d193b2cab3068962b5f958d755a1a809f641f1e7 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Sat, 4 Jul 2015 21:24:35 +0800
Subject: [PATCH 102/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=8D=8F=E8=AE=AE=E7=9A=84=E7=BB=A7=E6=89=BF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index f9aaa911..0933d597 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -534,7 +534,7 @@ for thing in things {
 <a name="protocol_inheritance"></a>
 ## 协议的继承
 
-协议能够继承一到多个其他协议。语法与类的继承相似，多个协议间用逗号`，`分隔
+协议能够继承一个或多个其他协议，可以在继承的协议基础上增加新的内容要求。协议的继承语法与类的继承相似，多个被继承的协议间用逗号分隔:
 
 ```swift
 protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
@@ -550,9 +550,9 @@ protocol PrettyTextRepresentable: TextRepresentable {
 }
 ```
 
-遵循`PrettyTextRepresentable`协议的同时，也需要遵循`TextRepresentable`协议。
+例子中定义了一个新的协议`PrettyTextRepresentable`，它继承自`TextRepresentable`协议。任何遵循`PrettyTextRepresentable`协议的类型在满足该协议的要求时，也必须满足`TextRepresentable`协议的要求。在这个例子中，`PrettyTextRepresentable`协议要求其遵循者提供一个返回值为`String`类型的`asPrettyText`方法。
 
-如下所示，用`扩展`为`SnakesAndLadders`遵循`PrettyTextRepresentable`协议:
+如下所示，扩展`SnakesAndLadders`，让其遵循`PrettyTextRepresentable`协议:
 
 ```swift
 extension SnakesAndLadders: PrettyTextRepresentable {
@@ -573,11 +573,11 @@ extension SnakesAndLadders: PrettyTextRepresentable {
 }
 ```
 
-在`for in`中迭代出了`board`数组中的每一个元素:
+上述扩展使得`SnakesAndLadders`遵循了`PrettyTextRepresentable`协议，并为每个`SnakesAndLadders`类型提供了了协议要求的`asPrettyText()`方法。每个`PrettyTextRepresentable`类型同时也是`TextRepresentable`类型，所以在`asPrettyText`的实现中，可以调用`asText()`方法。之后在每一行加上换行符，作为输出的开始。然后遍历数组中的元素，输出一个几何图形来表示遍历的结果:
 
-* 当从数组中迭代出的元素的值大于0时，用`▲`表示
-* 当从数组中迭代出的元素的值小于0时，用`▼`表示
-* 当从数组中迭代出的元素的值等于0时，用`○`表示
+* 当从数组中取出的元素的值大于0时，用`▲`表示
+* 当从数组中取出的元素的值小于0时，用`▼`表示
+* 当从数组中取出的元素的值等于0时，用`○`表示
 
 任意`SankesAndLadders`的实例都可以使用`asPrettyText()`方法。
 

From 8aa424081db64495d410b23f692fbeec39b1d3f2 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 6 Jul 2015 20:46:55 +0800
Subject: [PATCH 103/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E7=B1=BB=E4=B8=93=E5=B1=9E=E5=8D=8F=E8=AE=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 0933d597..6375ab3d 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -589,19 +589,20 @@ print(game.asPrettyText())
 
 <a name="class_only_protocol"></a>
 ## 类专属协议
-你可以在协议的继承列表中,通过添加“class”关键字,限制协议只能适配到类（class）类型。（结构体或枚举不能遵循该协议）。该“class”关键字必须是第一个出现在协议的继承列表中，其后，才是其他继承协议。
+你可以在协议的继承列表中,通过添加`class`关键字,限制协议只能适配到类（class）类型。（结构体或枚举不能遵循该协议）。该`class`关键字必须是第一个出现在协议的继承列表中，其后，才是其他继承协议。
 
 ```swift
 protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
     // class-only protocol definition goes here
 }
 ```
-在以上例子中，协议SomeClassOnlyProtocol只能被类（class）类型适配。如果尝试让结构体或枚举类型适配该协议，则会出现编译错误。
+
+在以上例子中，协议`SomeClassOnlyProtocol`只能被类（class）类型适配。如果尝试让结构体或枚举类型适配该协议，则会出现编译错误。
+
+<!--TODO 链接-->
 
 >注意
->
->当协议需求定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。关于引用语义，值语义的更多内容，请查看<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_145">结构体和枚举是值类型</a>和<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_146">类是引用类型</a>
-
+>当协议想要定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。关于引用语义，值语义的更多内容，请查看<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_145">结构体和枚举是值类型</a>和<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_146">类是引用类型</a>
 
 
 <a name="protocol_composition"></a>

From 8592e22eadc9a66e1e3d50dd8f463968b0fb07ff Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 6 Jul 2015 20:58:25 +0800
Subject: [PATCH 104/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E5=8D=8F=E8=AE=AE=E5=90=88=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 6375ab3d..6e3c9e03 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -608,9 +608,9 @@ protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
 <a name="protocol_composition"></a>
 ## 协议合成
 
-一个协议可由多个协议采用`protocol<SomeProtocol， AnotherProtocol>`这样的格式进行组合，称为`协议合成(protocol composition)`。
+有时候需要同时遵循多个协议。你可以将多个协议采用`protocol<SomeProtocol， AnotherProtocol>`这样的格式进行组合，称为`协议合成(protocol composition)`。你可以在`<>`中罗列任意多个你想要遵循的协议，以逗号分隔。
 
-举个例子：
+下面的例子中，将`Named`和`Aged`两个协议按照上述的语法组合成一个协议:
 
 ```swift
 protocol Named {
@@ -633,9 +633,12 @@ wishHappyBirthday(birthdayPerson)
 
 `Named`协议包含`String`类型的`name`属性;`Aged`协议包含`Int`类型的`age`属性。`Person`结构体`遵循`了这两个协议。
 
-`wishHappyBirthday`函数的形参`celebrator`的类型为`protocol<Named，Aged>`。可以传入任意`遵循`这两个协议的类型的实例
+`wishHappyBirthday`函数的形参`celebrator`的类型为`protocol<Named，Aged>`。可以传入任意`遵循`这两个协议的类型的实例。
 
-> 注意: `协议合成`并不会生成一个新协议类型，而是将多个协议合成为一个临时的协议，超出范围后立即失效。
+上面的例子创建了一个名为`birthdayPerson`的`Person`实例，作为参数传递给了`wishHappyBirthday(_:)`函数。因为`Person`同时遵循这两个协议，所以这个参数合法，函数将输出生日问候语。
+
+> 注意
+> `协议合成`并不会生成一个新协议类型，而是将多个协议合成为一个临时的协议，超出范围后立即失效。
 
 <a name="checking_for_protocol_conformance"></a>
 ## 检验协议的一致性

From e3e52f6eaf3a9a96809aac6e44cd768049394df0 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Mon, 6 Jul 2015 21:17:57 +0800
Subject: [PATCH 105/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E6=A3=80=E9=AA=8C=E5=8D=8F=E8=AE=AE=E7=9A=84=E4=B8=80=E8=87=B4?=
 =?UTF-8?q?=E6=80=A7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 6e3c9e03..8a44a0c4 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -643,20 +643,21 @@ wishHappyBirthday(birthdayPerson)
 <a name="checking_for_protocol_conformance"></a>
 ## 检验协议的一致性
 
-使用`is`和`as`操作符来检查协议的一致性或转化协议类型。检查和转化的语法和之前相同(*详情查看[Typy Casting章节](5)*):
+<!--TODO 链接-->
+你可以使用`is`和`as`操作符来检查是否遵循某一协议或强制转化为某一类型。检查和转化的语法和之前相同(*详情查看[Typy Casting章节](5)*):
 
-* `is`操作符用来检查实例是否`遵循`了某个`协议`。
+* `is`操作符用来检查实例是否`遵循`了某个`协议`
 * `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil`
-* `as`用以强制向下转型。
+* `as`用以强制向下转型，如果强转失败，会引起运行时错误。
+
+下面的例子定义了一个`HasArea`的协议，要求有一个`Double`类型可读的`area`:
 
 ```swift
-@objc protocol HasArea {
+protocol HasArea {
     var area: Double { get }
 }
 ```
 
-> 注意: `@objc`用来表示协议是可选的，也可以用来表示暴露给`Objective-C`的代码，此外，`@objc`型协议只对`类`有效，因此只能在`类`中检查协议的一致性。详情查看*[Using Siwft with Cocoa and Objectivei-c](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)*。
-
 如下所示，定义了`Circle`和`Country`类，它们都遵循了`HasArea`协议
 
 ```swift
@@ -683,7 +684,7 @@ class Animal {
 }
 ```
 
-`Circle，Country，Animal`并没有一个相同的基类，因而采用`AnyObject`类型的数组来装载在他们的实例，如下所示:
+`Circle`，`Country`，`Animal`并没有一个相同的基类，然而，它们都是类，它们的实例都可以作为`AnyObject`类型的变量，存储在同一个数组中:
 
 ```swift
 let objects: [AnyObject] = [
@@ -693,7 +694,7 @@ let objects: [AnyObject] = [
 ]
 ```
 
-`objects`数组使用字面量初始化，数组包含一个`radius`为2。0的`Circle`的实例，一个保存了英国面积的`Country`实例和一个`legs`为4的`Animal`实例。
+`objects`数组使用字面量初始化，数组包含一个`radius`为2的`Circle`的实例，一个保存了英国面积的`Country`实例和一个`legs`为4的`Animal`实例。
 
 如下所示，`objects`数组可以被迭代，对迭代出的每一个元素进行检查，看它是否遵循了`HasArea`协议:
 
@@ -712,7 +713,7 @@ for object in objects {
 
 当迭代出的元素遵循`HasArea`协议时，通过`as?`操作符将其`可选绑定(optional binding)`到`objectWithArea`常量上。`objectWithArea`是`HasArea`协议类型的实例，因此`area`属性是可以被访问和打印的。
 
-`objects`数组中元素的类型并不会因为`向下转型`而改变，它们仍然是`Circle`，`Country`，`Animal`类型。然而，当它们被赋值给`objectWithArea`常量时，则只被视为`HasArea`类型，因此只有`area`属性能够被访问。
+`objects`数组中元素的类型并不会因为强转而丢失类型信息，它们仍然是`Circle`，`Country`，`Animal`类型。然而，当它们被赋值给`objectWithArea`常量时，则只被视为`HasArea`类型，因此只有`area`属性能够被访问。
 
 <a name="optional_protocol_requirements"></a>
 ## 对可选协议的规定

From 8432bd90ad56b55b1ed03404bb29f419ad512902 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Thu, 9 Jul 2015 10:20:51 +0800
Subject: [PATCH 106/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90=20?=
 =?UTF-8?q?=E5=AF=B9=E5=8F=AF=E9=80=89=E5=8D=8F=E8=AE=AE=E7=9A=84=E8=A7=84?=
 =?UTF-8?q?=E5=AE=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 52 ++++++++++++++++++++-------------
 1 file changed, 32 insertions(+), 20 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 8a44a0c4..7d10a7cb 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -718,15 +718,18 @@ for object in objects {
 <a name="optional_protocol_requirements"></a>
 ## 对可选协议的规定
 
-可选协议含有可选成员，其`遵循者`可以选择是否实现这些成员。在协议中使用`@optional`关键字作为前缀来定义可选成员。
+协议可以含有可选成员，其`遵循者`可以选择是否实现这些成员。在协议中使用`optional`关键字作为前缀来定义可选成员。
 
-可选协议在调用时使用`可选链`，详细内容在[Optional Chaning](7)章节中查看。
+<!--TODO 链接-->
+可选协议在调用时使用`可选链`，因为协议的遵循者可能没有实现可选内容，详细内容在[Optional Chaning](7)章节中查看。
 
-像`someOptionalMethod?(someArgument)`这样，你可以在可选方法名称后加上`?`来检查该方法是否被实现。`可选方法`和`可选属性`都会返回一个`可选值(optional value)`，当其不可访问时，`?`之后语句不会执行，并整体返回`nil`
+像`someOptionalMethod?(someArgument)`这样，你可以在可选方法名称后加上`?`来检查该方法是否被实现。可选方法和可选属性都会返回一个`可选值(optional value)`，当其不可访问时，`?`之后语句不会执行，并整体返回`nil`
 
-> 注意: 可选协议只能在含有`@objc`前缀的协议中生效。且`@objc`的协议只能被`类`遵循
+> 注意  
+> 可选协议只能在含有`@objc`前缀的协议中生效。且`@objc`的协议只能被`类`遵循  
+> 这个前缀表示协议将暴露给Objective-C代码，详情参见`Using Swift with Cocoa and Objective-C`。即使你不打算和Objective-C有什么交互，如果你想要指明协议包含可选属性，那么还是要加上`@obj`前缀
 
-如下所示，`Counter`类使用含有两个可选成员的`CounterDataSource`协议类型的外部数据源来提供`增量值(increment amount)`
+下面的例子定义了一个叫`Counter`的整数加法类，它使用外部的数据源来实现每次的增量。数据源是两个可选属性，在`CounterDataSource`协议中定义:
 
 ```swift
 @objc protocol CounterDataSource {
@@ -735,9 +738,10 @@ for object in objects {
 }
 ```
 
-`CounterDataSource`含有`incrementForCount`的`可选方法`和`fiexdIncrement`的`可选属性`，它们使用了不同的方法来从数据源中获取合适的增量值。
+`CounterDataSource`含有`incrementForCount`可选方法和`fiexdIncrement`可选属性，它们使用了不同的方法来从数据源中获取合适的增量值。
 
-> 注意: `CounterDataSource`中的属性和方法都是可选的，因此可以在类中声明但不实现这些成员，尽管技术上允许这样做，不过最好不要这样写。
+> 注意  
+> `CounterDataSource`中的属性和方法都是可选的，因此可以在类中声明都不实现这些成员，尽管技术上允许这样做，不过最好不要这样写。
 
 `Counter`类含有`CounterDataSource?`类型的可选属性`dataSource`，如下所示:
 
@@ -755,25 +759,27 @@ for object in objects {
 }
 ```
 
-`count`属性用于存储当前的值，`increment`方法用来为`count`赋值。
+类`Counter`使用`count`来存储当前的值。该类同时定义了一个`increment`方法，每次调用该方法的时候，将会增加`count`的值。
 
-`increment`方法通过`可选链`，尝试从两种`可选成员`中获取`count`。
+`increment()`方法首先试图使用`incrementForCount(_:)`方法来得到每次的增量。`increment()`方法使用可选链来尝试调用`incrementForCount(_:)`，并将当前的`count`值作为参数传入。
 
-1. 由于`dataSource`可能为`nil`，因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用`incrementForCount`方法。
+这里使用了两种可选链方法。由于`dataSource`可能为`nil`，因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用`incrementForCount`方法。即使`dataSource`存在，但是也无法保证其是否实现了`incrementForCount`方法，因此在`incrementForCount`方法后边也加有`?`标记。
 
-2. 即使`dataSource`存在，但是也无法保证其是否实现了`incrementForCount`方法，因此在`incrementForCount`方法后边也加有`?`标记
+调用`incrementForCount`方法在上述两种情形都有可能失败，所以返回值为*可选*`Int`类型。虽然在`CounterDataSource`中，`incrementForCount`被定义为一个非可选`Int`(non-optional)，但是这里我们仍然需要返回*可选*`Int`类型。
 
-在调用`incrementForCount`方法后，`Int`型`可选值`通过`可选绑定(optional binding)`自动拆包并赋值给常量`amount`。
+在调用`incrementForCount`方法后，`Int`型`可选值`通过`可选绑定(optional binding)`自动拆包并赋值给常量`amount`。如果可选值确实包含一个数值，这表示`delegate`和方法都存在，之后便将`amount`加到`count`上，增加操作完成。
 
-当`incrementForCount`不能被调用时，尝试使用可选属性`fixedIncrement`来代替。
+如果没有从`incrementForCount(_:)`获取到值，可能是`dataSource`为nil，或者它并没有实现`incrementForCount`方法——那么`increment()`方法将试图从数据源的`fixedIncrement`属性中获取增量。`fixedIncrement`也是一个可选型，所以在属性名的后面添加`?`来试图取回可选属性的值。和之前一样，返回值为可选型。
 
-`ThreeSource`实现了`CounterDataSource`协议，如下所示:
+`ThreeSource`实现了`CounterDataSource`协议，它实现来可选属性`fixedIncrement`，每次返回值`3`:
 
-	class ThreeSource: CounterDataSource {
-		let fixedIncrement = 3
-	}
+```swift
+@objc class ThreeSource: CounterDataSource {
+	let fixedIncrement = 3
+}
+```
 
-使用`ThreeSource`作为数据源开实例化一个`Counter`:
+可以使用`ThreeSource`的实例作为`Counter`实例的数据源:
 
 ```swift
 var counter = Counter()
@@ -788,7 +794,9 @@ for _ in 1...4 {
 // 12
 ```
 
-`TowardsZeroSource`实现了`CounterDataSource`协议中的`incrementForCount`方法，如下所示:
+上述代码新建了一个`Counter`实例；将它的数据源设置为`TreeSource`实例；调用`increment()`4次。和你预想的一样，每次在调用的时候，`count`的值增加3.
+
+下面是一个更为复杂的数据源`TowardsZeroSource`，它将使得最后的值变为0:
 
 ```swift
 class TowardsZeroSource: CounterDataSource {
@@ -804,7 +812,11 @@ func incrementForCount(count: Int) -> Int {
 }
 ```
 
-下边是执行的代码：
+`TowardsZeroSource`实现了`CounterDataSource`协议中的`incrementForCount(_:)`方法，以`count`参数为依据，计算出每次的增量。如果`count`已经为0，方法返回0，这表示之后不会再有增量。
+
+你可以配合使用`TowardsZeroSource`实例和`Counter`实例来从`-4`增加到`0`.一旦增加到`0`，数值便不会再有变动。
+
+在下面的例子中，将从`-4`增加到`0`。一旦结果为`0`，便不在增加:
 
 ```swift
 counter.count = -4

From 648b809c20e4d4c94b183a64b798f623f292c838 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Thu, 9 Jul 2015 11:04:43 +0800
Subject: [PATCH 107/228] =?UTF-8?q?Protocols=20-=20=E5=AE=8C=E6=88=90=20?=
 =?UTF-8?q?=E6=8F=90=E4=BE=9B=E9=BB=98=E8=AE=A4=E5=AE=9E=E7=8E=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 40 ++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 7d10a7cb..35cda28c 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -58,7 +58,7 @@ class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
 
 协议可以规定其`遵循者`提供特定名称和类型的`实例属性(instance property)`或`类属性(type property)`，而不指定是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外还必须指明是只读的还是可读可写的。
 
-如果协议要求属性是可读可写的，那么这个属性不能是常量或只读的计算属性。如果协议只要求属性是只读的(gettable)，那个属性不仅可以是只读的，如果你代码需要的话，也可以是可写的。
+如果协议规定属性是可读可写的，那么这个属性不能是常量或只读的计算属性。如果协议只要求属性是只读的(gettable)，那个属性不仅可以是只读的，如果你代码需要的话，也可以是可写的。
 
 协议中的通常用var来声明属性，在类型声明后加上`{ set get }`来表示属性是可读可写的，只读属性则用`{ get }`来表示。
 
@@ -835,9 +835,9 @@ for _ in 1...5 {
 <a name="protocol_extensions"></a>
 ## 协议扩展
 
-Protocols can be extended to provide method and property implementations to conforming types. This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function.
+使用扩展协议的方式可以为遵循者提供方法或属性的实现。通过这种方式，可以让你无需在每个遵循者中都实现一次，无需使用全局函数，你可以通过扩展协议的方式进行定义。
 
-For example, the `RandomNumberGenerator` protocol can be extended to provide a `randomBool()` method, which uses the result of the required `random()` method to return a random `Bool` value:
+例如，可以扩展`RandomNumberGenerator`协议，让其提供`randomBool()`方法。该方法使用协议中要求的`random()`方法来实现:
 
 ```swift
 extension RandomNumberGenerator {
@@ -847,24 +847,24 @@ extension RandomNumberGenerator {
 }
 ```
 
-By creating an extension on the protocol, all conforming types automatically gain this method implementation without any additional modification.
+通过扩展协议，所有协议的遵循者，在不用任何修改的情况下，都自动得到了这个扩展所增加的方法。
 
 ```swift
 let generator = LinearCongruentialGenerator()
 print("Here's a random number: \(generator.random())")
-// prints "Here's a random number: 0.37464991998171"
+// 输出 "Here's a random number: 0.37464991998171"
 print("And here's a random Boolean: \(generator.randomBool())")
-// prints "And here's a random Boolean: true"
+// 输出 "And here's a random Boolean: true"
 ```
 
-### Providing Default Implementations
+### 提供默认实现
 
-You can use protocol extensions to provide a default implementation to any method or property requirement of that protocol. If a conforming type provides its own implementation of a required method or property, that implementation will be used instead of the one provided by the extension.
+可以通过协议扩展的方式来为协议规定的属性和方法提供默认的实现。如果协议的遵循者对规定的属性和方法提供了自己的实现，那么遵循者提供的实现将被使用。
 
-> NOTE
-> Protocol requirements with default implementations provided by extensions are distinct from optional protocol requirements. Although conforming types don’t have to provide their own implementation of either, requirements with default implementations can be called without optional chaining.
+> 注意
+> 通过扩展协议提供的协议实现和可选协议规定有区别。虽然协议遵循者无需自己实现，通过扩展提供的默认实现，可以不是用可选链调用。
 
-For example, the `PrettyTextRepresentable` protocol, which inherits the `TextRepresentable` protocol can provide a default implementation of its required `asPrettyText()` method to simply return the result of the `asText()` method:
+例如，`PrettyTextRepresentable`协议，继承了`TextRepresentable`协议，可以为其提供一个默认的`asPrettyText()`方法来简化返回值
 
 ```swift
 extension PrettyTextRepresentable  {
@@ -874,11 +874,11 @@ extension PrettyTextRepresentable  {
 }
 ```
 
-### Adding Constraints to Protocol Extensions
+### 为协议扩展添加限制条件
 
-When you define a protocol extension, you can specify constraints that conforming types must satisfy before the methods and properties of the extension are available. You write these constraints after the name of the protocol you’re extending using a `where` clause, as described in ([Where 子句](TODO)).:
+在扩展协议的时候，可以指定一些限制，只有满足这些限制的协议遵循者，才能获得协议扩展提供的属性和方法。这些限制写在协议名之后，使用`where`关键字来描述限制情况。([Where 子句](TODO))。:
 
-For instance, you can define an extension to the `CollectionType` protocol that applies to any collection whose elements conform to the `TextRepresentable protocol` from the example above.
+例如，你可以扩展`CollectionType`协议，但是只适用于元素遵循`TextRepresentable`的情况:
 
 ```swift
 extension CollectionType where Generator.Element : TextRepresentable {
@@ -888,9 +888,9 @@ extension CollectionType where Generator.Element : TextRepresentable {
 }
 ```
 
-The `asList()` method takes the textual representation of each element in the collection and concatenates them into a comma-separated list.
+`asList()`方法将每个元素以`asText()`的方式表示，最后以逗号分隔链接起来。
 
-Consider the `Hamster` structure from before, which conforms to the `TextRepresentable` protocol, and an array of `Hamster` values:
+现在我们来看`Hamster`，它遵循`TextRepresentable`:
 
 ```swift
 let murrayTheHamster = Hamster(name: "Murray")
@@ -899,12 +899,12 @@ let mauriceTheHamster = Hamster(name: "Maurice")
 let hamsters = [murrayTheHamster, morganTheHamster, mauriceTheHamster]
 ```
 
-Because `Array` conforms to `CollectionType`, and the array’s elements conform to the `TextRepresentable` protocol, the array can use the `asList()` method to get a textual representation of its contents:
+因为`Array`遵循`CollectionType`协议，数组的元素又遵循`TextRepresentable`协议，所以数组可以使用`asList()`方法得到数组内容的文本表示:
 
 ```swift
 print(hamsters.asList())
-// prints "(A hamster named Murray, A hamster named Morgan, A hamster named Maurice)"
+// 输出 "(A hamster named Murray, A hamster named Morgan, A hamster named Maurice)"
 ```
 
-> NOTE
-> If a conforming type satisfies the requirements for multiple constrained extensions that provide implementations for the same method or property, Swift will use the implementation corresponding to the most specialized constraints.
+> 注意  
+> 如果有多个协议扩展，而一个协议的遵循者又同时满足它们的限制，那么将会使用所满足限制最多的那个扩展。

From 70d812f278d84a739fd8796d070a99badd22f066 Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Thu, 9 Jul 2015 11:18:17 +0800
Subject: [PATCH 108/228] merge

---
 source/chapter2/22_Protocols.md | 68 ---------------------------------
 1 file changed, 68 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 2ffa2111..35cda28c 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -58,11 +58,7 @@ class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
 
 协议可以规定其`遵循者`提供特定名称和类型的`实例属性(instance property)`或`类属性(type property)`，而不指定是`存储型属性(stored property)`还是`计算型属性(calculate property)`。此外还必须指明是只读的还是可读可写的。
 
-<<<<<<< HEAD
 如果协议规定属性是可读可写的，那么这个属性不能是常量或只读的计算属性。如果协议只要求属性是只读的(gettable)，那个属性不仅可以是只读的，如果你代码需要的话，也可以是可写的。
-=======
-如果协议要求属性是可读可写的，那么这个属性不能是常量或只读的计算属性。如果协议只要求属性是只读的(gettable)，那个属性不仅可以是只读的，如果你代码需要的话，也可以是可写的。
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 协议中的通常用var来声明属性，在类型声明后加上`{ set get }`来表示属性是可读可写的，只读属性则用`{ get }`来表示。
 
@@ -650,17 +646,11 @@ wishHappyBirthday(birthdayPerson)
 <!--TODO 链接-->
 你可以使用`is`和`as`操作符来检查是否遵循某一协议或强制转化为某一类型。检查和转化的语法和之前相同(*详情查看[Typy Casting章节](5)*):
 
-<<<<<<< HEAD
 * `is`操作符用来检查实例是否`遵循`了某个`协议`
 * `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil`
 * `as`用以强制向下转型，如果强转失败，会引起运行时错误。
 
 下面的例子定义了一个`HasArea`的协议，要求有一个`Double`类型可读的`area`:
-=======
-* `is`操作符用来检查实例是否`遵循`了某个`协议`。
-* `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil`
-* `as`用以强制向下转型。
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 ```swift
 protocol HasArea {
@@ -771,13 +761,7 @@ for object in objects {
 
 类`Counter`使用`count`来存储当前的值。该类同时定义了一个`increment`方法，每次调用该方法的时候，将会增加`count`的值。
 
-<<<<<<< HEAD
 `increment()`方法首先试图使用`incrementForCount(_:)`方法来得到每次的增量。`increment()`方法使用可选链来尝试调用`incrementForCount(_:)`，并将当前的`count`值作为参数传入。
-=======
-`increment`方法通过`可选链`，尝试从两种`可选成员`中获取`count`。
-
-1. 由于`dataSource`可能为`nil`，因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用`incrementForCount`方法。
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 这里使用了两种可选链方法。由于`dataSource`可能为`nil`，因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用`incrementForCount`方法。即使`dataSource`存在，但是也无法保证其是否实现了`incrementForCount`方法，因此在`incrementForCount`方法后边也加有`?`标记。
 
@@ -851,15 +835,9 @@ for _ in 1...5 {
 <a name="protocol_extensions"></a>
 ## 协议扩展
 
-<<<<<<< HEAD
 使用扩展协议的方式可以为遵循者提供方法或属性的实现。通过这种方式，可以让你无需在每个遵循者中都实现一次，无需使用全局函数，你可以通过扩展协议的方式进行定义。
 
 例如，可以扩展`RandomNumberGenerator`协议，让其提供`randomBool()`方法。该方法使用协议中要求的`random()`方法来实现:
-=======
-Protocols can be extended to provide method and property implementations to conforming types. This allows you to define behavior on protocols themselves, rather than in each type’s individual conformance or in a global function.
-
-For example, the `RandomNumberGenerator` protocol can be extended to provide a `randomBool()` method, which uses the result of the required `random()` method to return a random `Bool` value:
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 ```swift
 extension RandomNumberGenerator {
@@ -869,16 +847,11 @@ extension RandomNumberGenerator {
 }
 ```
 
-<<<<<<< HEAD
 通过扩展协议，所有协议的遵循者，在不用任何修改的情况下，都自动得到了这个扩展所增加的方法。
-=======
-By creating an extension on the protocol, all conforming types automatically gain this method implementation without any additional modification.
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 ```swift
 let generator = LinearCongruentialGenerator()
 print("Here's a random number: \(generator.random())")
-<<<<<<< HEAD
 // 输出 "Here's a random number: 0.37464991998171"
 print("And here's a random Boolean: \(generator.randomBool())")
 // 输出 "And here's a random Boolean: true"
@@ -892,21 +865,6 @@ print("And here's a random Boolean: \(generator.randomBool())")
 > 通过扩展协议提供的协议实现和可选协议规定有区别。虽然协议遵循者无需自己实现，通过扩展提供的默认实现，可以不是用可选链调用。
 
 例如，`PrettyTextRepresentable`协议，继承了`TextRepresentable`协议，可以为其提供一个默认的`asPrettyText()`方法来简化返回值
-=======
-// prints "Here's a random number: 0.37464991998171"
-print("And here's a random Boolean: \(generator.randomBool())")
-// prints "And here's a random Boolean: true"
-```
-
-### Providing Default Implementations
-
-You can use protocol extensions to provide a default implementation to any method or property requirement of that protocol. If a conforming type provides its own implementation of a required method or property, that implementation will be used instead of the one provided by the extension.
-
-> NOTE
-> Protocol requirements with default implementations provided by extensions are distinct from optional protocol requirements. Although conforming types don’t have to provide their own implementation of either, requirements with default implementations can be called without optional chaining.
-
-For example, the `PrettyTextRepresentable` protocol, which inherits the `TextRepresentable` protocol can provide a default implementation of its required `asPrettyText()` method to simply return the result of the `asText()` method:
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 ```swift
 extension PrettyTextRepresentable  {
@@ -916,19 +874,11 @@ extension PrettyTextRepresentable  {
 }
 ```
 
-<<<<<<< HEAD
 ### 为协议扩展添加限制条件
 
 在扩展协议的时候，可以指定一些限制，只有满足这些限制的协议遵循者，才能获得协议扩展提供的属性和方法。这些限制写在协议名之后，使用`where`关键字来描述限制情况。([Where 子句](TODO))。:
 
 例如，你可以扩展`CollectionType`协议，但是只适用于元素遵循`TextRepresentable`的情况:
-=======
-### Adding Constraints to Protocol Extensions
-
-When you define a protocol extension, you can specify constraints that conforming types must satisfy before the methods and properties of the extension are available. You write these constraints after the name of the protocol you’re extending using a `where` clause, as described in ([Where 子句](TODO)).:
-
-For instance, you can define an extension to the `CollectionType` protocol that applies to any collection whose elements conform to the `TextRepresentable protocol` from the example above.
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 ```swift
 extension CollectionType where Generator.Element : TextRepresentable {
@@ -938,15 +888,9 @@ extension CollectionType where Generator.Element : TextRepresentable {
 }
 ```
 
-<<<<<<< HEAD
 `asList()`方法将每个元素以`asText()`的方式表示，最后以逗号分隔链接起来。
 
 现在我们来看`Hamster`，它遵循`TextRepresentable`:
-=======
-The `asList()` method takes the textual representation of each element in the collection and concatenates them into a comma-separated list.
-
-Consider the `Hamster` structure from before, which conforms to the `TextRepresentable` protocol, and an array of `Hamster` values:
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28
 
 ```swift
 let murrayTheHamster = Hamster(name: "Murray")
@@ -955,7 +899,6 @@ let mauriceTheHamster = Hamster(name: "Maurice")
 let hamsters = [murrayTheHamster, morganTheHamster, mauriceTheHamster]
 ```
 
-<<<<<<< HEAD
 因为`Array`遵循`CollectionType`协议，数组的元素又遵循`TextRepresentable`协议，所以数组可以使用`asList()`方法得到数组内容的文本表示:
 
 ```swift
@@ -965,14 +908,3 @@ print(hamsters.asList())
 
 > 注意  
 > 如果有多个协议扩展，而一个协议的遵循者又同时满足它们的限制，那么将会使用所满足限制最多的那个扩展。
-=======
-Because `Array` conforms to `CollectionType`, and the array’s elements conform to the `TextRepresentable` protocol, the array can use the `asList()` method to get a textual representation of its contents:
-
-```swift
-print(hamsters.asList())
-// prints "(A hamster named Murray, A hamster named Morgan, A hamster named Maurice)"
-```
-
-> NOTE
-> If a conforming type satisfies the requirements for multiple constrained extensions that provide implementations for the same method or property, Swift will use the implementation corresponding to the most specialized constraints.
->>>>>>> 6062b84363714e2573bfbb79500b7a5839478a28

From 3a5201d4ca6fe6316da76e2c8447451de6fe63da Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Thu, 9 Jul 2015 11:28:24 +0800
Subject: [PATCH 109/228] =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/22_Protocols.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 35cda28c..96912982 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -175,7 +175,7 @@ print("And another one: \(generator.random())")
 如果你在协议中定义了一个方法旨在改变遵循该协议的实例，那么在协议定义时需要在方法前加`mutating`关键字。这使得结构和枚举遵循协议并满足此方法要求。
 
 
->注意:
+>注意:  
 >用类实现协议中的`mutating`方法时，不用写`mutating`关键字;用结构体，枚举实现协议中的`mutating`方法时，必须写`mutating`关键字。
 
 如下所示，`Togglable`协议含有名为`toggle`的实例方法。根据名称推测，`toggle()`方法将通过改变实例属性，来切换遵循该协议的实例的状态。
@@ -238,7 +238,7 @@ class SomeClass: SomeProtocol {
 关于`required`构造器的更多内容，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_454">`Required`构造器 </a>
 
 <!--TODO 参考链接-->
->注意
+>注意  
 >如果类已经被标记为`final`，那么不需要在协议构造器的实现中使用`required`修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_339">防止重写</a>
 
 如果一个子类重写了父类的指定构造器，并且该构造器遵循了某个协议的规定，那么该构造器的实现需要被同时标示`required`和`override`修饰符
@@ -282,7 +282,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 * 作为常量、变量或属性的类型
 * 作为数组、字典或其他容器中的元素类型
 
-> 注意
+> 注意  
 > 协议是一种类型，因此协议类型的名称应与其他类型(Int，Double，String)的写法相同，使用大写字母开头的驼峰式写法，例如(`FullyNamed`和`RandomNumberGenerator`)
 
 如下所示，这个示例中将协议当做类型来使用
@@ -440,7 +440,7 @@ game.play()
 
 即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(*译者注: 类，结构体，枚举等*)。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。详情请在[扩展](4)章节中查看。
 
-> 注意
+> 注意  
 > 通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法
 
 例如`TextRepresentable`协议，任何想要表示一些文本内容的类型都可以遵循该协议。这些想要表示的内容可以是类型本身的描述，也可以是当前内容的版本:
@@ -506,7 +506,7 @@ print(somethingTextRepresentable.asText())
 // 输出 "A hamster named Simon"
 ```
 
-> 注意
+> 注意  
 > 即使满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出显式的协议声明
 
 <a name="collections_of_protocol_types"></a>
@@ -601,7 +601,7 @@ protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
 
 <!--TODO 链接-->
 
->注意
+>注意  
 >当协议想要定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。关于引用语义，值语义的更多内容，请查看<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_145">结构体和枚举是值类型</a>和<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_146">类是引用类型</a>
 
 
@@ -637,7 +637,7 @@ wishHappyBirthday(birthdayPerson)
 
 上面的例子创建了一个名为`birthdayPerson`的`Person`实例，作为参数传递给了`wishHappyBirthday(_:)`函数。因为`Person`同时遵循这两个协议，所以这个参数合法，函数将输出生日问候语。
 
-> 注意
+> 注意  
 > `协议合成`并不会生成一个新协议类型，而是将多个协议合成为一个临时的协议，超出范围后立即失效。
 
 <a name="checking_for_protocol_conformance"></a>
@@ -861,7 +861,7 @@ print("And here's a random Boolean: \(generator.randomBool())")
 
 可以通过协议扩展的方式来为协议规定的属性和方法提供默认的实现。如果协议的遵循者对规定的属性和方法提供了自己的实现，那么遵循者提供的实现将被使用。
 
-> 注意
+> 注意  
 > 通过扩展协议提供的协议实现和可选协议规定有区别。虽然协议遵循者无需自己实现，通过扩展提供的默认实现，可以不是用可选链调用。
 
 例如，`PrettyTextRepresentable`协议，继承了`TextRepresentable`协议，可以为其提供一个默认的`asPrettyText()`方法来简化返回值

From b7f61209fada04cec0c94af3f9a9c9782a900360 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Fri, 10 Jul 2015 23:03:15 +0800
Subject: [PATCH 110/228] =?UTF-8?q?=E6=96=B0=E7=89=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter3/03_Types.md       | 127 ++++++++++---------
 source/chapter3/04_Expressions.md | 200 ++++++++++++++----------------
 2 files changed, 156 insertions(+), 171 deletions(-)
 mode change 100755 => 100644 source/chapter3/03_Types.md
 mode change 100755 => 100644 source/chapter3/04_Expressions.md

diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md
old mode 100755
new mode 100644
index c2267554..327f5e7b
--- a/source/chapter3/03_Types.md
+++ b/source/chapter3/03_Types.md
@@ -18,16 +18,16 @@
 - [类型继承子句（Type Inheritance Clause）](#type_inheritance_clause)
 - [类型推断（Type Inference）](#type_inference)
 
-Swift 语言存在两种类型：命名型类型和复合型类型。*命名型类型*是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类`MyClass`的实例拥有类型`MyClass`。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。
+Swift 语言存在两种类型：命名型类型和复合型类型。命名型类型是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类MyClass的实例拥有类型MyClass。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。
 
-那些通常被其它语言认为是基本或初级的数据型类型（Data types）——比如表示数字、字符和字符串——实际上就是命名型类型，Swift 标准库是使用结构体定义和实现它们的。因为它们是命名型类型，因此你可以按照“扩展和扩展声明”章节里讨论的那样，声明一个扩展来增加它们的行为以适应你程序的需求。
+那些通常被其它语言认为是基本或初级的数据型类型（Data types）——比如表示数字、字符和字符串的类型——实际上就是命名型类型，这些类型在Swift 标准库中是使用结构体来定义和实现的。因为它们是命名型类型，因此你可以按照“扩展和扩展声明”章节里讨论的那样，声明一个扩展来增加它们的行为以迎合你程序的需求。
 
-*复合型类型*是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型`(Int, (Int, Int))`包含两个元素：第一个是命名型类型`Int`，第二个是另一个复合型类型`(Int, Int)`.
+*复合型类型*是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型(Int, (Int, Int))包含两个元素：第一个是命名型类型Int，第二个是另一个复合型类型(Int, Int).
 
 本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。
 
 > 类型语法  
-> *类型* → [*数组类型*](..\chapter3\03_Types.html#array_type) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type)  
+> *类型* → [*数组类型*](#array_type) | [*字典类型*](..\chapter3\03_Types.html#dictionary_type) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type)  
 
 <a name="type_annotation"></a>
 ##类型注解
@@ -50,9 +50,9 @@ func someFunction(a: Int){ /* ... */ }
 
 类型标识符引用命名型类型或者是命名型/复合型类型的别名。
 
-大多数情况下，类型标识符引用的是同名的命名型类型。例如类型标识符`Int`引用命名型类型`Int`，同样，类型标识符`Dictionary<String, Int>`引用命名型类型`Dictionary<String, Int>`。
+大多数情况下，类型标识符引用的是与之同名的命名型类型。例如类型标识符`Int`引用命名型类型`Int`，同样，类型标识符`Dictionary<String, Int>`引用命名型类型`Dictionary<String, Int>`。
 
-在两种情况下类型标识符引用的不是同名的类型。情况一，类型标识符引用的是命名型/复合型类型的类型别名。比如，在下面的例子中，类型标识符使用`Point`来引用元组`(Int, Int)`：
+在两种情况下类型标识符不引用同名的类型。情况一，类型标识符引用的是命名型/复合型类型的类型别名。比如，在下面的例子中，类型标识符使用`Point`来引用元组`(Int, Int)`：
 
 ```swift
 typealias Point = (Int, Int)
@@ -74,9 +74,9 @@ var someValue: ExampleModule.MyType
 
 元组类型使用逗号隔开并使用括号括起来的0个或多个类型组成的列表。
 
-你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符和`:`组成。“函数和多返回值”章节里有一个展示上述特性的例子。
+你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符紧跟一个冒号`(:)`组成。“函数和多返回值”章节里有一个展示上述特性的例子。
 
-`void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含两个元素以上时才可以标记元组元素。
+`void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含的元素个数在两个及以上时才可以命名元组元素。
 
 > 元组类型语法  
 > *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)**  
@@ -90,54 +90,39 @@ var someValue: ExampleModule.MyType
 
 函数类型表示一个函数、方法或闭包的类型，它由一个参数类型和返回值类型组成，中间用箭头`->`隔开：
 
-- `parameter type` -> `return type`
+         `parameter type` -> `return type`
 
-由于 *参数类型* 和 *返回值类型* 可以是元组类型，所以函数类型可以让函数与方法支持多参数与多返回值。
+由于 *参数类型* 和 *返回值类型* 可以是元组类型，所以函数类型支持多参数与多返回值的函数与方法。。
 
-你可以对函数类型应用带有参数类型`()`并返回表达式类型的`auto_closure`属性（见类型属性章节）。一个自动闭包函数捕获特定表达式上的隐式闭包而非表达式本身。下面的例子使用`auto_closure`属性来定义一个很简单的assert函数：
+对于参数类型是空元组类型`()`以及返回值类型为表达式类型的函数类型，你可以对其参数声明使用`autoclosure`（见声明属性章节）。一个自动闭包函数捕获特定表达式上的隐式闭包而非表达式本身。下面的例子使用`autoclosure`属性来定义一个很简单的assert函数：
 
 ```swift
-func simpleAssert(condition: @auto_closure () -> Bool, message: String){
-    if !condition(){
-        println(message)
+func simpleAssert(@autoclosure condition: Void -> Bool, _ message: String) {
+    if !condition() {
+        print(message)
     }
 }
 let testNumber = 5
 simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.")
 // prints "testNumber isn't an even number."
 ```
-函数类型可以拥有一个可变长参数作为参数类型中的最后一个参数。从语法角度上讲，可变长参数由一个基础类型名字和`...`组成，如`Int...`。可变长参数被认为是一个包含了基础类型元素的数组。即`Int...`就是`Int[]`。关于使用可变长参数的例子，见章节“可变长参数”。
+函数类型可以拥有一个可变长参数作为参数类型中的最后一个参数。从语法角度上讲，可变长参数由一个基础类型名字紧随三个点`(...)`组成，如`Int...`。可变长参数被认为是一个包含了基础类型元素的数组。即`Int...`就是`[Int]`。关于使用可变长参数的例子，见章节Variadic Parameters。
 
 为了指定一个`in-out`参数，可以在参数类型前加`inout`前缀。但是你不可以对可变长参数或返回值类型使用`inout`。关于In-Out参数的讨论见章节In-Out参数部分。
 
-柯里化函数（curried function）的类型相当于一个嵌套函数类型。例如，下面的柯里化函数`addTwoNumber()()`的类型是`Int -> Int -> Int`：
+柯里化函数（Curried fuction）的函数类型从右向左递归地组成一组。例如，函数类型`Int -> Int -> Int`可以被理解为`Int -> (Int -> Int)`——也就是说，一个函数的参数为`Int`类型，其返回类型是一个参数类型为`Int`返回类型为`Int`的函数类型。关于柯里化函数的讨论见章节Curried Fuctions。
 
-```swift
-func addTwoNumbers(a: Int)(b: Int) -> Int{
-    return a + b
-}
-addTwoNumbers(4)(5)      // returns 9
-```
-
-柯里化函数的函数类型从右向左组成一组。例如，函数类型`Int -> Int -> Int`可以被理解为`Int -> (Int -> Int)`——也就是说，一个函数传入一个`Int`然后输出作为另一个函数的输入，然后又返回一个`Int`。例如，你可以使用如下嵌套函数来重写柯里化函数`addTwoNumbers()()`：
-
-```swift
-func addTwoNumbers(a: Int) -> (Int -> Int){
-    func addTheSecondNumber(b: Int) -> Int{
-        return a + b
-    }
-    return addTheSecondNumber
-}
-addTwoNumbers(4)(5)     // Returns 9
-```
+函数类型若要抛出错误就必须使用`throws`关键字来标记，若要重抛错误则必须使用`rethrows`关键字来标记。`throws`关键字是函数类型的一部分，不抛出函数（nonthrowing function）是抛出函数（throwing function）函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。对于柯里化函数，`throws`关键字只应用于最里层的函数。抛出和重抛函数（rethrowing function）的相关描述见章节抛出函数与方法和重抛函数与方法。
 
 > 函数类型语法  
-> *函数类型* → [*类型*](..\chapter3\03_Types.html#type) **->** [*类型*](..\chapter3\03_Types.html#type)  
+> *函数类型* → [*类型*](..\chapter3\03_Types.html#type) _抛出_ _可选_ **->** [*类型*](..\chapter3\03_Types.html#type)  
+> *函数类型* → [*类型*](..\chapter3\03_Types.html#type)_重抛_ **->** [*类型*](..\chapter3\03_Types.html#type)  
 
 <a name="array_type"></a>
 ##数组类型
 
-Swift语言使用类型名紧接中括号`[]`来简化标准库中定义的命名型类型`Array<T>`。换句话说，下面两个声明是等价的：
+Swift语言中使用[`type`]来简化标准库中定义`Array<T>`类型的操作。
+换句话说，下面两个声明是等价的：
 
 ```swift
 let someArray: String[] = ["Alex", "Brian", "Dave"]
@@ -145,22 +130,38 @@ let someArray: Array<String> = ["Alex", "Brian", "Dave"]
 ```
 上面两种情况下，常量`someArray`都被声明为字符串数组。数组的元素也可以通过`[]`获取访问：`someArray[0]`是指第0个元素`“Alex”`。
 
-上面的例子同时显示，你可以使用`[]`作为初始值构造数组，空的`[]`则用来来构造指定类型的空数组。
+你也可以嵌套多对方括号来创建多维数组，最里面的方括号中指明数组元素的基本类型。比如，下面例子中使用三对方括号创建三维整数数组。
 
 ```swift
-var emptyArray: Double[] = []
-```
-你也可以使用链接起来的多个`[]`集合来构造多维数组。例如，下例使用三个`[]`集合来构造三维整型数组：
-
-```swift
-var array3D: Int[][][] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
 ```
 访问一个多维数组的元素时，最左边的下标指向最外层数组的相应位置元素。接下来往右的下标指向第一层嵌入的相应位置元素，依次类推。这就意味着，在上面的例子中，`array3D[0]`是指`[[1, 2], [3, 4]]`，`array3D[0][1]`是指`[3, 4]`，`array3D[0][1][1]`则是指值`4`。
 
 关于Swift标准库中`Array`类型的细节讨论，见章节Arrays。
 
 > 数组类型语法  
-> *数组类型* → [*类型*](..\chapter3\03_Types.html#type) **[** **]** | [*数组类型*](..\chapter3\03_Types.html#array_type) **[** **]**  
+> *数组类型* → [*类型*](..\chapter3\03_Types.html#type)
+
+<a name="dictionary_type"></a>
+##字典类型
+
+Swift语言中使用[`key type: value type`]来简化标准库中定义`Dictionary<Key,Value>`类型的操作。
+换句话说，下面两个声明是等价的：
+
+```swift
+let someDictionary: [String: Int] = ["Alex": 31, "Paul": 39]
+let someDictionary: Dictionary<String, Int> = ["Alex": 31, "Paul": 39]
+```
+上面两种情况，常量`someDictionary`被声明为一个字典，其中键为String类型，值为Int类型。
+
+字典中的值可以通过下标来访问，这个下标在方括号中指明了具体的键：`someDictionary["Alex"]`返回键`Alex`对应的值。如果键在字典中不存在的话，则这个下标返回`nil`。
+
+字典中键的类型必须遵循Swift标准库中的可哈希协议。
+
+关于Swift标准库中`Dictionary`类型的更多细节可查看章节Dictionaries。
+
+> 字典类型语法  
+> *字典类型* → **[**[*类型*](..\chapter3\03_Types.html#type) **:** [*类型*](..\chapter3\03_Types.html#type) **]** 
 
 <a name="optional_type"></a>
 ##可选类型
@@ -177,8 +178,6 @@ var optionalInteger: Optional<Int>
 
 如果你在声明或定义可选变量或特性的时候没有提供初始值，它的值则会自动赋成缺省值`nil`。
 
-可选符合`LogicValue`协议，因此可以出现在布尔值环境下。此时，如果一个可选类型`T?`实例包含有类型为`T`的值（也就是说值为`Optional.Some(T)`），那么此可选类型就为`true`，否则为`false`。
-
 如果一个可选类型的实例包含一个值，那么你就可以使用后缀操作符`!`来获取该值，正如下面描述的：
 
 ```swift
@@ -189,7 +188,7 @@ optionalInteger!      // 42
 
 你也可以使用可选链和可选绑定来选择性的执行可选表达式上的操作。如果值为`nil`，不会执行任何操作因此也就没有运行错误产生。
 
-更多细节以及更多如何使用可选类型的例子，见章节“可选”。
+更多细节以及更多如何使用可选类型的例子，见章节Optionals。
 
 > 可选类型语法  
 > *可选类型* → [*类型*](..\chapter3\03_Types.html#type) **?**  
@@ -205,7 +204,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
 ```
 上述两种情况下，变量`implicitlyUnwrappedString`被声明为一个隐式解析可选类型的字符串。注意类型与`!`之间没有空格。
 
-你可以在使用可选的地方同样使用隐式解析可选。比如，你可以将隐式解析可选的值赋给变量、常量和可选特性，反之亦然。
+你可以在使用可选类型的地方同样使用隐式解析可选类型。比如，你可以将隐式解析可选类型的值赋给变量、常量和可选特性，反之亦然。
 
 有了可选，你在声明隐式解析可选变量或特性的时候就不用指定初始值，因为它有缺省值`nil`。
 
@@ -213,7 +212,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
 
 使用可选链会选择性的执行隐式解析可选表达式上的某一个操作。如果值为`nil`，就不会执行任何操作，因此也不会产生运行错误。
 
-关于隐式解析可选的更多细节，见章节“隐式解析可选”。
+关于隐式解析可选的更多细节，见章节Implicitly Unwrapped Optionals。
 
 > 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法  
 > *隐式解析可选类型* → [*类型*](..\chapter3\03_Types.html#type) **!**  
@@ -221,7 +220,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
 <a name="protocol_composition_type"></a>
 ##协议合成类型
 
-协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型注解和泛型参数中。
+协议合成类型是一种遵循具体协议列表中每个协议的类型。协议合成类型可能会用在类型注解和泛型参数中。
 
 协议合成类型的形式如下：
 
@@ -229,9 +228,9 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
 protocol<Protocol 1, Procotol 2>
 ```
 
-协议合成类型允许你指定一个值，其类型可以适配多个协议的条件，而且不需要定义一个新的命名型协议来继承其它想要适配的各个协议。比如，协议合成类型`protocol<Protocol A, Protocol B, Protocol C>`等效于一个从`Protocol A`，`Protocol B`， `Protocol C`继承而来的新协议`Protocol D`，很显然这样做有效率的多，甚至不需引入一个新名字。
+协议合成类型允许你指定一个值，其类型遵循多个协议的条件且不需要定义一个新的命名型协议来继承其它想要遵循的各个协议。比如，协议合成类型`protocol<Protocol A, Protocol B, Protocol C>`等效于一个从`Protocol A`，`Protocol B`， `Protocol C`继承而来的新协议`Protocol D`，很显然这样做有效率的多，甚至不需引入一个新名字。
 
-协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能适配。
+协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能遵循。
 
 > 协议合成类型语法  
 > *协议合成类型* → **protocol** **<** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>**  
@@ -243,9 +242,9 @@ protocol<Protocol 1, Procotol 2>
 
 元类型是指所有类型的类型，包括类、结构体、枚举和协议。
 
-类、结构体或枚举类型的元类型是相应的类型名紧跟`.Type`。协议类型的元类型——并不是运行时适配该协议的具体类型——是该协议名字紧跟`.Protocol`。比如，类`SomeClass`的元类型就是`SomeClass.Type`，协议`SomeProtocol`的元类型就是`SomeProtocal.Protocol`。
+类、结构体或枚举类型的元类型是相应的类型名紧跟`.Type`。协议类型的元类型——并不是运行时遵循该协议的具体类型——是该协议名字紧跟`.Protocol`。比如，类`SomeClass`的元类型就是`SomeClass.Type`，协议`SomeProtocol`的元类型就是`SomeProtocal.Protocol`。
 
-你可以使用后缀`self`表达式来获取类型。比如，`SomeClass.self`返回`SomeClass`本身，而不是`SomeClass`的一个实例。同样，`SomeProtocol.self`返回`SomeProtocol`本身，而不是运行时适配`SomeProtocol`的某个类型的实例。还可以对类型的实例使用`dynamicType`表达式来获取该实例在运行阶段的类型，如下所示：
+你可以使用后缀`self`表达式来获取类型。比如，`SomeClass.self`返回`SomeClass`本身，而不是`SomeClass`的一个实例。同样，`SomeProtocol.self`返回`SomeProtocol`本身，而不是运行时遵循`SomeProtocol`的某个类型的实例。还可以对类型的实例使用`dynamicType`表达式来获取该实例在运行阶段的类型，如下所示：
 
 ```swift
 class SomeBaseClass {
@@ -264,29 +263,35 @@ let someInstance: SomeBaseClass = SomeSubClass()
 someInstance.dynamicType.printClassName()
 // prints "SomeSubClass
 ```
+> 注意
+> **不能创建元类型类的实例，因为不能保证其子类会提供初始化的代码。**
+
 
 > 元(Metatype)类型语法  
-> *元类型* → [*类型*](..\chapter3\03_Types.html#type) **.** **Type** | [*类型*](..\chapter3\03_Types.html#type) **.** **Protocol**  x
+> *元类型* → [*类型*](..\chapter3\03_Types.html#type) **.** **Type** | [*类型*](..\chapter3\03_Types.html#type) **.** **Protocol** 
 
 <a name="type_inheritance_clause"></a>
 ##类型继承子句
 
-类型继承子句被用来指定一个命名型类型继承哪个类且适配哪些协议。类型继承子句开始于冒号`:`，紧跟由`,`隔开的类型标识符列表。
+类型继承子句被用来指定一个命名型类型继承的哪个类、遵循的哪些协议。类型继承子句也用来指定一个类需要遵循的协议。类型继承子句开始于冒号`:`，其后是类所需遵循的协议或者类型标识符列表或者两者均有。
 
-类可以继承单个超类，适配任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要适配的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，见章节“继承”。
+类可以继承单个超类，遵循任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要遵循的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，见章节Inheritance。
 
-其它命名型类型可能只继承或适配一个协议列表。协议类型可能继承于其它任意数量的协议。当一个协议类型继承于其它协议时，其它协议的条件集合会被集成在一起，然后其它从当前协议继承的任意类型必须适配所有这些条件。
+其它命名型类型可能只继承或遵循一个协议列表。协议类型可能继承于其它任意数量的协议。当一个协议类型继承于其它协议时，其它协议的条件集合会被整合在一起，然后其它从当前协议继承的任意类型必须遵循所有这些条件。正如在协议声明中所讨论的那样，可以把类的关键字放到类型继承子句中的首位，这样就可以用一个类的条件来标记一个协议声明。
 
-枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举，一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节“原始值”。
+枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举——一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节Raw Values。
 
 > 类型继承子句语法  
-> *类型继承子句* → **:** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)  
+> *类型继承子句* → **:** [*类需求*](..\chapter3\03_Types.html#class_requirement) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list) 
+> *类型继承子句* → **:** [*类需求*](..\chapter3\03_Types.html#class_requirement)
+> *类型继承子句* → **:** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)
 > *类型继承列表* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)
+> *类需求* → **类**
 
 <a name="type_inference"></a>
 ##类型推断
 
-Swift广泛的使用类型推断，从而允许你可以忽略很多变量和表达式的类型或部分类型。比如，对于`var x: Int = 0`，你可以完全忽略类型而简写成`var x = 0`——编译器会正确的推断出`x`的类型`Int`。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了`let dict: Dictionary = ["A": 1]`，编译提也能推断出`dict`的类型是`Dictionary<String, Int>`。
+Swift广泛的使用类型推断，从而允许你可以忽略代码中很多变量和表达式的类型或部分类型。比如，对于`var x: Int = 0`，你可以完全忽略类型而简写成`var x = 0`——编译器会正确的推断出`x`的类型`Int`。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了`let dict: Dictionary = ["A": 1]`，编译提也能推断出`dict`的类型是`Dictionary<String, Int>`。
 
 在上面的两个例子中，类型信息从表达式树（expression tree）的叶子节点传向根节点。也就是说，`var x: Int = 0`中`x`的类型首先根据`0`的类型进行推断，然后将该类型信息传递到根节点（变量`x`）。
 
diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md
old mode 100755
new mode 100644
index 6f413808..bdcb7ea9
--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@@ -16,25 +16,16 @@
 
 Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary）表达式，主要（primary）表达式和后缀（postfix）表达式。表达式可以返回一个值，以及运行某些逻辑（causes a side effect）。
 
-前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述～
+前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述。
 
 > 表达式语法  
-> *表达式* → [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
+> *表达式* → [*试算子(try operator)*](..\chapter3\04_Expressions.html#*) _可选_ | [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) | [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
 > *表达式列表* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*表达式*](..\chapter3\04_Expressions.html#expression) **,** [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)  
 
 <a name="prefix_expressions"></a>
 ## 前缀表达式（Prefix Expressions）
-
-前缀表达式由 前缀符号和表达式组成。（这个前缀符号只能接收一个参数）
-
-Swift 标准库支持如下的前缀操作符：
-
-- ++ 自增1 （increment）
-- -- 自减1 （decrement）
-- ! 逻辑否 （Logical NOT ）
-- ~ 按位否 （Bitwise NOT ）
-- \+ 加（Unary plus）
-- \- 减（Unary minus）
+ 
+前缀表达式由可选的前缀符号和表达式组成。（这个前缀符号只能接收一个参数）
 
 对于这些操作符的使用，请参见： Basic Operators and Advanced Operators
 
@@ -45,6 +36,16 @@ Swift 标准库支持如下的前缀操作符：
 > *前置表达式* → [*写入写出(in-out)表达式*](..\chapter3\04_Expressions.html#in_out_expression)  
 > *写入写出(in-out)表达式* → **&** [*标识符*](LexicalStructure.html#identifier)  
 
+<a name="try_operator"></a>
+## try 操作符（try operator）
+try表达式由紧跟在可能会出错的表达式后面的`try`操作符组成，形式如下：
+    `try expression`
+强制的try表示由紧跟在可能会出错的表达式后面的`try!`操作符组成，出错时会产生一个运行时错误，形式如下：
+    `try! expression`
+关于`try`更多的例子和信息请参见：Catching and Handling Errors.
+> try表达式语法  
+> *try 操作符* → [*try*](LexicalStructure.html#try_operator) | *try!*
+
 <a name="binary_expressions"></a>
 ## 二元表达式（Binary Expressions）
 
@@ -52,76 +53,18 @@ Swift 标准库支持如下的前缀操作符：
 
 > `left-hand argument` `operator` `right-hand argument`
 
-Swift 标准库提供了如下的二元运算符：
-
-- 求幂相关（无结合，优先级160）
-  - << 按位左移（Bitwise left shift）
-  - >> 按位右移（Bitwise right shift）
-- 乘除法相关（左结合，优先级150）
-  - \* 乘
-  - / 除
-  - % 求余
-  - &* 乘法，忽略溢出（ Multiply, ignoring overflow）
-  - &/ 除法，忽略溢出（Divide, ignoring overflow）
-  - &% 求余, 忽略溢出（ Remainder, ignoring overflow）
-  - & 位与（ Bitwise AND）
-- 加减法相关（左结合, 优先级140）
-  - \+ 加
-  - \- 减
-  - &+ Add with overflow
-  - &- Subtract with overflow
-  - | 按位或（Bitwise OR ）
-  - ^ 按位异或（Bitwise XOR）
-- Range （无结合,优先级 135）
-  - ..< 半闭值域 Half-closed range
-  - ... 全闭值域 Closed range
-- 类型转换 （无结合,优先级 132）
-  - is 类型检查（ type check）
-  - as 类型转换（ type cast）
-- Comparative （无结合,优先级 130）
-  - < 小于
-  - <= 小于等于
-  - &gt; 大于
-  - &gt;= 大于等于
-  - == 等于
-  - != 不等
-  - === 恒等于
-  - !== 不恒等
-  - ~= 模式匹配（ Pattern match）
-- 合取（ Conjunctive） （左结合,优先级 120）
-  - && 逻辑与（Logical AND）
-- 析取（Disjunctive） （左结合,优先级 110）
-  - || 逻辑或（ Logical OR）
-- 三元条件（Ternary Conditional ）（右结合,优先级 100）
-  - ?: 三元条件 Ternary conditional
-- 赋值 （Assignment） （右结合, 优先级 90）
-  - = 赋值（Assign）
-  - *=  Multiply and assign
-  - /= Divide and assign
-  - %= Remainder and assign
-  - += Add and assign
-  - -= Subtract and assign
-  - <<= Left bit shift and assign
-  - &gt;&gt;= Right bit shift and assign
-  - &= Bitwise AND and assign
-  - ^= Bitwise XOR and assign
-  - |= Bitwise OR and assign
-  - &&= Logical AND and assign
-  - ||= Logical OR and assign
-
 关于这些运算符（operators）的更多信息，请参见：Basic Operators and Advanced Operators.
 
 > 注意  
 > 在解析时,  一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 * 5 首先被认为是：  2, + , `` 3``, *, 5. 随后它被转换成 tree （2 + （3 * 5））
 
-<p></p>
-
 > 二元表达式语法  
 > *二元表达式* → [*二元运算符*](LexicalStructure.html#binary_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
 > *二元表达式* → [*赋值运算符*](..\chapter3\04_Expressions.html#assignment_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
 > *二元表达式* → [*条件运算符*](..\chapter3\04_Expressions.html#conditional_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
 > *二元表达式* → [*类型转换运算符*](..\chapter3\04_Expressions.html#type_casting_operator)  
 > *二元表达式列表* → [*二元表达式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
+> *赋值操作符*
 
 
 <a name="assignment_operator"></a>
@@ -160,49 +103,43 @@ Swift 标准库提供了如下的二元运算符：
 <a name="type-casting_operators"></a>
 ## 类型转换运算符（Type-Casting Operators）
 
-有两种类型转换操作符： as 和 is.  它们有如下的形式：
+有4种类型转换运算符： `is`,`as`,`? `和`!`.  它们有如下的形式：
 
-> `expression` as `type`  
-> `expression` as? `type`  
 > `expression` is `type`  
+> `expression` as `type`  
+> `expression` is? `type`
+> `expression` as! `type`  
 
-as 运算符会把`目标表达式`转换成指定的`类型`（specified type），过程如下：
-
-- 如果类型转换成功， 那么目标表达式就会返回指定类型的实例（instance）. 例如：把子类（subclass）变成父类（superclass）时.
-- 如果转换失败，则会抛出编译错误（ compile-time error）。
-- 如果上述两个情况都不是（也就是说，编译器在编译时期无法确定转换能否成功，） 那么目标表达式就会变成指定的类型的optional. （is an optional of the specified type ） 然后在运行时，如果转换成功， 目标表达式就会作为 optional的一部分来返回， 否则，目标表达式返回nil. 对应的例子是： 把一个 superclass 转换成一个 subclass.
+`is`运算符在程序运行时检查表达式能否向下转化为指定的类型，如果可以在返回`ture`，如果不行，则返回`false`。
 
+`as`运算符在程序编译时执行类型转化，且总是成功，比如进行向上转换（upcast）和桥接（bridging）。向上转换指把表达式转换成类型的超类的一个是实例而不使用中间的变量。以下表达式是等价的：
 ```swift
-class SomeSuperType {}
-class SomeType: SomeSuperType {}
-class SomeChildType: SomeType {}
-let s = SomeType()
-
-let x = s as SomeSuperType  // known to succeed; type is SomeSuperType
-let y = s as Int            // known to fail; compile-time error
-let z = s as SomeChildType  // might fail at runtime; type is SomeChildType?
+func f(any: Any) { print("Function for Any") }
+func f(int: Int) { print("Function for Int") }
+let x = 10
+f(x)
+// prints "Function for Int"
+ 
+let y: Any = x
+f(y)
+// prints "Function for Any"
+ 
+f(x as Any)
+// prints "Function for Any"
 ```
+桥接运算可以让你把一个Swift标准库中的类型的表达式作为一个与之相关的基础类（比如NSString）来使用，而不需要新建一个实例。关于桥接的更多实例参见Using Swift with Cocoa and Objective-C中的Cocoa Data Types。
 
-使用'as'做类型转换跟正常的类型声明，对于编译器来说是一样的。例如：
+`as?`操作符为带条件的类型转换。`as?`操作符返回可选的转换类型。在运行时，如果转换成功，表达式的值会被覆盖掉再返回，如果转换不成功的话，则返回`nil`。如果条件转换中的条件的真值一开始就已经确定真伪了，则在编译时会报错。
 
-```swift
-let y1 = x as SomeType  // Type information from 'as'
-let y2: SomeType = x    // Type information from an annotation
-```
-
-'is' 运算符在“运行时（runtime）”会做检查。 成功会返回true, 否则 false
-
-上述检查在“编译时（compile time）”不能使用。 例如下面的使用是错误的：
-
-```swift
-"hello" is String
-"hello" is Int
-```
+`a!`操作符表示强制转换，其返回指定的类型，而不是可选的类型。如果转换失败，则会出现运行时错误。表达式`x as T` 效果等同于`(x as? T)!`。
 
 关于类型转换的更多内容和例子，请参见： Type Casting.
 
 > 类型转换运算符(type-casting-operator)语法  
-> *类型转换运算符* → **is** [*类型*](..\chapter3\03_Types.html#type) | **as** **?** _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *类型转换运算符* → **is** [*类型*](..\chapter3\03_Types.html#type) 
+> *类型转换运算符* → **as** [*类型*](..\chapter3\03_Types.html#type) 
+> *类型转换运算符* → **is** **?** [*类型*](..\chapter3\03_Types.html#type) 
+> *类型转换运算符* → **as** **!** [*类型*](..\chapter3\03_Types.html#type)  
 
 <a name="primary_expressions"></a>
 ## 主表达式（Primary Expressions）
@@ -211,7 +148,7 @@ let y2: SomeType = x    // Type information from an annotation
 
 > 主表达式语法  
 > *主表达式* → [*标识符*](LexicalStructure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
-> *主表达式* → [*字面量表达式*](..\chapter3\04_Expressions.html#literal_expression)  
+> *主表达式* → [*字符型表达式*](..\chapter3\04_Expressions.html#literal_expression)  
 > *主表达式* → [*self表达式*](..\chapter3\04_Expressions.html#self_expression)  
 > *主表达式* → [*超类表达式*](..\chapter3\04_Expressions.html#superclass_expression)  
 > *主表达式* → [*闭包表达式*](..\chapter3\04_Expressions.html#closure_expression)  
@@ -232,18 +169,36 @@ let y2: SomeType = x    // Type information from an annotation
 
 在某个函数（function）中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在特殊的成员如init/subscript中 会返回这个关键字的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。
 
-一个array literal，是一个有序的值的集合。 它的形式是：
+当作为函数或者方法时，字符型表达式的值在被调用时初始化。
+```swift
+func logFunctionName(string: String = __FUNCTION__) {
+    print(string)
+}
+func myFunction() {
+    logFunctionName() // Prints "myFunction()".
+}
+ 
+myFunction()
+namedArgs(1, withJay: 2)
+```
+
+一个`array literal`，是一个有序的值的集合。 它的形式是：
 
 > [`value 1`, `value 2`, `...`]
 
-数组中的最后一个表达式可以紧跟一个逗号（','）. []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共supertype最接近的type.（closest common supertype）
+数组中的最后一个表达式可以紧跟一个逗号（','）. []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共`supertype`最接近的type.空的`array literal`由一组方括号定义，可用来创建特定类型的空数组。
+```swift
+var emptyArray: [Double] = []
+```
 
 一个`dictionary literal` 是一个包含无序的键值对（key-value pairs）的集合，它的形式是:
 
 > [`key 1`: `value 1`, `key 2`: `value 2`, `...`]
 
-dictionary 的最后一个表达式可以是一个逗号（','）. [:] 表示一个空的dictionary. 它的type是 Dictionary<KeyType, ValueType> （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.
-
+dictionary 的最后一个表达式可以是一个逗号（','）. [:] 表示一个空的dictionary. 它的type是 Dictionary<KeyType, ValueType> （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.一个空的dictionary literal由方括号中加一个冒号组成，以此来与空array literal区分开，可以使用空的dictionary literal来创建特定类型的键值对。
+```swift
+var emptyDictionary: [String: Double]=[:]
+```
 > 字面量表达式语法  
 > *字面量表达式* → [*字面量*](LexicalStructure.html#literal)  
 > *字面量表达式* → [*数组字面量*](..\chapter3\04_Expressions.html#array_literal) | [*字典字面量*](..\chapter3\04_Expressions.html#dictionary_literal)  
@@ -531,8 +486,7 @@ t.0 = t.1
 // Now t is （20, 20, 30）
 ```
 
-The members of a module access the top-level declarations of that module.
-（不确定：对于某个module的member的调用，只能调用在top-level声明中的member.）
+对于某个module的member的调用，只能调用在top-level声明中的member.
 
 > 显式成员表达式语法  
 > *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit)  
@@ -604,6 +558,16 @@ someInstance.dynamicType.printClassName（）
 > `expression`!
 
 如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误（runtime error）。
+返回的值可能会被需改，可以是被赋值了，也可以是出现异常造成的。比如：
+```swift
+var x: Int? = 0
+x!++
+// x is now 1
+ 
+var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
+someDictionary["a"]![0] = 100
+// someDictionary is now [b: [10, 20], a: [100, 2, 3]] 
+```
 
 > 强制取值(Forced Value)语法  
 > *强制取值(Forced Value)表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **!**  
@@ -632,6 +596,22 @@ if let unwrappedC = c {
     result = unwrappedC.property.performAction（）
 }
 ```
+后缀'?' 返回目标表达式的值可能会被修改，可能是由于出现了赋值，也有可能是出现异常而产生的修改。如果可选链表达式为`nil`，则表达式右边的复制操作不会被执行。比如：
+```swift
+func someFunctionWithSideEffects() -> Int {
+    return 42  // No actual side effects.
+}
+var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
+ 
+someDictionary["not here"]?[0] = someFunctionWithSideEffects()
+// someFunctionWithSideEffects is not evaluated
+// someDictionary is still [b: [10, 20], a: [1, 2, 3]]
+ 
+someDictionary["a"]?[0] = someFunctionWithSideEffects()
+// someFunctionWithSideEffects is evaluated and returns 42
+// someDictionary is now [b: [10, 20], a: [42, 2, 3]]
+```
+
 
 > 可选链表达式语法  
 > *可选链表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **?**  

From bea57c8ffbb925c4eaaca12c3f6fdc071fdc6b8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Fri, 10 Jul 2015 23:04:56 +0800
Subject: [PATCH 111/228] =?UTF-8?q?=E6=96=B0=E7=89=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/14_Initialization.md   | 1951 ++++++++++++------------
 source/chapter2/15_Deinitialization.md |  216 +--
 2 files changed, 1117 insertions(+), 1050 deletions(-)

diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 7059c09b..59c57e4c 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -1,942 +1,1009 @@
-> 翻译：[lifedim](https://github.com/lifedim)  
-> 校对：[lifedim](https://github.com/lifedim)
-
-# 构造过程（Initialization）
-
------------------
-
-本页包含内容：
-
-- [存储型属性的初始赋值](#setting_initial_values_for_stored_properties)
-- [定制化构造过程](#customizing_initialization)
-- [默认构造器](#default_initializers)
-- [值类型的构造器代理](#initializer_delegation_for_value_types)
-- [类的继承和构造过程](#class_inheritance_and_initialization)
-- [可失败构造器](#failable_initializers)
-- [必要构造器](#required_initializers) 
-- [通过闭包和函数来设置属性的默认值](#setting_a_default_property_value_with_a_closure_or_function)
-
-
-构造过程是为了使用某个类、结构体或枚举类型的实例而进行的准备过程。这个过程包含了为实例中的每个属性设置初始值和为其执行必要的准备和初始化任务。
-
-构造过程是通过定义构造器（`Initializers`）来实现的，这些构造器可以看做是用来创建特定类型实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。
-
-类实例也可以通过定义析构器（`deinitializer`）在类实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](../chapter2/15_Deinitialization.html)。
-
-<a name="setting_initial_values_for_stored_properties"></a>
-## 存储型属性的初始赋值
-
-类和结构体在实例创建时，必须为所有存储型属性设置合适的初始值。存储型属性的值不能处于一个未知的状态。
-
-你可以在构造器中为存储型属性赋初值，也可以在定义属性时为其设置默认值。以下章节将详细介绍这两种方法。
-
->注意：  
-当你为存储型属性设置默认值或者在构造器中为其赋值时，它们的值是被直接设置的，不会触发任何属性观测器（`property observers`）。
-
-### 构造器
-
-构造器在创建某特定类型的新实例时调用。它的最简形式类似于一个不带任何参数的实例方法，以关键字`init`命名。
-
-下面例子中定义了一个用来保存华氏温度的结构体`Fahrenheit`，它拥有一个`Double`类型的存储型属性`temperature`：
-
-```swift
-struct Fahrenheit {
-    var temperature: Double
-    init() {
-        temperature = 32.0
-    }
-}
-```
-
-```swift
-var f = Fahrenheit()
-println("The default temperature is \(f.temperature)° Fahrenheit")
-// 输出 "The default temperature is 32.0° Fahrenheit”
-```
-
-这个结构体定义了一个不带参数的构造器`init`，并在里面将存储型属性`temperature`的值初始化为`32.0`（华摄氏度下水的冰点）。
-
-### 默认属性值
-
-如前所述，你可以在构造器中为存储型属性设置初始值；同样，你也可以在属性声明时为其设置默认值。
-
->注意：  
-如果一个属性总是使用同一个初始值，可以为其设置一个默认值。无论定义默认值还是在构造器中赋值，最终它们实现的效果是一样的，只不过默认值将属性的初始化和属性的声明结合的更紧密。使用默认值能让你的构造器更简洁、更清晰，且能通过默认值自动推导出属性的类型；同时，它也能让你充分利用默认构造器、构造器继承（后续章节将讲到）等特性。
-
-你可以使用更简单的方式在定义结构体`Fahrenheit`时为属性`temperature`设置默认值：
-
-```swift
-struct Fahrenheit {
-    var temperature = 32.0
-}
-```
-
-<a name="customizing_initialization"></a>
-## 定制化构造过程
-
-你可以通过输入参数和可选属性类型来定制构造过程，也可以在构造过程中修改常量属性。这些都将在后面章节中提到。
-
-### 构造参数
-
-你可以在定义构造器时提供构造参数，为其提供定制化构造所需值的类型和名字。构造器参数的功能和语法跟函数和方法参数相同。
-
-下面例子中定义了一个包含摄氏度温度的结构体`Celsius`。它定义了两个不同的构造器：`init(fromFahrenheit:)`和`init(fromKelvin:)`，二者分别通过接受不同刻度表示的温度值来创建新的实例：
-
-```swift
-struct Celsius {
-    var temperatureInCelsius: Double = 0.0
-    init(fromFahrenheit fahrenheit: Double) {
-        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
-    }
-    init(fromKelvin kelvin: Double) {
-        temperatureInCelsius = kelvin - 273.15
-    }
-}
-```
-
-```swift
-let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
-// boilingPointOfWater.temperatureInCelsius 是 100.0
-let freezingPointOfWater = Celsius(fromKelvin: 273.15)
-// freezingPointOfWater.temperatureInCelsius 是 0.0”
-```
-
-第一个构造器拥有一个构造参数，其外部名字为`fromFahrenheit`，内部名字为`fahrenheit`；第二个构造器也拥有一个构造参数，其外部名字为`fromKelvin`，内部名字为`kelvin`。这两个构造器都将唯一的参数值转换成摄氏温度值，并保存在属性`temperatureInCelsius`中。
-
-### 内部和外部参数名
-
-跟函数和方法参数相同，构造参数也存在一个在构造器内部使用的参数名字和一个在调用构造器时使用的外部参数名字。
-
-然而，构造器并不像函数和方法那样在括号前有一个可辨别的名字。所以在调用构造器时，主要通过构造器中的参数名和类型来确定需要调用的构造器。正因为参数如此重要，如果你在定义构造器时没有提供参数的外部名字，Swift 会为每个构造器的参数自动生成一个跟内部名字相同的外部名，就相当于在每个构造参数之前加了一个哈希符号。
-
-> 注意：  
-如果你不希望为构造器的某个参数提供外部名字，你可以使用下划线`_`来显示描述它的外部名，以此覆盖上面所说的默认行为。
-
-以下例子中定义了一个结构体`Color`，它包含了三个常量：`red`、`green`和`blue`。这些属性可以存储0.0到1.0之间的值，用来指示颜色中红、绿、蓝成分的含量。
-
-`Color`提供了一个构造器，其中包含三个`Double`类型的构造参数：
-
-```swift
-struct Color {
-    let red, green, blue: Double
-    init(red: Double, green: Double, blue: Double) {
-        self.red   = red
-        self.green = green
-        self.blue  = blue
-    }
-    init(white: Double) {
-        red   = white
-        green = white
-        blue  = white
-    }
-}
-```
-
-每当你创建一个新的`Color`实例，你都需要通过三种颜色的外部参数名来传值，并调用构造器。
-
-```swift
-let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
-let halfGray = Color(white: 0.5)
-```
-
-注意，如果不通过外部参数名字传值，你是没法调用这个构造器的。只要构造器定义了某个外部参数名，你就必须使用它，忽略它将导致编译错误：
-
-```swift
-let veryGreen = Color(0.0, 1.0, 0.0)
-// 报编译时错误，需要外部名称
-```
-
-### 可选属性类型
-
-如果你定制的类型包含一个逻辑上允许取值为空的存储型属性--不管是因为它无法在初始化时赋值，还是因为它可以在之后某个时间点可以赋值为空--你都需要将它定义为可选类型`optional type`。可选类型的属性将自动初始化为空`nil`，表示这个属性是故意在初始化时设置为空的。
-
-下面例子中定义了类`SurveyQuestion`，它包含一个可选字符串属性`response`：
-
-```swift
-class SurveyQuestion {
-    var text: String
-    var response: String?
-    init(text: String) {
-        self.text = text
-    }
-    func ask() {
-        println(text)
-    }
-}
-let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
-cheeseQuestion.ask()
-// 输出 "Do you like cheese?"
-cheeseQuestion.response = "Yes, I do like cheese."
-```
-
-调查问题在问题提出之后，我们才能得到回答。所以我们将属性回答`response`声明为`String?`类型，或者说是可选字符串类型`optional String`。当`SurveyQuestion`实例化时，它将自动赋值为空`nil`，表明暂时还不存在此字符串。
-
-### 构造过程中常量属性的修改
-
-只要在构造过程结束前常量的值能确定，你可以在构造过程中的任意时间点修改常量属性的值。
-
->注意：  
-对某个类实例来说，它的常量属性只能在定义它的类的构造过程中修改；不能在子类中修改。
-
-你可以修改上面的`SurveyQuestion`示例，用常量属性替代变量属性`text`，指明问题内容`text`在其创建之后不会再被修改。尽管`text`属性现在是常量，我们仍然可以在其类的构造器中设置它的值：
-
-```swift
-class SurveyQuestion {
-    let text: String
-    var response: String?
-    init(text: String) {
-        self.text = text
-    }
-    func ask() {
-        println(text)
-    }
-}
-let beetsQuestion = SurveyQuestion(text: "How about beets?")
-beetsQuestion.ask()
-// 输出 "How about beets?"
-beetsQuestion.response = "I also like beets. (But not with cheese.)"
-```
-
-<a name="default_initializers"></a>
-## 默认构造器
-
-Swift 将为所有属性已提供默认值的且自身没有定义任何构造器的结构体或基类，提供一个默认的构造器。这个默认构造器将简单的创建一个所有属性值都设置为默认值的实例。
-
-下面例子中创建了一个类`ShoppingListItem`，它封装了购物清单中的某一项的属性：名字（`name`）、数量（`quantity`）和购买状态 `purchase state`。
-
-```swift
-class ShoppingListItem {
-    var name: String?
-    var quantity = 1
-    var purchased = false
-}
-var item = ShoppingListItem()
-```
-
-由于`ShoppingListItem`类中的所有属性都有默认值，且它是没有父类的基类，它将自动获得一个可以为所有属性设置默认值的默认构造器（尽管代码中没有显式为`name`属性设置默认值，但由于`name`是可选字符串类型，它将默认设置为`nil`）。上面例子中使用默认构造器创造了一个`ShoppingListItem`类的实例（使用`ShoppingListItem()`形式的构造器语法），并将其赋值给变量`item`。
-
-### 结构体的逐一成员构造器
-
-除上面提到的默认构造器，如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。
-
-逐一成员构造器是用来初始化结构体新实例里成员属性的快捷方法。我们在调用逐一成员构造器时，通过与成员属性名相同的参数名进行传值来完成对成员属性的初始赋值。
-
-下面例子中定义了一个结构体`Size`，它包含两个属性`width`和`height`。Swift 可以根据这两个属性的初始赋值`0.0`自动推导出它们的类型`Double`。
-
-由于这两个存储型属性都有默认值，结构体`Size`自动获得了一个逐一成员构造器 `init(width:height:)`。 你可以用它来为`Size`创建新的实例：
-
-```swift
-struct Size {
-    var width = 0.0, height = 0.0
-}
-let twoByTwo = Size(width: 2.0, height: 2.0)
-```
-
-<a name="initializer_delegation_for_value_types"></a>
-## 值类型的构造器代理
-
-构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。
-
-构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](../chapter2/13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
-
-对于值类型，你可以使用`self.init`在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用`self.init`。
-
-注意，如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。
-
->注意：  
-假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](../chapter2/20_Extensions.html)章节。
-
-下面例子将定义一个结构体`Rect`，用来代表几何矩形。这个例子需要两个辅助的结构体`Size`和`Point`，它们各自为其所有的属性提供了初始值`0.0`。
-
-```swift
-struct Size {
-    var width = 0.0, height = 0.0
-}
-struct Point {
-    var x = 0.0, y = 0.0
-}
-```
-
-你可以通过以下三种方式为`Rect`创建实例--使用默认的0值来初始化`origin`和`size`属性；使用特定的`origin`和`size`实例来初始化；使用特定的`center`和`size`来初始化。在下面`Rect`结构体定义中，我们为这三种方式提供了三个自定义的构造器：
-
-```swift
-struct Rect {
-    var origin = Point()
-    var size = Size()
-    init() {}
-    init(origin: Point, size: Size) {
-        self.origin = origin
-        self.size = size
-    }
-    init(center: Point, size: Size) {
-        let originX = center.x - (size.width / 2)
-        let originY = center.y - (size.height / 2)
-        self.init(origin: Point(x: originX, y: originY), size: size)
-    }
-}
-```
-
-第一个`Rect`构造器`init()`，在功能上跟没有自定义构造器时自动获得的默认构造器是一样的。这个构造器是一个空函数，使用一对大括号`{}`来描述，它没有执行任何定制的构造过程。调用这个构造器将返回一个`Rect`实例，它的`origin`和`size`属性都使用定义时的默认值`Point(x: 0.0, y: 0.0)`和`Size(width: 0.0, height: 0.0)`：
-
-```swift
-let basicRect = Rect()
-// basicRect 的原点是 (0.0, 0.0)，尺寸是 (0.0, 0.0)
-```
-
-第二个`Rect`构造器`init(origin:size:)`，在功能上跟结构体在没有自定义构造器时获得的逐一成员构造器是一样的。这个构造器只是简单地将`origin`和`size`的参数值赋给对应的存储型属性：
-
-```swift
-let originRect = Rect(origin: Point(x: 2.0, y: 2.0),
-    size: Size(width: 5.0, height: 5.0))
-// originRect 的原点是 (2.0, 2.0)，尺寸是 (5.0, 5.0)
-```
-
-第三个`Rect`构造器`init(center:size:)`稍微复杂一点。它先通过`center`和`size`的值计算出`origin`的坐标。然后再调用（或代理给）`init(origin:size:)`构造器来将新的`origin`和`size`值赋值到对应的属性中：
-
-```swift
-let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
-    size: Size(width: 3.0, height: 3.0))
-// centerRect 的原点是 (2.5, 2.5)，尺寸是 (3.0, 3.0)
-```
-
-构造器`init(center:size:)`可以自己将`origin`和`size`的新值赋值到对应的属性中。然而尽量利用现有的构造器和它所提供的功能来实现`init(center:size:)`的功能，是更方便、更清晰和更直观的方法。
-
->注意：  
-如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](../chapter2/20_Extensions.html)。
-
-<a name="class_inheritance_and_initialization"></a>
-## 类的继承和构造过程
-
-类里面的所有存储型属性--包括所有继承自父类的属性--都必须在构造过程中设置初始值。
-
-Swift 提供了两种类型的类构造器来确保所有类实例中存储型属性都能获得初始值，它们分别是指定构造器和便利构造器。
-
-### 指定构造器和便利构造器
-
-指定构造器是类中最主要的构造器。一个指定构造器将初始化类中提供的所有属性，并根据父类链往上调用父类的构造器来实现父类的初始化。
-
-每一个类都必须拥有至少一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节[自动构造器的继承](#automatic_initializer_inheritance)。
-
-便利构造器是类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为其参数提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入的实例。
-
-你应当只在必要的时候为类提供便利构造器，比方说某种情况下通过使用便利构造器来快捷调用某个指定构造器，能够节省更多开发时间并让类的构造过程更清晰明了。
-
-<a name="initialization_chain"></a>
-### 构造器链
-
-为了简化指定构造器和便利构造器之间的调用关系，Swift 采用以下三条规则来限制构造器之间的代理调用：
-
-#### 规则 1
-指定构造器必须调用其直接父类的的指定构造器。
-
-#### 规则 2
-便利构造器必须调用同一类中定义的其它构造器。
-
-#### 规则 3
-便利构造器必须最终以调用一个指定构造器结束。
-
-一个更方便记忆的方法是：
-
-- 指定构造器必须总是向上代理
-- 便利构造器必须总是横向代理
-
-这些规则可以通过下面图例来说明：
-
-![构造器代理图](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializerDelegation01_2x.png)
-
-如图所示，父类中包含一个指定构造器和两个便利构造器。其中一个便利构造器调用了另外一个便利构造器，而后者又调用了唯一的指定构造器。这满足了上面提到的规则2和3。这个父类没有自己的父类，所以规则1没有用到。
-
-子类中包含两个指定构造器和一个便利构造器。便利构造器必须调用两个指定构造器中的任意一个，因为它只能调用同一个类里的其他构造器。这满足了上面提到的规则2和3。而两个指定构造器必须调用父类中唯一的指定构造器，这满足了规则1。
-
-> 注意：  
-这些规则不会影响使用时，如何用类去创建实例。任何上图中展示的构造器都可以用来完整创建对应类的实例。这些规则只在实现类的定义时有影响。
-
-下面图例中展示了一种针对四个类的更复杂的类层级结构。它演示了指定构造器是如何在类层级中充当“管道”的作用，在类的构造器链上简化了类之间的相互关系。
-
-![复杂构造器代理图](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializerDelegation02_2x.png)
-
-<a name="two_phase_initialization"></a>
-### 两段式构造过程
-
-Swift 中类的构造过程包含两个阶段。第一个阶段，每个存储型属性通过引入它们的类的构造器来设置初始值。当每一个存储型属性值被确定后，第二阶段开始，它给每个类一次机会在新实例准备使用之前进一步定制它们的存储型属性。
-
-两段式构造过程的使用让构造过程更安全，同时在整个类层级结构中给予了每个类完全的灵活性。两段式构造过程可以防止属性值在初始化之前被访问；也可以防止属性被另外一个构造器意外地赋予不同的值。
-
-> 注意：  
-Swift的两段式构造过程跟 Objective-C 中的构造过程类似。最主要的区别在于阶段 1，Objective-C 给每一个属性赋值`0`或空值（比如说`0`或`nil`）。Swift  的构造流程则更加灵活，它允许你设置定制的初始值，并自如应对某些属性不能以`0`或`nil`作为合法默认值的情况。
-
-Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造过程能顺利完成：
-
-#### 安全检查 1
-
-指定构造器必须保证它所在类引入的所有属性都必须先初始化完成，之后才能将其它构造任务向上代理给父类中的构造器。
-
-如上所述，一个对象的内存只有在其所有存储型属性确定之后才能完全初始化。为了满足这一规则，指定构造器必须保证它所在类引入的属性在它往上代理之前先完成初始化。
-
-#### 安全检查 2
-
-指定构造器必须先向上代理调用父类构造器，然后再为继承的属性设置新值。如果没这么做，指定构造器赋予的新值将被父类中的构造器所覆盖。
-
-#### 安全检查 3
-
-便利构造器必须先代理调用同一类中的其它构造器，然后再为任意属性赋新值。如果没这么做，便利构造器赋予的新值将被同一类中其它指定构造器所覆盖。
-
-#### 安全检查 4
-
-构造器在第一阶段构造完成之前，不能调用任何实例方法、不能读取任何实例属性的值，`self`的值不能被引用。
-
-类实例在第一阶段结束以前并不是完全有效，仅能访问属性和调用方法，一旦完成第一阶段，该实例才会声明为有效实例。
-
-以下是两段式构造过程中基于上述安全检查的构造流程展示：
-
-#### 阶段 1
-
-- 某个指定构造器或便利构造器被调用；
-- 完成新实例内存的分配，但此时内存还没有被初始化；
-- 指定构造器确保其所在类引入的所有存储型属性都已赋初值。存储型属性所属的内存完成初始化；
-- 指定构造器将调用父类的构造器，完成父类属性的初始化；
-- 这个调用父类构造器的过程沿着构造器链一直往上执行，直到到达构造器链的最顶部；
-- 当到达了构造器链最顶部，且已确保所有实例包含的存储型属性都已经赋值，这个实例的内存被认为已经完全初始化。此时阶段1完成。
-
-#### 阶段 2
-
-- 从顶部构造器链一直往下，每个构造器链中类的指定构造器都有机会进一步定制实例。构造器此时可以访问`self`、修改它的属性并调用实例方法等等。
-- 最终，任意构造器链中的便利构造器可以有机会定制实例和使用`self`。
-
-下图展示了在假定的子类和父类之间构造的阶段1：
-·
-![构造过程阶段1](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/twoPhaseInitialization01_2x.png)
-
-在这个例子中，构造过程从对子类中一个便利构造器的调用开始。这个便利构造器此时没法修改任何属性，它把构造任务代理给同一类中的指定构造器。
-
-如安全检查1所示，指定构造器将确保所有子类的属性都有值。然后它将调用父类的指定构造器，并沿着造器链一直往上完成父类的构建过程。
-
-父类中的指定构造器确保所有父类的属性都有值。由于没有更多的父类需要构建，也就无需继续向上做构建代理。
-
-一旦父类中所有属性都有了初始值，实例的内存被认为是完全初始化，而阶段1也已完成。
-
-以下展示了相同构造过程的阶段2：
-
-![构建过程阶段2](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/twoPhaseInitialization02_2x.png)
-
-父类中的指定构造器现在有机会进一步来定制实例（尽管它没有这种必要）。
-
-一旦父类中的指定构造器完成调用，子类的构指定构造器可以执行更多的定制操作（同样，它也没有这种必要）。
-
-最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。
-
-### 构造器的继承和重载
-
-跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。
-
-假如你希望自定义的子类中能实现一个或多个跟父类相同的构造器--也许是为了完成一些定制的构造过程--你可以在你定制的子类中提供和重载与父类相同的构造器。
-
-如果你重载的构造器是一个指定构造器，你可以在子类里重载它的实现，并在自定义版本的构造器中调用父类版本的构造器。
-
-如果你重载的构造器是一个便利构造器，你的重载过程必须通过调用同一类中提供的其它指定构造器来实现。这一规则的详细内容请参考[构造器链](#initialization_chain)。
-
->注意：  
-与方法、属性和下标不同，在重载构造器时你没有必要使用关键字`override`。
-
-<a name="automatic_initializer_inheritance"></a>
-### 自动构造器的继承
-
-如上所述，子类不会默认继承父类的构造器。但是如果特定条件可以满足，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重载父类的构造器，并且在尽可能安全的情况下以最小的代价来继承父类的构造器。
-
-假设要为子类中引入的任意新属性提供默认值，请遵守以下2个规则：
-
-#### 规则 1
-
-如果子类没有定义任何指定构造器，它将自动继承所有父类的指定构造器。
-
-#### 规则 2
-
-如果子类提供了所有父类指定构造器的实现--不管是通过规则1继承过来的，还是通过自定义实现的--它将自动继承所有父类的便利构造器。
-
-即使你在子类中添加了更多的便利构造器，这两条规则仍然适用。
-
->注意：  
-子类可以通过部分满足规则2的方式，使用子类便利构造器来实现父类的指定构造器。
-
-### 指定构造器和便利构造器的语法
-
-类的指定构造器的写法跟值类型简单构造器一样：
-
-```swift
-init(parameters) {
-    statements
-}
-```
-
-便利构造器也采用相同样式的写法，但需要在`init`关键字之前放置`convenience`关键字，并使用空格将它们俩分开：
-
-```swift
-convenience init(parameters) {
-    statements
-}
-```
-
-### 指定构造器和便利构造器实战
-
-接下来的例子将在实战中展示指定构造器、便利构造器和自动构造器的继承。它定义了包含三个类`Food`、`RecipeIngredient`以及`ShoppingListItem`的类层次结构，并将演示它们的构造器是如何相互作用的。
-
-类层次中的基类是`Food`，它是一个简单的用来封装食物名字的类。`Food`类引入了一个叫做`name`的`String`类型属性，并且提供了两个构造器来创建`Food`实例：
-
-```swift
-class Food {
-    var name: String
-    init(name: String) {
-        self.name = name
-    }
-    convenience init() {
-        self.init(name: "[Unnamed]")
-    }
-}
-```
-
-下图中展示了`Food`的构造器链：
-
-![Food构造器链](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializersExample01_2x.png)
-
-类没有提供一个默认的逐一成员构造器，所以`Food`类提供了一个接受单一参数`name`的指定构造器。这个构造器可以使用一个特定的名字来创建新的`Food`实例：
-
-```swift
-let namedMeat = Food(name: "Bacon")
-// namedMeat 的名字是 "Bacon”
-```
-
-`Food`类中的构造器`init(name: String)`被定义为一个指定构造器，因为它能确保所有新`Food`实例的中存储型属性都被初始化。`Food`类没有父类，所以`init(name: String)`构造器不需要调用`super.init()`来完成构造。
-
-`Food`类同样提供了一个没有参数的便利构造器 `init()`。这个`init()`构造器为新食物提供了一个默认的占位名字，通过代理调用同一类中定义的指定构造器`init(name: String)`并给参数`name`传值`[Unnamed]`来实现：
-
-```swift
-let mysteryMeat = Food()
-// mysteryMeat 的名字是 [Unnamed]
-```
-
-类层级中的第二个类是`Food`的子类`RecipeIngredient`。`RecipeIngredient`类构建了食谱中的一味调味剂。它引入了`Int`类型的数量属性`quantity`（以及从`Food`继承过来的`name`属性），并且定义了两个构造器来创建`RecipeIngredient`实例：
-
-```swift
-class RecipeIngredient: Food {
-    var quantity: Int
-    init(name: String, quantity: Int) {
-        self.quantity = quantity
-        super.init(name: name)
-    }
-    override convenience init(name: String) {
-        self.init(name: name, quantity: 1)
-    }
-}
-```
-
-下图中展示了`RecipeIngredient`类的构造器链：
-
-![RecipeIngredient构造器](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializersExample02_2x.png)
-
-`RecipeIngredient`类拥有一个指定构造器`init(name: String, quantity: Int)`，它可以用来产生新`RecipeIngredient`实例的所有属性值。这个构造器一开始先将传入的`quantity`参数赋值给`quantity`属性，这个属性也是唯一在`RecipeIngredient`中新引入的属性。随后，构造器将任务向上代理给父类`Food`的`init(name: String)`。这个过程满足[两段式构造过程](#two_phase_initialization)中的安全检查1。
-
-`RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。
-
-注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识。
-
-在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
-
-所有的这三种构造器都可以用来创建新的`RecipeIngredient`实例：
-
-```swift
-let oneMysteryItem = RecipeIngredient()
-let oneBacon = RecipeIngredient(name: "Bacon")
-let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
-```
-
-类层级中第三个也是最后一个类是`RecipeIngredient`的子类，叫做`ShoppingListItem`。这个类构建了购物单中出现的某一种调味料。
-
-购物单中的每一项总是从`unpurchased`未购买状态开始的。为了展现这一事实，`ShoppingListItem`引入了一个布尔类型的属性`purchased`，它的默认值是`false`。`ShoppingListItem`还添加了一个计算型属性`description`，它提供了关于`ShoppingListItem`实例的一些文字描述：
-
-```swift
-class ShoppingListItem: RecipeIngredient {
-    var purchased = false
-    var description: String {
-    var output = "\(quantity) x \(name.lowercaseString)"
-        output += purchased ? " ✔" : " ✘"
-        return output
-    }
-}
-```
-
-> 注意：  
-`ShoppingListItem`没有定义构造器来为`purchased`提供初始化值，这是因为任何添加到购物单的项的初始状态总是未购买。
-
-由于它为自己引入的所有属性都提供了默认值，并且自己没有定义任何构造器，`ShoppingListItem`将自动继承所有父类中的指定构造器和便利构造器。
-
-下图种展示了所有三个类的构造器链：
-
-![三类构造器图](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializersExample03_2x.png)
-
-你可以使用全部三个继承来的构造器来创建`ShoppingListItem`的新实例：
-
-```swift
-var breakfastList = [
-    ShoppingListItem(),
-    ShoppingListItem(name: "Bacon"),
-    ShoppingListItem(name: "Eggs", quantity: 6),
-]
-breakfastList[0].name = "Orange juice"
-breakfastList[0].purchased = true
-for item in breakfastList {
-    println(item.description)
-}
-// 1 x orange juice ✔
-// 1 x bacon ✘
-// 6 x eggs ✘
-```
-
-如上所述，例子中通过字面量方式创建了一个新数组`breakfastList`，它包含了三个新的`ShoppingListItem`实例，因此数组的类型也能自动推导为`ShoppingListItem[]`。在数组创建完之后，数组中第一个`ShoppingListItem`实例的名字从`[Unnamed]`修改为`Orange juice`，并标记为已购买。接下来通过遍历数组每个元素并打印它们的描述值，展示了所有项当前的默认状态都已按照预期完成了赋值。
-
-<a name="failable_initializers"></a>
-## 可失败构造器 
-
-如果一个类，结构体或枚举类型的对象，在构造自身的过程中有可能失败，则为其定义一个可失败构造器，是非常有必要的。这里所指的“失败”是指，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。
-
-为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在`init`关键字后面加添问号`(init?)`。
-
-> 注意： 
-> 
-> 可失败构造器的参数名和参数类型，不能与其它非可失败构造器的参数名，及其类型相同。
-
-可失败构造器，在构建对象的过程中，创建一个其自身类型为可选类型的对象。你通过`return nil` 语句，来表明可失败构造器在何种情况下“失败”。
-
-> 注意：
->
-> 严格来说，构造器都不支持返回值。因为构造器本身的作用，只是为了能确保对象自身能被正确构建。所以即使你在表明可失败构造器，失败的这种情况下，用到了`return nil`。也不要在表明可失败构造器成功的这种情况下，使用关键字 `return`。
-
-下例中，定义了一个名为`Animal`的结构体，其中有一个名为`species`的，`String`类型的常量属性。同时该结构体还定义了一个，带一个`String`类型参数`species`的,可失败构造器。这个可失败构造器，被用来检查传入的参数是否为一个空字符串，如果为空字符串，则该可失败构造器，构建对象失败，否则成功。
-
-```swift
-struct Animal {
-    let species: String
-    init?(species: String) {
-        if species.isEmpty { return nil }
-        self.species = species
-    }
-}
-```
-
-你可以通过该可失败构造器来构建一个Animal的对象，并检查其构建过程是否成功。
-
-```swift
-let someCreature = Animal(species: "Giraffe")
-// someCreature 的类型是 Animal? 而不是 Animal
- 
-if let giraffe = someCreature {
-    println("An animal was initialized with a species of \(giraffe.species)")
-}
-// 打印 "An animal was initialized with a species of Giraffe"
-```
-
-如果你给该可失败构造器传入一个空字符串作为其参数，则该可失败构造器失败。
-
-```swift
-let anonymousCreature = Animal(species: "")
-// anonymousCreature 的类型是 Animal?, 而不是 Animal
- 
-if anonymousCreature == nil {
-    println("The anonymous creature could not be initialized")
-}
-// 打印 "The anonymous creature could not be initialized"
-```
-
-> 注意：
->
-> 空字符串（```""```）和一个值为```nil```的可选类型的字符串是两个完全不同的概念。上例中的空字符串（`""`）其实是一个有效的，非可选类型的字符串。这里我们只所以让`Animal`的可失败构造器，构建对象失败，只是因为对于`Animal`这个类的`species`属性来说，它更适合有一个具体的值，而不是空字符串。
-
-###枚举类型的可失败构造器
-
-你可以通过构造一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。还能在参数不满足你所期望的条件时，导致构造失败。
-
-下例中，定义了一个名为TemperatureUnit的枚举类型。其中包含了三个可能的枚举成员(```Kelvin```，```Celsius```，和 ```Fahrenheit```)和一个被用来找到```Character```值所对应的枚举成员的可失败构造器：
-
-```swift
-enum TemperatureUnit {
-    case Kelvin, Celsius, Fahrenheit
-    init?(symbol: Character) {
-        switch symbol {
-        case "K":
-            self = .Kelvin
-        case "C":
-            self = .Celsius
-        case "F":
-            self = .Fahrenheit
-        default:
-            return nil
-        }
-    }
-}
-```
-
-你可以通过给该可失败构造器传递合适的参数来获取这三个枚举成员中相匹配的其中一个枚举成员。当参数的值不能与任意一枚举成员相匹配时，该枚举类型的构建过程失败：
-
-```swift
-let fahrenheitUnit = TemperatureUnit(symbol: "F")
-if fahrenheitUnit != nil {
-    println("This is a defined temperature unit, so initialization succeeded.")
-}
-// 打印 "This is a defined temperature unit, so initialization succeeded."
- 
-let unknownUnit = TemperatureUnit(symbol: "X")
-if unknownUnit == nil {
-    println("This is not a defined temperature unit, so initialization failed.")
-}
-// 打印 "This is not a defined temperature unit, so initialization failed."
-
-```
-
-###带原始值的枚举类型的可失败构造器
-
-带原始值的枚举类型会自带一个可失败构造器```init?(rawValue:)```,该可失败构造器有一个名为```rawValue```的默认参数,其类型和枚举类型的原始值类型一致，如果该参数的值能够和枚举类型成员所带的原始值匹配，则该构造器构造一个带此原始值的枚举成员，否则构造失败。
-
-因此上面的 TemperatureUnit的例子可以重写为：
-
-```swift
-enum TemperatureUnit: Character {
-    case Kelvin = "K", Celsius = "C", Fahrenheit = "F"
-}
- 
-let fahrenheitUnit = TemperatureUnit(rawValue: "F")
-if fahrenheitUnit != nil {
-    println("This is a defined temperature unit, so initialization succeeded.")
-}
-// prints "This is a defined temperature unit, so initialization succeeded."
- 
-let unknownUnit = TemperatureUnit(rawValue: "X")
-if unknownUnit == nil {
-    println("This is not a defined temperature unit, so initialization failed.")
-}
-// prints "This is not a defined temperature unit, so initialization failed."
-
-```
-
-###类的可失败构造器
-
-值类型（如结构体或枚举类型）的可失败构造器，对何时何地触发构造失败这个行为没有任何的限制。比如在前面的例子中，结构体```Animal```的可失败构造器触发失败的行为，甚至发生在`species`属性的值被初始化以前。而对类而言，就没有那么幸运了。类的可失败构造器只能在所有的类属性被初始化后和所有类之间的构造器之间的代理调用发生完后触发失败行为。
-
-下例子中，定义了一个名为```Product```的类，其内部结构和结构体```Animal```很相似，内部也有一个名为```name```的```String```类型的属性。由于该属性的值同样不能为空字符串，所以我们加入了可失败构造器来确保该类满足上述条件。但由于```Product```类不是一个结构体，所以当想要在该类中添加可失败构造器触发失败条件时，必须确保```name```属性被初始化。因此我们把```name```属性的```String```类型做了一点点小小的修改，把其改为隐式解析可选类型（```String!```），来确保可失败构造器触发失败条件时，所有类属性都被初始化了。因为所有可选类型都有一个默认的初始值```nil```。因此最后```Product```类可写为：
-
-```swift
-class Product {
-    let name: String!
-    init?(name: String) {
-        if name.isEmpty { return nil }
-        self.name = name
-    }
-}
-```
-
-因为```name```属性是一个常量，所以一旦```Product```类构造成功，```name```属性肯定有一个非```nil```的值。因此完全可以放心大胆的直接访问```Product```类的```name```属性，而不用考虑去检查```name```属性是否有值。
-
-```swift
-if let bowTie = Product(name: "bow tie") {
-    // 不需要检查 bowTie.name == nil
-    println("The product's name is \(bowTie.name)")
-}
-// 打印 "The product's name is bow tie"
-```
-
-###构造失败的传递
-
-可失败构造器同样满足在[构造器链](#initialization_chain)中所描述的构造规则。其允许在同一类，结构体和枚举中横向代理其他的可失败构造器。类似的，子类的可失败构造器也能向上代理基类的可失败构造器。
-
-无论是向上代理还是横向代理，如果你代理的可失败构造器，在构造过程中触发了构造失败的行为，整个构造过程都将被立即终止，接下来任何的构造代码都将不会被执行。
-
->注意：
-> 
->可失败构造器也可以代理调用其它的非可失败构造器。通过这个方法，你可以为已有的构造过程加入构造失败的条件。
-
-下面这个例子，定义了一个名为```CartItem```的```Product```类的子类。这个类建立了一个在线购物车中的物品的模型，它有一个名为```quantity```的常量参数，用来表示该物品的数量至少为1：
-
-```swift
-class CartItem: Product {
-    let quantity: Int!
-    init?(name: String, quantity: Int) {
-        super.init(name: name)
-        if quantity < 1 { return nil }
-        self.quantity = quantity
-    }
-}
-```
-和```Product```类中的```name```属性相类似的，```CartItem```类中的```quantity```属性的类型也是一个隐式解析可选类型，只不过由（```String！```）变为了（```Int!```）。这样做都是为了确保在构造过程中，该属性在被赋予特定的值之前能有一个默认的初始值nil。
-
-可失败构造器总是先向上代理调用基类,```Product```的构造器 ```init(name:)```。这满足了可失败构造器在触发构造失败这个行为前必须总是执行构造代理调用这个条件。
-
-如果由于```name```的值为空而导致基类的构造器在构造过程中失败。则整个`CartIem`类的构造过程都将失败，后面的子类的构造过程都将不会被执行。如果基类构建成功，则继续运行子类的构造器代码。
-
-如果你构造了一个```CartItem```对象，并且该对象的```name```属性不为空以及```quantity```属性为1或者更多，则构造成功：
-
-```swift
-if let twoSocks = CartItem(name: "sock", quantity: 2) {
-    println("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
-}
-// 打印 "Item: sock, quantity: 2"
-```
-如果你构造一个```CartItem```对象，其```quantity```的值```0```, 则```CartItem```的可失败构造器触发构造失败的行为:
-
-```swift
-if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
-    println("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
-} else {
-    println("Unable to initialize zero shirts")
-}
-// 打印 "Unable to initialize zero shirts"
-```
-
-类似的, 如果你构造一个```CartItem```对象，但其```name```的值为空, 则基类```Product```的可失败构造器将触发构造失败的行为，整个```CartItem```的构造行为同样为失败：
-
-```swift
-if let oneUnnamed = CartItem(name: "", quantity: 1) {
-    println("Item: \(oneUnnamed.name), quantity: \(oneUnnamed.quantity)")
-} else {
-    println("Unable to initialize one unnamed product")
-}
-// 打印 "Unable to initialize one unnamed product"
-```
-
-###覆盖一个可失败构造器
-
-就如同其它构造器一样，你也可以用子类的可失败构造器覆盖基类的可失败构造器。或者你也可以用子类的非可失败构造器覆盖一个基类的可失败构造器。这样做的好处是，即使基类的构造器为可失败构造器，但当子类的构造器在构造过程不可能失败时，我们也可以把它修改过来。
-
-注意当你用一个子类的非可失败构造器覆盖了一个父类的可失败构造器时，子类的构造器将不再能向上代理父类的可失败构造器。一个非可失败的构造器永远也不能代理调用一个可失败构造器。
-
->注意：
->
->你可以用一个非可失败构造器覆盖一个可失败构造器，但反过来却行不通。
-
-下例定义了一个名为```Document```的类，这个类中的```name```属性允许为```nil```和一个非空字符串，但不能是一个空字符串：
-
-```swift
-class Document {
-    var name: String?
-    // 该构造器构建了一个name属性值为nil的document对象
-    init() {}
-    // 该构造器构建了一个name属性值为非空字符串的document对象
-    init?(name: String) {
-        if name.isEmpty { return nil }
-        self.name = name
-    }
-}
-```
-
-下面这个例子，定义了一个名为```AutomaticallyNamedDocument```的```Document```类的子类。这个子类覆盖了基类的两个指定构造器。确保了不论在何种情况下```name```属性总是有一个非空字符串```[Untitled]```的值。
-
-```swift
-class AutomaticallyNamedDocument: Document {
-    override init() {
-        super.init()
-        self.name = "[Untitled]"
-    }
-    override init(name: String) {
-        super.init()
-        if name.isEmpty {
-            self.name = "[Untitled]"
-        } else {
-            self.name = name
-        }
-    }
-}
-```
-```AutomaticallyNamedDocument```用一个非可失败构造器```init(name:)```,覆盖了基类的可失败构造器```init?(name:)```。因为子类用不同的方法处理了```name```属性的值为一个空字符串的这种情况。所以子类将不再需要一个可失败的构造器。
-
-###可失败构造器 init!
-
-通常来说我们通过在```init```关键字后添加问号的方式来定义一个可失败构造器，但你也可以使用通过在```init```后面添加惊叹号的方式来定义一个可失败构造器```（init!）```，该可失败构造器将会构建一个特定类型的隐式解析可选类型的对象。
-
-你可以在 ```init？```构造器中代理调用 ```init！```构造器，反之亦然。
-你也可以用 ```init？```覆盖 ```init！```，反之亦然。
-你还可以用 ```init```代理调用```init！```，但这会触发一个断言：是否 ```init！```构造器会触发构造失败？
-
-<a name="required_initializers"></a> 
-##必要构造器
-
-在类的构造器前添加```required```修饰符表明所有该类的子类都必须实现该构造器：
-
-```swift
-class SomeClass {
-    required init() {
-        // 在这里添加该必要构造器的实现代码
-    }
-}
-```
-当子类覆盖基类的必要构造器时，必须在子类的构造器前同样添加```required```修饰符以确保当其它类继承该子类时，该构造器同为必要构造器。在覆盖基类的必要构造器时，不需要添加```override```修饰符：
-
-```swift
-class SomeSubclass: SomeClass {
-    required init() {
-        // 在这里添加子类必要构造器的实现代码
-    }
-}
-```
-
->注意：
->
->如果子类继承的构造器能满足必要构造器的需求，则你无需显示的在子类中提供必要构造器的实现。
-
-<a name="setting_a_default_property_value_with_a_closure_or_function"></a>
-## 通过闭包和函数来设置属性的默认值
-
-如果某个存储型属性的默认值需要特别的定制或准备，你就可以使用闭包或全局函数来为其属性提供定制的默认值。每当某个属性所属的新类型实例创建时，对应的闭包或函数会被调用，而它们的返回值会当做默认值赋值给这个属性。
-
-这种类型的闭包或函数一般会创建一个跟属性类型相同的临时变量，然后修改它的值以满足预期的初始状态，最后将这个临时变量的值作为属性的默认值进行返回。
-
-下面列举了闭包如何提供默认值的代码概要：
-
-```swift
-class SomeClass {
-    let someProperty: SomeType = {
-        // 在这个闭包中给 someProperty 创建一个默认值
-        // someValue 必须和 SomeType 类型相同
-        return someValue
-        }()
-}
-```
-
-注意闭包结尾的大括号后面接了一对空的小括号。这是用来告诉 Swift 需要立刻执行此闭包。如果你忽略了这对括号，相当于是将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。
-
->注意：  
-如果你使用闭包来初始化属性的值，请记住在闭包执行时，实例的其它部分都还没有初始化。这意味着你不能够在闭包里访问其它的属性，就算这个属性有默认值也不允许。同样，你也不能使用隐式的`self`属性，或者调用其它的实例方法。
-
-下面例子中定义了一个结构体`Checkerboard`，它构建了西洋跳棋游戏的棋盘：
-
-![西洋跳棋棋盘](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/checkersBoard_2x.png)
-
-西洋跳棋游戏在一副黑白格交替的 10x10 的棋盘中进行。为了呈现这副游戏棋盘，`Checkerboard`结构体定义了一个属性`boardColors`，它是一个包含 100 个布尔值的数组。数组中的某元素布尔值为`true`表示对应的是一个黑格，布尔值为`false`表示对应的是一个白格。数组中第一个元素代表棋盘上左上角的格子，最后一个元素代表棋盘上右下角的格子。
-
-`boardColor`数组是通过一个闭包来初始化和组装颜色值的：
-
-```swift
-struct Checkerboard {
-    let boardColors: [Bool] = {
-        var temporaryBoard = [Bool]()
-        var isBlack = false
-        for i in 1...10 {
-            for j in 1...10 {
-                temporaryBoard.append(isBlack)
-                isBlack = !isBlack
-            }
-            isBlack = !isBlack
-        }
-        return temporaryBoard
-        }()
-    func squareIsBlackAtRow(row: Int, column: Int) -> Bool {
-        return boardColors[(row * 10) + column]
-    }
-}
-```
-
-每当一个新的`Checkerboard`实例创建时，对应的赋值闭包会执行，一系列颜色值会被计算出来作为默认值赋值给`boardColors`。上面例子中描述的闭包将计算出棋盘中每个格子合适的颜色，将这些颜色值保存到一个临时数组`temporaryBoard`中，并在构建完成时将此数组作为闭包返回值返回。这个返回的值将保存到`boardColors`中，并可以通`squareIsBlackAtRow`这个工具函数来查询。
-
-```swift
-let board = Checkerboard()
-println(board.squareIsBlackAtRow(0, column: 1))
-// 输出 "true"
-println(board.squareIsBlackAtRow(9, column: 9))
-// 输出 "false"
-```
+> 翻译：[lifedim](https://github.com/lifedim)
+> 校对：[lifedim](https://github.com/lifedim)，[chenmingbiao](https://github.com/chenmingbiao)
+
+# 构造过程（Initialization）
+
+-----------------
+
+本页包含内容：
+
+- [存储型属性的初始赋值](#setting_initial_values_for_stored_properties)
+- [自定义构造过程](#customizing_initialization)
+- [默认构造器](#default_initializers)
+- [值类型的构造器代理](#initializer_delegation_for_value_types)
+- [类的继承和构造过程](#class_inheritance_and_initialization)
+- [可失败构造器](#failable_initializers)
+- [必要构造器](#required_initializers) 
+- [通过闭包和函数来设置属性的默认值](#setting_a_default_property_value_with_a_closure_or_function)
+
+
+构造过程是为了使用某个类、结构体或枚举类型的实例而进行的准备过程。这个过程包含了为实例中的每个存储型属性设置初始值和为其执行必要的准备和初始化任务。
+
+构造过程是通过定义构造器（`Initializers`）来实现的，这些构造器可以看做是用来创建特定类型实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。
+
+类的实例也可以通过定义析构器（`deinitializer`）在实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](15_Deinitialization.html)。
+
+<a name="setting_initial_values_for_stored_properties"></a>
+## 存储型属性的初始赋值
+
+类和结构体在实例创建时，必须为所有存储型属性设置合适的初始值。存储型属性的值不能处于一个未知的状态。
+
+你可以在构造器中为存储型属性赋初值，也可以在定义属性时为其设置默认值。以下章节将详细介绍这两种方法。
+
+>注意：  
+当你为存储型属性设置默认值或者在构造器中为其赋值时，它们的值是被直接设置的，不会触发任何属性观测器（`property observers`）。
+
+### 构造器
+
+构造器在创建某特定类型的新实例时调用。它的最简形式类似于一个不带任何参数的实例方法，以关键字`init`命名。
+
+```swift
+init() {
+    // 在此处执行构造过程    
+}
+```
+
+下面例子中定义了一个用来保存华氏温度的结构体`Fahrenheit`，它拥有一个`Double`类型的存储型属性`temperature`：
+
+```swift
+struct Fahrenheit {
+    var temperature: Double
+    init() {
+        temperature = 32.0
+    }
+}
+var f = Fahrenheit()
+println("The default temperature is \(f.temperature)° Fahrenheit")
+// 输出 "The default temperature is 32.0° Fahrenheit”
+```
+
+这个结构体定义了一个不带参数的构造器`init`，并在里面将存储型属性`temperature`的值初始化为`32.0`（华摄氏度下水的冰点）。
+
+### 默认属性值
+
+如前所述，你可以在构造器中为存储型属性设置初始值。同样，你也可以在属性声明时为其设置默认值。
+
+>注意：  
+如果一个属性总是使用同一个初始值，可以为其设置一个默认值。无论定义默认值还是在构造器中赋值，最终它们实现的效果是一样的，只不过默认值将属性的初始化和属性的声明结合的更紧密。使用默认值能让你的构造器更简洁、更清晰，且能通过默认值自动推导出属性的类型；同时，它也能让你充分利用默认构造器、构造器继承（后续章节将讲到）等特性。
+
+你可以使用更简单的方式在定义结构体`Fahrenheit`时为属性`temperature`设置默认值：
+
+```swift
+struct Fahrenheit {
+    var temperature = 32.0
+}
+```
+
+<a name="customizing_initialization"></a>
+## 自定义构造过程
+
+你可以通过输入参数和可选属性类型来定义构造过程，也可以在构造过程中修改常量属性。这些都将在后面章节中提到。
+
+### 构造参数
+
+你可以在定义构造器时提供构造参数，为其提供自定义构造所需值的类型和名字。构造器参数的功能和语法跟函数和方法参数相同。
+
+下面例子中定义了一个包含摄氏度温度的结构体`Celsius`。它定义了两个不同的构造器：`init(fromFahrenheit:)`和`init(fromKelvin:)`，二者分别通过接受不同刻度表示的温度值来创建新的实例：
+
+```swift
+struct Celsius {
+    var temperatureInCelsius: Double = 0.0
+    init(fromFahrenheit fahrenheit: Double) {
+        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
+    }
+    init(fromKelvin kelvin: Double) {
+        temperatureInCelsius = kelvin - 273.15
+    }
+}
+let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
+// boilingPointOfWater.temperatureInCelsius 是 100.0
+let freezingPointOfWater = Celsius(fromKelvin: 273.15)
+// freezingPointOfWater.temperatureInCelsius 是 0.0”
+```
+
+第一个构造器拥有一个构造参数，其外部名字为`fromFahrenheit`，内部名字为`fahrenheit`；第二个构造器也拥有一个构造参数，其外部名字为`fromKelvin`，内部名字为`kelvin`。这两个构造器都将唯一的参数值转换成摄氏温度值，并保存在属性`temperatureInCelsius`中。
+
+### 参数的内部名称和外部名称
+
+跟函数和方法参数相同，构造参数也存在一个在构造器内部使用的参数名字和一个在调用构造器时使用的外部参数名字。
+
+然而，构造器并不像函数和方法那样在括号前有一个可辨别的名字。所以在调用构造器时，主要通过构造器中的参数名和类型来确定需要调用的构造器。正因为参数如此重要，如果你在定义构造器时没有提供参数的外部名字，Swift 会为每个构造器的参数自动生成一个跟内部名字相同的外部名，就相当于在每个构造参数之前加了一个哈希符号。
+
+以下例子中定义了一个结构体`Color`，它包含了三个常量：`red`、`green`和`blue`。这些属性可以存储0.0到1.0之间的值，用来指示颜色中红、绿、蓝成分的含量。
+
+`Color`提供了一个构造器，其中包含三个`Double`类型的构造参数。`Color`也可以提供第二个构造器，它只包含`Double`类型名叫`white`的参数，它被用于给上述三个构造参数赋予同样的值。
+
+```swift
+struct Color {
+    let red, green, blue: Double
+    init(red: Double, green: Double, blue: Double) {
+        self.red   = red
+        self.green = green
+        self.blue  = blue
+    }
+    init(white: Double) {
+        red   = white
+        green = white
+        blue  = white
+    }
+}
+```
+
+两种构造器都能用于创建一个新的`Color`实例，你需要为构造器每个外部参数传值。
+
+```swift
+let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
+let halfGray = Color(white: 0.5)
+```
+
+注意，如果不通过外部参数名字传值，你是没法调用这个构造器的。只要构造器定义了某个外部参数名，你就必须使用它，忽略它将导致编译错误：
+
+```swift
+let veryGreen = Color(0.0, 1.0, 0.0)
+// 报编译时错误，需要外部名称
+```
+
+### 不带外部名的构造器参数
+
+如果你不希望为构造器的某个参数提供外部名字，你可以使用下划线(_)来显示描述它的外部名，以此覆盖上面所说的默认行为。
+
+下面是之前`Celsius`例子的扩展，跟之前相比添加了一个带有`Double`类型参数名为`celsius`的构造器，其外部名用`_`代替。
+
+```swift
+struct Celsius {I
+    var temperatureInCelsius: Double = 0.0
+    init(fromFahrenheit fahrenheit: Double) {
+        temperatureInCelsius = (fahrenheit - 32.0) / 1.8
+    }
+    init(fromKelvin kelvin: Double) {
+        temperatureInCelsius = kelvin - 273.15
+    }
+    init(_ celsius: Double){
+        temperatureInCelsius = celsius
+    }
+}
+let bodyTemperature = Celsius(37.0)
+// bodyTemperature.temperatureInCelsius 为 37.0
+```
+
+调用这种不需要外部参数名称的`Celsius(37.0)`构造器看起来十分简明的。因此适当使用这种`init(_ celsius: Double)`构造器可以提供`Double`类型的参数值而不需要加上外部名。
+
+### 可选属性类型
+
+如果你定制的类型包含一个逻辑上允许取值为空的存储型属性--不管是因为它无法在初始化时赋值，还是因为它可以在之后某个时间点可以赋值为空--你都需要将它定义为可选类型`optional type`。可选类型的属性将自动初始化为空`nil`，表示这个属性是故意在初始化时设置为空的。
+
+下面例子中定义了类`SurveyQuestion`，它包含一个可选字符串属性`response`：
+
+```swift
+class SurveyQuestion {
+    var text: String
+    var response: String?
+    init(text: String) {
+        self.text = text
+    }
+    func ask() {
+        println(text)
+    }
+}
+let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
+cheeseQuestion.ask()
+// 输出 "Do you like cheese?"
+cheeseQuestion.response = "Yes, I do like cheese."
+```
+
+调查问题在问题提出之后，我们才能得到回答。所以我们将属性回答`response`声明为`String?`类型，或者说是可选字符串类型`optional String`。当`SurveyQuestion`实例化时，它将自动赋值为空`nil`，表明暂时还不存在此字符串。
+
+### 构造过程中常量属性的修改
+
+只要在构造过程结束前常量的值能确定，你可以在构造过程中的任意时间点修改常量属性的值。
+
+>注意：  
+对某个类实例来说，它的常量属性只能在定义它的类的构造过程中修改；不能在子类中修改。
+
+你可以修改上面的`SurveyQuestion`示例，用常量属性替代变量属性`text`，指明问题内容`text`在其创建之后不会再被修改。尽管`text`属性现在是常量，我们仍然可以在其类的构造器中设置它的值：
+
+```swift
+class SurveyQuestion {
+    let text: String
+    var response: String?
+    init(text: String) {
+        self.text = text
+    }
+    func ask() {
+        println(text)
+    }
+}
+let beetsQuestion = SurveyQuestion(text: "How about beets?")
+beetsQuestion.ask()
+// 输出 "How about beets?"
+beetsQuestion.response = "I also like beets. (But not with cheese.)"
+```
+
+<a name="default_initializers"></a>
+## 默认构造器
+
+Swift 将为所有属性已提供默认值的且自身没有定义任何构造器的结构体或基类，提供一个默认的构造器。这个默认构造器将简单的创建一个所有属性值都设置为默认值的实例。
+
+下面例子中创建了一个类`ShoppingListItem`，它封装了购物清单中的某一项的属性：名字（`name`）、数量（`quantity`）和购买状态 `purchase state`。
+
+```swift
+class ShoppingListItem {
+    var name: String?
+    var quantity = 1
+    var purchased = false
+}
+var item = ShoppingListItem()
+```
+
+由于`ShoppingListItem`类中的所有属性都有默认值，且它是没有父类的基类，它将自动获得一个可以为所有属性设置默认值的默认构造器（尽管代码中没有显式为`name`属性设置默认值，但由于`name`是可选字符串类型，它将默认设置为`nil`）。上面例子中使用默认构造器创造了一个`ShoppingListItem`类的实例（使用`ShoppingListItem()`形式的构造器语法），并将其赋值给变量`item`。
+
+### 结构体的逐一成员构造器
+
+除上面提到的默认构造器，如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。
+
+逐一成员构造器是用来初始化结构体新实例里成员属性的快捷方法。我们在调用逐一成员构造器时，通过与成员属性名相同的参数名进行传值来完成对成员属性的初始赋值。
+
+下面例子中定义了一个结构体`Size`，它包含两个属性`width`和`height`。Swift 可以根据这两个属性的初始赋值`0.0`自动推导出它们的类型`Double`。
+
+由于这两个存储型属性都有默认值，结构体`Size`自动获得了一个逐一成员构造器 `init(width:height:)`。 你可以用它来为`Size`创建新的实例：
+
+```swift
+struct Size {
+    var width = 0.0, height = 0.0
+}
+let twoByTwo = Size(width: 2.0, height: 2.0)
+```
+
+<a name="initializer_delegation_for_value_types"></a>
+## 值类型的构造器代理
+
+构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。
+
+构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
+
+对于值类型，你可以使用`self.init`在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用`self.init`。
+
+如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。
+
+>注意：  
+假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](20_Extensions.html)章节。
+
+下面例子将定义一个结构体`Rect`，用来代表几何矩形。这个例子需要两个辅助的结构体`Size`和`Point`，它们各自为其所有的属性提供了初始值`0.0`。
+
+```swift
+struct Size {
+    var width = 0.0, height = 0.0
+}
+struct Point {
+    var x = 0.0, y = 0.0
+}
+```
+
+你可以通过以下三种方式为`Rect`创建实例--使用默认的0值来初始化`origin`和`size`属性；使用特定的`origin`和`size`实例来初始化；使用特定的`center`和`size`来初始化。在下面`Rect`结构体定义中，我们为这三种方式提供了三个自定义的构造器：
+
+```swift
+struct Rect {
+    var origin = Point()
+    var size = Size()
+    init() {}
+    init(origin: Point, size: Size) {
+        self.origin = origin
+        self.size = size
+    }
+    init(center: Point, size: Size) {
+        let originX = center.x - (size.width / 2)
+        let originY = center.y - (size.height / 2)
+        self.init(origin: Point(x: originX, y: originY), size: size)
+    }
+}
+```
+
+第一个`Rect`构造器`init()`，在功能上跟没有自定义构造器时自动获得的默认构造器是一样的。这个构造器是一个空函数，使用一对大括号`{}`来描述，它没有执行任何定制的构造过程。调用这个构造器将返回一个`Rect`实例，它的`origin`和`size`属性都使用定义时的默认值`Point(x: 0.0, y: 0.0)`和`Size(width: 0.0, height: 0.0)`：
+
+```swift
+let basicRect = Rect()
+// basicRect 的原点是 (0.0, 0.0)，尺寸是 (0.0, 0.0)
+```
+
+第二个`Rect`构造器`init(origin:size:)`，在功能上跟结构体在没有自定义构造器时获得的逐一成员构造器是一样的。这个构造器只是简单地将`origin`和`size`的参数值赋给对应的存储型属性：
+
+```swift
+let originRect = Rect(origin: Point(x: 2.0, y: 2.0),
+    size: Size(width: 5.0, height: 5.0))
+// originRect 的原点是 (2.0, 2.0)，尺寸是 (5.0, 5.0)
+```
+
+第三个`Rect`构造器`init(center:size:)`稍微复杂一点。它先通过`center`和`size`的值计算出`origin`的坐标。然后再调用（或代理给）`init(origin:size:)`构造器来将新的`origin`和`size`值赋值到对应的属性中：
+
+```swift
+let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
+    size: Size(width: 3.0, height: 3.0))
+// centerRect 的原点是 (2.5, 2.5)，尺寸是 (3.0, 3.0)
+```
+
+构造器`init(center:size:)`可以自己将`origin`和`size`的新值赋值到对应的属性中。然而尽量利用现有的构造器和它所提供的功能来实现`init(center:size:)`的功能，是更方便、更清晰和更直观的方法。
+
+>注意：  
+如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](20_Extensions.html)。
+
+<a name="class_inheritance_and_initialization"></a>
+## 类的继承和构造过程
+
+类里面的所有存储型属性--包括所有继承自父类的属性--都必须在构造过程中设置初始值。
+
+Swift 提供了两种类型的类构造器来确保所有类实例中存储型属性都能获得初始值，它们分别是指定构造器和便利构造器。
+
+### 指定构造器和便利构造器
+
+指定构造器是类中最主要的构造器。一个指定构造器将初始化类中提供的所有属性，并根据父类链往上调用父类的构造器来实现父类的初始化。
+
+每一个类都必须拥有至少一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节[自动构造器的继承](#automatic_initializer_inheritance)。
+
+便利构造器是类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为其参数提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入的实例。
+
+你应当只在必要的时候为类提供便利构造器，比方说某种情况下通过使用便利构造器来快捷调用某个指定构造器，能够节省更多开发时间并让类的构造过程更清晰明了。
+
+### 指定构造器和便利构造器的语法
+
+类的指定构造器的写法跟值类型简单构造器一样：
+
+```swift
+init(parameters) {
+    statements
+}
+```
+
+便利构造器也采用相同样式的写法，但需要在`init`关键字之前放置`convenience`关键字，并使用空格将它们俩分开：
+
+```swift
+convenience init(parameters) {
+    statements
+}
+```
+
+<a name="initialization_chain"></a>
+### 构造器链
+
+为了简化指定构造器和便利构造器之间的调用关系，Swift 采用以下三条规则来限制构造器之间的代理调用：
+
+#### 规则 1
+指定构造器必须调用其直接父类的的指定构造器。
+
+#### 规则 2
+便利构造器必须调用同一类中定义的其它构造器。
+
+#### 规则 3
+便利构造器必须最终以调用一个指定构造器结束。
+
+一个更方便记忆的方法是：
+
+- 指定构造器必须总是向上代理
+- 便利构造器必须总是横向代理
+
+这些规则可以通过下面图例来说明：
+
+![构造器代理图](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializerDelegation01_2x.png)
+
+如图所示，父类中包含一个指定构造器和两个便利构造器。其中一个便利构造器调用了另外一个便利构造器，而后者又调用了唯一的指定构造器。这满足了上面提到的规则2和3。这个父类没有自己的父类，所以规则1没有用到。
+
+子类中包含两个指定构造器和一个便利构造器。便利构造器必须调用两个指定构造器中的任意一个，因为它只能调用同一个类里的其他构造器。这满足了上面提到的规则2和3。而两个指定构造器必须调用父类中唯一的指定构造器，这满足了规则1。
+
+> 注意：  
+这些规则不会影响使用时，如何用类去创建实例。任何上图中展示的构造器都可以用来完整创建对应类的实例。这些规则只在实现类的定义时有影响。
+
+下面图例中展示了一种针对四个类的更复杂的类层级结构。它演示了指定构造器是如何在类层级中充当“管道”的作用，在类的构造器链上简化了类之间的相互关系。
+
+![复杂构造器代理图](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializerDelegation02_2x.png)
+
+<a name="two_phase_initialization"></a>
+### 两段式构造过程
+
+Swift 中类的构造过程包含两个阶段。第一个阶段，每个存储型属性通过引入它们的类的构造器来设置初始值。当每一个存储型属性值被确定后，第二阶段开始，它给每个类一次机会在新实例准备使用之前进一步定制它们的存储型属性。
+
+两段式构造过程的使用让构造过程更安全，同时在整个类层级结构中给予了每个类完全的灵活性。两段式构造过程可以防止属性值在初始化之前被访问；也可以防止属性被另外一个构造器意外地赋予不同的值。
+
+> 注意：  
+Swift的两段式构造过程跟 Objective-C 中的构造过程类似。最主要的区别在于阶段 1，Objective-C 给每一个属性赋值`0`或空值（比如说`0`或`nil`）。Swift  的构造流程则更加灵活，它允许你设置定制的初始值，并自如应对某些属性不能以`0`或`nil`作为合法默认值的情况。
+
+Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造过程能顺利完成：
+
+#### 安全检查 1
+
+指定构造器必须保证它所在类引入的所有属性都必须先初始化完成，之后才能将其它构造任务向上代理给父类中的构造器。
+
+如上所述，一个对象的内存只有在其所有存储型属性确定之后才能完全初始化。为了满足这一规则，指定构造器必须保证它所在类引入的属性在它往上代理之前先完成初始化。
+
+#### 安全检查 2
+
+指定构造器必须先向上代理调用父类构造器，然后再为继承的属性设置新值。如果没这么做，指定构造器赋予的新值将被父类中的构造器所覆盖。
+
+#### 安全检查 3
+
+便利构造器必须先代理调用同一类中的其它构造器，然后再为任意属性赋新值。如果没这么做，便利构造器赋予的新值将被同一类中其它指定构造器所覆盖。
+
+#### 安全检查 4
+
+构造器在第一阶段构造完成之前，不能调用任何实例方法、不能读取任何实例属性的值，`self`的值不能被引用。
+
+类实例在第一阶段结束以前并不是完全有效，仅能访问属性和调用方法，一旦完成第一阶段，该实例才会声明为有效实例。
+
+以下是两段式构造过程中基于上述安全检查的构造流程展示：
+
+#### 阶段 1
+
+- 某个指定构造器或便利构造器被调用；
+- 完成新实例内存的分配，但此时内存还没有被初始化；
+- 指定构造器确保其所在类引入的所有存储型属性都已赋初值。存储型属性所属的内存完成初始化；
+- 指定构造器将调用父类的构造器，完成父类属性的初始化；
+- 这个调用父类构造器的过程沿着构造器链一直往上执行，直到到达构造器链的最顶部；
+- 当到达了构造器链最顶部，且已确保所有实例包含的存储型属性都已经赋值，这个实例的内存被认为已经完全初始化。此时阶段1完成。
+
+#### 阶段 2
+
+- 从顶部构造器链一直往下，每个构造器链中类的指定构造器都有机会进一步定制实例。构造器此时可以访问`self`、修改它的属性并调用实例方法等等。
+- 最终，任意构造器链中的便利构造器可以有机会定制实例和使用`self`。
+
+下图展示了在假定的子类和父类之间构造的阶段1：
+
+![构造过程阶段1](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/twoPhaseInitialization01_2x.png)
+
+在这个例子中，构造过程从对子类中一个便利构造器的调用开始。这个便利构造器此时没法修改任何属性，它把构造任务代理给同一类中的指定构造器。
+
+如安全检查1所示，指定构造器将确保所有子类的属性都有值。然后它将调用父类的指定构造器，并沿着造器链一直往上完成父类的构建过程。
+
+父类中的指定构造器确保所有父类的属性都有值。由于没有更多的父类需要构建，也就无需继续向上做构建代理。
+
+一旦父类中所有属性都有了初始值，实例的内存被认为是完全初始化，而阶段1也已完成。
+
+以下展示了相同构造过程的阶段2：
+
+![构建过程阶段2](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/twoPhaseInitialization02_2x.png)
+
+父类中的指定构造器现在有机会进一步来定制实例（尽管它没有这种必要）。
+
+一旦父类中的指定构造器完成调用，子类的构指定构造器可以执行更多的定制操作（同样，它也没有这种必要）。
+
+最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。
+
+### 构造器的继承和重载
+
+跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。
+
+>注意：
+父类的构造器仅在确定和安全的情况下被继承。具体内容请参考后续章节[自动构造器的继承](#automatic_initializer_inheritance)。
+
+假如你希望自定义的子类中能实现一个或多个跟父类相同的构造器，也许是为了完成一些定制的构造过程，你可以在你定制的子类中提供和重载与父类相同的构造器。
+
+当你写一个父类中带有指定构造器的子类构造器时，你需要重载这个指定的构造器。因此，你必须在定义子类构造器时带上`override`修饰符。即使你重载系统提供的默认构造器也需要带上`override`修饰符，具体内容请参考[默认构造器](#default_initializers)。
+
+无论是重载属性，方法或者是下标脚本，只要含有`override`修饰符就会去检查父类是否有相匹配的重载指定构造器和验证重载构造器参数。
+
+>注意：  
+当你重载一个父类指定构造器时，你需要写`override`修饰符，甚至你的子类构造器继承的是父类的便利构造器。
+
+相反地，如果你写了一个和父类便利构造器相匹配的子类构造器，子类都不能直接调用父类的便利构造器，每个规则都在上文[构造器链](#initialization_chain)有所描述。
+
+在下面的例子中定义了一个基础类叫`Vehicle`。基础类中声明了一个存储型属性`numberOfWheels`，它是值为`0`的`Int`类型属性。`numberOfWheels`属性用于创建名为`descrpiption`类型为`String`的计算型属性。
+
+```swift
+class Vehicle {
+    var numberOfWheels = 0
+    var description: String {
+        return "\(numberOfWheels) wheel(s)"
+    }
+}
+```
+
+`Vehicle`类只为存储型属性提供默认值，而不自定义构造器。因此，它会自动生成一个默认构造器，具体内容请参考[默认构造器](#default_initializers)。默认构造器通常在类中是指定构造器，它可以用于创建属性叫`numberOfWheels`值为`0`的`Vehicle`实例。
+
+```swift
+let vehicle = Vehicle()
+print("Vehicle: \(vehicle.description)")
+// Vehicle: 0 wheel(s)
+```
+
+下面例子中定义了一个`Vehicle`的子类`Bicycle`：
+
+```swift
+class Bicycle: Vehicle {
+    override init() {
+        super.init()
+        numberOfWheels = 2
+    }
+}
+```
+
+子类`Bicycle`定义了一个自定义指定构造器`init()`。这个指定构造器和父类的指定构造器相匹配，所以`Bicycle`中的指定构造器需要带上`override`修饰符。
+
+`Bicycle`的构造器`init()`一开始调用`super.init()`方法，这个方法的作用是调用`Bicycle`的父类`Vehicle`。这样可以确保`Bicycle`在修改属性之前它所继承的属性`numberOfWheels`能被`Vehicle`类初始化。在调用`super.init()`之后，原本的属性`numberOfWheels`被赋值为`2`。
+
+如果你创建一个`Bicycle`实例，你可以调用继承的`description`计算型属性去查看属性`numberOfWheels`是否有改变。
+
+```swift
+let bicycle = Bicycle()
+print("Bicycle: \(bicycle.description)")
+// Bicycle: 2 wheel(s)
+```
+
+>注意
+子类可以在初始化时修改继承变量属性，但是不能修改继承过来的常量属性。
+
+<a name="automatic_initializer_inheritance"></a>
+### 自动构造器的继承
+
+如上所述，子类不会默认继承父类的构造器。但是如果特定条件可以满足，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重载父类的构造器，并且在尽可能安全的情况下以最小的代价来继承父类的构造器。
+
+假设要为子类中引入的任意新属性提供默认值，请遵守以下2个规则：
+
+#### 规则 1
+
+如果子类没有定义任何指定构造器，它将自动继承所有父类的指定构造器。
+
+#### 规则 2
+
+如果子类提供了所有父类指定构造器的实现--不管是通过规则1继承过来的，还是通过自定义实现的--它将自动继承所有父类的便利构造器。
+
+即使你在子类中添加了更多的便利构造器，这两条规则仍然适用。
+
+>注意：  
+子类可以通过部分满足规则2的方式，使用子类便利构造器来实现父类的指定构造器。
+
+### 指定构造器和便利构造器操作
+
+接下来的例子将在操作中展示指定构造器、便利构造器和自动构造器的继承。它定义了包含三个类`Food`、`RecipeIngredient`以及`ShoppingListItem`的类层次结构，并将演示它们的构造器是如何相互作用的。
+
+类层次中的基类是`Food`，它是一个简单的用来封装食物名字的类。`Food`类引入了一个叫做`name`的`String`类型属性，并且提供了两个构造器来创建`Food`实例：
+
+```swift
+class Food {
+    var name: String
+    init(name: String) {
+        self.name = name
+    }
+    convenience init() {
+        self.init(name: "[Unnamed]")
+    }
+}
+```
+
+下图中展示了`Food`的构造器链：
+
+![Food构造器链](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializersExample01_2x.png)
+
+类没有提供一个默认的逐一成员构造器，所以`Food`类提供了一个接受单一参数`name`的指定构造器。这个构造器可以使用一个特定的名字来创建新的`Food`实例：
+
+```swift
+let namedMeat = Food(name: "Bacon")
+// namedMeat 的名字是 "Bacon”
+```
+
+`Food`类中的构造器`init(name: String)`被定义为一个指定构造器，因为它能确保所有新`Food`实例的中存储型属性都被初始化。`Food`类没有父类，所以`init(name: String)`构造器不需要调用`super.init()`来完成构造。
+
+`Food`类同样提供了一个没有参数的便利构造器 `init()`。这个`init()`构造器为新食物提供了一个默认的占位名字，通过代理调用同一类中定义的指定构造器`init(name: String)`并给参数`name`传值`[Unnamed]`来实现：
+
+```swift
+let mysteryMeat = Food()
+// mysteryMeat 的名字是 [Unnamed]
+```
+
+类层级中的第二个类是`Food`的子类`RecipeIngredient`。`RecipeIngredient`类构建了食谱中的一味调味剂。它引入了`Int`类型的数量属性`quantity`（以及从`Food`继承过来的`name`属性），并且定义了两个构造器来创建`RecipeIngredient`实例：
+
+```swift
+class RecipeIngredient: Food {
+    var quantity: Int
+    init(name: String, quantity: Int) {
+        self.quantity = quantity
+        super.init(name: name)
+    }
+    override convenience init(name: String) {
+        self.init(name: name, quantity: 1)
+    }
+}
+```
+
+下图中展示了`RecipeIngredient`类的构造器链：
+
+![RecipeIngredient构造器](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializersExample02_2x.png)
+
+`RecipeIngredient`类拥有一个指定构造器`init(name: String, quantity: Int)`，它可以用来产生新`RecipeIngredient`实例的所有属性值。这个构造器一开始先将传入的`quantity`参数赋值给`quantity`属性，这个属性也是唯一在`RecipeIngredient`中新引入的属性。随后，构造器将任务向上代理给父类`Food`的`init(name: String)`。这个过程满足[两段式构造过程](#two_phase_initialization)中的安全检查1。
+
+`RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。
+
+注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识。
+
+在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
+
+所有的这三种构造器都可以用来创建新的`RecipeIngredient`实例：
+
+```swift
+let oneMysteryItem = RecipeIngredient()
+let oneBacon = RecipeIngredient(name: "Bacon")
+let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
+```
+
+类层级中第三个也是最后一个类是`RecipeIngredient`的子类，叫做`ShoppingListItem`。这个类构建了购物单中出现的某一种调味料。
+
+购物单中的每一项总是从`unpurchased`未购买状态开始的。为了展现这一事实，`ShoppingListItem`引入了一个布尔类型的属性`purchased`，它的默认值是`false`。`ShoppingListItem`还添加了一个计算型属性`description`，它提供了关于`ShoppingListItem`实例的一些文字描述：
+
+```swift
+class ShoppingListItem: RecipeIngredient {
+    var purchased = false
+    var description: String {
+    var output = "\(quantity) x \(name.lowercaseString)"
+        output += purchased ? " ✔" : " ✘"
+        return output
+    }
+}
+```
+
+> 注意：  
+`ShoppingListItem`没有定义构造器来为`purchased`提供初始化值，这是因为任何添加到购物单的项的初始状态总是未购买。
+
+由于它为自己引入的所有属性都提供了默认值，并且自己没有定义任何构造器，`ShoppingListItem`将自动继承所有父类中的指定构造器和便利构造器。
+
+下图种展示了所有三个类的构造器链：
+
+![三类构造器图](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/initializersExample03_2x.png)
+
+你可以使用全部三个继承来的构造器来创建`ShoppingListItem`的新实例：
+
+```swift
+var breakfastList = [
+    ShoppingListItem(),
+    ShoppingListItem(name: "Bacon"),
+    ShoppingListItem(name: "Eggs", quantity: 6),
+]
+breakfastList[0].name = "Orange juice"
+breakfastList[0].purchased = true
+for item in breakfastList {
+    println(item.description)
+}
+// 1 x orange juice ✔
+// 1 x bacon ✘
+// 6 x eggs ✘
+```
+
+如上所述，例子中通过字面量方式创建了一个新数组`breakfastList`，它包含了三个新的`ShoppingListItem`实例，因此数组的类型也能自动推导为`ShoppingListItem[]`。在数组创建完之后，数组中第一个`ShoppingListItem`实例的名字从`[Unnamed]`修改为`Orange juice`，并标记为已购买。接下来通过遍历数组每个元素并打印它们的描述值，展示了所有项当前的默认状态都已按照预期完成了赋值。
+
+<a name="failable_initializers"></a>
+## 可失败构造器 
+
+如果一个类，结构体或枚举类型的对象，在构造自身的过程中有可能失败，则为其定义一个可失败构造器，是非常有必要的。这里所指的“失败”是指，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。
+
+为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在`init`关键字后面加添问号`(init?)`。
+
+> 注意： 
+可失败构造器的参数名和参数类型，不能与其它非可失败构造器的参数名，及其类型相同。
+
+可失败构造器，在构建对象的过程中，创建一个其自身类型为可选类型的对象。你通过`return nil` 语句，来表明可失败构造器在何种情况下“失败”。
+
+> 注意：
+严格来说，构造器都不支持返回值。因为构造器本身的作用，只是为了能确保对象自身能被正确构建。所以即使你在表明可失败构造器，失败的这种情况下，用到了`return nil`。也不要在表明可失败构造器成功的这种情况下，使用关键字 `return`。
+
+下例中，定义了一个名为`Animal`的结构体，其中有一个名为`species`的，`String`类型的常量属性。同时该结构体还定义了一个，带一个`String`类型参数`species`的,可失败构造器。这个可失败构造器，被用来检查传入的参数是否为一个空字符串，如果为空字符串，则该可失败构造器，构建对象失败，否则成功。
+
+```swift
+struct Animal {
+    let species: String
+    init?(species: String) {
+        if species.isEmpty { return nil }
+        self.species = species
+    }
+}
+```
+
+你可以通过该可失败构造器来构建一个Animal的对象，并检查其构建过程是否成功。
+
+```swift
+let someCreature = Animal(species: "Giraffe")
+// someCreature 的类型是 Animal? 而不是 Animal
+ 
+if let giraffe = someCreature {
+    println("An animal was initialized with a species of \(giraffe.species)")
+}
+// 打印 "An animal was initialized with a species of Giraffe"
+```
+
+如果你给该可失败构造器传入一个空字符串作为其参数，则该可失败构造器失败。
+
+```swift
+let anonymousCreature = Animal(species: "")
+// anonymousCreature 的类型是 Animal?, 而不是 Animal
+ 
+if anonymousCreature == nil {
+    println("The anonymous creature could not be initialized")
+}
+// 打印 "The anonymous creature could not be initialized"
+```
+
+> 注意：
+空字符串（```""```）和一个值为```nil```的可选类型的字符串是两个完全不同的概念。上例中的空字符串（`""`）其实是一个有效的，非可选类型的字符串。这里我们只所以让`Animal`的可失败构造器，构建对象失败，只是因为对于`Animal`这个类的`species`属性来说，它更适合有一个具体的值，而不是空字符串。
+
+###枚举类型的可失败构造器
+
+你可以通过构造一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。还能在参数不满足你所期望的条件时，导致构造失败。
+
+下例中，定义了一个名为TemperatureUnit的枚举类型。其中包含了三个可能的枚举成员(```Kelvin```，```Celsius```，和 ```Fahrenheit```)和一个被用来找到```Character```值所对应的枚举成员的可失败构造器：
+
+```swift
+enum TemperatureUnit {
+    case Kelvin, Celsius, Fahrenheit
+    init?(symbol: Character) {
+        switch symbol {
+        case "K":
+            self = .Kelvin
+        case "C":
+            self = .Celsius
+        case "F":
+            self = .Fahrenheit
+        default:
+            return nil
+        }
+    }
+}
+```
+
+你可以通过给该可失败构造器传递合适的参数来获取这三个枚举成员中相匹配的其中一个枚举成员。当参数的值不能与任意一枚举成员相匹配时，该枚举类型的构建过程失败：
+
+```swift
+let fahrenheitUnit = TemperatureUnit(symbol: "F")
+if fahrenheitUnit != nil {
+    println("This is a defined temperature unit, so initialization succeeded.")
+}
+// 打印 "This is a defined temperature unit, so initialization succeeded."
+ 
+let unknownUnit = TemperatureUnit(symbol: "X")
+if unknownUnit == nil {
+    println("This is not a defined temperature unit, so initialization failed.")
+}
+// 打印 "This is not a defined temperature unit, so initialization failed."
+```
+
+###带原始值的枚举类型的可失败构造器
+
+带原始值的枚举类型会自带一个可失败构造器```init?(rawValue:)```,该可失败构造器有一个名为```rawValue```的默认参数,其类型和枚举类型的原始值类型一致，如果该参数的值能够和枚举类型成员所带的原始值匹配，则该构造器构造一个带此原始值的枚举成员，否则构造失败。
+
+因此上面的 TemperatureUnit的例子可以重写为：
+
+```swift
+enum TemperatureUnit: Character {
+    case Kelvin = "K", Celsius = "C", Fahrenheit = "F"
+}
+ 
+let fahrenheitUnit = TemperatureUnit(rawValue: "F")
+if fahrenheitUnit != nil {
+    println("This is a defined temperature unit, so initialization succeeded.")
+}
+// prints "This is a defined temperature unit, so initialization succeeded."
+ 
+let unknownUnit = TemperatureUnit(rawValue: "X")
+if unknownUnit == nil {
+    println("This is not a defined temperature unit, so initialization failed.")
+}
+// prints "This is not a defined temperature unit, so initialization failed."
+```
+
+###类的可失败构造器
+
+值类型（如结构体或枚举类型）的可失败构造器，对何时何地触发构造失败这个行为没有任何的限制。比如在前面的例子中，结构体```Animal```的可失败构造器触发失败的行为，甚至发生在`species`属性的值被初始化以前。而对类而言，就没有那么幸运了。类的可失败构造器只能在所有的类属性被初始化后和所有类之间的构造器之间的代理调用发生完后触发失败行为。
+
+下例子中，定义了一个名为```Product```的类，其内部结构和结构体```Animal```很相似，内部也有一个名为```name```的```String```类型的属性。由于该属性的值同样不能为空字符串，所以我们加入了可失败构造器来确保该类满足上述条件。但由于```Product```类不是一个结构体，所以当想要在该类中添加可失败构造器触发失败条件时，必须确保```name```属性被初始化。因此我们把```name```属性的```String```类型做了一点点小小的修改，把其改为隐式解析可选类型（```String!```），来确保可失败构造器触发失败条件时，所有类属性都被初始化了。因为所有可选类型都有一个默认的初始值```nil```。因此最后```Product```类可写为：
+
+```swift
+class Product {
+    let name: String!
+    init?(name: String) {
+        if name.isEmpty { return nil }
+        self.name = name
+    }
+}
+```
+
+因为```name```属性是一个常量，所以一旦```Product```类构造成功，```name```属性肯定有一个非```nil```的值。因此完全可以放心大胆的直接访问```Product```类的```name```属性，而不用考虑去检查```name```属性是否有值。
+
+```swift
+if let bowTie = Product(name: "bow tie") {
+    // 不需要检查 bowTie.name == nil
+    println("The product's name is \(bowTie.name)")
+}
+// 打印 "The product's name is bow tie"
+```
+
+###构造失败的传递
+
+可失败构造器同样满足在[构造器链](#initialization_chain)中所描述的构造规则。其允许在同一类，结构体和枚举中横向代理其他的可失败构造器。类似的，子类的可失败构造器也能向上代理基类的可失败构造器。
+
+无论是向上代理还是横向代理，如果你代理的可失败构造器，在构造过程中触发了构造失败的行为，整个构造过程都将被立即终止，接下来任何的构造代码都将不会被执行。
+
+>注意：
+可失败构造器也可以代理调用其它的非可失败构造器。通过这个方法，你可以为已有的构造过程加入构造失败的条件。
+
+下面这个例子，定义了一个名为```CartItem```的```Product```类的子类。这个类建立了一个在线购物车中的物品的模型，它有一个名为```quantity```的常量参数，用来表示该物品的数量至少为1：
+
+```swift
+class CartItem: Product {
+    let quantity: Int!
+    init?(name: String, quantity: Int) {
+        super.init(name: name)
+        if quantity < 1 { return nil }
+        self.quantity = quantity
+    }
+}
+```
+
+和```Product```类中的```name```属性相类似的，```CartItem```类中的```quantity```属性的类型也是一个隐式解析可选类型，只不过由（```String！```）变为了（```Int!```）。这样做都是为了确保在构造过程中，该属性在被赋予特定的值之前能有一个默认的初始值nil。
+
+可失败构造器总是先向上代理调用基类,```Product```的构造器 ```init(name:)```。这满足了可失败构造器在触发构造失败这个行为前必须总是执行构造代理调用这个条件。
+
+如果由于```name```的值为空而导致基类的构造器在构造过程中失败。则整个`CartIem`类的构造过程都将失败，后面的子类的构造过程都将不会被执行。如果基类构建成功，则继续运行子类的构造器代码。
+
+如果你构造了一个```CartItem```对象，并且该对象的```name```属性不为空以及```quantity```属性为1或者更多，则构造成功：
+
+```swift
+if let twoSocks = CartItem(name: "sock", quantity: 2) {
+    println("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
+}
+// 打印 "Item: sock, quantity: 2"
+```
+如果你构造一个```CartItem```对象，其```quantity```的值```0```, 则```CartItem```的可失败构造器触发构造失败的行为:
+
+```swift
+if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
+    println("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
+} else {
+    println("Unable to initialize zero shirts")
+}
+// 打印 "Unable to initialize zero shirts"
+```
+
+类似的, 如果你构造一个```CartItem```对象，但其```name```的值为空, 则基类```Product```的可失败构造器将触发构造失败的行为，整个```CartItem```的构造行为同样为失败：
+
+```swift
+if let oneUnnamed = CartItem(name: "", quantity: 1) {
+    println("Item: \(oneUnnamed.name), quantity: \(oneUnnamed.quantity)")
+} else {
+    println("Unable to initialize one unnamed product")
+}
+// 打印 "Unable to initialize one unnamed product"
+```
+
+###重写一个可失败构造器
+
+就如同其它构造器一样，你也可以用子类的可失败构造器重写基类的可失败构造器。或者你也可以用子类的非可失败构造器重写一个基类的可失败构造器。这样做的好处是，即使基类的构造器为可失败构造器，但当子类的构造器在构造过程不可能失败时，我们也可以把它修改过来。
+
+注意当你用一个子类的非可失败构造器重写了一个父类的可失败构造器时，子类的构造器将不再能向上代理父类的可失败构造器。一个非可失败的构造器永远也不能代理调用一个可失败构造器。
+
+>注意：
+你可以用一个非可失败构造器重写一个可失败构造器，但反过来却行不通。
+
+下例定义了一个名为```Document```的类，这个类中的```name```属性允许为```nil```和一个非空字符串，但不能是一个空字符串：
+
+```swift
+class Document {
+    var name: String?
+    // 该构造器构建了一个name属性值为nil的document对象
+    init() {}
+    // 该构造器构建了一个name属性值为非空字符串的document对象
+    init?(name: String) {
+        if name.isEmpty { return nil }
+        self.name = name
+    }
+}
+```
+
+下面这个例子，定义了一个名为```AutomaticallyNamedDocument```的```Document```类的子类。这个子类重写了基类的两个指定构造器。确保了不论在何种情况下```name```属性总是有一个非空字符串```[Untitled]```的值。
+
+```swift
+class AutomaticallyNamedDocument: Document {
+    override init() {
+        super.init()
+        self.name = "[Untitled]"
+    }
+    override init(name: String) {
+        super.init()
+        if name.isEmpty {
+            self.name = "[Untitled]"
+        } else {
+            self.name = name
+        }
+    }
+}
+```
+
+```AutomaticallyNamedDocument```用一个非可失败构造器```init(name:)```,重写了基类的可失败构造器```init?(name:)```。因为子类用不同的方法处理了```name```属性的值为一个空字符串的这种情况。所以子类将不再需要一个可失败的构造器。
+
+###可失败构造器 init!
+
+通常来说我们通过在```init```关键字后添加问号的方式来定义一个可失败构造器，但你也可以使用通过在```init```后面添加惊叹号的方式来定义一个可失败构造器```（init!）```，该可失败构造器将会构建一个特定类型的隐式解析可选类型的对象。
+
+你可以在 ```init？```构造器中代理调用 ```init！```构造器，反之亦然。
+你也可以用 ```init？```重写 ```init！```，反之亦然。
+你还可以用 ```init```代理调用```init！```，但这会触发一个断言：是否 ```init！```构造器会触发构造失败？
+
+<a name="required_initializers"></a> 
+##必要构造器
+
+在类的构造器前添加```required```修饰符表明所有该类的子类都必须实现该构造器：
+
+```swift
+class SomeClass {
+    required init() {
+        // 在这里添加该必要构造器的实现代码
+    }
+}
+```
+当子类重写基类的必要构造器时，必须在子类的构造器前同样添加```required```修饰符以确保当其它类继承该子类时，该构造器同为必要构造器。在重写基类的必要构造器时，不需要添加```override```修饰符：
+
+```swift
+class SomeSubclass: SomeClass {
+    required init() {
+        // 在这里添加子类必要构造器的实现代码
+    }
+}
+```
+
+>注意：
+如果子类继承的构造器能满足必要构造器的需求，则你无需显示的在子类中提供必要构造器的实现。
+
+<a name="setting_a_default_property_value_with_a_closure_or_function"></a>
+## 通过闭包和函数来设置属性的默认值
+
+如果某个存储型属性的默认值需要特别的定制或准备，你就可以使用闭包或全局函数来为其属性提供定制的默认值。每当某个属性所属的新类型实例创建时，对应的闭包或函数会被调用，而它们的返回值会当做默认值赋值给这个属性。
+
+这种类型的闭包或函数一般会创建一个跟属性类型相同的临时变量，然后修改它的值以满足预期的初始状态，最后将这个临时变量的值作为属性的默认值进行返回。
+
+下面列举了闭包如何提供默认值的代码概要：
+
+```swift
+class SomeClass {
+    let someProperty: SomeType = {
+        // 在这个闭包中给 someProperty 创建一个默认值
+        // someValue 必须和 SomeType 类型相同
+        return someValue
+        }()
+}
+```
+
+注意闭包结尾的大括号后面接了一对空的小括号。这是用来告诉 Swift 需要立刻执行此闭包。如果你忽略了这对括号，相当于是将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。
+
+>注意：  
+如果你使用闭包来初始化属性的值，请记住在闭包执行时，实例的其它部分都还没有初始化。这意味着你不能够在闭包里访问其它的属性，就算这个属性有默认值也不允许。同样，你也不能使用隐式的`self`属性，或者调用其它的实例方法。
+
+下面例子中定义了一个结构体`Checkerboard`，它构建了西洋跳棋游戏的棋盘：
+
+![西洋跳棋棋盘](https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Art/checkersBoard_2x.png)
+
+西洋跳棋游戏在一副黑白格交替的 10x10 的棋盘中进行。为了呈现这副游戏棋盘，`Checkerboard`结构体定义了一个属性`boardColors`，它是一个包含 100 个布尔值的数组。数组中的某元素布尔值为`true`表示对应的是一个黑格，布尔值为`false`表示对应的是一个白格。数组中第一个元素代表棋盘上左上角的格子，最后一个元素代表棋盘上右下角的格子。
+
+`boardColor`数组是通过一个闭包来初始化和组装颜色值的：
+
+```swift
+struct Checkerboard {
+    let boardColors: [Bool] = {
+        var temporaryBoard = [Bool]()
+        var isBlack = false
+        for i in 1...10 {
+            for j in 1...10 {
+                temporaryBoard.append(isBlack)
+                isBlack = !isBlack
+            }
+            isBlack = !isBlack
+        }
+        return temporaryBoard
+        }()
+    func squareIsBlackAtRow(row: Int, column: Int) -> Bool {
+        return boardColors[(row * 10) + column]
+    }
+}
+```
+
+每当一个新的`Checkerboard`实例创建时，对应的赋值闭包会执行，一系列颜色值会被计算出来作为默认值赋值给`boardColors`。上面例子中描述的闭包将计算出棋盘中每个格子合适的颜色，将这些颜色值保存到一个临时数组`temporaryBoard`中，并在构建完成时将此数组作为闭包返回值返回。这个返回的值将保存到`boardColors`中，并可以通`squareIsBlackAtRow`这个工具函数来查询。
+
+```swift
+let board = Checkerboard()
+println(board.squareIsBlackAtRow(0, column: 1))
+// 输出 "true"
+println(board.squareIsBlackAtRow(9, column: 9))
+// 输出 "false"
+```
+
diff --git a/source/chapter2/15_Deinitialization.md b/source/chapter2/15_Deinitialization.md
index 57a17a88..dac45280 100755
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -1,108 +1,108 @@
-> 翻译：[bruce0505](https://github.com/bruce0505)  
-> 校对：[fd5788](https://github.com/fd5788)
-
-# 析构过程（Deinitialization）
----------------------------
-
-本页包含内容：
-
-- [析构过程原理](#how_deinitialization_works)
-- [析构函数操作](#deinitializers_in_action)
-
-在一个类的实例被释放之前，析构函数被立即调用。用关键字`deinit`来标示析构函数，类似于初始化函数用`init`来标示。析构函数只适用于类类型。
-
-<a name="how_deinitialization_works"></a>
-##析构过程原理
-
-Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](16_Automatic_Reference_Counting.html)那一章描述，Swift 通过_自动引用计数_（ARC）处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。
-
-在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号：
-
-```swift
-deinit {
-    // 执行析构过程
-}
-```
-
-析构函数是在实例释放发生前一步被自动调用。不允许主动调用自己的析构函数。子类继承了父类的析构函数，并且在子类析构函数实现的最后，父类的析构函数被自动调用。即使子类没有提供自己的析构函数，父类的析构函数也总是被调用。
-
-因为直到实例的析构函数被调用时，实例才会被释放，所以析构函数可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件的名称）。
-
-<a name="deinitializers_in_action"></a>
-##析构函数操作
-
-这里是一个析构函数操作的例子。这个例子是一个简单的游戏，定义了两种新类型，`Bank`和`Player`。`Bank`结构体管理一个虚拟货币的流通，在这个流通中`Bank`永远不可能拥有超过 10,000 的硬币。在这个游戏中有且只能有一个`Bank`存在，因此`Bank`由带有静态属性和静态方法的结构体实现，从而存储和管理其当前的状态。
-
-```swift
-struct Bank {
-    static var coinsInBank = 10_000
-    static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
-          numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
-          coinsInBank -= numberOfCoinsToVend
-         return numberOfCoinsToVend
-    }
-    static func receiveCoins(coins: Int) {
-        coinsInBank += coins
-    }
-}
-```
-
-`Bank`根据它的`coinsInBank`属性来跟踪当前它拥有的硬币数量。银行还提供两个方法——`vendCoins`和`receiveCoins`——用来处理硬币的分发和收集。
-
-`vendCoins`方法在 bank 分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，`Bank`返回一个比请求时小的数字(如果没有硬币留在 bank 中就返回 0)。`vendCoins`方法声明`numberOfCoinsToVend`为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。`vendCoins`方法返回一个整型值，表明了提供的硬币的实际数目。
-
-`receiveCoins`方法只是将 bank 的硬币存储和接收到的硬币数目相加，再保存回 bank。
-
-`Player`类描述了游戏中的一个玩家。每一个 player 在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过 player 的`coinsInPurse`属性来体现：
-
-```swift
-class Player {
-    var coinsInPurse: Int
-    init(coins: Int) {
-        coinsInPurse = Bank.vendCoins(coins)
-    }
-    func winCoins(coins: Int) {
-        coinsInPurse += Bank.vendCoins(coins)
-    }
-    deinit {
-        Bank.receiveCoins(coinsInPurse)
-    }
-}
-```
-
-
-每个`Player`实例都由一个指定数目硬币组成的启动额度初始化，这些硬币在 bank 初始化的过程中得到。如果没有足够的硬币可用，`Player`实例可能收到比指定数目少的硬币。
-
-`Player`类定义了一个`winCoins`方法，该方法从银行获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构函数，这个析构函数在`Player`实例释放前一步被调用。这里析构函数只是将玩家的所有硬币都返回给银行：
-
-```swift
-var playerOne: Player? = Player(coins: 100)
-println("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
-// 输出 "A new player has joined the game with 100  coins"
-println("There are now \(Bank.coinsInBank) coins left   in the bank")
-// 输出 "There are now 9900 coins left in the bank"
-```
-
-一个新的`Player`实例随着一个 100 个硬币（如果有）的请求而被创建。这`个Player`实例存储在一个名为`playerOne`的可选`Player`变量中。这里使用一个可选变量，是因为玩家可以随时离开游戏。设置为可选使得你可以跟踪当前是否有玩家在游戏中。
-
-因为`playerOne`是可选的，所以由一个感叹号（`!`）来修饰，每当其`winCoins`方法被调用时，`coinsInPurse`属性被访问并打印出它的默认硬币数目。
-
-```swift
-playerOne!.winCoins(2_000)
-println("PlayerOne won 2000 coins & now has \(playerOne!.coinsInPurse) coins")
-// 输出 "PlayerOne won 2000 coins & now has 2100 coins"
-println("The bank now only has \(Bank.coinsInBank) coins left")
-// 输出 "The bank now only has 7900 coins left"
-```
-
-这里，player 已经赢得了 2,000 硬币。player 的钱包现在有 2,100 硬币，bank 只剩余 7,900 硬币。
-
-```swift
-playerOne = nil
-println("PlayerOne has left the game")
-// 输出 "PlayerOne has left the game"
-println("The bank now has \(Bank.coinsInBank) coins")
-// 输出 "The bank now has 10000 coins"
-```
-
-玩家现在已经离开了游戏。这表明是要将可选的`playerOne`变量设置为`nil`，意思是“没有`Player`实例”。当这种情况发生的时候，`playerOne`变量对`Player`实例的引用被破坏了。没有其它属性或者变量引用`Player`实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到银行。
+> 翻译：[bruce0505](https://github.com/bruce0505)
+> 校对：[fd5788](https://github.com/fd5788)，[chenmingbiao](https://github.com/chenmingbiao)
+
+# 析构过程（Deinitialization）
+---------------------------
+
+本页包含内容：
+
+- [析构过程原理](#how_deinitialization_works)
+- [析构器操作](#deinitializers_in_action)
+
+析构器只适用于类类型，当一个类的实例被释放之前，析构器会被立即调用。析构器用关键字`deinit`来标示，类似于构造器要用`init`来标示。
+
+<a name="how_deinitialization_works"></a>
+##析构过程原理
+
+Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](16_Automatic_Reference_Counting.html)章节中所讲述，Swift 通过`自动引用计数（ARC）`处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。
+
+在类的定义中，每个类最多只能有一个析构器，而且析构器不带任何参数，如下所示：
+
+```swift
+deinit {
+    // 执行析构过程
+}
+```
+
+析构器是在实例释放发生前被自动调用。析构器是不允许被主动调用的。子类继承了父类的析构器，并且在子类析构器实现的最后，父类的析构器会被自动调用。即使子类没有提供自己的析构器，父类的析构器也同样会被调用。
+
+因为直到实例的析构器被调用时，实例才会被释放，所以析构器可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件）。
+
+<a name="deinitializers_in_action"></a>
+##析构器操作
+
+这是一个析构器操作的例子。这个例子描述了一个简单的游戏，这里定义了两种新类型，分别是`Bank`和`Player`。`Bank`结构体管理一个虚拟货币的流通，在这个流通中我们设定`Bank`永远不可能拥有超过 10,000 的硬币，而且在游戏中有且只能有一个`Bank`存在，因此`Bank`结构体在实现时会带有静态属性和静态方法来存储和管理其当前的状态。
+
+```swift
+struct Bank {
+    static var coinsInBank = 10_000
+    static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
+          numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
+          coinsInBank -= numberOfCoinsToVend
+         return numberOfCoinsToVend
+    }
+    static func receiveCoins(coins: Int) {
+        coinsInBank += coins
+    }
+}
+```
+
+`Bank`根据它的`coinsInBank`属性来跟踪当前它拥有的硬币数量。`Bank`还提供两个方法——`vendCoins(_:)`和`receiveCoins(_:)`，分别用来处理硬币的分发和收集。
+
+`vendCoins(_:)`方法在bank对象分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，`Bank`会返回一个比请求时要小的数字(如果没有硬币留在bank对象中就返回 0)。`vendCoins`方法声明`numberOfCoinsToVend`为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。`vendCoins`方法返回一个整型值，表明了提供的硬币的实际数目。
+
+`receiveCoins`方法只是将bank对象的硬币存储和接收到的硬币数目相加，再保存回bank对象。
+
+`Player`类描述了游戏中的一个玩家。每一个 player 在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过 player 的`coinsInPurse`属性来体现：
+
+```swift
+class Player {
+    var coinsInPurse: Int
+    init(coins: Int) {
+        coinsInPurse = Bank.vendCoins(coins)
+    }
+    func winCoins(coins: Int) {
+        coinsInPurse += Bank.vendCoins(coins)
+    }
+    deinit {
+        Bank.receiveCoins(coinsInPurse)
+    }
+}
+```
+
+
+每个`Player`实例构造时都会设定由硬币组成的启动额度值，这些硬币在bank对象初始化的过程中得到。如果在bank对象中没有足够的硬币可用，`Player`实例可能收到比指定数目少的硬币。
+
+`Player`类定义了一个`winCoins(_:)`方法，该方法从bank对象获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构器，这个析构器在`Player`实例释放前被调用。在这里，析构器的作用只是将玩家的所有硬币都返回给bank对象：
+
+```swift
+var playerOne: Player? = Player(coins: 100)
+println("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
+// 输出 "A new player has joined the game with 100  coins"
+println("There are now \(Bank.coinsInBank) coins left   in the bank")
+// 输出 "There are now 9900 coins left in the bank"
+```
+
+一个新的`Player`实例被创建时会设定有 100 个硬币（如果bank对象中硬币的数目足够）。这`个Player`实例存储在一个名为`playerOne`的可选`Player`变量中。这里使用一个可选变量，是因为玩家可以随时离开游戏。设置为可选使得你可以跟踪当前是否有玩家在游戏中。
+
+因为`playerOne`是可选的，所以用一个感叹号（`!`）作为修饰符，每当其`winCoins(_:)`方法被调用时，`coinsInPurse`属性就会被访问并打印出它的默认硬币数目。
+
+```swift
+playerOne!.winCoins(2_000)
+println("PlayerOne won 2000 coins & now has \(playerOne!.coinsInPurse) coins")
+// 输出 "PlayerOne won 2000 coins & now has 2100 coins"
+println("The bank now only has \(Bank.coinsInBank) coins left")
+// 输出 "The bank now only has 7900 coins left"
+```
+
+这里，player 已经赢得了 2,000 硬币，所以player 的钱包现在有 2,100 硬币，而bank对象只剩余 7,900 硬币。
+
+```swift
+playerOne = nil
+println("PlayerOne has left the game")
+// 输出 "PlayerOne has left the game"
+println("The bank now has \(Bank.coinsInBank) coins")
+// 输出 "The bank now has 10000 coins"
+```
+
+玩家现在已经离开了游戏。这表明是要将可选的`playerOne`变量设置为`nil`，意思是“不存在`Player`实例”。当这种情况发生的时候，`playerOne`变量对`Player`实例的引用被破坏了。没有其它属性或者变量引用`Player`实例，因此为了清空它占用的内存从而释放它。在这发生前，其析构器会被自动调用，从而使其硬币被返回到bank对象中。

From 5a018759c38fe65c23ac2740e7c2461d8c63aa79 Mon Sep 17 00:00:00 2001
From: Lenhoon <393509661@qq.com>
Date: Fri, 10 Jul 2015 23:54:31 +0800
Subject: [PATCH 112/228] translate completed,but some links need to add

---
 source/chapter3/05_Declarations.md | 809 ++++++++++++++++-------------
 1 file changed, 440 insertions(+), 369 deletions(-)

diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md
index 34ffb277..be67b2ec 100755
--- a/source/chapter3/05_Declarations.md
+++ b/source/chapter3/05_Declarations.md
@@ -1,12 +1,13 @@
-> 翻译：[marsprince](https://github.com/marsprince)  
-> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
-
-# 声明
+> 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon)
+> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
+
+<a name="declarations"></a>
+# 声明
 -----------------
 
 本页包含内容：
 
-- [模块范围](#module_scope)
+- [顶级代码](#top-level_code)
 - [代码块](#code_blocks)
 - [引入声明](#import_declaration)
 - [常量声明](#constant_declaration)
@@ -24,96 +25,90 @@
 - [运算符声明](#operator_declaration)
 - [声明修饰符](#declaration_modifiers)
 
-一条声明可以在你的程序里引入新的名字和构造。举例来说，你可以使用声明来引入函数和方法，变量和常量，或者来定义
-新的命名好的枚举，结构，类和协议类型。你也可以使用一条声明来延长一个已经存在的命名好的类型的行为。或者在你的
-程序里引入在其他地方声明的符号。
+一条*声明(declaration)*可以在程序里引入新的名字或者构造。举例来说，可以使用声明来引入函数和方法，变量和常量，或者来定义新的命名好的枚举，结构，类和协议类型。可以使用一条声明来延长一个已经存在的命名好的类型的行为。或者在程序里引入在其它地方声明的符号。
 
-在swift中，大多数声明在某种意义上讲也是执行或同事声明它们的初始化定义。这意味着，因为协议和它们的成员不匹配，
-大多数协议成员需要单独的声明。为了方便起见，也因为这些区别在swift里不是很重要，声明语句同时包含了声明和定义。
+在Swift中，大多数声明在某种意义上讲也是执行或同时声明它们的初始化定义。这意味着，因为协议和它们的成员不匹配，大多数协议成员需要单独的声明。为了方便起见，也因为这些区别在Swift里不是很重要，*声明语句(declaration)*同时包含了声明和定义。
 
 > 声明语法  
-> *声明* → [*导入声明*](..\chapter3\05_Declarations.html#import_declaration)  
-> *声明* → [*常量声明*](..\chapter3\05_Declarations.html#constant_declaration)  
-> *声明* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration)  
-> *声明* → [*类型别名声明*](..\chapter3\05_Declarations.html#typealias_declaration)  
-> *声明* → [*函数声明*](..\chapter3\05_Declarations.html#function_declaration)  
-> *声明* → [*枚举声明*](..\chapter3\05_Declarations.html#enum_declaration)  
-> *声明* → [*结构体声明*](..\chapter3\05_Declarations.html#struct_declaration)  
-> *声明* → [*类声明*](..\chapter3\05_Declarations.html#class_declaration)  
-> *声明* → [*协议声明*](..\chapter3\05_Declarations.html#protocol_declaration)  
-> *声明* → [*构造器声明*](..\chapter3\05_Declarations.html#initializer_declaration)  
-> *声明* → [*析构器声明*](..\chapter3\05_Declarations.html#deinitializer_declaration)  
-> *声明* → [*扩展声明*](..\chapter3\05_Declarations.html#extension_declaration)  
-> *声明* → [*附属脚本声明*](..\chapter3\05_Declarations.html#subscript_declaration)  
-> *声明* → [*运算符声明*](..\chapter3\05_Declarations.html#operator_declaration)  
-> *声明(Declarations)列表* → [*声明*](..\chapter3\05_Declarations.html#declaration) [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_  
-> *声明描述符(Specifiers)列表* → [*声明描述符(Specifier)*](..\chapter3\05_Declarations.html#declaration_specifier) [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_  
-> *声明描述符(Specifier)* → **class** | **mutating** | **nonmutating** | **override** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **weak**  
+> *声明* → [*导入声明*](#grammer_of_an_import_declaration)  
+> *声明* → [*常量声明*](#grammer_of_a_constant_declaration)  
+> *声明* → [*变量声明*](#grammer_of_a_variable_declaration)  
+> *声明* → [*类型别名声明*](#grammer_of_a_type_alias_declaration)  
+> *声明* → [*函数声明*](#grammer_of_a_function_declaration)  
+> *声明* → [*枚举声明*](#grammer_of_a_enumeration_declaration)  
+> *声明* → [*结构体声明*](#grammer_of_a_structure_declaration)  
+> *声明* → [*类声明*](#grammer_of_a_class_declaration)  
+> *声明* → [*协议声明*](#grammer_of_a_protocol_declaration)  
+> *声明* → [*构造器声明*](#grammer_of_an_initializer_declaration)  
+> *声明* → [*析构器声明*](#grammer_of_a_deinitializer_declaration)  
+> *声明* → [*扩展声明*](#grammer_of_an_extension_declaration)  
+> *声明* → [*附属脚本声明*](#grammer_of_a_subscript_declaration)  
+> *声明* → [*运算符声明*](#grammer_of_an_operator_declaration)  
+> *声明(Declarations)列表* → [*声明*](#declaration) [*声明(Declarations)列表*](#declarations) _可选_    
 
-<a name="module_scope"></a>
-##模块范围
+<a name="top-level_code"></a>
+##顶级代码
 
-模块范围定义了对模块中其他源文件可见的代码。（注：待改进）在swift的源文件中，最高级别的代码由零个或多个语句，
-声明和表达组成。变量，常量和其他的声明语句在一个源文件的最顶级被声明，使得它们对同一模块中的每个源文件都是可见的。
+Swift的源文件中的顶级代码由零个或多个语句，声明和表达式组成。默认情况下，在一个源文件的顶层声明的变量，常量和其他命名的声明语句可以被同一模块部分里的每一个源文件中的代码访问。可以通过使用一个访问级别修饰符来标记这个声明，从而重写这个默认行为，[访问控制级别(Access Control Levels)](#access_control_levels)中有所介绍。
 
 > 顶级(Top Level) 声明语法  
-> *顶级声明* → [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_  
+> *顶级声明* → [*多条语句(Statements)*](TODO) _可选_  
 
 <a name="code_blocks"></a>
 ##代码块
 
-代码块用来将一些声明和控制结构的语句组织在一起。它有如下的形式：
+*代码块*用来将一些声明和控制结构的语句组织在一起。它有如下的形式：
 
 > {  
 >     `statements`  
 > }  
 
-代码块中的语句包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。
+代码块中的*语句(statements)*包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。
 
 > 代码块语法  
-> *代码块* → **{** [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_ **}**  
+> *代码块* → **{** [*多条语句(Statements)*](TODO) _可选_ **}**  
 
 <a name="import_declaration"></a>
 ##引入声明
 
-引入声明使你可以使用在其他文件中声明的内容。引入语句的基本形式是引入整个代码模块；它由import关键字开始，后面
+可以使用在其他文件中声明的内容*引入声明(import declaration)*。引入语句的基本形式是引入整个代码模块；它由`import`关键字开始，后面
 紧跟一个模块名：
 
 > import `module`
 
-你可以提供更多的细节来限制引入的符号，如声明一个特殊的子模块或者在一个模块或子模块中做特殊的声明。（待改进）
-当你使用了这些细节后，在当前的程序汇总只有引入的符号是可用的（并不是声明的整个模块）。
+可以提供更多的细节来限制引入的符号，如声明一个特殊的子模块或者在一个模块或子模块中做特殊的声明。（待改进）
+当使用了这些细节后，在当前的程序汇总只有引入的符号是可用的（并不是声明的整个模块）。
 
 > import `import kind` `module`.`symbol name`  
 > import `module`.`submodule`  
 
-<p></p>
-
+<a name="grammer_of_an_import_declaration"></a>
 > 导入(Import)声明语法  
-> *导入声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **import** [*导入类型*](..\chapter3\05_Declarations.html#import_kind) _可选_ [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
+> *导入声明* → [*特性(attributes)列表*](TODO) _可选_ **import** [*导入类型*](..\chapter3\05_Declarations.html#import_kind) _可选_ [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
 > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**  
 > *导入路径* → [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) | [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) **.** [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
-> *导入路径标识符* → [*标识符*](LexicalStructure.html#identifier) | [*运算符*](LexicalStructure.html#operator)  
+> *导入路径标识符* → [*标识符*](TODO) | [*运算符*](TODO)  
 
 <a name="constant_declaration"></a>
 ##常量声明
 
-常量声明可以在你的程序里命名一个常量。常量以关键词let来声明，遵循如下的格式:
+*常量声明(constant declaration)*可以在程序里命名一个常量。常量以关键词`let`来声明，遵循如下的格式:
 
 > let `constant name`: `type` = `expression`
 
-当常量的值被给定后，常量就将常量名称和表达式初始值不变的结合在了一起，而且不能更改。
-这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
-当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，它被认为是一个常量
-属性。常量并不是可计算的属性，因此不包含getters和setters。（译者注：getters和setters不知道怎么翻译，待改进）
+当常量的值被给定后，常量就将*常量名称(constant name)*和*表达式(expression)*初始值不变的结合在了一起，而且不能更改。
 
-如果常量名是一个元组形式，元组中的每一项初始化表达式中都要有对应的值
+这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
+
+当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，它被认为是一个*常量属性(constant property)*。常量并不是可计算的属性，因此不包含getters和setters。
+
+如果*常量名(constant name)*是一个元组形式，元组中的每一项初始化*表达式(expression)*中都要有对应的值。
 
 ```swift
 let (firstNumber, secondNumber) = (10, 42)
 ```
 
-在上例中，firstNumber是一个值为10的常量，secnodeName是一个值为42的常量。所有常量都可以独立的使用：
+在上例中，`firstNumber`是一个值为`10`的常量，`secnodeName`是一个值为`42`的常量。所有常量都可以独立的使用：
 
 ```swift
 println("The first number is \(firstNumber).")
@@ -122,15 +117,15 @@ println("The second number is \(secondNumber).")
 // prints "The second number is 42."
 ```
 
-类型注释（:type）在常量声明中是一个可选项，它可以用来描述在类型推断（type inference）中找到的类型。
+当*常量名称(constant name)*的类型可以被推断出时，类型标注*（:type）*在常量声明中是一个可选项，它可以用来描述在[类型推断(Type Inference)](TODO)中找到的类型。
 
-声明一个静态常量要使用关键字static。静态属性在类型属性（type propetries）中有介绍。
-
-如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看常量和变量（constants and variables）,
-存储属性（stored properties）等节。
+声明一个常量类型属性要使用关键字`static`声明修饰符。类型属性在[类型属性(Type Properties)](TODO)中有介绍。
 
+如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看[常量和变量(Constants and Variables)](TODO)和[存储属性(Stored Properties)](TODO)等节。
+
+<a name="grammer_of_a_constant_declaration"></a>
 > 常数声明语法  
-> *常量声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
+> *常量声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
 > *模式构造器列表* → [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
 > *模式构造器* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_  
 > *构造器* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
@@ -138,28 +133,32 @@ println("The second number is \(secondNumber).")
 <a name="variable_declaration"></a>
 ##变量声明
 
-变量声明可以在你的程序里声明一个变量，它以关键字var来声明。根据声明变量类型和值的不同，如存储和计算
-变量和属性，存储变量和属性监视，和静态变量属性，有着不同的声明形式。（待改进）
-所使用的声明形式取决于变量所声明的范围和你打算声明的变量类型。
+*变量声明(variable declaration)*可以在程序里声明一个变量，它以关键字`var`来声明。
+
+变量声明有几种不同的形式声明不同种类的命名值和计算型值，如存储和计算变量和属性，存储变量和属性监视，和静态变量属性。所使用的声明形式取决于变量所声明的范围和打算声明的变量类型。
 
 >注意：  
-你也可以在协议声明的上下文声明属性，详情参见类型属性声明。
-
+>也可以在协议声明的上下文声明属性，详情参见[协议属性声明(Protocal Property Declaration)](TODO)。
+
+可以重载一个子类中的属性，通过使用'override'声明修饰符来标记子类的属性声明，[重写(Overriding)](TODO)中有所介绍。
+
+<a name="stored_variables_and_stored_variable_properties"></a>
 ###存储型变量和存储型属性
 
 下面的形式声明了一个存储型变量或存储型变量属性
 
 > var `variable name`: `type` = `expression`
 
-你可以在全局，函数内，或者在类和结构体的声明(context)中使用这种形式来声明一个变量。当变量以这种形式
-在全局或者一个函数内被声明时，它代表一个存储型变量。当它在类或者结构体中被声明时，它代表一个存储型变量属性。
+可以在全局，函数内，或者在类和结构体的声明(context)中使用这种形式来声明一个变量。当变量以这种形式
+在全局或者一个函数内被声明时，它代表一个*存储型变量(stored variable)*。当它在类或者结构体中被声明时，它代表一个*存储型变量属性(stored variable property)*。
 
-初始化的表达式不可以在协议（protocol）的定义中出现，在其他情况下，初始化表达式是可选的（optional），如果没有初始化表达式，那么变量定义时必须显示的声明变量类型（:type)
+初始化的*表达式（expression）*不可以在协议的声明中出现，在其他情况下，初始化*表达式(expression)*是可选的（optional），如果没有初始化*表达式(expression)*，那么变量定义时必须显示包括类型标注（*:type*)
 
-对于常量的定义，如果名字是一个元组（tuple），元组每一项的`name`都要和初始化表达式`expression`中的相应值一致。
+对于常量的定义，如果*变量名字（variable name）*是一个元组（tuple），元组中每一项的名称都要和初始化*表达式(expression)*中的相应值一致。
 
 正如名字一样，存储型变量的值或存储型变量属性存储在内存中。
-
+
+<a name="computed_variables_and_computed_properties"></a>
 ###计算型变量和计算型属性
 
 如下形式声明一个一个存储型变量或存储型属性：
@@ -173,24 +172,21 @@ println("The second number is \(secondNumber).")
 > }  
 > }  
 
-你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
-当变量以这种形式在全局或者一个函数内被声明时，它代表一个计算型变量。当它在类，结构体，枚举，扩展声明的上下文
-中中被声明时，它代表一个计算型变量属性。
+可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。当变量以这种形式在全局或者一个函数内被声明时，它代表一个*计算型变量(computed variable)*。当它在类，结构体，枚举，扩展声明的上下文中中被声明时，它代表一个*计算型变量(computed variable)*。
 
-getter用来读取变量值，setter用来写入变量值。setter子句是可选择的，只有getter是必需的，你可以将这些语句
-都省略，只是简单的直接返回请求值，正如在只读计算属性(read-only computed properites)中描述的那样。
-但是如果你提供了一个setter语句，你也必需提供一个getter语句。
+getter用来读取变量值，setter用来写入变量值。setter子句是可选择的，只有getter是必需的，可以将这些语句
+都省略，只是简单的直接返回请求值，正如在[只读计算属性(Read-Only Computed Properties)](TODO)中描述的那样。但是如果提供了一个setter语句，也必需提供一个getter语句。
 
-setter的名字和圆括号内的语句是可选的。如果你写了一个setter名，它就会作为setter的参数被使用。如果你不写setter名，
-setter的初始名为newValue，正如在setter声明速记(shorthand setter declaration)中提到的那样。
+setter的名字和圆括号内的语句是可选的。如果写了一个setter名，它就会作为setter的参数被使用。如果不写setter名，setter的初始名为'newValue'，正如在[setter声明速记(Shorthand Setter Declaration)](TODO)中提到的那样。
 
 不像存储型变量和存储型属性那样，计算型属性和计算型变量的值不存储在内存中。
 
-获得更多信息，查看更多关于计算型属性的例子，请查看计算型属性(computed properties)一节。
-
+获得更多信息，查看更多关于计算型属性的例子，请查看[计算型属性(Computed Properties)](TODO)一节。
+
+<a name="stored_variable_observers_and_property_observers"></a>
 ###存储型变量监视器和属性监视器
 
-你可以用willset和didset监视器来声明一个存储型变量或属性。一个包含监视器的存储型变量或属性按如下的形式声明：
+可以用`willset`和`didset`监视器来声明一个存储型变量或属性。一个包含监视器的存储型变量或属性按如下的形式声明：
 
 > var `variable name`: `type` = expression {  
 > willSet(setter name) {  
@@ -201,46 +197,44 @@ setter的初始名为newValue，正如在setter声明速记(shorthand setter dec
 > }  
 > }  
 
-你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
-当变量以这种形式在全局或者一个函数内被声明时，监视器代表一个存储型变量监视器；
-当它在类，结构体，枚举，扩展声明的上下文中被声明时，监视器代表属性监视器。
+可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。当变量以这种形式在全局或者一个函数内被声明时，监视器代表一个*存储型变量监视器(stored variable observers)*；当它在类，结构体，枚举，扩展声明的上下文中被声明时，监视器代表*属性监视器(property observers)*。
 
-你可以为适合的监视器添加任何存储型属性。你也可以通过重写子类属性的方式为适合的监视器添加任何继承的属性
-(无论是存储型还是计算型的)，参见重写属性监视器(overriding properyt observers)。
+可以为适合的监视器添加任何存储型属性。也可以通过重写子类属性的方式为适合的监视器添加任何继承的属性
+(无论是存储型还是计算型的)，参见[重写属性监视器(Overriding Property Observers)](TODO)。
 
-初始化表达式在类或者结构体的声明中是可选的，但是在其他地方是必需的。无论在什么地方声明，
-所有包含监视器的变量声明都必须有类型注释(type annotation)。
+初始化*表达式(expression)*在一个类中或者结构体的声明中是可选的，但是在其他地方是必需的。当类型可以从初始化*表达式(expression)*中推断而来，那么这个*类型(type)*标注是可选的。
 
-当变量或属性的值被改变时，willset和didset监视器提供了一个监视方法（适当的回应）。
+当变量或属性的值被改变时，`willset`和`didset`监视器提供了一个监视方法（适当的回应）。
 监视器不会在变量或属性第一次初始化时运行，它们只有在值被外部初始化语句改变时才会被运行。
 
-willset监视器只有在变量或属性值被改变之前运行。新的值作为一个常量经过过willset监视器，因此不可以在
-willset语句中改变它。didset监视器在变量或属性值被改变后立即运行。和willset监视器相反，为了以防止你仍然
-需要获得旧的数据，旧变量值或者属性会经过didset监视器。这意味着，如果你在变量或属性自身的didiset监视器语句
-中设置了一个值，你设置的新值会取代刚刚在willset监视器中经过的那个值。
+`willset`监视器只有在变量或属性值被改变之前运行。新的值作为一个常量经过过`willset`监视器，因此不可以在`willset`语句中改变它。`didset`监视器在变量或属性值被改变后立即运行。和`willset`监视器相反，为了以防止仍然需要获得旧的数据，旧变量值或者属性会经过`didset`监视器。这意味着，如果在变量或属性自身的`didiset`监视器语句中设置了一个值，设置的新值会取代刚刚在`willset`监视器中经过的那个值。
 
-在willset和didset语句中，setter名和圆括号的语句是可选的。如果你写了一个setter名，它就会作为willset和didset的参数被使用。如果你不写setter名，
-willset监视器初始名为newvalue，didset监视器初始名为oldvalue。
+在`willset`和`didset`语句中，*setter名(setter name)*和圆括号的语句是可选的。如果写了一个setter名，它就会作为`willset`和`didset`的参数被使用。如果不写setter名，
+`willset`监视器初始名为`newvalue`，`didset`监视器初始名为`oldvalue`。
 
-当你提供一个willset语句时，didset语句是可选的。同样的，在你提供了一个didset语句时，willset语句是可选的。
-
-获得更多信息，查看如何使用属性监视器的例子，请查看属性监视器(prpperty observers)一节。
+当提供一个`willset`语句时，`didset`语句是可选的。同样的，在提供了一个`didset`语句时，`willset`语句是可选的。
 
+获得更多信息，查看如何使用属性监视器的例子，请查看[属性监视器(Property Observers)](TODO)一节。
+声明修饰符
+
+<a name="type_variable_properties"></a>
 ###类型变量属性
 
-为了声明一个类型变量属性，要用```static```声明描述符标记该声明。类可能需要```class```声明描述符去标记类的类型计算属性从而允许子类可以覆盖父类的实现。类型属性在[类型属性](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Properties.html#//apple_ref/doc/uid/TP40014097-CH14-ID264)章节讨论。
+声明一个类型变量属性，要用`static`声明修饰符标记该声明。类可能需要`class`声明修饰符去标记类的类型计算型属性从而允许子类可以重写超类的实现。类型属性在[类型属性(Type Properties)](TODO)章节讨论。
 
 >>注意
 >>
->在一个类声明中，关键字```static```与把一个声明同时标记为```class```和```final```的效果相同
-
+>在一个类声明中，关键字`static`与用声明修饰符`class`和`final`去标记一个声明的效果相同
+
+<a name="grammer_of_a_variable_declaration"></a>
 > 变量声明语法  
 > *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)  
-> *变量声明头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var**  
+> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
+> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)   
+> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*构造器*](..\chapter3\05_Declarations.html#initializer) [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)   
+> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)  
+> *变量声明头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var**  
 > *变量名称* → [*标识符*](LexicalStructure.html#identifier)  
 > *getter-setter块* → **{** [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) _可选_ **}**  
 > *getter-setter块* → **{** [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) **}**  
@@ -259,46 +253,44 @@ willset监视器初始名为newvalue，didset监视器初始名为oldvalue。
 <a name="type_alias_declaration"></a>
 ##类型的别名声明
 
-类型别名的声明可以在你的程序里为一个已存在的类型声明一个别名。类型的别名声明以关键字typealias开始，遵循如下的
-形式：
+*类型别名声明(type alias declaration)*可以在程序里为一个已存在的类型声明一个别名。类型的别名声明语句使用关键字`typealias`声明，遵循如下的形式：
 
 > `typealias name` = `existing type`
 
-当声明一个类型的别名后，你可以在你程序的任何地方使用别名来代替已存在的类型。已存在的类型可以是已经被命名的
-类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。
-
-查看更多Protocol Associated Type Declaration.
+当声明一个类型的别名后，可以在程序的任何地方使用别*名(name)*来代替*已存在的类型(existing type)*。已存在的类型可以是已经被命名的类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。
 
+查看更多[协议关联类型声明(Protocol Associated Type Declaration)](TODO).
+
+<a name="grammer_of_a_type_alias_declaration"></a>
 > 类型别名声明语法  
 > *类型别名声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment)  
-> *类型别名头(Head)* → **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name)  
+> *类型别名头(Head)* → [*属性列表*](todo) _可选_ [*访问级别修饰符*]((TODO) _可选_ **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name)  
 > *类型别名名称* → [*标识符*](LexicalStructure.html#identifier)  
 > *类型别名赋值* → **=** [*类型*](..\chapter3\03_Types.html#type)  
 
 <a name="function_declaration"></a>
 ##函数声明
 
-你可以使用函数声明在你的程序里引入新的函数。函数可以在类的上下文，结构体，枚举，或者作为方法的协议中被声明。
-函数声明使用关键字func，遵循如下的形式：
+使用*函数声明(function declaration)*在程序里引入新的函数或者方法。一个函数被声明在类的上下文，结构体，枚举，或者协议中，从而作为*方法(method)*被引用。
+函数声明使用关键字`func`，遵循如下的形式：
 
 > func `function name`(`parameters`) -> `return type` {  
 >     `statements`  
 > }  
 
-如果函数不返回任何值，返回类型可以被忽略，如下所示：
+如果函数返回`Void`类型，返回类型可以被忽略，如下所示：
 
 > func `function name`(`parameters`) {  
 >     `statements`  
 > }  
 
-每个参数的类型都要标明，它们不能被推断出来。初始时函数的参数是常量。在这些参数前面添加var使它们成为变量，
-作用域内任何对变量的改变只在函数体内有效，或者用inout使的这些改变可以在调用域内生效。
-更多关于in-out参数的讨论，参见in-out参数(in-out parameters)
+每个参数的类型都要标明，它们不能被推断出来。虽然函数的参数默认是常量，也可以使用参数名前使用`let`来强调这一行为。在这些参数前面添加`var`使它们成为变量，作用域内任何对变量的改变只在函数体内有效，或者用`inout`使的这些改变可以在调用域内生效。更多关于in-out参数的讨论，参见[In-Out参数(In-Out Parameters)](TODO)
 
 函数可以使用元组类型作为返回值来返回多个变量。
 
-函数定义可以出现在另一个函数声明内。这种函数被称作nested函数。更多关于nested函数的讨论，参见nestde functions。
-
+函数定义可以出现在另一个函数声明内。这种函数被称作nested函数。更多关于*嵌套函数(Nested Functions)*的讨论，参见[嵌套函数(Nested Functions)](TODO)。
+
+<a name="parameter_names"></a>
 ###参数名
 
 函数的参数是一个以逗号分隔的列表 。函数调用是的变量顺序必须和函数声明时的参数顺序一致。
@@ -306,70 +298,62 @@ willset监视器初始名为newvalue，didset监视器初始名为oldvalue。
 
 > `parameter name`: `parameter type`
 
-对于函数参数来讲，参数名在函数体内被使用，而不是在函数调用时使用。对于方法参数，参数名在函数体内被使用，
-同时也在方法被调用时作为标签被使用。该方法的第一个参数名仅仅在函数体内被使用，就像函数的参数一样，举例来讲：
+一个参数有一个内部名称，这个内部名称可以在函数体内被使用。同样也可以作为外部名称，当调用方法时这个外部名称被作为实参的标签来使用。默认情况下，第一个参数的外部名称省略不写，第二个和其之后的参数使用它们的内部名称作为它们的外部名称。
 
 ```swift
-func f(x: Int, y: String) -> String {
-    return y + String(x)
-}
-f(7, "hello")  // x and y have no name
+func f(x: Int, y: Int) -> Int{ return x + y}
+f(1, y: 2) // y是有标记的，x没有
 ```
 
-```swift
-class C {
-    func f(x: Int, y: String) -> String {
-       return y + String(x)
-    }
-}
-let c = C()
-c.f(7, y: "hello")  // x没有名称，y有名称
-```
+可以按如下的一种形式，重写参数名被使用的默认过程：
 
-你可以按如下的形式，重写参数名被使用的过程：
-
-> `external parameter name` `local parameter name`: `parameter type`  
-> &#35;`parameter name`: `parameter type`  
+> `external parameter name` `local parameter name`: `parameter type`    
 > _ `local parameter name`: `parameter type`  
+
+在内部参数名前的名称赋予这个参数一个外部名称，这个名称可以和内部参数的名称不同。外部参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有外部名 。
 
-在本地参数前命名的第二名称(second name)使得参数有一个扩展名。且不同于本地的参数名。
-扩展参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有扩展名 。
-
-在参数名前所写的哈希符号(#)代表着这个参数名可以同时作为外部或本体参数名来使用。等同于书写两次本地参数名。
-在函数或方法调用时，与其对应的语句必须包含这个名字。
-
-本地参数名前的强调字符(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
-
+内部参数名前的强调字符下划线(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
+
+```swift
+func f(x x: Int, withY y: Int, _z: Int) -> Int{
+	return x + y + z }
+f(x: 1, withY: 2, 3) // x和y是有标记的，z没有
+```
+
+<a name="special_kinds_of_parameters"></a>
 ###特殊类型的参数
 
-参数可以被忽略，值可以是变化的，并且提供一个初始值，这种方法有着如下的形式：
+参数可以被忽略，参数的值的数量可变，并且还可以提供默认值，使用形式如下：
 
-> _ : <#parameter type#.  
+> _ : `parameter type`.  
 > `parameter name`: `parameter type`...  
 > `parameter name`: `parameter type` = `default argument value`  
 
-以强调符(_)命名的参数明确的在函数体内不能被访问。
+以下划线(_)命名的参数是明确忽略的，在函数体内不能被访问。
 
-一个以基础类型名的参数，如果紧跟着三个点(...)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，
-且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数int...被看做是int[]。
-查看可变参数的使用例子，详见可变参数(variadic parameters)一节。
-
-在参数的类型后面有一个以等号(=)连接的表达式，这样的参数被看做有着给定表达式的初始值。如果参数在函数
-调用时被省略了，就会使用初始值。如果参数没有省略，那么它在函数调用是必须有自己的名字.举例来讲，
-f()和f(x:7)都是只有一个变量x的函数的有效调用，但是f(7)是非法的，因为它提供了一个值而不是名称。
+一个以基础类型名的参数，如果紧跟着三个点(`...`)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数`Int...`被看做是`[Int]`。查看可变参数的使用例子，详见[可变参数(Variadic Parameters)](TODO)一节。
 
+在参数的类型后面有一个以等号(`=`)连接的表达式，这样的参数被看做有着给定表达式的初始值。当函数被调用时，给定的表达式被求值。如果参数在函数调用时被省略了，就会使用初始值。
+
+```swift
+func f(x: Int = 42) -> Int { return x}
+f()  // 有效的，使用默认值
+f(7) // 有效的，提供了值，没有提供值的名称
+f(x: 7) //无效的，值和值的名称都提供了
+```
+<a name="special_kinds_of_methods"></a>
 ###特殊方法
 
-以self修饰的枚举或结构体方法必须以mutating关键字作为函数声明头。
+枚举或结构体的方法来修改`self`属性，必须以`mutating`声明修饰符标记。
 
-子类重写的方法必须以override关键字作为函数声明头。不用override关键字重写的方法，使用了override关键字
-却并没有重写父类方法都会报错。
+子类方法重写超类中的方法必须以`override`声明修饰符标记。重写一个方法不使用`override`修饰符，或者使用了`override`修饰符却并没有重写超类方法都会产生一个编译时错误。
+
+枚举或者结构体中的类型方法而不是实例方法，要以`static`声明修饰符标记，而对于类中的类型方法，要使用`class`声明修饰符标记。
+
+<a name="curried_functions"></a>
+###柯里化函数(Curried Functions)
 
-和类型相关而不是和类型实例相关的方法必须在static声明的结构以或枚举内，亦或是以class关键字定义的类内。
-
-###柯里化函数和方法(Curried Functions and Methods)
-
-你可以重写一个带有多个参数的函数使它等同于一个只有一个参数并且返回一个函数的函数，这个返回函数携带下一个参数并且返回另外一个函数，一直持续到再没有剩余的参数，此时要返回的函数返回原来的多参函数要返回的原始值。这个重写的函数被称为“柯里化函数”。例如，你可以为```addTwoInts```重写一个等价的```addTwoIntsCurried```的函数。
+可以重写一个带有多个参数的函数使它等同于一个只有一个参数并且返回一个函数的函数，这个返回函数携带下一个参数并且返回另外一个函数，一直持续到再没有剩余的参数，此时要返回的函数返回原来的多参函数要返回的原始值。这个重写的函数被称为*柯里化函数(curried function)*。例如，可以为`addTwoInts(a:b:)`重写一个等价的`addTwoIntsCurried(a:)(b:)`的函数。
 
 ```swift
 func addTwoInts(a: Int, b: Int) -> Int {
@@ -384,23 +368,23 @@ func addTwoIntsCurried(a: Int) -> (Int -> Int) {
 }
 ```
 
-这个```addTwoInts```函数带有两个整型值并且返回他们的和。```addTwoIntsCurried```函数带有一个整型值，并且返回另外一个带有第二个整型值的函数并使其和第一个整型值相加（这个内嵌的函数从包含它的函数中捕获第一个整型参数的值）。
+这个`addTwoInts(a:b:)`函数带有两个整型值并且返回他们的和。`addTwoIntsCurried(a:)(b:)`函数带有一个整型值，并且返回另外一个带有第二个整型值的函数并使其和第一个整型值相加（这个内嵌的函数从包含它的函数中捕获第一个整型参数的值）。
 
-在Swift中，你可以通过以下语法非常简明的写一个柯里化函数：
+在Swift中，可以通过以下语法非常简明的写一个柯里化函数：
 
-> func `function name`(`parameters`)(`parameters`) -> `return type` {  
->     `statements`  
+> func `function name`(`parameter`)(`parameter`) -> `return type` {  
+> `statements`  
 > }  
-> 
 
 举例来说，下面的两个声明是等价的:
 
 ```swift
-func addTwoIntsCurried(a: Int)(b: Int) -> Int {
+func addTwoIntsCurried(a a: Int)(b: Int) -> Int {
     return a + b
 }
 
-func addTwoIntsCurried(a: Int) -> (Int -> Int) {
+func addTwoIntsCurried(a a: Int) -> (Int -> Int) 
+			{
     func addTheOtherInt(b: Int) -> Int {
         return a + b
     }
@@ -408,118 +392,145 @@ func addTwoIntsCurried(a: Int) -> (Int -> Int) {
 }
 ```
 
-为了像使用非柯里化函数一样的方式使用```addTwoIntsCurried```函数，你必须用第一个整型参数调用```addTwoIntsCurried```,紧接着用第二个整型参数调用其返回的函数：
+为了像使用非柯里化函数一样的方式使用`addTwoIntsCurried(a:)(b:)`函数，必须用第一个整型参数调用`addTwoIntsCurried(a:)(b:)`,紧接着用第二个整型参数调用其返回的函数：
 
 ```swift
-addTwoInts(4, 5)
+addTwoInts(a: 4, b: 5)
 //返回值为9
-addTwoIntsCurried(4)(5)
+addTwoIntsCurried(a: 4)(b: 5)
 //返回值为9
 ```
 
-虽然你在每次调用一个非柯里化函数时必须提供所有的参数，你可以使用函数的柯里化形式把参数分配在多次函数调用中，称之为“偏函数应用”，例如你可以为```addTwoIntsCurried```函数使用参数```1```然后把返回的结果赋值给常量```plusOne```：
+虽然在每次调用一个非柯里化函数时必须提供所有的参数，可以使用函数的柯里化形式把参数分配在多次函数调用中，称之为“*偏函数应用(partial function application)*”，例如可以为`addTwoIntsCurried(a:)(b:)`函数使用参数`1`然后把返回的结果赋值给常量`plusOne`：
 
 ```swift
-let plusOne = addTwoIntsCurried(1)
+let plusOne = addTwoIntsCurried(a: 1)
 // plusOne 是类型为 Int -> Int的函数
 ```
 
-因为```plusOne```是函数```addTwoIntsCurried```绑定参数为```1```时结果，所以可以调用```plusOne```并且传入一个整型使其和```1```相加。
+因为`plusOne`是函数`addTwoIntsCurried(a:)(b:)`绑定参数为`1`时结果，所以可以调用`plusOne`并且传入一个整型使其和`1`相加。
 
 ```swift
 plusOne(10)
 // 返回值为11
-```
-
+```
+
+<a name="throwing_functions_and_methods"></a>
+###抛出异常函数和抛出异常方法(Throwing Functions and Methods)
+
+可以抛出一个错误的函数或方法必需使用`throws`关键字标记。这些函数和方法被称为*抛出异常函数(throwing functions)*和*抛出异常方法(throwing methods)*。它们有着下面的形式:
+
+>	func `function name`(`parameters`) throws ->
+>		`return type`	{
+>			`statements`
+>		}
+
+调用一个抛出异常函数或抛出异常方法必需用一个`try`或者`try!`表达式来封装（也就是说，在一个范围内使用一个`try`或者`try!`运算符）。
+
+`throws`关键字是函数的类型的一部分，不抛出异常的函数是抛出异常函数的一个子类型。所以，可以在使用抛出异常函数的地方使用不抛出异常函数。对于柯里化函数，`throws`关键字仅运用于最内层的函数。
+
+不能重写一个仅基于是否能抛出错误的函数。也就是说，可以重载一个基于函数*参数(parameter)*能否抛出一个错误的函数。
+
+一个抛出异常的方法不能重写一个不能抛出异常的方法，而且一个异常抛出方法不能满足一个协议对于不抛出异常方法的需求。也就是说，一个不抛出异常的方法可以重写一个抛出异常的方法，而且一个不抛出异常的方法可以满足一个协议对于抛出异常的需求。
+
+<a name="rethrowing_functions_and_methods"></a>
+###重抛出异常函数和重抛出异常方法(Rethrowing Functions and Methods)
+
+一个函数或方法可以使用`rethrows`关键字来声明，从而表明仅当这个函数或方法的一个函数参数抛出错误时这个函数或方法才抛出错误。这些函数和方法被称为*重抛出异常函数(rethrowing functions)*和*重抛出异常方法(rethrowing methods)*。重抛出异常函数或方法必需有至少一个抛出异常函数参数。
+
+```
+	func functionWithCallback(callback: () throws -> Int) rethrows {
+		try callback()
+	}
+```
+一个抛出异常函数方法不能重写一个重抛出异常函数方法，一个抛出异常方法不能满足一个协议对于重抛出异常方法的需求。也就是说，一个重抛出异常方法可以重写一个抛出异常方法，而且一个重抛出异常方法可以满足一个协议对于抛出异常方法的需求。
+
+<a name="grammer_of_a_function_declaration"></a>
 > 函数声明语法  
 > *函数声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature) [*函数体*](..\chapter3\05_Declarations.html#function_body)  
-> *函数头* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **func**  
+> *函数头* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **func**  
 > *函数名* → [*标识符*](LexicalStructure.html#identifier) | [*运算符*](LexicalStructure.html#operator)  
-> *函数签名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
+> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **throws** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
+> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
 > *函数结果* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
 > *函数体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *parameter-clauses* → [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可选_  
 > *参数子句* → **(** **)** | **(** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list) **...** _可选_ **)**  
 > *参数列表* → [*参数*](..\chapter3\05_Declarations.html#parameter) | [*参数*](..\chapter3\05_Declarations.html#parameter) **,** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list)  
-> *参数* → **inout** _可选_ **let** _可选_ **#** _可选_ [*参数名*](..\chapter3\05_Declarations.html#parameter_name) [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
-> *参数* → **inout** _可选_ **var** **#** _可选_ [*参数名*](..\chapter3\05_Declarations.html#parameter_name) [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name)_可选_ [*内部参数名*](..\chapter3\05_Declarations.html#local_parameter_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → **inout** _可选_ **var** [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name) [*内部参数名*](..\chapter3\05_Declarations.html#local_parameter_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
 > *参数* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
 > *参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**  
-> *本地参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**  
+> *内部参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**  
 > *默认参数子句* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
 
 <a name="enumeration_declaration"></a>
 ##枚举声明
 
-在你的程序里使用枚举声明来引入一个枚举类型。
+在程序里使用*枚举声明(enumeration)*来引入一个枚举类型。
 
-枚举声明有两种基本的形式，使用关键字enum来声明。枚举声明体使用从零开始的变量——叫做枚举事件，和任意数量的
-声明，包括计算型属性，实例方法，静态方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能
-包含析构器或者协议声明。
+枚举声明有两种基本的形式，使用关键字`enum`来声明。枚举声明体使用从零开始的变量——叫做*枚举事件(enumeration cases)*，和任意数量的声明，包括计算型属性，实例方法，类型方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能包含析构器或者协议声明。
+
+枚举类型可以采用任何数量的协议，但是这些协议不能从类，结构体和其他的枚举继承。
 
-不像类或者结构体。枚举类型并不提供隐式的初始构造器，所有构造器必须显式的声明。构造器可以委托枚举中的其他
-构造器，但是构造过程仅当构造器将一个枚举时间完成后才全部完成。
+不像类或者结构体。枚举类型并不提供隐式的初始构造器，所有构造器必须显式的声明。构造器可以委托枚举中的其他构造器，但是构造过程仅当构造器将一个枚事件指定给`self`才全部完成。
 
 和结构体类似但是和类不同，枚举是值类型：枚举实例在赋予变量或常量时，或者被函数调用时被复制。
-更多关于值类型的信息，参见结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
-
-你可以扩展枚举类型，正如在扩展名声明(Extension Declaration)中讨论的一样。
+更多关于值类型的信息，参见结构体和枚举都是[值类型(Structures and Enumerations Are Value Types)](TODO)一节。
 
+可以扩展枚举类型，正如在[扩展声明(Extension Declaration)](TODO)中讨论的一样。
+
+<a name="enumerations_with_cases_of_any_type"></a>
 ###任意事件类型的枚举
 
 如下的形式声明了一个包含任意类型枚举时间的枚举变量
 
-> enum `enumeration name` {  
+> enum `enumeration name`: `adopted protocols`{  
 >     case `enumeration case 1`  
 >     case `enumeration case 2`(`associated value types`)  
 > }  
 
-这种形式的枚举声明在其他语言中有时被叫做可识别联合(discrinminated)。
+这种形式的枚举声明在其他语言中有时被叫做*可识别联合(discrinminated)*。
 
-这种形式中，每一个事件块由关键字case开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是
-独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在关联值类型的元组里被指定，立即书写在事件
-名后。获得更多关于关联值类型的信息和例子，请查看关联值(associated values)一节。
-
-###使用原始事件值的枚举
+这种形式中，每一个事件块由关键字`case`开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在*关联值类型(associated values types)*的元组里被指定，立即书写在事件
+名后。获得更多关于关联值类型的信息和例子，请查看[关联值(Associated Values)](TODO)一节。
+
+<a name="enumerations_with_cases_of_a_raw-value_type"></a>
+###使用原始值类型事件的枚举(Enumerations with Cases of a Raw-Value Type)
 
 以下的形式声明了一个包含相同基础类型的枚举事件的枚举：
 
-> enum `enumeration name`: `raw value type` {  
->     case `enumeration case 1` = `raw value 1`  
->     case `enumeration case 2` = `raw value 2`  
+> 	enum `enumeration name`: `raw value type`, `adopted protocols`{  
+>		case `enumeration case 1` = `raw value 1`  
+>		case `enumeration case 2` = `raw value 2`  
 > }  
 
-在这种形式中，每一个事件块由case关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举
-事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做原始值(raw value)。这些值的类型在原始值类型(raw value type)
-中被指定，必须是字面上的整数，浮点数，字符或者字符串。
+在这种形式中，每一个事件块由`case`关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做*原始值(raw value)*。这些值的类型在*原始值类型(raw-value type)*中被指定，必须表示一个整数，浮点数，字符串，或者一个字符。特别是*原始值类型(raw-value type)*必需遵守`Equatable`类型的协议和下列形式中的一种字面量构造协议(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮点行字面量有`FloatingPointLiteralConvertible`，包含任意数量字符的字符串型字面量有`StringLiteralConvertible`，仅包含一个单一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。
 
-每一个事件必须有唯一的名字，必须有一个唯一的初始值。如果初始值类型被指定为int，则不必为事件显式的指定值，
-它们会隐式的被标为值0,1,2等。每一个没有被赋值的Int类型时间会隐式的赋予一个初始值，它们是自动递增的。
+每一个事件必须有唯一的名字，必须有一个唯一的初始值。如果初始值类型被指定为`Int`，则不必为事件显式的指定值，它们会隐式的被标为值`0,1,2`等。每一个没有被赋值的`Int`类型时间会隐式的赋予一个初始值，它们是自动递增的。
 
-```swift
+```Swift
 num ExampleEnum: Int {
     case A, B, C = 5, D
 }
 ```
 
-在上面的例子中，ExampleEnum.A的值是0，ExampleEnum.B的值是1。因为ExampleEnum.C的值被显式的设定为5，因此
-ExampleEnum.D的值会自动增长为6.
-
-枚举事件的初始值可以调用方法toRaw获得，如ExampleEnum.B.toRaw()。你也可以通过调用fromRaw方法来使用初始值找到
-其对应的事件，并返回一个可选的事件。查看更多信息和获取初始值类型事件的信息，参阅初始值(raw values)。
-
+在上面的例子中，`ExampleEnum.A`的值是`0`，`ExampleEnum.B`的值是`1`。因为`ExampleEnum.C`的值被显式的设定为`5`，因此`ExampleEnum.D`的值会自动增长为`6`。
+
+拥有多种事件的原始值类型的枚举含蓄地遵循定义在Swift标准库中的`RawRepresentable`协议。所以，它们拥有一个原始值(`rawValue`)属性和一个有着`init?(rawValue: RawValue)`签名的可失败构造器(a failable initializer)。可以使用原始值属性去取的枚举事件的原始值，就像在`ExampleEnum.B.rawValue`中一样。如果有一个事件符合，也可以使用原始值去找到一个符合的事件，通过调用枚举的可失败构造器，如`ExampleEnum(rawValue: 5)`,这个可失败构造器返回一个可选的事件。想得到更多的信息和关于原始值类型查看更多信息和获取初始值类型事件的信息，参阅初始值[原始值(Raw Values)](TODO)。
+
+<a name="accessing_enumeration_cases"></a>
 ###获得枚举事件
 
-使用点(.)来引用枚举类型的事件，如 EnumerationType.EnumerationCase。当枚举类型可以上下文推断出时，你可以
-省略它(.仍然需要)，参照枚举语法(Enumeration Syntax)和显式成员表达(Implicit Member Expression).
+使用点(.)来引用枚举类型的事件，如`EnumerationType.EnumerationCase`。当枚举类型可以上下文推断出时，可以省略它(.仍然需要)，参照枚举语法[(Enumeration Syntax)](TODO)和[显式成员表达(Implicit Member Expression)](TODO)。
 
-使用switch语句来检验枚举事件的值，正如使用switch语句匹配枚举值（Matching Enumeration Values with a Switch Statement)一节描述的那样。
-
-枚举类型是模式匹配(pattern-matched)的，和其相反的是switch语句case块中枚举事件匹配，在枚举事件类型(Enumeration Case Pattern)中有描述。
-
-> 枚举声明语法  
-> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*联合式枚举*](..\chapter3\05_Declarations.html#union_style_enum) | [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*原始值式枚举*](..\chapter3\05_Declarations.html#raw_value_style_enum)  
-> *联合式枚举* → [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
+使用`switch`语句来检验枚举事件的值，正如使用[switch语句匹配枚举值（Matching Enumeration Values with a Switch Statement)](TODO)一节描述的那样。枚举类型是模式匹配(pattern-matched)的，和其相反的是`switch`语句case块中枚举事件匹配，在[枚举事件类型(Enumeration Case Pattern)](TODO)中有描述。
+
+<a name="grammer_of_an_enumeration_declaration"></a>
+> 枚举声明语法 
+> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO) 
+> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO)  _可选_ [*原始值式枚举*](..\chapter3\05_Declarations.html#raw_value_style_enum) 
+> *联合式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [类型继承子句](TODO)_可选_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
 > *union-style-enum-members* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_  
 > *union-style-enum-member* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case子句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)  
 > *联合式(Union Style)的枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
@@ -527,123 +538,130 @@ ExampleEnum.D的值会自动增长为6.
 > *联合式(Union Style)的case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组类型*](..\chapter3\03_Types.html#tuple_type) _可选_  
 > *枚举名* → [*标识符*](LexicalStructure.html#identifier)  
 > *枚举的case名* → [*标识符*](LexicalStructure.html#identifier)  
-> *原始值式枚举* → [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier) **{** [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_ **}**  
+> *原始值式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](TODO) **{** [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) **}**  
 > *原始值式枚举成员列表* → [*原始值式枚举成员*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_  
 > *原始值式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚举case子句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)  
 > *原始值式枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
 > *原始值式枚举case列表* → [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
 > *原始值式枚举case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*原始值赋值*](..\chapter3\05_Declarations.html#raw_value_assignment) _可选_  
-> *原始值赋值* → **=** [*字面量*](LexicalStructure.html#literal)  
+> *原始值赋值* → **=** [*原始值字面量*](TODO)  
+> *原始值字面量* → [数字型字面量](TODO)|[字符串型字面量](TODO)|[布尔型字面量](TODO)
 
 <a name="structure_declaration"></a>
 ##结构体声明
 
-使用结构体声明可以在你的程序里引入一个结构体类型。结构体声明使用struct关键字，遵循如下的形式：
+使用*结构体声明(strucre declaration)*可以在程序里引入一个结构体类型。结构体声明使用`struct`关键字，遵循如下的形式：
 
 > struct `structure name`: `adopted protocols` {  
 >     `declarations`  
 > }  
 
-结构体内包含零或多个声明。这些声明可以包括存储型和计算型属性，静态属性，实例方法，静态方法，构造器，
-类型别名，甚至其他结构体，类，和枚举声明。结构体声明不能包含析构器或者协议声明。详细讨论和包含多种结构体
-声明的实例，参见类和结构体一节。
+结构体内包含零或多个声明*声明(declarations)*。这些*声明(declarations)*可以包括存储型和计算型属性，类型属性，实例方法，类型方法，构造器，下标脚本，类型别名，甚至其他结构体，类，和枚举声明。结构体声明不能包含析构器或者协议声明。详细讨论和包含多种结构体声明的实例，参见[类和结构体(Classes and Structures)](TODO)一节。
 
 结构体可以包含任意数量的协议，但是不能继承自类，枚举或者其他结构体。
 
 有三种方法可以创建一个声明过的结构体实例：
 
--调用结构体内声明的构造器，参照构造器(initializers)一节。
+* 调用结构体内声明的构造器，参照[构造器(Initializers)](TODO)一节。
 
-—如果没有声明构造器，调用结构体的逐个构造器，详情参见Memberwise Initializers for Structure Types.
+* 如果没有声明构造器，调用结构体的逐个构造器，详情参见[Memberwise Initializers for Structure Types](TODO)。
 
-—如果没有声明析构器，结构体的所有属性都有初始值，调用结构体的默认构造器，详情参见默认构造器(Default Initializers).
+* 如果没有声明析构器，结构体的所有属性都有初始值，调用结构体的默认构造器，详情参见[默认构造器(Default Initializers)](TODO)。
 
-结构体的构造过程参见初始化(initiaization)一节。
+结构体的构造过程参见[构造过程(Initiaization)](TODO)一节。
 
-结构体实例属性可以用点(.)来获得，详情参见获得属性(Accessing Properties)一节。
+结构体实例属性可以用点(.)来获得，详情参见[获得属性(Accessing Properties)](TODO)一节。
 
 结构体是值类型；结构体的实例在被赋予变量或常量，被函数调用时被复制。获得关于值类型更多信息，参见
-结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
-
-你可以使用扩展声明来扩展结构体类型的行为，参见扩展声明(Extension Declaration).
+[结构体和枚举是值类型(Structures and Enumerations Are Value Types)](TODO)一节。
 
+可以使用扩展声明来扩展结构体类型的行为，参见[扩展声明(Extension Declaration)](TODO)。
+
+<a name="grammer_of_a_structure_declaration"></a>
 > 结构体声明语法  
-> *结构体声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **struct** [*结构体名称*](..\chapter3\05_Declarations.html#struct_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](..\chapter3\05_Declarations.html#struct_body)  
+> *结构体声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [访问级别修饰符](TODO )_可选_ **struct** [*结构体名称*](..\chapter3\05_Declarations.html#struct_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](..\chapter3\05_Declarations.html#struct_body)  
 > *结构体名称* → [*标识符*](LexicalStructure.html#identifier)  
 > *结构体主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
 
 <a name="class_declaration"></a>
 ##类声明
 
-你可以在你的程序中使用类声明来引入一个类。类声明使用关键字class，遵循如下的形式：
+可以在程序中使用*类声明(class declaration)*来引入一个类。类声明使用关键字`class`，遵循如下的形式：
 
 > class `class name`: `superclass`, `adopted protocols` {  
 >     `declarations`  
 > }  
 
-一个类内包含零或多个声明。这些声明可以包括存储型和计算型属性，实例方法，类方法，构造器，单独的析构器方法，
-类型别名，甚至其他结构体，类，和枚举声明。类声明不能包含协议声明。详细讨论和包含多种类声明的实例，参见类和
-结构体一节。
+一个类内包含零或多个*声明(declarations)*。这些*声明(declarations)*可以包括存储型和计算型属性，实例方法，类型方法，构造器，单独的析构器，下标脚本，类型别名，甚至其他结构体，类，和枚举声明。类声明不能包含协议声明。详细讨论和包含多种类声明的实例，参见[类和结构体(Classes and Structures)](TODO)一节。
 
-一个类只能继承一个父类，超类，但是可以包含任意数量的协议。这些超类第一次在type-inheritance-clause出现，遵循任意协议。
+一个类只能继承一个父类，*超类(superclass)*，但是可以包含任意数量的协议。*超类(superclass)*第一次出现在*类名(class name)*和冒号后面，其后跟着*采用的协议(adopted protocols)*。泛型类可以继承其它类型类和非泛型类，但是非泛型类只能继承其它的非泛型类。当在冒号后面写泛型超类的名称时，必须写那个泛型类的全名，包括它的泛型参数子句。
 
-正如在初始化声明(Initializer Declaration)谈及的那样，类可以有指定(designated)和方便(convenience)构造器。当你声明任一种构造器时，
-你可以使用required变量来标记构造器，要求任意子类来重写它。指定类的构造器必须初始化类所有的已声明的属性，
-它必须在子类构造器调用前被执行。
+正如在[初始化声明(Initializer Declaration)](TODO)谈及的那样，类可以有指定构造器和方便构造器。类的指定构造器必须初始化类所有的已声明的属性，它必须在超类构造器调用前被执行。
 
-类可以重写属性，方法和它的超类的构造器。重写的方法和属性必须以override标注。
+类可以重写属性，方法，下表脚本和它的超类构造器。重写的属性，方法，下标脚本，和指定构造器必须以`override`声明修饰符标记。
+
+为了要求子类去实现超类的构造器，使用`required`声明修饰符去标记超类的构造器。在子类实现父类构造器时也必须使用`required`声明修饰符去标记。
 
-虽然超类的属性和方法声明可以被当前类继承，但是超类声明的指定构造器却不能。这意味着，如果当前类重写了超类
-的所有指定构造器，它就继承了超类的方便构造器。Swift的类并不是继承自一个全局基础类。
+虽然*超类(superclass)*的属性和方法声明可以被当前类继承，但是*超类(superclass)*声明的指定构造器却不能。这意味着，如果当前类重写了超类的所有指定构造器，它就继承了超类的方便构造器。Swift的类并不是继承自一个全局基础类。
 
 有两种方法来创建已声明的类的实例：
 
-- 调用类的一个构造器，参见构造器(initializers)。
-- 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见默认构造器(default initializers).
+* 调用类的一个构造器，参见[构造器(Initializers)](TODO)。
+
+* 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见[默认构造器(Default Initializers)](TODO)。
 
-类实例属性可以用点(.)来获得，详情参见获得属性(Accessing Properties)一节。
+类实例属性可以用点(.)来获得，详情参见[获得属性(Accessing Properties)](TODO)一节。
 
-类是引用类型；当被赋予常量或变量，函数调用时，类的实例是被引用，而不是复制。获得更多关于引用类型的信息，
-结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
-
-你可以使用扩展声明来扩展类的行为，参见扩展声明(Extension Declaration).
+类是引用类型；当被赋予常量或变量，函数调用时，类的实例是被引用，而不是复制。获得更多关于引用类型的信息，[结构体和枚举都是值类型(Structures and Enumerations Are Value Types)](TODO)一节。
 
+可以使用扩展声明来扩展类的行为，参见[扩展声明(Extension Declaration)](TODO)。
+
+<a name="grammer_of_a_class_declaration"></a>
 > 类声明语法  
-> *类声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **class** [*类名*](..\chapter3\05_Declarations.html#class_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类主体*](..\chapter3\05_Declarations.html#class_body)  
+> *类声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [访问级别修饰符](TODO)**class** [*类名*](..\chapter3\05_Declarations.html#class_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类主体*](..\chapter3\05_Declarations.html#class_body)  
 > *类名* → [*标识符*](LexicalStructure.html#identifier)  
 > *类主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
 
 <a name="protocol_declaration"></a>
 ##协议声明(translated by 小一)
 
-一个协议声明为你的程序引入一个命名了的协议类型。协议声明使用 `protocol` 关键词来进行声明并有下面这样的形式：
+一个*协议声明(protocol declaration)*为程序引入一个命名了的协议类型。协议声明在一个全局访问的区域使用 `protocol` 关键词来进行声明并有下面这样的形式：
 
 > protocol `protocol name`: `inherited protocols` {  
 >     `protocol member declarations`  
 > }  
 
-协议的主体包含零或多个协议成员声明，这些成员描述了任何采用该协议必须满足的一致性要求。特别的，一个协议可以声明必须实现某些属性、方法、初始化程序及下标脚本的一致性类型。协议也可以声明专用种类的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议成员声明会在下面的详情里进行讨论。
+协议的主体包含零或多个*协议成员声明(protocol member declarations)*，这些成员描述了任何采用该协议必须满足的一致性要求。特别的，一个协议可以声明必须实现某些属性、方法、初始化程序及下标脚本的一致性类型。协议也可以声明专用种类的类型别名，叫做*关联类型(associated types)*，它可以指定协议的不同声明之间的关系。协议声明不包括类，结构体，枚举或者其它协议的声明。协议成员声明会在下面的详情里进行讨论。
 
-协议类型可以从很多其它协议那继承。当一个协议类型从其它协议那继承的时候，来自其它协议的所有要求就集合了，而且从当前协议继承的任何类型必须符合所有的这些要求。对于如何使用协议继承的例子，查看[协议继承](../chapter2/21_Protocols.html#protocol_inheritance)
+协议类型可以从很多其它协议那继承。当一个协议类型从其它协议那继承的时候，来自其它协议的所有要求就集合了，而且从当前协议继承的任何类型必须符合所有的这些要求。对于如何使用协议继承的例子，查看[协议继承(Protocol Inheritance)](../chapter2/21_Protocols.html#protocol_inheritance)
 
 > 注意：  
-你也可以使用协议合成类型集合多个协议的一致性要求，详情参见[协议合成类型](../chapter3/03_Types.html#protocol_composition_type)和[协议合成](../chapter2/21_Protocols.html#protocol_composition)
+也可以使用协议合成类型集合多个协议的一致性要求，详情参见[协议合成类型(Protocol Composition Type)](../chapter3/03_Types.html#protocol_composition_type)和[协议合成(Protocol Composition)](../chapter2/21_Protocols.html#protocol_composition)
 
-你可以通过采用在类型的扩展声明中的协议来为之前声明的类型添加协议一致性。在扩展中你必须实现所有采用协议的要求。如果该类型已经实现了所有的要求，你可以让这个扩展声明的主题留空。
+可以通过采用在类型的扩展声明中的协议来为之前声明的类型添加协议一致性。在扩展中必须实现所有采用协议的要求。如果该类型已经实现了所有的要求，可以让这个扩展声明的主题留空。
 
-默认地，符合某一个协议的类型必须实现所有声明在协议中的属性、方法和下标脚本。也就是说，你可以用`optional`属性标注这些协议成员声明以指定它们的一致性类型实现是可选的。`optional`属性仅仅可以用于使用`objc`属性标记过的协议。这样的结果就是仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用`optional`属性的信息及如何访问可选协议成员的指导——比如当你不能肯定是否一致性的类型实现了它们——参见[可选协议要求](../chapter2/21_Protocols.html#optional_protocol_requirements)
+默认地，符合某一个协议的类型必须实现所有声明在协议中的属性、方法和下标脚本。也就是说，可以用`optional`声明修饰符标注这些协议成员声明以指定它们的一致性类型实现是可选的。`optional`修饰符仅仅可以用于使用`objc`属性标记过的协议。这样的结果就是仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用`optional`属性的信息及如何访问可选协议成员的指导——比如当不能肯定是否一致性的类型实现了它们——参见[可选协议要求(Optional Protocol Requirements)](../chapter2/21_Protocols.html#optional_protocol_requirements)
 
-为了限制协议的采用仅仅针对类类型，需要使用`class_protocol`属性标记整个协议声明。任意继承自标记有`class_protocol`属性协议的协议都可以智能地仅能被类类型采用。
+为了限制协议的采用仅仅针对类类型，需要强制使用`class`来标记协议，通过将`class`关键在写在冒号后面的*继承协议列表(inherited protocols)*的第一个位置。例如，下面的协议形式只能被类类型采用：
+
+```swift
+protocol SomeProtocol:class{
+	/* Protocol member go here */
+}
+```
+
+任意继承自需要标记有`class`协议的协议都可以智能地仅能被类类型采用。
 
 >注意：  
-如果协议已经用`object`属性标记了，`class_protocol`属性就隐性地应用于该协议；没有必要再明确地使用`class_protocol`属性来标记该协议了。
+>如果协议已经用`object`属性标记了，`class`条件就隐性地应用于该协议；没有必要再明确地使用`class`条件来标记该协议了。
 
-协议是命名的类型，因此它们可以以另一个命名类型出现在你代码的所有地方，就像[协议类型](../chapter2/21_Protocols.html#protocols_as_types)里讨论的那样。然而你不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。
-
-你可以使用协议来声明一个类的代理的方法或者应该实现的结构，就像[委托(代理)模式](../chapter2/21_Protocols.html#delegation)描述的那样。
+协议是命名的类型，因此它们可以以另一个命名类型出现在代码的所有地方，就像[协议类型(Protocol as Types)](../chapter2/21_Protocols.html#protocols_as_types)里讨论的那样。然而不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。
 
+可以使用协议来声明一个类的代理的方法或者应该实现的结构，就像[委托(代理)模式(Delegation)](../chapter2/21_Protocols.html#delegation)描述的那样。
+
+<a name="grammer_of_a_protocol_declaration"></a>
 > 协议(Protocol)声明语法  
-> *协议声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **protocol** [*协议名*](..\chapter3\05_Declarations.html#protocol_name) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](..\chapter3\05_Declarations.html#protocol_body)  
+> *协议声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ **protocol** [*协议名*](..\chapter3\05_Declarations.html#protocol_name) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](..\chapter3\05_Declarations.html#protocol_body)  
 > *协议名* → [*标识符*](LexicalStructure.html#identifier)  
 > *协议主体* → **{** [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_ **}**  
 > *协议成员声明* → [*协议属性声明*](..\chapter3\05_Declarations.html#protocol_property_declaration)  
@@ -656,76 +674,79 @@ ExampleEnum.D的值会自动增长为6.
 <a name="protocol_property_declaration"></a>
 ###协议属性声明
 
-协议声明了一致性类型必须在协议声明的主体里通过引入一个协议属性声明来实现一个属性。协议属性声明有一种特殊的类型声明形式：
+协议声明了一致性类型必须在协议声明的主体里通过引入一个*协议属性声明(protocol property declaraion)*来实现一个属性。协议属性声明有一种特殊的类型声明形式：
 
 > var `property name`: `type` { get set }
 
-同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了`getter`和`setter`要求。结果就是你不需要在协议里它被声明的地方实现`getter`和`setter`。
+同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了`getter`和`setter`要求。结果就是不需要在协议里它被声明的地方实现`getter`和`setter`。
 
-`getter`和`setter`要求可以通过一致性类型以各种方式满足。如果属性声明包含`get`和`set`关键词，一致性类型就可以用可读写（实现了`getter`和`setter`）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含`get`关键词的话，它可以作为任意类型的属性被实现。比如说实现了协议的属性要求的一致性类型，参见[属性要求](../chapter2/21_Protocols.html#property_requirements)
-
-更多参见[变量声明](../chapter3/05_Declarations.html#variable_declaration)
+`getter`和`setter`要求可以通过一致性类型以各种方式满足。如果属性声明包含`get`和`set`关键词，一致性类型就可以用可读写（实现了`getter`和`setter`）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含`get`关键词的话，它可以作为任意类型的属性被实现。比如说实现了协议的属性要求的一致性类型，参见[属性要求(Property Requirements)](../chapter2/21_Protocols.html#property_requirements)
 
+更多参见[变量声明(Variabel Declaration)](../chapter3/05_Declarations.html#variable_declaration)
+
+<a name="grammer_of_an_import_declaration"></a>
 > 协议属性声明语法  
-> *协议属性声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-
+> *协议属性声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
+
+<a name="protocol_method_declaration"></a>
 ###协议方法声明
 
-协议声明了一致性类型必须在协议声明的主体里通过引入一个协议方法声明来实现一个方法.
-协议方法声明和函数方法声明有着相同的形式，包含如下两条规则：它们不包括函数体，你不能在类的声明内为它们的
-参数提供初始值.举例来说，符合的类型执行协议必需的方法。参见必需方法一节。
+协议声明了一致性类型必须在协议声明的主体里通过引入一个协议方法声明来实现一个方法。协议方法声明和函数方法声明有着相同的形式，包含如下两条规则：它们不包括函数体，不能在类的声明内为它们的参数提供初始值.举例来说，符合的类型执行协议必需的方法。参见[必需方法(Method Requirements)](TODO)一节。
 
-使用关键字class可以在协议声明中声明一个类或必需的静态方法。执行这些方法的类也用关键字class声明。
-相反的，执行这些方法的结构体必须以关键字static声明。如果你想使用扩展方法，在扩展类时使用class关键字，
-在扩展结构体时使用static关键字。
-
-更多请参阅函数声明。
+使用`static`声明修饰符可以在协议声明中声明一个类或必需的静态方法。执行这些方法的类用修饰符`class`声明。相反的，执行这些方法的结构体必须以`static`声明修饰符声明。如果想使用扩展方法，在扩展类时使用`class`修饰符，在扩展结构体时使用`static`修饰符。
 
+更多请参阅[函数声明(Function Declaration)](TODO)。
+
+<a name="grammer_of_a_protocol_declaration"></a>
 > 协议方法声明语法  
 > *协议方法声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature)  
-
+
+<a name="protocol_initializer_declaration"></a>
 ###协议构造器声明
 
 协议声明了一致性类型必须在协议声明的主体里通过引入一个协议构造器声明来实现一个构造器。协议构造器声明
-除了不包含构造器体外，和构造器声明有着相同的形式，
-
-更多请参阅构造器声明。
+除了不包含构造器体外，和构造器声明有着相同的形式。
+
+一个一致性类型可以通过实现一个非可失败构造器或者`init!`可失败构造器去满足一个非可失败协议构造器的需求。一个一致性类型通过实现任意类型的构造器可以满足一个可失败协议构造器的需求。
+
+当一个类去实现一个构造器去满足一个协议的构造器的需求，如果这个类还没有用`final`声明修饰符标记，这个构造器必需使用`required`声明修饰符去标记。
 
+更多请参阅[构造器声明(Initializer Declaration)](TODO)。
+
+<a name="grammer_of_a_protocol_initializer_declaration"></a>
 > 协议构造器声明语法  
 > *协议构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)  
-
+
+<a name="protocol_subscript_declaration"></a>
 ###协议下标脚本声明
 
-协议声明了一致性类型必须在协议声明的主体里通过引入一个协议下标脚本声明来实现一个下标脚本。协议属性声明
-对下标脚本声明有一个特殊的形式：
+协议声明了一致性类型必须在协议声明的主体里通过引入一个协议下标脚本声明来实现一个下标脚本。协议下标脚本声明对下标脚本声明有一个特殊的形式：
 
 > subscript (`parameters`) -> `return type` { get set }
 
-下标脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果下标脚本申明包含get和set关键字，
-一致的类型也必须有一个getter和setter语句。如果下标脚本声明值包含get关键字，一致的类型必须至少包含一个
-getter语句，可以选择是否包含setter语句。
-
-更多参阅下标脚本声明。
+下标脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果下标脚本申明包含get和set关键字，一致的类型也必须有一个getter和setter语句。如果下标脚本声明值包含get关键字，一致的类型必须*至少(at least)*包含一个getter语句，可以选择是否包含setter语句。
 
+更多参阅[下标脚本声明(Subscript Declaration)](TODO)。
+
+<a name="grammer_of_a_protocol_subscript_declaration"></a>
 > 协议附属脚本声明语法  
 > *协议附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-
+
+<a name="protocol_associated_type_declaration"></a>
 ###协议相关类型声明
 
-协议声明相关类型使用关键字typealias。相关类型为作为协议声明的一部分的类型提供了一个别名。相关类型和参数
-语句中的类型参数很相似，但是它们在声明的协议中包含self关键字。在这些语句中，self指代和协议一致的可能的类型。
-获得更多信息和例子，查看相关类型或类型别名声明。
-
+协议声明相关类型使用关键字`typealias`。相关类型为作为协议声明的一部分的类型提供了一个别名。相关类型和参数语句中的类型参数很相似，但是它们在声明的协议中包含`self`关键字。在这些语句中，`self`指代和协议一致的可能的类型。获得更多信息和例子，查看[关联类型(Associated Types)](TODO)一节或[类型别名声明(Type Alias Declaration)](TODO)一节。
+
+<a name="grammer_of_a_protocol_associated_type_declaration"></a>
 > 协议关联类型声明语法  
 > *协议关联类型声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment) _可选_  
 
 <a name="initializer_declaration"></a>
 ##构造器声明
 
-构造器声明会为程序内的类，结构体或枚举引入构造器。构造器使用关键字Init来声明，遵循两条基本形式。
+*构造器(initializer)*声明会为程序内的类，结构体或枚举引入构造器。构造器使用关键字`init`来声明，遵循两条基本形式。
 
-结构体，枚举，类可以有任意数量的构造器，但是类的构造器的规则和行为是不一样的。不像结构体和枚举那样，类
-有两种结构体，designed initializers 和convenience initializers，参见构造器一节。
+结构体，枚举，类可以有任意数量的构造器，但是类的构造器的规则和行为是不一样的。不像结构体和枚举那样，类有两种结构体，designed initializers 和convenience initializers，参见[构造器(Initialization)](TODO)一节。
 
 如下的形式声明了结构体，枚举和类的指定构造器：
 
@@ -733,15 +754,13 @@ getter语句，可以选择是否包含setter语句。
 >     `statements`  
 > }  
 
-类的指定构造器将类的所有属性直接初始化。如果类有超类，它不能调用该类的其他构造器,它只能调用超类的一个
-指定构造器。如果该类从它的超类处继承了任何属性，这些属性在当前类内被赋值或修饰时，必须调用一个超类的
-指定构造器。
+类的指定构造器将类的所有属性直接初始化。如果类有超类，它不能调用该类的其他构造器,它只能调用超类的一个指定构造器。如果该类从它的超类处继承了任何属性，这些属性在当前类内被赋值或修饰时，必须调用一个超类的指定构造器。
 
 指定构造器可以在类声明的上下文中声明，因此它不能用扩展声明的方法加入一个类中。
 
 结构体和枚举的构造器可以调用其他的已声明的构造器，委托其中一个或所有的构造器进行初始化过程。
 
-以关键字convenience来声明一个类的便利构造器：
+以`convenience`声明修饰符来标记构造器声明来声明一个类的便利构造器：
 
 > convenience init(`parameters`) {  
 >    `statements`  
@@ -750,22 +769,69 @@ getter语句，可以选择是否包含setter语句。
 便利构造器可以将初始化过程委托给另一个便利构造器或类的一个指定构造器。这意味着，类的初始化过程必须
 以一个将所有类属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。
 
-你可以使用required关键字，将便利构造器和指定构造器标记为每个子类的构造器都必须拥有的。因为指定构造器
-不被子类继承，它们必须被立即执行。当子类直接执行所有超类的指定构造器(或使用便利构造器重写指定构造器)时，
-必需的便利构造器可以被隐式的执行，亦可以被继承。不像方法，下标脚本那样，你不需要为这些重写的构造器标注
-overrride关键字。
+可以使用required声明修饰符，将便利构造器和指定构造器标记为每个子类的构造器都必须实现的。一个子类的关于这个构造器的实现也必须使用`required`声明修饰符标记。
+
+默认情况下，声明在超类的构造器没有被子类继承。也就是说，如果一个子类使用默认的值去构造它所有的存储属性，而且没有定义任何自己的构造器，它将继承超类的构造器。如果子类重写所有超类的指定构造器，子类继承超类的便利构造器。
+
+和方法，属性和下表脚本一样，需要使用`override`声明修饰符标记重写了的制定构造器。
+
+>注意
+>如果使用`required`声明修饰符去标记一个构造器，当在子类中重写必要构造器时，也不要用`override`修饰符去标记构造器。
 
-查看更多关于不同声明方法的构造器的例子，参阅构造过程一节。
+查看更多关于不同声明方法的构造器的例子，参阅[构造过程(Initialization)](TODO)一节。
+
+<a name="failable_initializers"></a>
+###可失败构造器(Failable Initializers)
+
+*可失败构造器*是一种可以生成可选实例或者是一类构造器声明的隐式解析可选实例(an implicitly unwrapped optional instance)类型。所以，构造区通过返回`nil`来指明构造过程失败。
+
+声明可以生成可选实例的可失败构造器，在构造器声明的`init`关键字后加追加一个问号(`init?`)。声明可生成隐式解析可选实例的可失败构造器，在构造器声明后追加一个叹号(`init!`)。使用`init?`可失败构造器生成结构体的一个可选实例的例子如下。
+
+```swift
+struct SomeStruct {
+	let string: String
+	//生成一个'SomeStruct'的可选实例
+	init?(input: String) {
+		if input.isEmpty {
+			// 弃用'self' 返回 'nil'
+		}
+		string = input
+	}
+}
+```
+
+除非必需处理结果的可选性，可以使用调用非可失败构造器的方式调用`init?`可失败构造器。
+
+```swift
+if let actualInstance = SomeStruct(input: "Hello") {
+	//'SomeStruct'实例相关
+} else {
+	//'SomeStruct'实例构造过程失败，构造器返回'nil'
+}
+```
 
+在实现构造体的任何时间，结构体或者枚举的可失败构造器可以返回`nil`。然而，类的可失败构造器，仅在类的所有存储属性被构造之后且`self.init`或`super.init`被调用之后才返回`nil`（就是说，构造器的委托被执行）。
+
+可失败构造器可以委托任何种类的构造器。非可失败可以委托其它非可失败构造器或者`init!`可失败构造器。
+
+构造过程的失败由构造器的委托产生。特别的，如果可失败构造器代理一个构造器失败且返回`nil`，那么之后被委托的构造器也会失败且隐式的返回`nil`。如果非可失败构造器代理`init!`可失败构造器失败了且返回`nil`，那么后出现一个运行时错误（如同使用`!`操作符去解析一个有着`nil`值的可选项）。
+
+可失败指定构造器可以在子类中任何一种指定构造器重写。非可失败指定构造器在子类中仅能通过非可失败构造器被重写。
+
+得到更多的信息并且了解更多关于可失败构造器的例子，请参阅[可失败构造器(Failable Initializer)](TODO)
+
+<a name="grammer_of_an_initializer_declaration"></a>
 > 构造器声明语法  
 > *构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*构造器主体*](..\chapter3\05_Declarations.html#initializer_body)  
-> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **convenience** _可选_ **init**  
+> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init**       
+> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init ?**           
+> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init !** 
 > *构造器主体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 
 <a name="deinitializer_declaration"></a>
 ##析构声明
 
-析构声明为类声明了一个析构器。析构器没有参数，遵循如下的格式：
+*析构声明(deinitializer declaration)*为类声明了一个析构器。析构器没有参数，遵循如下的格式：
 
 > deinit {  
 >    `statements`  
@@ -778,40 +844,39 @@ overrride关键字。
 
 析构器不会被直接调用。
 
-查看例子和如何在类的声明中使用析构器，参见析构过程一节。
-
+查看例子和如何在类的声明中使用析构器，参见[析构过程Deinitialization](TODO)一节。
+
+<a name="grammer_of_a_deinitializer_declaration"></a>
 > 析构器声明语法  
 > *析构器声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 
 <a name="extension_declaration"></a>
 ##扩展声明
 
-扩展声明用于扩展一个现存的类，结构体，枚举的行为。扩展声明以关键字extension开始，遵循如下的规则：
+*扩展声明(extension declaration)*用于扩展一个现存的类，结构体，枚举的行为。扩展声明使用关键字`extension`，遵循如下的规则：
 
-> extension `type`: `adopted protocols` {  
+> extension `type name`: `adopted protocols` {  
 >    `declarations`  
 > }  
 
-一个扩展声明体包括零个或多个声明。这些声明可以包括计算型属性，计算型静态属性，实例方法，静态和类方法，构造器，
-下标脚本声明，甚至其他结构体，类，和枚举声明。扩展声明不能包含析构器，协议声明，存储型属性，属性监测器或其他
-的扩展属性。详细讨论和查看包含多种扩展声明的实例，参见扩展一节。
+一个扩展声明体包括零个或多个*声明语句(declarations)*。这些*声明语句(declarations)*可以包括计算型属性，计算型类型属性，实例方法，类型方法，构造器，下标脚本声明，甚至其他结构体，类，和枚举声明。扩展声明不能包含析构器，协议声明，存储型属性，属性监测器或其他的扩展属性。详细讨论和查看包含多种扩展声明的实例，参见[扩展(Extensions)](TODO)一节。
 
-扩展声明可以向现存的类，结构体，枚举内添加一致的协议。扩展声明不能向一个类中添加继承的类，因此
-type-inheritance-clause是一个只包含协议列表的扩展声明。
+扩展声明可以向现存的类，结构体，枚举内添加*一致的协议(adopted protocols)*。扩展声明不能向一个类中添加继承的类，因此在*类型名称*的冒号后面仅能指定一个协议列表。
 
 属性，方法，现存类型的构造器不能被它们类型的扩展所重写。
 
-扩展声明可以包含构造器声明，这意味着，如果你扩展的类型在其他模块中定义，构造器声明必须委托另一个在
+扩展声明可以包含构造器声明，这意味着，如果扩展的类型在其他模块中定义，构造器声明必须委托另一个在
 那个模块里声明的构造器来恰当的初始化。
-
+
+<a name="grammer_of_an_extension_declaration"></a>
 > 扩展(Extension)声明语法  
-> *扩展声明* → **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)  
+> *扩展声明* → [访问级别修饰符](TODO) _可选_ **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)  
 > *extension-body* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
 
 <a name="subscript_declaration"></a>
-##下标脚本声明(translated by 林)
-
-附属脚本用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字`subscript`，声明形式如下：
+##下标脚本声明
+
+*下标脚本(subscript)*声明用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字`subscript`，声明形式如下：
 
 > subscript (`parameter`) -> (return type){  
 >     get{    
@@ -824,74 +889,78 @@ type-inheritance-clause是一个只包含协议列表的扩展声明。
 
 附属脚本声明只能在类，结构体，枚举，扩展和协议声明的上下文进行声明。
 
-_变量(parameters)_指定一个或多个用于在相关类型的下标脚本中访问元素的索引（例如，表达式`object[i]`中的`i`）。尽管用于元素访问的索引可以是任意类型的，但是每个变量必须包含一个用于指定每种索引类型的类型标注。_返回类型(return type)_指定被访问的元素的类型。
+*参数列表(parameters)*指定一个或多个用于在相关类型的下标脚本中访问元素的索引（例如，表达式`object[i]`中的`i`）。尽管用于元素访问的索引可以是任意类型的，但是每个变量必须包含一个用于指定每种索引类型的类型标注。*返回类型(return type)*指定被访问的元素的类型。
 
 和计算性属性一样，下标脚本声明支持对访问元素的读写操作。getter用于读取值，setter用于写入值。setter子句是可选的，当仅需要一个getter子句时，可以将二者都忽略且直接返回请求的值即可。也就是说，如果使用了setter子句，就必须使用getter子句。
 
-setter的名字和封闭的括号是可选的。如果使用了setter名称，它会被当做传给setter的变量的名称。如果不使用setter名称，那么传给setter的变量的名称默认是`value`。setter名称的类型必须与_返回类型(return type)_的类型相同。
+*setter名称(setter name)*和封闭的括号是可选的。如果使用了setter名称，它会被当做传给setter的变量的名称。如果不使用setter名称，那么传给setter的变量的名称默认是`value`。*setter名称(setter name)*的类型必须与*返回类型(return type)*的类型相同。
 
-可以在下标脚本声明的类型中，可以重载下标脚本，只要_变量(parameters)_或_返回类型(return type)_与先前的不同即可。此时，必须使用`override`关键字声明那个被覆盖的下标脚本。(注：好乱啊！到底是重载还是覆盖？！)
+可以在下标脚本声明的类型中，可以重载下标脚本，只要*参数列表(parameters)*或*返回类型(return type)*与先前的不同即可。也可以重写继承自超类的下标脚本声明。此时，必须使用`override`声明修饰符声明那个被重写的下标脚本。(待定)
 
-同样可以在协议声明的上下文中声明下标脚本，[Protocol Subscript Declaration](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_619)中有所描述。
-
-更多关于下标脚本和下标脚本声明的例子，请参考[Subscripts](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Subscripts.html#//apple_ref/doc/uid/TP40014097-CH16-XID_393)。
+同样可以在协议声明的上下文中声明下标脚本，[协议下标脚本声明(Protocol Subscript Declaration)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_619)中有所描述。
 
+更多关于下标脚本和下标脚本声明的例子，请参考[下标脚本(Subscripts)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Subscripts.html#//apple_ref/doc/uid/TP40014097-CH16-XID_393)。
+
+<a name="grammer_of_a_subscript_declaration"></a>
 > 附属脚本声明语法  
 > *附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
 > *附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
 > *附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-> *附属脚本头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **subscript** [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)  
+> *附属脚本头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)  
 > *附属脚本结果(Result)* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)   
 
 <a name="operator_declaration"></a>
 ##运算符声明(translated by 林)
 
-运算符声明会向程序中引入中缀、前缀或后缀运算符，它使用上下文关键字`operator`声明。
-可以声明三种不同的缀性：中缀、前缀和后缀。操作符的缀性描述了操作符与它的操作数的相对位置。
-运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在`operator`和运算符之间添加上下文关键字`infix`，`prefix`或`postfix`来指定。每种形式中，运算符的名字只能包含[Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_871)中定义的运算符字符。
+*运算符声明(operator declaration)*会向程序中引入中缀、前缀或后缀运算符，它使用关键字`operator`声明。
+
+可以声明三种不同的缀性：中缀、前缀和后缀。操作符的*缀性(fixity)*描述了操作符与它的操作数的相对位置。
+
+运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在`operator`关键字之前添加声明修饰符`infix`，`prefix`或`postfix`来指定。每种形式中，运算符的名字只能包含[运算符(Operators)](TODO)中定义的运算符字符。
 
 下面的这种形式声明了一个新的中缀运算符：
-> operator infix `operator name`{  
->     previewprecedence `precedence level`  
+> 	infix operator `operator name` {  
+>     precedence `precedence level`  
 >     associativity `associativity`  
 > }  
 
-_中缀_运算符是二元运算符，它可以被置于两个操作数之间，比如表达式`1 + 2` 中的加法运算符(`+`)。
+*中缀运算符(infix operator)*是二元运算符，它可以被置于两个操作数之间，比如表达式`1 + 2` 中的加法运算符(`+`)。
 
 中缀运算符可以可选地指定优先级，结合性，或两者同时指定。
 
-运算符的_优先级_可以指定在没有括号包围的情况下，运算符与它的操作数如何紧密绑定的。可以使用上下文关键字`precedence`并_优先级(precedence level)_一起来指定一个运算符的优先级。_优先级_可以是0到255之间的任何一个数字(十进制整数)；与十进制整数字面量不同的是，它不可以包含任何下划线字符。尽管优先级是一个特定的数字，但它仅用作与另一个运算符比较(大小)。也就是说，一个操作数可以同时被两个运算符使用时，例如`2 + 3 * 5`，优先级更高的运算符将优先与操作数绑定。
+运算符的*优先级(precedence)*可以指定在没有括号包围的情况下，运算符与它的操作数如何紧密绑定的。可以使用上下文关键字`precedence`并*优先级(precedence level)*一起来指定一个运算符的优先级。*优先级(precedence level)*可以是0到255之间的任何一个数字(十进制整数)；与十进制整数字面量不同的是，它不可以包含任何下划线字符。尽管优先级是一个特定的数字，但它仅用作与另一个运算符比较(大小)。也就是说，一个操作数可以同时被两个运算符使用时，例如`2 + 3 * 5`，优先级更高的运算符将优先与操作数绑定。
 
-运算符的_结合性_可以指定在没有括号包围的情况下，优先级相同的运算符以何种顺序被分组的。可以使用上下文关键字`associativity`并_结合性(associativity)_一起来指定一个运算符的结合性，其中_结合性_可以说是上下文关键字`left`，`right`或`none`中的任何一个。左结合运算符以从左到右的形式分组。例如，减法运算符(`-`)具有左结合性，因此`4 - 5 - 6`被以`(4 - 5) - 6`的形式分组，其结果为`-7`。
+运算符的*结合性(associativit)*可以指定在没有括号包围的情况下，优先级相同的运算符以何种顺序被分组的。可以使用上下文关键字`associativity`并_结合性(associativity)_一起来指定一个运算符的结合性，其中_结合性_可以说是上下文关键字`left`，`right`或`none`中的任何一个。左结合运算符以从左到右的形式分组。例如，减法运算符(`-`)具有左结合性，因此`4 - 5 - 6`被以`(4 - 5) - 6`的形式分组，其结果为`-7`。
 右结合运算符以从右到左的形式分组，对于设置为`none`的非结合运算符，它们不以任何形式分组。具有相同优先级的非结合运算符，不可以互相邻接。例如，表达式`1 < 2 < 3`非法的。
 
 声明时不指定任何优先级或结合性的中缀运算符，它们的优先级会被初始化为100，结合性被初始化为`none`。
 
 下面的这种形式声明了一个新的前缀运算符：
-> operator prefix `operator name`{}  
+> prefix operator `operator name`{}  
 
-紧跟在操作数前边的_前缀运算符(prefix operator)_是一元运算符，例如表达式`++i`中的前缀递增运算符(`++`)。
+紧跟在操作数前边的*前缀运算符(prefix operator)*是一元运算符，例如表达式`++i`中的前缀递增运算符(`++`)。
 
 前缀运算符的声明中不指定优先级。前缀运算符是非结合的。
 
 下面的这种形式声明了一个新的后缀运算符：
 
-> operator postfix `operator name`{}  
+> postfix operator `operator name`{}  
 
-紧跟在操作数后边的_后缀运算符(postfix operator)_是一元运算符，例如表达式`i++`中的前缀递增运算符(`++`)。
+紧跟在操作数后边的*后缀运算符(postfix operator)*是一元运算符，例如表达式`i++`中的前缀递增运算符(`++`)。
 
 和前缀运算符一样，后缀运算符的声明中不指定优先级。后缀运算符是非结合的。
 
-声明了一个新的运算符以后，需要声明一个跟这个运算符同名的函数来实现这个运算符。如何实现一个新的运算符，请参考[Custom Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48)。
-
+声明了一个新的运算符以后，需要声明一个跟这个运算符同名的函数来实现这个运算符。如果在实现一个前缀或者后缀操作符，也必须使用相符的`prefix`或者`postfix`声明修饰符标记函数声明。如果实现中缀操作符，不需要使用`infix`声明修饰符标记函数声明。如何实现一个新的运算符，请参考[Custom Operators](TODO)。
+
+<a name="grammer_of_an_operator_declaration"></a>
 > 运算符声明语法  
 > *运算符声明* → [*前置运算符声明*](..\chapter3\05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](..\chapter3\05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](..\chapter3\05_Declarations.html#infix_operator_declaration)  
-> *前置运算符声明* → **运算符** **prefix** [*运算符*](LexicalStructure.html#operator) **{** **}**  
-> *后置运算符声明* → **运算符** **postfix** [*运算符*](LexicalStructure.html#operator) **{** **}**  
-> *中置运算符声明* → **运算符** **infix** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}**  
+> *前置运算符声明* → **prefix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}**  
+> *后置运算符声明* → **postfix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}**  
+> *中置运算符声明* → **infix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}**  
 > *中置运算符属性* → [*优先级子句*](..\chapter3\05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](..\chapter3\05_Declarations.html#associativity_clause) _可选_  
 > *优先级子句* → **precedence** [*优先级水平*](..\chapter3\05_Declarations.html#precedence_level)  
-> *优先级水平* → 数值 0 到 255  
+> *优先级水平* → 十进制整数 0 到 255  
 > *结和性子句* → **associativity** [*结和性*](..\chapter3\05_Declarations.html#associativity)  
 > *结和性* → **left** | **right** | **none**  
 
@@ -899,11 +968,10 @@ _中缀_运算符是二元运算符，它可以被置于两个操作数之间，
 <a name="declaration_modifiers"></a>
 ## 声明修饰符
 
-
-声明修饰符是关键字或者说是上下文相关的关键字，它可以修改一个声明的行为或者含义。你可以在一个声明的特性和引进该声明的关键字之间，指定一个声明修饰符，并写下它的关键字或上下文相关的关键字。
+*声明修饰符(Declaration modifiers)*是关键字或者说是上下文相关的关键字，它可以修改一个声明的行为或者含义。可以在一个声明的特性和引进该声明的关键字之间，指定一个声明修饰符，并写下它的关键字或上下文相关的关键字。
 
 `dynamic`
-可以将该修饰符用于任何可以出现在Objective-C中的类成员上。当你将`dynamic`修饰符用于一个成员声明上时，对该成员的访问总是由Objective-C的实时系统动态地安排，而永远不会由编译器内联或去虚拟化。
+可以将该修饰符用于任何可以出现在Objective-C中的类成员上。当将`dynamic`修饰符用于一个成员声明上时，对该成员的访问总是由Objective-C的实时系统动态地安排，而永远不会由编译器内联或去虚拟化。
 因为当一个声明被标识`dynamic`修饰符时，会由Objective-C的实时系统动态地安排，所以他们是被隐式的标识了`objc`特性的。
 
 `final`
@@ -912,12 +980,12 @@ _中缀_运算符是二元运算符，它可以被置于两个操作数之间，
 
 `lazy`
 
-该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在第一次访问它时。如何使用`lazy`特性的一个例子，请见：[惰性存储型属性]()。
+该修饰符用于修饰类或结构体中的存储型变量属性，表示该属性的初始值最多只被计算和存储一次，且发生在第一次访问它时。如何使用`lazy`特性的一个例子，请见：[惰性存储型属性(Lazy Stored Properties)](TODO)。
 
 `optional`
 
 该修饰符用于修饰一个类或类中的属性，方法，以及下标成员,表示遵循类型没有被要求实现这些成员。
-你只能将`optional`修饰符用于被`objc`标识的协议。这样一来，只有类类型可以适配或遵循拥有可选成员需求的协议。关于如何使用`optional`修饰符,以及如何访问可选协议成员的指导(比如，你不确定遵循类型是否已经实现了这些可选成员)，你可以参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_415">可选成员需求</a>一章
+只能将`optional`修饰符用于被`objc`标识的协议。这样一来，只有类类型可以适配或遵循拥有可选成员需求的协议。关于如何使用`optional`修饰符,以及如何访问可选协议成员的指导(比如，不确定遵循类型是否已经实现了这些可选成员)，可以参见[可选成员需求(Optional Protocol Requirements)](TODO)一章
 
 `required`
 
@@ -926,12 +994,12 @@ _中缀_运算符是二元运算符，它可以被置于两个操作数之间，
 
 `weak`
 
-`weak`修饰符用于修饰一个变量或一个存储型变量属性，表示该变量或属性通过一个弱引用指向存储其值的对象。该变量或属性的类型必须是一个可选类类型。通过`weak`修饰符可避免强引用循环。关于`weak`修饰符的例子和更多信息，你可以参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-XID_94">弱引用</a>一章
+`weak`修饰符用于修饰一个变量或一个存储型变量属性，表示该变量或属性通过一个弱引用指向存储其值的对象。该变量或属性的类型必须是一个可选类类型。通过`weak`修饰符可避免强引用循环。关于`weak`修饰符的例子和更多信息，可以参见[弱引用(Weak References)](TODO)一章
+
+<a name="access_control_levels"></a>
+### 访问控制级别
 
-### 权限控制的级别
-
-
-Swift提供了三个级别的权限控制：`public`, `internal`, 和 `private`。你可以给声明标识以下访问级别修饰符中的一个以指定声明的权限级别。权限控制在<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AccessControl.html#//apple_ref/doc/uid/TP40014097-CH41-XID_29">权限控制</a>一章有详细说明。
+Swift提供了三个级别的权限控制：`public`, `internal`, 和 `private`。可以给声明标识以下访问级别修饰符中的一个以指定声明的权限级别。访问控制在[访问控制(Access Control)](TODO)一章有详细说明。
 
 `public`
 
@@ -947,17 +1015,20 @@ Swift提供了三个级别的权限控制：`public`, `internal`, 和 `private`
 修饰符用于修饰声明时，表示该声明只能被同一源文件中的代码访问。
 
 
-以上的任意一个权限级别修饰符都可以有选择的带上一个参数，该参数由关键字`set`和一对括号组成（比如，`private(set)`）。当你想要指明一个变量或下标脚注的setter的访问级别要低于或等于该变量或下标脚注的实际访问级别时，使用这种格式的权限级别修饰符，就像<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AccessControl.html#//apple_ref/doc/uid/TP40014097-CH41-XID_49">Getters and Setters</a>一章中讨论的一样。
-
+以上的任意一个权限级别修饰符都可以有选择的带上一个参数，该参数由关键字`set`和一对括号组成（比如，`private(set)`）。当想要指明一个变量或下标脚注的setter的访问级别要低于或等于该变量或下标脚注的实际访问级别时，使用这种格式的权限级别修饰符，就像[Getters and Setters](TODO)一章中讨论的一样。
+
+<a name="grammer_of_a_declaration_modifier"></a>
 >声明修饰符的语法
 
->声明修饰符 → class­ | convenience­ | dynamic­ | final­ | infix­ | lazy­ | mutating­ | nonmutating­ | optional­ | override­ | postfix |­ prefix­ | required­ | static­ | unowned­ | unowned­(­safe­)­ | unowned­(­unsafe­)­ | weak­
+>声明修饰符 → **class**­ | **convenience­**| **dynamic**­ | **final**­ | **infix**­ | **lazy­** | **mutating**­ | **nonmutating**­ | **optional**­ | **override**­ | **postfix**|­ **prefix­** | **required­** | **static**­ | **unowned­** | **unowned­(­safe­)**­ | **unowned­(­unsafe­)­** | **weak**­
 
 >声明修饰符 → 权限级别修饰符­
 >
->权限级别修饰符 → internal­  internal­(­set­)­
+>访问级别修饰符 → **internal**­ | **internal­(­set­)­**
 >
->权限级别修饰符 → private­  private­(­set­)­
+>访问级别修饰符 → **private­** | **private­(­set­)­**
 >
->权限级别修饰符 → public­  public­(­set­)­
+>访问级别修饰符 → **public­** | **public­(­set­)­**
+>
+>访问级别修饰符 → [访问级别修饰符(access-level-modeifier)](TODO) [访问级别修饰符列表(access-level-modeifiers)](TODO) _可选_
 ­
\ No newline at end of file

From 38b3871353b24027369ac7e2553d69632bbd1e3d Mon Sep 17 00:00:00 2001
From: AlanMelody <alanmelody@qq.com>
Date: Sun, 12 Jul 2015 23:16:58 +0800
Subject: [PATCH 113/228] =?UTF-8?q?=E5=9F=BA=E6=9C=AC=E6=93=8D=E4=BD=9C?=
 =?UTF-8?q?=E7=AC=A6=E9=83=A8=E5=88=86=E7=BF=BB=E8=AF=91=E6=A0=A1=E5=AF=B9?=
 =?UTF-8?q?=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/02_Basic_Operators.md | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 5ea98ba4..71ee8d1e 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -1,7 +1,6 @@
 
-> 翻译：[XieLingWang](https://github.com/xielingwang)    
-> 校对：[EvilCome](https://github.com/Evilcome)  
-> 最终校对：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)
+> 翻译：[XieLingWang](https://github.com/xielingwang), [JackAlan](https://github.com/AlanMelody)    
+> 校对：[EvilCome](https://github.com/Evilcome), [JackAlan](https://github.com/AlanMelody)    
 
 # 基本运算符
 -----------------
@@ -18,7 +17,7 @@
 - [区间运算符](#range_operators)
 - [逻辑运算符](#logical_operators)
 
-运算符是检查、改变、合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。复杂些的运算例如逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），或让 i 值加1的便捷自增运算符`++i`等。
+运算符是检查、改变、合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。更复杂的运算例子包括逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），或让 i 值加1的便捷自增运算符`++i`等。
 
 Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如：赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。算术运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](24_Advanced_Operators.html#overflow_operators)。
 
@@ -31,7 +30,7 @@ Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减
 
 运算符有一元、二元和三元运算符。
 
-- 一元运算符对单一操作对象操作（如`-a`）。一元运算符分前置运算符和后置运算符，前置运算符需紧排操作对象之前（如`!b`），后置运算符需紧跟操作对象之后（如`i++`）。
+- 一元运算符对单一操作对象操作（如`-a`）。一元运算符分前置运算符和后置运算符，前置运算符需紧跟在操作对象之前（如`!b`），后置运算符需紧跟在操作对象之后（如`i++`）。
 - 二元运算符操作两个操作对象（如`2 + 3`），是中置的，因为它们出现在两个操作对象之间。
 - 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三目运算符（`a ? b : c`）。
 
@@ -47,7 +46,7 @@ Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减
 	a = b
 	// a 现在等于 10
 
-如果赋值的右边是一个多元组，它的元素可以马上被分解多个常量或变量：
+如果赋值的右边是一个多元组，它的元素可以马上被分解成多个常量或变量：
 
 	let (x, y) = (1, 2)
 	// 现在 x 等于 1, y 等于 2
@@ -190,7 +189,7 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 <a name="compound_assignment_operators"></a>
 ## 复合赋值（Compound Assignment Operators）
 
-如同强大的 C 语言，Swift 也提供把其他运算符和赋值运算（`=`）组合的复合赋值运算符，组合加运算（`+=`）是其中一个例子：
+如同 C 语言，Swift 也提供把其他运算符和赋值运算（`=`）组合的复合赋值运算符，组合加运算（`+=`）是其中一个例子：
 
 	var a = 1
 	a += 2 // a 现在是 3
@@ -307,8 +306,8 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 	//userDefinedColorName的值为空 ，所以colorNameToUse的值为`red`
 
 
-`userDefinedColorName`变量被定义为一个可选字符串类型，默认值为nil。由于`userDefinedColorName`是一个可选类型，我们可以使用空合运算符去判断其值。在上一个例子中，通过空合运算符为一个名为`colorNameToUse`的变量赋予一个字符串类型初始值。
-由于`userDefinedColorName`值为空，因此表达式` userDefinedColorName ?? defaultColorName `返回默认值，即`red`。
+`userDefinedColorName`变量被定义为一个可选`String`类型，默认值为`nil`。由于`userDefinedColorName`是一个可选类型，我们可以使用空合运算符去判断其值。在上一个例子中，通过空合运算符为一个名为`colorNameToUse`的变量赋予一个字符串类型初始值。
+由于`userDefinedColorName`值为空，因此表达式` userDefinedColorName ?? defaultColorName `返回`defaultColorName`的值，即`red`。
 
 另一种情况，分配一个非空值(`non-nil`)给 `userDefinedColorName`，再次执行空合运算，运算结果为封包在`userDefaultColorName`中的值，而非默认值。
 
@@ -322,7 +321,7 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 Swift 提供了两个方便表达一个区间的值的运算符。
 
 ### 闭区间运算符
-闭区间运算符（`a...b`）定义一个包含从`a`到`b`(包括`a`和`b`)的所有值的区间，`b`必须大于`a`。
+闭区间运算符（`a...b`）定义一个包含从`a`到`b`(包括`a`和`b`)的所有值的区间，`b`必须大于等于`a`。
 ‌
 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在`for-in`循环中：
 
@@ -372,7 +371,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 
 逻辑非运算（`!a`）对一个布尔值取反，使得`true`变`false`，`false`变`true`。
 
-它是一个前置运算符，需出现在操作数之前，且不加空格。读作`非 a`，例子如下：
+它是一个前置运算符，需紧跟在操作数之前，且不加空格。读作`非 a`，例子如下：
 
 	let allowedEntry = false
 	if !allowedEntry {
@@ -435,7 +434,11 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 
 如果我们输入了正确的密码并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。
 
-前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。
+前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。
+
+>注意：
+Swift 逻辑操作符`&&`和`||`是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算
+最左边的子表达式。
 
 ### 使用括号来明确优先级
 

From ea1dd5caeaab8f9aea35ddda9ec9b77abf351a6a Mon Sep 17 00:00:00 2001
From: AlanMelody <alanmelody@qq.com>
Date: Sun, 12 Jul 2015 23:36:27 +0800
Subject: [PATCH 114/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=80=E5=A4=84?=
 =?UTF-8?q?=E5=86=97=E4=BD=99=E7=9A=84=E7=A9=BA=E6=A0=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/02_Basic_Operators.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 71ee8d1e..82d3fb23 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -437,8 +437,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。
 
 >注意：
-Swift 逻辑操作符`&&`和`||`是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算
-最左边的子表达式。
+Swift 逻辑操作符`&&`和`||`是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。
 
 ### 使用括号来明确优先级
 

From 553e257bfe2f4cd03b8a5e38907440714a8a82f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=89=AC?= <zhangyang@baimes.com>
Date: Tue, 14 Jul 2015 23:28:15 +0800
Subject: [PATCH 115/228] update:function

add:functions with Multiple parameters
---
 source/chapter2/06_Functions.md | 42 +++++++++++++++++++++++++--------
 1 file changed, 32 insertions(+), 10 deletions(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 87d22485..22111e55 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -25,7 +25,7 @@ Swift 统一的函数语法足够灵活，可以用来表示任何函数，包
 
 每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，你用函数名“调用”，并传给它匹配的输入值（称作实参，arguments）。一个函数的实参必须与函数参数表里参数的顺序一致。
 
-在下面例子中的函数叫做`"greetingForPerson"`，之所以叫这个名字是因为这个函数用一个人的名字当做输入，并返回给这个人的问候语。为了完成这个任务，你定义一个输入参数-一个叫做 `personName` 的 `String` 值，和一个包含给这个人问候语的 `String` 类型的返回值：
+在下面例子中的函数叫做`"sayHello(_:)"`，之所以叫这个名字,是因为这个函数用一个人的名字当做输入，并返回给这个人的问候语。为了完成这个任务，你定义一个输入参数-一个叫做 `personName` 的 `String` 值，和一个包含给这个人问候语的 `String` 类型的返回值：
 
 ```swift
 func sayHello(personName: String) -> String {
@@ -45,11 +45,11 @@ println(sayHello("Brian"))
 // prints "Hello, Brian!"
 ```
 
-调用 `sayHello` 函数时，在圆括号中传给它一个 `String` 类型的实参。因为这个函数返回一个 `String` 类型的值，`sayHello` 可以被包含在 `println` 的调用中，用来输出这个函数的返回值，正如上面所示。
+调用 `sayHello(_:)` 函数时，在圆括号中传给它一个 `String` 类型的实参。因为这个函数返回一个 `String` 类型的值，`sayHello` 可以被包含在 `println` 的调用中，用来输出这个函数的返回值，正如上面所示。
 
-在 `sayHello` 的函数体中，先定义了一个新的名为 `greeting` 的 `String` 常量，同时赋值了给 `personName` 的一个简单问候消息。然后用 `return` 关键字把这个问候返回出去。一旦 `return greeting` 被调用，该函数结束它的执行并返回 `greeting` 的当前值。
+在 `sayHello(_:)` 的函数体中，先定义了一个新的名为 `greeting` 的 `String` 常量，同时赋值了给 `personName` 的一个简单问候消息。然后用 `return` 关键字把这个问候返回出去。一旦 `return greeting` 被调用，该函数结束它的执行并返回 `greeting` 的当前值。
 
-你可以用不同的输入值多次调用 `sayHello`。上面的例子展示的是用`"Anna"`和`"Brian"`调用的结果，该函数分别返回了不同的结果。
+你可以用不同的输入值多次调用 `sayHello(_:)`。上面的例子展示的是用`"Anna"`和`"Brian"`调用的结果，该函数分别返回了不同的结果。
 
 为了简化这个函数的定义，可以将问候消息的创建和返回写成一句：
 
@@ -94,9 +94,31 @@ println(sayHelloWorld())
 
 尽管这个函数没有参数，但是定义中在函数名后还是需要一对圆括号。当被调用时，也需要在函数名后写一对圆括号。
 
+### 多参量函数 (Functions With Multiple Parameters)
+
+函数可以有多种输入参数,这写参数被包含在函数的括号之中,以逗号分隔.
+
+这个函数取得一个人的名字和是否被招呼作为输入,并对那个人返回适当地问候语:
+
+```swift
+func sayHello(personName: String, alreadyGreeted: Bool) -> String {
+    if alreadyGreeted {
+        return sayHelloAgain(personName)
+    } else {
+        return sayHello(personName)
+    }
+}
+print(sayHello("Tim", alreadyGreeted: true))
+// prints "Hello again, Tim!"
+```
+
+你通过在括号内传递一个`String`参数值和一个标识为`alreadyGreeted`的`Bool`值,使用逗号分隔来调用`sayHello(_:alreadyGreeted:)`函数.
+
+当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记,函数参数命名在[Function Parameter Names](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID166)有更详细的描述.
+
 ### 无返回值函数（Functions Without Return Values）
 
-函数可以没有返回值。下面是 `sayHello` 函数的另一个版本，叫 `waveGoodbye`，这个函数直接输出 `String` 值，而不是返回它：
+函数可以没有返回值。下面是 `sayHello(_:)` 函数的另一个版本，叫 `sayGoodbye(_:)`，这个函数直接输出 `String` 值，而不是返回它：
 
 ```swift
 func sayGoodbye(personName: String) {
@@ -109,14 +131,14 @@ sayGoodbye("Dave")
 因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头（->）和返回类型。
 
 > 注意：
-> 严格上来说，虽然没有返回值被定义，`sayGoodbye` 函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫 `Void`。它其实是一个空的元组（tuple），没有任何元素，可以写成`()`。
+> 严格上来说，虽然没有返回值被定义，`sayGoodbye(_:)` 函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫 `Void`。它其实是一个空的元组（tuple），没有任何元素，可以写成`()`。
 
 被调用时，一个函数的返回值可以被忽略：
 
 ```swift
 func printAndCount(stringToPrint: String) -> Int {
-    println(stringToPrint)
-    return countElements(stringToPrint)
+    print(stringToPrint)
+    return stringToPrint.characters.count
 }
 func printWithoutCounting(stringToPrint: String) {
     printAndCount(stringToPrint)
@@ -128,10 +150,10 @@ printWithoutCounting("hello, world")
 
 ```
 
-第一个函数 `printAndCount`，输出一个字符串并返回 `Int` 类型的字符数。第二个函数 `printWithoutCounting`调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。
+第一个函数 `printAndCount(_:)`，输出一个字符串并返回 `Int` 类型的字符数。第二个函数 `printWithoutCounting`调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。
 
 > 注意：
-> 返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，这将导致编译错误（compile-time error）。
+> 返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，并且试图这样做,这将导致编译错误（compile-time error）。
 
 ### 多重返回值函数（Functions with Multiple Return Values）
 

From 8c75dc5a64a973af6240c5418fed151f661dc657 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=89=AC?= <zhangyang@baimes.com>
Date: Wed, 15 Jul 2015 00:26:47 +0800
Subject: [PATCH 116/228] update to Function_Parameter_Names

---
 source/chapter2/06_Functions.md | 66 ++++++++++++++++++++++++---------
 1 file changed, 48 insertions(+), 18 deletions(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 22111e55..d2eb86bd 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -114,7 +114,7 @@ print(sayHello("Tim", alreadyGreeted: true))
 
 你通过在括号内传递一个`String`参数值和一个标识为`alreadyGreeted`的`Bool`值,使用逗号分隔来调用`sayHello(_:alreadyGreeted:)`函数.
 
-当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记,函数参数命名在[Function Parameter Names](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID166)有更详细的描述.
+当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记,函数参数命名在[函数参数名称（Function Parameter Names）](#Function_Parameter_Names)有更详细的描述.
 
 ### 无返回值函数（Functions Without Return Values）
 
@@ -159,36 +159,66 @@ printWithoutCounting("hello, world")
 
 你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。
 
-下面的这个例子中，`count` 函数用来计算一个字符串中元音，辅音和其他字母的个数（基于美式英语的标准）。
+下面的这个例子中，定义了一个名为`minMax(_:)`的函数,作用是在一个`Int`数组中找出最小值与最大值.
 
 ```swift
-func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
-    var vowels = 0, consonants = 0, others = 0
-    for character in string {
-        switch String(character).lowercaseString {
-        case "a", "e", "i", "o", "u":
-            ++vowels
-        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
-          "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
-            ++consonants
-        default:
-            ++others
+func minMax(array: [Int]) -> (min: Int, max: Int) {
+    var currentMin = array[0]
+    var currentMax = array[0]
+    for value in array[1..<array.count] {
+        if value < currentMin {
+            currentMin = value
+        } else if value > currentMax {
+            currentMax = value
         }
     }
-    return (vowels, consonants, others)
+    return (currentMin, currentMax)
 }
 ```
 
-你可以用 `count` 函数来处理任何一个字符串，返回的值将是一个包含三个 `Int` 型值的元组（tuple）：
+`minMax(_:)`函数返回一个包含两个`Int`值的元组,这些值被标记为`min`和`max`,一遍查询函数的返回值时他们可以被访问.
+
+`minMax(_:)`的函数体中,在开始的时候设置两个工作变量`currentMin`和`currentMax`作为数组中的第一个`Int`值.然后函数会遍历数组中剩余的值并检查该值是否比`currentMin`和`currentMax`更小或更大.最后数组中的最小值与最大值返回两个`Int`值最为一个元组.
+
+因为元组的成员值被命名为函数的返回类型的一部分​​，可以通过点语法来访问与取回发现的最小值与最小值:
 
 ```swift
-let total = count("some arbitrary string!")
-println("\(total.vowels) vowels and \(total.consonants) consonants")
-// prints "6 vowels and 13 consonants"
+let bounds = minMax([8, -6, 2, 109, 3, 71])
+print("min is \(bounds.min) and max is \(bounds.max)")
+// prints "min is -6 and max is 109"
 ```
 
 需要注意的是，元组的成员不需要在函数中返回时命名，因为它们的名字已经在函数返回类型中有了定义。
 
+可选元组返回类型(Optional Tuple Return Types)
+
+如果函数返回的元组类型中有可能在整个元组中含有“没有值”，你可以使用*可选的(Optional)* 元组返回类型反映整个元组可以是`nil`的事实.你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组,例如`(Int,Int)?`或`(String,Int,Bool)?`
+
+> 注意:
+> 可选元组类型如`(Int,Int)?`与元组包含可选属性如`(Int?,Int?)`是不同的.可选的元组类型，整个数组是可选的，而不只是元组中的每个元素值.
+
+前面的`minMax(_:)`函数返回了一个包含两个`Int`值的元组.但是函数不会在数组中执行任何安全检查,如果`array`参数有一个空数组,如上定义的`minMax(_:)`在试图访问`array[0]`时会触发一个运行时错误.
+
+为了安全的处理这个"空数组"问题,写一个`minMax(_:)`函数使用可选元组返回类型,并且当数组为空时返回`nil`:
+
+```swift
+func minMax(array: [Int]) -> (min: Int, max: Int)? {
+    if array.isEmpty { return nil }
+    var currentMin = array[0]
+    var currentMax = array[0]
+    for value in array[1..<array.count] {
+        if value < currentMin {
+            currentMin = value
+        } else if value > currentMax {
+            currentMax = value
+        }
+    }
+    return (currentMin, currentMax)
+}
+```
+
+你可以选择性的绑定当`minMax(_:)`函数返回的是一个实际的元组值还是`nil`
+
 <a name="Function_Parameter_Names"></a>
 ## 函数参数名称（Function Parameter Names）
 

From 5105a2c404b94f4946e0bda0275b57155c7d7d74 Mon Sep 17 00:00:00 2001
From: Michael Xiang <xiangt@bc.edu>
Date: Tue, 14 Jul 2015 16:05:34 -0400
Subject: [PATCH 117/228] cp01 cp02
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

cp 01 02 修改
---
 source/chapter1/01_swift.md        |  5 +-
 source/chapter1/02_a_swift_tour.md | 84 +++++++++++++-----------------
 2 files changed, 38 insertions(+), 51 deletions(-)

diff --git a/source/chapter1/01_swift.md b/source/chapter1/01_swift.md
index d00378e4..7026bcae 100755
--- a/source/chapter1/01_swift.md
+++ b/source/chapter1/01_swift.md
@@ -6,11 +6,12 @@
 
 Swift 是一种新的编程语言，用于编写 iOS，OS X 和 watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架，它的降临将重新定义软件开发。
 
-Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa 的基础上构建框架栈并将其标准化。Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。正是得益于这些基础工作，我们现在才能发布这样一个用于未来苹果软件开发的新语言。
+Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa 的基础上构建框架栈使其完全现代化和标准化。
+Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。正是得益于这些基础工作，我们现在才能发布这样一个用于未来苹果软件开发的新语言。
 
 Objective-C 开发者对 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。
 
-Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。
+Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的脚本语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。
 
 Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 既可以用于开发 “hello, world” 这样的小程序，也可以用于开发一套完整的操作系统。所有的这些特性让 Swift 对于开发者和苹果来说都是一项值得的投资。
 
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index 43f8fa10..b0153af3 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -27,7 +27,7 @@ print("Hello, world")
 
 > 注意：
 > 为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。
-> <a href="https://github.com/numbbbbb/the-swift-programming-language-in-chinese/raw/gh-pages/source/chapter1/GuidedTour.playground.zip">打开Playground</a>
+> <a href="https://github.com/numbbbbb/the-swift-programming-language-in-chinese/raw/gh-pages/source/chapter1/GuidedTour.playground.zip">下载Playground</a>
 
 <a name="simple_values"></a>
 ## 简单值
@@ -40,7 +40,7 @@ myVariable = 50
 let myConstant = 42
 ```
 
-常量或者变量的类型必须和你赋给它们的值一样。然而，声明时类型是可选的，声明的同时赋值的话，编译器会自动推断类型。在上面的例子中，编译器推断出`myVariable`是一个整数（integer）因为它的初始值是整数。
+常量或者变量的类型必须和你赋给它们的值一样。然而，你不用明确地声明类型，声明的同时赋值的话，编译器会自动推断类型。在上面的例子中，编译器推断出`myVariable`是一个整数（integer）因为它的初始值是整数。
 
 如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。
 
@@ -107,7 +107,7 @@ occupations = [:]
 <a name="control_flow"></a>
 ## 控制流
 
-使用`if`和`switch`来进行条件操作，使用`for-in`、`for`、`while`和`do-while`来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的。
+使用`if`和`switch`来进行条件操作，使用`for-in`、`for`、`while`和`repeat-while`来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的。
 
 ```swift
 let individualScores = [75, 43, 103, 87, 12]
@@ -124,7 +124,7 @@ print(teamScore)
 
 在`if`语句中，条件必须是一个布尔表达式——这意味着像`if score { ... }`这样的代码将报错，而不会隐形地与 0 做对比。
 
-你可以一起使用`if`和`let`来处理值缺失的情况。有些变量的值是可选的。一个可选的值可能是一个具体的值或者是`nil`，表示值缺失。在类型后面加一个问号来标记这个变量的值是可选的。
+你可以一起使用`if`和`let`来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者是`nil`以表示值缺失。在类型后面加一个问号来标记这个变量的值是可选的。
 
 ```swift
 var optionalString: String? = "Hello"
@@ -161,7 +161,7 @@ default:
 > 练习：
 > 删除`default`语句，看看会有什么错误？
 
-声明'let'可用于匹配某部分固定值的模式
+声明`let`可用于匹配某部分固定值的模式
 
 运行`switch`中匹配到的子句之后，程序会退出`switch`语句，并不会继续向下运行，所以不需要在每个子句结尾写`break`。
 
@@ -185,9 +185,9 @@ print(largest)
 ```
 
 > 练习：
-> 添加另一个变量来记录哪种类型的数字是最大的。
+> 添加另一个变量来记录现在和之前最大数字的类型。
 
-使用`while`来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。
+使用`while`来重复运行一段代码直到不满足条件。循环条件也可以在结尾，保证能至少循环一次。
 
 ```swift
 var n = 2
@@ -197,7 +197,7 @@ while n < 100 {
 print(n)
 
 var m = 2
-do {
+repeat {
     m = m * 2
 } while m < 100
 print(m)
@@ -224,7 +224,7 @@ print(secondForLoop)
 <a name="functions_and_closures"></a>
 ## 函数和闭包
 
-使用`func`来声明一个函数，使用名字和参数来调用函数。使用`->`来指定函数返回值。
+使用`func`来声明一个函数，使用名字和参数来调用函数。使用`->`来指定函数返回值的类型。
 
 ```swift
 func greet(name: String, day: String) -> String {
@@ -319,10 +319,10 @@ func lessThanTen(number: Int) -> Bool {
     return number < 10
 }
 var numbers = [20, 19, 7, 12]
-hasAnyMatches(numbers, lessThanTen)
+hasAnyMatches(numbers, condition: lessThanTen)
 ```
 
-函数实际上是一种特殊的闭包，你可以使用`{}`来创建一个匿名闭包。使用`in`将参数和返回值类型声明与闭包函数体进行分离。
+函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用`{}`来创建一个匿名闭包。使用`in`将参数和返回值类型声明与闭包函数体进行分离。
 
 ```swift
 numbers.map({
@@ -335,14 +335,14 @@ numbers.map({
 > 练习：
 > 重写闭包，对所有奇数返回0。
 
-有很多种创建闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
+有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
 
 ```swift
 let mappedNumbers = numbers.map({ number in 3 * number })
-mappedNumbers
+print(mappedNumbers)
 ```
 
-你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。
+你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。
 
 ```swift
 let sortedNumbers = sorted(numbers) { $0 > $1 }
@@ -423,9 +423,9 @@ test.simpleDescription()
 ```
 
 > 练习：
-> 创建`NamedShape`的另一个子类`Circle`，构造器接收两个参数，一个是半径一个是名称，实现`area`和`describe`方法。
+> 创建`NamedShape`的另一个子类`Circle`，构造器接收两个参数，一个是半径一个是名称，在子类`Circle`中实现`area()`和`simpleDescription()`方法。
 
-属性可以有 getter 和 setter 。
+除了储存简单的属性之外，属性可以有 getter 和 setter 。
 
 ```swift
 class EquilateralTriangle: NamedShape {
@@ -473,12 +473,12 @@ class TriangleAndSquare {
     var triangle: EquilateralTriangle {
     willSet {
         square.sideLength = newValue.sideLength
-    }
+      }
     }
     var square: Square {
     willSet {
         triangle.sideLength = newValue.sideLength
-    }
+      }
     }
     init(size: Double, name: String) {
         square = Square(sideLength: size, name: name)
@@ -486,23 +486,10 @@ class TriangleAndSquare {
     }
 }
 var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
-triangleAndSquare.square.sideLength
-triangleAndSquare.triangle.sideLength
+print(triangleAndSquare.square.sideLength)
+print(triangleAndSquare.triangle.sideLength)
 triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
-triangleAndSquare.triangle.sideLength
-```
-
-类中的方法和一般的函数有一个重要的区别，函数的参数名只在函数内部使用，但是方法的参数名需要在调用的时候显式说明（除了第一个参数）。默认情况下，方法的参数名和它在方法内部的名字一样，不过你也可以定义第二个名字，这个名字被用在方法内部。
-
-```swift
-class Counter {
-    var count: Int = 0
-    func incrementBy(amount: Int, numberOfTimes times: Int) {
-        count += amount * times
-    }
-}
-var counter = Counter()
-counter.incrementBy(2, numberOfTimes: 7)
+print(triangleAndSquare.triangle.sideLength)
 ```
 
 处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加`?`。如果`?`之前的值是`nil`，`?`后面的东西都会被忽略，并且整个表达式返回`nil`。否则，`?`之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。
@@ -544,9 +531,9 @@ let aceRawValue = ace.rawValue
 > 练习：
 > 写一个函数，通过比较它们的原始值来比较两个`Rank`值。
 
-在上面的例子中，枚举原始值的类型是`Int`，所以你只需要设置第一个原始值。剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。
+在上面的例子中，枚举原始值的类型是`Int`，所以你只需要设置第一个原始值。剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。使用`rawValue`来访问一个枚举成员的原始值。
 
-使用'rawValue'在原始值和枚举值之间进行转换。
+使用`init?(rawValue:)`构造器来从原始值中枚举一个例子。
 
 ```swift
 if let convertedRank = Rank(rawValue: 3) {
@@ -554,7 +541,7 @@ if let convertedRank = Rank(rawValue: 3) {
 }
 ```
 
-枚举的成员值是实际值，并不是原始值的另一种表达方法。实际上，如果原始值没有意义，你不需要设置。
+枚举的成员值是实际值，并不是原始值的另一种表达方法。实际上，以防原始值没有意义，你不需要设置。
 
 ```swift
 enum Suit {
@@ -578,12 +565,11 @@ let heartsDescription = hearts.simpleDescription()
 ```
 
 > 练习：
-> 给`Suit`添加一个`color`方法，对`spades`和`clubs`返回“black”，对`hearts`和`diamonds`返回“red”。
+> 给`Suit`添加一个`color()`方法，对`spades`和`clubs`返回“black”，对`hearts`和`diamonds`返回“red”。
 
 注意，有两种方式可以引用`Hearts`成员：给`hearts`常量赋值时，枚举成员`Suit.Hearts`需要用全名来引用，因为常量没有显式指定类型。在`switch`里，枚举成员使用缩写`.Hearts`来引用，因为`self`的值已经知道是一个`suit`。已知变量类型的情况下你可以使用缩写。
 
-使用`struct`来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个区别就是
-结构体是传值，类是传引用。
+使用`struct`来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个区别就是结构体是传值，类是传引用。
 
 ```swift
 struct Card {
@@ -624,7 +610,7 @@ case let .Error(error):
 > 练习：
 > 给`ServerResponse`和`switch`添加第三种情况。
 
-注意如何从`ServerResponse`中提取日升和日落时间。
+注意如何从`ServerResponse`中提取日升和日落时间并用得到的值用来和`switch`的情况作比较。
 
 <a name="protocols_and_extensions"></a>
 ## 协议和扩展
@@ -679,7 +665,7 @@ extension Int: ExampleProtocol {
         self += 42
     }
 }
-7.simpleDescription
+print(7.simpleDescription)
 ```
 
 > 练习：
@@ -701,17 +687,17 @@ protocolValue.simpleDescription
 在尖括号里写一个名字来创建一个泛型函数或者类型。
 
 ```swift
-func repeat<ItemType>(item: ItemType, times: Int) -> [ItemType] {
-    var result = [ItemType]()
-    for i in 0..<times {
+func repeatItem<Item>(item: Item, numberOfTimes: Int) -> [Item] {
+    var result = [Item]()
+    for _ in 0..<numberOfTimes {
         result.append(item)
     }
     return result
 }
-repeat("knock", 4)
+repeatItem("knock", numberOfTimes:4)
 ```
 
-你也可以创建泛型类、枚举和结构体。
+你也可以创建泛型函数、方法、类、枚举和结构体。
 
 ```swift
 // Reimplement the Swift standard library's optional type
@@ -726,7 +712,7 @@ possibleInteger = .Some(100)
 在类型名后面使用`where`来指定对类型的需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者限定某个类必须有一个特定的父类
 
 ```swift
-func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> Bool {
+func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, _ rhs: U) -> Bool {
     for lhsItem in lhs {
         for rhsItem in rhs {
             if lhsItem == rhsItem {
@@ -740,6 +726,6 @@ anyCommonElements([1, 2, 3], [3])
 ```
 
 > 练习：
-> 修改`anyCommonElements`函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。
+> 修改`anyCommonElements(_:_:)`函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。
 
 简单起见，你可以忽略`where`，只在冒号后面写协议或者类名。` <T: Equatable>`和`<T where T: Equatable>`是等价的。

From e2ccc79fb9639850f7b71ee8204b7f50435efec7 Mon Sep 17 00:00:00 2001
From: Wang Ming <wangmchn@163.com>
Date: Wed, 15 Jul 2015 18:43:49 +0800
Subject: [PATCH 118/228] Update 04_Collection_Types.md

---
 source/chapter2/04_Collection_Types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index 19c05246..7fdf8c8d 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -7,7 +7,7 @@
 本页包含内容：
 
 - [数组（Arrays）](#arrays)
-- [集合(Sets)](#sets)
+- [集合 (Sets)](#sets)
 - [字典（Dictionaries）](#dictionaries)
 - [集合的可变性（Mutability of Collections）](#mutability_of_collections)
 

From e1c395df84f1b732f58d65360fec2e509f8d934e Mon Sep 17 00:00:00 2001
From: Wang Ming <wangmchn@163.com>
Date: Wed, 15 Jul 2015 18:44:23 +0800
Subject: [PATCH 119/228] =?UTF-8?q?=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/04_Collection_Types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index 7fdf8c8d..718cfb1c 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -7,7 +7,7 @@
 本页包含内容：
 
 - [数组（Arrays）](#arrays)
-- [集合 (Sets)](#sets)
+- [集合（Sets）](#sets)
 - [字典（Dictionaries）](#dictionaries)
 - [集合的可变性（Mutability of Collections）](#mutability_of_collections)
 

From ab81dcf1d6b0f1497a596f2cf9890027f3b5d146 Mon Sep 17 00:00:00 2001
From: paper <jue_paper@126.com>
Date: Thu, 16 Jul 2015 16:46:08 +0800
Subject: [PATCH 120/228] =?UTF-8?q?=E6=95=B0=E7=BB=84=E7=B1=BB=E5=9E=8B=20?=
 =?UTF-8?q?=E7=A4=BA=E4=BE=8B=E4=BB=A3=E7=A0=81=E4=B8=80=E7=82=B9=E5=B0=8F?=
 =?UTF-8?q?=E9=97=AE=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter3/03_Types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md
index 327f5e7b..02224959 100644
--- a/source/chapter3/03_Types.md
+++ b/source/chapter3/03_Types.md
@@ -125,7 +125,7 @@ Swift语言中使用[`type`]来简化标准库中定义`Array<T>`类型的操作
 换句话说，下面两个声明是等价的：
 
 ```swift
-let someArray: String[] = ["Alex", "Brian", "Dave"]
+let someArray: [String] = ["Alex", "Brian", "Dave"]
 let someArray: Array<String> = ["Alex", "Brian", "Dave"]
 ```
 上面两种情况下，常量`someArray`都被声明为字符串数组。数组的元素也可以通过`[]`获取访问：`someArray[0]`是指第0个元素`“Alex”`。

From b722eb877d0dcdd9ff40dbe9a5b0f202697b2267 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E6=89=AC?= <zhangyang@baimes.com>
Date: Sun, 19 Jul 2015 18:43:13 +0800
Subject: [PATCH 121/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/06_Functions.md | 235 +++++++++++++-------------------
 1 file changed, 92 insertions(+), 143 deletions(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index d2eb86bd..eaf1f1e1 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -219,25 +219,32 @@ func minMax(array: [Int]) -> (min: Int, max: Int)? {
 
 你可以选择性的绑定当`minMax(_:)`函数返回的是一个实际的元组值还是`nil`
 
+```swift
+if let bounds = minMax([8, -6, 2, 109, 3, 71]) {
+    print("min is \(bounds.min) and max is \(bounds.max)")
+}
+// prints "min is -6 and max is 109"
+```
+
 <a name="Function_Parameter_Names"></a>
 ## 函数参数名称（Function Parameter Names）
 
-以上所有的函数都给它们的参数定义了`参数名（parameter name）`：
+函数参数都有一个*外部参数名(external parameter name)*和一个*本地参数名(local parameter name)*.外部参数名用来标记传递给函数调用的参数,本地参数名在实现函数的时候使用.
 
 ```swift
-func someFunction(parameterName: Int) {
-    // function body goes here, and can use parameterName
-    // to refer to the argument value for that parameter
+func someFunction(firstParameterName: Int, secondParameterName: Int) {
+    // function body goes here
+    // firstParameterName and secondParameterName refer to
+    // the argument values for the first and second parameters
 }
+someFunction(1, secondParameterName: 2)
 ```
 
-但是，这些参数名仅在函数体中使用，不能在函数调用时使用。这种类型的参数名被称作`局部参数名（local parameter name）`，因为它们只能在函数体中使用。
+一般情况下,第一个参数省略其外部参数名,第二个以后的参数使用其本地参数名作为自己的外部参数名.所有参数需要有不同的本地参数名,但可以共享相同的外部参数名.
 
-### 外部参数名（External Parameter Names）
+### 指定外部参数名(Specifying External Parameter Names)
 
-有时候，调用函数时，给每个参数命名是非常有用的，因为这些参数名可以指出各个实参的用途是什么。
-
-如果你希望函数的使用者在调用函数时提供参数名字，那就需要给每个参数除了局部参数名外再定义一个`外部参数名`。外部参数名写在局部参数名之前，用空格分隔。
+你可以在本地参数名前指定外部参数名,中间以逗号分隔.
 
 ```swift
 func someFunction(externalParameterName localParameterName: Int) {
@@ -246,130 +253,64 @@ func someFunction(externalParameterName localParameterName: Int) {
 }
 ```
 
-> 注意：
+> 注意:
 > 如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。
 
-以下是个例子，这个函数使用一个`结合者（joiner）`把两个字符串联在一起：
+这个版本的`sayHello(_:)`函数,得到了两个人的名字,会同时返回对他俩的问候:
 
 ```swift
-func join(s1: String, s2: String, joiner: String) -> String {
-    return s1 + joiner + s2
+func sayHello(to person: String, and anotherPerson: String) -> String {
+    return "Hello \(person) and \(anotherPerson)!"
 }
+print(sayHello(to: "Bill", and: "Ted"))
+// prints "Hello Bill and Ted!"
 ```
 
-当你调用这个函数时，这三个字符串的用途是不清楚的：
+为每个参数指定外部参数名,在你调用函数`sayHello(to:and:)`函数时时两个参数都必须被标记出来.
+
+使用外部函数名可以使得函数可以用一句话表达清楚,并且使得函数体内部可读,能表达出函数的明确意图.
+
+### 忽略外部参数名(Omitting External Parameter Names)
+
+如果你不想为第二个及后续的参数设置参数名,用一个下划线(_)代替一个明确地参数名.
 
 ```swift
-join("hello", "world", ", ")
-// returns "hello, world"
-```
-
-为了让这些字符串的用途更为明显，我们为 `join` 函数添加外部参数名：
-
-```swift
-func join(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
-    return s1 + joiner + s2
+func someFunction(firstParameterName: Int, _ secondParameterName: Int) {
+    // function body goes here
+    // firstParameterName and secondParameterName refer to
+    // the argument values for the first and second parameters
 }
+someFunction(1, 2)
 ```
 
-在这个版本的 `join` 函数中，第一个参数有一个叫 `string` 的外部参数名和 `s1` 的局部参数名，第二个参数有一个叫 `toString` 的外部参数名和 `s2` 的局部参数名，第三个参数有一个叫 `withJoiner` 的外部参数名和 `joiner` 的局部参数名。
+> 注意:
+> 因为第一个参数默认忽略其外部参数名称，明确写下划线是多余的。
 
-现在，你可以使用这些外部参数名以一种清晰地方式来调用函数了：
-
-```swift
-join(string: "hello", toString: "world", withJoiner: ", ")
-// returns "hello, world"
-```
-
-使用外部参数名让第二个版本的 `join` 函数的调用更为有表现力，更为通顺，同时还保持了函数体是可读的和有明确意图的。
-
-> 注意：
-> 当其他人在第一次读你的代码，函数参数的意图显得不明显时，考虑使用外部参数名。如果函数参数名的意图是很明显的，那就不需要定义外部参数名了。
-
-### 简写外部参数名（Shorthand External Parameter Names）
-
-如果你需要提供外部参数名，但是局部参数名已经定义好了，那么你不需要写两次参数名。相反，只写一次参数名，并用`井号（#）`作为前缀就可以了。这告诉 Swift 使用这个参数名作为局部和外部参数名。
-
-下面这个例子定义了一个叫 `containsCharacter` 的函数，使用`井号（#）`的方式定义了外部参数名：
-
-```swift
-func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
-    for character in string {
-        if character == characterToFind {
-            return true
-        }
-    }
-    return false
-}
-```
-
-这样定义参数名，使得函数体更为可读，清晰，同时也可以以一个不含糊的方式被调用：
-
-```swift
-let containsAVee = containsCharacter(string: "aardvark", characterToFind: "v")
-// containsAVee equals true, because "aardvark" contains a "v”
-```
 
 ### 默认参数值（Default Parameter Values）
 
-你可以在函数体中为每个参数定义`默认值`。当默认值被定义后，调用这个函数时可以忽略这个参数。
+你可以在函数体中为每个参数定义`默认值(Deafult Values)`。当默认值被定义后，调用这个函数时可以忽略这个参数。
+
+```swift
+func someFunction(parameterWithDefault: Int = 12) {
+    // function body goes here
+    // if no arguments are passed to the function call,
+    // value of parameterWithDefault is 42
+}
+someFunction(6) // parameterWithDefault is 6
+someFunction() // parameterWithDefault is 12
+```
 
 > 注意：
 > 将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。
 
-以下是另一个版本的`join`函数，其中`joiner`有了默认参数值：
-
-```swift
-func join(string s1: String, toString s2: String, withJoiner joiner: String = " ") -> String {
-    return s1 + joiner + s2
-}
-```
-
-像第一个版本的 `join` 函数一样，如果 `joiner` 被赋值时，函数将使用这个字符串值来连接两个字符串：
-
-```swift
-join(string: "hello", toString: "world", withJoiner: "-")
-// returns "hello-world"
-```
-
-当这个函数被调用时，如果 `joiner` 的值没有被指定，函数会使用默认值（" "）：
-
-```swift
-join(string: "hello", toString:"world")
-// returns "hello world"
-```
-
-### 默认值参数的外部参数名（External Names for Parameters with Default Values）
-
-在大多数情况下，给带默认值的参数起一个外部参数名是很有用的。这样可以保证当函数被调用且带默认值的参数被提供值时，实参的意图是明显的。
-
-为了使定义外部参数名更加简单，当你未给带默认值的参数提供外部参数名时，Swift 会自动提供外部名字。此时外部参数名与局部名字是一样的，就像你已经在局部参数名前写了`井号（#）`一样。
-
-下面是 `join` 函数的另一个版本，这个版本中并没有为它的参数提供外部参数名，但是 `joiner` 参数依然有外部参数名：
-
-```swift
-func join(s1: String, s2: String, joiner: String = " ") -> String {
-    return s1 + joiner + s2
-}
-```
-
-在这个例子中，Swift 自动为 `joiner` 提供了外部参数名。因此，当函数调用时，外部参数名必须使用，这样使得参数的用途变得清晰。
-
-```swift
-join("hello", "world", joiner: "-")
-// returns "hello-world"
-```
-
-> 注意：
-> 你可以使用`下划线（_）`作为默认值参数的外部参数名，这样可以在调用时不用提供外部参数名。但是给带默认值的参数命名总是更加合适的。
-
 ### 可变参数（Variadic Parameters）
 
 一个`可变参数（variadic parameter）`可以接受一个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入`（...）`的方式来定义可变参数。
 
 传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做 `numbers` 的 `Double...` 型可变参数，在函数体内可以当做一个叫 `numbers` 的 `Double[]` 型的数组常量。
 
-下面的这个函数用来计算一组任意长度数字的算术平均数：
+下面的这个函数用来计算一组任意长度数字的`算术平均数(arithmetic mean)`：
 
 ```swift
 func arithmeticMean(numbers: Double...) -> Double {
@@ -381,12 +322,13 @@ func arithmeticMean(numbers: Double...) -> Double {
 }
 arithmeticMean(1, 2, 3, 4, 5)
 // returns 3.0, which is the arithmetic mean of these five numbers
-arithmeticMean(3, 8, 19)
+arithmeticMean(3, 8.25, 18.75)
 // returns 10.0, which is the arithmetic mean of these three numbers
 ```
 
 > 注意：
-> 一个函数至多能有一个可变参数，而且它必须是参数表中最后的一个。这样做是为了避免函数调用时出现歧义。
+> 最多可以有一个可变参数函数,和它必须出现在参数列表中,为了避免歧义在调用函数有多个参数。
+> 如果你的函数有一个或多个参数有默认值,还有一个可变的参数,将可变参写在参数列表的最后。
 
 如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后。
 
@@ -399,8 +341,8 @@ arithmeticMean(3, 8, 19)
 通过在参数名前加关键字 `var` 来定义变量参数：
 
 ```swift
-func alignRight(var string: String, count: Int, pad: Character) -> String {
-    let amountToPad = count - countElements(string)
+func alignRight(var string: String, totalLength: Int, pad: Character) -> String {
+    let amountToPad = totalLength - string.characters.count
     if amountToPad < 1 {
         return string
     }
@@ -411,16 +353,22 @@ func alignRight(var string: String, count: Int, pad: Character) -> String {
     return string
 }
 let originalString = "hello"
-let paddedString = alignRight(originalString, 10, "-")
+let paddedString = alignRight(originalString, totalLength: 10, pad: "-")
 // paddedString is equal to "-----hello"
 // originalString is still equal to "hello"
 ```
 
-这个例子中定义了一个新的叫做 `alignRight` 的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串`"hello"`被转换成了`"-----hello"`。
+这个例子中定义了一个新的叫做 `alignRight(_:totalLength:pad:)` 的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串`"hello"`被转换成了`"-----hello"`。
 
-`alignRight` 函数将参数 `string` 定义为变量参数。这意味着 `string` 现在可以作为一个局部变量，用传入的字符串值初始化，并且可以在函数体中进行操作。
+`alignRight(_:totalLength:pad:)` 函数将参数 `string` 定义为变量参数。这意味着 `string` 现在可以作为一个局部变量，用传入的字符串值初始化，并且可以在函数体中进行操作。
 
-该函数首先计算出多少个字符需要被添加到 `string` 的左边，以右对齐到总的字符串中。这个值存在局部常量 `amountToPad` 中。这个函数然后将 `amountToPad` 多的填充（pad）字符填充到 `string` 左边，并返回结果。它使用了 `string` 这个变量参数来进行所有字符串操作。
+　函数首先找出有多少字符需要被添加到左边的字符串以右对齐在整个字符串。这个值是存储在一个本地常数称为amountToPad。如果不需要填充(也就是说,如果amountToPad小于1),该函数返回字符串没有填充的输入值。
+　　
+　　否则,该函数创建一个新的临时字符串常量称为padString,初始化填充字符,并将amountToPad padString副本添加到现有的左边的字符串。(一个字符串值不能被添加到一个字符值,所以padString常数用于确保双方+操作符的字符串值)。
+
+该函数首先计算出多少个字符需要被添加到 `string` 的左边，以右对齐到总的字符串中。这个值存在局部常量 `amountToPad` 中。如果不需要填充(即,如果`amountToPad`小于`1`),该函数返回没有填充输入的`string`.
+
+否则,该函数会建立一个临时的String常量称为`padString`,初始化`pad`字符,并将`amountToPad`作为`padString`的副本添加到现有的字符串左边.(一个`Character`后不能直接添加一个`String`值,所以`padString`经常用于确保`+`号两边都是`String`值.)
 
 > 注意：
 > 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。
@@ -436,29 +384,29 @@ let paddedString = alignRight(originalString, 10, "-")
 > 注意：
 > 输入输出参数不能有默认值，而且可变参数不能用 `inout` 标记。如果你用 `inout` 标记一个参数，这个参数不能被 `var` 或者 `let` 标记。
 
-下面是例子，`swapTwoInts` 函数，有两个分别叫做 `a` 和 `b` 的输入输出参数：
+下面是例子，`swapTwoInts(_:_:)` 函数，有两个分别叫做 `a` 和 `b` 的输入输出参数：
 
 ```swift
-func swapTwoInts(inout a: Int, inout b: Int) {
+func swapTwoInts(inout a: Int, inout _ b: Int) {
     let temporaryA = a
     a = b
     b = temporaryA
 }
 ```
 
-这个 `swapTwoInts` 函数仅仅交换 `a` 与 `b` 的值。该函数先将 `a` 的值存到一个暂时常量 `temporaryA` 中，然后将 `b` 的值赋给 `a`，最后将 `temporaryA` 幅值给 `b`。
+这个 `swapTwoInts(_:_:)` 函数仅仅交换 `a` 与 `b` 的值。该函数先将 `a` 的值存到一个暂时常量 `temporaryA` 中，然后将 `b` 的值赋给 `a`，最后将 `temporaryA` 幅值给 `b`。
 
-你可以用两个 `Int` 型的变量来调用 `swapTwoInts`。需要注意的是，`someInt` 和 `anotherInt` 在传入 `swapTwoInts` 函数前，都加了 `&` 的前缀：
+你可以用两个 `Int` 型的变量来调用 `swapTwoInts(_:_:)`。需要注意的是，`someInt` 和 `anotherInt` 在传入 `swapTwoInts(_:_:)` 函数前，都加了 `&` 的前缀：
 
 ```swift
 var someInt = 3
 var anotherInt = 107
 swapTwoInts(&someInt, &anotherInt)
-println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
-// prints "someInt is now 107, and anotherInt is now 3”
+print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
+// prints "someInt is now 107, and anotherInt is now 3"
 ```
 
-从上面这个例子中，我们可以看到 `someInt` 和 `anotherInt` 的原始值在 `swapTwoInts` 函数中被修改，尽管它们的定义在函数体外。
+从上面这个例子中，我们可以看到 `someInt` 和 `anotherInt` 的原始值在 `swapTwoInts(_:_:)` 函数中被修改，尽管它们的定义在函数体外。
 
 > 注意：
 > 输入输出参数和返回值是不一样的。上面的 `swapTwoInts` 函数并没有定义任何返回值，但仍然修改了 `someInt` 和 `anotherInt` 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
@@ -471,10 +419,10 @@ println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
 例如：
 
 ```swift
-func addTwoInts(a: Int, b: Int) -> Int {
+func addTwoInts(a: Int, _ b: Int) -> Int {
     return a + b
 }
-func multiplyTwoInts(a: Int, b: Int) -> Int {
+func multiplyTwoInts(a: Int, _ b: Int) -> Int {
     return a * b
 }
 ```
@@ -487,11 +435,11 @@ func multiplyTwoInts(a: Int, b: Int) -> Int {
 
 ```swift
 func printHelloWorld() {
-    println("hello, world")
+    print("hello, world")
 }
 ```
 
-这个函数的类型是：`() -> ()`，或者叫“没有参数，并返回 `Void` 类型的函数”。没有指定返回类型的函数总返回 `Void`。在Swift中，`Void` 与空的元组是一样的。
+这个函数的类型是：`() -> void`，或者叫“没有参数，并返回 `Void` 类型的函数”。
 
 ### 使用函数类型（Using Function Types）
 
@@ -510,7 +458,7 @@ var mathFunction: (Int, Int) -> Int = addTwoInts
 现在，你可以用 `mathFunction` 来调用被赋值的函数了：
 
 ```swift
-println("Result: \(mathFunction(2, 3))")
+print("Result: \(mathFunction(2, 3))")
 // prints "Result: 5"
 ```
 
@@ -518,7 +466,7 @@ println("Result: \(mathFunction(2, 3))")
 
 ```swift
 mathFunction = multiplyTwoInts
-println("Result: \(mathFunction(2, 3))")
+print("Result: \(mathFunction(2, 3))")
 // prints "Result: 6"
 ```
 
@@ -536,18 +484,18 @@ let anotherMathFunction = addTwoInts
 下面是另一个例子，正如上面的函数一样，同样是输出某种数学运算结果：
 
 ```swift
-func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
-    println("Result: \(mathFunction(a, b))")
+func printMathResult(mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
+    print("Result: \(mathFunction(a, b))")
 }
 printMathResult(addTwoInts, 3, 5)
-// prints "Result: 8”
+// prints "Result: 8"
 ```
 
-这个例子定义了 `printMathResult` 函数，它有三个参数：第一个参数叫 `mathFunction`，类型是`(Int, Int) -> Int`，你可以传入任何这种类型的函数；第二个和第三个参数叫 `a` 和 `b`，它们的类型都是 `Int`，这两个值作为已给的函数的输入值。
+这个例子定义了 `printMathResult(_:_:_:)` 函数，它有三个参数：第一个参数叫 `mathFunction`，类型是`(Int, Int) -> Int`，你可以传入任何这种类型的函数；第二个和第三个参数叫 `a` 和 `b`，它们的类型都是 `Int`，这两个值作为已给的函数的输入值。
 
-当 `printMathResult` 被调用时，它被传入 `addTwoInts` 函数和整数`3`和`5`。它用传入`3`和`5`调用 `addTwoInts`，并输出结果：`8`。
+当 `printMathResult(_:_:_:)` 被调用时，它被传入 `addTwoInts` 函数和整数`3`和`5`。它用传入`3`和`5`调用 `addTwoInts`，并输出结果：`8`。
 
-`printMathResult` 函数的作用就是输出另一个合适类型的数学函数的调用结果。它不关心传入函数是如何实现的，它只关心这个传入的函数类型是正确的。这使得 `printMathResult` 可以以一种类型安全（type-safe）的方式来保证传入函数的调用是正确的。
+`printMathResult(_:_:_:)` 函数的作用就是输出另一个合适类型的数学函数的调用结果。它不关心传入函数是如何实现的，它只关心这个传入的函数类型是正确的。这使得 `printMathResult(_:_:_:)` 可以以一种类型安全（type-safe）的方式来保证传入函数的调用是正确的。
 
 ### 函数类型作为返回类型（Function Type as Return Types）
 
@@ -564,7 +512,7 @@ func stepBackward(input: Int) -> Int {
 }
 ```
 
-下面这个叫做 `chooseStepFunction` 的函数，它的返回类型是 `(Int) -> Int` 的函数。`chooseStepFunction` 根据布尔值 `backwards` 来返回 `stepForward` 函数或 `stepBackward` 函数：
+下面这个叫做 `chooseStepFunction(_:)` 的函数，它的返回类型是 `(Int) -> Int` 的函数。`chooseStepFunction(_:)` 根据布尔值 `backwards` 来返回 `stepForward(_:)` 函数或 `stepBackward(_:)` 函数：
 
 ```swift
 func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
@@ -572,7 +520,7 @@ func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
 }
 ```
 
-你现在可以用 `chooseStepFunction` 来获得一个函数，不管是那个方向：
+你现在可以用 `chooseStepFunction(_:)` 来获得一个函数，不管是那个方向：
 
 ```swift
 var currentValue = 3
@@ -580,22 +528,23 @@ let moveNearerToZero = chooseStepFunction(currentValue > 0)
 // moveNearerToZero now refers to the stepBackward() function
 ```
 
-上面这个例子中计算出从 `currentValue` 逐渐接近到`0`是需要向正数走还是向负数走。`currentValue` 的初始值是`3`，这意味着 `currentValue > 0` 是真的（`true`），这将使得 `chooseStepFunction` 返回 `stepBackward` 函数。一个指向返回的函数的引用保存在了 `moveNearerToZero` 常量中。
+上面这个例子中计算出从 `currentValue` 逐渐接近到`0`是需要向正数走还是向负数走。`currentValue` 的初始值是`3`，这意味着 `currentValue > 0` 是真的（`true`），这将使得 `chooseStepFunction(_:)` 返回 `stepBackward(_:)` 函数。一个指向返回的函数的引用保存在了 `moveNearerToZero` 常量中。
 
 现在，`moveNearerToZero` 指向了正确的函数，它可以被用来数到`0`：
 
 ```swift
-println("Counting to zero:")
+print("Counting to zero:")
 // Counting to zero:
 while currentValue != 0 {
-    println("\(currentValue)... ")
+    print("\(currentValue)... ")
     currentValue = moveNearerToZero(currentValue)
 }
-println("zero!")
+print("zero!")
 // 3...
 // 2...
 // 1...
 // zero!
+
 ```
 
 <a name="Nested_Functions"></a>
@@ -605,7 +554,7 @@ println("zero!")
 
 默认情况下，嵌套函数是对外界不可见的，但是可以被他们封闭函数（enclosing function）来调用。一个封闭函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
 
-你可以用返回嵌套函数的方式重写 `chooseStepFunction` 函数：
+你可以用返回嵌套函数的方式重写 `chooseStepFunction(_:)` 函数：
 
 ```swift
 func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
@@ -617,10 +566,10 @@ var currentValue = -4
 let moveNearerToZero = chooseStepFunction(currentValue > 0)
 // moveNearerToZero now refers to the nested stepForward() function
 while currentValue != 0 {
-    println("\(currentValue)... ")
+    print("\(currentValue)... ")
     currentValue = moveNearerToZero(currentValue)
 }
-println("zero!")
+print("zero!")
 // -4...
 // -3...
 // -2...

From f6533d5bd05209e991b1e688eda5316c7b4e0e21 Mon Sep 17 00:00:00 2001
From: AlanMelody <alanmelody@qq.com>
Date: Fri, 17 Jul 2015 20:50:30 +0800
Subject: [PATCH 122/228] =?UTF-8?q?=E7=AC=AC=E5=9B=9B=E7=AB=A0=E9=9B=86?=
 =?UTF-8?q?=E5=90=88=E7=B1=BB=E5=9E=8B=E7=BF=BB=E8=AF=91=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/04_Collection_Types.md | 450 +++++++++++++------------
 1 file changed, 237 insertions(+), 213 deletions(-)

diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index 718cfb1c..21db0b85 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -1,42 +1,99 @@
-> 翻译：[zqp](https://github.com/zqp)
-> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin)
+> 翻译：[zqp](https://github.com/zqp), [JackAlan](https://github.com/AlanMelody)
+> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin), [JackAlan](https://github.com/AlanMelody)
 
 # 集合类型 (Collection Types)
 -----------------
 
 本页包含内容：
 
+- [集合的可变性（Mutability of Collections）](#mutability_of_collections)
 - [数组（Arrays）](#arrays)
 - [集合（Sets）](#sets)
 - [字典（Dictionaries）](#dictionaries)
-- [集合的可变性（Mutability of Collections）](#mutability_of_collections)
 
-Swift 语言提供经典的数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址（就是键值对）。
+Swift 语言提供`Arrays`、`Sets`和`Dictionaries`三种基本的集合类型用来存储集合数据。数组是有序数据的集。集合是无序无重复数据的集。字典是无序的键值对的集。
 
-Swift 语言里的数组和字典中存储的数据值类型必须明确。 这意味着我们不能把不正确的数据类型插入其中。 同时这也说明我们完全可以对获取出的值类型非常自信。 Swift 对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚，也让我们在开发中可以早早地找到任何的类型不匹配错误。
+![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/CollectionTypes_intro_2x.png)
+
+Swift 语言中的`Arrays`、`Sets`和`Dictionaries`中存储的数据值类型必须明确。这意味着我们不能把不正确的数据类型插入其中。同时这也说明我们完全可以对取回值的类型非常自信。
 
 > 注意：
-Swift 的数组结构在被声明成常量和变量或者被传入函数与方法中时会相对于其他类型展现出不同的特性。 获取更多信息请参见[集合的可变性](#mutability_of_collections)与[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)章节。
+Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更多关于泛型类型和集合，参见 [泛型](23_Generics.html)章节。
+
+<a name="mutability_of_collections"></a>
+## 集合的可变性
+
+如果创建一个`Arrays`、`Sets`或`Dictionaries`并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项来改变这个集合的大小。如果我们把`Arrays`、`Sets`或`Dictionaries`分配成常量，那么它就是不可变的，它的大小不能被改变。
+
+> 注意：
+ 在我们不需要改变集合大小的时候创建不可变集合是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。
 
 <a name="arrays"></a>
-## 数组
+## 数组(Arrays)
 
 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。
 
-Swift 数组特定于它所存储元素的类型。这与 Objective-C 的 NSArray 和 NSMutableArray 不同，这两个类可以存储任意类型的对象，并且不提供所返回对象的任何特别信息。在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，而且不是必须是`class`类型。例如： 如果我们创建了一个`Int`值类型的数组，我们不能往其中插入任何不是`Int`类型的数据。 Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。
+> 注意:
+ Swift 的`Array`类型被桥接到`Foundation`中的`NSArray`类。
+ 更多关于在`Foundation`和`Cocoa`中使用`Array`的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。 
 
 <a name="array_type_shorthand_syntax"></a>
 ### 数组的简单语法
 
-写 Swift 数组应该遵循像`Array<SomeType>`这样的形式，其中`SomeType`是这个数组中唯一允许存在的数据类型。 我们也可以使用像`[SomeType]`这样的简单语法。 尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
+写 Swift 数组应该遵循像`Array<T>`这样的形式，其中`T`是这个数组中唯一允许存在的数据类型。我们也可以使用像`[T]`这样的简单语法。尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
 
-<a name="array_literals"></a>
-### 数组构造语句
+<a name="creating_an_empty_array"></a>
+###创建一个空数组
+
+我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
+
+```swift
+var someInts = [Int]()
+print("someInts is of type [Int] with \(someInts.count) items。")
+// 打印 "someInts is of type [Int] with 0 items。"
+```
+
+注意 通过构造函数的类型，`someInts`的值类型被推断为`[Int]`。
+
+或者，如果代码上下文中已经提供了类型信息，例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：`[]`（一对空方括号）：
+
+```swift
+someInts.append(3)
+// someInts 现在包含一个Int值
+someInts = []
+// someInts 现在是空数组，但是仍然是[Int]类型的。
+```
+
+<a name="creating_an_array_with_a_default_value"></a>
+###创建一个带有默认值的数组
+
+Swift 中的`Array`类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（`count`）和适当类型的初始值（`repeatedValue`）传入数组构造函数：
+
+```swift
+var threeDoubles = [Double](count: 3, repeatedValue:0.0)
+// threeDoubles 是一种 [Double]数组, 等于 [0.0, 0.0, 0.0]
+```
+
+<a name="creating_an_array_by_adding_two_arrays_together"></a>
+###通过两个数组相加创建一个数组
+
+我们可以使用加法操作符（`+`）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：
+
+```swift
+var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
+// anotherThreeDoubles is inferred as [Double], and equals [2.5, 2.5, 2.5]
+
+var sixDoubles = threeDoubles + anotherThreeDoubles
+// sixDoubles 被推断为 [Double], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
+```
+
+<a name="creating_an_array_with_an_array_literals"></a>
+### 用字面量构造数组
 
 我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值。
 `[value 1, value 2, value 3]`。
 
-下面这个例子创建了一个叫做`shoppingList`并且存储字符串的数组：
+下面这个例子创建了一个叫做`shoppingList`并且存储`String`的数组：
 
 ```swift
 var shoppingList: [String] = ["Eggs", "Milk"]
@@ -65,7 +122,7 @@ var shoppingList = ["Eggs", "Milk"]
 还可以使用数组的只读属性`count`来获取数组中的数据项数量。
 
 ```swift
-println("The shopping list contains \(shoppingList.count) items.")
+print("The shopping list contains \(shoppingList.count) items.")
 // 输出"The shopping list contains 2 items."（这个数组有2个项）
 ```
 
@@ -73,9 +130,9 @@ println("The shopping list contains \(shoppingList.count) items.")
 
 ```swift
 if shoppingList.isEmpty {
-    println("The shopping list is empty.")
+    print("The shopping list is empty.")
 } else {
-    println("The shopping list is not empty.")
+    print("The shopping list is not empty.")
 }
 // 打印 "The shopping list is not empty."（shoppinglist不是空的）
 ```
@@ -120,9 +177,10 @@ shoppingList[4...6] = ["Bananas", "Apples"]
 ```
 
 > 注意：
->我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于 0 时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。
+> 不可以用下表访问的形式去在数组尾部添加新项。
 
-调用数组的`insert(atIndex:)`方法来在某个具体索引值之前添加数据项：
+
+调用数组的`insert(_:atIndex:)`方法来在某个具体索引值之前添加数据项：
 
 ```swift
 shoppingList.insert("Maple Syrup", atIndex: 0)
@@ -140,6 +198,8 @@ let mapleSyrup = shoppingList.removeAtIndex(0)
 // shoppingList 现在只有6项，而且不包括Maple Syrup
 // mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup"
 ```
+> 注意：
+> 如果我们试着对索引越界的数据进行检索或者设置新值的操作，会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于 0 时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。
 
 数据项被移除后数组中的空出项会被自动填补，所以现在索引值为`0`的数据项的值再次等于`"Six eggs"`:
 
@@ -148,7 +208,7 @@ firstItem = shoppingList[0]
 // firstItem 现在等于 "Six eggs"
 ```
 
-如果我们只想把数组中的最后一项移除，可以使用`removeLast`方法而不是`removeAtIndex`方法来避免我们需要获取数组的`count`属性。就像后者一样，前者也会返回被移除的数据项：
+如果我们只想把数组中的最后一项移除，可以使用`removeLast`方法而不是`removeAtIndex(_:)`方法来避免我们需要获取数组的`count`属性。就像后者一样，前者也会返回被移除的数据项：
 
 ```swift
 let apples = shoppingList.removeLast()
@@ -164,7 +224,7 @@ let apples = shoppingList.removeLast()
 
 ```swift
 for item in shoppingList {
-    println(item)
+    print(item)
 }
 // Six eggs
 // Milk
@@ -173,11 +233,11 @@ for item in shoppingList {
 // Bananas
 ```
 
-如果我们同时需要每个数据项的值和索引值，可以使用全局`enumerate`函数来进行数组遍历。`enumerate`返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：
+如果我们同时需要每个数据项的值和索引值，可以使用`enumerate()`方法来进行数组遍历。`enumerate()`返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：
 
 ```swift
-for (index, value) in enumerate(shoppingList) {
-    println("Item \(String(index + 1)): \(value)")
+for (index, value) in shoppingList.enumerate() {
+    print("Item \(String(index + 1)): \(value)")
 }
 // Item 1: Six eggs
 // Item 2: Milk
@@ -188,146 +248,122 @@ for (index, value) in enumerate(shoppingList) {
 
 更多关于`for-in`循环的介绍请参见[for 循环](05_Control_Flow.html#for_loops)。
 
-<a name="creating_and_initializing_an_array"></a>
-### 创建并且构造一个数组
-
-我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
-
-```swift
-var someInts = [Int]()
-println("someInts is of type [Int] with \(someInts.count) items。")
-// 打印 "someInts is of type [Int] with 0 items。"（someInts是0数据项的Int[]数组）
-```
-
-注意`someInts`被设置为一个`[Int]`构造函数的输出所以它的变量类型被定义为`[Int]`。
-
-除此之外，如果代码上下文中提供了类型信息， 例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：`[]`（一对空方括号）：
-
-```swift
-someInts.append(3)
-// someInts 现在包含一个INT值
-someInts = []
-// someInts 现在是空数组，但是仍然是[Int]类型的。
-```
-
-Swift 中的`Array`类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（`count`）和适当类型的初始值（`repeatedValue`）传入数组构造函数：
-
-```swift
-var threeDoubles = [Double](count: 3, repeatedValue:0.0)
-// threeDoubles 是一种 [Double]数组, 等于 [0.0, 0.0, 0.0]
-```
-
-因为类型推断的存在，我们使用这种构造方法的时候不需要特别指定数组中存储的数据类型，因为类型可以从默认值推断出来：
-
-```swift
-var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
-// anotherThreeDoubles is inferred as [Double], and equals [2.5, 2.5, 2.5]
-```
-
-最后，我们可以使用加法操作符（`+`）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：
-
-```swift
-var sixDoubles = threeDoubles + anotherThreeDoubles
-// sixDoubles 被推断为 [Double], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
-```
 <a name="sets"></a>
 ## 集合
 
-集合用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以把集合当做是数组另一形式。
+集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以把集合当做是数组另一形式。
 
 > 注意：
-> Swift的<code>Set</code>类型被桥接到<code>Fundation</code>中的<code>NSSet</code>类
-> 关于使用<code>Fundation</code>和<code>Cocoa</code>中集合的知识，请看<a link="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216">Swift与Cocoa和Objective-C使用</a>
+> Swift的`Set`类型被桥接到`Fundation`中的`NSSet`类。
+> 关于使用`Fundation`和`Cocoa`中`Set`的知识，请看 *Using Swift with Cocoa and Objective-C*。
+
+<a name="hash_values_for_set_types"></a>
+#### Set类型的哈希值
+
+为了存储在集合中，该类型必须是可哈希化的-也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是```Int```类型的，它和其他的对象相同，其被用来比较相等与否，比如```a==b```,它遵循的是```a.hashValue == b.hashValue```。
+
+Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool```)默认都是可哈希化的，它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在[枚举部分](08_Enumerations.html)有讲述)默认也是可哈希化的。
+
+> 注意：
+> 你可以使用你自定义的类型作为集合的值或者是字典的键值类型，但你需要使你的自定义类型服从Swift标准库中的`Hashable`协议。服从`Hashable`协议的类型需要提供一个类型为`Int`的取值访问器属性`hashValue`。这个由类型的`hashValue`返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。
+> 因为`hashable`协议服从于`Equatable`协议，所以遵循该协议的类型也必须提供一个"是否等"运算符(`==`)的实现。这个`Equatable`协议需要任何遵循的`==`的实现都是一种相等的关系。也就是说，对于`a,b,c`三个值来说，`==`的实现必须满足下面三种情况：
+
+* ```a==a```(自反性)
+* ```a==b```意味着```b==a```(对称性)
+* ```a==b&&b==c```意味着```a==c```(传递性)
+
+关于协议遵循的更多信息，请看[协议](22_Protocols.html)
 
 <a name="set_type_syntax"></a>
 ### Set类型语法
 
-Swift中的<code>Set</code>类型被写为```Set<SomeType>```,这里的```SomeType```表示```Set```中允许存储的类型，和数组不同的是，集合没有等价的简化形式。
+Swift中的`Set`类型被写为`Set<T>`, 这里的`T`表示`Set`中允许存储的类型，和数组不同的是，集合没有等价的简化形式。
 
-<a name="create_and_initializing_a_set"></a>
-### 创建和构造一个Set
+<a name="creating_and_initalizing_an_empty_set"></a>
+### 创建和构造一个空的Set
 
 你可以通过构造器语法创建一个特定类型的空集合：
 
 ```swift
 var letters = Set<Character>()
-println("letters is of type Set<Character> with \(letters.count) items.")
+print("letters is of type Set<Character> with \(letters.count) items.")
 // 打印 "letters is of type Set<Character> with 0 items."
 ```
 
-注意这里的```letters```变量的类型来自于构造器的类型，其为```Set<Character>```。
+> 注意：
+> 通过构造器，这里的`letters`变量的类型被推断为`Set<Character>`。
 
-另外，如果上下文提供了类型信息，比如作为函数的参数或者已知类型的变量或常量，你可以通过一个空的数组字面量创建一个空的```Set```：
+此外，如果上下文提供了类型信息，比如作为函数的参数或者已知类型的变量或常量，我们可以通过一个空的数组字面量创建一个空的`Set`：
 
 ```swift
 letters.insert("a")
-// letters现在含有1个Character类型的值
+// letters 现在含有1个Character类型的值
 letters = []
-// letters现在是一个空的Set, 但是它依然是Set<Character>类型
+// letters 现在是一个空的Set, 但是它依然是 Set<Character> 类型
 ```
 
-<a name="sets_with_arrays_literals"></a>
-### 集合与数组字面量
+<a name="creating_a_set_with_an_array_literal"></a>
+### 用数组字面量创建集合
 
-你可以使用一个数组字面量来构造一个集合，并且可以使用简化形式写一个或者多个值作为集合元素。
+你可以使用数组字面量来构造集合，并且可以使用简化形式写一个或者多个值作为集合元素。
 
-下面的例子创建一个称之为```favoriteGenres```的集合来存储```String```类型的值：
+下面的例子创建一个称之为`favoriteGenres`的集合来存储`String`类型的值：
 
 ```swift
 var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
 // favoriteGenres被构造成含有三个初始值的集合
 ```
 
-这个```favoriteGenres```变量被声明为“一个```String```值的集合”，写为```Set<String>```。由于这个特定的集合含有指定```String```类型的值，所以它只允许存储```String```类型值。这里的```favoriteGenres```变量有三个```String```类型的初始值("```Rock```","```Classical```"和"```Hip hop```"),并以数组字面量的方式出现。
+这个`favoriteGenres`变量被声明为“一个`String`值的集合”，写为`Set<String>`。由于这个特定的集合含有指定`String`类型的值，所以它只允许存储`String`类型值。这里的`favoriteGenres`变量有三个`String`类型的初始值("`Rock`","`Classical`"和"`Hip hop`")，并以数组字面量的方式出现。
 
 > 注意：
-> ```favoriteGenres```被声明为一个变量(拥有```var```标示符)而不是一个常量(拥有```let```标示符),因为它里面的元素将会在下面的例子中被增加或者移除。
+> `favoriteGenres`被声明为一个变量(拥有`var`标示符)而不是一个常量(拥有`let`标示符),因为它里面的元素将会在下面的例子中被增加或者移除。
 
-一个```Set```类型不能从数组中字面量中独立地被推断出来，因此```Set```类型必须显式声明。然而，由于Swift的类型推导功能，如果你想使用一个数组字面量构造一个Set并且该数组字面量中的所有元素类型相同，那么你无须写出```Set```的具体类型。```favoriteGenres```的构造形式可以采用简化的方式代替：
+一个`Set`类型不能从数组中字面量中独立地被推断出来，因此`Set`类型必须显式声明。然而，由于Swift的类型推导功能，如果你想使用一个数组字面量构造一个Set并且该数组字面量中的所有元素类型相同，那么你无须写出`Set`的具体类型。`favoriteGenres`的构造形式可以采用简化的方式代替：
 
 ```swift
 var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
 ```
 
-由于数组字面量中的所有元素类型相同，Swift可以推断出```Set<String>```作为```favoriteGenres```变量的正确类型。
+由于数组字面量中的所有元素类型相同，Swift可以推断出`Set<String>`作为`favoriteGenres`变量的正确类型。
 
 <a name="accesing_and_modifying_a_set"></a>
 ### 访问和修改一个Set
 
-你可以通过```Set```的属性和方法来访问和修改一个```Set```.
+你可以通过`Set`的属性和方法来访问和修改一个`Set`.
 
-为了找出一个```Set```中元素的数量，可以使用其只读属性```count```:
+为了找出一个`Set`中元素的数量，可以使用其只读属性`count`:
 
 ```swift
-println("I have \(favoriteGenres.count) favorite music genres.")
-// 打印 ""I have 3 favorite music genres.""
+print("I have \(favoriteGenres.count) favorite music genres.")
+// 打印 "I have 3 favorite music genres."
 ```
 
-使用布尔属性```isEmpty```作为一个缩写形式去检查```count```属性是否为```0```:
+使用布尔属性`isEmpty`作为一个缩写形式去检查`count`属性是否为`0`:
 
 ```swift
 if favoriteGenres.isEmpty {
-    println("As far as music goes, I'm not picky.")
+    print("As far as music goes, I'm not picky.")
 } else {
-    println("I have particular music preferences.")
+    print("I have particular music preferences.")
 }
 // 打印 "I have particular music preferences."
 ```
 
-你可以通过调用```Set```的``` insert(_:) ```方法添加一个新的元素：
+你可以通过调用`Set`的` insert(_:) `方法来添加一个新元素：
 
 ```swift
 favoriteGenres.insert("Jazz")
 // favoriteGenres 现在包含4个元素
 ```
 
-你可以通过调用```Set```的```remove(_:)```方法去删除一个元素，如果该值是该```Set```的一个元素则删除该元素并且返回被删除的元素值，否认如果该```Set```不包含该值，则返回```nil```。另外，```Set```中的所有元素可以通过它的```removeAll()```方法删除。
+你可以通过调用`Set`的`remove(_:)`方法去删除一个元素，如果该值是该`Set`的一个元素则删除该元素并且返回被删除的元素值，否认如果该`Set`不包含该值，则返回`nil`。另外，`Set`中的所有元素可以通过它的`removeAll()`方法删除。
 
 ```swift
 if let removedGenre = favoriteGenres.remove("Rock") {
-    println("\(removedValue)? I'm over it.")
+    print("\(removedValue)? I'm over it.")
 } else {
-    println("I never much cared for that.")
+    print("I never much cared for that.")
 }
 // 打印 "Rock? I'm over it."
 ```
@@ -336,9 +372,9 @@ if let removedGenre = favoriteGenres.remove("Rock") {
 
 ```swift
 if favoriteGenres.contains("Funk") {
-    println("I get up on the good foot.")
+    print("I get up on the good foot.")
 } else {
-    println("It's too funky in here.")
+    print("It's too funky in here.")
 }
 // 打印 "It's too funky in here."
 ```
@@ -350,20 +386,20 @@ if favoriteGenres.contains("Funk") {
 
 ```swift
 for genre in favoriteGenres {
-    println("\(genre)")
+    print("\(genre)")
 }
 // Classical
 // Jazz
 // Hip hop
 ```
 
-更多关于```for-in```循环信息，请看<a link="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ControlFlow.html#//apple_ref/doc/uid/TP40014097-CH9-ID121">For循环</a>
+更多关于`for-in`循环信息，参见[For循环](05_Control_Flow.html#for_loops)。
 
-Swift的```Set```类型没有确定的顺序，为了按照特定顺序来遍历一个```Set```中值可以使用全局```sorted```函数，它将根据提供的序列返回一个排序的集合.
+Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中值可以使用`sorted()`方法，它将根据提供的序列返回一个排序的集合.
 
 ```swift
--> for genre in sorted(favoriteGenres) {
-    println("\(genre)")
+for genre in sorted(favoriteGenres) {
+    print("\(genre)")
 }
 // prints "Classical"
 // prints "Hip hop"
@@ -373,19 +409,19 @@ Swift的```Set```类型没有确定的顺序，为了按照特定顺序来遍历
 <a name="performing_set_operations"></a>
 ### 完成集合操作
 
-你可以高效的完成```Set```的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。
+你可以高效的完成`Set`的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。
 
-<a name="constructing_sets"></a>
-#### 构造集合
+<a name="fundamental_set_operations"></a>
+#### 基本集合操作
 
-下面的插图描述了两个集合-```a```和```b```-以及通过阴影部分的区域显示集合各种操作的结果。
+下面的插图描述了两个集合-`a`和`b`-以及通过阴影部分的区域显示集合各种操作的结果。
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/setVennDiagram_2x.png)
 
-* 使用```union(_:)```方法根据两个集合的值创建一个新的集合。
-* 使用```subtract(_:)```方法根据不在该集合中的值创建一个新的集合。
-* 使用```intersect(_:)```方法根据两个集合中都包含的值创建的一个新的集合。
-* 使用```exclusiveOr(_:)```方法根据值在一个集合中但不在两个集合中的值创建一个新的集合。
+* 使用`intersect(_:)`方法根据两个集合中都包含的值创建的一个新的集合。
+* 使用`exclusiveOr(_:)`方法根据值在一个集合中但不在两个集合中的值创建一个新的集合。
+* 使用`union(_:)`方法根据两个集合的值创建一个新的集合。
+* 使用`subtract(_:)`方法根据不在该集合中的值创建一个新的集合。
 
 ```swift
 let oddDigits: Set = [1, 3, 5, 7, 9]
@@ -401,18 +437,18 @@ sorted(oddDigits.exclusiveOr(singleDigitPrimeNumbers))
 // [1, 2, 9]
 ```
 
-<a name="comparing_sets"></a>
-#### 集合比较
+<a name="set_membership_and_equality"></a>
+#### 集合成员关系和相等
 
-下面的插图描述了三个集合-```a```,```b```和```c```,以及通过悬浮区域表述集合间共享的元素。Set ```a```是Set ```b```的父集合，因为```a```包含了```b```中所有的元素，相反的，Set ```b```是```a```的子集合，因为属于```b```的元素也被```a```包含。Set ```b```和Set ```c```彼此不关联，因为它们之间没有共同的元素。
+下面的插图描述了三个集合-`a`,`b`和`c`,以及通过悬浮区域表述集合间共享的元素。Set `a`是Set`b`的父集合，因为`a`包含了`b`中所有的元素，相反的，Set `b`是`a`的子集合，因为属于`b`的元素也被`a`包含。Set `b`和Set `c`彼此不关联，因为它们之间没有共同的元素。
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/setEulerDiagram_2x.png)
 
-* 使用“是否等”运算符(```==```)来判断两个集合是否包含相同的值。
-* 使用```isSubsetOf(_:)```方法来判断一个集合中的值是否也被包含在另外一个集合中。
-* 使用```isSupersetOf(_:)```方法来判断一个集合中包含的值是另一个集合中所有的值。
-* 使用```isStrictSubsetOf(_:)```或者```isStrictSupersetOf(_:)```方法来判断一个集合是否是另外一个集合的子集合或者父集合并且和特定集合不相等。
-* 使用```isDisjointWith(_:)```方法来判断两个结合是否不含有相同的值。
+* 使用“是否等”运算符(`==`)来判断两个集合是否包含全部相同的值。
+* 使用`isSubsetOf(_:)`方法来判断一个集合中的值是否也被包含在另外一个集合中。
+* 使用`isSupersetOf(_:)`方法来判断一个集合中包含的值是另一个集合中所有的值。
+* 使用`isStrictSubsetOf(_:)`或者`isStrictSupersetOf(_:)`方法来判断一个集合是否是另外一个集合的子集合或者父集合并且和特定集合不相等。
+* 使用`isDisjointWith(_:)`方法来判断两个结合是否不含有相同的值。
 
 ```swift
 let houseAnimals: Set = ["🐶", "🐱"]
@@ -426,22 +462,6 @@ farmAnimals.isDisjointWith(cityAnimals)
 // true
 ```
 
-<a name="hash_values_for_set_types"></a>
-#### Set类型的哈希值
-
-为了存储在集合中，该类型必须是可哈希化的-也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是```Int```类型的，它和其他的对象相同，其被用来比较相等与否，比如```a==b```,它遵循的是``` a.hashValue == b.hashValue```。
-
-Swift的所有基本类型(比如```String```,```Int```,```Double```和```Bool```)默认都是可哈希化的，它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在[枚举部分](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Enumerations.html#//apple_ref/doc/uid/TP40014097-CH12-ID145)有讲述)默认也是可哈希化的。
-
->注意
->你可以使用你自定义的类型作为集合的值或者是字典的键值类型，但你需要使你的自定义类型服从Swift标准库中的```Hashable```协议。服从```Hashable```协议的类型需要提供一个类型为```Int```的取值访问器属性```hashValue```。这个由类型的```hashValue```返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。
->因为```hashable```协议服从于```Equatable```协议，所以遵循该协议的类型也必须提供一个"是否等"运算符(```==```)的实现。这个```Equatable```协议需要任何遵循的```==```的实现都是一种相等的关系。也就是说，对于```a,b,c```三个值来说，```==```的实现必须满足下面三种情况：
-
-* ```a==a```(自反性)
-* ```a==b```意味着```b==a```(对称性)
-* ```a==b&&b==c```意味着```a==c```(传递性)
-
-关于协议遵循的更多信息，请看[协议](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-ID267)
 
 
 <a name="dictionaries"></a>
@@ -449,18 +469,54 @@ Swift的所有基本类型(比如```String```,```Int```,```Double```和```Bool``
 
 字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。
 
+> 注意：
+> Swiftly 的`Dictionary` 类型被桥接到Foundation的`NSDictionary`类。
+> 更多关于在`Foundation`和`Cocoa`中使用`Dictionary`类型的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。
+
+<a name="dictionary_type_shorthand_syntax"></a>
+## 字典类型快捷语法
+<!--more
 Swift 的字典使用时需要具体规定可以存储键和值类型。不同于 Objective-C 的`NSDictionary`和`NSMutableDictionary` 类可以使用任何类型的对象来作键和值并且不提供任何关于这些对象的本质信息。在 Swift 中，在某个特定字典中可以存储的键和值必须提前定义清楚，方法是通过显性类型标注或者类型推断。
+-->
+Swift 的字典使用`Dictionary<Key, Value>`定义，其中`Key`是字典中键的数据类型，`Value`是字典中对应于这些键所存储值的数据类型。
 
-Swift 的字典使用`Dictionary<KeyType, ValueType>`定义,其中`KeyType`是字典中键的数据类型，`ValueType`是字典中对应于这些键所存储值的数据类型。
+> 注意：
+> 一个字典的`Key`类型必须遵循`Hashable`协议，就像`Set`的值类型。
 
+我们也可以用`[Key: Value]`这样快捷的形式去创建一个字典类型。虽然这俩种形式功能上相同，但是后者是首选，并且这本指导书涉及到字典类型时通篇采用后者。
+
+<!--more
 `KeyType`的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如`String`，`Int`， `Double`和`Bool`）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见[枚举](08_Enumerations.html)）也是默认可哈希的。
+-->
+
+<a name="creating_an_empty_dictionary"></a>
+### 创建一个空字典
+
+我们可以像数组一样使用构造语法创建一个拥有确定类型的空字典：
+
+```swift
+var namesOfIntegers = [Int: String]
+// namesOfIntegers 是一个空的 [Int: String] 字典
+```
+
+这个例子创建了一个`[Int: String]`类型的空字典来储存英语对整数的命名。它的键是`Int`型，值是`String`型。
+
+如果上下文已经提供了信息类型，我们可以使用空字典字面量来创建一个空字典，记作`[:]`（中括号中放一个冒号）：
+
+```swift
+namesOfIntegers[16] = "sixteen"
+// namesOfIntegers 现在包含一个键值对
+namesOfIntegers = [:]
+// namesOfIntegers 又成为了一个 Int, String类型的空字典
+```
+
+<a name="creating_a_dictionary_with_a_dictionary_literal"></a>
 
-<a name="dictionary_literals"></a>
 ## 字典字面量
 
-我们可以使用字典字面量来构造字典，它们和我们刚才介绍过的数组字面量拥有相似语法。一个字典字面量是一个定义拥有一个或者多个键值对的字典集合的简单语句。
+我们可以使用字典字面量来构造字典，这和我们刚才介绍过的数组字面量拥有相似语法。字典字面量是一种将写一个或多个键值对作`Dictionary`集合的快捷途径。
 
-一个键值对是一个`key`和一个`value`的结合体。在字典字面量中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含并且由逗号分割：
+一个键值对是一个`key`和一个`value`的结合体。在字典字面量中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含、由逗号分割：
 
 ```swift
 [key 1: value 1, key 2: value 2, key 3: value 3]
@@ -469,48 +525,51 @@ Swift 的字典使用`Dictionary<KeyType, ValueType>`定义,其中`KeyType`是
 下面的例子创建了一个存储国际机场名称的字典。在这个字典中键是三个字母的国际航空运输相关代码，值是机场名称：
 
 ```swift
-var airports: [String:String] = ["TYO": "Tokyo", "DUB": "Dublin"]
+var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
 ```
 
-`airports`字典被定义为一种 `[String: String]`,它意味着这个字典的键和值都是`String`类型。
+`airports`字典被声明为一种 `[String: String]`类型，这意味着这个字典的键和值都是`String`类型。
 
 > 注意：
 > `airports`字典被声明为变量（用`var`关键字）而不是常量（`let`关键字）因为后来更多的机场信息会被添加到这个示例字典中。
 
-`airports`字典使用字典字面量初始化，包含两个键值对。第一对的键是`TYO`，值是`Tokyo`。第二对的键是`DUB`，值是`Dublin`。
+`airports`字典使用字典字面量初始化，包含两个键值对。第一对的键是`YYZ`，值是`Toronto Pearson`。第二对的键是`DUB`，值是`Dublin`。
 
-这个字典语句包含了两个`String: String`类型的键值对。它们对应`airports`变量声明的类型（一个只有`String`键和`String`值的字典）所以这个字典字面量是构造两个初始数据项的`airport`字典。
+这个字典语句包含了两个`String: String`类型的键值对。它们对应`airports`变量声明的类型（一个只有`String`键和`String`值的字典）所以这个字典字面量的任务是构造拥有两个初始数据项的`airport`字典。
 
-和数组一样，如果我们使用字面量构造字典就不用把类型定义清楚。`airports`的也可以用这种方法简短定义：
+和数组一样，我们在用字典字面量构造字典时，如果它的键和值都有各自一致的类型，那么就不必写出字典的类型。
+`airports`的也可以用这种方法简短定义：
 
 ```swift
-var airports = ["TYO": "Tokyo", "DUB": "Dublin"]
+var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
 ```
 
-因为这个语句中所有的键和值都分别是相同的数据类型，Swift 可以推断出`Dictionary<String, String>`是`airports`字典的正确类型。
+因为这个语句中所有的键和值都各自拥有相同的数据类型，Swift 可以推断出`Dictionary<String, String>`是`airports`字典的正确类型。
 
 <a name="accessing_and_modifying_a_dictionary"></a>
 ### 读取和修改字典
 
-我们可以通过字典的方法和属性来读取和修改字典，或者使用下标语法。和数组一样，我们可以通过字典的只读属性`count`来获取某个字典的数据项数量：
+我们可以通过字典的方法和属性来读取和修改字典，或者通过使用下标语法。
+
+和数组一样，我们可以通过字典的只读属性`count`来获取某个字典的数据项数量：
 
 ```swift
-println("The dictionary of airports contains \(airports.count) items.")
+print("The dictionary of airports contains \(airports.count) items.")
 // 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项）
 ```
 
-可以使用布尔属性`isEmpty`来快捷的检查字典的`count`属性是否等于0。
+使用布尔属性`isEmpty`来快捷的检查字典的`count`属性是否等于0。
 
 ```swift
 if airports.isEmpty {
-    println("The airports dictionary is empty.")
+    print("The airports dictionary is empty.")
 } else {
-    println("The airports dictionary is not empty.")
+    print("The airports dictionary is not empty.")
 }
-// 打印 "The airports dictionary is not empty.(这个字典不为空)"
+// 打印 "The airports dictionary is not empty."
 ```
 
-我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的 key 作为下标索引，并且分配新的合适类型的值：
+我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的键值作为下标索引，并且分配新的合适类型的值：
 
 ```swift
 airports["LHR"] = "London"
@@ -524,26 +583,28 @@ airports["LHR"] = "London Heathrow"
 // "LHR"对应的值 被改为 "London Heathrow
 ```
 
-作为另一种下标方法，字典的`updateValue(forKey:)`方法可以设置或者更新特定键对应的值。就像上面所示的示例，`updateValue(forKey:)`方法在这个键不存在对应值的时候设置值或者在存在时更新已存在的值。和上面的下标方法不一样，这个方法返回更新值之前的原值。这样方便我们检查更新是否成功。
+作为另一种下标方法，字典的`updateValue(_:forKey:)`方法可以设置或者更新特定键对应的值。就像上面所示的下标示例，`updateValue(_:forKey:)`方法在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值。和上面的下标方法不同的，`updateValue(_:forKey:)`这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。
 
-`updateValue(forKey:)`函数会返回包含一个字典值类型的可选值。举例来说：对于存储`String`值的字典，这个函数会返回一个`String?`或者“可选 `String`”类型的值。如果值存在，则这个可选值值等于被替换的值，否则将会是`nil`。
+`updateValue(_:forKey:)`函数会返回包含一个字典值类型的可选值。举例来说：对于存储`String`值的字典，这个函数会返回一个`String?`或者“可选 `String`”类型的值。
+
+如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是`nil`。
 
 ```swift
-if let oldValue = airports.updateValue("Dublin Internation", forKey: "DUB") {
-    println("The old value for DUB was \(oldValue).")
+if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
+    print("The old value for DUB was \(oldValue).")
 }
-// 输出 "The old value for DUB was Dublin."（DUB原值是dublin）
+// 输出 "The old value for DUB was Dublin."
 ```
 
-我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选类型返回这个键存在的相关值，否则就返回`nil`：
+我们也可以使用下标语法来在字典中检索特定键对应的值。因为有可能请求的键没有对应的值存在，字典的下标访问会返回一个字典值类型的可选值。如果这个字典包含请求键所对应的值，下标会返回一个包含这个存在值的可选值，否则将返回`nil`：
 
 ```swift
 if let airportName = airports["DUB"] {
-    println("The name of the airport is \(airportName).")
+    print("The name of the airport is \(airportName).")
 } else {
-    println("That airport is not in the airports dictionary.")
+    print("That airport is not in the airports dictionary.")
 }
-// 打印 "The name of the airport is Dublin Internation."（机场的名字是都柏林国际）
+// 打印 "The name of the airport is Dublin Airport."
 ```
 
 我们还可以使用下标语法来通过给某个键的对应值赋值为`nil`来从字典里移除一个键值对：
@@ -555,45 +616,45 @@ airports["APL"] = nil
 // APL现在被移除了
 ```
 
-另外，`removeValueForKey`方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的value或者在没有值的情况下返回`nil`：
+此外，`removeValueForKey(_:)`方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回`nil`：
 
 ```swift
 if let removedValue = airports.removeValueForKey("DUB") {
-    println("The removed airport's name is \(removedValue).")
+    print("The removed airport's name is \(removedValue).")
 } else {
-    println("The airports dictionary does not contain a value for DUB.")
+    print("The airports dictionary does not contain a value for DUB.")
 }
-// prints "The removed airport's name is Dublin International."
+// prints "The removed airport's name is Dublin Airport."
 ```
 
 <a name="iterating_over_a_dictionary"></a>
 ### 字典遍历
 
-我们可以使用`for-in`循环来遍历某个字典中的键值对。每一个字典中的数据项都由`(key, value)`元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组：
+我们可以使用`for-in`循环来遍历某个字典中的键值对。每一个字典中的数据项都以`(key, value)`元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组：
 
 ```swift
 for (airportCode, airportName) in airports {
-    println("\(airportCode): \(airportName)")
+    print("\(airportCode): \(airportName)")
 }
-// TYO: Tokyo
+// YYZ: Toronto Pearson
 // LHR: London Heathrow
 ```
 
-`for-in`循环请参见[For 循环](05_Control_Flow.html#for_loops)。
+更多关于`for-in`循环的信息，参见[For 循环](05_Control_Flow.html#for_loops)。
 
-我们也可以通过访问它的`keys`或者`values`属性（都是可遍历集合）检索一个字典的键或者值：
+通过访问`keys`或者`values`属性，我们也可以遍历字典的键或者值。
 
 ```swift
 for airportCode in airports.keys {
-    println("Airport code: \(airportCode)")
+    print("Airport code: \(airportCode)")
 }
-// Airport code: TYO
+// Airport code: YYZ
 // Airport code: LHR
 
 for airportName in airports.values {
-    println("Airport name: \(airportName)")
+    print("Airport name: \(airportName)")
 }
-// Airport name: Tokyo
+// Airport name: Toronto Pearson
 // Airport name: London Heathrow
 ```
 
@@ -601,47 +662,10 @@ for airportName in airports.values {
 
 ```swift
 let airportCodes = Array(airports.keys)
-// airportCodes is ["TYO", "LHR"]
+// airportCodes is ["YYZ", "LHR"]
 
 let airportNames = Array(airports.values)
-// airportNames is ["Tokyo", "London Heathrow"]
+// airportNames is ["Toronto Pearson", "London Heathrow"]
 ```
 
-> 注意：
-> Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。
-
-<a name="creating_an_empty_dictionary"></a>
-### 创建一个空字典
-
-我们可以像数组一样使用构造语法创建一个空字典：
-
-```swift
-var namesOfIntegers = Dictionary<Int, String>()
-// namesOfIntegers 是一个空的 Dictionary<Int, String>
-```
-
-这个例子创建了一个`Int, String`类型的空字典来储存英语对整数的命名。它的键是`Int`型，值是`String`型。
-
-如果上下文已经提供了信息类型，我们可以使用空字典字面量来创建一个空字典，记作`[:]`（中括号中放一个冒号）：
-
-```swift
-namesOfIntegers[16] = "sixteen"
-// namesOfIntegers 现在包含一个键值对
-namesOfIntegers = [:]
-// namesOfIntegers 又成为了一个 Int, String类型的空字典
-```
-
-> 注意：
-> 在后台，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见[泛型](22_Generics.html)。
-
-<a name="mutability_of_collections"></a>
-## 集合的可变性
-
-数组和字典都是在单个集合中存储可变值。如果我们创建一个数组或者字典并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项来改变这个集合的大小。与此相反，如果我们把数组或字典分配成常量，那么它就是不可变的，它的大小不能被改变。
-
-相反，如果你给常量赋值一个数组、集合或者字典，那它就是不可变的，大小和内容都不能修改。
-
-Swift 数组的可变性行为同时影响了数组实例如何被分配和修改，想获取更多信息，请参见[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)。
-
-> 注意：
-> 在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。
+Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的`keys`或`values`属性使用`sort()`方法。

From 8c59b9c8448543ed3194c17fbe11332568229f8b Mon Sep 17 00:00:00 2001
From: AlanMelody <alanmelody@qq.com>
Date: Sat, 18 Jul 2015 16:39:49 +0800
Subject: [PATCH 123/228] =?UTF-8?q?=E7=AC=AC=E4=BA=94=E7=AB=A0ControlFlow?=
 =?UTF-8?q?=E5=9F=BA=E6=9C=AC=E7=BF=BB=E8=AF=91=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/05_Control_Flow.md | 294 +++++++++++++++++------------
 1 file changed, 169 insertions(+), 125 deletions(-)

diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index c87698ec..23f1b9f3 100755
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -1,5 +1,5 @@
-> 翻译：[vclwei](https://github.com/vclwei), [coverxit](https://github.com/coverxit), [NicePiao](https://github.com/NicePiao)
-> 校对：[coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai)
+> 翻译：[vclwei](https://github.com/vclwei), [coverxit](https://github.com/coverxit), [NicePiao](https://github.com/NicePiao), [JackAlan](https://github.com/AlanMelody)
+> 校对：[coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai), [JackAlan](https://github.com/AlanMelody)
 
 # 控制流
 -----------------
@@ -11,19 +11,19 @@
 - [条件语句](#conditional_statement)
 - [控制转移语句（Control Transfer Statements）](#control_transfer_statements)
 
-Swift提供了类似 C 语言的流程控制结构，包括可以多次执行任务的`for`和`while`循环，基于特定条件选择执行不同代码分支的`if`和`switch`语句，还有控制流程跳转到其他代码的`break`和`continue`语句。
+Swift提供了类似 C 语言的流程控制结构，包括可以多次执行任务的`for`和`while`循环，基于特定条件选择执行不同代码分支的`if`、`guard`和`switch`语句，还有控制流程跳转到其他代码的`break`和`continue`语句。
 
-除了 C 语言里面传统的 for 条件递增（`for-condition-increment`）循环，Swift 还增加了`for-in`循环，用来更简单地遍历数组（array），字典（dictionary），区间（range），字符串（string）和其他序列类型。
+除了 C 语言里面传统的 for 循环，Swift 还增加了`for-in`循环，用来更简单地遍历数组（array），字典（dictionary），区间（range），字符串（string）和其他序列类型。
 
-Swift 的`switch`语句比 C 语言中更加强大。在 C 语言中，如果某个 case 不小心漏写了`break`，这个 case 就会贯穿（fallthrough）至下一个 case，Swift 无需写`break`，所以不会发生这种贯穿（fallthrough）的情况。case 还可以匹配更多的类型模式，包括区间匹配（range matching），元组（tuple）和特定类型的描述。`switch`的 case 语句中匹配的值可以是由 case 体内部临时的常量或者变量决定，也可以由`where`分句描述更复杂的匹配条件。
+Swift 的`switch`语句比 C 语言中更加强大。在 C 语言中，如果某个 case 不小心漏写了`break`，这个 case 就会贯穿至下一个 case，Swift 无需写`break`，所以不会发生这种贯穿的情况。case 还可以匹配更多的类型模式，包括区间匹配（range matching），元组（tuple）和特定类型的描述。`switch`的 case 语句中匹配的值可以是由 case 体内部临时的常量或者变量决定，也可以由`where`分句描述更复杂的匹配条件。
 
 <a name="for_loops"></a>
 ## For 循环
 
-`for`循环用来按照指定的次数多次执行一系列语句。Swift 提供两种`for`循环形式：
+Swift 提供两种`for`循环形式以来按照指定的次数多次执行一系列语句：
 
-* `for-in`用来遍历一个区间（range），序列（sequence），集合（collection），系列（progression）里面所有的元素执行一系列语句。
-* for条件递增（`for-condition-increment`）语句，用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。
+* `for-in`循环对一个集合里面的每个元素执行一系列语句。
+* for循环，用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。
 
 <a name="for_in"></a>
 ### For-In
@@ -34,7 +34,7 @@ Swift 的`switch`语句比 C 语言中更加强大。在 C 语言中，如果某
 
 ```swift
 for index in 1...5 {
-    println("\(index) times 5 is \(index * 5)")
+    print("\(index) times 5 is \(index * 5)")
 }
 // 1 times 5 is 5
 // 2 times 5 is 10
@@ -43,13 +43,10 @@ for index in 1...5 {
 // 5 times 5 is 25
 ```
 
-例子中用来进行遍历的元素是一组使用闭区间操作符（`...`）表示的从`1`到`5`的数字。`index`被赋值为闭区间中的第一个数字（`1`），然后循环中的语句被执行一次。在本例中，这个循环只包含一个语句，用来输出当前`index`值所对应的乘 5 乘法表结果。该语句执行后，`index`的值被更新为闭区间中的第二个数字（`2`），之后`println`方法会再执行一次。整个过程会进行到闭区间结尾为止。
+例子中用来进行遍历的元素是一组使用闭区间操作符（`...`）表示的从`1`到`5`的数字。`index`被赋值为闭区间中的第一个数字（`1`），然后循环中的语句被执行一次。在本例中，这个循环只包含一个语句，用来输出当前`index`值所对应的乘 5 乘法表结果。该语句执行后，`index`的值被更新为闭区间中的第二个数字（`2`），之后`print(_:)`函数会再执行一次。整个过程会进行到闭区间结尾为止。
 
 上面的例子中，`index`是一个每次循环遍历开始时被自动赋值的常量。这种情况下，`index`在使用前不需要声明，只需要将它包含在循环的声明中，就可以对其进行隐式声明，而无需使用`let`关键字声明。
 
->注意：
-`index`常量只存在于循环的生命周期里。如果你想在循环完成后访问`index`的值，又或者想让`index`成为一个变量而不是常量，你必须在循环之前自己进行声明。
-
 如果你不需要知道区间内每一项的值，你可以使用下划线（`_`）替代变量名来忽略对值的访问：
 
 ```swift
@@ -59,7 +56,7 @@ var answer = 1
 for _ in 1...power {
     answer *= base
 }
-println("\(base) to the power of \(power) is \(answer)")
+print("\(base) to the power of \(power) is \(answer)")
 // 输出 "3 to the power of 10 is 59049"
 ```
 
@@ -70,7 +67,7 @@ println("\(base) to the power of \(power) is \(answer)")
 ```swift
 let names = ["Anna", "Alex", "Brian", "Jack"]
 for name in names {
-    println("Hello, \(name)!")
+    print("Hello, \(name)!")
 }
 // Hello, Anna!
 // Hello, Alex!
@@ -78,41 +75,27 @@ for name in names {
 // Hello, Jack!
 ```
 
-你也可以通过遍历一个字典来访问它的键值对（key-value pairs）。遍历字典时，字典的每项元素会以`(key, value)`元组的形式返回，你可以在`for-in`循环中使用显式的常量名称来解读`(key, value)`元组。下面的例子中，字典的键（key）解读为常量`animalName`，字典的值会被解读为常量`legCount`：
+你也可以通过遍历一个字典来访问它的键值对。遍历字典时，字典的每项元素会以`(key, value)`元组的形式返回，你可以在`for-in`循环中使用显式的常量名称来解读`(key, value)`元组。下面的例子中，字典的键（key）解读为常量`animalName`，字典的值会被解读为常量`legCount`：
 
 ```swift
 let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
 for (animalName, legCount) in numberOfLegs {
-    println("\(animalName)s have \(legCount) legs")
+    print("\(animalName)s have \(legCount) legs")
 }
-// spiders have 8 legs
 // ants have 6 legs
 // cats have 4 legs
+// spiders have 8 legs
 ```
 
-字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见[集合类型](../chapter2/04_Collection_Types.html)。
+字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见[集合类型](04_Collection_Types.html)。
 
-除了数组和字典，你也可以使用`for-in`循环来遍历字符串中的字符（`Character`）：
-
-```swift
-for character in "Hello" {
-    println(character)
-}
-// H
-// e
-// l
-// l
-// o
-```
-
-<a name="for_condition_increment"></a>
-### For条件递增（for-condition-increment）
+<a name="for"></a>
 
 除了`for-in`循环，Swift 提供使用条件判断和递增方法的标准 C 样式`for`循环:
 
 ```swift
 for var index = 0; index < 3; ++index {
-    println("index is \(index)")
+    print("index is \(index)")
 }
 // index is 0
 // index is 1
@@ -129,30 +112,23 @@ for var index = 0; index < 3; ++index {
 
 这个循环执行流程如下：
 
-1. 循环首次启动时，初始化表达式（_initialization expression_）被调用一次，用来初始化循环所需的所有常量和变量。
-2. 条件表达式（_condition expression_）被调用，如果表达式调用结果为`false`，循环结束，继续执行`for`循环关闭大括号
-（`}`）之后的代码。如果表达式调用结果为`true`，则会执行大括号内部的代码（_statements_）。
-3. 执行所有语句（_statements_）之后，执行递增表达式（_increment expression_）。通常会增加或减少计数器的值，或者根据语句（_statements_）输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第 2 步，条件表达式会再次执行。
+1. 循环首次启动时，初始化表达式被调用一次，用来初始化循环所需的所有常量和变量。
+2. 条件表达式被调用，如果表达式调用结果为`false`，循环结束，继续执行`for`循环关闭大括号
+（`}`）之后的代码。如果表达式调用结果为`true`，则会执行大括号内部的代码。
+3. 执行所有语句之后，执行递增表达式。通常会增加或减少计数器的值，或者根据语句输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第 2 步，条件表达式会再次执行。
 
-上述描述和循环格式等同于：
-
-> `initialization`
-> while `condition` {
->     `statements`
->     `increment`
-> }
 
 在初始化表达式中声明的常量和变量（比如`var index = 0`）只在`for`循环的生命周期里有效。如果想在循环结束后访问`index`的值，你必须要在循环生命周期开始前声明`index`。
 
 ```swift
 var index: Int
 for index = 0; index < 3; ++index {
-    println("index is \(index)")
+    print("index is \(index)")
 }
 // index is 0
 // index is 1
 // index is 2
-println("The loop statements were executed \(index) times")
+print("The loop statements were executed \(index) times")
 // 输出 "The loop statements were executed 3 times
 ```
 
@@ -177,7 +153,7 @@ println("The loop statements were executed \(index) times")
 >     `statements`
 > }
 
-下面的例子来玩一个叫做_蛇和梯子（Snakes and Ladders）_的小游戏，也叫做_滑道和梯子（Chutes and Ladders）_：
+下面的例子来玩一个叫做蛇和梯子的小游戏，也叫做滑道和梯子：
 
 ![image](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/snakesAndLadders_2x.png)
 
@@ -219,7 +195,7 @@ while square < finalSquare {
         square += board[square]
     }
 }
-println("Game over!")
+print("Game over!")
 ```
 
 本例中使用了最简单的方法来模拟掷骰子。 `diceRoll`的值并不是一个随机数，而是以`0`为初始值，之后每一次`while`循环，`diceRoll`的值使用前置自增操作符(`++i`)来自增 1 ，然后检测是否超出了最大值。`++diceRoll`调用完成_后_，返回值等于`diceRoll`自增后的值。任何时候如果`diceRoll`的值等于7时，就超过了骰子的最大值，会被重置为`1`。所以`diceRoll`的取值顺序会一直是`1`，`2`，`3`，`4`，`5`，`6`，`1`，`2`。
@@ -233,18 +209,21 @@ println("Game over!")
 `while` 循环比较适合本例中的这种情况，因为在 `while` 循环开始时，我们并不知道游戏的长度或者循环的次数，只有在达成指定条件时循环才会结束。
 
 
-<a name="do_while"></a>
-###Do-While
+<a name="repeat_while"></a>
+###Repeat-While
 
-`while`循环的另外一种形式是`do-while`，它和`while`的区别是在判断循环条件之前，先执行一次循环的代码块，然后重复循环直到条件为`false`。
+`while`循环的另外一种形式是`repeat-while`，它和`while`的区别是在判断循环条件之前，先执行一次循环的代码块，然后重复循环直到条件为`false`。
 
-下面是一般情况下 `do-while`循环的格式：
+> 注意：
+> Swift语言的`repeat-while`循环合其他语言中的`do-while`循环是类似的。
 
-> do {
+下面是一般情况下 `repeat-while`循环的格式：
+
+> repeat {
 >     `statements`
 > } while `condition`
 
-还是蛇和梯子的游戏，使用`do-while`循环来替代`while`循环。`finalSquare`、`board`、`square`和`diceRoll`的值初始化同`while`循环一样：
+还是蛇和梯子的游戏，使用`repeat-while`循环来替代`while`循环。`finalSquare`、`board`、`square`和`diceRoll`的值初始化同`while`循环一样：
 
 ``` swift
 let finalSquare = 25
@@ -255,12 +234,12 @@ var square = 0
 var diceRoll = 0
 ```
 
-`do-while`的循环版本，循环中_第一步_就需要去检测是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，所以玩家不会通过梯子直接赢得游戏。这样在循环开始时先检测是否踩在梯子或者蛇上是安全的。
+`repeat-while`的循环版本，循环中_第一步_就需要去检测是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，所以玩家不会通过梯子直接赢得游戏。这样在循环开始时先检测是否踩在梯子或者蛇上是安全的。
 
 游戏开始时，玩家在第 0 个方格上，`board[0]`一直等于 0， 不会有什么影响：
 
 ```swift
-do {
+repeat {
     // 顺着梯子爬上去或者顺着蛇滑下去
     square += board[square]
     // 掷骰子
@@ -268,12 +247,12 @@ do {
     // 根据点数移动
     square += diceRoll
 } while square < finalSquare
-println("Game over!")
+print("Game over!")
 ```
 
 检测完玩家是否踩在梯子或者蛇上之后，开始掷骰子，然后玩家向前移动`diceRoll`个方格，本轮循环结束。
 
-循环条件（`while square < finalSquare`）和`while`方式相同，但是只会在循环结束后进行计算。在这个游戏中，`do-while`表现得比`while`循环更好。`do-while`方式会在条件判断`square`没有超出后直接运行`square += board[square]`，这种方式可以去掉`while`版本中的数组越界判断。
+循环条件（`while square < finalSquare`）和`while`方式相同，但是只会在循环结束后进行计算。在这个游戏中，`repeat-while`表现得比`while`循环更好。`repeat-while`方式会在条件判断`square`没有超出后直接运行`square += board[square]`，这种方式可以去掉`while`版本中的数组越界判断。
 
 <a name="conditional_statement"></a>
 ## 条件语句
@@ -290,7 +269,7 @@ Swift 提供两种类型的条件语句：`if`语句和`switch`语句。通常
 ```swift
 var temperatureInFahrenheit = 30
 if temperatureInFahrenheit <= 32 {
-    println("It's very cold. Consider wearing a scarf.")
+    print("It's very cold. Consider wearing a scarf.")
 }
 // 输出 "It's very cold. Consider wearing a scarf."
 ```
@@ -302,9 +281,9 @@ if temperatureInFahrenheit <= 32 {
 ```swift
 temperatureInFahrenheit = 40
 if temperatureInFahrenheit <= 32 {
-    println("It's very cold. Consider wearing a scarf.")
+    print("It's very cold. Consider wearing a scarf.")
 } else {
-    println("It's not that cold. Wear a t-shirt.")
+    print("It's not that cold. Wear a t-shirt.")
 }
 // 输出 "It's not that cold. Wear a t-shirt."
 ```
@@ -316,11 +295,11 @@ if temperatureInFahrenheit <= 32 {
 ```swift
 temperatureInFahrenheit = 90
 if temperatureInFahrenheit <= 32 {
-    println("It's very cold. Consider wearing a scarf.")
+    print("It's very cold. Consider wearing a scarf.")
 } else if temperatureInFahrenheit >= 86 {
-    println("It's really warm. Don't forget to wear sunscreen.")
+    print("It's really warm. Don't forget to wear sunscreen.")
 } else {
-    println("It's not that cold. Wear a t-shirt.")
+    print("It's not that cold. Wear a t-shirt.")
 }
 // 输出 "It's really warm. Don't forget to wear sunscreen."
 ```
@@ -330,11 +309,11 @@ if temperatureInFahrenheit <= 32 {
 实际上，最后的`else`语句是可选的：
 
 ```swift
-temperatureInFahrenheit = 72
+temperatureInFahrenheit = 90
 if temperatureInFahrenheit <= 32 {
-    println("It's very cold. Consider wearing a scarf.")
+    print("It's very cold. Consider wearing a scarf.")
 } else if temperatureInFahrenheit >= 86 {
-    println("It's really warm. Don't forget to wear sunscreen.")
+    print("It's really warm. Don't forget to wear sunscreen.")
 }
 ```
 
@@ -361,7 +340,7 @@ if temperatureInFahrenheit <= 32 {
 
 每一个 case 都是代码执行的一条分支，这与`if`语句类似。与之不同的是，`switch`语句会决定哪一条分支应该被执行。
 
-`switch`语句必须是_完备的_。这就是说，每一个可能的值都必须至少有一个 case 分支与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认（`default`）分支满足该要求，这个默认分支必须在`switch`语句的最后面。
+`switch`语句必须是完备的。这就是说，每一个可能的值都必须至少有一个 case 分支与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认（`default`）分支满足该要求，这个默认分支必须在`switch`语句的最后面。
 
 下面的例子使用`switch`语句来匹配一个名为`someCharacter`的小写字符：
 
@@ -369,12 +348,12 @@ if temperatureInFahrenheit <= 32 {
 let someCharacter: Character = "e"
 switch someCharacter {
 case "a", "e", "i", "o", "u":
-    println("\(someCharacter) is a vowel")
+    print("\(someCharacter) is a vowel")
 case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
 "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
-    println("\(someCharacter) is a consonant")
+    print("\(someCharacter) is a consonant")
 default:
-    println("\(someCharacter) is not a vowel or a consonant")
+    print("\(someCharacter) is not a vowel or a consonant")
 }
 // 输出 "e is a vowel"
 ```
@@ -389,7 +368,7 @@ default:
 与 C 语言和 Objective-C 中的`switch`语句不同，在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用`break`语句。这使得`switch`语句更安全、更易用，也避免了因忘记写`break`语句而产生的错误。
 
 > 注意：
-你依然可以在 case 分支中的代码执行完毕前跳出，详情请参考[Switch 语句中的 break](#break_in_a_switch_statement)。
+虽然在Swift中`break`不是必须的，但你依然可以在 case 分支中的代码执行完毕前使用`break`跳出，详情请参见[Switch 语句中的 break](#break_in_a_switch_statement)。
 
 每一个 case 分支都*必须*包含至少一条语句。像下面这样书写代码是无效的，因为第一个 case 分支是空的：
 
@@ -398,9 +377,9 @@ let anotherCharacter: Character = "a"
 switch anotherCharacter {
 case "a":
 case "A":
-    println("The letter A")
+    print("The letter A")
 default:
-    println("Not the letter A")
+    print("Not the letter A")
 }
 // this will report a compile-time error
 ```
@@ -418,39 +397,42 @@ default:
 > 注意：
 如果想要贯穿至特定的 case 分支中，请使用`fallthrough`语句，详情请参考[贯穿（Fallthrough）](#fallthrough)。
 
-<a name="range_matching"></a>
-#### 区间匹配（Range Matching）
+<a name="interval_matching"></a>
+#### 区间匹配
 
 case 分支的模式也可以是一个值的区间。下面的例子展示了如何使用区间匹配来输出任意数字对应的自然语言格式：
 
-```swift
-let count = 3_000_000_000_000
-let countedThings = "stars in the Milky Way"
+```
+let approximateCount = 62
+let countedThings = "moons orbiting Saturn"
 var naturalCount: String
-switch count {
+switch approximateCount {
 case 0:
     naturalCount = "no"
-case 1...3:
+case 1..<5:
     naturalCount = "a few"
-case 4...9:
+case 5..<12:
     naturalCount = "several"
-case 10...99:
-    naturalCount = "tens of"
-case 100...999:
+case 12..<100:
+    naturalCount = "dozens of"
+case 100..<1000:
     naturalCount = "hundreds of"
-case 1000...999_999:
-    naturalCount = "thousands of"
 default:
-    naturalCount = "millions and millions of"
+    naturalCount = "many"
 }
-println("There are \(naturalCount) \(countedThings).")
-// 输出 "There are millions and millions of stars in the Milky Way."
+print("There are \(naturalCount) \(countedThings).")
+// 输出 "There are dozens of moons orbiting Saturn."
 ```
 
+在上例中，`approximateCount`在一个`switch`声明中被估值。每一个`case`都与之进行比较。因为`approximateCount`落在了12到100的区间，所以`naturalCount`等于`"dozens of"`值，并且此后这段执行跳出了`switch`声明。
+
+> 注意：
+> 闭区间操作符(`...`)以及半开区间操作符(`..<`)功能被重载去返回`IntervalType`或`Range`。一个区间可以决定他是否包含特定的元素，就像当匹配一个`switch`声明的`case`一样。区间是一个连续值的集合，可以用`for-in`语句遍历它。
+
 <a name="tuples"></a>
 #### 元组（Tuple）
 
-你可以使用元组在同一个`switch`语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（`_`）来匹配所有可能的值。
+我们可以使用元组在同一个`switch`语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（`_`）来匹配所有可能的值。
 
 下面的例子展示了如何使用一个`(Int, Int)`类型的元组来分类下图中的点(x, y)：
 
@@ -458,15 +440,15 @@ println("There are \(naturalCount) \(countedThings).")
 let somePoint = (1, 1)
 switch somePoint {
 case (0, 0):
-    println("(0, 0) is at the origin")
+    print("(0, 0) is at the origin")
 case (_, 0):
-    println("(\(somePoint.0), 0) is on the x-axis")
+    print("(\(somePoint.0), 0) is on the x-axis")
 case (0, _):
-    println("(0, \(somePoint.1)) is on the y-axis")
+    print("(0, \(somePoint.1)) is on the y-axis")
 case (-2...2, -2...2):
-    println("(\(somePoint.0), \(somePoint.1)) is inside the box")
+    print("(\(somePoint.0), \(somePoint.1)) is inside the box")
 default:
-    println("(\(somePoint.0), \(somePoint.1)) is outside of the box")
+    print("(\(somePoint.0), \(somePoint.1)) is outside of the box")
 }
 // 输出 "(1, 1) is inside the box"
 ```
@@ -489,11 +471,11 @@ case 分支的模式允许将匹配的值绑定到一个临时的常量或变量
 let anotherPoint = (2, 0)
 switch anotherPoint {
 case (let x, 0):
-    println("on the x-axis with an x value of \(x)")
+    print("on the x-axis with an x value of \(x)")
 case (0, let y):
-    println("on the y-axis with a y value of \(y)")
+    print("on the y-axis with a y value of \(y)")
 case let (x, y):
-    println("somewhere else at (\(x), \(y))")
+    print("somewhere else at (\(x), \(y))")
 }
 // 输出 "on the x-axis with an x value of 2"
 ```
@@ -504,7 +486,7 @@ case let (x, y):
 
 这三个 case 都声明了常量`x`和`y`的占位符，用于临时获取元组`anotherPoint`的一个或两个值。第一个 case ——`case (let x, 0)`将匹配一个纵坐标为`0`的点，并把这个点的横坐标赋给临时的常量`x`。类似的，第二个 case ——`case (0, let y)`将匹配一个横坐标为`0`的点，并把这个点的纵坐标赋给临时的常量`y`。
 
-一旦声明了这些临时的常量，它们就可以在其对应的 case 分支里引用。在这个例子中，它们用于简化`println`的书写。
+一旦声明了这些临时的常量，它们就可以在其对应的 case 分支里引用。在这个例子中，它们用于简化`print(_:)`的书写。
 
 请注意，这个`switch`语句不包含默认分支。这是因为最后一个 case ——`case let(x, y)`声明了一个可以匹配余下所有值的元组。这使得`switch`语句已经完备了，因此不需要再书写默认分支。
 
@@ -521,11 +503,11 @@ case 分支的模式可以使用`where`语句来判断额外的条件。
 let yetAnotherPoint = (1, -1)
 switch yetAnotherPoint {
 case let (x, y) where x == y:
-    println("(\(x), \(y)) is on the line x == y")
+    print("(\(x), \(y)) is on the line x == y")
 case let (x, y) where x == -y:
-    println("(\(x), \(y)) is on the line x == -y")
+    print("(\(x), \(y)) is on the line x == -y")
 case let (x, y):
-    println("(\(x), \(y)) is just some arbitrary point")
+    print("(\(x), \(y)) is just some arbitrary point")
 }
 // 输出 "(1, -1) is on the line x == -y"
 ```
@@ -543,20 +525,20 @@ case let (x, y):
 
 控制转移语句改变你代码的执行顺序，通过它你可以实现代码的跳转。Swift有四种控制转移语句。
 
-- continue
-- break
-- fallthrough
-- return
+- `continue`
+- `break`
+- `fallthrough`
+- `return`
 
-我们将会在下面讨论`continue`、`break`和`fallthrough`语句。`return`语句将会在[函数](../chapter2/06_Functions.html)章节讨论。
+我们将会在下面讨论`continue`、`break`和`fallthrough`语句。`return`语句将会在[函数](06_Functions.html)章节讨论。
 
 <a name="continue"></a>
 ### Continue
 
 `continue`语句告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。就好像在说“本次循环迭代我已经执行完了”，但是并不会离开整个循环体。
 
->注意：
-在一个for条件递增（`for-condition-increment`）循环体中，在调用`continue`语句后，迭代增量仍然会被计算求值。循环体继续像往常一样工作，仅仅只是循环体中的执行代码会被跳过。
+> 注意：
+> 在一个带有条件和递增的for循环体中，调用`continue`语句后，迭代增量仍然会被计算求值。循环体继续像往常一样工作，仅仅只是循环体中的执行代码会被跳过。
 
 下面的例子把一个小写字符串中的元音字母和空格字符移除，生成了一个含义模糊的短句：
 
@@ -571,7 +553,7 @@ for character in puzzleInput {
         puzzleOutput.append(character)
     }
 }
-println(puzzleOutput)
+print(puzzleOutput)
     // 输出 "grtmndsthnklk"
 ```
 
@@ -615,9 +597,9 @@ default:
     break
 }
 if let integerValue = possibleIntegerValue {
-    println("The integer value of \(numberSymbol) is \(integerValue).")
+    print("The integer value of \(numberSymbol) is \(integerValue).")
 } else {
-    println("An integer value could not be found for \(numberSymbol).")
+    print("An integer value could not be found for \(numberSymbol).")
 }
 // 输出 "The integer value of 三 is 3."
 ```
@@ -633,7 +615,7 @@ if let integerValue = possibleIntegerValue {
 
 Swift 中的`switch`不会从上一个 case 分支落入到下一个 case 分支中。相反，只要第一个匹配到的 case 分支完成了它需要执行的语句，整个`switch`代码块完成了它的执行。相比之下，C 语言要求你显示的插入`break`语句到每个`switch`分支的末尾来阻止自动落入到下一个 case 分支中。Swift 的这种避免默认落入到下一个分支中的特性意味着它的`switch` 功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个 case 分支从而引发的错误。
 
-如果你确实需要 C 风格的贯穿（fallthrough）的特性，你可以在每个需要该特性的 case 分支中使用`fallthrough`关键字。下面的例子使用`fallthrough`来创建一个数字的描述语句。
+如果你确实需要 C 风格的贯穿的特性，你可以在每个需要该特性的 case 分支中使用`fallthrough`关键字。下面的例子使用`fallthrough`来创建一个数字的描述语句。
 
 ```swift
 let integerToDescribe = 5
@@ -645,7 +627,7 @@ case 2, 3, 5, 7, 11, 13, 17, 19:
 default:
     description += " an integer."
 }
-println(description)
+print(description)
 // 输出 "The number 5 is a prime number, and also an integer."
 ```
 
@@ -653,13 +635,13 @@ println(description)
 
 如果`integerToDescribe`的值不属于列表中的任何质数，那么它不会匹配到第一个`switch`分支。而这里没有其他特别的分支情况，所以`integerToDescribe`匹配到包含所有的`default`分支中。
 
-当`switch`代码块执行完后，使用`println`函数打印该数字的描述。在这个例子中，数字`5`被准确的识别为了一个质数。
+当`switch`代码块执行完后，使用`print`函数打印该数字的描述。在这个例子中，数字`5`被准确的识别为了一个质数。
 
->注意：
-`fallthrough`关键字不会检查它下一个将会落入执行的 case 中的匹配条件。`fallthrough`简单地使代码执行继续连接到下一个 case 中的执行代码，这和 C 语言标准中的`switch`语句特性是一样的。
+> 注意：
+> `fallthrough`关键字不会检查它下一个将会落入执行的 case 中的匹配条件。`fallthrough`简单地使代码执行继续连接到下一个 case 中的执行代码，这和 C 语言标准中的`switch`语句特性是一样的。
 
 <a name="labeled_statements"></a>
-### 带标签的语句（Labeled Statements）
+### 带标签的语句
 
 在 Swift 中，你可以在循环体和`switch`代码块中嵌套循环体和`switch`代码块来创造复杂的控制流结构。然而，循环体和`switch`代码块两者都可以使用`break`语句来提前结束整个方法体。因此，显示地指明`break`语句想要终止的是哪个循环体或者`switch`代码块，会很有用。类似地，如果你有许多嵌套的循环体，显示指明`continue`语句想要影响哪一个循环体也会非常有用。
 
@@ -671,9 +653,9 @@ println(description)
 >     `statements`
 > }
 
-下面的例子是在一个带有标签的`while`循环体中调用`break`和`continue`语句，该循环体是前面章节中_蛇和梯子_的改编版本。这次，游戏增加了一条额外的规则：
+下面的例子是在一个带有标签的`while`循环体中调用`break`和`continue`语句，该循环体是前面章节中*蛇和梯子*的改编版本。这次，游戏增加了一条额外的规则：
 
-- 为了获胜，你必须_刚好_落在第 25 个方块中。
+- 为了获胜，你必须*刚好*落在第 25 个方块中。
 
 如果某次掷骰子使你的移动超出第 25 个方块，你必须重新掷骰子，直到你掷出的骰子数刚好使你能落在第 25 个方块中。
 
@@ -681,7 +663,7 @@ println(description)
 
 ![image](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/snakesAndLadders_2x.png)
 
-值`finalSquare`、`board`、`square`和`diceRoll`的初始化也和之前一样：
+`finalSquare`、`board`、`square`和`diceRoll`值被和之前一样的方式初始化：
 
 ```swift
 let finalSquare = 25
@@ -712,7 +694,7 @@ gameLoop: while square != finalSquare {
         square += board[square]
     }
 }
-println("Game over!")
+print("Game over!")
 ```
 
 每次循环迭代开始时掷骰子。与之前玩家掷完骰子就立即移动不同，这里使用了`switch`来考虑每次移动可能产生的结果，从而决定玩家本次是否能够移动。
@@ -724,3 +706,65 @@ println("Game over!")
 >注意：
 如果上述的`break`语句没有使用`gameLoop`标签，那么它将会中断`switch`代码块而不是`while`循环体。使用`gameLoop`标签清晰的表明了`break`想要中断的是哪个代码块。
 同时请注意，当调用`continue gameLoop`去跳转到下一次循环迭代时，这里使用`gameLoop`标签并不是严格必须的。因为在这个游戏中，只有一个循环体，所以`continue`语句会影响到哪个循环体是没有歧义的。然而，`continue`语句使用`gameLoop`标签也是没有危害的。这样做符合标签的使用规则，同时参照旁边的`break gameLoop`，能够使游戏的逻辑更加清晰和易于理解。
+
+<a name="early_exit"></a>
+### 提前退出
+
+像`if`语句一样，`guard`的执行取决于一个表达式的布尔值。我们可以使用`guard`语句来要求条件必须为真时，以执行`guard`语句后的代码。不同于`if`语句，一个`guard`语句总是有一个`else`分句，如果条件不为真则执行`else`分局中的代码。
+
+```swift
+func greet(person: [String: String]) {
+	guard let name = person["name"] else {
+		return
+	}
+	print("Hello \(name)")
+
+	guard let location = person["location"] else {
+		print("I hope the weather is nice near you.")
+		return
+	}
+	print("I hope the weather is nice in \(location).")
+}
+greet(["name": "John"])
+// prints "Hello John!"
+// prints "I hope the weather is nice near you."
+greet(["name": "Jane", "location": "Cupertino"])
+// prints "Hello Jane!"
+// prints "I hope the weather is nice in Cupertino."
+```
+
+如果`guard`语句的条件被满足，则在保护语句的封闭大括号结束后继续执行代码。任何使用了可选绑定作为条件的一部分并被分配了值的变量或常量对于剩下的保护语句出现的代码段是可用的。
+
+如果条件不被满足，在`else`分支上的代码就会被执行。这个分支必须转移控制以退出`guard`语句出现的代码段。它可以用控制转移语句如`return`,`break`或`continue`做这件事，或者它调用了一个不返回的方法或函数，例如`fatalError()`。
+
+相比于可以实现同样功能的`if`语句，按需使用`guard`语句会提升我们代码的可靠性。
+它可以使你的代码连贯的被执行而不需要将它包在`else`块中，它可以使你处理违反要求的代码接近要求。
+
+<a name="checking_api_availability"></a>
+### 检测API是否可用
+
+Swift 有内置支持去检查接口的可用性的，这可以确保我们不会不小心地使用对于当前部署目标不可用的API。
+
+编译器使用SDK中的可用信息来验证在我们在可用部署目标指定项目的代码中所有的API调用。如果我们尝试使用一个不可用的API，Swift会在编译期报错。
+
+我们使用一个可用性条件在一个`if`或`guard`语句中去有条件的执行一段代码，这取决于我们想要使用的API是否在运行时是可用的。编译器使用从可用性条件语句中获取的信息，这时它会去验证在代码块中调用的API是否都可用。
+
+```swift
+if #available(iOS 9, OSX 10.10, *) {
+    // 在 iOS 使用 iOS 9 APIs , 并且在 OS X 使用 OS X v10.10 APIs 
+} else {
+    // 回滚至早前 iOS and OS X 的API
+}
+```
+
+以上可用性条件指定在iOS，`if`段的代码仅仅在iOS9及更高可运行；在OS X，仅在OS X v10.10及更高可运行。最后一个参数，`*`，是必须的并且指定在任何其他平台上，`if`段的代码在最小可用部署目标指定项目中执行。
+
+在它普遍的形式中，可用性条件获取了平台名字和版本的清单。平台名字可以是`iOS`，`OSX`或`watchOS`。除了特定的主板本号像iOS8，我们可以指定较小的版本号像iOS8.3以及 OS X v10.10.3。
+
+```swift
+if #available(`platform name` `version`, `...`, *) {
+    `statements to execute if the APIs are available`
+} else {
+    `fallback statements to execute if the APIs are unavailable`
+}
+```
\ No newline at end of file

From c7d78d52609a5355a196b529e4096baf587a8fc5 Mon Sep 17 00:00:00 2001
From: Wentao <wentao@WentaodeiMac.local>
Date: Mon, 20 Jul 2015 21:08:46 +0800
Subject: [PATCH 124/228] =?UTF-8?q?=E7=B1=BB=E5=92=8C=E7=BB=93=E6=9E=84?=
 =?UTF-8?q?=E4=BD=93=E9=80=90=E5=AD=97=E7=BF=BB=E8=AF=91=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/09_Classes_and_Structures.md | 41 ++++++++++----------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index f95de7d5..a468b995 100755
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -1,5 +1,5 @@
-> 翻译：[JaySurplus](https://github.com/JaySurplus)
-> 校对：[sg552](https://github.com/sg552)
+> 翻译：[JaySurplus](https://github.com/JaySurplus),[SkyJean](https://github.com/SkyJean)
+> 校对：[sg552](https://github.com/sg552),[SkyJean](https://github.com/SkyJean)
 
 # 类和结构体
 
@@ -9,9 +9,10 @@
 - [结构体和枚举是值类型](#structures_and_enumerations_are_value_types)
 - [类是引用类型](#classes_are_reference_types)
 - [类和结构体的选择](#choosing_between_classes_and_structures)
-- [集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types)
+- [字符串(String)、数组(Array)、和字典(Dictionary)类型的赋值与复制行为](#assignment_and_copy_behavior_for_strings_arrays_and_dictionaries)
 
-类和结构体是人们构建代码所用的一种通用且灵活的构造体。为了在类和结构体中实现各种功能，我们必须要严格按照常量、变量以及函数所规定的语法规则来定义属性和添加方法。
+
+类和结构体是人们构建代码所用的一种通用且灵活的构造体。我们可以使用完全相同的语法规则来为类和结构体定义属性（常量、变量）和添加方法，从而扩展类和结构体的功能。
 
 与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口。
 
@@ -28,7 +29,7 @@ Swift 中类和结构体有很多共同点。共同处在于：
 * 定义附属脚本用于访问值
 * 定义构造器用于生成初始化值
 * 通过扩展以增加默认实现的功能
-* 符合协议以对某类提供标准功能
+* 实现协议以提供某种标准功能
 
 更多信息请参见 [属性](10_Properties.html)，[方法](11_Methods.html)，[下标脚本](12_Subscripts.html)，[初始过程](14_Initialization.html)，[扩展](20_Extensions.html)，和[协议](21_Protocols.html)。
 
@@ -39,7 +40,7 @@ Swift 中类和结构体有很多共同点。共同处在于：
 * 解构器允许一个类实例释放任何其所被分配的资源
 * 引用计数允许对一个类的多次引用
 
-更多信息请参见[继承](http://)，[类型转换](http://)，[初始化](http://)，和[自动引用计数](http://)。
+更多信息请参见[继承](13_Inheritance.html)，[类型转换](20_Type_Casting.html)，[析构过程](15_Deinitialization)，和[自动引用计数](16_Automatic_Reference_Counting)。
 
 > 注意：
 结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
@@ -77,7 +78,7 @@ class VideoMode {
 
 在上面的示例中我们定义了一个名为`Resolution`的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为`width`和`height`的存储属性。存储属性是捆绑和存储在类或结构体中的常量或变量。当这两个属性被初始化为整数`0`的时候，它们会被推断为`Int`类型。
 
-在上面的示例中我们还定义了一个名为`VideoMode`的类，用来描述一个视频显示器的特定模式。这个类包含了四个储存属性变量。第一个是`分辨率`，它被初始化为一个新的`Resolution`结构体的实例，具有`Resolution`的属性类型。新`VideoMode`实例同时还会初始化其它三个属性，它们分别是，初始值为`false`(意为“non-interlaced video”)的`interlaced`，回放帧率初始值为`0.0`的`frameRate`和值为可选`String`的`name`。`name`属性会被自动赋予一个默认值`nil`，意为“没有`name`值”，因为它是一个可选类型。
+在上面的示例中我们还定义了一个名为`VideoMode`的类，用来描述一个视频显示器的特定模式。这个类包含了四个储存属性变量。第一个是`分辨率`，它被初始化为一个新的`Resolution`结构体的实例，具有`Resolution`的属性类型。新`VideoMode`实例同时还会初始化其它三个属性，它们分别是，初始值为`false`(意为“非隔行扫描视频”)的`interlaced`，回放帧率初始值为`0.0`的`frameRate`和值为可选`String`的`name`。`name`属性会被自动赋予一个默认值`nil`，意为“没有`name`值”，因为它是一个可选类型。
 
 ### 类和结构体实例
 
@@ -90,7 +91,7 @@ let someResolution = Resolution()
 let someVideoMode = VideoMode()
 ```
 
-结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
+结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
 
 ### 属性访问
 
@@ -121,9 +122,9 @@ println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
 >  注意：
 与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要重新设置`resolution`属性。
 
-### 结构体类型的成员逐一构造器(Memberwise Initializers for structure Types)
+### 结构体类型的成员逐一构造器(Memberwise Initializers for Structure Types)
 
-所有结构体都有一个自动生成的成员逐一构造器，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中：
+所有结构体都有一个自动生成的*成员逐一构造器*，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一构造器之中：
 
 ```swift
 let vga = Resolution(width:640, height: 480)
@@ -134,11 +135,11 @@ let vga = Resolution(width:640, height: 480)
 <a name="structures_and_enumerations_are_value_types"></a>
 ## 结构体和枚举是值类型
 
-值类型被赋予给一个变量，常数或者本身被传递给一个函数的时候，实际上操作的是其的拷贝。
+*值类型*被赋予给一个变量、常量或者本身被传递给一个函数的时候，实际上操作的是其的*拷贝*。
 
-在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数（Integer）、浮点数（floating-point）、布尔值（Booleans）、字符串（string)、数组（array）和字典（dictionaries），都是值类型，并且都是以结构体的形式在后台所实现。
+在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数（Integer）、浮点数（floating-point）、布尔值（Boolean）、字符串（string)、数组（array）和字典（dictionary），都是值类型，并且都是以结构体的形式在后台所实现。
 
-在 Swift 中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
+在 Swift 中，所有的结构体和枚举类型都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
 
 请看下面这个示例，其使用了前一个示例中`Resolution`结构体：
 
@@ -171,7 +172,7 @@ println("hd is still \(hd.width	) pixels wide")
 // 输出 "hd is still 1920 pixels wide"
 ```
 
-在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所存储的`值（values）`进行拷贝，然后将拷贝的数据存储到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的宽（width）。
+在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所存储的`值（values）`进行拷贝，然后将拷贝的数据存储到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的`width`的值。
 
 枚举也遵循相同的行为准则：
 
@@ -252,7 +253,7 @@ if tenEighty === alsoTenEighty {
 
 ### 指针
 
-如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与 C 语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号（*）来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。
+如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用*指针*来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与 C 语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号（*）来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。
 
 <a name="choosing_between_classes_and_structures"></a>
 ## 类和结构体的选择
@@ -268,7 +269,7 @@ if tenEighty === alsoTenEighty {
 * 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
 * 结构体不需要去继承另一个已存在类型的属性或者行为。
 
-合适的结构体候选者包括：
+举例来说，以下情境中适合使用结构体：
 
 * 几何形状的大小，封装一个`width`属性和`height`属性，两者均为`Double`类型。
 * 一定范围内的路径，封装一个`start`属性和`length`属性，两者均为`Int`类型。
@@ -276,15 +277,15 @@ if tenEighty === alsoTenEighty {
 
 在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。
 
-<a name="assignment_and_copy_behavior_for_collection_types"></a>
-## 集合（Collection）类型的赋值和拷贝行为
+<a name="assignment_and_copy_behavior_for_strings_arrays_and_dictionaries"></a>
+## 字符串(String)、数组(Array)、和字典(Dictionary)类型的赋值与复制行为
 
-Swift 中`字符串（String）`,`数组（Array）`和`字典（Dictionary）`类型均以结构体的形式实现。这意味着String，Array，Dictionary类型数据被赋值给新的常量(或变量），或者被传入函数（或方法）中时，它们的值会发生拷贝行为（值传递方式）。
+Swift 中`字符串（String）`,`数组（Array）`和`字典（Dictionary）`类型均以结构体的形式实现。这意味着String，Array，Dictionary类型数据被赋值给新的常量或变量，或者被传入函数或方法中时，它们的值会发生拷贝行为（值传递方式）。
 
 Objective-C中`字符串（NSString）`,`数组（NSArray）`和`字典（NSDictionary）`类型均以类的形式实现，这与Swfit中以值传递方式是不同的。NSString，NSArray，NSDictionary在发生赋值或者传入函数（或方法）时，不会发生值拷贝，而是传递已存在实例的引用。
 
 
 > 注意：
-以上是对于数组，字典，字符串和其它值的`拷贝`的描述。
+以上是对于字符串、数组、字典和其它值的`拷贝`的描述。
 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在 Swift 的后台中，只有确有必要，`实际（actual）`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。（实际赋值由系统管理优化）
 

From 0779f979ac71cb840ddd73a4740e5fdeca05b602 Mon Sep 17 00:00:00 2001
From: chenyc <chen.yangcun@xiaoyi.com>
Date: Tue, 21 Jul 2015 17:34:44 +0800
Subject: [PATCH 125/228] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E9=9B=86=E5=90=88?=
 =?UTF-8?q?=E7=B1=BB=E5=9E=8B=E5=9C=A8Swift=202.0=20sort=E6=96=B9=E6=B3=95?=
 =?UTF-8?q?=E7=9A=84=E4=BD=BF=E7=94=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/04_Collection_Types.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index 21db0b85..c8795de5 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -35,7 +35,7 @@ Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更
 
 > 注意:
  Swift 的`Array`类型被桥接到`Foundation`中的`NSArray`类。
- 更多关于在`Foundation`和`Cocoa`中使用`Array`的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。 
+ 更多关于在`Foundation`和`Cocoa`中使用`Array`的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。
 
 <a name="array_type_shorthand_syntax"></a>
 ### 数组的简单语法
@@ -395,10 +395,10 @@ for genre in favoriteGenres {
 
 更多关于`for-in`循环信息，参见[For循环](05_Control_Flow.html#for_loops)。
 
-Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中值可以使用`sorted()`方法，它将根据提供的序列返回一个排序的集合.
+Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中值可以使用`sort()`方法，它将根据提供的序列返回一个排序的集合.
 
 ```swift
-for genre in sorted(favoriteGenres) {
+for genre in favoriteGenres.sort() {
     print("\(genre)")
 }
 // prints "Classical"
@@ -427,13 +427,13 @@ for genre in sorted(favoriteGenres) {
 let oddDigits: Set = [1, 3, 5, 7, 9]
 let evenDigits: Set = [0, 2, 4, 6, 8]
 let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
-sorted(oddDigits.union(evenDigits))
+oddDigits.union(evenDigits).sort()
 // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-sorted(oddDigits.intersect(evenDigits))
+oddDigits.intersect(evenDigits).sort()
 // []
-sorted(oddDigits.subtract(singleDigitPrimeNumbers))
+oddDigits.subtract(singleDigitPrimeNumbers).sort()
 // [1, 9]
-sorted(oddDigits.exclusiveOr(singleDigitPrimeNumbers))
+oddDigits.exclusiveOr(singleDigitPrimeNumbers).sort()
 // [1, 2, 9]
 ```
 

From 1ffaef1bd577e10b44e3c591e2e729f63910bf05 Mon Sep 17 00:00:00 2001
From: chenyc <chen.yangcun@xiaoyi.com>
Date: Tue, 21 Jul 2015 17:35:04 +0800
Subject: [PATCH 126/228] =?UTF-8?q?=E6=9B=BF=E6=8D=A2println=20=E4=B8=BA?=
 =?UTF-8?q?=20print?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/01_The_Basics.md              |  50 +++---
 source/chapter2/02_Basic_Operators.md         |  38 ++---
 source/chapter2/03_Strings_and_Characters.md  | 156 +++++++++---------
 source/chapter2/05_Control_Flow.md            |   4 +-
 source/chapter2/06_Functions.md               |  14 +-
 source/chapter2/09_Classes_and_Structures.md  |  17 +-
 source/chapter2/11_Methods.md                 |   4 +-
 source/chapter2/12_Subscripts.md              |   2 +-
 source/chapter2/13_Inheritance.md             |  19 +--
 source/chapter2/14_Initialization.md          |  57 ++++---
 source/chapter2/15_Deinitialization.md        |  12 +-
 .../16_Automatic_Reference_Counting.md        |   3 +-
 source/chapter2/17_Optional_Chaining.md       |  40 ++---
 source/chapter2/19_Nested_Types.md            |   3 +-
 source/chapter2/21_Extensions.md              |  12 +-
 source/chapter2/24_Access_Control.md          |   7 +-
 16 files changed, 214 insertions(+), 224 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 3fb8fee5..65f1c0d6 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -121,28 +121,28 @@ languageName = "Swift++"
 
 ### 输出常量和变量
 
-你可以用`println`函数来输出当前常量或变量的值:
+你可以用`print`函数来输出当前常量或变量的值:
 
 ```swift
-println(friendlyWelcome)
+print(friendlyWelcome)
 // 输出 "Bonjour!"
 ```
 
-`println`是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，`println`将会输出内容到“console”面板上。(另一种函数叫`print`，唯一区别是在输出内容最后不会换行。)
+`print`是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，`print`将会输出内容到“console”面板上。(另一种函数叫`print`，唯一区别是在输出内容最后不会换行。)
 
-`println`函数输出传入的`String`值：
+`print`函数输出传入的`String`值：
 
 ```swift
-println("This is a string")
+print("This is a string")
 // 输出 "This is a string"
 ```
 
-与 Cocoa 里的`NSLog`函数类似的是，`println`函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。
+与 Cocoa 里的`NSLog`函数类似的是，`print`函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。
 
 Swift 用_字符串插值（string interpolation）_的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：
 
 ```swift
-println("The current value of friendlyWelcome is \(friendlyWelcome)")
+print("The current value of friendlyWelcome is \(friendlyWelcome)")
 // 输出 "The current value of friendlyWelcome is Bonjour!
 ```
 
@@ -181,7 +181,7 @@ Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠
 与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号（`;`），当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句：
 
 ```swift
-let cat = "🐱"; println(cat)
+let cat = "🐱"; print(cat)
 // 输出 "🐱"
 ```
 
@@ -409,9 +409,9 @@ let turnipsAreDelicious = false
 
 ```swift
 if turnipsAreDelicious {
-    println("Mmm, tasty turnips!")
+    print("Mmm, tasty turnips!")
 } else {
-    println("Eww, turnips are horrible.")
+    print("Eww, turnips are horrible.")
 }
 // 输出 "Eww, turnips are horrible."
 ```
@@ -460,9 +460,9 @@ let http404Error = (404, "Not Found")
 
 ```swift
 let (statusCode, statusMessage) = http404Error
-println("The status code is \(statusCode)")
+print("The status code is \(statusCode)")
 // 输出 "The status code is 404"
-println("The status message is \(statusMessage)")
+print("The status message is \(statusMessage)")
 // 输出 "The status message is Not Found"
 ```
 
@@ -470,16 +470,16 @@ println("The status message is \(statusMessage)")
 
 ```swift
 let (justTheStatusCode, _) = http404Error
-println("The status code is \(justTheStatusCode)")
+print("The status code is \(justTheStatusCode)")
 // 输出 "The status code is 404"
 ```
 
 此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：
 
 ```swift
-println("The status code is \(http404Error.0)")
+print("The status code is \(http404Error.0)")
 // 输出 "The status code is 404"
-println("The status message is \(http404Error.1)")
+print("The status message is \(http404Error.1)")
 // 输出 "The status message is Not Found"
 ```
 
@@ -492,9 +492,9 @@ let http200Status = (statusCode: 200, description: "OK")
 给元组中的元素命名后，你可以通过名字来获取这些元素的值：
 
 ```swift
-println("The status code is \(http200Status.statusCode)")
+print("The status code is \(http200Status.statusCode)")
 // 输出 "The status code is 200"
-println("The status message is \(http200Status.description)")
+print("The status message is \(http200Status.description)")
 // 输出 "The status message is OK"
 ```
 
@@ -537,9 +537,9 @@ let convertedNumber = possibleNumber.toInt()
 
 ```swift
 if convertedNumber != nil {
-    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
+    print("\(possibleNumber) has an integer value of \(convertedNumber!)")
 } else {
-    println("\(possibleNumber) could not be converted to an integer")
+    print("\(possibleNumber) could not be converted to an integer")
 }
 // 输出 "123 has an integer value of 123"
 ```
@@ -566,9 +566,9 @@ if let constantName = someOptional {
 
 ```swift
 if let actualNumber = possibleNumber.toInt() {
-    println("\(possibleNumber) has an integer value of \(actualNumber)")
+    print("\(possibleNumber) has an integer value of \(actualNumber)")
 } else {
-    println("\(possibleNumber) could not be converted to an integer")
+    print("\(possibleNumber) could not be converted to an integer")
 }
 // 输出 "123 has an integer value of 123"
 ```
@@ -619,13 +619,13 @@ Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`n
 
 ```swift
 let possibleString: String? = "An optional string."
-println(possibleString!) // 需要惊叹号来获取值
+print(possibleString!) // 需要惊叹号来获取值
 // 输出 "An optional string."
 ```
 
 ```swift
 let assumedString: String! = "An implicitly unwrapped optional string."
-println(assumedString)  // 不需要感叹号
+print(assumedString)  // 不需要感叹号
 // 输出 "An implicitly unwrapped optional string."
 ```
 
@@ -638,7 +638,7 @@ println(assumedString)  // 不需要感叹号
 
 ```swift
 if assumedString {
-    println(assumedString)
+    print(assumedString)
 }
 // 输出 "An implicitly unwrapped optional string."
 ```
@@ -647,7 +647,7 @@ if assumedString {
 
 ```swift
 if let definiteString = assumedString {
-    println(definiteString)
+    print(definiteString)
 }
 // 输出 "An implicitly unwrapped optional string."
 ```
diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 82d3fb23..dc6a1b8b 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -1,6 +1,6 @@
 
-> 翻译：[XieLingWang](https://github.com/xielingwang), [JackAlan](https://github.com/AlanMelody)    
-> 校对：[EvilCome](https://github.com/Evilcome), [JackAlan](https://github.com/AlanMelody)    
+> 翻译：[XieLingWang](https://github.com/xielingwang), [JackAlan](https://github.com/AlanMelody)
+> 校对：[EvilCome](https://github.com/Evilcome), [JackAlan](https://github.com/AlanMelody)
 
 # 基本运算符
 -----------------
@@ -69,10 +69,10 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 - 减法（`-`）
 - 乘法（`*`）
 - 除法（`/`）
-	
+
 		1 + 2       // 等于 3
 		5 - 3       // 等于 2
-		2 * 3       // 等于 6	
+		2 * 3       // 等于 6
 		10.0 / 2.5  // 等于 4.0
 
 
@@ -230,12 +230,12 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 
 比较运算多用于条件语句，如`if`条件：
 
-	
+
 	let name = "world"
 	if name == "world" {
-		println("hello, world")
+		print("hello, world")
 	} else {
-	    println("I'm sorry \(name), but I don't recognize you")
+	    print("I'm sorry \(name), but I don't recognize you")
 	}
 	// 输出 "hello, world", 因为 `name` 就是等于 "world"
 
@@ -256,7 +256,7 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 	}
 
 这里有个计算表格行高的例子。如果有表头，那行高应比内容高度要高出50像素; 如果没有表头，只需高出20像素。
-	
+
 	let contentHeight = 40
 	let hasHeader = true
 	let rowHeight = contentHeight + (hasHeader ? 50 : 20)
@@ -326,7 +326,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在`for-in`循环中：
 
 	for index in 1...5 {
-	    println("\(index) * 5 = \(index * 5)")
+	    print("\(index) * 5 = \(index * 5)")
 	}
 	// 1 * 5 = 5
 	// 2 * 5 = 10
@@ -348,7 +348,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 	let names = ["Anna", "Alex", "Brian", "Jack"]
 	let count = names.count
 	for i in 0..<count {
-	    println("第 \(i + 1) 个人叫 \(names[i])")
+	    print("第 \(i + 1) 个人叫 \(names[i])")
 	}
 	// 第 1 个人叫 Anna
 	// 第 2 个人叫 Alex
@@ -375,7 +375,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 
 	let allowedEntry = false
 	if !allowedEntry {
-	    println("ACCESS DENIED")
+	    print("ACCESS DENIED")
 	}
 	// 输出 "ACCESS DENIED"
 
@@ -395,9 +395,9 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 	let enteredDoorCode = true
 	let passedRetinaScan = false
 	if enteredDoorCode && passedRetinaScan {
-	    println("Welcome!")
+	    print("Welcome!")
 	} else {
-	    println("ACCESS DENIED")
+	    print("ACCESS DENIED")
 	}
 	// 输出 "ACCESS DENIED"
 
@@ -413,9 +413,9 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 	let hasDoorKey = false
 	let knowsOverridePassword = true
 	if hasDoorKey || knowsOverridePassword {
-	    println("Welcome!")
+	    print("Welcome!")
 	} else {
-	    println("ACCESS DENIED")
+	    print("ACCESS DENIED")
 	}
 	// 输出 "Welcome!"
 
@@ -424,9 +424,9 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 我们可以组合多个逻辑运算来表达一个复合逻辑：
 
 	if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
-	    println("Welcome!")
+	    print("Welcome!")
 	} else {
-	    println("ACCESS DENIED")
+	    print("ACCESS DENIED")
 	}
 	// 输出 "Welcome!"
 
@@ -445,9 +445,9 @@ Swift 逻辑操作符`&&`和`||`是左结合的，这意味着拥有多元逻辑
 
 
 	if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
-	    println("Welcome!")
+	    print("Welcome!")
 	} else {
-	    println("ACCESS DENIED")
+	    print("ACCESS DENIED")
 	}
 	// 输出 "Welcome!"
 
diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 1ad844a4..98164903 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -38,26 +38,26 @@ Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 
 <a name="string_literals"></a>
 ## 字符串字面量（String Literals）
 
-您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。   
+您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
 字符串字面量可以用于为常量和变量提供初始值：
 ```let someString = "Some string literal value"```
 注意`someString`常量通过字符串字面量进行初始化，Swift 会推断该常量为`String`类型。
 > 注意：
-> 更多关于在字面量的特殊字符，请查看 [Special Characters in String Literals](#special_characters_in_string_literals) 。   
+> 更多关于在字面量的特殊字符，请查看 [Special Characters in String Literals](#special_characters_in_string_literals) 。
 
 
 <a name="initializing_an_empty_string"></a>
 ## 初始化空字符串 (Initializing an Empty String)
 
-要创建一个空字符串作为初始值，可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：   
- 
+要创建一个空字符串作为初始值，可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：
+
 ```swift
 var emptyString = ""               // 空字符串字面量
 var anotherEmptyString = String()  // 初始化方法
 // 两个字符串均为空并等价。
 ```
 
-您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：   
+您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：
 ```swift
 if emptyString.isEmpty {
     print("Nothing to see here")
@@ -79,7 +79,7 @@ constantString += " and another Highlander"
 // 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。
 ```
 
-> 注意：   
+> 注意：
 > 在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改。
 
 <a name="strings_are_value_types"></a>
@@ -121,7 +121,7 @@ for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细
 
 ```swift
 let exclamationMark: Charater = "!"
-```   
+```
 字符串可以通过传递一个值类型为`Charater`的数组作为自变量来初始化：
 
 ```swift
@@ -148,8 +148,8 @@ var welcome = string1 +　string2
 ```swift
 var instruction = "look over"
 instruction += string2
-// instruction 现在等于　"look over there" 
-```   
+// instruction 现在等于　"look over there"
+```
 
 您可以用`append`方法将一个字符附加到一个字符串变量的尾部：
 
@@ -160,7 +160,7 @@ welcome.append(exclamationMark)
 ```
 
 > 注意：  
-> 您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。   
+> 您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
 
 
 <a name="string_interpolation"></a>
@@ -183,28 +183,28 @@ let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
 在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
 
 > 注意：  
-> 插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。   
+> 插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。
 
 
-<a name="unicode"></a>   
+<a name="unicode"></a>
 ## Unicode
 
 Unicode 是一个国际标准，用于文本的编码和表示。
 它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
 Swift 的字符串和字符类型是完全兼容 Unicode 标准的。  
 
-<a name="unicode_scalars"></a>   
-### Unicode 标量（Unicode Scalars）   
+<a name="unicode_scalars"></a>
+### Unicode 标量（Unicode Scalars）
 
 Swift 的`String`类型是基于 *Unicode 标量* 建立的。
-Unicode 标量是对应字符的唯一21位数字或者修饰符，例如`U+0061`表示小写的拉丁字母(`LATIN SMALL LETTER A`)("`a`")，`U+1F425`表示小鸡表情(`FRONT-FACING BABY CHICK`) ("`🐥`")   
-> 注意：   
+Unicode 标量是对应字符的唯一21位数字或者修饰符，例如`U+0061`表示小写的拉丁字母(`LATIN SMALL LETTER A`)("`a`")，`U+1F425`表示小鸡表情(`FRONT-FACING BABY CHICK`) ("`🐥`")
+> 注意：
 > Unicode *码位(code poing)* 的范围是`U+0000`到`U+D7FF`或者`U+E000`到`U+10FFFF`。Unicode 标量不包括 Unicode *代理项(surrogate pair)* 码位，其码位范围是`U+D800`到`U+DFFF`。
 
-注意不是所有的21位 Unicode 标量都代表一个字符，因为有一些标量是保留给未来分配的。已经代表一个典型字符的标量都有自己的名字，例如上面例子中的`LATIN SMALL LETTER A`和`FRONT-FACING BABY CHICK`。   
+注意不是所有的21位 Unicode 标量都代表一个字符，因为有一些标量是保留给未来分配的。已经代表一个典型字符的标量都有自己的名字，例如上面例子中的`LATIN SMALL LETTER A`和`FRONT-FACING BABY CHICK`。
 
-<a name="special_characters_in_string_literals"></a>   
-### 字符串字面量的特殊字符 (Special Characters in String Literals)   
+<a name="special_characters_in_string_literals"></a>
+### 字符串字面量的特殊字符 (Special Characters in String Literals)
 
 字符串字面量可以包含以下特殊字符：
 
@@ -221,42 +221,42 @@ let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
 let dollarSign = "\u{24}"             // $, Unicode 标量 U+0024
 let blackHeart = "\u{2665}"           // ♥, Unicode 标量 U+2665
 let sparklingHeart = "\u{1F496}"  // 💖, Unicode 标量 U+1F496
-```   
+```
 
 <a name="extended_grapheme_clusters"></a>  
-### 可扩展的字形群集(Extended Grapheme Clusters)   
+### 可扩展的字形群集(Extended Grapheme Clusters)
 每一个 Swift 的`Character`类型代表一个可扩展的字形群。
-一个可扩展的字形群是一个或者更多可生成人类可读的字符 Unicode 标量的有序排列。   
+一个可扩展的字形群是一个或者更多可生成人类可读的字符 Unicode 标量的有序排列。
 举个例子，字母 é 可以用单一的 Unicode 标量 é (`LATIN SMALL LETTER E WITH ACUTE`, 或者`U+00E9`)来表示。然而一个标准的字母 e (`LATIN SMALL LETTER E`或者`U+0065`) 加上一个急促重音(`COMBINING ACTUE ACCENT`)的标量(`U+0301`)，这样一对标量就表示了同样的字母 é。
-这个急促重音的标量形象的将 e 转换成了 é。   
+这个急促重音的标量形象的将 e 转换成了 é。
 在这两种情况中，字母 é 代表了一个单一的 Swift 的字符串，同时代表了一个可扩展的字形群。
-在第一种情况，这个字形群包含一个单一标量；而在第二种情况，它是包含两个标量的字形群：   
+在第一种情况，这个字形群包含一个单一标量；而在第二种情况，它是包含两个标量的字形群：
 
 ```swift
 let eAcute: Character = "\u{E9}"                         // é
 let combinedEAcute: Character = "\u{65}\u{301}"          // e 后面加上  ́
 // eAcute 是 é, combinedEAcute 是 é
-```   
+```
 
 可扩展的字符群集是一个灵活的方法，用许多复杂的脚本字符表示单一字符。
 例如，来自朝鲜语字母表的韩语音节能表示为组合或分解的有序排列。
-在 Swift 都会表示为同一个单一的字符：   
+在 Swift 都会表示为同一个单一的字符：
 
 
 ```swift
 let precomposed: Character = "\u{D55C}"                  // 한
 let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
 // precomposed 是 한, decomposed 是 한
-```   
+```
 
-可拓展的字符群集可以使包围记号(例如`COMBINING ENCLOSING CIRCLE`或者`U+20DD`)的标量包围其他 Unicode 标量，作为一个单一的字符： 
+可拓展的字符群集可以使包围记号(例如`COMBINING ENCLOSING CIRCLE`或者`U+20DD`)的标量包围其他 Unicode 标量，作为一个单一的字符：
 
 ```swift
 let enclosedEAcute: Character = "\u{E9}\u{20DD}"
 // enclosedEAcute 是 é⃝
 ```  
 
-局部的指示符号的 Unicode 标量可以组合成一个单一的字符，例如 `REGIONAL INDICATOR SYMBOL LETTER U`(`U+1F1FA`)和`REGIONAL INDICATOR SYMBOL LETTER S`(`U+1F1F8`)：   
+局部的指示符号的 Unicode 标量可以组合成一个单一的字符，例如 `REGIONAL INDICATOR SYMBOL LETTER U`(`U+1F1FA`)和`REGIONAL INDICATOR SYMBOL LETTER S`(`U+1F1F8`)：
 
 
 ```swift
@@ -276,7 +276,7 @@ print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
 // 打印输出："unusualMenagerie has 40 characters"
 ```
 
-注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。   
+注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。
 例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 `COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是 é ，而不是 e ：
 
 ```swift
@@ -290,20 +290,20 @@ print("the number of characters in \(word) is \(word.characters.count)")
 
 > 注意：  
 > 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`characters`属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
-> 另外需要注意的是通过`characters`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。   
+> 另外需要注意的是通过`characters`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。
 
 
-<a name="accessing_and_modifying_a_string"></a>   
-## 访问和修改字符串 (Accessing and Modifying a String)   
-你可以通字符串的属性和方法来访问和读取一个它，当然也可以用下标语法完成。   
+<a name="accessing_and_modifying_a_string"></a>
+## 访问和修改字符串 (Accessing and Modifying a String)
+你可以通字符串的属性和方法来访问和读取一个它，当然也可以用下标语法完成。
 
 <a name="string_indices"></a>
-### 字符串索引 (String Indices)   
-每一个字符串都有一个关联的索引(*index*)类型，`String.index`，它对应着字符串中的每一个字符的位置。   
-前面提到，不同的字符可能会占用不同的内存空间数量，所以要知道字符的确定位置，就必须从字符串开头遍历每一个 Unicode 标量到字符串结尾。因此，Swift 的字符串不能用整数(integer)做索引。   
-使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后一个字符的末尾位置。如果字符串是空值，`startIndex`和`endIndex`是相等的。   
-通过调用`String.Index`的`predecessor()`方法，可以立即得到前面一个索引，调用`successor()`方法可以立即得到后面一个索引。任何一个字符串的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用`advance(start:n:)`函数来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误。   
-你可以使用下标语法来访问字符在字符串的确切索引。尝试获取出界的字符串索引，仍然抛出一个运行时错误。   
+### 字符串索引 (String Indices)
+每一个字符串都有一个关联的索引(*index*)类型，`String.index`，它对应着字符串中的每一个字符的位置。
+前面提到，不同的字符可能会占用不同的内存空间数量，所以要知道字符的确定位置，就必须从字符串开头遍历每一个 Unicode 标量到字符串结尾。因此，Swift 的字符串不能用整数(integer)做索引。
+使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后一个字符的末尾位置。如果字符串是空值，`startIndex`和`endIndex`是相等的。
+通过调用`String.Index`的`predecessor()`方法，可以立即得到前面一个索引，调用`successor()`方法可以立即得到后面一个索引。任何一个字符串的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用`advance(start:n:)`函数来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误。
+你可以使用下标语法来访问字符在字符串的确切索引。尝试获取出界的字符串索引，仍然抛出一个运行时错误。
 
 ```swift
 let greeting = "Guten Tag"
@@ -318,43 +318,43 @@ greeting[index]
 // a
 greeting[greeting.endIndex] // 错误
 greeting.endIndex.successor() // 错误
-```   
+```
 
 使用`characters`属性的`indices`会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问分立的字符。  
- 
+
 ```swift
 for index in greeting.characters.indices {
     print("\(greeting[index]) ", appendNewline: false)
 }
 // 打印输出 "G u t e n   T a g !"
-```   
+```
 
-<a name="inserting_and_removing"></a>   
-### 插入和删除 (Inserting and Removing)   
-调用`insert(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符。   
+<a name="inserting_and_removing"></a>
+### 插入和删除 (Inserting and Removing)
+调用`insert(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符。
 
 ```swift
 var welcome = "hello"
 welcome.insert("!", atIndex: welcome.endIndex)
-// welcome now 现在等于 "hello!"   
-```   
+// welcome now 现在等于 "hello!"
+```
 
-调用`splice(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符串。   
+调用`splice(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符串。
 
 ```swift
 welcome.splice(" there".characters, atIndex: welcome.endIndex.predecessor())
 // welcome 现在等于 "hello there!"
-```    
+```
 
-调用`removeAtIndex(_:)`方法可以在一个字符串的指定索引删除一个字符。   
+调用`removeAtIndex(_:)`方法可以在一个字符串的指定索引删除一个字符。
 
 ```swift
 welcome.removeAtIndex(welcome.endIndex.predecessor())
 // welcome 现在等于 "hello there"
 // 翻译的人解释：最后还有一个换行符，所以这里删除的是 !
-```   
+```
 
-调用`removeRange(_:)`方法可以在一个字符串的指定索引删除一个子字符串。   
+调用`removeRange(_:)`方法可以在一个字符串的指定索引删除一个子字符串。
 
 ```swift
 let range = advance(welcome.endIndex, -6)..<welcome.endIndex
@@ -369,7 +369,7 @@ welcome.removeRange(range)
 Swift 提供了三种方式来比较文本值：字符串字符相等、前缀相等和后缀相等。
 
 <a name="string_and_character_equality"></a>
-### 字符串/字符相等 (String and Character Equality)   
+### 字符串/字符相等 (String and Character Equality)
 字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在 [Comparison Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-ID70)：
 
 ```swift
@@ -379,10 +379,10 @@ if quotation == sameQuotation {
     print("These two strings are considered equal")
 }
 // 打印输出 "These two strings are considered equal"
-```   
+```
 
-如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。   
-例如，`LATIN SMALL LETTER E WITH ACUTE`(`U+00E9`)就是标准相等于`LATIN SMALL LETTER E`(`U+0065`)后面加上`COMBINING ACUTE ACCENT`(`U+0301`)。这两个字符群集都有效的表示字符 é ，所以它们被认为是标准相等的：   
+如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。
+例如，`LATIN SMALL LETTER E WITH ACUTE`(`U+00E9`)就是标准相等于`LATIN SMALL LETTER E`(`U+0065`)后面加上`COMBINING ACUTE ACCENT`(`U+0301`)。这两个字符群集都有效的表示字符 é ，所以它们被认为是标准相等的：
 
 ```swift
 // "Voulez-vous un café?" 使用 LATIN SMALL LETTER E WITH ACUTE
@@ -393,9 +393,9 @@ if eAcuteQuestion == combinedEAcuteQuestion {
     print("These two strings are considered equal")
 }
 // 打印输出 "These two strings are considered equal"
-```   
+```
 
-相反，英语中的`LATIN CAPITAL LETTER A`(`U+0401`，或者`A`)不等于俄语中的`CYRILLIC CAPITAL LETTER A`(`U+0410`，或者`A`)。两个字符看着是一样的，但却有不同的语言意义：   
+相反，英语中的`LATIN CAPITAL LETTER A`(`U+0401`，或者`A`)不等于俄语中的`CYRILLIC CAPITAL LETTER A`(`U+0410`，或者`A`)。两个字符看着是一样的，但却有不同的语言意义：
 
 ```swift
 let latinCapitalLetterA: Character = "\u{41}"
@@ -404,16 +404,16 @@ if latinCapitalLetterA != cyrillicCapitalLetterA {
     print("These two characters are not equivalent")
 }
 // 打印 "These two characters are not equivalent"
-```   
+```
 
 > 注意：
-> 在 Swift 中，字符串和字符并不区分区域。   
+> 在 Swift 中，字符串和字符并不区分区域。
 
 
 <a name="prefix_and_suffix_equality"></a>
 ### 前缀/后缀相等 (Prefix and Suffix Equality)
 
-通过调用字符串的`hasPrefix(_:)`/`hasSuffix(_:)`方法来检查字符串是否拥有特定前缀/后缀，两个方法均需要以字符串作为参数传入并传出`Boolean`值。   
+通过调用字符串的`hasPrefix(_:)`/`hasSuffix(_:)`方法来检查字符串是否拥有特定前缀/后缀，两个方法均需要以字符串作为参数传入并传出`Boolean`值。
 下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
 
 ```swift
@@ -459,14 +459,14 @@ for scene in romeoAndJuliet {
 }
 print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
 // 打印输出 "6 mansion scenes; 2 cell scenes"
-```   
+```
 
 > 注意：
-> `hasPrefix(_:)`和`hasSuffix(_:)`方法都是在每个字符串中一个一个字符的比较其可扩展的字符群集是否标准相等，详细描述在[字符串/字符相等](#string_and_character_equality)。   
+> `hasPrefix(_:)`和`hasSuffix(_:)`方法都是在每个字符串中一个一个字符的比较其可扩展的字符群集是否标准相等，详细描述在[字符串/字符相等](#string_and_character_equality)。
 
 
 <a name="unicode_representations_of_strings"></a>
-## 字符串的 Unicode 表示形式（Unicode Representations of Strings）   
+## 字符串的 Unicode 表示形式（Unicode Representations of Strings）
 当一个 Unicode 字符串被写进文本文件或者其他储存时，字符串中的 Unicode 标量会用 Unicode 定义的几种编码格式编码。每一个字符串中的小块编码都被称为代码单元。这些包括 UTF-8 编码格式（编码字符串为8位的代码单元）， UTF-16 编码格式（编码字符串位16位的代码单元），以及 UTF-32 编码格式（编码字符串32位的代码单元）。
 
 Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。
@@ -483,13 +483,13 @@ Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式
 
 ```swift
 let dogString = "Dog‼🐶"
-```   
+```
 
 
 <a name="UTF-8_representation"></a>
-### UTF-8 表示   
+### UTF-8 表示
 您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
-其为`String.UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：   
+其为`String.UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
 
 <body>
 <center>
@@ -542,14 +542,14 @@ print("")
 
 上面的例子中，前三个10进制代码单元值 (68, 111, 103) 代表了字符`D`、`o`和 `g`，它们的 UTF-8 表示与 ASCII 表示相同。
 接下来的三个10进制代码单元值 (226, 128, 188) 是`DOUBLE EXCLAMATION MARK`的3字节 UTF-8 表示。
-最后的四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。   
+最后的四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。
 
 
 <a name="UTF-16_representation"></a>
 ### UTF-16 表示
 
 您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
-其为`String.UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：   
+其为`String.UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
 <body>
 <center>
 <table style='text-align:center'>
@@ -581,7 +581,7 @@ print("")
  </tr>
 </table>
 </center>
-</body>   
+</body>
 
 
 ```swift
@@ -592,8 +592,8 @@ print("")
 // 68 111 103 8252 55357 56374
 ```
 
-同样，前三个代码单元值 (68, 111, 103) 代表了字符`D`、`o`和`g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。   
-第四个代码单元值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量值`U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。    
+同样，前三个代码单元值 (68, 111, 103) 代表了字符`D`、`o`和`g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。
+第四个代码单元值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量值`U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。
 第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
 第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
 
@@ -604,7 +604,7 @@ print("")
 其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。
 `UnicodeScalar`是21位的 Unicode 代码点。
 
-每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示：   
+每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示：
 
 <body>
 <center>
@@ -635,7 +635,7 @@ print("")
  </tr>
 </table>
 </center>
-</body>   
+</body>
 
 
 ```swift
@@ -646,8 +646,8 @@ print("")
 // 68 111 103 8252 128054
 ```
 
-前三个代码单元值 (68, 111, 103) 仍然代表字符`D`、`o`和`g`。   
-第四个代码单元值 (8252) 仍然是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量`U+203C`。   
+前三个代码单元值 (68, 111, 103) 仍然代表字符`D`、`o`和`g`。
+第四个代码单元值 (8252) 仍然是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量`U+203C`。
 第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于`DOG FACE`的Unicode 标量`U+1F436`。
 
 作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
@@ -661,4 +661,4 @@ for scalar in dogString.unicodeScalars {
 // g
 // ‼
 // 🐶
-```    
+```
diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index 23f1b9f3..bf6bb692 100755
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -751,7 +751,7 @@ Swift 有内置支持去检查接口的可用性的，这可以确保我们不
 
 ```swift
 if #available(iOS 9, OSX 10.10, *) {
-    // 在 iOS 使用 iOS 9 APIs , 并且在 OS X 使用 OS X v10.10 APIs 
+    // 在 iOS 使用 iOS 9 APIs , 并且在 OS X 使用 OS X v10.10 APIs
 } else {
     // 回滚至早前 iOS and OS X 的API
 }
@@ -767,4 +767,4 @@ if #available(`platform name` `version`, `...`, *) {
 } else {
     `fallback statements to execute if the APIs are unavailable`
 }
-```
\ No newline at end of file
+```
diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 0a83e15a..eca20a64 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -39,13 +39,13 @@ func sayHello(personName: String) -> String {
 该定义描述了函数做什么，它期望接收什么和执行结束时它返回的结果是什么。这样的定义使得函数可以在别的地方以一种清晰的方式被调用：
 
 ```swift
-println(sayHello("Anna"))
+print(sayHello("Anna"))
 // prints "Hello, Anna!"
-println(sayHello("Brian"))
+print(sayHello("Brian"))
 // prints "Hello, Brian!"
 ```
 
-调用 `sayHello(_:)` 函数时，在圆括号中传给它一个 `String` 类型的实参。因为这个函数返回一个 `String` 类型的值，`sayHello` 可以被包含在 `println` 的调用中，用来输出这个函数的返回值，正如上面所示。
+调用 `sayHello(_:)` 函数时，在圆括号中传给它一个 `String` 类型的实参。因为这个函数返回一个 `String` 类型的值，`sayHello` 可以被包含在 `print` 的调用中，用来输出这个函数的返回值，正如上面所示。
 
 在 `sayHello(_:)` 的函数体中，先定义了一个新的名为 `greeting` 的 `String` 常量，同时赋值了给 `personName` 的一个简单问候消息。然后用 `return` 关键字把这个问候返回出去。一旦 `return greeting` 被调用，该函数结束它的执行并返回 `greeting` 的当前值。
 
@@ -57,7 +57,7 @@ println(sayHello("Brian"))
 func sayHelloAgain(personName: String) -> String {
     return "Hello again, " + personName + "!"
 }
-println(sayHelloAgain("Anna"))
+print(sayHelloAgain("Anna"))
 // prints "Hello again, Anna!"
 ```
 
@@ -76,7 +76,7 @@ println(sayHelloAgain("Anna"))
 func halfOpenRangeLength(start: Int, end: Int) -> Int {
     return end - start
 }
-println(halfOpenRangeLength(1, 10))
+print(halfOpenRangeLength(1, 10))
 // prints "9"
 ```
 
@@ -88,7 +88,7 @@ println(halfOpenRangeLength(1, 10))
 func sayHelloWorld() -> String {
     return "hello, world"
 }
-println(sayHelloWorld())
+print(sayHelloWorld())
 // prints "hello, world"
 ```
 
@@ -122,7 +122,7 @@ print(sayHello("Tim", alreadyGreeted: true))
 
 ```swift
 func sayGoodbye(personName: String) {
-    println("Goodbye, \(personName)!")
+    print("Goodbye, \(personName)!")
 }
 sayGoodbye("Dave")
 // prints "Goodbye, Dave!"
diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index a468b995..84b16ae6 100755
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -98,7 +98,7 @@ let someVideoMode = VideoMode()
 通过使用*点语法*（*dot syntax*），你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接：
 
 ```swift
-println("The width of someResolution is \(someResolution.width)")
+print("The width of someResolution is \(someResolution.width)")
 // 输出 "The width of someResolution is 0"
 ```
 
@@ -107,7 +107,7 @@ println("The width of someResolution is \(someResolution.width)")
 你也可以访问子属性，如`VideoMode`中`Resolution`属性的`width`属性：
 
 ```swift
-println("The width of someVideoMode is \(someVideoMode.resolution.width)")
+print("The width of someVideoMode is \(someVideoMode.resolution.width)")
 // 输出 "The width of someVideoMode is 0"
 ```
 
@@ -115,7 +115,7 @@ println("The width of someVideoMode is \(someVideoMode.resolution.width)")
 
 ```swift
 someVideoMode.resolution.width = 1280
-println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
+print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
 // 输出 "The width of someVideoMode is now 1280"
 ```
 
@@ -161,14 +161,14 @@ cinema.width = 2048
 这里，将会显示`cinema`的`width`属性确已改为了`2048`：
 
 ```swift
-println("cinema is now  \(cinema.width) pixels wide")
+print("cinema is now  \(cinema.width) pixels wide")
 // 输出 "cinema is now 2048 pixels wide"
 ```
 
 然而，初始的`hd`实例中`width`属性还是`1920`：
 
 ```swift
-println("hd is still \(hd.width	) pixels wide")
+print("hd is still \(hd.width	) pixels wide")
 // 输出 "hd is still 1920 pixels wide"
 ```
 
@@ -184,7 +184,7 @@ var currentDirection = CompassPoint.West
 let rememberedDirection = currentDirection
 currentDirection = .East
 if rememberedDirection == .West {
-	println("The remembered direction is still .West")
+	print("The remembered direction is still .West")
 }
 // 输出 "The remembered direction is still .West"
 ```
@@ -220,7 +220,7 @@ alsoTenEighty.frameRate = 30.0
 下面，通过查看`tenEighty`的`frameRate`属性，我们会发现它正确的显示了基本`VideoMode`实例的新帧率，其值为`30.0`：
 
 ```swift
-println("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
+print("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
 // 输出 "The frameRate property of theEighty is now 30.0"
 ```
 
@@ -239,7 +239,7 @@ println("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
 
 ```swift
 if tenEighty === alsoTenEighty {
-	println("tenEighty and alsoTenEighty refer to the same Resolution instance.")
+	print("tenEighty and alsoTenEighty refer to the same Resolution instance.")
 }
 //输出 "tenEighty and alsoTenEighty refer to the same Resolution instance."
 ```
@@ -288,4 +288,3 @@ Objective-C中`字符串（NSString）`,`数组（NSArray）`和`字典（NSDict
 > 注意：
 以上是对于字符串、数组、字典和其它值的`拷贝`的描述。
 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在 Swift 的后台中，只有确有必要，`实际（actual）`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。（实际赋值由系统管理优化）
-
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index ab00d474..61ab2728 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -62,7 +62,7 @@ class Counter {
 
 函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。
 
-Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy(_:)`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。   
+Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy(_:)`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。
 
 具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称；默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。
 
@@ -85,7 +85,7 @@ counter.incrementBy(5, numberOfTimes: 3)
 // counter 的值现在是 15
 ```
 
-你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy(_numberOfTimes:)`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。   
+你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy(_numberOfTimes:)`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。
 这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
 
 
diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index d9e4db4e..21a390dd 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -54,7 +54,7 @@ struct TimesTable {
     }
 }
 let threeTimesTable = TimesTable(multiplier: 3)
-println("3的6倍是\(threeTimesTable[6])")
+print("3的6倍是\(threeTimesTable[6])")
 // 输出 "3的6倍是18"
 ```
 
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index fc2f5918..2c4ece52 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -49,7 +49,7 @@ let someVehicle = Vehicle()
 现在已经创建了一个`Vehicle`的新实例，你可以访问它的`description`属性来打印车辆的当前速度。
 
 ```swift
-println("Vehicle: \(someVehicle.description)")
+print("Vehicle: \(someVehicle.description)")
 // Vehicle: traveling at 0.0 miles per hour
 ```
 
@@ -81,17 +81,17 @@ class Bicycle: Vehicle {
 除了它所继承的特性，`Bicycle`类还定义了一个默认值为`false`的存储型属性`hasBasket`（属性推断为`Bool`）。
 
 默认情况下，你创建任何新的`Bicycle`实例将不会有一个篮子，创建该实例之后，你可以为特定的`Bicycle`实例设置`hasBasket `属性为`ture`：
- 
+
 ```swift
 let bicycle = Bicycle()
 bicycle.hasBasket = true
 ```
- 
+
 你还可以修改`Bicycle `实例所继承的`currentSpeed `属性，和查询实例所继承的`description `属性：
- 
+
 ```swift
 bicycle.currentSpeed = 15.0
-println("Bicycle: \(bicycle.description)")
+print("Bicycle: \(bicycle.description)")
 // Bicycle: traveling at 15.0 miles per hour
 ```
 
@@ -112,7 +112,7 @@ let tandem = Tandem()
 tandem.hasBasket = true
 tandem.currentNumberOfPassengers = 2
 tandem.currentSpeed = 22.0
-println("Tandem: \(tandem.description)")
+print("Tandem: \(tandem.description)")
 // Tandem: traveling at 22.0 miles per hour
 ```
 
@@ -144,7 +144,7 @@ println("Tandem: \(tandem.description)")
 ```swift
 class Train: Vehicle {
     override func makeNoise() {
-        println("Choo Choo")
+        print("Choo Choo")
     }
 }
 ```
@@ -189,7 +189,7 @@ class Car: Vehicle {
 let car = Car()
 car.currentSpeed = 25.0
 car.gear = 3
-println("Car: \(car.description)")
+print("Car: \(car.description)")
 // Car: traveling at 25.0 miles per hour in gear 3
 ```
 
@@ -217,7 +217,7 @@ class AutomaticCar: Car {
 ```swift
 let automatic = AutomaticCar()
 automatic.currentSpeed = 35.0
-println("AutomaticCar: \(automatic.description)")
+print("AutomaticCar: \(automatic.description)")
 // AutomaticCar: traveling at 35.0 miles per hour in gear 4
 ```
 
@@ -229,4 +229,3 @@ println("AutomaticCar: \(automatic.description)")
 如果你重写了`final`方法，属性或下标脚本，在编译时会报错。在类扩展中的方法，属性或下标脚本也可以在扩展的定义里标记为 final。
 
 你可以通过在关键字`class`前添加`final`特性（`final class`）来将整个类标记为 final 的，这样的类是不可被继承的，任何子类试图继承此类时，在编译时会报错。
-
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 59c57e4c..cf1149dc 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -13,7 +13,7 @@
 - [值类型的构造器代理](#initializer_delegation_for_value_types)
 - [类的继承和构造过程](#class_inheritance_and_initialization)
 - [可失败构造器](#failable_initializers)
-- [必要构造器](#required_initializers) 
+- [必要构造器](#required_initializers)
 - [通过闭包和函数来设置属性的默认值](#setting_a_default_property_value_with_a_closure_or_function)
 
 
@@ -39,7 +39,7 @@
 
 ```swift
 init() {
-    // 在此处执行构造过程    
+    // 在此处执行构造过程
 }
 ```
 
@@ -53,7 +53,7 @@ struct Fahrenheit {
     }
 }
 var f = Fahrenheit()
-println("The default temperature is \(f.temperature)° Fahrenheit")
+print("The default temperature is \(f.temperature)° Fahrenheit")
 // 输出 "The default temperature is 32.0° Fahrenheit”
 ```
 
@@ -182,7 +182,7 @@ class SurveyQuestion {
         self.text = text
     }
     func ask() {
-        println(text)
+        print(text)
     }
 }
 let cheeseQuestion = SurveyQuestion(text: "Do you like cheese?")
@@ -210,7 +210,7 @@ class SurveyQuestion {
         self.text = text
     }
     func ask() {
-        println(text)
+        print(text)
     }
 }
 let beetsQuestion = SurveyQuestion(text: "How about beets?")
@@ -656,7 +656,7 @@ var breakfastList = [
 breakfastList[0].name = "Orange juice"
 breakfastList[0].purchased = true
 for item in breakfastList {
-    println(item.description)
+    print(item.description)
 }
 // 1 x orange juice ✔
 // 1 x bacon ✘
@@ -666,13 +666,13 @@ for item in breakfastList {
 如上所述，例子中通过字面量方式创建了一个新数组`breakfastList`，它包含了三个新的`ShoppingListItem`实例，因此数组的类型也能自动推导为`ShoppingListItem[]`。在数组创建完之后，数组中第一个`ShoppingListItem`实例的名字从`[Unnamed]`修改为`Orange juice`，并标记为已购买。接下来通过遍历数组每个元素并打印它们的描述值，展示了所有项当前的默认状态都已按照预期完成了赋值。
 
 <a name="failable_initializers"></a>
-## 可失败构造器 
+## 可失败构造器
 
 如果一个类，结构体或枚举类型的对象，在构造自身的过程中有可能失败，则为其定义一个可失败构造器，是非常有必要的。这里所指的“失败”是指，如给构造器传入无效的参数值，或缺少某种所需的外部资源，又或是不满足某种必要的条件等。
 
 为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在`init`关键字后面加添问号`(init?)`。
 
-> 注意： 
+> 注意：
 可失败构造器的参数名和参数类型，不能与其它非可失败构造器的参数名，及其类型相同。
 
 可失败构造器，在构建对象的过程中，创建一个其自身类型为可选类型的对象。你通过`return nil` 语句，来表明可失败构造器在何种情况下“失败”。
@@ -697,9 +697,9 @@ struct Animal {
 ```swift
 let someCreature = Animal(species: "Giraffe")
 // someCreature 的类型是 Animal? 而不是 Animal
- 
+
 if let giraffe = someCreature {
-    println("An animal was initialized with a species of \(giraffe.species)")
+    print("An animal was initialized with a species of \(giraffe.species)")
 }
 // 打印 "An animal was initialized with a species of Giraffe"
 ```
@@ -709,9 +709,9 @@ if let giraffe = someCreature {
 ```swift
 let anonymousCreature = Animal(species: "")
 // anonymousCreature 的类型是 Animal?, 而不是 Animal
- 
+
 if anonymousCreature == nil {
-    println("The anonymous creature could not be initialized")
+    print("The anonymous creature could not be initialized")
 }
 // 打印 "The anonymous creature could not be initialized"
 ```
@@ -748,13 +748,13 @@ enum TemperatureUnit {
 ```swift
 let fahrenheitUnit = TemperatureUnit(symbol: "F")
 if fahrenheitUnit != nil {
-    println("This is a defined temperature unit, so initialization succeeded.")
+    print("This is a defined temperature unit, so initialization succeeded.")
 }
 // 打印 "This is a defined temperature unit, so initialization succeeded."
- 
+
 let unknownUnit = TemperatureUnit(symbol: "X")
 if unknownUnit == nil {
-    println("This is not a defined temperature unit, so initialization failed.")
+    print("This is not a defined temperature unit, so initialization failed.")
 }
 // 打印 "This is not a defined temperature unit, so initialization failed."
 ```
@@ -769,16 +769,16 @@ if unknownUnit == nil {
 enum TemperatureUnit: Character {
     case Kelvin = "K", Celsius = "C", Fahrenheit = "F"
 }
- 
+
 let fahrenheitUnit = TemperatureUnit(rawValue: "F")
 if fahrenheitUnit != nil {
-    println("This is a defined temperature unit, so initialization succeeded.")
+    print("This is a defined temperature unit, so initialization succeeded.")
 }
 // prints "This is a defined temperature unit, so initialization succeeded."
- 
+
 let unknownUnit = TemperatureUnit(rawValue: "X")
 if unknownUnit == nil {
-    println("This is not a defined temperature unit, so initialization failed.")
+    print("This is not a defined temperature unit, so initialization failed.")
 }
 // prints "This is not a defined temperature unit, so initialization failed."
 ```
@@ -804,7 +804,7 @@ class Product {
 ```swift
 if let bowTie = Product(name: "bow tie") {
     // 不需要检查 bowTie.name == nil
-    println("The product's name is \(bowTie.name)")
+    print("The product's name is \(bowTie.name)")
 }
 // 打印 "The product's name is bow tie"
 ```
@@ -841,7 +841,7 @@ class CartItem: Product {
 
 ```swift
 if let twoSocks = CartItem(name: "sock", quantity: 2) {
-    println("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
+    print("Item: \(twoSocks.name), quantity: \(twoSocks.quantity)")
 }
 // 打印 "Item: sock, quantity: 2"
 ```
@@ -849,9 +849,9 @@ if let twoSocks = CartItem(name: "sock", quantity: 2) {
 
 ```swift
 if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
-    println("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
+    print("Item: \(zeroShirts.name), quantity: \(zeroShirts.quantity)")
 } else {
-    println("Unable to initialize zero shirts")
+    print("Unable to initialize zero shirts")
 }
 // 打印 "Unable to initialize zero shirts"
 ```
@@ -860,9 +860,9 @@ if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
 
 ```swift
 if let oneUnnamed = CartItem(name: "", quantity: 1) {
-    println("Item: \(oneUnnamed.name), quantity: \(oneUnnamed.quantity)")
+    print("Item: \(oneUnnamed.name), quantity: \(oneUnnamed.quantity)")
 } else {
-    println("Unable to initialize one unnamed product")
+    print("Unable to initialize one unnamed product")
 }
 // 打印 "Unable to initialize one unnamed product"
 ```
@@ -920,7 +920,7 @@ class AutomaticallyNamedDocument: Document {
 你也可以用 ```init？```重写 ```init！```，反之亦然。
 你还可以用 ```init```代理调用```init！```，但这会触发一个断言：是否 ```init！```构造器会触发构造失败？
 
-<a name="required_initializers"></a> 
+<a name="required_initializers"></a>
 ##必要构造器
 
 在类的构造器前添加```required```修饰符表明所有该类的子类都必须实现该构造器：
@@ -1001,9 +1001,8 @@ struct Checkerboard {
 
 ```swift
 let board = Checkerboard()
-println(board.squareIsBlackAtRow(0, column: 1))
+print(board.squareIsBlackAtRow(0, column: 1))
 // 输出 "true"
-println(board.squareIsBlackAtRow(9, column: 9))
+print(board.squareIsBlackAtRow(9, column: 9))
 // 输出 "false"
 ```
-
diff --git a/source/chapter2/15_Deinitialization.md b/source/chapter2/15_Deinitialization.md
index dac45280..6a42b759 100755
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -77,9 +77,9 @@ class Player {
 
 ```swift
 var playerOne: Player? = Player(coins: 100)
-println("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
+print("A new player has joined the game with \(playerOne!.coinsInPurse) coins")
 // 输出 "A new player has joined the game with 100  coins"
-println("There are now \(Bank.coinsInBank) coins left   in the bank")
+print("There are now \(Bank.coinsInBank) coins left   in the bank")
 // 输出 "There are now 9900 coins left in the bank"
 ```
 
@@ -89,9 +89,9 @@ println("There are now \(Bank.coinsInBank) coins left   in the bank")
 
 ```swift
 playerOne!.winCoins(2_000)
-println("PlayerOne won 2000 coins & now has \(playerOne!.coinsInPurse) coins")
+print("PlayerOne won 2000 coins & now has \(playerOne!.coinsInPurse) coins")
 // 输出 "PlayerOne won 2000 coins & now has 2100 coins"
-println("The bank now only has \(Bank.coinsInBank) coins left")
+print("The bank now only has \(Bank.coinsInBank) coins left")
 // 输出 "The bank now only has 7900 coins left"
 ```
 
@@ -99,9 +99,9 @@ println("The bank now only has \(Bank.coinsInBank) coins left")
 
 ```swift
 playerOne = nil
-println("PlayerOne has left the game")
+print("PlayerOne has left the game")
 // 输出 "PlayerOne has left the game"
-println("The bank now has \(Bank.coinsInBank) coins")
+print("The bank now has \(Bank.coinsInBank) coins")
 // 输出 "The bank now has 10000 coins"
 ```
 
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index b0efa8b9..8487742d 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -299,7 +299,7 @@ class CreditCard {
 }
 ```
 
-> 注意: 
+> 注意:
 > `CreditCard`类的`number`属性被定义为`UInt64`类型而不是`Int`类型，以确保`number`属性的存储量在32位和64位系统上都能足够容纳16位的卡号。
 
 下面的代码片段定义了一个叫`john`的可选类型`Customer`变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为`nil`。
@@ -557,4 +557,3 @@ print(paragraph!.asHTML())
 paragraph = nil
 // prints "p is being deinitialized"
 ```
-
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index c8e90811..ecb01830 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -62,9 +62,9 @@ let roomCount = john.residence!.numberOfRooms
 
 ```swift
 if let roomCount = john.residence?.numberOfRooms {
-    println("John's residence has \(roomCount) room(s).")
+    print("John's residence has \(roomCount) room(s).")
 } else {
-	println("Unable to retrieve the number of rooms.")
+	print("Unable to retrieve the number of rooms.")
 }
 // 打印 "Unable to retrieve the number of rooms.
 ```
@@ -85,9 +85,9 @@ john.residence = Residence()
 
 ```swift
 if let roomCount = john.residence?.numberOfRooms {
-    println("John's residence has \(roomCount) room(s).")
+    print("John's residence has \(roomCount) room(s).")
 } else {
-    println("Unable to retrieve the number of rooms.")
+    print("Unable to retrieve the number of rooms.")
 }
 // 打印 "John's residence has 1 room(s)"。
 ```
@@ -119,7 +119,7 @@ class Residence {
         return rooms[i]
     }
     func printNumberOfRooms() {
-        println("The number of rooms is \(numberOfRooms)")
+        print("The number of rooms is \(numberOfRooms)")
     }
     var address: Address?
 }
@@ -173,9 +173,9 @@ class Address {
 ```swift
 let john = Person()
 if let roomCount = john.residence?.numberOfRooms {
-    println("John's residence has \(roomCount) room(s).")
+    print("John's residence has \(roomCount) room(s).")
 } else {
-    println("Unable to retrieve the number of rooms.")
+    print("Unable to retrieve the number of rooms.")
 }
 // 打印 "Unable to retrieve the number of rooms。
 ```
@@ -191,7 +191,7 @@ if let roomCount = john.residence?.numberOfRooms {
 
 ```swift
 func printNumberOfRooms(){
-	println(“The number of rooms is \(numberOfRooms)”)
+	print(“The number of rooms is \(numberOfRooms)”)
 }
 ```
 
@@ -201,9 +201,9 @@ func printNumberOfRooms(){
 
 ```swift
 if john.residence?.printNumberOfRooms?() {
-    println("It was possible to print the number of rooms.")
+    print("It was possible to print the number of rooms.")
 } else {
-    println("It was not possible to print the number of rooms.")
+    print("It was not possible to print the number of rooms.")
 }
 // 打印 "It was not possible to print the number of rooms."。
 ```
@@ -220,9 +220,9 @@ if john.residence?.printNumberOfRooms?() {
 
 ```swift
 if let firstRoomName = john.residence?[0].name {
-    println("The first room name is \(firstRoomName).")
+    print("The first room name is \(firstRoomName).")
 } else {
-    println("Unable to retrieve the first room name.")
+    print("Unable to retrieve the first room name.")
 }
 // 打印 "Unable to retrieve the first room name."。
 ```
@@ -238,9 +238,9 @@ johnsHouse.rooms += Room(name: "Kitchen")
 john.residence = johnsHouse
 
 if let firstRoomName = john.residence?[0].name {
-    println("The first room name is \(firstRoomName).")
+    print("The first room name is \(firstRoomName).")
 } else {
-    println("Unable to retrieve the first room name.")
+    print("Unable to retrieve the first room name.")
 }
 // 打印 "The first room name is Living Room."。
 ```
@@ -263,9 +263,9 @@ if let firstRoomName = john.residence?[0].name {
 
 ```swift
 if let johnsStreet = john.residence?.address?.street {
-    println("John's street name is \(johnsStreet).")
+    print("John's street name is \(johnsStreet).")
 } else {
-    println("Unable to retrieve the address.")
+    print("Unable to retrieve the address.")
 }
 // 打印 "Unable to retrieve the address.”。
 ```
@@ -285,9 +285,9 @@ john.residence!.address = johnsAddress
 
 ```swift
 if let johnsStreet = john.residence?.address?.street {
-    println("John's street name is \(johnsStreet).")
+    print("John's street name is \(johnsStreet).")
 } else {
-    println("Unable to retrieve the address.")
+    print("Unable to retrieve the address.")
 }
 // 打印 "John's street name is Laurel Street."。
 ```
@@ -303,7 +303,7 @@ if let johnsStreet = john.residence?.address?.street {
 
 ```swift
 if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
-    println("John's building identifier is \(buildingIdentifier).")
+    print("John's building identifier is \(buildingIdentifier).")
 }
 // 打印 "John's building identifier is The Larches."。
 ```
@@ -312,7 +312,7 @@ if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
 
 ```swift
 if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {
-    println("John's uppercase building identifier is \(upper).")
+    print("John's uppercase building identifier is \(upper).")
 }
 // 打印 "John's uppercase building identifier is THE LARCHES."。
 ```
diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/19_Nested_Types.md
index 46c4a6bc..4c1a1bbb 100755
--- a/source/chapter2/19_Nested_Types.md
+++ b/source/chapter2/19_Nested_Types.md
@@ -45,7 +45,7 @@ struct BlackjackCard {
             }
        }
     }
-    
+
     // BlackjackCard 的属性和方法
     let rank: Rank, suit: Suit
     var description: String {
@@ -93,4 +93,3 @@ let heartsSymbol = BlackjackCard.Suit.Hearts.rawValue
 ```
 
 对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由定义它们的上下文来限定。
-
diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index cbdf946a..a0f8da7b 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -67,10 +67,10 @@ extension Double {
     var ft: Double { return self / 3.28084 }
 }
 let oneInch = 25.4.mm
-println("One inch is \(oneInch) meters")
+print("One inch is \(oneInch) meters")
 // 打印输出："One inch is 0.0254 meters"
 let threeFeet = 3.ft
-println("Three feet is \(threeFeet) meters")
+print("Three feet is \(threeFeet) meters")
 // 打印输出："Three feet is 0.914399970739201 meters"
 ```
 
@@ -84,7 +84,7 @@ println("Three feet is \(threeFeet) meters")
 
 ```swift
 let aMarathon = 42.km + 195.m
-println("A marathon is \(aMarathon) meters long")
+print("A marathon is \(aMarathon) meters long")
 // 打印输出："A marathon is 42195.0 meters long"
 ```
 
@@ -169,7 +169,7 @@ extension Int {
 
 ```swift
 3.repetitions({
-    println("Hello!")
+    print("Hello!")
     })
 // Hello!
 // Hello!
@@ -180,7 +180,7 @@ extension Int {
 
 ```swift
 3.repetitions{
-    println("Goodbye!")
+    print("Goodbye!")
 }
 // Goodbye!
 // Goodbye!
@@ -296,5 +296,3 @@ printIntegerKinds([3, 19, -27, 0, -6, 0, 7])
 
 >注意：
 由于已知`number.kind `是`Int.Kind`型，所以`Int.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `. Negative`代替`Int.Kind.Negative`。
-
-
diff --git a/source/chapter2/24_Access_Control.md b/source/chapter2/24_Access_Control.md
index fa4e21b2..4be28249 100644
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@@ -255,7 +255,7 @@ struct TrackedString {
 ```
 
 
-`TrackedString`结构体定义了一个用于存储`String`类型的属性`value`，并将初始化值设为`""`（即一个空字符串）。该结构体同时也定义了另一个用于存储`Int`类型的属性名`numberOfEdits`，它用于记录属性`value`被修改的次数。这个功能的实现通过属性`value`的`didSet`方法实现，每当给`value`赋新值时就会调用`didSet`方法，然后将`numberOfEdits`的值加一。   
+`TrackedString`结构体定义了一个用于存储`String`类型的属性`value`，并将初始化值设为`""`（即一个空字符串）。该结构体同时也定义了另一个用于存储`Int`类型的属性名`numberOfEdits`，它用于记录属性`value`被修改的次数。这个功能的实现通过属性`value`的`didSet`方法实现，每当给`value`赋新值时就会调用`didSet`方法，然后将`numberOfEdits`的值加一。
 
 结构体`TrackedString`和它的属性`value`均没有申明显式访问级别，所以它们都拥有默认的访问级别`internal`。但是该结构体的`numberOfEdits`属性使用`private(set)`修饰符进行申明，这意味着`numberOfEdits`属性只能在定义该结构体的源文件中赋值。`numberOfEdits`属性的`Getter`依然是默认的访问级别`internal`，但是`Setter`的访问级别是`private`，这表示该属性只有在当前的源文件中是可读写的，而在当前源文件所属的模块中它只是一个可读的属性。  
 
@@ -266,7 +266,7 @@ var stringToEdit = TrackedString()
 stringToEdit.value = "This string will be tracked."
 stringToEdit.value += " This edit will increment numberOfEdits."
 stringToEdit.value += " So will this one."
-println("The number of edits is \(stringToEdit.numberOfEdits)")
+print("The number of edits is \(stringToEdit.numberOfEdits)")
 // prints "The number of edits is 3"
 ```
 
@@ -345,6 +345,3 @@ Swift为结构体、类都提供了一个默认的无参初始化方法，用于
 任何你定义的类型别名都会被当作不同的类型，以便于进行访问控制。一个类型别名的访问级别不可高于原类型的访问级别。比如说，一个`private`级别的类型别名可以设定给一个`public`、`internal`、`private`的类型，但是一个`public`级别的类型别名只能设定给一个`public`级别的类型，不能设定给`internal`或`private` 级别的类型。
 
 > 注意：这条规则也适用于为满足协议一致性而给相关类型命名别名的情况。
-
-
-

From 2a51e997186fe08da5b83aad171f218c673ad02f Mon Sep 17 00:00:00 2001
From: lyojo <lyojo@qq.com>
Date: Tue, 21 Jul 2015 17:56:10 +0800
Subject: [PATCH 127/228] =?UTF-8?q?=E9=94=99=E8=AF=AF=E5=A4=84=E7=90=86?=
 =?UTF-8?q?=E7=BF=BB=E8=AF=91=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/18_Error_Handling.md | 142 ++++++++++++++++++++++++++-
 1 file changed, 141 insertions(+), 1 deletion(-)

diff --git a/source/chapter2/18_Error_Handling.md b/source/chapter2/18_Error_Handling.md
index c1d1e62e..e4564442 100644
--- a/source/chapter2/18_Error_Handling.md
+++ b/source/chapter2/18_Error_Handling.md
@@ -1,2 +1,142 @@
 # 错误处理
------------------
\ No newline at end of file
+-----------------
+错误处理是响应错误以及从错误中返回的过程。swift提供第一类错误支持，包括在运行时抛出，捕获，传送和控制可回收错误。
+
+一些函数和方法不能总保证能够执行所有代码或产生有用的输出。可空类型用来表示值可能为空，但是当函数执行失败的事后，可空通常可以用来确定执行失败的原因，因此代码可以正确地响应失败。在Swift中，这叫做抛出函数或者抛出方法。
+
+举个例子，考虑到一个从磁盘上的一个文件读取以及处理数据的任务，有几种情况可能会导致这个任务失败，包括指定路径的文件不存在，文件不具有可读属性，或者文件没有被编码成合适的格式。区分这些错误可以让程序解决并且修复这些错误，并且，如果可能的话，把这些错误报告给用户。
+
+>
+NOTE：
+Swift中的错误处理涉及到错误处理样式，这会用到Cocoa中的NSError和Objective-C。更多信息请参见：[Error Handling](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)中的[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
+
+###错误的表示：
+在Swift中，错误用符合ErrorType协议的值表示。
+Swift枚举特别适合把一系列相关的错误组合在一起，同时可以把一些相关的值和错误关联在一起。因此编译器会为实现ErrorType协议的Swift枚举类型自动实现相应合成。
+
+比如说，你可以这样表示操作自动贩卖机会出现的错误：
+
+	enum VendingMachineError: ErrorType {
+	case InvalidSelection
+	case InsufficientFunds(required: Double)
+	case OutOfStock
+	}
+在这种情况下，自动贩卖机可能会因为以下原因失败：
+请求的物品不存在，用InvalidSelection表示。
+请求的物品的价格高于已投入金额，用InsufficientFunds表示。相关的双精度值表示还需要多少钱来完成此次交易。
+请求的物品已经卖完了，用OutOfStock表示。
+
+错误抛出
+通过在函数或方法声明的参数后面加上throws关键字，表明这个函数或方法可以抛出错误。如果指定一个返回值，可以把throws关键字放在返回箭头(->)的前面。除非明确地指出，一个函数，方法或者就闭包不能抛出错误。
+
+	func canThrowErrors() throws -> String
+	func cannotThrowErrors() -> String
+
+在抛出函数体的任意一个地方，可以通过throw语句抛出错误。在下面的例子中，如果请求的物品不存在，或者卖完了，或者超出投入金额，vend(itemNamed:)函数会抛出一个错误：
+
+	struct Item {
+	var price: Double
+	var count: Int
+	}
+	var inventory = [
+	"Candy Bar": Item(price: 1.25, count: 7),
+	"Chips": Item(price: 1.00, count: 4),
+	"Pretzels": Item(price: 0.75, count: 11)
+	]
+	var amountDeposited = 1.00
+	func vend(itemNamed name: String) throws {
+	guard var item = inventory[name] else {
+	throw VendingMachineError.InvalidSelection
+	    }
+	guard item.count > 0 else {
+	throw VendingMachineError.OutOfStock
+	    }
+	if amountDeposited >= item.price {
+	// Dispense the snack
+	amountDeposited -= item.price
+	        --item.count
+	inventory[name] = item
+	    } else {
+	let amountRequired = item.price - amountDeposited
+	throw VendingMachineError.InsufficientFunds(required: 	amountRequired)
+	    }
+	}
+首先，guard语句用来把绑定item常量和count变量到在库存中对应的值。如果物品不在库存中，将会抛出InvalidSelection错误。然后，物品是否可获取有物品的剩余数量决定。如果count小于等于0，将会抛出OutOfStock错误。最后，把请求物品的价格和已经投入的金额进行比较，如果如果投入的金额大于物品的价格，将会从投入的金额从减去物品的价格，然后库存中该物品的数量减1，然后返回请求的物品。否则，将会计算还需要多少钱，然后把这个值作为InsufficientFunds错误的关联值。因为throw语句会马上改变程序流程，当所有的购买条件（物品存在，库存足够以及投入金额足够）都满足的时候，物品才会出售。
+
+当调用一个抛出函数的时候，在调用前面加上try。这个关键字表明函数可以抛出错误，而且在try后面代码将不会执行。
+
+	let favoriteSnacks = [
+	"Alice": "Chips",
+	"Bob": "Licorice",
+	"Eve": "Pretzels",
+	]
+	func buyFavoriteSnack(person: String) throws {
+	let snackName = favoriteSnacks[person] ?? "Candy Bar"
+	try vend(itemNamed: snackName)
+	}
+buyFavoriteSnack(_:) 函数查找某个人的最喜欢的零食，然后尝试买给他。如果这个人在列表中没有喜欢的零食，就会购买Candy Bar。这个函数会调用vend函数，vend函数可能会抛出错误，所以在vend前面加上了try关键字。因为buyFavoriteSnack函数也是一个抛出函数，所以vend函数抛出的任何错误都会向上传递到buyFavoriteSnack被调用的地方。
+
+###捕捉和处理错误
+使用do-catch语句来就捕获和处理错误
+
+	do {
+	
+	    try function that throws
+	
+	    statements
+		
+	} catch pattern {
+	
+	    statements
+
+	}
+如果一个错误被抛出了，这个错误会被传递到外部域，直到被一个catch分句处理。一个catch分句包含一个catch关键字，跟着一个pattern来匹配错误和相应的执行语句。
+
+类似switch语句，编译器会检查catch分句是否能够处理全部错误。如果能够处理所有错误情况，就认为这个错误被完全处理。否者，包含这个抛出函数的所在域就要处理这个错误，或者包含这个抛出函数的函数也用throws声明。为了保证错误被处理，用一个带pattern的catch分句来匹配所有错误。如果一个catch分句没有指定样式，这个分句会匹配并且绑定任何错误到一个本地error常量。更多关于pattern的信息，参见[Patterns](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/doc/uid/TP40014097-CH36-ID419)。
+
+	do {	
+	try vend(itemNamed: "Candy Bar")	
+	// Enjoy delicious snack	
+	} catch VendingMachineError.InvalidSelectio {
+	print("Invalid Selection")
+	} catch VendingMachineError.OutOfStock {
+	print("Out of Stock.")
+	} catch VendingMachineError.InsufficientFunds(let 	amountRequired) {
+	print("Insufficient funds. Please insert an additional $\(amountRequired).")
+	}
+
+在上面的例子中，vend(itemNamed:) 函数在try表达式中被调用，因为这个函数会抛出错误。如果抛出了错误，程序执行流程马上转到catch分句，在catch分句中确定错误传递是否继续传送。如果没有抛出错误，将会执行在do语句中剩余的语句。
+
+###禁止错误传送
+在运行时，有几种情况抛出函数事实上是不会抛出错误的。在这几种情况下，你可以用forced-try表达式来调用抛出函数或方法，即使用try!来代替try。
+
+通过try!来调用抛出函数或方法禁止了错误传送，并且把调用包装在运行时断言，这样就不会抛出错误。如果错误真的抛出了，会触发运行时错误。
+
+	func willOnlyThrowIfTrue(value: Bool) throws {
+	if value { throw someError }
+	}
+	do {
+	try willOnlyThrowIfTrue(false)
+	} catch {
+	// Handle Error
+	}
+	try! willOnlyThrowIfTrue(false)
+
+###收尾操作
+使用defer语句来在执行一系列的语句。这样不管有没有错误发生，都可以执行一些必要的收尾操作。包括关闭打开的文件描述符以及释放所有手动分配的内存。
+
+defer语句把执行推迟到退出当前域的时候。defer语句包括defer关键字以及后面要执行的语句。被推迟的语句可能不包含任何将执行流程转移到外部的代码，比如break或者return语句，或者通过抛出一个错误。被推迟的操作的执行的顺序和他们定义的顺序相反，也就是说，在第一个defer语句中的代码在第二个defer语句中的代码之后执行。
+
+	func processFile(filename: String) throws {
+	if exists(filename) {
+	let file = open(filename)
+	defer {
+	close(file)
+	        }
+	while let line = try file.readline() {
+	/* Work with the file. */
+	        }
+	// close(file) is called here, at the end of the scope.
+	    }
+	}
+上面这个例子使用了defer语句来保证open有对应的close。这个调用不管是否有抛出都会执行。
\ No newline at end of file

From 6467f73be69eff6d9ccd82bcb06f56b96ae13afb Mon Sep 17 00:00:00 2001
From: lyojo <lyojo@qq.com>
Date: Wed, 22 Jul 2015 21:32:53 +0800
Subject: [PATCH 128/228] =?UTF-8?q?=E5=8F=AF=E7=A9=BA=E9=93=BE=E5=BC=8F?=
 =?UTF-8?q?=E8=B0=83=E7=94=A8=E7=BF=BB=E8=AF=91=E5=AE=8C=E6=88=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/17_Optional_Chaining.md | 278 +++++++++++++++++++++++-
 1 file changed, 275 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index ecb01830..bee7000b 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,7 +1,5 @@
-> 翻译：[Jasonbroker](https://github.com/Jasonbroker)  
-> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
-
 # Optional Chaining
+<<<<<<< Updated upstream
 -----------------
 
 本页包含内容：
@@ -319,3 +317,277 @@ if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {
 
 > 注意：  
 在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是`buildingIdentifier`方法的返回值，不是`buildingIdentifier`方法本身。
+=======
+-----------------
+可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。
+
+>
+注意：
+Swift 的可空链式调用和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且能够检查调用是否成功。
+
+##可空链式调用作为强制展开的另一个方案
+通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，然而强制展开将会触发运行时错误。
+
+为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回nil则说明调用失败。
+
+特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回Int的类型的结果将会返回Int?类型。
+
+下面几段代码将解释可空链式调用和强制展开的不同。
+首先定义两个类Person和Residence。
+
+	class Person {
+	var residence: Residence?
+	}
+	class Residence {
+	var numberOfRooms = 1
+	}
+
+Residence有一个Int类型的属性numberOfRooms，其默认值为1。Person具有一个可空的residence属性，其类型为Residence？。
+
+如果创建一个新的Person实例，因为它的residence属性是可空的，john属性将初始化为nil：
+
+	let john = Person()
+
+如果使用叹号（！）强制展开获得这个john的residence属性中的numberOfRooms值，会触发运行时错误，因为这时没有可以展开的residence：
+
+	let roomCount = john.residence!.numberOfRooms
+	// this triggers a runtime error
+
+john.residence非空的时候，上面的调用成功，并且把roomCount设置为Int类型的房间数量。正如上面说到的，当residence为空的时候上面这段代码会触发运行时错误。
+
+可空链式调用提供了一种另一种访问numberOfRooms的方法，使用问号（？）来代替原来叹号（！）的位置：
+
+	if let roomCount = john.residence?.numberOfRooms {
+	    print("John's residence has \(roomCount) room(s).")
+	} else {
+	    print("Unable to retrieve the number of rooms.")
+	}
+	// prints "Unable to retrieve the number of rooms."
+
+在residence后面添加问号之后，Swift就会在residence不为空的情况下访问numberOfRooms。
+
+因为访问numberOfRooms有可能失败，可空链式调用会返回Int?类型，或称为“可空的Int”。如上例所示，当residence为nil的时候，可空的Int将会为nil，表明无法访问numberOfRooms。
+
+要注意的是，即使numberOfRooms是不可空的Int时，这一点也成立。只要是通过可空链式调用就意味着最后numberOfRooms返回一个Int？而不是Int。
+
+通过赋给john.residence一个Residence的实例变量：
+
+	john.residence = Residence()
+这样john.residence不为nil了。现在就可以正常访问john.residence.numberOfRooms，其值为默认的1，类型为Int?：
+
+	if let roomCount = john.residence?.numberOfRooms {
+	print("John's residence has \(roomCount) room(s).")
+	} else {
+	print("Unable to retrieve the number of rooms.")
+	}
+	// prints "John's residence has 1 room(s)."
+##为可空链式调用定义模型类
+通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。并且判断能否访问子属性的属性，方法或下标。
+
+下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在Person和Residence的基础上增加了Room和Address，以及相关的属性，方法以及下标。
+
+Person类定义基本保持不变：
+
+	class Person {
+	    var residence: Residence?
+	}
+Residence类比之前复杂些，增加了一个Room类型的空数组room：
+
+	class Residence {
+	    var rooms = [Room]()
+	    var numberOfRooms: Int {
+	        return rooms.count
+	    }
+	    subscript(i: Int) -> Room {
+	        get {
+	            return rooms[i]
+	        }
+	        set {
+	            rooms[i] = newValue
+	        }
+	    }
+	    func printNumberOfRooms() {
+	        print("The number of rooms is \(numberOfRooms)")
+	    }
+	    var address: Address?
+	}
+
+现在Residence有了一个存储Room类型的数组，numberOfRooms属性需要计算，而不是作为单纯的变量。计算后的numberOfRooms返回rooms数组的count属性值。现在的Residence还提供访问rooms数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供printNumberOfRooms方法，这个方法的作用就是输出这个房子中房间的数量。最后，Residence定义了一个可空属性address，其类型为Address?。Address类的定义在下面会说明。
+
+类Room是一个简单类，只包含一个属性name，以及一个初始化函数：
+
+	class Room {
+	    let name: String
+	    init(name: String) { self.name = name }
+	}
+最后一个类是Address，这个类有三个String?类型的可空属性。buildingName以及buildingNumber属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称：
+
+	class Address {
+	    var buildingName: String?
+	    var buildingNumber: String?
+	    var street: String?
+	    func buildingIdentifier() -> String? {
+	        if buildingName != nil {
+	            return buildingName
+	        } else if buildingNumber != nil {
+	            return buildingNumber
+	        } else {
+	            return nil
+	        }
+	    }
+	}
+类Address提供buildingIdentifier()方法，返回值为String?。 如果buildingName不为空则返回buildingName， 如果buildingNumber不为空则返回buildingNumber。如果这两个属性都为空则返回nil。
+
+##通过可空链式调用访问属性
+正如[可空链式调用作为强制展开的另一个方案]中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。
+
+下面的代码创建了一个Person实例，然后访问numberOfRooms属性：
+
+	let john = Person()
+	if let roomCount = john.residence?.numberOfRooms {
+	    print("John's residence has \(roomCount) room(s).")
+	} else {
+	    print("Unable to retrieve the number of rooms.")
+	}
+	// prints "Unable to retrieve the number of rooms."
+因为john.residence为nil，所以毫无疑问这个可空链式调用失败。
+
+通过可空链式调用来设定属性值：
+
+	let someAddress = Address()
+	someAddress.buildingNumber = "29"
+	someAddress.street = "Acacia Road"
+	john.residence?.address = someAddress
+在这个例子中，通过john.residence来设定address属性也是不行的，因为john.residence为nil。
+
+##通过可空链式调用来调用方法
+可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
+Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值：
+
+	func printNumberOfRooms() {
+	    print("The number of rooms is \(numberOfRooms)")
+	}
+这个方法没有返回值。但是没有返回值的方法隐式返回Void类型，如[无返回值函数](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID163)中所述。这意味着没有返回值的方法也会返回()或者空的元组。
+
+如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为Void?，而不是Void，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用if语句来判断能否成功调用printNumberOfRooms()方法，即使方法本身没有定义返回值。通过返回值是否为nil可以判断调用是否成功：
+
+	if john.residence?.printNumberOfRooms() != nil {
+	    print("It was possible to print the number of rooms.")
+	} else {
+	    print("It was not possible to print the number of rooms.")
+	}
+	// prints "It was not possible to print the number of rooms."
+同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给john.residence中的address属性赋值，即使residence为nil。通过可空链式调用给属性赋值会返回Void?，通过判断返回值是否为nil可以知道赋值是否成功：
+
+	if (john.residence?.address = someAddress) != nil {
+	print("It was possible to set the address.")
+	} else {
+	print("It was not possible to set the address.")
+	}
+	// prints "It was not possible to set the address."
+
+##通过可空链式调用来访问下标
+通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。
+>
+注意：
+当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。可空链式调用的问号一般直接跟在可空表达式的后面。
+
+下面这个例子用下标访问john.residence中rooms数组中第一个房间的名称，因为john.residence为nil，所以下标调用毫无疑问失败了：
+
+	if let firstRoomName = john.residence?[0].name {
+	    print("The first room name is \(firstRoomName).")
+	} else {
+	    print("Unable to retrieve the first room name.")
+	}
+	// prints "Unable to retrieve the first room name."
+在这个例子中，问号直接放在john.residence的后面，并且在方括号的前面，因为john.residence是可空值。
+
+类似的，可以通过下标，用可空链式调用来赋值：
+
+	let johnsHouse = Residence()
+	johnsHouse.rooms.append(Room(name: "Living Room"))
+	johnsHouse.rooms.append(Room(name: "Kitchen"))
+	john.residence = johnsHouse
+	if let firstRoomName = john.residence?[0].name {
+	print("The first room name is \(firstRoomName).")
+	} else {
+	print("Unable to retrieve the first room name.")
+	}
+	// prints "The first room name is Living Room."
+
+##访问可空类型的下标：
+如果下标返回可空类型值，比如Swift中Dictionary的key下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值：
+
+	var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
+	testScores["Dave"]?[0] = 91
+	testScores["Bev"]?[0]++
+	testScores["Brian"]?[0] = 72
+	// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]
+上面的例子中定义了一个testScores数组，包含了两个键值对， 把String类型的key映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个key存在。但是key“Brian”在字典中不存在，所以第三个调用失败。
+
+##多层链接
+可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。
+
+也就是说：
+
++ 如果你访问的值不是可空的，通过可空链式调用将会放回可空值。
++ 如果你访问的值已经是可空的，通过可空链式调用不会变得“更”可空。
+
+因此：
+
++ 通过可空链式调用访问一个Int值，将会返回Int？，不过进行了多少次可空链式调用。
++ 类似的，通过可空链式调用访问Int?值，并不会变得更加可空。
+
+下面的例子访问john中的residence中的address中的street属性。这里使用了两层可空链式调用，residence以及address，这两个都是可空值。
+
+	if let johnsStreet = john.residence?.address?.street {
+	    print("John's street name is \(johnsStreet).")
+	} else {
+	    print("Unable to retrieve the address.")
+	}
+	// prints "Unable to retrieve the address."
+
+john.residence包含Residence实例，但是john.residence.address为nil。因此，不能访问john.residence?.address?.street。
+
+需要注意的是，上面的例子中，street的属性为String?。john.residence?.address?.street的返回值也依然是String?，即使已经进行了两次可空的链式调用。
+
+如果把john.residence.address指向一个实例，并且为address中的street属性赋值，我们就能过通过可空链式调用来访问street属性。
+
+	let johnsAddress = Address()
+	johnsAddress.buildingName = "The Larches"
+	johnsAddress.street = "Laurel Street"
+	john.residence?.address = johnsAddress
+ 	
+	if let johnsStreet = john.residence?.address?.street {
+	    print("John's street name is \(johnsStreet).")
+	} else {
+	    print("Unable to retrieve the address.")
+	}
+	// prints "John's street name is Laurel Street."
+在上面的例子中，因为john.residence是一个可用的Residence实例，所以对john.residence的address属性赋值成功。
+
+##对返回可空值的函数进行链接
+上面的例子说明了如何通过可空链式调用来获取可空属性值。我们还可以通过可空链式调用来调用返回可空值的方法，并且可以继续对可空值进行链接。
+
+在下面的例子中，通过可空链式调用来调用Address的buildingIdentifier()方法。这个方法返回String?类型。正如上面所说，通过可空链式调用的方法的最终返回值还是String?：
+ 
+	if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
+	    print("John's building identifier is \(buildingIdentifier).")
+	}
+	// prints "John's building identifier is The Larches."
+
+如果要进一步对方法的返回值进行可空链式调用，在方法buildingIdentifier()的圆括号后面加上问号：
+
+	if let beginsWithThe =
+	john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
+	if beginsWithThe {
+	print("John's building identifier begins with \"The\".")
+	} else {
+	print("John's building identifier does not begin with \"The\".")
+	}
+	}
+	// prints "John's building identifier begins with "The"."
+>	
+注意：
+在上面的例子中在，在方法的圆括号后面加上问号是因为buildingIdentifier()的返回值是可空值，而不是方法本身是可空的。
+>>>>>>> Stashed changes

From 8d70b6daf83a0cd3710f6ed23db3f1ca35d0c524 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Wed, 22 Jul 2015 21:44:35 +0800
Subject: [PATCH 129/228] fix conflict

---
 source/chapter2/17_Optional_Chaining.md | 739 +++++++-----------------
 1 file changed, 210 insertions(+), 529 deletions(-)

diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index bee7000b..84eddd35 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,593 +1,274 @@
 # Optional Chaining
-<<<<<<< Updated upstream
+
 -----------------
+可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。
 
-本页包含内容：
+>
+注意：
+Swift 的可空链式调用和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且能够检查调用是否成功。
 
-- [可选链可替代强制解析](#optional_chaining_as_an_alternative_to_forced_unwrapping)
-- [为可选链定义模型类](#defining_model_classes_for_optional_chaining)
-- [通过可选链调用属性](#calling_properties_through_optional_chaining)
-- [通过可选链调用方法](#calling_methods_through_optional_chaining)
-- [使用可选链调用下标脚本](#calling_subscripts_through_optional_chaining)
-- [连接多层链接](#linking_multiple_levels_of_chaining)
-- [链接可选返回值的方法](#chaining_on_methods_with_optional_return_values)
+##可空链式调用作为强制展开的另一个方案
+通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，然而强制展开将会触发运行时错误。
 
-可选链（Optional Chaining）是一种可以请求和调用属性、方法及下标脚本的过程，它的可选性体现于请求或调用的目标当前可能为空（`nil`）。如果可选的目标有值，那么调用就会成功；相反，如果选择的目标为空（`nil`），则这种调用将返回空（`nil`）。多次请求或调用可以被链接在一起形成一个链，如果任何一个节点为空（`nil`）将导致整个链失效。
+为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回nil则说明调用失败。
 
-> 注意：  
-Swift 的可选链和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且失败与否可以被检测到。
+特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回Int的类型的结果将会返回Int?类型。
 
-<a name="optional_chaining_as_an_alternative_to_forced_unwrapping"></a>
-## 可选链可替代强制解析
+下面几段代码将解释可空链式调用和强制展开的不同。
+首先定义两个类Person和Residence。
 
-通过在想调用的属性、方法、或下标脚本的可选值（`optional value`）（非空）后面放一个问号，可以定义一个可选链。这一点很像在可选值后面放一个叹号来强制拆得其封包内的值。它们的主要的区别在于当可选值为空时可选链即刻失败，然而一般的强制解析将会引发运行时错误。
+	class Person {
+	var residence: Residence?
+	}
+	class Residence {
+	var numberOfRooms = 1
+	}
 
-为了反映可选链可以调用空（`nil`），不论你调用的属性、方法、下标脚本等返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来检测你的可选链是否调用成功，有返回值即成功，返回nil则失败。
+Residence有一个Int类型的属性numberOfRooms，其默认值为1。Person具有一个可空的residence属性，其类型为Residence？。
 
-调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个可选值，当可选链调用成功时，一个应该返回`Int`的属性将会返回`Int?`。
+如果创建一个新的Person实例，因为它的residence属性是可空的，john属性将初始化为nil：
 
-下面几段代码将解释可选链和强制解析的不同。
+	let john = Person()
 
-首先定义两个类`Person`和`Residence`。
+如果使用叹号（！）强制展开获得这个john的residence属性中的numberOfRooms值，会触发运行时错误，因为这时没有可以展开的residence：
 
-```swift
-class Person {
-    var residence: Residence?
-}
+	let roomCount = john.residence!.numberOfRooms
+	// this triggers a runtime error
 
-class Residence {
-    var numberOfRooms = 1
-}
-```
+john.residence非空的时候，上面的调用成功，并且把roomCount设置为Int类型的房间数量。正如上面说到的，当residence为空的时候上面这段代码会触发运行时错误。
 
-`Residence`具有一个`Int`类型的`numberOfRooms`，其值为 1。`Person`具有一个可选`residence`属性，它的类型是`Residence？`。
+可空链式调用提供了一种另一种访问numberOfRooms的方法，使用问号（？）来代替原来叹号（！）的位置：
 
-如果你创建一个新的`Person`实例，它的`residence`属性由于是被定义为可选型的，此属性将默认初始化为空：
+	if let roomCount = john.residence?.numberOfRooms {
+	    print("John's residence has \(roomCount) room(s).")
+	} else {
+	    print("Unable to retrieve the number of rooms.")
+	}
+	// prints "Unable to retrieve the number of rooms."
 
-```swift
-let john = Person()
-```
+在residence后面添加问号之后，Swift就会在residence不为空的情况下访问numberOfRooms。
 
-如果你想使用感叹号（`!`）强制解析获得这个人`residence`属性`numberOfRooms`属性值，将会引发运行时错误，因为这时没有可以供解析的`residence`值。
+因为访问numberOfRooms有可能失败，可空链式调用会返回Int?类型，或称为“可空的Int”。如上例所示，当residence为nil的时候，可空的Int将会为nil，表明无法访问numberOfRooms。
 
-```swift
-let roomCount = john.residence!.numberOfRooms
-//将导致运行时错误
-```
-当`john.residence`不是`nil`时，会运行通过，且会将`roomCount` 设置为一个`int`类型的合理值。然而，如上所述，当`residence`为空时，这个代码将会导致运行时错误。
+要注意的是，即使numberOfRooms是不可空的Int时，这一点也成立。只要是通过可空链式调用就意味着最后numberOfRooms返回一个Int？而不是Int。
 
-可选链提供了一种另一种获得`numberOfRooms`的方法。利用可选链，使用问号来代替原来`!`的位置：
+通过赋给john.residence一个Residence的实例变量：
 
-```swift
-if let roomCount = john.residence?.numberOfRooms {
-    print("John's residence has \(roomCount) room(s).")
-} else {
+	john.residence = Residence()
+这样john.residence不为nil了。现在就可以正常访问john.residence.numberOfRooms，其值为默认的1，类型为Int?：
+
+	if let roomCount = john.residence?.numberOfRooms {
+	print("John's residence has \(roomCount) room(s).")
+	} else {
 	print("Unable to retrieve the number of rooms.")
-}
-// 打印 "Unable to retrieve the number of rooms.
-```
+	}
+	// prints "John's residence has 1 room(s)."
+##为可空链式调用定义模型类
+通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。并且判断能否访问子属性的属性，方法或下标。
 
-这告诉 Swift 来链接可选`residence?`属性，如果`residence`存在则取回`numberOfRooms`的值。
+下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在Person和Residence的基础上增加了Room和Address，以及相关的属性，方法以及下标。
 
-因为这种尝试获得`numberOfRooms`的操作有可能失败，可选链会返回`Int?`类型值，或者称作“可选`Int`”。当`residence`是空的时候（上例），选择`Int`将会为空，因此会出现无法访问`numberOfRooms`的情况。
+Person类定义基本保持不变：
 
-要注意的是，即使numberOfRooms是非可选`Int`（`Int?`）时这一点也成立。只要是通过可选链的请求就意味着最后`numberOfRooms`总是返回一个`Int?`而不是`Int`。
+	class Person {
+	    var residence: Residence?
+	}
+Residence类比之前复杂些，增加了一个Room类型的空数组room：
 
-你可以自己定义一个`Residence`实例给`john.residence`，这样它就不再为空了：
+	class Residence {
+	    var rooms = [Room]()
+	    var numberOfRooms: Int {
+	        return rooms.count
+	    }
+	    subscript(i: Int) -> Room {
+	        get {
+	            return rooms[i]
+	        }
+	        set {
+	            rooms[i] = newValue
+	        }
+	    }
+	    func printNumberOfRooms() {
+	        print("The number of rooms is \(numberOfRooms)")
+	    }
+	    var address: Address?
+	}
 
-```swift
-john.residence = Residence()
-```
+现在Residence有了一个存储Room类型的数组，numberOfRooms属性需要计算，而不是作为单纯的变量。计算后的numberOfRooms返回rooms数组的count属性值。现在的Residence还提供访问rooms数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供printNumberOfRooms方法，这个方法的作用就是输出这个房子中房间的数量。最后，Residence定义了一个可空属性address，其类型为Address?。Address类的定义在下面会说明。
 
-`john.residence` 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得`numberOfRoooms`，它将返回一个包含默认值 1 的`Int?`：
+类Room是一个简单类，只包含一个属性name，以及一个初始化函数：
 
-```swift
-if let roomCount = john.residence?.numberOfRooms {
-    print("John's residence has \(roomCount) room(s).")
-} else {
-    print("Unable to retrieve the number of rooms.")
-}
-// 打印 "John's residence has 1 room(s)"。
-```
+	class Room {
+	    let name: String
+	    init(name: String) { self.name = name }
+	}
+最后一个类是Address，这个类有三个String?类型的可空属性。buildingName以及buildingNumber属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称：
 
-<a name="defining_model_classes_for_optional_chaining"></a>
-##为可选链定义模型类
+	class Address {
+	    var buildingName: String?
+	    var buildingNumber: String?
+	    var street: String?
+	    func buildingIdentifier() -> String? {
+	        if buildingName != nil {
+	            return buildingName
+	        } else if buildingNumber != nil {
+	            return buildingNumber
+	        } else {
+	            return nil
+	        }
+	    }
+	}
+类Address提供buildingIdentifier()方法，返回值为String?。 如果buildingName不为空则返回buildingName， 如果buildingNumber不为空则返回buildingNumber。如果这两个属性都为空则返回nil。
 
-你可以使用可选链来多层调用属性，方法，和下标脚本。这让你可以利用它们之间的复杂模型来获取更底层的属性，并检查是否可以成功获取此类底层属性。
+##通过可空链式调用访问属性
+正如[可空链式调用作为强制展开的另一个方案]中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。
 
-后面的代码定义了四个将在后面使用的模型类，其中包括多层可选链。这些类是由上面的`Person`和`Residence`模型通过添加一个`Room`和一个`Address`类拓展来。
+下面的代码创建了一个Person实例，然后访问numberOfRooms属性：
 
-`Person`类定义与之前相同。
+	let john = Person()
+	if let roomCount = john.residence?.numberOfRooms {
+	    print("John's residence has \(roomCount) room(s).")
+	} else {
+	    print("Unable to retrieve the number of rooms.")
+	}
+	// prints "Unable to retrieve the number of rooms."
+因为john.residence为nil，所以毫无疑问这个可空链式调用失败。
 
-```swift
-class Person {
-    var residence: Residence?
-}
-```
+通过可空链式调用来设定属性值：
 
-`Residence`类比之前复杂些。这次，它定义了一个变量 `rooms`，它被初始化为一个`Room[]`类型的空数组：
+	let someAddress = Address()
+	someAddress.buildingNumber = "29"
+	someAddress.street = "Acacia Road"
+	john.residence?.address = someAddress
+在这个例子中，通过john.residence来设定address属性也是不行的，因为john.residence为nil。
 
-```swift
-class Residence {
-    var rooms = [Room]()
-    var numberOfRooms: Int {
-    return rooms.count
-    }
-    subscript(i: Int) -> Room {
-        return rooms[i]
-    }
-    func printNumberOfRooms() {
-        print("The number of rooms is \(numberOfRooms)")
-    }
-    var address: Address?
-}
-```
+##通过可空链式调用来调用方法
+可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
+Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值：
 
-因为`Residence`存储了一个`Room`实例的数组，它的`numberOfRooms`属性值不是一个固定的存储值，而是通过计算而来的。`numberOfRooms`属性值是由返回`rooms`数组的`count`属性值得到的。
+	func printNumberOfRooms() {
+	    print("The number of rooms is \(numberOfRooms)")
+	}
+这个方法没有返回值。但是没有返回值的方法隐式返回Void类型，如[无返回值函数](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID163)中所述。这意味着没有返回值的方法也会返回()或者空的元组。
 
-为了能快速访问`rooms`数组，`Residence`定义了一个只读的下标脚本，通过插入数组的元素角标就可以成功调用。如果该角标存在，下标脚本则将该元素返回。
+如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为Void?，而不是Void，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用if语句来判断能否成功调用printNumberOfRooms()方法，即使方法本身没有定义返回值。通过返回值是否为nil可以判断调用是否成功：
 
-`Residence`中也提供了一个`printNumberOfRooms`的方法，即简单的打印房间个数。
+	if john.residence?.printNumberOfRooms() != nil {
+	    print("It was possible to print the number of rooms.")
+	} else {
+	    print("It was not possible to print the number of rooms.")
+	}
+	// prints "It was not possible to print the number of rooms."
+同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给john.residence中的address属性赋值，即使residence为nil。通过可空链式调用给属性赋值会返回Void?，通过判断返回值是否为nil可以知道赋值是否成功：
 
-最后，`Residence`定义了一个可选属性叫`address`（`address?`）。`Address`类的属性将在后面定义。
-用于`rooms`数组的`Room`类是一个很简单的类，它只有一个`name`属性和一个设定`room`名的初始化器。
+	if (john.residence?.address = someAddress) != nil {
+	print("It was possible to set the address.")
+	} else {
+	print("It was not possible to set the address.")
+	}
+	// prints "It was not possible to set the address."
 
-```swift
-class Room {
-    let name: String
-    init(name: String) { self.name = name }
-}
-```
+##通过可空链式调用来访问下标
+通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。
+>
+注意：
+当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。可空链式调用的问号一般直接跟在可空表达式的后面。
 
+下面这个例子用下标访问john.residence中rooms数组中第一个房间的名称，因为john.residence为nil，所以下标调用毫无疑问失败了：
 
-这个模型中的最终类叫做`Address`。它有三个类型是`String?`的可选属性。前面两个可选属性`buildingName`和 `buildingNumber`作为地址的一部分，是定义某个建筑物的两种方式。第三个属性`street`，用于命名地址的街道名：
+	if let firstRoomName = john.residence?[0].name {
+	    print("The first room name is \(firstRoomName).")
+	} else {
+	    print("Unable to retrieve the first room name.")
+	}
+	// prints "Unable to retrieve the first room name."
+在这个例子中，问号直接放在john.residence的后面，并且在方括号的前面，因为john.residence是可空值。
 
-```swift
-class Address {
-    var buildingName: String?
-    var buildingNumber: String?
-    var street: String?
-    func buildingIdentifier() -> String? {
-        if buildingName {
-            return buildingName
-        } else if buildingNumber {
-            return buildingNumber
-        } else {
-            return nil
-        }
-    }
-}
-```
+类似的，可以通过下标，用可空链式调用来赋值：
 
-`Address`类还提供了一个`buildingIdentifier`的方法，它的返回值类型为`String?`。这个方法检查`buildingName`和`buildingNumber`的属性，如果`buildingName`有值则将其返回，或者如果`buildingNumber`有值则将其返回，再或如果没有一个属性有值，返回空。
+	let johnsHouse = Residence()
+	johnsHouse.rooms.append(Room(name: "Living Room"))
+	johnsHouse.rooms.append(Room(name: "Kitchen"))
+	john.residence = johnsHouse
+	if let firstRoomName = john.residence?[0].name {
+	print("The first room name is \(firstRoomName).")
+	} else {
+	print("Unable to retrieve the first room name.")
+	}
+	// prints "The first room name is Living Room."
 
-<a name="calling_properties_through_optional_chaining"></a>
-##通过可选链调用属性
+##访问可空类型的下标：
+如果下标返回可空类型值，比如Swift中Dictionary的key下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值：
 
-正如上面“ [可选链可替代强制解析](#optional_chaining_as_an_alternative_to_forced_unwrapping)”中所述，你可以利用可选链的可选值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。
+	var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
+	testScores["Dave"]?[0] = 91
+	testScores["Bev"]?[0]++
+	testScores["Brian"]?[0] = 72
+	// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]
+上面的例子中定义了一个testScores数组，包含了两个键值对， 把String类型的key映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个key存在。但是key“Brian”在字典中不存在，所以第三个调用失败。
 
-使用上述定义的类来创建一个人实例，并再次尝试后去它的`numberOfRooms`属性：
+##多层链接
+可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。
 
-```swift
-let john = Person()
-if let roomCount = john.residence?.numberOfRooms {
-    print("John's residence has \(roomCount) room(s).")
-} else {
-    print("Unable to retrieve the number of rooms.")
-}
-// 打印 "Unable to retrieve the number of rooms。
-```
-
-由于`john.residence`是空，所以这个可选链和之前一样失败了，但是没有运行时错误。
-
-<a name="calling_methods_through_optional_chaining"></a>
-##通过可选链调用方法
-
-你可以使用可选链的来调用可选值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。
-
-`Residence`的`printNumberOfRooms`方法会打印`numberOfRooms`的当前值。方法如下：
-
-```swift
-func printNumberOfRooms(){
-	print(“The number of rooms is \(numberOfRooms)”)
-}
-```
-
-这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型`Void`（参见Function Without Return Values）。
-
-如果你利用可选链调用此方法，这个方法的返回值类型将是`Void?`，而不是`Void`，因为当通过可选链调用方法时返回值总是可选类型（optional type）。即使这个方法本身没有定义返回值，你也可以使用`if`语句来检查是否能成功调用`printNumberOfRooms`方法：如果方法通过可选链调用成功，`printNumberOfRooms`的隐式返回值将会是`Void`，如果没有成功，将返回`nil`：
-
-```swift
-if john.residence?.printNumberOfRooms?() {
-    print("It was possible to print the number of rooms.")
-} else {
-    print("It was not possible to print the number of rooms.")
-}
-// 打印 "It was not possible to print the number of rooms."。
-```
-
-<a name="calling_subscripts_through_optional_chaining"></a>
-##使用可选链调用下标脚本
-
-你可以使用可选链来尝试从下标脚本获取值并检查下标脚本的调用是否成功，然而，你不能通过可选链来设置下标脚本。
-
-> 注意：  
-当你使用可选链来获取下标脚本的时候，你应该将问号放在下标脚本括号的前面而不是后面。可选链的问号一般直接跟在表达语句的后面。
-
-下面这个例子用在`Residence`类中定义的下标脚本来获取`john.residence`数组中第一个房间的名字。因为`john.residence`现在是`nil`，下标脚本的调用失败了。
-
-```swift
-if let firstRoomName = john.residence?[0].name {
-    print("The first room name is \(firstRoomName).")
-} else {
-    print("Unable to retrieve the first room name.")
-}
-// 打印 "Unable to retrieve the first room name."。
-```
-
-在下标脚本调用中可选链的问号直接跟在`john.residence`的后面，在下标脚本括号的前面，因为`john.residence`是可选链试图获得的可选值。
-
-如果你创建一个`Residence`实例给`john.residence`，且在他的`rooms`数组中有一个或多个`Room`实例，那么你可以使用可选链通过`Residence`下标脚本来获取在`rooms`数组中的实例了：
-
-```swift
-let johnsHouse = Residence()
-johnsHouse.rooms += Room(name: "Living Room")
-johnsHouse.rooms += Room(name: "Kitchen")
-john.residence = johnsHouse
-
-if let firstRoomName = john.residence?[0].name {
-    print("The first room name is \(firstRoomName).")
-} else {
-    print("Unable to retrieve the first room name.")
-}
-// 打印 "The first room name is Living Room."。
-```
-
-<a name="linking_multiple_levels_of_chaining"></a>
-##连接多层链接
-
-你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和下标脚本。然而多层可选链不能再添加比已经返回的可选值更多的层。
 也就是说：
 
-如果你试图获得的类型不是可选类型，由于使用了可选链它将变成可选类型。
-如果你试图获得的类型已经是可选类型，由于可选链它也不会提高可选性。
++ 如果你访问的值不是可空的，通过可空链式调用将会放回可空值。
++ 如果你访问的值已经是可空的，通过可空链式调用不会变得“更”可空。
 
 因此：
 
-如果你试图通过可选链获得`Int`值，不论使用了多少层链接返回的总是`Int?`。
-相似的，如果你试图通过可选链获得`Int?`值，不论使用了多少层链接返回的总是`Int?`。
++ 通过可空链式调用访问一个Int值，将会返回Int？，不过进行了多少次可空链式调用。
++ 类似的，通过可空链式调用访问Int?值，并不会变得更加可空。
 
-下面的例子试图获取`john`的`residence`属性里的`address`的`street`属性。这里使用了两层可选链来联系`residence`和`address`属性，它们两者都是可选类型：
+下面的例子访问john中的residence中的address中的street属性。这里使用了两层可空链式调用，residence以及address，这两个都是可空值。
 
-```swift
-if let johnsStreet = john.residence?.address?.street {
-    print("John's street name is \(johnsStreet).")
-} else {
-    print("Unable to retrieve the address.")
-}
-// 打印 "Unable to retrieve the address.”。
-```
+	if let johnsStreet = john.residence?.address?.street {
+	    print("John's street name is \(johnsStreet).")
+	} else {
+	    print("Unable to retrieve the address.")
+	}
+	// prints "Unable to retrieve the address."
 
-`john.residence`的值现在包含一个`Residence`实例，然而`john.residence.address`现在是`nil`，因此`john.residence?.address?.street`调用失败。
+john.residence包含Residence实例，但是john.residence.address为nil。因此，不能访问john.residence?.address?.street。
 
-从上面的例子发现，你试图获得`street`属性值。这个属性的类型是`String?`。因此尽管在可选类型属性前使用了两层可选链，`john.residence?.address?.street`的返回值类型也是`String?`。
+需要注意的是，上面的例子中，street的属性为String?。john.residence?.address?.street的返回值也依然是String?，即使已经进行了两次可空的链式调用。
 
-如果你为`Address`设定一个实例来作为`john.residence.address`的值，并为`address`的`street`属性设定一个实际值，你可以通过多层可选链来得到这个属性值。
+如果把john.residence.address指向一个实例，并且为address中的street属性赋值，我们就能过通过可空链式调用来访问street属性。
 
-```swift
-let johnsAddress = Address()
-johnsAddress.buildingName = "The Larches"
-johnsAddress.street = "Laurel Street"
-john.residence!.address = johnsAddress
-```
+	let johnsAddress = Address()
+	johnsAddress.buildingName = "The Larches"
+	johnsAddress.street = "Laurel Street"
+	john.residence?.address = johnsAddress
+ 	
+	if let johnsStreet = john.residence?.address?.street {
+	    print("John's street name is \(johnsStreet).")
+	} else {
+	    print("Unable to retrieve the address.")
+	}
+	// prints "John's street name is Laurel Street."
+在上面的例子中，因为john.residence是一个可用的Residence实例，所以对john.residence的address属性赋值成功。
 
-```swift
-if let johnsStreet = john.residence?.address?.street {
-    print("John's street name is \(johnsStreet).")
-} else {
-    print("Unable to retrieve the address.")
-}
-// 打印 "John's street name is Laurel Street."。
-```
+##对返回可空值的函数进行链接
+上面的例子说明了如何通过可空链式调用来获取可空属性值。我们还可以通过可空链式调用来调用返回可空值的方法，并且可以继续对可空值进行链接。
 
-值得注意的是，“`!`”符号在给`john.residence.address`分配`address`实例时的使用。`john.residence`属性是一个可选类型，因此你需要在它获取`address`属性之前使用`!`解析以获得它的实际值。
+在下面的例子中，通过可空链式调用来调用Address的buildingIdentifier()方法。这个方法返回String?类型。正如上面所说，通过可空链式调用的方法的最终返回值还是String?：
+ 
+	if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
+	    print("John's building identifier is \(buildingIdentifier).")
+	}
+	// prints "John's building identifier is The Larches."
 
-<a name="chaining_on_methods_with_optional_return_values"></a>
-##链接可选返回值的方法
+如果要进一步对方法的返回值进行可空链式调用，在方法buildingIdentifier()的圆括号后面加上问号：
 
-前面的例子解释了如何通过可选链来获得可选类型属性值。你也可以通过可选链调用一个返回可选类型值的方法并按需链接该方法的返回值。
-
-下面的例子通过可选链调用了`Address`类中的`buildingIdentifier` 方法。这个方法的返回值类型是`String?`。如上所述，这个方法在可选链调用后最终的返回值类型依然是`String?`：
-
-```swift
-if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
-    print("John's building identifier is \(buildingIdentifier).")
-}
-// 打印 "John's building identifier is The Larches."。
-```
-
-如果你还想进一步对方法返回值执行可选链，将可选链问号符放在方法括号的后面：
-
-```swift
-if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {
-    print("John's uppercase building identifier is \(upper).")
-}
-// 打印 "John's uppercase building identifier is THE LARCHES."。
-```
-
-> 注意：  
-在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是`buildingIdentifier`方法的返回值，不是`buildingIdentifier`方法本身。
-=======
------------------
-可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。
-
->
-注意：
-Swift 的可空链式调用和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且能够检查调用是否成功。
-
-##可空链式调用作为强制展开的另一个方案
-通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，然而强制展开将会触发运行时错误。
-
-为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回nil则说明调用失败。
-
-特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回Int的类型的结果将会返回Int?类型。
-
-下面几段代码将解释可空链式调用和强制展开的不同。
-首先定义两个类Person和Residence。
-
-	class Person {
-	var residence: Residence?
-	}
-	class Residence {
-	var numberOfRooms = 1
-	}
-
-Residence有一个Int类型的属性numberOfRooms，其默认值为1。Person具有一个可空的residence属性，其类型为Residence？。
-
-如果创建一个新的Person实例，因为它的residence属性是可空的，john属性将初始化为nil：
-
-	let john = Person()
-
-如果使用叹号（！）强制展开获得这个john的residence属性中的numberOfRooms值，会触发运行时错误，因为这时没有可以展开的residence：
-
-	let roomCount = john.residence!.numberOfRooms
-	// this triggers a runtime error
-
-john.residence非空的时候，上面的调用成功，并且把roomCount设置为Int类型的房间数量。正如上面说到的，当residence为空的时候上面这段代码会触发运行时错误。
-
-可空链式调用提供了一种另一种访问numberOfRooms的方法，使用问号（？）来代替原来叹号（！）的位置：
-
-	if let roomCount = john.residence?.numberOfRooms {
-	    print("John's residence has \(roomCount) room(s).")
-	} else {
-	    print("Unable to retrieve the number of rooms.")
-	}
-	// prints "Unable to retrieve the number of rooms."
-
-在residence后面添加问号之后，Swift就会在residence不为空的情况下访问numberOfRooms。
-
-因为访问numberOfRooms有可能失败，可空链式调用会返回Int?类型，或称为“可空的Int”。如上例所示，当residence为nil的时候，可空的Int将会为nil，表明无法访问numberOfRooms。
-
-要注意的是，即使numberOfRooms是不可空的Int时，这一点也成立。只要是通过可空链式调用就意味着最后numberOfRooms返回一个Int？而不是Int。
-
-通过赋给john.residence一个Residence的实例变量：
-
-	john.residence = Residence()
-这样john.residence不为nil了。现在就可以正常访问john.residence.numberOfRooms，其值为默认的1，类型为Int?：
-
-	if let roomCount = john.residence?.numberOfRooms {
-	print("John's residence has \(roomCount) room(s).")
-	} else {
-	print("Unable to retrieve the number of rooms.")
-	}
-	// prints "John's residence has 1 room(s)."
-##为可空链式调用定义模型类
-通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。并且判断能否访问子属性的属性，方法或下标。
-
-下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在Person和Residence的基础上增加了Room和Address，以及相关的属性，方法以及下标。
-
-Person类定义基本保持不变：
-
-	class Person {
-	    var residence: Residence?
-	}
-Residence类比之前复杂些，增加了一个Room类型的空数组room：
-
-	class Residence {
-	    var rooms = [Room]()
-	    var numberOfRooms: Int {
-	        return rooms.count
-	    }
-	    subscript(i: Int) -> Room {
-	        get {
-	            return rooms[i]
-	        }
-	        set {
-	            rooms[i] = newValue
-	        }
-	    }
-	    func printNumberOfRooms() {
-	        print("The number of rooms is \(numberOfRooms)")
-	    }
-	    var address: Address?
-	}
-
-现在Residence有了一个存储Room类型的数组，numberOfRooms属性需要计算，而不是作为单纯的变量。计算后的numberOfRooms返回rooms数组的count属性值。现在的Residence还提供访问rooms数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供printNumberOfRooms方法，这个方法的作用就是输出这个房子中房间的数量。最后，Residence定义了一个可空属性address，其类型为Address?。Address类的定义在下面会说明。
-
-类Room是一个简单类，只包含一个属性name，以及一个初始化函数：
-
-	class Room {
-	    let name: String
-	    init(name: String) { self.name = name }
-	}
-最后一个类是Address，这个类有三个String?类型的可空属性。buildingName以及buildingNumber属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称：
-
-	class Address {
-	    var buildingName: String?
-	    var buildingNumber: String?
-	    var street: String?
-	    func buildingIdentifier() -> String? {
-	        if buildingName != nil {
-	            return buildingName
-	        } else if buildingNumber != nil {
-	            return buildingNumber
-	        } else {
-	            return nil
-	        }
-	    }
-	}
-类Address提供buildingIdentifier()方法，返回值为String?。 如果buildingName不为空则返回buildingName， 如果buildingNumber不为空则返回buildingNumber。如果这两个属性都为空则返回nil。
-
-##通过可空链式调用访问属性
-正如[可空链式调用作为强制展开的另一个方案]中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。
-
-下面的代码创建了一个Person实例，然后访问numberOfRooms属性：
-
-	let john = Person()
-	if let roomCount = john.residence?.numberOfRooms {
-	    print("John's residence has \(roomCount) room(s).")
-	} else {
-	    print("Unable to retrieve the number of rooms.")
-	}
-	// prints "Unable to retrieve the number of rooms."
-因为john.residence为nil，所以毫无疑问这个可空链式调用失败。
-
-通过可空链式调用来设定属性值：
-
-	let someAddress = Address()
-	someAddress.buildingNumber = "29"
-	someAddress.street = "Acacia Road"
-	john.residence?.address = someAddress
-在这个例子中，通过john.residence来设定address属性也是不行的，因为john.residence为nil。
-
-##通过可空链式调用来调用方法
-可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
-Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值：
-
-	func printNumberOfRooms() {
-	    print("The number of rooms is \(numberOfRooms)")
-	}
-这个方法没有返回值。但是没有返回值的方法隐式返回Void类型，如[无返回值函数](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID163)中所述。这意味着没有返回值的方法也会返回()或者空的元组。
-
-如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为Void?，而不是Void，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用if语句来判断能否成功调用printNumberOfRooms()方法，即使方法本身没有定义返回值。通过返回值是否为nil可以判断调用是否成功：
-
-	if john.residence?.printNumberOfRooms() != nil {
-	    print("It was possible to print the number of rooms.")
-	} else {
-	    print("It was not possible to print the number of rooms.")
-	}
-	// prints "It was not possible to print the number of rooms."
-同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给john.residence中的address属性赋值，即使residence为nil。通过可空链式调用给属性赋值会返回Void?，通过判断返回值是否为nil可以知道赋值是否成功：
-
-	if (john.residence?.address = someAddress) != nil {
-	print("It was possible to set the address.")
-	} else {
-	print("It was not possible to set the address.")
-	}
-	// prints "It was not possible to set the address."
-
-##通过可空链式调用来访问下标
-通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。
->
-注意：
-当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。可空链式调用的问号一般直接跟在可空表达式的后面。
-
-下面这个例子用下标访问john.residence中rooms数组中第一个房间的名称，因为john.residence为nil，所以下标调用毫无疑问失败了：
-
-	if let firstRoomName = john.residence?[0].name {
-	    print("The first room name is \(firstRoomName).")
-	} else {
-	    print("Unable to retrieve the first room name.")
-	}
-	// prints "Unable to retrieve the first room name."
-在这个例子中，问号直接放在john.residence的后面，并且在方括号的前面，因为john.residence是可空值。
-
-类似的，可以通过下标，用可空链式调用来赋值：
-
-	let johnsHouse = Residence()
-	johnsHouse.rooms.append(Room(name: "Living Room"))
-	johnsHouse.rooms.append(Room(name: "Kitchen"))
-	john.residence = johnsHouse
-	if let firstRoomName = john.residence?[0].name {
-	print("The first room name is \(firstRoomName).")
-	} else {
-	print("Unable to retrieve the first room name.")
-	}
-	// prints "The first room name is Living Room."
-
-##访问可空类型的下标：
-如果下标返回可空类型值，比如Swift中Dictionary的key下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值：
-
-	var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
-	testScores["Dave"]?[0] = 91
-	testScores["Bev"]?[0]++
-	testScores["Brian"]?[0] = 72
-	// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]
-上面的例子中定义了一个testScores数组，包含了两个键值对， 把String类型的key映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个key存在。但是key“Brian”在字典中不存在，所以第三个调用失败。
-
-##多层链接
-可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。
-
-也就是说：
-
-+ 如果你访问的值不是可空的，通过可空链式调用将会放回可空值。
-+ 如果你访问的值已经是可空的，通过可空链式调用不会变得“更”可空。
-
-因此：
-
-+ 通过可空链式调用访问一个Int值，将会返回Int？，不过进行了多少次可空链式调用。
-+ 类似的，通过可空链式调用访问Int?值，并不会变得更加可空。
-
-下面的例子访问john中的residence中的address中的street属性。这里使用了两层可空链式调用，residence以及address，这两个都是可空值。
-
-	if let johnsStreet = john.residence?.address?.street {
-	    print("John's street name is \(johnsStreet).")
-	} else {
-	    print("Unable to retrieve the address.")
-	}
-	// prints "Unable to retrieve the address."
-
-john.residence包含Residence实例，但是john.residence.address为nil。因此，不能访问john.residence?.address?.street。
-
-需要注意的是，上面的例子中，street的属性为String?。john.residence?.address?.street的返回值也依然是String?，即使已经进行了两次可空的链式调用。
-
-如果把john.residence.address指向一个实例，并且为address中的street属性赋值，我们就能过通过可空链式调用来访问street属性。
-
-	let johnsAddress = Address()
-	johnsAddress.buildingName = "The Larches"
-	johnsAddress.street = "Laurel Street"
-	john.residence?.address = johnsAddress
- 	
-	if let johnsStreet = john.residence?.address?.street {
-	    print("John's street name is \(johnsStreet).")
-	} else {
-	    print("Unable to retrieve the address.")
-	}
-	// prints "John's street name is Laurel Street."
-在上面的例子中，因为john.residence是一个可用的Residence实例，所以对john.residence的address属性赋值成功。
-
-##对返回可空值的函数进行链接
-上面的例子说明了如何通过可空链式调用来获取可空属性值。我们还可以通过可空链式调用来调用返回可空值的方法，并且可以继续对可空值进行链接。
-
-在下面的例子中，通过可空链式调用来调用Address的buildingIdentifier()方法。这个方法返回String?类型。正如上面所说，通过可空链式调用的方法的最终返回值还是String?：
- 
-	if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
-	    print("John's building identifier is \(buildingIdentifier).")
-	}
-	// prints "John's building identifier is The Larches."
-
-如果要进一步对方法的返回值进行可空链式调用，在方法buildingIdentifier()的圆括号后面加上问号：
-
-	if let beginsWithThe =
-	john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
-	if beginsWithThe {
-	print("John's building identifier begins with \"The\".")
-	} else {
-	print("John's building identifier does not begin with \"The\".")
-	}
-	}
-	// prints "John's building identifier begins with "The"."
->	
-注意：
-在上面的例子中在，在方法的圆括号后面加上问号是因为buildingIdentifier()的返回值是可空值，而不是方法本身是可空的。
->>>>>>> Stashed changes
+	if let beginsWithThe =
+	john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
+	if beginsWithThe {
+	print("John's building identifier begins with \"The\".")
+	} else {
+	print("John's building identifier does not begin with \"The\".")
+	}
+	}
+	// prints "John's building identifier begins with "The"."
+>	
+注意：
+在上面的例子中在，在方法的圆括号后面加上问号是因为buildingIdentifier()的返回值是可空值，而不是方法本身是可空的。

From f39bd06843f786efd54112e83cae94ab57abee3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Wed, 22 Jul 2015 21:45:29 +0800
Subject: [PATCH 130/228] add author info

---
 source/chapter2/17_Optional_Chaining.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index 84eddd35..6bc5b394 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,5 +1,8 @@
 # Optional Chaining
 
+> 翻译：[Jasonbroker](https://github.com/Jasonbroker)  
+> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
+
 -----------------
 可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。
 

From 7db8009b1f7d2682e8cffb1f1f7c8370e95de7a9 Mon Sep 17 00:00:00 2001
From: KYawn <K.Yawn@icloud.com>
Date: Thu, 23 Jul 2015 18:06:55 +0800
Subject: [PATCH 131/228] chapter3 part6 objc attribute

---
 source/chapter3/06_Attributes.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/06_Attributes.md b/source/chapter3/06_Attributes.md
index e6063258..603f8cf2 100755
--- a/source/chapter3/06_Attributes.md
+++ b/source/chapter3/06_Attributes.md
@@ -95,7 +95,7 @@ class MyClass {
 
 该特性用于修饰任何可以在Objective-C中表示的声明。比如，非嵌套类、协议、非泛型枚举（仅限整型值类型）、类和协议的属性和方法（包括`getter`和`setter`）、构造器、析构器以及下标。`objc`特性告诉编译器这个声明可以在Objective-C代码中使用。
 
-如果你将`objc`特性应用于一个类或协议，它也会隐式地应用于那个类的成员或协议。对于标记了`objc`特性的类，编译器会隐式地为它的子类添加`objc`特性。标记了`objc`特性的协议不能继承没有标记`objc`的协议。
+标有`objc`特性的类必须继承自Objective-C中定义的类。如果你将`objc`特性应用于一个类或协议，它也会隐式地应用于那个类的成员或协议。对于标记了`objc`特性的类，编译器会隐式地为它的子类添加`objc`特性。标记了`objc`特性的协议不能继承没有标记`objc`的协议。
 
 如果你将`objc`特性应用于枚举，每一个枚举的`case`都会以枚举名称和`case`名称组合的方式暴露在Objective-C代码中。例如：一个名为`Venus`的`case`在`Planet`枚举中，这个`case`暴露在Objective-C代码中时叫做`PlanetVenus`。
 

From 21306131c0efcfa562e608cfcdedd5c89add3713 Mon Sep 17 00:00:00 2001
From: Wang Ming <wangmchn@163.com>
Date: Fri, 24 Jul 2015 15:45:28 +0800
Subject: [PATCH 132/228] Update 14_Initialization.md

---
 source/chapter2/14_Initialization.md | 44 ++++++++++++++--------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index cf1149dc..9f2583fc 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -717,13 +717,13 @@ if anonymousCreature == nil {
 ```
 
 > 注意：
-空字符串（```""```）和一个值为```nil```的可选类型的字符串是两个完全不同的概念。上例中的空字符串（`""`）其实是一个有效的，非可选类型的字符串。这里我们只所以让`Animal`的可失败构造器，构建对象失败，只是因为对于`Animal`这个类的`species`属性来说，它更适合有一个具体的值，而不是空字符串。
+空字符串（`""`）和一个值为`nil`的可选类型的字符串是两个完全不同的概念。上例中的空字符串（`""`）其实是一个有效的，非可选类型的字符串。这里我们只所以让`Animal`的可失败构造器，构建对象失败，只是因为对于`Animal`这个类的`species`属性来说，它更适合有一个具体的值，而不是空字符串。
 
 ###枚举类型的可失败构造器
 
 你可以通过构造一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。还能在参数不满足你所期望的条件时，导致构造失败。
 
-下例中，定义了一个名为TemperatureUnit的枚举类型。其中包含了三个可能的枚举成员(```Kelvin```，```Celsius```，和 ```Fahrenheit```)和一个被用来找到```Character```值所对应的枚举成员的可失败构造器：
+下例中，定义了一个名为TemperatureUnit的枚举类型。其中包含了三个可能的枚举成员(`Kelvin`，`Celsius`，和 `Fahrenheit`)和一个被用来找到`Character`值所对应的枚举成员的可失败构造器：
 
 ```swift
 enum TemperatureUnit {
@@ -761,7 +761,7 @@ if unknownUnit == nil {
 
 ###带原始值的枚举类型的可失败构造器
 
-带原始值的枚举类型会自带一个可失败构造器```init?(rawValue:)```,该可失败构造器有一个名为```rawValue```的默认参数,其类型和枚举类型的原始值类型一致，如果该参数的值能够和枚举类型成员所带的原始值匹配，则该构造器构造一个带此原始值的枚举成员，否则构造失败。
+带原始值的枚举类型会自带一个可失败构造器`init?(rawValue:)`,该可失败构造器有一个名为`rawValue`的默认参数,其类型和枚举类型的原始值类型一致，如果该参数的值能够和枚举类型成员所带的原始值匹配，则该构造器构造一个带此原始值的枚举成员，否则构造失败。
 
 因此上面的 TemperatureUnit的例子可以重写为：
 
@@ -785,9 +785,9 @@ if unknownUnit == nil {
 
 ###类的可失败构造器
 
-值类型（如结构体或枚举类型）的可失败构造器，对何时何地触发构造失败这个行为没有任何的限制。比如在前面的例子中，结构体```Animal```的可失败构造器触发失败的行为，甚至发生在`species`属性的值被初始化以前。而对类而言，就没有那么幸运了。类的可失败构造器只能在所有的类属性被初始化后和所有类之间的构造器之间的代理调用发生完后触发失败行为。
+值类型（如结构体或枚举类型）的可失败构造器，对何时何地触发构造失败这个行为没有任何的限制。比如在前面的例子中，结构体`Animal`的可失败构造器触发失败的行为，甚至发生在`species`属性的值被初始化以前。而对类而言，就没有那么幸运了。类的可失败构造器只能在所有的类属性被初始化后和所有类之间的构造器之间的代理调用发生完后触发失败行为。
 
-下例子中，定义了一个名为```Product```的类，其内部结构和结构体```Animal```很相似，内部也有一个名为```name```的```String```类型的属性。由于该属性的值同样不能为空字符串，所以我们加入了可失败构造器来确保该类满足上述条件。但由于```Product```类不是一个结构体，所以当想要在该类中添加可失败构造器触发失败条件时，必须确保```name```属性被初始化。因此我们把```name```属性的```String```类型做了一点点小小的修改，把其改为隐式解析可选类型（```String!```），来确保可失败构造器触发失败条件时，所有类属性都被初始化了。因为所有可选类型都有一个默认的初始值```nil```。因此最后```Product```类可写为：
+下例子中，定义了一个名为`Product`的类，其内部结构和结构体`Animal`很相似，内部也有一个名为`name`的`String`类型的属性。由于该属性的值同样不能为空字符串，所以我们加入了可失败构造器来确保该类满足上述条件。但由于`Product`类不是一个结构体，所以当想要在该类中添加可失败构造器触发失败条件时，必须确保`name`属性被初始化。因此我们把`name`属性的`String`类型做了一点点小小的修改，把其改为隐式解析可选类型（`String!`），来确保可失败构造器触发失败条件时，所有类属性都被初始化了。因为所有可选类型都有一个默认的初始值`nil`。因此最后`Product`类可写为：
 
 ```swift
 class Product {
@@ -799,7 +799,7 @@ class Product {
 }
 ```
 
-因为```name```属性是一个常量，所以一旦```Product```类构造成功，```name```属性肯定有一个非```nil```的值。因此完全可以放心大胆的直接访问```Product```类的```name```属性，而不用考虑去检查```name```属性是否有值。
+因为`name`属性是一个常量，所以一旦`Product`类构造成功，`name`属性肯定有一个非`nil`的值。因此完全可以放心大胆的直接访问`Product`类的`name`属性，而不用考虑去检查`name`属性是否有值。
 
 ```swift
 if let bowTie = Product(name: "bow tie") {
@@ -818,7 +818,7 @@ if let bowTie = Product(name: "bow tie") {
 >注意：
 可失败构造器也可以代理调用其它的非可失败构造器。通过这个方法，你可以为已有的构造过程加入构造失败的条件。
 
-下面这个例子，定义了一个名为```CartItem```的```Product```类的子类。这个类建立了一个在线购物车中的物品的模型，它有一个名为```quantity```的常量参数，用来表示该物品的数量至少为1：
+下面这个例子，定义了一个名为`CartItem`的`Product`类的子类。这个类建立了一个在线购物车中的物品的模型，它有一个名为`quantity`的常量参数，用来表示该物品的数量至少为1：
 
 ```swift
 class CartItem: Product {
@@ -831,13 +831,13 @@ class CartItem: Product {
 }
 ```
 
-和```Product```类中的```name```属性相类似的，```CartItem```类中的```quantity```属性的类型也是一个隐式解析可选类型，只不过由（```String！```）变为了（```Int!```）。这样做都是为了确保在构造过程中，该属性在被赋予特定的值之前能有一个默认的初始值nil。
+和`Product`类中的`name`属性相类似的，`CartItem`类中的`quantity`属性的类型也是一个隐式解析可选类型，只不过由（`String!`）变为了（`Int!`）。这样做都是为了确保在构造过程中，该属性在被赋予特定的值之前能有一个默认的初始值nil。
 
-可失败构造器总是先向上代理调用基类,```Product```的构造器 ```init(name:)```。这满足了可失败构造器在触发构造失败这个行为前必须总是执行构造代理调用这个条件。
+可失败构造器总是先向上代理调用基类,`Product`的构造器 `init(name:)`。这满足了可失败构造器在触发构造失败这个行为前必须总是执行构造代理调用这个条件。
 
-如果由于```name```的值为空而导致基类的构造器在构造过程中失败。则整个`CartIem`类的构造过程都将失败，后面的子类的构造过程都将不会被执行。如果基类构建成功，则继续运行子类的构造器代码。
+如果由于`name`的值为空而导致基类的构造器在构造过程中失败。则整个`CartIem`类的构造过程都将失败，后面的子类的构造过程都将不会被执行。如果基类构建成功，则继续运行子类的构造器代码。
 
-如果你构造了一个```CartItem```对象，并且该对象的```name```属性不为空以及```quantity```属性为1或者更多，则构造成功：
+如果你构造了一个`CartItem`对象，并且该对象的`name`属性不为空以及`quantity`属性为1或者更多，则构造成功：
 
 ```swift
 if let twoSocks = CartItem(name: "sock", quantity: 2) {
@@ -845,7 +845,7 @@ if let twoSocks = CartItem(name: "sock", quantity: 2) {
 }
 // 打印 "Item: sock, quantity: 2"
 ```
-如果你构造一个```CartItem```对象，其```quantity```的值```0```, 则```CartItem```的可失败构造器触发构造失败的行为:
+如果你构造一个`CartItem`对象，其`quantity`的值`0`, 则`CartItem`的可失败构造器触发构造失败的行为:
 
 ```swift
 if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
@@ -856,7 +856,7 @@ if let zeroShirts = CartItem(name: "shirt", quantity: 0) {
 // 打印 "Unable to initialize zero shirts"
 ```
 
-类似的, 如果你构造一个```CartItem```对象，但其```name```的值为空, 则基类```Product```的可失败构造器将触发构造失败的行为，整个```CartItem```的构造行为同样为失败：
+类似的, 如果你构造一个`CartItem`对象，但其`name`的值为空, 则基类`Product`的可失败构造器将触发构造失败的行为，整个`CartItem`的构造行为同样为失败：
 
 ```swift
 if let oneUnnamed = CartItem(name: "", quantity: 1) {
@@ -876,7 +876,7 @@ if let oneUnnamed = CartItem(name: "", quantity: 1) {
 >注意：
 你可以用一个非可失败构造器重写一个可失败构造器，但反过来却行不通。
 
-下例定义了一个名为```Document```的类，这个类中的```name```属性允许为```nil```和一个非空字符串，但不能是一个空字符串：
+下例定义了一个名为`Document`的类，这个类中的`name`属性允许为`nil`和一个非空字符串，但不能是一个空字符串：
 
 ```swift
 class Document {
@@ -891,7 +891,7 @@ class Document {
 }
 ```
 
-下面这个例子，定义了一个名为```AutomaticallyNamedDocument```的```Document```类的子类。这个子类重写了基类的两个指定构造器。确保了不论在何种情况下```name```属性总是有一个非空字符串```[Untitled]```的值。
+下面这个例子，定义了一个名为`AutomaticallyNamedDocument`的`Document`类的子类。这个子类重写了基类的两个指定构造器。确保了不论在何种情况下`name`属性总是有一个非空字符串`[Untitled]`的值。
 
 ```swift
 class AutomaticallyNamedDocument: Document {
@@ -910,20 +910,20 @@ class AutomaticallyNamedDocument: Document {
 }
 ```
 
-```AutomaticallyNamedDocument```用一个非可失败构造器```init(name:)```,重写了基类的可失败构造器```init?(name:)```。因为子类用不同的方法处理了```name```属性的值为一个空字符串的这种情况。所以子类将不再需要一个可失败的构造器。
+`AutomaticallyNamedDocument`用一个非可失败构造器`init(name:)`,重写了基类的可失败构造器`init?(name:)`。因为子类用不同的方法处理了`name`属性的值为一个空字符串的这种情况。所以子类将不再需要一个可失败的构造器。
 
 ###可失败构造器 init!
 
-通常来说我们通过在```init```关键字后添加问号的方式来定义一个可失败构造器，但你也可以使用通过在```init```后面添加惊叹号的方式来定义一个可失败构造器```（init!）```，该可失败构造器将会构建一个特定类型的隐式解析可选类型的对象。
+通常来说我们通过在`init`关键字后添加问号的方式来定义一个可失败构造器，但你也可以使用通过在`init`后面添加惊叹号的方式来定义一个可失败构造器`(init!)`，该可失败构造器将会构建一个特定类型的隐式解析可选类型的对象。
 
-你可以在 ```init？```构造器中代理调用 ```init！```构造器，反之亦然。
-你也可以用 ```init？```重写 ```init！```，反之亦然。
-你还可以用 ```init```代理调用```init！```，但这会触发一个断言：是否 ```init！```构造器会触发构造失败？
+你可以在 `init? `构造器中代理调用 `init!`构造器，反之亦然。
+你也可以用 `init?`重写 `init!`，反之亦然。
+你还可以用 `init`代理调用`init!`，但这会触发一个断言：是否 `init!` 构造器会触发构造失败？
 
 <a name="required_initializers"></a>
 ##必要构造器
 
-在类的构造器前添加```required```修饰符表明所有该类的子类都必须实现该构造器：
+在类的构造器前添加 `required` 修饰符表明所有该类的子类都必须实现该构造器：
 
 ```swift
 class SomeClass {
@@ -932,7 +932,7 @@ class SomeClass {
     }
 }
 ```
-当子类重写基类的必要构造器时，必须在子类的构造器前同样添加```required```修饰符以确保当其它类继承该子类时，该构造器同为必要构造器。在重写基类的必要构造器时，不需要添加```override```修饰符：
+当子类重写基类的必要构造器时，必须在子类的构造器前同样添加`required`修饰符以确保当其它类继承该子类时，该构造器同为必要构造器。在重写基类的必要构造器时，不需要添加`override`修饰符：
 
 ```swift
 class SomeSubclass: SomeClass {

From c599703ff37b4ec4af3e62af9d09e7fe80b4346d Mon Sep 17 00:00:00 2001
From: Lenhoon <393509661@qq.com>
Date: Fri, 24 Jul 2015 20:48:32 +0800
Subject: [PATCH 133/228] update to 2015 7 21

---
 source/chapter3/05_Declarations.md | 32 +++++++++++++++++++++++++-----
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md
index be67b2ec..cc141e17 100755
--- a/source/chapter3/05_Declarations.md
+++ b/source/chapter3/05_Declarations.md
@@ -495,6 +495,20 @@ plusOne(10)
 这种形式中，每一个事件块由关键字`case`开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在*关联值类型(associated values types)*的元组里被指定，立即书写在事件
 名后。获得更多关于关联值类型的信息和例子，请查看[关联值(Associated Values)](TODO)一节。
 
+枚举有一个递归结构，就是说，枚举有着枚举类型自身实例的关联值的事件。然而，枚举类型的实例有值语义，意味着它们在内存中有着固定的位置。为了支持递归，编译器必需插入一个间接层。
+
+为间接使用特殊的枚举事件，使用`indirect`声明修饰符标记。
+
+> enum Tree<T> {
+> 		case Empty
+> 		indirect case Node(value: T, left: Tree, right:Tree)
+> }
+
+为了间接的使用一个枚举的所有事件，使用`indirect`修饰符标记整个枚举-当枚举有许多事件且每个事件都需要使用`indirect`修饰符标记的时候这将非常便利。
+
+一个被`indirect`修饰符标记的枚举事件必需有一个关联值。一个使用`indirect`修饰符标记的枚举包含有着关联值的事件和没有关联值的事件的混合。就是说，它不能包含任何也使用`indirect`修饰符标记的事件。
+
+
 <a name="enumerations_with_cases_of_a_raw-value_type"></a>
 ###使用原始值类型事件的枚举(Enumerations with Cases of a Raw-Value Type)
 
@@ -505,9 +519,9 @@ plusOne(10)
 >		case `enumeration case 2` = `raw value 2`  
 > }  
 
-在这种形式中，每一个事件块由`case`关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做*原始值(raw value)*。这些值的类型在*原始值类型(raw-value type)*中被指定，必须表示一个整数，浮点数，字符串，或者一个字符。特别是*原始值类型(raw-value type)*必需遵守`Equatable`类型的协议和下列形式中的一种字面量构造协议(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮点行字面量有`FloatingPointLiteralConvertible`，包含任意数量字符的字符串型字面量有`StringLiteralConvertible`，仅包含一个单一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。
-
-每一个事件必须有唯一的名字，必须有一个唯一的初始值。如果初始值类型被指定为`Int`，则不必为事件显式的指定值，它们会隐式的被标为值`0,1,2`等。每一个没有被赋值的`Int`类型时间会隐式的赋予一个初始值，它们是自动递增的。
+在这种形式中，每一个事件块由`case`关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做*原始值(raw value)*。这些值的类型在*原始值类型(raw-value type)*中被指定，必须表示一个整数，浮点数，字符串，或者一个字符。特别是*原始值类型(raw-value type)*必需遵守`Equatable`类型的协议和下列形式中的一种字面量构造协议(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮点行字面量有`FloatingPointLiteralConvertible`，包含任意数量字符的字符串型字面量有`StringLiteralConvertible`，仅包含一个单一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。每一个事件必须有唯一的名字，必须有一个唯一的初始值。
+
+如果初始值类型被指定为`Int`，则不必为事件显式的指定值，它们会隐式的被标为值`0,1,2`等。每一个没有被赋值的`Int`类型时间会隐式的赋予一个初始值，它们是自动递增的。
 
 ```Swift
 num ExampleEnum: Int {
@@ -517,6 +531,14 @@ num ExampleEnum: Int {
 
 在上面的例子中，`ExampleEnum.A`的值是`0`，`ExampleEnum.B`的值是`1`。因为`ExampleEnum.C`的值被显式的设定为`5`，因此`ExampleEnum.D`的值会自动增长为`6`。
 
+如果原始值类型被指定为`String`类型，你不用明确的为事件指定值，每一个没有指定的事件会隐式地用与事件名字相同的字符串指定。
+
+> enum WeekendDay: String {
+> 		case Saturday, Sunday
+> }
+
+在上面这个例子中，`WeekendDay.Saturday`的原始值是`"Saturday"`,`WeekendDay.Sunday`的原始值是`"Sunday"`。
+
 拥有多种事件的原始值类型的枚举含蓄地遵循定义在Swift标准库中的`RawRepresentable`协议。所以，它们拥有一个原始值(`rawValue`)属性和一个有着`init?(rawValue: RawValue)`签名的可失败构造器(a failable initializer)。可以使用原始值属性去取的枚举事件的原始值，就像在`ExampleEnum.B.rawValue`中一样。如果有一个事件符合，也可以使用原始值去找到一个符合的事件，通过调用枚举的可失败构造器，如`ExampleEnum(rawValue: 5)`,这个可失败构造器返回一个可选的事件。想得到更多的信息和关于原始值类型查看更多信息和获取初始值类型事件的信息，参阅初始值[原始值(Raw Values)](TODO)。
 
 <a name="accessing_enumeration_cases"></a>
@@ -530,10 +552,10 @@ num ExampleEnum: Int {
 > 枚举声明语法 
 > *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO) 
 > *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO)  _可选_ [*原始值式枚举*](..\chapter3\05_Declarations.html#raw_value_style_enum) 
-> *联合式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [类型继承子句](TODO)_可选_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
+> *联合式枚举* → **indirect** _可选_ **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [类型继承子句](TODO)_可选_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
 > *union-style-enum-members* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_  
 > *union-style-enum-member* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case子句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)  
-> *联合式(Union Style)的枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
+> *联合式(Union Style)的枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **indirect** _可选_ **case** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
 > *联合式(Union Style)的枚举case列表* → [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
 > *联合式(Union Style)的case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组类型*](..\chapter3\03_Types.html#tuple_type) _可选_  
 > *枚举名* → [*标识符*](LexicalStructure.html#identifier)  

From 19cfcda5dbc1ab56341bdc3d9b62029c320da711 Mon Sep 17 00:00:00 2001
From: lifeng <88274310@qq.com>
Date: Fri, 24 Jul 2015 23:58:56 +0800
Subject: [PATCH 134/228] fix some error code

---
 source/chapter2/04_Collection_Types.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index c8795de5..fda9f2b0 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -361,7 +361,7 @@ favoriteGenres.insert("Jazz")
 
 ```swift
 if let removedGenre = favoriteGenres.remove("Rock") {
-    print("\(removedValue)? I'm over it.")
+    print("\(removedGenre)? I'm over it.")
 } else {
     print("I never much cared for that.")
 }
@@ -456,7 +456,7 @@ let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
 let cityAnimals: Set = ["🐦", "🐭"]
 houseAnimals.isSubsetOf(farmAnimals)
 // true
-farmAnimals.isSuperSetOf(houseAnimals)
+farmAnimals.isSupersetOf(houseAnimals)
 // true
 farmAnimals.isDisjointWith(cityAnimals)
 // true
@@ -495,7 +495,7 @@ Swift 的字典使用`Dictionary<Key, Value>`定义，其中`Key`是字典中键
 我们可以像数组一样使用构造语法创建一个拥有确定类型的空字典：
 
 ```swift
-var namesOfIntegers = [Int: String]
+var namesOfIntegers = [Int: String]()
 // namesOfIntegers 是一个空的 [Int: String] 字典
 ```
 

From a0863d558a9b77db54a868ae3bb433538c0aac53 Mon Sep 17 00:00:00 2001
From: 100mango <100mango@users.noreply.github.com>
Date: Sat, 25 Jul 2015 17:09:14 +0800
Subject: [PATCH 135/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=80=BC=E6=8D=95?=
 =?UTF-8?q?=E8=8E=B7=E7=AB=A0=E8=8A=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/07_Closures.md | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 5023a0b6..d39d877c 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -283,7 +283,7 @@ Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的
 每次调用`incrementor`时，其会以`amount`作为增量增加`runningTotal`的值。
 
 ```swift
-func makeIncrementor(forIncrement amount: Int) -> Void -> Int {
+func makeIncrementor(forIncrement amount: Int) -> () -> Int {
     var runningTotal = 0
     func incrementor() -> Int {
         runningTotal += amount
@@ -293,7 +293,7 @@ func makeIncrementor(forIncrement amount: Int) -> Void -> Int {
 }
 ```
 
-`makeIncrementor`返回类型为`Void -> Int`。
+`makeIncrementor`返回类型为`() -> Int`。
 这意味着其返回的是一个函数，而不是一个简单类型值。
 该函数在每次调用时不接受参数只返回一个`Int`类型的值。
 关于函数返回其他函数的内容，请查看[函数类型作为返回类型](../chapter2/06_Functions.html#function_types_as_return_types)。
@@ -315,16 +315,11 @@ func incrementor() -> Int {
 }
 ```
 
-`incrementor`函数并没有获取任何参数，但是在函数体内访问了`runningTotal`和`amount`变量。这是因为其通过捕获在包含它的函数体内已经存在的`runningTotal`和`amount`变量而实现。
-
-由于没有修改`amount`变量，`incrementor`实际上捕获并存储了该变量的一个副本，而该副本随着`incrementor`一同被存储。
-
-然而，因为每次调用该函数的时候都会修改`runningTotal`的值，`incrementor`捕获了当前`runningTotal`变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当`makeIncrementor`结束时候并不会消失，也保证了当下一次执行`incrementor`函数时，`runningTotal`可以继续增加。
+`incrementer`函数并没有任何参数，但是在函数体内访问了`runningTotal`和`amount`变量。这是因为其通过捕获在包含它的函数体内已经存在的`runningTotal`和`amount`变量的引用(reference)而实现。捕捉了变量引用,保证了`runningTotal`和`amount`变量在调用完`makeIncrementer`后不会消失,并且保证了在下一次执行`incrementer`函数时,`runningTotal`可以继续增加。
 
 > 注意：
-> Swift 会决定捕获引用还是拷贝值。
-> 您不需要标注`amount`或者`runningTotal`来声明在嵌入的`incrementor`函数中的使用方式。
-> Swift 同时也处理`runingTotal`变量的内存管理操作，如果不再被`incrementor`函数使用，则会被清除。
+> 为了优化,Swift可能会捕捉和保存一份对值的拷贝,如果这个值是不可变或是在闭包外的。
+> Swift同样负责被捕捉的所有变量的内存管理,包括释放不被需要的变量。
 
 下面代码为一个使用`makeIncrementor`的例子：
 

From 7cf4ecc8c7e7a1bd5a315003e08d13e245de2a93 Mon Sep 17 00:00:00 2001
From: Michael Xiang <xiangt@bc.edu>
Date: Mon, 27 Jul 2015 11:49:44 -0400
Subject: [PATCH 136/228] cp1,2,3

cp 1,2,3 final draft
---
 source/chapter1/01_swift.md        |   2 +-
 source/chapter1/02_a_swift_tour.md |   2 +-
 source/chapter2/01_The_Basics.md   | 287 +++++++++++++++++++----------
 3 files changed, 189 insertions(+), 102 deletions(-)

diff --git a/source/chapter1/01_swift.md b/source/chapter1/01_swift.md
index 7026bcae..f845f96e 100755
--- a/source/chapter1/01_swift.md
+++ b/source/chapter1/01_swift.md
@@ -1,5 +1,5 @@
 > 翻译：[numbbbbb](https://github.com/numbbbbb)  
-> 校对：[yeahdongcn](https://github.com/yeahdongcn)
+> 校对：[yeahdongcn](https://github.com/yeahdongcn), [xtymichael](https://github.com/xtymichael)
 
 # 关于 Swift
 -----------------
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index b0153af3..e1ccf6b8 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -1,4 +1,4 @@
-> 翻译：[numbbbbb](https://github.com/numbbbbb)
+> 翻译：[numbbbbb](https://github.com/numbbbbb), [xtymichael](https://github.com/xtymichael)
 > 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai)
 
 # Swift 初见
diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 3fb8fee5..c14debff 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -1,4 +1,4 @@
-> 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus)
+> 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus), [xtymichael](https://github.com/xtymichael)
 > 校对：[lslxdx](https://github.com/lslxdx)
 
 # 基础部分
@@ -7,20 +7,34 @@
 本页包含内容：
 
 - [常量和变量](#constants_and_variables)
+- [声明常量和变量](#declaring)
+- [类型标注](#type_annotations)
+- [常量和变量的命名](#naming)
+- [输出常量和变量](#printing)
 - [注释](#comments)
 - [分号](#semicolons)
 - [整数](#integers)
+- [整数范围](#integer_bounds)
+- [Int](#Int)
+- [UInt](#UInt)
 - [浮点数](#floating-point_numbers)
 - [类型安全和类型推断](#type_safety_and_type_inference)
 - [数值型字面量](#numeric_literals)
 - [数值型类型转换](#numeric_type_conversion)
+- [整数转换](#integer_conversion)
+- [数整数和浮点数转换](#integer_and_floating_point_conversion)
 - [类型别名](#type_aliases)
 - [布尔值](#booleans)
 - [元组](#tuples)
 - [可选](#optionals)
+- [nil](#nil)
+- [if 语句以及强制解析](#if)
+- [可选绑定](#optional_binding)
+- [隐式解析可选类型](#implicityly_unwrapped_optionals)
+- [错误处理](#error_handling)
 - [断言](#assertions)
 
-Swift 是一门进行 iOS 和 OS X 应用开发的新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。
+Swift 是一门开发 iOS, OS X 和 watchOS 应用的新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。
 
 Swift 包含了 C 和 Objective-C 上所有基础数据类型，`Int`表示整型值；`Double`和`Float`表示浮点型值；`Bool`是布尔型值；`String`是文本型数据。Swift 还提供了三个基本的集合类型，`Array`，`Set`和`Dictionary`，详见[集合类型](04_Collection_Types.html)。
 
@@ -37,6 +51,7 @@ Swift 是一门类型安全的语言，可选类型就是一个很好的例子
 
 常量和变量把一个名字（比如`maximumNumberOfLoginAttempts`或者`welcomeMessage`）和一个指定类型的值（比如数字`10`或者字符串`"Hello"`）关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。
 
+<a name="declaring"></a>
 ### 声明常量和变量
 
 常量和变量必须在使用前声明，用`let`来声明常量，用`var`来声明变量。下面的例子展示了如何用常量和变量来记录用户尝试登录的次数：
@@ -61,9 +76,10 @@ var x = 0.0, y = 0.0, z = 0.0
 >注意：  
 如果你的代码中有不需要改变的值，请使用`let`关键字将它声明为常量。只将需要改变的值声明为变量。
 
+<a name="type_annotations"></a>
 ### 类型标注
 
-当你声明常量或者变量的时候可以加上_类型标注（type annotation）_，说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。
+当你声明常量或者变量的时候可以加上类型标注（type annotation），说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。
 
 这个例子给`welcomeMessage`变量添加了类型标注，表示这个变量可以存储`String`类型的值：
 
@@ -86,6 +102,7 @@ welcomeMessage = "Hello"
 > 注意：  
 一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考[类型安全和类型推断](#type_safety_and_type_inference)。在上面的例子中，没有给`welcomeMessage`赋初始值，所以变量`welcomeMessage`的类型是通过一个类型标注指定的，而不是通过初始值推断的。
 
+<a name="naming"></a>
 ### 常量和变量的命名
 
 你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符：
@@ -119,30 +136,31 @@ languageName = "Swift++"
 // 这会报编译时错误 - languageName 不可改变
 ```
 
+<a name="printing"></a>
 ### 输出常量和变量
 
-你可以用`println`函数来输出当前常量或变量的值:
+你可以用`print(_:)`函数来输出当前常量或变量的值:
 
 ```swift
-println(friendlyWelcome)
+print(friendlyWelcome)
 // 输出 "Bonjour!"
 ```
 
-`println`是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，`println`将会输出内容到“console”面板上。(另一种函数叫`print`，唯一区别是在输出内容最后不会换行。)
+`print(_:)`是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，`print(_:)`将会输出内容到“console”面板上。(另一种函数叫`print(_:appendNewline:)`，唯一区别是在输出内容最后不会换行。)
 
-`println`函数输出传入的`String`值：
+`print(_:)`函数输出传入的`String`值：
 
 ```swift
-println("This is a string")
+print("This is a string")
 // 输出 "This is a string"
 ```
 
-与 Cocoa 里的`NSLog`函数类似的是，`println`函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。
+`print(_:)`函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。
 
-Swift 用_字符串插值（string interpolation）_的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：
+Swift 用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：
 
 ```swift
-println("The current value of friendlyWelcome is \(friendlyWelcome)")
+print("The current value of friendlyWelcome is \(friendlyWelcome)")
 // 输出 "The current value of friendlyWelcome is Bonjour!
 ```
 
@@ -181,7 +199,7 @@ Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠
 与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号（`;`），当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句：
 
 ```swift
-let cat = "🐱"; println(cat)
+let cat = "🐱"; print(cat)
 // 输出 "🐱"
 ```
 
@@ -192,6 +210,7 @@ let cat = "🐱"; println(cat)
 
 Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是`UInt8`，32位有符号整数类型是`Int32`。就像 Swift 的其他类型一样，整数类型采用大写命名法。
 
+<a name="integer_bounds"></a>
 ### 整数范围
 
 你可以访问不同整数类型的`min`和`max`属性来获取对应类型的最大值和最小值：
@@ -202,6 +221,7 @@ let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型
 ```
 `min`和`max`所传回值的类型，正是其所对的整数类型(如上例UInt8, 所传回的类型是UInt8)，可用在表达式中相同类型值旁。
 
+<a name="Int"></a>
 ### Int
 
 一般来说，你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型`Int`，长度与当前平台的原生字长相同：
@@ -211,6 +231,7 @@ let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型
 
 除非你需要特定长度的整数，一般来说使用`Int`就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，`Int`可以存储的整数范围也可以达到`-2147483648`~`2147483647`，大多数时候这已经足够大了。
 
+<a name="UInt"></a>
 ### UInt
 
 Swift 也提供了一个特殊的无符号类型`UInt`，长度与当前平台的原生字长相同：
@@ -237,15 +258,15 @@ Swift 也提供了一个特殊的无符号类型`UInt`，长度与当前平台
 <a name="type_safety_and_type_inference"></a>
 ## 类型安全和类型推断
 
-Swift 是一个_类型安全（type safe）_的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个`String`，你绝对不可能不小心传进去一个`Int`。
+Swift 是一个类型安全（type safe）的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个`String`，你绝对不可能不小心传进去一个`Int`。
 
-由于 Swift 是类型安全的，所以它会在编译你的代码时进行_类型检查（type checks）_，并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
+由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
 
-当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用_类型推断（type inference）_来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。
+当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用_类型推断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。
 
 因为有类型推断，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
 
-当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个_字面量（literal value 或 literal）_即可触发类型推断。（字面量就是会直接出现在你代码中的值，比如`42`和`3.14159`。）
+当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个字面量（literal value 或 literal）即可触发类型推断。（字面量就是会直接出现在你代码中的值，比如`42`和`3.14159`。）
 
 例如，如果你给一个新常量赋值`42`并且没有标明类型，Swift 可以推断出常量类型是`Int`，因为你给它赋的初始值看起来像一个整数：
 
@@ -291,7 +312,7 @@ let octalInteger = 0o21           // 八进制的17
 let hexadecimalInteger = 0x11     // 十六进制的17
 ```
 
-浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是`0x`）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点字面量还有一个可选的_指数（exponent）_，在十进制浮点数中通过大写或者小写的`e`来指定，在十六进制浮点数中通过大写或者小写的`p`来指定。
+浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是`0x`）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点字面量还有一个可选的指数（exponent，在十进制浮点数中通过大写或者小写的`e`来指定，在十六进制浮点数中通过大写或者小写的`p`来指定。
 
 如果一个十进制数的指数为`exp`，那这个数相当于基数和10^exp的乘积：
 * `1.25e2` 表示 1.25 × 10^2，等于 `125.0`。
@@ -321,8 +342,10 @@ let justOverOneMillion = 1_000_000.000_000_1
 ## 数值型类型转换
 
 通常来讲，即使代码中的整数常量和变量已知非负，也请使用`Int`类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推断。
+
 只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。
 
+<a name="integer_conversion"></a>
 ### 整数转换
 
 不同整数类型的变量和常量可以存储不同范围的数字。`Int8`类型的常量或者变量可以存储的数字范围是`-128`~`127`，而`UInt8`类型的常量或者变量能存储的数字范围是`0`~`255`。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：
@@ -348,6 +371,7 @@ let twoThousandAndOne = twoThousand + UInt16(one)
 
 `SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考[扩展](20_Extensions.html)。
 
+<a name="integer_and_floating_point_conversion"></a>
 ### 整数和浮点数转换
 
 整数和浮点数的转换必须显式指定类型：
@@ -376,7 +400,7 @@ let integerPi = Int(pi)
 <a name="type_aliases"></a>
 ## 类型别名
 
-_类型别名（type aliases）_就是给现有类型定义另一个名字。你可以使用`typealias`关键字来定义类型别名。
+类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用`typealias`关键字来定义类型别名。
 
 当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：
 
@@ -396,7 +420,7 @@ var maxAmplitudeFound = AudioSample.min
 <a name="booleans"></a>
 ## 布尔值
 
-Swift 有一个基本的_布尔（Boolean）_类型，叫做`Bool`。布尔值指_逻辑上的（logical）_，因为它们只能是真或者假。Swift 有两个布尔常量，`true`和`false`：
+Swift 有一个基本的布尔（Boolean）类型，叫做`Bool`。布尔值指逻辑上的（logical，因为它们只能是真或者假。Swift 有两个布尔常量，`true`和`false`：
 
 ```swift
 let orangesAreOrange = true
@@ -409,9 +433,9 @@ let turnipsAreDelicious = false
 
 ```swift
 if turnipsAreDelicious {
-    println("Mmm, tasty turnips!")
+    print("Mmm, tasty turnips!")
 } else {
-    println("Eww, turnips are horrible.")
+    print"Eww, turnips are horrible.")
 }
 // 输出 "Eww, turnips are horrible."
 ```
@@ -443,9 +467,9 @@ if i == 1 {
 <a name="tuples"></a>
 ## 元组
 
-_元组（tuples）_把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
+元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
 
-下面这个例子中，`(404, "Not Found")`是一个描述 _HTTP 状态码（HTTP status code）_的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个`404 Not Found`状态码。
+下面这个例子中，`(404, "Not Found")`是一个描述 HTTP 状态码（HTTP status code）的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个`404 Not Found`状态码。
 
 ```swift
 let http404Error = (404, "Not Found")
@@ -456,13 +480,13 @@ let http404Error = (404, "Not Found")
 
 你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为`(Int, Int, Int)`或者`(String, Bool)`或者其他任何你想要的组合的元组。
 
-你可以将一个元组的内容_分解（decompose）_成单独的常量和变量，然后你就可以正常使用它们了：
+你可以将一个元组的内容分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：
 
 ```swift
 let (statusCode, statusMessage) = http404Error
-println("The status code is \(statusCode)")
+print("The status code is \(statusCode)")
 // 输出 "The status code is 404"
-println("The status message is \(statusMessage)")
+print("The status message is \(statusMessage)")
 // 输出 "The status message is Not Found"
 ```
 
@@ -470,16 +494,16 @@ println("The status message is \(statusMessage)")
 
 ```swift
 let (justTheStatusCode, _) = http404Error
-println("The status code is \(justTheStatusCode)")
+print("The status code is \(justTheStatusCode)")
 // 输出 "The status code is 404"
 ```
 
 此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：
 
 ```swift
-println("The status code is \(http404Error.0)")
+print("The status code is \(http404Error.0)")
 // 输出 "The status code is 404"
-println("The status message is \(http404Error.1)")
+print("The status message is \(http404Error.1)")
 // 输出 "The status message is Not Found"
 ```
 
@@ -492,9 +516,9 @@ let http200Status = (statusCode: 200, description: "OK")
 给元组中的元素命名后，你可以通过名字来获取这些元素的值：
 
 ```swift
-println("The status code is \(http200Status.statusCode)")
+print("The status code is \(http200Status.statusCode)")
 // 输出 "The status code is 200"
-println("The status message is \(http200Status.description)")
+print("The status message is \(http200Status.description)")
 // 输出 "The status message is OK"
 ```
 
@@ -506,13 +530,13 @@ println("The status message is \(http200Status.description)")
 <a name="optionals"></a>
 ## 可选类型
 
-使用_可选类型（optionals）_来处理值可能缺失的情况。可选类型表示：
+使用可选类型（optionals）来处理值可能缺失的情况。可选类型表示：
 
-* _有_值，等于 x
+* 有值，等于 x
 
 或者
 
-* _没有_值
+* 没有值
 
 > 注意：  
 C 和 Objective-C 中并没有可选类型这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回`nil`，`nil`表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如`NSNotFound`）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选类型可以让你暗示_任意类型_的值缺失，并不需要一个特殊值。
@@ -523,64 +547,13 @@ C 和 Objective-C 中并没有可选类型这个概念。最接近的是 Objecti
 
 ```swift
 let possibleNumber = "123"
-let convertedNumber = possibleNumber.toInt()
+let convertedNumber = Int(possibleNumber)
 // convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
 ```
 
-因为`toInt`方法可能会失败，所以它返回一个_可选类型（optional）_`Int`，而不是一个`Int`。一个可选的`Int`被写作`Int?`而不是`Int`。问号暗示包含的值是可选类型，也就是说可能包含`Int`值也可能不包含值。（不能包含其他任何值比如`Bool`值或者`String`值。只能是`Int`或者什么都没有。）
-
-### if 语句以及强制解析
-
-你可以使用`if`语句来判断一个可选是否包含值。如果可选类型有值，结果是`true`；如果没有值，结果是`false`。
-
-当你确定可选类型_确实_包含值之后，你可以在可选的名字后面加一个感叹号（`!`）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的_强制解析（forced unwrapping）_：
-
-```swift
-if convertedNumber != nil {
-    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
-} else {
-    println("\(possibleNumber) could not be converted to an integer")
-}
-// 输出 "123 has an integer value of 123"
-```
-
-更多关于`if`语句的内容，请参考[控制流](05_Control_Flow.html)。
-
-> 注意：  
-使用`!`来获取一个不存在的可选值会导致运行时错误。使用`!`来强制解析值之前，一定要确定可选包含一个非`nil`的值。
-
-<a name="optional_binding"></a>
-### 可选绑定
-
-使用_可选绑定（optional binding）_来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句，请参考[控制流](05_Control_Flow.html)。
-
-像下面这样在`if`语句中写一个可选绑定：
-
-```swift
-if let constantName = someOptional {
-    statements
-}
-```
-
-你可以像上面这样使用可选绑定来重写`possibleNumber`这个例子：
-
-```swift
-if let actualNumber = possibleNumber.toInt() {
-    println("\(possibleNumber) has an integer value of \(actualNumber)")
-} else {
-    println("\(possibleNumber) could not be converted to an integer")
-}
-// 输出 "123 has an integer value of 123"
-```
-
-这段代码可以被理解为：
-
-“如果`possibleNumber.toInt`返回的可选`Int`包含一个值，创建一个叫做`actualNumber`的新常量并将可选包含的值赋给它。”
-
-如果转换成功，`actualNumber`常量可以在`if`语句的第一个分支中使用。它已经被可选类型_包含的_值初始化过，所以不需要再使用`!`后缀来获取它的值。在这个例子中，`actualNumber`只被用来输出转换结果。
-
-你可以在可选绑定中使用常量和变量。如果你想在`if`语句的第一个分支中操作`actualNumber`的值，你可以改成`if var actualNumber`，这样可选类型包含的值就会被赋给一个变量而非常量。
+因为`toInt`方法可能会失败，所以它返回一个_可选类型（optional）`Int`，而不是一个`Int`。一个可选的`Int`被写作`Int?`而不是`Int`。问号暗示包含的值是可选类型，也就是说可能包含`Int`值也可能不包含值。（不能包含其他任何值比如`Bool`值或者`String`值。只能是`Int`或者什么都没有。）
 
+<a name="nil"></a>
 ### nil
 
 你可以给可选变量赋值为`nil`来表示它没有值：
@@ -603,15 +576,83 @@ var surveyAnswer: String?
 ```
 
 > 注意：  
-Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`nil`是一个指向不存在对象的指针。在 Swift 中，`nil`不是指针——它是一个确定的值，用来表示值缺失。_任何_类型的可选状态都可以被设置为`nil`，不只是对象类型。
+Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`nil`是一个指向不存在对象的指针。在 Swift 中，`nil`不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为`nil`，不只是对象类型。
 
+<a name="if"></a>
+### if 语句以及强制解析
+
+你可以使用`if`语句和nil比较来判断一个可选值是否包含值。你可以使用“相等”(==)或“不等”(!=)来执行比较。
+
+如果可选类型有值，它将不等于nil:
+
+```swift
+if convertedNumber != nil {
+    print("convertedNumber contains some integer value.")
+}
+// 输出 "转换的数字包含整数值。"
+```
+当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（`!`）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的_强制解析（forced unwrapping）：
+
+```swift
+if convertedNumber != nil {
+    print("convertedNumber has an integer value of \(convertedNumber).")
+}
+// 输出 "转换的数字有整数值123。"
+```
+
+更多关于`if`语句的内容，请参考[控制流](05_Control_Flow.html)。
+
+> 注意：  
+使用`!`来获取一个不存在的可选值会导致运行时错误。使用`!`来强制解析值之前，一定要确定可选包含一个非`nil`的值。
+
+<a name="optional_binding"></a>
+### 可选绑定
+
+使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句，请参考[控制流](05_Control_Flow.html)。
+
+像下面这样在`if`语句中写一个可选绑定：
+
+```swift
+if let constantName = someOptional {
+    statements
+}
+```
+
+你可以像上面这样使用可选绑定来重写`possibleNumber`这个例子：
+
+```swift
+if let actualNumber = possibleNumber.toInt() {
+    print("\(possibleNumber) has an integer value of \(actualNumber)")
+} else {
+    print("\(possibleNumber) could not be converted to an integer")
+}
+// 输出 "123 has an integer value of 123"
+```
+
+这段代码可以被理解为：
+
+“如果`possibleNumber.toInt`返回的可选`Int`包含一个值，创建一个叫做`actualNumber`的新常量并将可选包含的值赋给它。”
+
+如果转换成功，`actualNumber`常量可以在`if`语句的第一个分支中使用。它已经被可选类型_包含的_值初始化过，所以不需要再使用`!`后缀来获取它的值。在这个例子中，`actualNumber`只被用来输出转换结果。
+
+你可以在可选绑定中使用常量和变量。如果你想在`if`语句的第一个分支中操作`actualNumber`的值，你可以改成`if var actualNumber`，这样可选类型包含的值就会被赋给一个变量而非常量。
+
+多个可选绑定可以用逗号区分成一列表达式出现在一个`if`语句中。
+
+```swift
+if let constantName = someOptional, anotherConstantName = someOtherOptional {
+    statements
+}
+```
+
+<a name="implicityly_unwrapped_optionals"></a>
 ### 隐式解析可选类型
 
 如上所述，可选类型暗示了常量或者变量可以“没有值”。可选可以通过`if`语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。
 
 有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型_总会_有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
 
-这种类型的可选状态被定义为_隐式解析可选类型（implicitly unwrapped optionals）_。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选类型。
+这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选类型。
 
 当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考[类实例之间的循环强引用](16_Automatic_Reference_Counting.html#strong_reference_cycles_between_class_instances)。
 
@@ -619,14 +660,10 @@ Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`n
 
 ```swift
 let possibleString: String? = "An optional string."
-println(possibleString!) // 需要惊叹号来获取值
-// 输出 "An optional string."
-```
+let forcedString: possibleString! // 需要惊叹号来获取值
 
-```swift
 let assumedString: String! = "An implicitly unwrapped optional string."
-println(assumedString)  // 不需要感叹号
-// 输出 "An implicitly unwrapped optional string."
+let implicitString: String = assumedString  // 不需要感叹号
 ```
 
 你可以把隐式解析可选类型当做一个可以自动解析的可选类型。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾。
@@ -637,8 +674,8 @@ println(assumedString)  // 不需要感叹号
 你仍然可以把隐式解析可选类型当做普通可选类型来判断它是否包含值：
 
 ```swift
-if assumedString {
-    println(assumedString)
+if assumedString != nil {
+    print(assumedString)
 }
 // 输出 "An implicitly unwrapped optional string."
 ```
@@ -647,7 +684,7 @@ if assumedString {
 
 ```swift
 if let definiteString = assumedString {
-    println(definiteString)
+    print(definiteString)
 }
 // 输出 "An implicitly unwrapped optional string."
 ```
@@ -655,10 +692,60 @@ if let definiteString = assumedString {
 > 注意：  
 如果一个变量之后可能变成`nil`的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是`nil`的话，请使用普通可选类型。
 
+<a name="error_handling"></a>
+## 错误处理
+你可以使用错误处理(error handling)来应对程序执行中出错的条件。
+
+相对于可选中运用值得存在与缺失来表达函数的成功与失败，错误处理可以推断失败的原因，并传送至程序的其他部分。
+
+当一个函数遇到错误条件，它能报错。调用函数的地方能抛出错误消息并合理处理。
+
+```swift
+func canThrowAnErrow() throws{
+  //this function may or may not throw an error
+}
+```
+
+一个函数可以通过在声明中添加`throws`关键词来抛出错误消息。当你的函数能抛出错误消息时, 你应该在表达式中前置`try`关键词。
+
+```swift
+do {
+    try canThrowAnErrow()
+    // 没有错误消息抛出
+} catch {
+    // 有一个错误消息抛出
+}
+```
+
+一个`do`的声明创建了一个新的包含作用域,使得错误能被传播到一个或更多`catch`从句。
+
+这里有一个错误处理用来应对不同错误条件的例子。
+
+```swift
+func makeASandwich() throws {
+  // ...
+}
+
+do {
+  try makeASandwich()
+  eatASandwich()
+} catch Error.OutOfCleanDishes{
+  washDishes()
+} catch Error.MissingIngredients(let ingredients) {
+  buyGroceries(ingredients)
+}
+```
+
+在此例中，`makeASandwich()`（做一个三明治）函数会抛出一个错误消息如果没有干净的盘子或者某个原料缺失。因为`makeASandwich()`抛出错误，调用函数会被包裹在`try`表达式中。将函数包裹在一个`do`声明中,任何被抛出的错误会被传送到提供的`catch`从句中。
+
+如果没有错误被抛出, `eatASandwich()`函数会被调用。如果一个符合`Error.OutOfCleanDishes`的错误被抛出,`washDishes`函数会被调用。如果一个符合`Error.MissingIngredients`的错误被抛出，`buyGroceries(_:)`函数会被调用并传递相关被`catch`所捕捉到的`[String]`值。
+
+抛出，捕捉，传递错误会在[错误处理](../chapter2/18_Error_Handling.html)章节详细说明。
+
 <a name="assertions"></a>
 ## 断言
 
-可选类型可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能没办法继续执行。这时，你可以在你的代码中触发一个_断言（assertion）_来结束代码运行并通过调试来找到值缺失的原因。
+可选类型可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能没办法继续执行。这时，你可以在你的代码中触发一个断言（assertion）来结束代码运行并通过调试来找到值缺失的原因。
 
 ### 使用断言进行调试
 

From 462219eda63983907055c97e4d7ae243abb403fd Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Thu, 30 Jul 2015 17:00:16 +0800
Subject: [PATCH 137/228] =?UTF-8?q?2015-07-21=20=E5=BC=80=E5=A7=8B?=
 =?UTF-8?q?=E6=9B=B4=E6=96=B0=20=EF=BC=8D=20=E6=B7=BB=E5=8A=A0Recursive=20?=
 =?UTF-8?q?Enumerations?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 58 ++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 1484694f..45431733 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -10,6 +10,7 @@
 - [匹配枚举值与`Swith`语句（Matching Enumeration Values with a Switch Statement）](#matching_enumeration_values_with_a_switch_statement)
 - [相关值（Associated Values）](#associated_values)
 - [原始值（Raw Values）](#raw_values)
+- [递归枚举（Recursive Enumerations）](#recursive_enumerations)
 
 枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。
 
@@ -249,3 +250,60 @@ if let somePlanet = Planet(rawValue: positionToFind) {
 
 这个范例使用可选绑定（optional binding），通过原始值`9`试图访问一个行星。`if let somePlanet = Planet(rawValue: 9)`语句获得一个可选`Planet`，如果可选`Planet`可以被获得，把`somePlanet`设置成该可选`Planet`的内容。在这个范例中，无法检索到位置为`9`的行星，所以`else`分支被执行。
 
+<a name="recursive_enumerations"></a>
+## 递归枚举（Recursive Enumerations）
+
+Enumerations work well for modeling data when there is a fixed number of possibilities that need to be considered, such as the operations used for doing simple integer arithmetic. These operations let you combine simple arithmetic expressions that are made up of integers such as `5` into more complex ones such as `5 + 4`.
+
+One important characteristic of arithmetic expressions is that they can be nested. For example, the expression `(5 + 4) * 2` has a number on the right hand side of the multiplication and another expression on the left hand side of the multiplication. Because the data is nested, the enumeration used to store the data also needs to support nesting—this means the enumeration needs to be recursive.
+
+A recursive enumeration is an enumeration that has another instance of the enumeration as the associated value for one or more of the enumeration members. The compiler has to insert a layer of indirection when it works with recursive enumerations. You indicate that an enumeration member is recursive by writing indirect before it.
+
+A `recursive enumeration` is an enumeration that has another instance of the enumeration as the associated value for one or more of the enumeration members. The compiler has to insert a layer of indirection when it works with recursive enumerations. You indicate that an enumeration member is recursive by writing `indirect` before it.
+
+For example, here is an enumeration that stores simple arithmetic expressions:
+
+```swift
+enum ArithmeticExpression {
+    case Number(Int)
+    indirect case Addition(ArithmeticExpression, ArithmeticExpression)
+    indirect case Multiplication(ArithmeticExpression, ArithmeticExpression)
+}
+```
+
+You can also write `indirect` before the beginning of the enumeration, to enable indirection for all of the enumeration’s members that need it:
+
+```swift
+indirect enum ArithmeticExpression {
+    case Number(Int)
+    case Addition(ArithmeticExpression, ArithmeticExpression)
+    case Multiplication(ArithmeticExpression, ArithmeticExpression)
+}
+```
+
+This enumeration can store three kinds of arithmetic expressions: a plain number, the addition of two expressions, and the multiplication of two expressions. The `Addition` and `Multiplication` members have associated values that are also arithmetic expressions—these associated values make it possible to nest expressions.
+
+A recursive function is a straightforward way to work with data that has a recursive structure. For example, here’s a function that evaluates an arithmetic expression:
+
+```swift
+func evaluate(expression: ArithmeticExpression) -> Int {
+    switch expression {
+    case .Number(let value):
+        return value
+    case .Addition(let left, let right):
+        return evaluate(left) + evaluate(right)
+    case .Multiplication(let left, let right):
+        return evaluate(left) * evaluate(right)
+    }
+}
+ 
+// evaluate (5 + 4) * 2
+let five = ArithmeticExpression.Number(5)
+let four = ArithmeticExpression.Number(4)
+let sum = ArithmeticExpression.Addition(five, four)
+let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2))
+print(evaluate(product))
+// prints "18"
+```
+
+This function evaluates a plain number by simply returning the associated value. It evaluates an addition or multiplication by evaluating the expression on the left hand side, evaluating the expression on the right hand side, and then adding them or multiplying them.

From 4102e73967e6737630c4ed51205aa5e9b39717bb Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Thu, 30 Jul 2015 17:38:17 +0800
Subject: [PATCH 138/228] =?UTF-8?q?2015-07-21=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E6=9B=B4=E6=96=B0=20=EF=BC=8D=20=E6=B7=BB=E5=8A=A0Recursive=20?=
 =?UTF-8?q?Enumerations?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 45431733..123dc244 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -253,15 +253,14 @@ if let somePlanet = Planet(rawValue: positionToFind) {
 <a name="recursive_enumerations"></a>
 ## 递归枚举（Recursive Enumerations）
 
-Enumerations work well for modeling data when there is a fixed number of possibilities that need to be considered, such as the operations used for doing simple integer arithmetic. These operations let you combine simple arithmetic expressions that are made up of integers such as `5` into more complex ones such as `5 + 4`.
+在对操作符进行描述的时候，使用枚举类型来对数据建模很方便，因为需要考虑的情况固定可枚举。操作符可以将两个由数字组成的算数表达式连接起来，例如，将`5`连接成复杂一些的表达式`5+4`.
 
-One important characteristic of arithmetic expressions is that they can be nested. For example, the expression `(5 + 4) * 2` has a number on the right hand side of the multiplication and another expression on the left hand side of the multiplication. Because the data is nested, the enumeration used to store the data also needs to support nesting—this means the enumeration needs to be recursive.
+算数表达式的一个重要特性是，表达式可以嵌套使用。例如，表达式`(5 + 4) * 2`乘号右边是一个数字，左边则是另一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也许要支持这种嵌套————这表示枚举类型需要支持递归。
 
-A recursive enumeration is an enumeration that has another instance of the enumeration as the associated value for one or more of the enumeration members. The compiler has to insert a layer of indirection when it works with recursive enumerations. You indicate that an enumeration member is recursive by writing indirect before it.
+`递归枚举（recursive enumeration）`是一种枚举类型，表示它的枚举中，有一个或多个枚举成员拥有该枚举的其他成员作为相关值。使用递归枚举时，编译器会插入一个中间层。你可以在枚举成员前加上`indirect`来表示这成员可递归。
 
-A `recursive enumeration` is an enumeration that has another instance of the enumeration as the associated value for one or more of the enumeration members. The compiler has to insert a layer of indirection when it works with recursive enumerations. You indicate that an enumeration member is recursive by writing `indirect` before it.
+例如，下面的例子中，枚举类型存储了简单的算数表达式：
 
-For example, here is an enumeration that stores simple arithmetic expressions:
 
 ```swift
 enum ArithmeticExpression {
@@ -271,7 +270,7 @@ enum ArithmeticExpression {
 }
 ```
 
-You can also write `indirect` before the beginning of the enumeration, to enable indirection for all of the enumeration’s members that need it:
+你也可以在枚举类型开头加上`indirect`关键字来表示它的所有成员都是可递归的：
 
 ```swift
 indirect enum ArithmeticExpression {
@@ -281,9 +280,9 @@ indirect enum ArithmeticExpression {
 }
 ```
 
-This enumeration can store three kinds of arithmetic expressions: a plain number, the addition of two expressions, and the multiplication of two expressions. The `Addition` and `Multiplication` members have associated values that are also arithmetic expressions—these associated values make it possible to nest expressions.
+上面定义的枚举类型可以存储三种算数表达式：纯数字、两个表达式的相加、两个表达式相乘。`Addition` 和 `Multiplication`成员的相关值也是算数表达式————这些相关值使得嵌套表达式成为可能。
 
-A recursive function is a straightforward way to work with data that has a recursive structure. For example, here’s a function that evaluates an arithmetic expression:
+递归函数可以很直观地使用具有递归性质的数据结构。例如，下面是一个计算算数表达式的函数：
 
 ```swift
 func evaluate(expression: ArithmeticExpression) -> Int {
@@ -297,13 +296,13 @@ func evaluate(expression: ArithmeticExpression) -> Int {
     }
 }
  
-// evaluate (5 + 4) * 2
+// 计算 (5 + 4) * 2
 let five = ArithmeticExpression.Number(5)
 let four = ArithmeticExpression.Number(4)
 let sum = ArithmeticExpression.Addition(five, four)
 let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2))
 print(evaluate(product))
-// prints "18"
+// 输出 "18"
 ```
 
-This function evaluates a plain number by simply returning the associated value. It evaluates an addition or multiplication by evaluating the expression on the left hand side, evaluating the expression on the right hand side, and then adding them or multiplying them.
+该函数如果遇到纯数字，就直接返回该数字的值。如果遇到的是加法或乘法元算，则分别计算左边表达式和右边表达式的值，然后相加或相乘。

From 92ba2e2ef7e61e9599ed5f526d4e2e7b1c374d2d Mon Sep 17 00:00:00 2001
From: futantan <luckytantanfu@gmail.com>
Date: Thu, 30 Jul 2015 18:19:33 +0800
Subject: [PATCH 139/228] =?UTF-8?q?2015-07-21=20=E5=AE=8C=E6=88=90?=
 =?UTF-8?q?=E6=9B=B4=E6=96=B0=20=EF=BC=8D=20Added=20information=20about=20?=
 =?UTF-8?q?the=20behavior=20of=20enumeration=20cases=20with=20String=20raw?=
 =?UTF-8?q?=20values=20to=20the=20Implicitly=20Assigned=20Raw=20Values=20s?=
 =?UTF-8?q?ection=20of=20the=20Enumerations=20chapter?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/08_Enumerations.md | 44 +++++++++++++++++++++++++-----
 1 file changed, 37 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 123dc244..b86e77ae 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -201,9 +201,16 @@ enum ASCIIControlCharacter: Character {
 
 在这里，称为`ASCIIControlCharacter`的枚举的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符[`Strings and Characters`](03_Strings_and_Characters.html)部分。
 
-注意，原始值和相关值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。相关值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。
+原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。
 
-原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。当整型值被用于原始值，如果其他枚举成员没有值时，它们会自动递增。
+>注意：  
+>原始值和相关值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。相关值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。
+
+### 原始值的隐式赋值（Implicitly Assigned Raw Values）
+
+在使用原始值为整数或者字符串类型的枚举时，不需要显式的为每一个成员赋值，这时，Swift将会自动为你赋值。
+
+例如，当使用整数作为原始值时，隐式赋值的值依次递增1。如果第一个值没有被赋初值，将会被自动置为0。
 
 下面的枚举是对之前`Planet`这个枚举的一个细化，利用原始整型值来表示每个 planet 在太阳系中的顺序：
 
@@ -213,23 +220,46 @@ enum Planet: Int {
 }
 ```
 
-自动递增意味着`Planet.Venus`的原始值是`2`，依次类推。
+在上面的例子中，`Plant.Mercury`赋了初值`1`，`Planet.Venus`会拥有隐式赋值`2`，依次类推。
+
+当使用字符串作为枚举类型的初值时，每个枚举成员的隐式初值则为该成员的名称。
+
+下面的例子是`CompassPoint`枚举类型的精简版，使用字符串作为初值类型，隐式初始化为咩个方向的名称：
+
+```swift
+enum CompassPoint: String {
+    case North, South, East, West
+}
+```
+
+上面例子中，`CompassPoint.South`拥有隐式初值`South`，依次类推。
 
 使用枚举成员的`rawValue`属性可以访问该枚举成员的原始值：
 
 ```swift
 let earthsOrder = Planet.Earth.rawValue
-// earthsOrder is 3
+// earthsOrder 值为 3
+
+let sunsetDirection = CompassPoint.West.rawValue
+// sunsetDirection 值为 "West"
 ```
 
-通过参数为`rawValue`构造函数创建特定原始值的枚举。这个例子通过原始值`7`识别`Uranus`：
+### 使用原始值初始化枚举变量（Initializing from a Raw Value）
+
+如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法将原始值类型作为参数，返回枚举成员或者`nil`。你可以使用这种初始化方法来创建一个新的枚举变量。
+
+这个例子通过原始值`7`从而创建枚举成员：
 
 ```swift
 let possiblePlanet = Planet(rawValue: 7)
-// possiblePlanet is of type Planet? and equals Planet.Uranus
+// possiblePlanet 类型为 Planet? 值为 Planet.Uranus
 ```
 
-然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个***可选***的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
+然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
+
+<!-- TODO 连接 -->  
+>注意：  
+>原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[Failableinitializers](http://)
 
 如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`：
 

From 487c64663ada11b5b7abf19d8f3df31523da3c44 Mon Sep 17 00:00:00 2001
From: littledogboy <littledogboy@126.com>
Date: Sat, 1 Aug 2015 15:22:06 +0800
Subject: [PATCH 140/228] =?UTF-8?q?swift7.31=20do=E6=96=B0=E5=A2=9E?=
 =?UTF-8?q?=E6=8F=8F=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

swift 中的 do 语句与C 中限定代码块界限的大括号 （{}）很相似，并且在程序运行的时候并不会造成系统开销。
---
 source/chapter3/10_Statements.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index c122756a..d4e49cde 100755
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -452,6 +452,8 @@ avaliability 语句的形式如下：
 
 `do` 语句用于引入一个新的作用域,该作用域中可以含有一个或多个`catch`子句,catch子句中定义了一些匹配错误情况的模式。`do` 语句作用域内定义的常量和变量，只能在do语句作用域内访问。    
 
+swift 中的 do 语句与C 中限定代码块界限的大括号 （{}）很相似，并且在程序运行的时候并不会造成系统开销。    
+
 > do {    
 >    try `expression`    
 >    `statements`    

From 08a84ae4df0ebe8b46d5d3ec568879166d49beaa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Sat, 1 Aug 2015 21:45:50 +0800
Subject: [PATCH 141/228] change order

---
 source/chapter2/14_Initialization.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 9f2583fc..a11a5070 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -793,8 +793,8 @@ if unknownUnit == nil {
 class Product {
     let name: String!
     init?(name: String) {
-        if name.isEmpty { return nil }
         self.name = name
+        if name.isEmpty { return nil }
     }
 }
 ```

From 15321c7a749376fc13c73b27ba5f3d40f162c4a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Sun, 2 Aug 2015 11:21:19 +0800
Subject: [PATCH 142/228] add content

---
 source/chapter2/17_Optional_Chaining.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index 6bc5b394..62b03527 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -189,6 +189,12 @@ Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值：
 
 类似的，可以通过下标，用可空链式调用来赋值：
 
+john.residence?[0] = Room(name: "Bathroom")
+
+这次赋值同样会失败，因为`residence`目前是`nil`。
+
+如果你创建一个Residence实例，添加一些Room实例并赋值给john.residence，那就可以通过可选链和下标来访问数组中的元素：
+
 	let johnsHouse = Residence()
 	johnsHouse.rooms.append(Room(name: "Living Room"))
 	johnsHouse.rooms.append(Room(name: "Kitchen"))

From 2044f4667fb39b8e53be3c21f636102475656887 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Sun, 2 Aug 2015 22:12:05 +0800
Subject: [PATCH 143/228] finally adjust

---
 source/chapter1/01_swift.md                   |   7 +-
 source/chapter1/02_a_swift_tour.md            |   8 +-
 source/chapter2/01_The_Basics.md              |  32 +-
 source/chapter2/02_Basic_Operators.md         |  29 +-
 source/chapter2/03_Strings_and_Characters.md  | 426 ++++++------
 source/chapter2/04_Collection_Types.md        |  24 +-
 source/chapter2/05_Control_Flow.md            |  13 +-
 source/chapter2/06_Functions.md               |   7 +
 source/chapter2/07_Closures.md                |  16 +-
 source/chapter2/08_Enumerations.md            |  14 +-
 source/chapter2/09_Classes_and_Structures.md  |  18 +-
 source/chapter2/10_Properties.md              |  36 +-
 source/chapter2/11_Methods.md                 |  50 +-
 source/chapter2/12_Subscripts.md              |   8 +-
 source/chapter2/13_Inheritance.md             | 172 ++---
 source/chapter2/14_Initialization.md          |  23 +-
 source/chapter2/15_Deinitialization.md        |   8 +-
 .../16_Automatic_Reference_Counting.md        |  34 +-
 source/chapter2/17_Optional_Chaining.md       | 415 +++++++-----
 source/chapter2/18_Error_Handling.md          | 188 +++---
 source/chapter2/19_Nested_Types.md            |   6 +-
 source/chapter2/20_Type_Casting.md            |   9 +-
 source/chapter2/21_Extensions.md              |  12 +-
 source/chapter2/22_Protocols.md               |  26 +-
 source/chapter2/23_Generics.md                |  15 +-
 source/chapter2/24_Access_Control.md          |   8 +-
 source/chapter2/25_Advanced_Operators.md      |  10 +-
 .../01_About_the_Language_Reference.md        |   6 +-
 source/chapter3/02_Lexical_Structure.md       |  12 +-
 source/chapter3/03_Types.md                   |  46 +-
 source/chapter3/04_Expressions.md             | 207 +++---
 source/chapter3/05_Declarations.md            | 568 ++++++++--------
 source/chapter3/06_Attributes.md              |   8 +-
 source/chapter3/07_Patterns.md                |  42 +-
 .../08_Generic_Parameters_and_Arguments.md    |  20 +-
 source/chapter3/09_Summary_of_the_Grammar.md  | 636 +++++++++---------
 source/chapter3/10_Statements.md              | 432 ++++++------
 37 files changed, 1923 insertions(+), 1668 deletions(-)

diff --git a/source/chapter1/01_swift.md b/source/chapter1/01_swift.md
index f845f96e..f1c13a38 100755
--- a/source/chapter1/01_swift.md
+++ b/source/chapter1/01_swift.md
@@ -1,5 +1,10 @@
+> 1.0
 > 翻译：[numbbbbb](https://github.com/numbbbbb)  
-> 校对：[yeahdongcn](https://github.com/yeahdongcn), [xtymichael](https://github.com/xtymichael)
+> 校对：[yeahdongcn](https://github.com/yeahdongcn)
+
+> 2.0
+> 翻译+校对：[xtymichael](https://github.com/xtymichael)
+
 
 # 关于 Swift
 -----------------
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index e1ccf6b8..b2649081 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -1,6 +1,10 @@
-> 翻译：[numbbbbb](https://github.com/numbbbbb), [xtymichael](https://github.com/xtymichael)
+> 1.0
+> 翻译：[numbbbbb](https://github.com/numbbbbb)
 > 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai)
 
+> 2.0
+> 翻译+校对：[xtymichael](https://github.com/xtymichael)
+
 # Swift 初见
 
 ---
@@ -27,7 +31,7 @@ print("Hello, world")
 
 > 注意：
 > 为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。
-> <a href="https://github.com/numbbbbb/the-swift-programming-language-in-chinese/raw/gh-pages/source/chapter1/GuidedTour.playground.zip">下载Playground</a>
+> <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GuidedTour.playground.zip">下载Playground</a>
 
 <a name="simple_values"></a>
 ## 简单值
diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 6f8f4727..35e84613 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -1,6 +1,10 @@
-> 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus), [xtymichael](https://github.com/xtymichael)
+> 1.0
+> 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus)
 > 校对：[lslxdx](https://github.com/lslxdx)
 
+> 2.0
+> [xtymichael](https://github.com/xtymichael)
+
 # 基础部分
 -----------------
 
@@ -99,6 +103,12 @@ var welcomeMessage: String
 welcomeMessage = "Hello"
 ```
 
+你可以在一行中定义多个同样类型的变量，用逗号分割，并在最后一个变量名之后添加类型标注：
+
+```swift
+var red, green, blue: Double
+```
+
 > 注意：  
 一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考[类型安全和类型推断](#type_safety_and_type_inference)。在上面的例子中，没有给`welcomeMessage`赋初始值，所以变量`welcomeMessage`的类型是通过一个类型标注指定的，而不是通过初始值推断的。
 
@@ -165,7 +175,7 @@ print("The current value of friendlyWelcome is \(friendlyWelcome)")
 ```
 
 > 注意：  
-字符串插值所有可用的选项，请参考[字符串插值](03_Strings_and_Characters.html#string_interpolation)。
+字符串插值所有可用的选项，请参考[字符串插值](./03_Strings_and_Characters.html#string_interpolation)。
 
 <a name="comments"></a>
 ## 注释
@@ -369,7 +379,7 @@ let twoThousandAndOne = twoThousand + UInt16(one)
 
 现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推断为`UInt16`，因为它是两个`UInt16`值的和。
 
-`SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考[扩展](20_Extensions.html)。
+`SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考[扩展](./20_Extensions.html)。
 
 <a name="integer_and_floating_point_conversion"></a>
 ### 整数和浮点数转换
@@ -440,7 +450,7 @@ if turnipsAreDelicious {
 // 输出 "Eww, turnips are horrible."
 ```
 
-条件语句，例如`if`，请参考[控制流](05_Control_Flow.html)。
+条件语句，例如`if`，请参考[控制流](./05_Control_Flow.html)。
 
 如果你在需要使用`Bool`类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：
 
@@ -460,7 +470,7 @@ if i == 1 {
 }
 ```
 
-`i == 1`的比较结果是`Bool`类型，所以第二个例子可以通过类型检查。类似`i == 1`这样的比较，请参考[基本操作符](05_Control_Flow.html)。
+`i == 1`的比较结果是`Bool`类型，所以第二个例子可以通过类型检查。类似`i == 1`这样的比较，请参考[基本操作符](./05_Control_Flow.html)。
 
 和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的意图总是清晰的。
 
@@ -522,10 +532,10 @@ print("The status message is \(http200Status.description)")
 // 输出 "The status message is OK"
 ```
 
-作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个`(Int, String)`元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考[函数参数与返回值](06_Functions.html#Function_Parameters_and_Return_Values)。
+作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个`(Int, String)`元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考[函数参数与返回值](./06_Functions.html#Function_Parameters_and_Return_Values)。
 
 > 注意：  
-元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考[类和结构体](09_Classes_and_Structures.html)。
+元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考[类和结构体](./09_Classes_and_Structures.html)。
 
 <a name="optionals"></a>
 ## 可选类型
@@ -608,7 +618,7 @@ if convertedNumber != nil {
 <a name="optional_binding"></a>
 ### 可选绑定
 
-使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句，请参考[控制流](05_Control_Flow.html)。
+使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句，请参考[控制流](./05_Control_Flow.html)。
 
 像下面这样在`if`语句中写一个可选绑定：
 
@@ -654,7 +664,7 @@ if let constantName = someOptional, anotherConstantName = someOtherOptional {
 
 这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选类型。
 
-当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考[类实例之间的循环强引用](16_Automatic_Reference_Counting.html#strong_reference_cycles_between_class_instances)。
+当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考[无主引用以及隐式解析可选属性](./16_Automatic_Reference_Counting.html#unowned_references_and_implicitly_unwrapped_optional_properties)。
 
 一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型`String`和隐式解析可选类型`String`之间的区别：
 
@@ -740,7 +750,7 @@ do {
 
 如果没有错误被抛出, `eatASandwich()`函数会被调用。如果一个符合`Error.OutOfCleanDishes`的错误被抛出,`washDishes`函数会被调用。如果一个符合`Error.MissingIngredients`的错误被抛出，`buyGroceries(_:)`函数会被调用并传递相关被`catch`所捕捉到的`[String]`值。
 
-抛出，捕捉，传递错误会在[错误处理](../chapter2/18_Error_Handling.html)章节详细说明。
+抛出，捕捉，传递错误会在[错误处理](./18_Error_Handling.html)章节详细说明。
 
 <a name="assertions"></a>
 ## 断言
@@ -777,7 +787,7 @@ assert(age >= 0)
 * 需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
 * 一个可选值现在是`nil`，但是后面的代码运行需要一个非`nil`值。
 
-请参考[下标脚本](12_Subscripts.html)和[函数](06_Functions.html)。
+请参考[下标脚本](./12_Subscripts.html)和[函数](./06_Functions.html)。
 
 > 注意：  
 断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。
diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index dc6a1b8b..89beb3c1 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -1,6 +1,9 @@
+> 1.0
+> 翻译：[XieLingWang](https://github.com/xielingwang)
+> 校对：[EvilCome](https://github.com/Evilcome)
 
-> 翻译：[XieLingWang](https://github.com/xielingwang), [JackAlan](https://github.com/AlanMelody)
-> 校对：[EvilCome](https://github.com/Evilcome), [JackAlan](https://github.com/AlanMelody)
+> 2.0
+> 翻译+校对：[JackAlan](https://github.com/AlanMelody)
 
 # 基本运算符
 -----------------
@@ -19,11 +22,11 @@
 
 运算符是检查、改变、合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。更复杂的运算例子包括逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），或让 i 值加1的便捷自增运算符`++i`等。
 
-Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如：赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。算术运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](24_Advanced_Operators.html#overflow_operators)。
+Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如：赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。算术运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](./24_Advanced_Operators.html#overflow_operators)。
 
 区别于 C 语言，在 Swift 中你可以对浮点数进行取余运算（`%`），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符（`a..<b`和`a...b`），这方便我们表达一个区间内的数值。
 
-本章节只描述了 Swift 中的基本运算符，[高级运算符](24_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
+本章节只描述了 Swift 中的基本运算符，[高级运算符](./24_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
 
 <a name="terminology"></a>
 ## 术语
@@ -77,7 +80,7 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 
 
 
-与 C 语言和 Objective-C 不同的是，Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算（如`a &+ b`）。详情参见[溢出运算符](24_Advanced_Operators.html#overflow_operators)。
+与 C 语言和 Objective-C 不同的是，Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算（如`a &+ b`）。详情参见[溢出运算符](./24_Advanced_Operators.html#overflow_operators)。
 
 加法运算符也可用于`String`的拼接：
 
@@ -215,7 +218,7 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 - 小于等于（`a <= b`）
 
 > 注意：
-Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](09_Classes_and_Structures.html)。
+Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](./09_Classes_and_Structures.html)。
 
 每个比较运算都返回了一个标识表达式是否成立的布尔值：
 
@@ -240,7 +243,7 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 	// 输出 "hello, world", 因为 `name` 就是等于 "world"
 
 
-关于`if`语句，请看[控制流](05_Control_Flow.html)。
+关于`if`语句，请看[控制流](./05_Control_Flow.html)。
 
 <a name="ternary_conditional_operator"></a>
 ## 三目运算符(Ternary Conditional Operator)
@@ -335,7 +338,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 	// 5 * 5 = 25
 
 
-关于`for-in`，请看[控制流](05_Control_Flow.html)。
+关于`for-in`，请看[控制流](./05_Control_Flow.html)。
 
 ### 半开区间运算符
 
@@ -356,7 +359,7 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 	// 第 4 个人叫 Jack
 
 
-数组有4个元素，但`0..<count`只数到3(最后一个元素的下标)，因为它是半开区间。关于数组，请查阅[数组](04_Collection_Types.html#arrays)。
+数组有4个元素，但`0..<count`只数到3(最后一个元素的下标)，因为它是半开区间。关于数组，请查阅[数组](./04_Collection_Types.html#arrays)。
 
 <a name="logical_operators"></a>
 ## 逻辑运算
@@ -434,10 +437,10 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 
 如果我们输入了正确的密码并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。
 
-前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。
-
->注意：
-Swift 逻辑操作符`&&`和`||`是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。
+前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。
+
+>注意：
+Swift 逻辑操作符`&&`和`||`是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。
 
 ### 使用括号来明确优先级
 
diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 98164903..c8a1c31a 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -1,11 +1,15 @@
-> 翻译：[wh1100717](https://github.com/wh1100717)  
-> 校对：[Hawstein](https://github.com/Hawstein)
-
-# 字符串和字符（Strings and Characters）
----
-
-本页包含内容：
-
+> 1.0
+> 翻译：[wh1100717](https://github.com/wh1100717)  
+> 校对：[Hawstein](https://github.com/Hawstein)
+
+> 2.0
+> 翻译+校对：[DianQK](https://github.com/DianQK)
+
+# 字符串和字符（Strings and Characters）
+---
+
+本页包含内容：
+
 - [字符串字面量](#string_literals)
 - [初始化空字符串](#initializing_an_empty_string)
 - [字符串可变性](#string_mutability)
@@ -17,59 +21,59 @@
 - [计算字符数量](#counting_characters)
 - [访问和修改字符串](#accessing_and_modifying_a_string)
 - [比较字符串](#comparing_strings)
-- [字符串的 Unicode 表示形式](#unicode_representations_of_strings)
-
-
-`String`是例如"hello, world"，"albatross"这样的有序的`Character`（字符）类型的值的集合，通过`String`类型来表示。
+- [字符串的 Unicode 表示形式](#unicode_representations_of_strings)
+
+
+`String`是例如"hello, world"，"albatross"这样的有序的`Character`（字符）类型的值的集合，通过`String`类型来表示。
 Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本。
 创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。
 字符串连接操作只需要简单地通过`+`符号将两个字符串相连即可。
-与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
+与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
 尽管语法简易，但`String`类型是一种快速、现代化的字符串实现。
-每一个字符串都是由编码无关的 Unicode 字符组成，并支持访问字符的多种 Unicode 表示形式（representations）。
-你也可以在常量、变量、字面量和表达式中进行字符串插值操作，这可以帮助你轻松创建用于展示、存储和打印的自定义字符串。
-
+每一个字符串都是由编码无关的 Unicode 字符组成，并支持访问字符的多种 Unicode 表示形式（representations）。
+你也可以在常量、变量、字面量和表达式中进行字符串插值操作，这可以帮助你轻松创建用于展示、存储和打印的自定义字符串。
+
 > 注意：  
-> Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。就像 [AnyObject](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TypeCasting.html#//apple_ref/doc/uid/TP40014097-CH22-ID343) 中提到的一样，在使用 Cocoa 中的 Foundation 框架时，您可以将创建的任何字符串的值转换成`NSString`，并调用任意的`NSString` API。您也可以在任意要求传入`NSString`实例作为参数的 API 中用`String`类型的值代替。
+> Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。就像 [`AnyObject`类型](./20_Type_Casting.html#anyobject) 中提到的一样，在使用 Cocoa 中的 Foundation 框架时，您可以将创建的任何字符串的值转换成`NSString`，并调用任意的`NSString` API。您也可以在任意要求传入`NSString`实例作为参数的 API 中用`String`类型的值代替。
 > 更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 *[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)*。  
 
 
-
-<a name="string_literals"></a>
-## 字符串字面量（String Literals）
-
+
+<a name="string_literals"></a>
+## 字符串字面量（String Literals）
+
 您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
-字符串字面量可以用于为常量和变量提供初始值：
-```let someString = "Some string literal value"```
-注意`someString`常量通过字符串字面量进行初始化，Swift 会推断该常量为`String`类型。
+字符串字面量可以用于为常量和变量提供初始值：
+```let someString = "Some string literal value"```
+注意`someString`常量通过字符串字面量进行初始化，Swift 会推断该常量为`String`类型。
 > 注意：
 > 更多关于在字面量的特殊字符，请查看 [Special Characters in String Literals](#special_characters_in_string_literals) 。
 
-
-<a name="initializing_an_empty_string"></a>
-## 初始化空字符串 (Initializing an Empty String)
-
+
+<a name="initializing_an_empty_string"></a>
+## 初始化空字符串 (Initializing an Empty String)
+
 要创建一个空字符串作为初始值，可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：
-
+
 ```swift
 var emptyString = ""               // 空字符串字面量
 var anotherEmptyString = String()  // 初始化方法
 // 两个字符串均为空并等价。
-```
-
-您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：
+```
+
+您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：
 ```swift
 if emptyString.isEmpty {
     print("Nothing to see here")
 }
 // 打印输出："Nothing to see here"
-```
-
-<a name="string_mutability"></a>
-## 字符串可变性 (String Mutability)
-
-您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
-
+```
+
+<a name="string_mutability"></a>
+## 字符串可变性 (String Mutability)
+
+您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
+
 ```swift
 var variableString = "Horse"
 variableString += " and carriage"
@@ -77,33 +81,33 @@ variableString += " and carriage"
 let constantString = "Highlander"
 constantString += " and another Highlander"
 // 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。
-```
-
+```
+
 > 注意：
-> 在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改。
-
-<a name="strings_are_value_types"></a>
-## 字符串是值类型（Strings Are Value Types）
-
+> 在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改。
+
+<a name="strings_are_value_types"></a>
+## 字符串是值类型（Strings Are Value Types）
+
 Swift 的`String`类型是值类型。
 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。
-任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。
-值类型在 [结构体和枚举是值类型](09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了详细描述。
-
+任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。
+值类型在 [结构体和枚举是值类型](./09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了详细描述。
+
 > 注意：  
-> 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
-
-Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。
-很明显无论该值来自于哪里，都是您独自拥有的。
-您可以放心您传递的字符串本身不会被更改。
-
-在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。
-
-<a name="working_with_characters"></a>
-## 使用字符（Working with Characters）
-
-您可通过`for-in`循环来遍历字符串中的`characters`属性来获取每一个字符的值：
-
+> 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
+
+Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。
+很明显无论该值来自于哪里，都是您独自拥有的。
+您可以放心您传递的字符串本身不会被更改。
+
+在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。
+
+<a name="working_with_characters"></a>
+## 使用字符（Working with Characters）
+
+您可通过`for-in`循环来遍历字符串中的`characters`属性来获取每一个字符的值：
+
 ```swift
 for character in "Dog!🐶".characters {
     print(character)
@@ -113,12 +117,12 @@ for character in "Dog!🐶".characters {
 // g
 // !
 // 🐶
-```
-
-for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细描述。
-
-另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量：
-
+```
+
+for-in 循环在 [For Loops](./05_Control_Flow.html#for_loops) 中进行了详细描述。
+
+另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量：
+
 ```swift
 let exclamationMark: Charater = "!"
 ```
@@ -131,96 +135,96 @@ print(catString)
 // 打印输出："Cat!🐱"
 ```
 
-<a name="concatenating_strings_and_characters"></a>
-## 连接字符串和字符 (Concatenating Strings and Characters)
-
-字符串可以通过加法运算符（`+`）相加在一起（或称“连接”）创建一个新的字符串：
-
+<a name="concatenating_strings_and_characters"></a>
+## 连接字符串和字符 (Concatenating Strings and Characters)
+
+字符串可以通过加法运算符（`+`）相加在一起（或称“连接”）创建一个新的字符串：
+
 ```swift
 let string1 = "hello"
 let string2 = " there"
 var welcome = string1 +　string2
 // welcome 现在等于 "hello there"
-```
-
-您也可以通过加法赋值运算符 (`+=`) 将一个字符串添加到一个已经存在字符串变量上：
-
+```
+
+您也可以通过加法赋值运算符 (`+=`) 将一个字符串添加到一个已经存在字符串变量上：
+
 ```swift
 var instruction = "look over"
 instruction += string2
 // instruction 现在等于　"look over there"
 ```
-
-您可以用`append`方法将一个字符附加到一个字符串变量的尾部：
-
+
+您可以用`append`方法将一个字符附加到一个字符串变量的尾部：
+
 ```swift
 let exclamationMark: Character = "!"
 welcome.append(exclamationMark)
 // welcome 现在等于 "hello there!"
-```
-
+```
+
 > 注意：  
 > 您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
 
 
-<a name="string_interpolation"></a>
-## 字符串插值 (String Interpolation)
-
-字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。
-您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中：
-
+<a name="string_interpolation"></a>
+## 字符串插值 (String Interpolation)
+
+字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。
+您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中：
+
 ```swift
 let multiplier = 3
 let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
 // message 是 "3 times 2.5 is 7.5"
-```
-
-在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串字面量中。
-当创建字符串执行插值计算时此占位符会被替换为`multiplier`实际的值。
-
-`multiplier`的值也作为字符串中后面表达式的一部分。
-该表达式计算`Double(multiplier) * 2.5`的值并将结果 (7.5) 插入到字符串中。
-在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
-
+```
+
+在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串字面量中。
+当创建字符串执行插值计算时此占位符会被替换为`multiplier`实际的值。
+
+`multiplier`的值也作为字符串中后面表达式的一部分。
+该表达式计算`Double(multiplier) * 2.5`的值并将结果 (7.5) 插入到字符串中。
+在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
+
 > 注意：  
 > 插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。
 
-
+
 <a name="unicode"></a>
-## Unicode
-
-Unicode 是一个国际标准，用于文本的编码和表示。
-它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
+## Unicode
+
+Unicode 是一个国际标准，用于文本的编码和表示。
+它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
 Swift 的字符串和字符类型是完全兼容 Unicode 标准的。  
 
 <a name="unicode_scalars"></a>
 ### Unicode 标量（Unicode Scalars）
-
-Swift 的`String`类型是基于 *Unicode 标量* 建立的。
+
+Swift 的`String`类型是基于 *Unicode 标量* 建立的。
 Unicode 标量是对应字符的唯一21位数字或者修饰符，例如`U+0061`表示小写的拉丁字母(`LATIN SMALL LETTER A`)("`a`")，`U+1F425`表示小鸡表情(`FRONT-FACING BABY CHICK`) ("`🐥`")
 > 注意：
-> Unicode *码位(code poing)* 的范围是`U+0000`到`U+D7FF`或者`U+E000`到`U+10FFFF`。Unicode 标量不包括 Unicode *代理项(surrogate pair)* 码位，其码位范围是`U+D800`到`U+DFFF`。
+> Unicode *码位(code poing)* 的范围是`U+0000`到`U+D7FF`或者`U+E000`到`U+10FFFF`。Unicode 标量不包括 Unicode *代理项(surrogate pair)* 码位，其码位范围是`U+D800`到`U+DFFF`。
 
 注意不是所有的21位 Unicode 标量都代表一个字符，因为有一些标量是保留给未来分配的。已经代表一个典型字符的标量都有自己的名字，例如上面例子中的`LATIN SMALL LETTER A`和`FRONT-FACING BABY CHICK`。
 
 <a name="special_characters_in_string_literals"></a>
 ### 字符串字面量的特殊字符 (Special Characters in String Literals)
-
+
 字符串字面量可以包含以下特殊字符：
-
-* 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
-* Unicode 标量，写成`\u{n}`(u为小写)，其中`n`为任意一到八位十六进制数且可用的 Unicode 位码。
-
-下面的代码为各种特殊字符的使用示例。
-`wiseWords`常量包含了两个双引号；
-`dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量：
-
-```swift
+
+* 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
+* Unicode 标量，写成`\u{n}`(u为小写)，其中`n`为任意一到八位十六进制数且可用的 Unicode 位码。
+
+下面的代码为各种特殊字符的使用示例。
+`wiseWords`常量包含了两个双引号；
+`dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量：
+
+```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 sparklingHeart = "\u{1F496}"  // 💖, Unicode 标量 U+1F496
 ```
 
 <a name="extended_grapheme_clusters"></a>  
@@ -262,22 +266,22 @@ let enclosedEAcute: Character = "\u{E9}\u{20DD}"
 ```swift
 let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
 // regionalIndicatorForUS 是 🇺🇸
-```
-
-<a name="counting_characters"></a>
-## 计算字符数量 (Counting Characters)
+```
+
+<a name="counting_characters"></a>
+## 计算字符数量 (Counting Characters)
 
 调用字符串的`count`属性，就可以获取一个字符串的字符数量：
-
-
+
+
 ```swift
 let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
 print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
-// 打印输出："unusualMenagerie has 40 characters"
+// 打印输出："unusualMenagerie has 40 characters"
 ```
 
 注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。
-例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 `COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是 é ，而不是 e ：
+例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 `COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是 é ，而不是 e ：
 
 ```swift
 var word = "cafe"
@@ -287,9 +291,9 @@ word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301
 print("the number of characters in \(word) is \(word.characters.count)")
 // 打印输出 "the number of characters in café is 4"
 ```
-
+
 > 注意：  
-> 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`characters`属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
+> 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`characters`属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
 > 另外需要注意的是通过`characters`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。
 
 
@@ -361,24 +365,24 @@ let range = advance(welcome.endIndex, -6)..<welcome.endIndex
 welcome.removeRange(range)
 // welcome 现在等于 "hello"
 ```
-
-
-<a name="comparing_strings"></a>
-## 比较字符串 (Comparing Strings)
-
-Swift 提供了三种方式来比较文本值：字符串字符相等、前缀相等和后缀相等。
-
-<a name="string_and_character_equality"></a>
+
+
+<a name="comparing_strings"></a>
+## 比较字符串 (Comparing Strings)
+
+Swift 提供了三种方式来比较文本值：字符串字符相等、前缀相等和后缀相等。
+
+<a name="string_and_character_equality"></a>
 ### 字符串/字符相等 (String and Character Equality)
-字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在 [Comparison Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-ID70)：
-
+字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在[比较运算符](./02_Basic_Operators.html#comparison_operators)：
+
 ```swift
 let quotation = "We're a lot alike, you and I."
 let sameQuotation = "We're a lot alike, you and I."
 if quotation == sameQuotation {
     print("These two strings are considered equal")
 }
-// 打印输出 "These two strings are considered equal"
+// 打印输出 "These two strings are considered equal"
 ```
 
 如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。
@@ -404,18 +408,18 @@ if latinCapitalLetterA != cyrillicCapitalLetterA {
     print("These two characters are not equivalent")
 }
 // 打印 "These two characters are not equivalent"
-```
+```
 
 > 注意：
 > 在 Swift 中，字符串和字符并不区分区域。
 
-
-<a name="prefix_and_suffix_equality"></a>
-### 前缀/后缀相等 (Prefix and Suffix Equality)
-
+
+<a name="prefix_and_suffix_equality"></a>
+### 前缀/后缀相等 (Prefix and Suffix Equality)
+
 通过调用字符串的`hasPrefix(_:)`/`hasSuffix(_:)`方法来检查字符串是否拥有特定前缀/后缀，两个方法均需要以字符串作为参数传入并传出`Boolean`值。
-下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
-
+下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
+
 ```swift
 let romeoAndJuliet = [
     "Act 1 Scene 1: Verona, A public place",
@@ -429,11 +433,11 @@ let romeoAndJuliet = [
     "Act 2 Scene 4: A street in Verona",
     "Act 2 Scene 5: Capulet's mansion",
     "Act 2 Scene 6: Friar Lawrence's cell"
-]
-```
-
-您可以调用`hasPrefix(_:)`方法来计算话剧中第一幕的场景数：
-
+]
+```
+
+您可以调用`hasPrefix(_:)`方法来计算话剧中第一幕的场景数：
+
 ```swift
 var act1SceneCount = 0
 for scene in romeoAndJuliet {
@@ -442,11 +446,11 @@ for scene in romeoAndJuliet {
     }
 }
 print("There are \(act1SceneCount) scenes in Act 1")
-// 打印输出 "There are 5 scenes in Act 1"
-```
-
-相似地，您可以用`hasSuffix(_:)`方法来计算发生在不同地方的场景数：
-
+// 打印输出 "There are 5 scenes in Act 1"
+```
+
+相似地，您可以用`hasSuffix(_:)`方法来计算发生在不同地方的场景数：
+
 ```swift
 var mansionCount = 0
 var cellCount = 0
@@ -458,37 +462,37 @@ for scene in romeoAndJuliet {
     }
 }
 print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
-// 打印输出 "6 mansion scenes; 2 cell scenes"
+// 打印输出 "6 mansion scenes; 2 cell scenes"
 ```
 
 > 注意：
 > `hasPrefix(_:)`和`hasSuffix(_:)`方法都是在每个字符串中一个一个字符的比较其可扩展的字符群集是否标准相等，详细描述在[字符串/字符相等](#string_and_character_equality)。
 
-
-<a name="unicode_representations_of_strings"></a>
+
+<a name="unicode_representations_of_strings"></a>
 ## 字符串的 Unicode 表示形式（Unicode Representations of Strings）
-当一个 Unicode 字符串被写进文本文件或者其他储存时，字符串中的 Unicode 标量会用 Unicode 定义的几种编码格式编码。每一个字符串中的小块编码都被称为代码单元。这些包括 UTF-8 编码格式（编码字符串为8位的代码单元）， UTF-16 编码格式（编码字符串位16位的代码单元），以及 UTF-32 编码格式（编码字符串32位的代码单元）。
-
+当一个 Unicode 字符串被写进文本文件或者其他储存时，字符串中的 Unicode 标量会用 Unicode 定义的几种编码格式编码。每一个字符串中的小块编码都被称为代码单元。这些包括 UTF-8 编码格式（编码字符串为8位的代码单元）， UTF-16 编码格式（编码字符串位16位的代码单元），以及 UTF-32 编码格式（编码字符串32位的代码单元）。
+
 Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。
 您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 可扩展的字符群集的方式访问每一个字符值。
-该过程在 [使用字符](#working_with_characters) 中进行了描述。
-
-另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
-
-* UTF-8 代码单元集合 (利用字符串的`utf8`属性进行访问)
-* UTF-16 代码单元集合 (利用字符串的`utf16`属性进行访问)
-* 21位的 Unicode 标量值集合，也就是字符串的 UTF-32 编码格式 (利用字符串的`unicodeScalars`属性进行访问)
-
-下面由`D``o``g``‼`(`DOUBLE EXCLAMATION MARK`, Unicode 标量 `U+203C`)和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示：
-
+该过程在 [使用字符](#working_with_characters) 中进行了描述。
+
+另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
+
+* UTF-8 代码单元集合 (利用字符串的`utf8`属性进行访问)
+* UTF-16 代码单元集合 (利用字符串的`utf16`属性进行访问)
+* 21位的 Unicode 标量值集合，也就是字符串的 UTF-32 编码格式 (利用字符串的`unicodeScalars`属性进行访问)
+
+下面由`D``o``g``‼`(`DOUBLE EXCLAMATION MARK`, Unicode 标量 `U+203C`)和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示：
+
 ```swift
-let dogString = "Dog‼🐶"
+let dogString = "Dog‼🐶"
 ```
-
-
-<a name="UTF-8_representation"></a>
-### UTF-8 表示
-您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
+
+
+<a name="UTF-8_representation"></a>
+### UTF-8 表示
+您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
 其为`String.UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
 
 <body>
@@ -530,25 +534,25 @@ let dogString = "Dog‼🐶"
  </tr>
 </table>
 </center>
-</body>
-
+</body>
+
 ```swift
 for codeUnit in dogString.utf8 {
     print("\(codeUnit) ", appendNewline: false)
 }
 print("")
-// 68 111 103 226 128 188 240 159 144 182
-```
-
+// 68 111 103 226 128 188 240 159 144 182
+```
+
 上面的例子中，前三个10进制代码单元值 (68, 111, 103) 代表了字符`D`、`o`和 `g`，它们的 UTF-8 表示与 ASCII 表示相同。
 接下来的三个10进制代码单元值 (226, 128, 188) 是`DOUBLE EXCLAMATION MARK`的3字节 UTF-8 表示。
 最后的四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。
-
-
-<a name="UTF-16_representation"></a>
-### UTF-16 表示
-
-您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
+
+
+<a name="UTF-16_representation"></a>
+### UTF-16 表示
+
+您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
 其为`String.UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
 <body>
 <center>
@@ -582,28 +586,28 @@ print("")
 </table>
 </center>
 </body>
-
-
+
+
 ```swift
 for codeUnit in dogString.utf16 {
     print("\(codeUnit) ", appendNewline: false)
 }
 print("")
-// 68 111 103 8252 55357 56374
-```
-
+// 68 111 103 8252 55357 56374
+```
+
 同样，前三个代码单元值 (68, 111, 103) 代表了字符`D`、`o`和`g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。
 第四个代码单元值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量值`U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。
 第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
-第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
-
-<a name="unicode_scalars_representation"></a>
-### Unicode 标量表示 (Unicode Scalars Representation)
-
-您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。
-其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。
-`UnicodeScalar`是21位的 Unicode 代码点。
-
+第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
+
+<a name="unicode_scalars_representation"></a>
+### Unicode 标量表示 (Unicode Scalars Representation)
+
+您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。
+其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。
+`UnicodeScalar`是21位的 Unicode 代码点。
+
 每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示：
 
 <body>
@@ -636,22 +640,22 @@ print("")
 </table>
 </center>
 </body>
-
-
+
+
 ```swift
 for scalar in dogString.unicodeScalars {
     print("\(scalar.value) ", appendNewline: false)
 }
 print("")
-// 68 111 103 8252 128054
-```
-
+// 68 111 103 8252 128054
+```
+
 前三个代码单元值 (68, 111, 103) 仍然代表字符`D`、`o`和`g`。
 第四个代码单元值 (8252) 仍然是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量`U+203C`。
-第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于`DOG FACE`的Unicode 标量`U+1F436`。
-
-作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
-
+第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于`DOG FACE`的Unicode 标量`U+1F436`。
+
+作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
+
 ```swift
 for scalar in dogString.unicodeScalars {
     print("\(scalar) ")
@@ -660,5 +664,5 @@ for scalar in dogString.unicodeScalars {
 // o
 // g
 // ‼
-// 🐶
-```
+// 🐶
+```
diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index fda9f2b0..94636cdc 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -1,5 +1,9 @@
-> 翻译：[zqp](https://github.com/zqp), [JackAlan](https://github.com/AlanMelody)
-> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin), [JackAlan](https://github.com/AlanMelody)
+> 1.0
+> 翻译：[zqp](https://github.com/zqp), 
+> 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin)
+
+> 2.0
+> 翻译+校对：[JackAlan](https://github.com/AlanMelody)
 
 # 集合类型 (Collection Types)
 -----------------
@@ -18,7 +22,7 @@ Swift 语言提供`Arrays`、`Sets`和`Dictionaries`三种基本的集合类型
 Swift 语言中的`Arrays`、`Sets`和`Dictionaries`中存储的数据值类型必须明确。这意味着我们不能把不正确的数据类型插入其中。同时这也说明我们完全可以对取回值的类型非常自信。
 
 > 注意：
-Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更多关于泛型类型和集合，参见 [泛型](23_Generics.html)章节。
+Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更多关于泛型类型和集合，参见 [泛型](./23_Generics.html)章节。
 
 <a name="mutability_of_collections"></a>
 ## 集合的可变性
@@ -35,7 +39,7 @@ Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更
 
 > 注意:
  Swift 的`Array`类型被桥接到`Foundation`中的`NSArray`类。
- 更多关于在`Foundation`和`Cocoa`中使用`Array`的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。
+ 更多关于在`Foundation`和`Cocoa`中使用`Array`的信息，参见 [*Using Swift with Cocoa and Obejective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 一书。
 
 <a name="array_type_shorthand_syntax"></a>
 ### 数组的简单语法
@@ -255,14 +259,14 @@ for (index, value) in shoppingList.enumerate() {
 
 > 注意：
 > Swift的`Set`类型被桥接到`Fundation`中的`NSSet`类。
-> 关于使用`Fundation`和`Cocoa`中`Set`的知识，请看 *Using Swift with Cocoa and Objective-C*。
+> 关于使用`Fundation`和`Cocoa`中`Set`的知识，请看 [*Using Swift with Cocoa and Objective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
 
 <a name="hash_values_for_set_types"></a>
 #### Set类型的哈希值
 
 为了存储在集合中，该类型必须是可哈希化的-也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是```Int```类型的，它和其他的对象相同，其被用来比较相等与否，比如```a==b```,它遵循的是```a.hashValue == b.hashValue```。
 
-Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool```)默认都是可哈希化的，它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在[枚举部分](08_Enumerations.html)有讲述)默认也是可哈希化的。
+Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool```)默认都是可哈希化的，它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在[枚举](./08_Enumerations.html)有讲述)默认也是可哈希化的。
 
 > 注意：
 > 你可以使用你自定义的类型作为集合的值或者是字典的键值类型，但你需要使你的自定义类型服从Swift标准库中的`Hashable`协议。服从`Hashable`协议的类型需要提供一个类型为`Int`的取值访问器属性`hashValue`。这个由类型的`hashValue`返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。
@@ -272,7 +276,7 @@ Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool`
 * ```a==b```意味着```b==a```(对称性)
 * ```a==b&&b==c```意味着```a==c```(传递性)
 
-关于协议遵循的更多信息，请看[协议](22_Protocols.html)
+关于协议遵循的更多信息，请看[协议](./22_Protocols.html)
 
 <a name="set_type_syntax"></a>
 ### Set类型语法
@@ -393,7 +397,7 @@ for genre in favoriteGenres {
 // Hip hop
 ```
 
-更多关于`for-in`循环信息，参见[For循环](05_Control_Flow.html#for_loops)。
+更多关于`for-in`循环信息，参见[For循环](./05_Control_Flow.html#for_loops)。
 
 Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中值可以使用`sort()`方法，它将根据提供的序列返回一个排序的集合.
 
@@ -471,7 +475,7 @@ farmAnimals.isDisjointWith(cityAnimals)
 
 > 注意：
 > Swiftly 的`Dictionary` 类型被桥接到Foundation的`NSDictionary`类。
-> 更多关于在`Foundation`和`Cocoa`中使用`Dictionary`类型的信息，参见 *Using Swift with Cocoa and Obejective-C* 一书。
+> 更多关于在`Foundation`和`Cocoa`中使用`Dictionary`类型的信息，参见 [*Using Swift with Cocoa and Obejective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 一书。
 
 <a name="dictionary_type_shorthand_syntax"></a>
 ## 字典类型快捷语法
@@ -640,7 +644,7 @@ for (airportCode, airportName) in airports {
 // LHR: London Heathrow
 ```
 
-更多关于`for-in`循环的信息，参见[For 循环](05_Control_Flow.html#for_loops)。
+更多关于`for-in`循环的信息，参见[For 循环](./05_Control_Flow.html#for_loops)。
 
 通过访问`keys`或者`values`属性，我们也可以遍历字典的键或者值。
 
diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index bf6bb692..6070ef8b 100755
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -1,5 +1,9 @@
-> 翻译：[vclwei](https://github.com/vclwei), [coverxit](https://github.com/coverxit), [NicePiao](https://github.com/NicePiao), [JackAlan](https://github.com/AlanMelody)
-> 校对：[coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai), [JackAlan](https://github.com/AlanMelody)
+> 1.0
+> 翻译：[vclwei](https://github.com/vclwei), [coverxit](https://github.com/coverxit), [NicePiao](https://github.com/NicePiao)
+> 校对：[coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai)
+
+> 2.0
+> 翻译+校对：[JackAlan](https://github.com/AlanMelody)
 
 # 控制流
 -----------------
@@ -87,7 +91,7 @@ for (animalName, legCount) in numberOfLegs {
 // spiders have 8 legs
 ```
 
-字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见[集合类型](04_Collection_Types.html)。
+字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见[集合类型](./04_Collection_Types.html)。
 
 <a name="for"></a>
 
@@ -529,8 +533,9 @@ case let (x, y):
 - `break`
 - `fallthrough`
 - `return`
+- `throw`
 
-我们将会在下面讨论`continue`、`break`和`fallthrough`语句。`return`语句将会在[函数](06_Functions.html)章节讨论。
+我们将会在下面讨论`continue`、`break`和`fallthrough`语句。`return`语句将会在[函数](./06_Functions.html)章节讨论，`throw`语句会在[错误抛出](./18_Error_Handling.html#throwing_errors)
 
 <a name="continue"></a>
 ### Continue
diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index eca20a64..6b5030bb 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[honghaoz](https://github.com/honghaoz)
 > 校对：[LunaticM](https://github.com/LunaticM)
 
+> 2.0
+> 翻译+校对：[dreamkidd](https://github.com/dreamkidd)
+
 # 函数（Functions）
 -----------------
 
@@ -116,6 +120,7 @@ print(sayHello("Tim", alreadyGreeted: true))
 
 当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记,函数参数命名在[函数参数名称（Function Parameter Names）](#Function_Parameter_Names)有更详细的描述.
 
+<a name="functions_without_return_values"></a>
 ### 无返回值函数（Functions Without Return Values）
 
 函数可以没有返回值。下面是 `sayHello(_:)` 函数的另一个版本，叫 `sayGoodbye(_:)`，这个函数直接输出 `String` 值，而不是返回它：
@@ -242,6 +247,7 @@ someFunction(1, secondParameterName: 2)
 
 一般情况下,第一个参数省略其外部参数名,第二个以后的参数使用其本地参数名作为自己的外部参数名.所有参数需要有不同的本地参数名,但可以共享相同的外部参数名.
 
+<a name="specifying_external_parameter_names"></a>
 ### 指定外部参数名(Specifying External Parameter Names)
 
 你可以在本地参数名前指定外部参数名,中间以逗号分隔.
@@ -373,6 +379,7 @@ let paddedString = alignRight(originalString, totalLength: 10, pad: "-")
 > 注意：
 > 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。
 
+<a name="in_out_parameters"></a>
 ### 输入输出参数（In-Out Parameters）
 
 变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index d39d877c..5f22445b 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[wh1100717](https://github.com/wh1100717)
 > 校对：[lyuka](https://github.com/lyuka)
 
+> 2.0
+> 翻译+校对：[100mango](https://github.com/100mango)
+
 # 闭包（Closures）
 -----------------
 
@@ -20,7 +24,7 @@ Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他
 > 注意：
 > 如果您不熟悉捕获（capturing）这个概念也不用担心，您可以在 [值捕获](#capturing_values) 章节对其进行详细了解。
 
-在[函数](../chapter2/06_Functions.html) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
+在[函数](./06_Functions.html) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
 
 * 全局函数是一个有名字但不会捕获任何值的闭包
 * 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
@@ -37,7 +41,7 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
 ## 闭包表达式（Closure Expressions）
 
 
-[嵌套函数](../chapter2/06_Functions.html#nested_function) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
+[嵌套函数](./06_Functions.html#nested_function) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
 
 闭包表达式是一种利用简洁语法构建内联闭包的方式。
 闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
@@ -172,7 +176,7 @@ Swift 的`String`类型定义了关于大于号 (`>`) 的字符串实现，其
 reversed = names.sort(>)
 ```
 
-更多关于运算符表达式的内容请查看 [运算符函数](../chapter2/24_Advanced_Operators.html#operator_functions)。
+更多关于运算符表达式的内容请查看 [运算符函数](./24_Advanced_Operators.html#operator_functions)。
 
 <a name="trailing_closures"></a>
 ## 尾随闭包（Trailing Closures）
@@ -246,7 +250,7 @@ let strings = numbers.map {
 `map`在数组中为每一个元素调用了闭包表达式。
 您不需要指定闭包的输入参数`number`的类型，因为可以通过要映射的数组类型进行推断。
 
-闭包`number`参数被声明为一个变量参数（变量的具体描述请参看[常量参数和变量参数](../chapter2/06_Functions.html#constant_and_variable_parameters)），因此可以在闭包函数体内对其进行修改。闭包表达式制定了返回类型为`String`，以表明存储映射值的新数组类型为`String`。
+闭包`number`参数被声明为一个变量参数（变量的具体描述请参看[常量参数和变量参数](./06_Functions.html#constant_and_variable_parameters)），因此可以在闭包函数体内对其进行修改。闭包表达式制定了返回类型为`String`，以表明存储映射值的新数组类型为`String`。
 
 闭包表达式在每次被调用的时候创建了一个字符串并返回。
 其使用求余运算符 (number % 10) 计算最后一位数字并利用`digitNames`字典获取所映射的字符串。
@@ -296,7 +300,7 @@ func makeIncrementor(forIncrement amount: Int) -> () -> Int {
 `makeIncrementor`返回类型为`() -> Int`。
 这意味着其返回的是一个函数，而不是一个简单类型值。
 该函数在每次调用时不接受参数只返回一个`Int`类型的值。
-关于函数返回其他函数的内容，请查看[函数类型作为返回类型](../chapter2/06_Functions.html#function_types_as_return_types)。
+关于函数返回其他函数的内容，请查看[函数类型作为返回类型](./06_Functions.html#function_types_as_return_types)。
 
 `makeIncrementor`函数定义了一个整型变量`runningTotal`(初始为0) 用来存储当前跑步总数。
 该值通过`incrementor`返回。
@@ -352,7 +356,7 @@ incrementByTen()
 
 > 注意：
 > 如果您将闭包赋值给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
-> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [闭包引起的循环强引用](../chapter2/16_Automatic_Reference_Counting.html#strong_reference_cycles_for_closures)。
+> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [闭包引起的循环强引用](./16_Automatic_Reference_Counting.html#strong_reference_cycles_for_closures)。
 
 <a name="closures_are_reference_types"></a>
 ## 闭包是引用类型（Closures Are Reference Types）
diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 941b4f8d..506f9612 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[yankuangshi](https://github.com/yankuangshi)  
 > 校对：[shinyzhu](https://github.com/shinyzhu)
 
+> 2.0
+> 翻译+校对：[futantan](https://github.com/futantan)
+
 # 枚举（Enumerations）
 ---
 
@@ -20,7 +24,7 @@
 
 在 Swift 中，枚举类型是一等公民（first-class）。它们采用了很多传统上只被类（class）所支持的特征，例如计算型属性（computed properties），用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。
 
-欲了解更多相关信息，请参见[属性（Properties）](10_Properties.html)，[方法（Methods）](11_Methods.html)，[构造过程（Initialization）](14_Initialization.html)，[扩展（Extensions）](20_Extensions.html)和[协议（Protocols）](21_Protocols.html)。
+欲了解更多相关信息，请参见[属性（Properties）](./10_Properties.html)，[方法（Methods）](./11_Methods.html)，[构造过程（Initialization）](./14_Initialization.html)，[扩展（Extensions）](./20_Extensions.html)和[协议（Protocols）](./21_Protocols.html)。
 
 <a name="enumeration_syntax"></a>
 ## 枚举语法
@@ -97,7 +101,7 @@ case .West:
 
 等等以此类推。
 
-正如在[控制流（Control Flow）](05_Control_Flow.html)中介绍的那样，在判断一个枚举类型的值时，`switch`语句必须穷举所有情况。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。强制性全部穷举的要求确保了枚举成员不会被意外遗漏。
+正如在[控制流（Control Flow）](./05_Control_Flow.html)中介绍的那样，在判断一个枚举类型的值时，`switch`语句必须穷举所有情况。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。强制性全部穷举的要求确保了枚举成员不会被意外遗漏。
 
 当不需要匹配每个枚举成员的时候，你可以提供一个默认`default`分支来涵盖所有未明确被提出的枚举成员：
 
@@ -187,7 +191,7 @@ case let .QRCode(productCode):
 <a name="raw_values"></a>
 ## 原始值（Raw Values）
 
-在[Associated Values](#raw_values)小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的相关值。作为相关值的另一种选择，枚举成员可以被默认值（称为原始值）赋值，其中这些原始值具有相同的类型。
+在[相关值](#raw_values)小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的相关值。作为相关值的另一种选择，枚举成员可以被默认值（称为原始值）赋值，其中这些原始值具有相同的类型。
 
 这里是一个枚举成员存储 ASCII 码的例子：
 
@@ -199,7 +203,7 @@ enum ASCIIControlCharacter: Character {
 }
 ```
 
-在这里，`ASCIIControlCharacter`的枚举类型的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符[`Strings and Characters`](03_Strings_and_Characters.html)部分。
+在这里，`ASCIIControlCharacter`的枚举类型的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见[字符串和字符](./03_Strings_and_Characters.html)部分。
 
 
 原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。
@@ -261,7 +265,7 @@ let possiblePlanet = Planet(rawValue: 7)
 
 <!-- TODO 连接 -->  
 >注意：  
->原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[Failableinitializers](http://)
+>原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[可失败构造器](../chapter3/05_Declarations#failable_initializers)
 
 如果你试图寻找一个位置为9的行星，通过参数为`rawValue`构造函数返回的可选`Planet`值将是`nil`：
 
diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index 84b16ae6..df922f29 100755
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -1,5 +1,9 @@
-> 翻译：[JaySurplus](https://github.com/JaySurplus),[SkyJean](https://github.com/SkyJean)
-> 校对：[sg552](https://github.com/sg552),[SkyJean](https://github.com/SkyJean)
+> 1.0
+> 翻译：[JaySurplus](https://github.com/JaySurplus)
+> 校对：[sg552](https://github.com/sg552)
+
+> 2.0
+> 翻译+校对：[SkyJean](https://github.com/SkyJean)
 
 # 类和结构体
 
@@ -31,7 +35,7 @@ Swift 中类和结构体有很多共同点。共同处在于：
 * 通过扩展以增加默认实现的功能
 * 实现协议以提供某种标准功能
 
-更多信息请参见 [属性](10_Properties.html)，[方法](11_Methods.html)，[下标脚本](12_Subscripts.html)，[初始过程](14_Initialization.html)，[扩展](20_Extensions.html)，和[协议](21_Protocols.html)。
+更多信息请参见 [属性](./10_Properties.html)，[方法](./11_Methods.html)，[下标脚本](./12_Subscripts.html)，[初始过程](./14_Initialization.html)，[扩展](./20_Extensions.html)，和[协议](./21_Protocols.html)。
 
 与结构体相比，类还有如下的附加功能：
 
@@ -40,7 +44,7 @@ Swift 中类和结构体有很多共同点。共同处在于：
 * 解构器允许一个类实例释放任何其所被分配的资源
 * 引用计数允许对一个类的多次引用
 
-更多信息请参见[继承](13_Inheritance.html)，[类型转换](20_Type_Casting.html)，[析构过程](15_Deinitialization)，和[自动引用计数](16_Automatic_Reference_Counting)。
+更多信息请参见[继承](./13_Inheritance.html)，[类型转换](./20_Type_Casting.html)，[析构过程](./15_Deinitialization)，和[自动引用计数](./16_Automatic_Reference_Counting)。
 
 > 注意：
 结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
@@ -91,7 +95,7 @@ let someResolution = Resolution()
 let someVideoMode = VideoMode()
 ```
 
-结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
+结构体和类都使用构造器语法来生成新的实例。构造器语法的最简单形式是在结构体或者类的类型名称后跟随一对空括号，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属性均会被初始化为默认值。[构造过程](./14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
 
 ### 属性访问
 
@@ -130,7 +134,7 @@ print("The width of someVideoMode is now \(someVideoMode.resolution.width)")
 let vga = Resolution(width:640, height: 480)
 ```
 
-与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](14_Initialization.html)章节会对构造器进行更详细的讨论。
+与结构体不同，类实例没有默认的成员逐一构造器。[构造过程](./14_Initialization.html)章节会对构造器进行更详细的讨论。
 
 <a name="structures_and_enumerations_are_value_types"></a>
 ## 结构体和枚举是值类型
@@ -249,7 +253,7 @@ if tenEighty === alsoTenEighty {
 * “等价于”表示两个类类型（class type）的常量或者变量引用同一个类实例。
 * “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
 
-当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[运算符函数(Operator Functions)](24_Advanced_Operators.html#operator_functions)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
+当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[等价操作符](./24_Advanced_Operators.html#equivalence_operators)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
 
 ### 指针
 
diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 3ee6921e..b14c7579 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[shinyzhu](https://github.com/shinyzhu)  
 > 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
 
+> 2.0
+> 翻译+校对：[yangsiy](https://github.com/yangsiy)
+
 # 属性 (Properties)
 ---
 
@@ -23,7 +27,7 @@
 
 简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量。存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
 
-可以在定义存储属性的时候指定默认值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[默认属性值](../chapter2/14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[在初始化阶段修改常量存储属性](../chapter2/14_Initialization.html#modifying_constant_properties_during_initialization)一节。
+可以在定义存储属性的时候指定默认值，请参考[默认属性值](./14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[在初始化阶段修改常量存储属性](./14_Initialization.html#assigning_constant_properties_during_initialization)一节。
 
 下面的例子定义了一个名为`FixedLengthRange`的结构体，它描述了一个在创建后无法修改值域宽度的区间：
 
@@ -87,7 +91,7 @@ class DataManager {
 }
 
 let manager = DataManager()
-manager.data.append("Some data")
+manager.data.append("Some data")
 manager.data.append("Some more data")
 // DataImporter 实例的 importer 属性还没有被创建
 ```
@@ -104,9 +108,9 @@ manager.data.append("Some more data")
 print(manager.importer.fileName)
 // DataImporter 实例的 importer 属性现在被创建了
 // 输出 "data.txt”
-```
-
-> 注意：  
+```
+
+> 注意：  
 > 如果一个被标记为`lazy`的属性在没有初始化时就同时被多个线程访问，则无法保证该属性只会被初始化一次。
 
 <a name="stored_properties_and_instance_variables"></a>
@@ -219,7 +223,7 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
 
 *属性观察器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。
 
-可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。属性重载请参考[继承](chapter/13_Inheritance.html)一章的[重载](chapter/13_Inheritance.html#overriding)。
+可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。属性重载请参考[重载](./13_Inheritance.html#overriding)。
 
 > 注意：  
 > 不需要为非重载的计算属性添加属性观察器，因为可以通过它的 setter 直接监控和响应值的变化。  
@@ -233,9 +237,9 @@ print("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
 
 类似地，`didSet`观察器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。
 
-> 注意：  
-> 父类的属性在子类的构造器中被赋值时，它在父类中的`willSet`和`didSet`观察器会被调用。  
-> 有关构造器代理的更多信息，请参考[值类型的构造器代理](chapter/14_Initialization.html#initializer_delegation_for_value_types)和[构造器链](chapter/14_Initialization.html#initialization_chain)。
+> 注意：  
+> 父类的属性在子类的构造器中被赋值时，它在父类中的`willSet`和`didSet`观察器会被调用。  
+> 有关构造器代理的更多信息，请参考[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)和[类的构造器代理规则](./14_Initialization.html#initializer_delegation_for_class_types)。
 
 这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数。这个类可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
 
@@ -322,13 +326,13 @@ enum SomeEnumeration {
         return 6
     }
 }
-class SomeClass {
+class SomeClass {
     static var storedTypeProperty = "Some value."
     static var computedTypeProperty: Int {
         return 27
-    }
-    class var overrideableComputedTypeProperty: Int {
-        return 107
+    }
+    class var overrideableComputedTypeProperty: Int {
+        return 107
     }
 }
 ```
@@ -341,12 +345,12 @@ class SomeClass {
 
 跟实例的属性一样，类型属性的访问也是通过点运算符来进行。但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如：
 
-```swift
+```swift
 print(SomeStructure.storedTypeProperty)
-// 输出 "Some value."
+// 输出 "Some value."
 SomeStructure.storedTypeProperty = "Another value."
 print(SomeStructure.storedTypeProperty)
-// 输出 "Another value.”
+// 输出 "Another value.”
 print(SomeEnumeration.computedTypeProperty)
 // 输出 "6"
 print(SomeClass.computedTypeProperty)
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index 61ab2728..a119bf00 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[pp-prog](https://github.com/pp-prog)  
 > 校对：[zqp](https://github.com/zqp)
 
+> 2.0
+> 翻译+校对：[DianQK](https://github.com/DianQK)
+
 # 方法（Methods）
 -----------------
 
@@ -16,7 +20,7 @@
 <a name="instance_methods"></a>
 ## 实例方法 (Instance Methods)
 
-**实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](../charpter2/06_Functions.md)。
+**实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](./06_Functions.md)。
 
 实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。
 
@@ -60,7 +64,7 @@ class Counter {
 <a name="local_and_external_parameter"></a>
 ### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)
 
-函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。
+函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[指定外部参数名](./06_Functions.html#specifying_external_parameter_names)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。
 
 Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy(_:)`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。
 
@@ -85,8 +89,8 @@ counter.incrementBy(5, numberOfTimes: 3)
 // counter 的值现在是 15
 ```
 
-你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy(_numberOfTimes:)`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。
-这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
+你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy(_numberOfTimes:)`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。
+这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
 
 
 <a name="modifying_external_parameter_name_behavior_for_methods"></a>
@@ -95,7 +99,7 @@ counter.incrementBy(5, numberOfTimes: 3)
 有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（`#`）作为第一个参数的前缀来把这个局部名称当作外部名称使用。
 
 相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（`_`）作为该参数的显式外部名称，这样做将覆盖默认行为。
-
+
 
 <a name="the_self_property"></a>
 ### self 属性(The self Property)
@@ -157,7 +161,7 @@ print("The point is now at (\(somePoint.x), \(somePoint.y))")
 
 上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX(_:y:)`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字，这才让方法可以修改值类型的属性。
 
-注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量](10_Properties.html#global_and_local_variables)：
+注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量](./10_Properties.html#global_and_local_variables)：
 
 ```swift
 let fixedPoint = Point(x: 3.0, y: 3.0)
@@ -234,23 +238,23 @@ SomeClass.someTypeMethod()
 游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。
 
 ```swift
-struct LevelTracker {
-    static var highestUnlockedLevel = 1
-    static func unlockLevel(level: Int) {
-        if level > highestUnlockedLevel { highestUnlockedLevel = level }
-    }
-    static func levelIsUnlocked(level: Int) -> Bool {
-        return level <= highestUnlockedLevel
-    }
-    var currentLevel = 1
-    mutating func advanceToLevel(level: Int) -> Bool {
-        if LevelTracker.levelIsUnlocked(level) {
-            currentLevel = level
-            return true
-        } else {
-            return false
-        }
-    }
+struct LevelTracker {
+    static var highestUnlockedLevel = 1
+    static func unlockLevel(level: Int) {
+        if level > highestUnlockedLevel { highestUnlockedLevel = level }
+    }
+    static func levelIsUnlocked(level: Int) -> Bool {
+        return level <= highestUnlockedLevel
+    }
+    var currentLevel = 1
+    mutating func advanceToLevel(level: Int) -> Bool {
+        if LevelTracker.levelIsUnlocked(level) {
+            currentLevel = level
+            return true
+        } else {
+            return false
+        }
+    }
 }
 ```
 
diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index 21a390dd..2eba7640 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[siemenliu](https://github.com/siemenliu)  
 > 校对：[zq54zquan](https://github.com/zq54zquan)
 
+> 2.0
+> 翻译+校对：[shanksyang](https://github.com/shanksyang)
+
 
 # 下标脚本（Subscripts）
 -----------------
@@ -79,7 +83,7 @@ numberOfLegs["bird"] = 2
 
 上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`[String:Int]`。字典实例创建完成之后通过下标脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
 
-更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](../chapter2/04_Collection_Types.html)
+更多关于字典（Dictionary）下标脚本的信息请参考[读取和修改字典](./04_Collection_Types.html#accessing_and_modifying_a_dictionary)
 
 > 注意：  
 > Swift 中字典的附属脚本实现中，在`get`部分返回值是`Int?`，上例中的`numberOfLegs`字典通过附属脚本返回的是一个`Int?`或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。  
@@ -118,7 +122,7 @@ struct Matrix {
 }
 ```
 
-`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。通过传入数组长度和初始值0.0到数组的一个构造器，将`Matrix`中每个元素初始值0.0。关于数组的构造方法和析构方法请参考[创建并且构造一个数组](../chapter2/04_Collection_Types.html)。
+`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。通过传入数组长度和初始值0.0到数组的一个构造器，将`Matrix`中每个元素初始值0.0。关于数组的构造方法和析构方法请参考[创建一个空数组](./04_Collection_Types.html#creating_an_empty_array)。
 
 你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例：
 
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index 2c4ece52..d393f7fe 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[Hawstein](https://github.com/Hawstein)  
 > 校对：[menlongsheng](https://github.com/menlongsheng)
 
+> 2.0
+> 翻译+校对：[shanksyang](https://github.com/shanksyang)
+
 # 继承（Inheritance）
 -------------------
 
@@ -25,34 +29,34 @@
 > 注意：  
 Swift 中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。
 
-下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了一个名为`currentSpeed `，默认值是0.0的存储属性(属性类型推断为`Double `)。`currentSpeed `属性的值被一个`String` 类型的只读计算型属性`description`使用，用来创建车辆的描述。
-
+下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了一个名为`currentSpeed `，默认值是0.0的存储属性(属性类型推断为`Double `)。`currentSpeed `属性的值被一个`String` 类型的只读计算型属性`description`使用，用来创建车辆的描述。
+
 `Vehicle`基类也定义了一个名为`makeNoise`的方法。这个方法实际上不为`Vehicle`实例做任何事，但之后将会被`Vehicle`的子类定制：
 
 ```swift
-class Vehicle {
-    var currentSpeed = 0.0
-    var description: String {
-        return "traveling at \(currentSpeed) miles per hour"
-    }
-    func makeNoise() {
-        // 什么也不做-因为车辆不一定会有噪音
-    }
+class Vehicle {
+    var currentSpeed = 0.0
+    var description: String {
+        return "traveling at \(currentSpeed) miles per hour"
+    }
+    func makeNoise() {
+        // 什么也不做-因为车辆不一定会有噪音
+    }
 }
 ```
-
-您可以用初始化语法创建一个`Vehicle `的新实例，即类名后面跟一个空括号：
-```swift
-let someVehicle = Vehicle()
-```
-
-现在已经创建了一个`Vehicle`的新实例，你可以访问它的`description`属性来打印车辆的当前速度。
-
-```swift
-print("Vehicle: \(someVehicle.description)")
-// Vehicle: traveling at 0.0 miles per hour
-```
-
+
+您可以用初始化语法创建一个`Vehicle `的新实例，即类名后面跟一个空括号：
+```swift
+let someVehicle = Vehicle()
+```
+
+现在已经创建了一个`Vehicle`的新实例，你可以访问它的`description`属性来打印车辆的当前速度。
+
+```swift
+print("Vehicle: \(someVehicle.description)")
+// Vehicle: traveling at 0.0 miles per hour
+```
+
 `Vehicle`类定义了一个通用特性的车辆类，实际上没什么用处。为了让它变得更加有用，需要改进它能够描述一个更加具体的车辆类。
 
 <a name="subclassing"></a>
@@ -68,51 +72,51 @@ class SomeClass: SomeSuperclass {
 }
 ```
 
-下一个例子，定义一个叫`Bicycle`的子类，继承成父类`Vehicle`
-
-```swift
-class Bicycle: Vehicle {
-    var hasBasket = false
-}
-```
+下一个例子，定义一个叫`Bicycle`的子类，继承成父类`Vehicle`
 
-新的`Bicycle`类自动获得`Vehicle`类的所有特性，比如 `currentSpeed `和`description`属性，还有它的`makeNoise`方法。
-
-除了它所继承的特性，`Bicycle`类还定义了一个默认值为`false`的存储型属性`hasBasket`（属性推断为`Bool`）。
-
-默认情况下，你创建任何新的`Bicycle`实例将不会有一个篮子，创建该实例之后，你可以为特定的`Bicycle`实例设置`hasBasket `属性为`ture`：
-
-```swift
-let bicycle = Bicycle()
-bicycle.hasBasket = true
-```
-
-你还可以修改`Bicycle `实例所继承的`currentSpeed `属性，和查询实例所继承的`description `属性：
-
-```swift
-bicycle.currentSpeed = 15.0
-print("Bicycle: \(bicycle.description)")
-// Bicycle: traveling at 15.0 miles per hour
+```swift
+class Bicycle: Vehicle {
+    var hasBasket = false
+}
+```
+
+新的`Bicycle`类自动获得`Vehicle`类的所有特性，比如 `currentSpeed `和`description`属性，还有它的`makeNoise`方法。
+
+除了它所继承的特性，`Bicycle`类还定义了一个默认值为`false`的存储型属性`hasBasket`（属性推断为`Bool`）。
+
+默认情况下，你创建任何新的`Bicycle`实例将不会有一个篮子，创建该实例之后，你可以为特定的`Bicycle`实例设置`hasBasket `属性为`ture`：
+
+```swift
+let bicycle = Bicycle()
+bicycle.hasBasket = true
+```
+
+你还可以修改`Bicycle `实例所继承的`currentSpeed `属性，和查询实例所继承的`description `属性：
+
+```swift
+bicycle.currentSpeed = 15.0
+print("Bicycle: \(bicycle.description)")
+// Bicycle: traveling at 15.0 miles per hour
 ```
 
 子类还可以继续被其它类继承，下面的示例为`Bicycle `创建了一个名为`Tandem `（双人自行车）的子类：
 
 ```swift
-class Tandem: Bicycle {
-    var currentNumberOfPassengers = 0
+class Tandem: Bicycle {
+    var currentNumberOfPassengers = 0
 }
 ```
 
-`Tandem`从`Bicycle`继承了所有的属性与方法，这又使它同时继承了`Vehicle`的所有属性与方法。`Tandem`也增加了一个新的叫做`currentNumberOfPassengers`的存储型属性，默认值为0。
-
+`Tandem`从`Bicycle`继承了所有的属性与方法，这又使它同时继承了`Vehicle`的所有属性与方法。`Tandem`也增加了一个新的叫做`currentNumberOfPassengers`的存储型属性，默认值为0。
+
 如果你创建了一个`Tandem`的实例，你可以使用它所有的新属性和继承的属性，还能查询从`Vehicle`继承来的只读属性`description `：
 
 ```swift
-let tandem = Tandem()
-tandem.hasBasket = true
-tandem.currentNumberOfPassengers = 2
-tandem.currentSpeed = 22.0
-print("Tandem: \(tandem.description)")
+let tandem = Tandem()
+tandem.hasBasket = true
+tandem.currentNumberOfPassengers = 2
+tandem.currentSpeed = 22.0
+print("Tandem: \(tandem.description)")
 // Tandem: traveling at 22.0 miles per hour
 ```
 
@@ -142,18 +146,18 @@ print("Tandem: \(tandem.description)")
 下面的例子定义了`Vehicle`的一个新的子类，叫`Train `，它重写了从`Vehicle`类继承来的`makeNoise `方法：
 
 ```swift
-class Train: Vehicle {
-    override func makeNoise() {
-        print("Choo Choo")
-    }
+class Train: Vehicle {
+    override func makeNoise() {
+        print("Choo Choo")
+    }
 }
 ```
 
 如果你创建一个`Train `的新实例，并调用了它的`makeNoise `方法，你就会发现`Train `版本的方法被调用：
 
 ```swift
-let train = Train()
-train.makeNoise()
+let train = Train()
+train.makeNoise()
 // prints "Choo Choo"
 ```
 
@@ -173,23 +177,23 @@ train.makeNoise()
 以下的例子定义了一个新类，叫`Car`，它是`Vehicle `的子类。这个类引入了一个新的存储型属性叫做`gear `，默认为整数1。`Car`类重写了继承自`Vehicle `的description属性，提供自定义的，包含当前档位的描述：
 
 ```swift
-class Car: Vehicle {
-    var gear = 1
-    override var description: String {
-        return super.description + " in gear \(gear)"
-    }
+class Car: Vehicle {
+    var gear = 1
+    override var description: String {
+        return super.description + " in gear \(gear)"
+    }
 }
-```
-
-重写的`description `属性，首先要调用`super.description`返回`Vehicle`类的`description`属性。之后，`Car `类版本的`description`在末尾增加了一些额外的文本来提供关于当前档位的信息。
-
+```
+
+重写的`description `属性，首先要调用`super.description`返回`Vehicle`类的`description`属性。之后，`Car `类版本的`description`在末尾增加了一些额外的文本来提供关于当前档位的信息。
+
 如果你创建了`Car `的实例并且设置了它的`gear`和`currentSpeed`属性，你可以看到它的`description`返回了`Car`中定义的`description`：
 
 ```swift
-let car = Car()
-car.currentSpeed = 25.0
-car.gear = 3
-print("Car: \(car.description)")
+let car = Car()
+car.currentSpeed = 25.0
+car.gear = 3
+print("Car: \(car.description)")
 // Car: traveling at 25.0 miles per hour in gear 3
 ```
 
@@ -203,21 +207,21 @@ print("Car: \(car.description)")
 下面的例子定义了一个新类叫`AutomaticCar`，它是`Car`的子类。`AutomaticCar`表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位:
 
 ```swift
-class AutomaticCar: Car {
-    override var currentSpeed: Double {
-        didSet {
-            gear = Int(currentSpeed / 10.0) + 1
-        }
-    }
+class AutomaticCar: Car {
+    override var currentSpeed: Double {
+        didSet {
+            gear = Int(currentSpeed / 10.0) + 1
+        }
+    }
 }
 ```
 
 当你设置`AutomaticCar`的`currentSpeed `属性，属性的`didSet`观察器就会自动地设置`gear`属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位`gear`的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4：
 
 ```swift
-let automatic = AutomaticCar()
-automatic.currentSpeed = 35.0
-print("AutomaticCar: \(automatic.description)")
+let automatic = AutomaticCar()
+automatic.currentSpeed = 35.0
+print("AutomaticCar: \(automatic.description)")
 // AutomaticCar: traveling at 35.0 miles per hour in gear 4
 ```
 
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index a11a5070..7cdf3179 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -1,5 +1,9 @@
+> 1.0
 > 翻译：[lifedim](https://github.com/lifedim)
-> 校对：[lifedim](https://github.com/lifedim)，[chenmingbiao](https://github.com/chenmingbiao)
+> 校对：[lifedim](https://github.com/lifedim)
+
+> 2.0
+> 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
 
 # 构造过程（Initialization）
 
@@ -21,7 +25,7 @@
 
 构造过程是通过定义构造器（`Initializers`）来实现的，这些构造器可以看做是用来创建特定类型实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。
 
-类的实例也可以通过定义析构器（`deinitializer`）在实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](15_Deinitialization.html)。
+类的实例也可以通过定义析构器（`deinitializer`）在实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](./15_Deinitialization.html)。
 
 <a name="setting_initial_values_for_stored_properties"></a>
 ## 存储型属性的初始赋值
@@ -193,6 +197,7 @@ cheeseQuestion.response = "Yes, I do like cheese."
 
 调查问题在问题提出之后，我们才能得到回答。所以我们将属性回答`response`声明为`String?`类型，或者说是可选字符串类型`optional String`。当`SurveyQuestion`实例化时，它将自动赋值为空`nil`，表明暂时还不存在此字符串。
 
+<a name="assigning_constant_properties_during_initialization"></a>
 ### 构造过程中常量属性的修改
 
 只要在构造过程结束前常量的值能确定，你可以在构造过程中的任意时间点修改常量属性的值。
@@ -237,6 +242,7 @@ var item = ShoppingListItem()
 
 由于`ShoppingListItem`类中的所有属性都有默认值，且它是没有父类的基类，它将自动获得一个可以为所有属性设置默认值的默认构造器（尽管代码中没有显式为`name`属性设置默认值，但由于`name`是可选字符串类型，它将默认设置为`nil`）。上面例子中使用默认构造器创造了一个`ShoppingListItem`类的实例（使用`ShoppingListItem()`形式的构造器语法），并将其赋值给变量`item`。
 
+<a name="memberwise_initializers_for_structure_types"></a>
 ### 结构体的逐一成员构造器
 
 除上面提到的默认构造器，如果结构体对所有存储型属性提供了默认值且自身没有提供定制的构造器，它们能自动获得一个逐一成员构造器。
@@ -259,14 +265,14 @@ let twoByTwo = Size(width: 2.0, height: 2.0)
 
 构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。
 
-构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
+构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](./13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
 
 对于值类型，你可以使用`self.init`在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用`self.init`。
 
 如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。
 
 >注意：  
-假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](20_Extensions.html)章节。
+假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](./20_Extensions.html)章节。
 
 下面例子将定义一个结构体`Rect`，用来代表几何矩形。这个例子需要两个辅助的结构体`Size`和`Point`，它们各自为其所有的属性提供了初始值`0.0`。
 
@@ -324,7 +330,7 @@ let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
 构造器`init(center:size:)`可以自己将`origin`和`size`的新值赋值到对应的属性中。然而尽量利用现有的构造器和它所提供的功能来实现`init(center:size:)`的功能，是更方便、更清晰和更直观的方法。
 
 >注意：  
-如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](20_Extensions.html)。
+如果你想用另外一种不需要自己定义`init()`和`init(origin:size:)`的方式来实现这个例子，请参考[扩展](./20_Extensions.html)。
 
 <a name="class_inheritance_and_initialization"></a>
 ## 类的继承和构造过程
@@ -361,8 +367,8 @@ convenience init(parameters) {
 }
 ```
 
-<a name="initialization_chain"></a>
-### 构造器链
+<a name="initializer_delegation_for_class_types"></a>
+### 类的构造器代理规则
 
 为了简化指定构造器和便利构造器之间的调用关系，Swift 采用以下三条规则来限制构造器之间的代理调用：
 
@@ -465,6 +471,7 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造
 
 最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。
 
+<a name="initializer_inheritance_and_overriding"></a>
 ### 构造器的继承和重载
 
 跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。
@@ -609,7 +616,7 @@ class RecipeIngredient: Food {
 
 `RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。
 
-注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识。
+注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识（参见[构造器的继承和重载](#initializer_inheritance_and_overriding)）。
 
 在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
 
diff --git a/source/chapter2/15_Deinitialization.md b/source/chapter2/15_Deinitialization.md
index 6a42b759..6fd6cead 100755
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -1,5 +1,9 @@
+> 1.0
 > 翻译：[bruce0505](https://github.com/bruce0505)
-> 校对：[fd5788](https://github.com/fd5788)，[chenmingbiao](https://github.com/chenmingbiao)
+> 校对：[fd5788](https://github.com/fd5788)
+
+> 2.0
+> 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
 
 # 析构过程（Deinitialization）
 ---------------------------
@@ -14,7 +18,7 @@
 <a name="how_deinitialization_works"></a>
 ##析构过程原理
 
-Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](16_Automatic_Reference_Counting.html)章节中所讲述，Swift 通过`自动引用计数（ARC）`处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。
+Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](./16_Automatic_Reference_Counting.html)章节中所讲述，Swift 通过`自动引用计数（ARC）`处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前手动去关闭该文件。
 
 在类的定义中，每个类最多只能有一个析构器，而且析构器不带任何参数，如下所示：
 
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index 8487742d..3bb443c9 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[TimothyYe](https://github.com/TimothyYe)  
 > 校对：[Hawstein](https://github.com/Hawstein)
 
+> 2.0
+> 翻译+校对：[Channe](https://github.com/Channe)
+
 # 自动引用计数
 -----------------
 
@@ -23,8 +27,8 @@ Swift 使用自动引用计数（ARC）机制来跟踪和管理你的应用程
 <a name="how_arc_works"></a>
 ## 自动引用计数的工作机制
 
-当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。
-
+当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。
+
 此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
 
 然而，当 ARC 收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。
@@ -86,8 +90,8 @@ reference3 = reference1
 ```swift
 reference1 = nil
 reference2 = nil
-```
-
+```
+
 在你清楚地表明不再使用这个`Person`实例时，即第三个也就是最后一个强引用被断开时，ARC 会销毁它。
 
 ```swift
@@ -158,7 +162,7 @@ number73!.tenant = john
 在将两个实例联系在一起之后，强引用的关系如图所示：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle02_2x.png)
-
+
 不幸的是，这两个实例关联后会产生一个循环强引用。`Person`实例现在有了一个指向`Apartment`实例的强引用，而`Apartment`实例也有了一个指向`Person`实例的强引用。因此，当你断开`john`和`number73`变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
 
 ```swift
@@ -184,7 +188,7 @@ Swift 提供了两种办法用来解决你在使用类的属性时所遇到的
 对于生命周期中会变为`nil`的实例使用弱引用。相反地，对于初始化赋值后再也不会被赋值为`nil`的实例，使用无主引用。
 
 ### 弱引用
-
+
 弱引用不会对其引用的实例保持强引用，因而不会阻止 ARC 销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或者变量时，在前面加上`weak`关键字表明这是一个弱引用。
 
 在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以避免循环强引用。如果引用总是有值，则可以使用无主引用，在[无主引用](#2)中有描述。在上面`Apartment`的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。
@@ -297,9 +301,9 @@ class CreditCard {
     }
     deinit { print("Card #\(number) is being deinitialized") }
 }
-```
-
-> 注意:
+```
+
+> 注意:
 > `CreditCard`类的`number`属性被定义为`UInt64`类型而不是`Int`类型，以确保`number`属性的存储量在32位和64位系统上都能足够容纳16位的卡号。
 
 下面的代码片段定义了一个叫`john`的可选类型`Customer`变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为`nil`。
@@ -335,6 +339,8 @@ john = nil
 
 最后的代码展示了在`john`变量被设为`nil`后`Customer`实例和`CreditCard`实例的构造函数都打印出了“销毁”的信息。
 
+
+<a name="unowned_references_and_implicitly_unwrapped_optional_properties"></a>
 ###无主引用以及隐式解析可选属性
 
 上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。
@@ -373,9 +379,9 @@ class City {
 
 为了建立两个类的依赖关系，`City`的构造函数有一个`Country`实例的参数，并且将实例保存为`country`属性。
 
-`Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化完后，`Country`的构造函数才能把`self`传给`City`的构造函数。（[在两段式构造过程中有具体描述](14_Initialization.html)）
+`Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化完后，`Country`的构造函数才能把`self`传给`City`的构造函数。（在[两段式构造过程](./14_Initialization.html#two_phase_initialization)中有具体描述）
 
-为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（[在隐式解析可选类型中有描述](01_The_Basics.html)）
+为了满足这种需求，通过在类型结尾处加上感叹号（`City!`）的方式，将`Country`的`capitalCity`属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开它的值就能访问它。（在[隐式解析可选类型](./01_The_Basics.html#implicityly_unwrapped_optionals)中有描述）
 
 由于`capitalCity`默认值为`nil`，一旦`Country`的实例在构造函数中给`name`属性赋值后，整个初始化过程就完成了。这代表一旦`name`属性被赋值后，`Country`的构造函数就能引用并传递隐式的`self`。`Country`的构造函数在赋值`capitalCity`时，就能将`self`作为参数传递给`City`的构造函数。
 
@@ -456,7 +462,7 @@ print(paragraph!.asHTML())
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/closureReferenceCycle01_2x.png)
 
-实例的`asHTML`属性持有闭包的强引用。但是，闭包在其闭包体内使用了`self`（引用了`self.name`和`self.text`），因此闭包捕获了`self`，这意味着闭包又反过来持有了`HTMLElement`实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考[值捕获](07_Closures.html)）。
+实例的`asHTML`属性持有闭包的强引用。但是，闭包在其闭包体内使用了`self`（引用了`self.name`和`self.text`），因此闭包捕获了`self`，这意味着闭包又反过来持有了`HTMLElement`实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考[值捕获](./07_Closures.html#capturing_values)）。
 
 >注意:  
 虽然闭包多次使用了`self`，它只捕获`HTMLElement`实例的一个强引用。
@@ -477,9 +483,9 @@ paragraph = nil
 >注意:  
 Swift 有如下要求：只要在闭包内使用`self`的成员，就要用`self.someProperty`或者`self.someMethod`（而不只是`someProperty`或`someMethod`）。这提醒你可能会一不小心就捕获了`self`。
 
-###定义捕获列表
+###定义捕获列表
 
-捕获列表中的每一项都由一对元素组成，一个元素是`weak`或`unowned`关键字，另一个元素是类实例的引用（如`self`）或初始化过的变量（如`delegate = self.delegate!`）。这些项在方括号中用逗号分开。
+捕获列表中的每一项都由一对元素组成，一个元素是`weak`或`unowned`关键字，另一个元素是类实例的引用（如`self`）或初始化过的变量（如`delegate = self.delegate!`）。这些项在方括号中用逗号分开。
 
 如果闭包有参数列表和返回类型，把捕获列表放在它们前面：
 
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index 62b03527..13b0c87b 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,8 +1,12 @@
-# Optional Chaining
+# 可空链式调用
 
+> 1.0
 > 翻译：[Jasonbroker](https://github.com/Jasonbroker)  
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
+> 2.0
+> 翻译+校对：[lyojo](https://github.com/lyojo)
+
 -----------------
 可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。
 
@@ -10,166 +14,208 @@
 注意：
 Swift 的可空链式调用和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且能够检查调用是否成功。
 
-##可空链式调用作为强制展开的另一个方案
+<a name="optional_chaining_as_an_alternative_to_forced_unwrapping"></a>
+##使用可空链式调用来强制展开
 通过在想调用非空的属性、方法、或下标的可空值（optional value）后面放一个问号，可以定义一个可空链。这一点很像在可空值后面放一个叹号（！）来强制展开其中值。它们的主要的区别在于当可空值为空时可空链式只是调用失败，然而强制展开将会触发运行时错误。
 
-为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回nil则说明调用失败。
+为了反映可空链式调用可以在空对象（nil）上调用，不论这个调用的属性、方法、下标等返回的值是不是可空值，它的返回结果都是一个可空值。你可以利用这个返回值来判断你的可空链式调用是否调用成功，如果调用有返回值则说明调用成功，返回`nil`则说明调用失败。
 
-特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回Int的类型的结果将会返回Int?类型。
+特别地，可空链式调用的返回结果与原本的返回结果具有相同的类型，但是被包装成了一个可空类型值。当可空链式调用成功时，一个本应该返回`Int`的类型的结果将会返回`Int?`类型。
 
 下面几段代码将解释可空链式调用和强制展开的不同。
-首先定义两个类Person和Residence。
+首先定义两个类`Person`和`Residence`。
 
-	class Person {
+```swift
+class Person {
 	var residence: Residence?
-	}
-	class Residence {
+}
+
+class Residence {
 	var numberOfRooms = 1
-	}
+}
+```
 
-Residence有一个Int类型的属性numberOfRooms，其默认值为1。Person具有一个可空的residence属性，其类型为Residence？。
+`Residence`有一个`Int`类型的属性`numberOfRooms`，其默认值为1。`Person`具有一个可空的`residence`属性，其类型为`Residence?`。
 
-如果创建一个新的Person实例，因为它的residence属性是可空的，john属性将初始化为nil：
+如果创建一个新的`Person`实例，因为它的`residence`属性是可空的，`john`属性将初始化为`nil`：
 
-	let john = Person()
+```swift
+let john = Person()
+```
 
-如果使用叹号（！）强制展开获得这个john的residence属性中的numberOfRooms值，会触发运行时错误，因为这时没有可以展开的residence：
+如果使用叹号（！）强制展开获得这个`john`的`residence`属性中的`numberOfRooms`值，会触发运行时错误，因为这时没有可以展开的`residence`：
 
-	let roomCount = john.residence!.numberOfRooms
-	// this triggers a runtime error
+```swift
+let roomCount = john.residence!.numberOfRooms
+// this triggers a runtime error
+```
 
-john.residence非空的时候，上面的调用成功，并且把roomCount设置为Int类型的房间数量。正如上面说到的，当residence为空的时候上面这段代码会触发运行时错误。
+`john.residence`非空的时候，上面的调用成功，并且把`roomCount`设置为`Int`类型的房间数量。正如上面说到的，当`residence`为空的时候上面这段代码会触发运行时错误。
 
-可空链式调用提供了一种另一种访问numberOfRooms的方法，使用问号（？）来代替原来叹号（！）的位置：
+可空链式调用提供了一种另一种访问`numberOfRooms`的方法，使用问号（？）来代替原来叹号（！）的位置：
 
-	if let roomCount = john.residence?.numberOfRooms {
-	    print("John's residence has \(roomCount) room(s).")
-	} else {
-	    print("Unable to retrieve the number of rooms.")
-	}
-	// prints "Unable to retrieve the number of rooms."
+```swift
+if let roomCount = john.residence?.numberOfRooms {
+    print("John's residence has \(roomCount) room(s).")
+} else {
+    print("Unable to retrieve the number of rooms.")
+}
+// prints "Unable to retrieve the number of rooms."
+```
 
-在residence后面添加问号之后，Swift就会在residence不为空的情况下访问numberOfRooms。
+在`residence`后面添加问号之后，Swift就会在`residence`不为空的情况下访问`numberOfRooms`。
 
-因为访问numberOfRooms有可能失败，可空链式调用会返回Int?类型，或称为“可空的Int”。如上例所示，当residence为nil的时候，可空的Int将会为nil，表明无法访问numberOfRooms。
+因为访问`numberOfRooms`有可能失败，可空链式调用会返回`Int?`类型，或称为“可空的Int”。如上例所示，当`residence`为`nil`的时候，可空的`Int`将会为`nil`，表明无法访问`numberOfRooms`。
 
-要注意的是，即使numberOfRooms是不可空的Int时，这一点也成立。只要是通过可空链式调用就意味着最后numberOfRooms返回一个Int？而不是Int。
+要注意的是，即使`numberOfRooms`是不可空的`Int`时，这一点也成立。只要是通过可空链式调用就意味着最后`numberOfRooms`返回一个`Int?`而不是`Int`。
 
-通过赋给john.residence一个Residence的实例变量：
+通过赋给`john.residence`一个`Residence`的实例变量：
 
-	john.residence = Residence()
-这样john.residence不为nil了。现在就可以正常访问john.residence.numberOfRooms，其值为默认的1，类型为Int?：
+```swift
+john.residence = Residence()
+```
 
-	if let roomCount = john.residence?.numberOfRooms {
+这样`john.residence`不为`nil`了。现在就可以正常访问`john.residence.numberOfRooms`，其值为默认的1，类型为`Int?`：
+
+```swift
+if let roomCount = john.residence?.numberOfRooms {
 	print("John's residence has \(roomCount) room(s).")
-	} else {
+} else {
 	print("Unable to retrieve the number of rooms.")
-	}
-	// prints "John's residence has 1 room(s)."
+}
+// prints "John's residence has 1 room(s)."
+```
+
 ##为可空链式调用定义模型类
 通过使用可空链式调用可以调用多层属性，方法，和下标。这样可以通过各种模型向下访问各种子属性。并且判断能否访问子属性的属性，方法或下标。
 
-下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在Person和Residence的基础上增加了Room和Address，以及相关的属性，方法以及下标。
+下面这段代码定义了四个模型类，这些例子包括多层可空链式调用。为了方便说明，在`Person`和`Residence`的基础上增加了`Room`和`Address`，以及相关的属性，方法以及下标。
 
 Person类定义基本保持不变：
 
-	class Person {
-	    var residence: Residence?
-	}
-Residence类比之前复杂些，增加了一个Room类型的空数组room：
+```swift
+class Person {
+    var residence: Residence?
+}
+```
 
-	class Residence {
-	    var rooms = [Room]()
-	    var numberOfRooms: Int {
-	        return rooms.count
-	    }
-	    subscript(i: Int) -> Room {
-	        get {
-	            return rooms[i]
-	        }
-	        set {
-	            rooms[i] = newValue
-	        }
-	    }
-	    func printNumberOfRooms() {
-	        print("The number of rooms is \(numberOfRooms)")
-	    }
-	    var address: Address?
-	}
+`Residence`类比之前复杂些，增加了一个`Room`类型的空数组`room`：
 
-现在Residence有了一个存储Room类型的数组，numberOfRooms属性需要计算，而不是作为单纯的变量。计算后的numberOfRooms返回rooms数组的count属性值。现在的Residence还提供访问rooms数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供printNumberOfRooms方法，这个方法的作用就是输出这个房子中房间的数量。最后，Residence定义了一个可空属性address，其类型为Address?。Address类的定义在下面会说明。
+```swift
+class Residence {
+    var rooms = [Room]()
+    var numberOfRooms: Int {
+        return rooms.count
+    }
+    subscript(i: Int) -> Room {
+        get {
+            return rooms[i]
+        }
+        set {
+            rooms[i] = newValue
+        }
+    }
+    func printNumberOfRooms() {
+        print("The number of rooms is \(numberOfRooms)")
+    }
+    var address: Address?
+}
+```
 
-类Room是一个简单类，只包含一个属性name，以及一个初始化函数：
+现在`Residence`有了一个存储`Room`类型的数组，`numberOfRooms`属性需要计算，而不是作为单纯的变量。计算后的`numberOfRooms`返回`rooms`数组的`count`属性值。现在的`Residence`还提供访问`rooms`数组的快捷方式， 通过可读写的下标来访问指定位置的数组元素。此外，还提供`printNumberOfRooms`方法，这个方法的作用就是输出这个房子中房间的数量。最后，`Residence`定义了一个可空属性`address`，其类型为`Address?`。`Address`类的定义在下面会说明。
 
-	class Room {
-	    let name: String
-	    init(name: String) { self.name = name }
-	}
-最后一个类是Address，这个类有三个String?类型的可空属性。buildingName以及buildingNumber属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称：
+类`Room`是一个简单类，只包含一个属性`name`，以及一个初始化函数：
 
-	class Address {
-	    var buildingName: String?
-	    var buildingNumber: String?
-	    var street: String?
-	    func buildingIdentifier() -> String? {
-	        if buildingName != nil {
-	            return buildingName
-	        } else if buildingNumber != nil {
-	            return buildingNumber
-	        } else {
-	            return nil
-	        }
-	    }
-	}
-类Address提供buildingIdentifier()方法，返回值为String?。 如果buildingName不为空则返回buildingName， 如果buildingNumber不为空则返回buildingNumber。如果这两个属性都为空则返回nil。
+```swift
+class Room {
+    let name: String
+    init(name: String) { self.name = name }
+}
+```
+
+最后一个类是`Address`，这个类有三个`String?`类型的可空属性。`buildingName`以及`buildingNumber`属性表示建筑的名称和号码，用来表示某个特定的建筑。第三个属性表示建筑所在街道的名称：
+
+```swift
+class Address {
+    var buildingName: String?
+    var buildingNumber: String?
+    var street: String?
+    func buildingIdentifier() -> String? {
+        if buildingName != nil {
+            return buildingName
+        } else if buildingNumber != nil {
+            return buildingNumber
+        } else {
+            return nil
+        }
+    }
+}
+```
+
+类`Address`提供`buildingIdentifier()`方法，返回值为`String?`。 如果`buildingName`不为空则返回`buildingName`， 如果`buildingNumber`不为空则返回`buildingNumber`。如果这两个属性都为空则返回`nil`。
 
 ##通过可空链式调用访问属性
-正如[可空链式调用作为强制展开的另一个方案]中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。
+正如[使用可空链式调用来强制展开](#optional_chaining_as_an_alternative_to_forced_unwrapping)中所述，可以通过可空链式调用访问属性的可空值，并且判断访问是否成功。
 
-下面的代码创建了一个Person实例，然后访问numberOfRooms属性：
+下面的代码创建了一个`Person`实例，然后访问`numberOfRooms`属性：
 
-	let john = Person()
-	if let roomCount = john.residence?.numberOfRooms {
-	    print("John's residence has \(roomCount) room(s).")
-	} else {
-	    print("Unable to retrieve the number of rooms.")
-	}
-	// prints "Unable to retrieve the number of rooms."
-因为john.residence为nil，所以毫无疑问这个可空链式调用失败。
+```swift
+let john = Person()
+if let roomCount = john.residence?.numberOfRooms {
+    print("John's residence has \(roomCount) room(s).")
+} else {
+    print("Unable to retrieve the number of rooms.")
+}
+// prints "Unable to retrieve the number of rooms."
+```
+
+因为`john.residence`为`nil`，所以毫无疑问这个可空链式调用失败。
 
 通过可空链式调用来设定属性值：
 
-	let someAddress = Address()
-	someAddress.buildingNumber = "29"
-	someAddress.street = "Acacia Road"
-	john.residence?.address = someAddress
-在这个例子中，通过john.residence来设定address属性也是不行的，因为john.residence为nil。
+```swift
+let someAddress = Address()
+someAddress.buildingNumber = "29"
+someAddress.street = "Acacia Road"
+john.residence?.address = someAddress
+```
+
+在这个例子中，通过`john.residence`来设定`address`属性也是不行的，因为`john.residence`为`nil`。
 
 ##通过可空链式调用来调用方法
 可以通过可空链式调用来调用方法，并判断是否调用成功，即使这个方法没有返回值。
-Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值：
+`Residence`中的`printNumberOfRooms()`方法输出当前的`numberOfRooms`值：
 
-	func printNumberOfRooms() {
-	    print("The number of rooms is \(numberOfRooms)")
-	}
-这个方法没有返回值。但是没有返回值的方法隐式返回Void类型，如[无返回值函数](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID163)中所述。这意味着没有返回值的方法也会返回()或者空的元组。
+```swift
+func printNumberOfRooms() {
+    print("The number of rooms is \(numberOfRooms)")
+}
+```
 
-如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为Void?，而不是Void，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用if语句来判断能否成功调用printNumberOfRooms()方法，即使方法本身没有定义返回值。通过返回值是否为nil可以判断调用是否成功：
+这个方法没有返回值。但是没有返回值的方法隐式返回`Void`类型，如[无返回值函数](./06_Functions.html#functions_without_return_values)中所述。这意味着没有返回值的方法也会返回()或者空的元组。
 
-	if john.residence?.printNumberOfRooms() != nil {
-	    print("It was possible to print the number of rooms.")
-	} else {
-	    print("It was not possible to print the number of rooms.")
-	}
-	// prints "It was not possible to print the number of rooms."
-同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给john.residence中的address属性赋值，即使residence为nil。通过可空链式调用给属性赋值会返回Void?，通过判断返回值是否为nil可以知道赋值是否成功：
+如果在可空值上通过可空链式调用来调用这个方法，这个方法的返回类型为`Void?`，而不是`Void`，因为通过可空链式调用得到的返回值都是可空的。这样我们就可以使用`if`语句来判断能否成功调用`printNumberOfRooms()`方法，即使方法本身没有定义返回值。通过返回值是否为`nil`可以判断调用是否成功：
 
-	if (john.residence?.address = someAddress) != nil {
+```swift
+if john.residence?.printNumberOfRooms() != nil {
+    print("It was possible to print the number of rooms.")
+} else {
+    print("It was not possible to print the number of rooms.")
+}
+// prints "It was not possible to print the number of rooms."
+```
+
+同样的，可以判断通过可空链式调用来给属性赋值是否成功。在上面的例子中，我们尝试给`john.residence`中的`address`属性赋值，即使`residence`为`nil`。通过可空链式调用给属性赋值会返回`Void?`，通过判断返回值是否为`nil`可以知道赋值是否成功：
+
+```swift
+if (john.residence?.address = someAddress) != nil {
 	print("It was possible to set the address.")
-	} else {
+} else {
 	print("It was not possible to set the address.")
-	}
-	// prints "It was not possible to set the address."
+}
+// prints "It was not possible to set the address."
+```
+
 
 ##通过可空链式调用来访问下标
 通过可空链式调用，我们可以用下标来对可空值进行读取或写入，并且判断下标调用是否成功。
@@ -177,44 +223,57 @@ Residence中得printNumberOfRooms()方法输出当前的numberOfRooms值：
 注意：
 当通过可空链式调用访问可空值的下标的时候，应该将问号放在下标方括号的前面而不是后面。可空链式调用的问号一般直接跟在可空表达式的后面。
 
-下面这个例子用下标访问john.residence中rooms数组中第一个房间的名称，因为john.residence为nil，所以下标调用毫无疑问失败了：
+下面这个例子用下标访问`john.residence`中`rooms`数组中第一个房间的名称，因为`john.residence`为`nil`，所以下标调用毫无疑问失败了：
 
-	if let firstRoomName = john.residence?[0].name {
-	    print("The first room name is \(firstRoomName).")
-	} else {
-	    print("Unable to retrieve the first room name.")
-	}
-	// prints "Unable to retrieve the first room name."
-在这个例子中，问号直接放在john.residence的后面，并且在方括号的前面，因为john.residence是可空值。
+```swift
+if let firstRoomName = john.residence?[0].name {
+    print("The first room name is \(firstRoomName).")
+} else {
+    print("Unable to retrieve the first room name.")
+}
+// prints "Unable to retrieve the first room name."
+```
+
+
+在这个例子中，问号直接放在`john.residence`的后面，并且在方括号的前面，因为`john.residence`是可空值。
 
 类似的，可以通过下标，用可空链式调用来赋值：
 
+```swift
 john.residence?[0] = Room(name: "Bathroom")
+```
+
 
 这次赋值同样会失败，因为`residence`目前是`nil`。
 
-如果你创建一个Residence实例，添加一些Room实例并赋值给john.residence，那就可以通过可选链和下标来访问数组中的元素：
+如果你创建一个`Residence`实例，添加一些`Room`实例并赋值给`john.residence`，那就可以通过可选链和下标来访问数组中的元素：
 
-	let johnsHouse = Residence()
-	johnsHouse.rooms.append(Room(name: "Living Room"))
-	johnsHouse.rooms.append(Room(name: "Kitchen"))
-	john.residence = johnsHouse
-	if let firstRoomName = john.residence?[0].name {
+```swift
+let johnsHouse = Residence()
+johnsHouse.rooms.append(Room(name: "Living Room"))
+johnsHouse.rooms.append(Room(name: "Kitchen"))
+john.residence = johnsHouse
+
+if let firstRoomName = john.residence?[0].name {
 	print("The first room name is \(firstRoomName).")
-	} else {
+} else {
 	print("Unable to retrieve the first room name.")
-	}
-	// prints "The first room name is Living Room."
+}
+// prints "The first room name is Living Room."
+```
 
 ##访问可空类型的下标：
-如果下标返回可空类型值，比如Swift中Dictionary的key下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值：
+如果下标返回可空类型值，比如Swift中`Dictionary`的`key`下标。可以在下标的闭合括号后面放一个问号来链接下标的可空返回值：
 
-	var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
-	testScores["Dave"]?[0] = 91
-	testScores["Bev"]?[0]++
-	testScores["Brian"]?[0] = 72
-	// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]
-上面的例子中定义了一个testScores数组，包含了两个键值对， 把String类型的key映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个key存在。但是key“Brian”在字典中不存在，所以第三个调用失败。
+```swift
+var testScores = ["Dave": [86, 82, 84], "Bev": [79, 94, 81]]
+testScores["Dave"]?[0] = 91
+testScores["Bev"]?[0]++
+testScores["Brian"]?[0] = 72
+// the "Dave" array is now [91, 82, 84] and the "Bev" array is now [80, 94, 81]
+```
+
+上面的例子中定义了一个`testScores`数组，包含了两个键值对， 把`String`类型的`key`映射到一个整形数组。这个例子用可空链式调用把“Dave”数组中第一个元素设为91，把”Bev”数组的第一个元素+1，然后尝试把”Brian”数组中的第一个元素设为72。前两个调用是成功的，因为这两个`key`存在。但是key“Brian”在字典中不存在，所以第三个调用失败。
 
 ##多层链接
 可以通过多个链接多个可空链式调用来向下访问属性，方法以及下标。但是多层可空链式调用不会添加返回值的可空性。
@@ -226,58 +285,68 @@ john.residence?[0] = Room(name: "Bathroom")
 
 因此：
 
-+ 通过可空链式调用访问一个Int值，将会返回Int？，不过进行了多少次可空链式调用。
-+ 类似的，通过可空链式调用访问Int?值，并不会变得更加可空。
++ 通过可空链式调用访问一个`Int`值，将会返回`Int?`，不过进行了多少次可空链式调用。
++ 类似的，通过可空链式调用访问`Int?`值，并不会变得更加可空。
 
-下面的例子访问john中的residence中的address中的street属性。这里使用了两层可空链式调用，residence以及address，这两个都是可空值。
+下面的例子访问`john`中的`residence`中的`address`中的`street`属性。这里使用了两层可空链式调用，`residence`以及`address`，这两个都是可空值。
 
-	if let johnsStreet = john.residence?.address?.street {
-	    print("John's street name is \(johnsStreet).")
-	} else {
-	    print("Unable to retrieve the address.")
-	}
-	// prints "Unable to retrieve the address."
+```swift
+if let johnsStreet = john.residence?.address?.street {
+    print("John's street name is \(johnsStreet).")
+} else {
+    print("Unable to retrieve the address.")
+}
+// prints "Unable to retrieve the address."
+```
 
-john.residence包含Residence实例，但是john.residence.address为nil。因此，不能访问john.residence?.address?.street。
+`john.residence`包含`Residence`实例，但是`john.residence.address`为`nil`。因此，不能访问`john.residence?.address?.street`。
 
-需要注意的是，上面的例子中，street的属性为String?。john.residence?.address?.street的返回值也依然是String?，即使已经进行了两次可空的链式调用。
+需要注意的是，上面的例子中，`street`的属性为`String?`。`john.residence?.address?.street`的返回值也依然是`String?`，即使已经进行了两次可空的链式调用。
 
-如果把john.residence.address指向一个实例，并且为address中的street属性赋值，我们就能过通过可空链式调用来访问street属性。
+如果把`john.residence.address`指向一个实例，并且为`address`中的`street`属性赋值，我们就能过通过可空链式调用来访问`street`属性。
 
-	let johnsAddress = Address()
-	johnsAddress.buildingName = "The Larches"
-	johnsAddress.street = "Laurel Street"
-	john.residence?.address = johnsAddress
- 	
-	if let johnsStreet = john.residence?.address?.street {
-	    print("John's street name is \(johnsStreet).")
-	} else {
-	    print("Unable to retrieve the address.")
-	}
-	// prints "John's street name is Laurel Street."
-在上面的例子中，因为john.residence是一个可用的Residence实例，所以对john.residence的address属性赋值成功。
+```swift
+let johnsAddress = Address()
+johnsAddress.buildingName = "The Larches"
+johnsAddress.street = "Laurel Street"
+john.residence?.address = johnsAddress
+	
+if let johnsStreet = john.residence?.address?.street {
+    print("John's street name is \(johnsStreet).")
+} else {
+    print("Unable to retrieve the address.")
+}
+// prints "John's street name is Laurel Street."
+```
+
+在上面的例子中，因为`john.residence`是一个可用的`Residence`实例，所以对`john.residence`的`address`属性赋值成功。
 
 ##对返回可空值的函数进行链接
 上面的例子说明了如何通过可空链式调用来获取可空属性值。我们还可以通过可空链式调用来调用返回可空值的方法，并且可以继续对可空值进行链接。
 
-在下面的例子中，通过可空链式调用来调用Address的buildingIdentifier()方法。这个方法返回String?类型。正如上面所说，通过可空链式调用的方法的最终返回值还是String?：
+在下面的例子中，通过可空链式调用来调用`Address`的`buildingIdentifier()`方法。这个方法返回`String?`类型。正如上面所说，通过可空链式调用的方法的最终返回值还是`String?`：
  
-	if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
-	    print("John's building identifier is \(buildingIdentifier).")
-	}
-	// prints "John's building identifier is The Larches."
+```swift
+if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
+    print("John's building identifier is \(buildingIdentifier).")
+}
+// prints "John's building identifier is The Larches."
+```
 
-如果要进一步对方法的返回值进行可空链式调用，在方法buildingIdentifier()的圆括号后面加上问号：
+如果要进一步对方法的返回值进行可空链式调用，在方法`buildingIdentifier()`的圆括号后面加上问号：
 
-	if let beginsWithThe =
+```swift
+if let beginsWithThe =
 	john.residence?.address?.buildingIdentifier()?.hasPrefix("The") {
-	if beginsWithThe {
-	print("John's building identifier begins with \"The\".")
-	} else {
-	print("John's building identifier does not begin with \"The\".")
-	}
-	}
-	// prints "John's building identifier begins with "The"."
+		if beginsWithThe {
+			print("John's building identifier begins with \"The\".")
+		} else {
+			print("John's building identifier does not begin with \"The\".")
+		}
+}
+// prints "John's building identifier begins with "The"."
+```
+
 >	
 注意：
-在上面的例子中在，在方法的圆括号后面加上问号是因为buildingIdentifier()的返回值是可空值，而不是方法本身是可空的。
+在上面的例子中在，在方法的圆括号后面加上问号是因为`buildingIdentifier()`的返回值是可空值，而不是方法本身是可空的。
diff --git a/source/chapter2/18_Error_Handling.md b/source/chapter2/18_Error_Handling.md
index e4564442..6fc497f3 100644
--- a/source/chapter2/18_Error_Handling.md
+++ b/source/chapter2/18_Error_Handling.md
@@ -1,3 +1,6 @@
+> 2.0
+> 翻译+校对：[lyojo](https://github.com/lyojo)
+
 # 错误处理
 -----------------
 错误处理是响应错误以及从错误中返回的过程。swift提供第一类错误支持，包括在运行时抛出，捕获，传送和控制可回收错误。
@@ -7,136 +10,167 @@
 举个例子，考虑到一个从磁盘上的一个文件读取以及处理数据的任务，有几种情况可能会导致这个任务失败，包括指定路径的文件不存在，文件不具有可读属性，或者文件没有被编码成合适的格式。区分这些错误可以让程序解决并且修复这些错误，并且，如果可能的话，把这些错误报告给用户。
 
 >
-NOTE：
-Swift中的错误处理涉及到错误处理样式，这会用到Cocoa中的NSError和Objective-C。更多信息请参见：[Error Handling](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)中的[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
+注意：
+Swift中的错误处理涉及到错误处理样式，这会用到Cocoa中的NSError和Objective-C。更多信息请参见：[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)中的[错误处理](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/AdoptingCocoaDesignPatterns.html#//apple_ref/doc/uid/TP40014216-CH7-ID10)。
 
 ###错误的表示：
-在Swift中，错误用符合ErrorType协议的值表示。
-Swift枚举特别适合把一系列相关的错误组合在一起，同时可以把一些相关的值和错误关联在一起。因此编译器会为实现ErrorType协议的Swift枚举类型自动实现相应合成。
+在Swift中，错误用符合`ErrorType`协议的值表示。
+Swift枚举特别适合把一系列相关的错误组合在一起，同时可以把一些相关的值和错误关联在一起。因此编译器会为实现`ErrorType`协议的Swift枚举类型自动实现相应合成。
 
 比如说，你可以这样表示操作自动贩卖机会出现的错误：
 
-	enum VendingMachineError: ErrorType {
+```swift
+enum VendingMachineError: ErrorType {
 	case InvalidSelection
 	case InsufficientFunds(required: Double)
 	case OutOfStock
-	}
+}
+```
+
 在这种情况下，自动贩卖机可能会因为以下原因失败：
-请求的物品不存在，用InvalidSelection表示。
-请求的物品的价格高于已投入金额，用InsufficientFunds表示。相关的双精度值表示还需要多少钱来完成此次交易。
-请求的物品已经卖完了，用OutOfStock表示。
+请求的物品不存在，用`InvalidSelection`表示。
+请求的物品的价格高于已投入金额，用`InsufficientFunds`表示。相关的双精度值表示还需要多少钱来完成此次交易。
+请求的物品已经卖完了，用`OutOfStock`表示。
 
+<a name="throwing_errors"></a>
 错误抛出
-通过在函数或方法声明的参数后面加上throws关键字，表明这个函数或方法可以抛出错误。如果指定一个返回值，可以把throws关键字放在返回箭头(->)的前面。除非明确地指出，一个函数，方法或者就闭包不能抛出错误。
+通过在函数或方法声明的参数后面加上`throws`关键字，表明这个函数或方法可以抛出错误。如果指定一个返回值，可以把`throws`关键字放在返回箭头(->)的前面。除非明确地指出，一个函数，方法或者就闭包不能抛出错误。
 
-	func canThrowErrors() throws -> String
-	func cannotThrowErrors() -> String
+```swift
+func canThrowErrors() throws -> String
 
-在抛出函数体的任意一个地方，可以通过throw语句抛出错误。在下面的例子中，如果请求的物品不存在，或者卖完了，或者超出投入金额，vend(itemNamed:)函数会抛出一个错误：
+func cannotThrowErrors() -> String
+```
 
-	struct Item {
+在抛出函数体的任意一个地方，可以通过`throw`语句抛出错误。在下面的例子中，如果请求的物品不存在，或者卖完了，或者超出投入金额，`vend(itemNamed:)`函数会抛出一个错误：
+
+```swift
+struct Item {
 	var price: Double
 	var count: Int
-	}
-	var inventory = [
+}
+
+var inventory = [
 	"Candy Bar": Item(price: 1.25, count: 7),
 	"Chips": Item(price: 1.00, count: 4),
 	"Pretzels": Item(price: 0.75, count: 11)
-	]
-	var amountDeposited = 1.00
-	func vend(itemNamed name: String) throws {
+]
+var amountDeposited = 1.00
+
+func vend(itemNamed name: String) throws {
 	guard var item = inventory[name] else {
-	throw VendingMachineError.InvalidSelection
-	    }
+		throw VendingMachineError.InvalidSelection
+    }
+
 	guard item.count > 0 else {
-	throw VendingMachineError.OutOfStock
-	    }
+		throw VendingMachineError.OutOfStock
+    }
+
 	if amountDeposited >= item.price {
-	// Dispense the snack
-	amountDeposited -= item.price
-	        --item.count
-	inventory[name] = item
-	    } else {
-	let amountRequired = item.price - amountDeposited
-	throw VendingMachineError.InsufficientFunds(required: 	amountRequired)
-	    }
+		// Dispense the snack
+		amountDeposited -= item.price
+	    --item.count
+		inventory[name] = item
+	} else {
+		let amountRequired = item.price - amountDeposited
+		throw VendingMachineError.InsufficientFunds(required: 	amountRequired)
 	}
-首先，guard语句用来把绑定item常量和count变量到在库存中对应的值。如果物品不在库存中，将会抛出InvalidSelection错误。然后，物品是否可获取有物品的剩余数量决定。如果count小于等于0，将会抛出OutOfStock错误。最后，把请求物品的价格和已经投入的金额进行比较，如果如果投入的金额大于物品的价格，将会从投入的金额从减去物品的价格，然后库存中该物品的数量减1，然后返回请求的物品。否则，将会计算还需要多少钱，然后把这个值作为InsufficientFunds错误的关联值。因为throw语句会马上改变程序流程，当所有的购买条件（物品存在，库存足够以及投入金额足够）都满足的时候，物品才会出售。
+}
+```
 
-当调用一个抛出函数的时候，在调用前面加上try。这个关键字表明函数可以抛出错误，而且在try后面代码将不会执行。
+首先，`guard`语句用来把绑定`item`常量和`count`变量到在库存中对应的值。如果物品不在库存中，将会抛出`InvalidSelection`错误。然后，物品是否可获取有物品的剩余数量决定。如果`count`小于等于0，将会抛出`OutOfStock`错误。最后，把请求物品的价格和已经投入的金额进行比较，如果如果投入的金额大于物品的价格，将会从投入的金额从减去物品的价格，然后库存中该物品的数量减1，然后返回请求的物品。否则，将会计算还需要多少钱，然后把这个值作为`InsufficientFunds`错误的关联值。因为`throw`语句会马上改变程序流程，当所有的购买条件（物品存在，库存足够以及投入金额足够）都满足的时候，物品才会出售。
 
-	let favoriteSnacks = [
+当调用一个抛出函数的时候，在调用前面加上`try`。这个关键字表明函数可以抛出错误，而且在`try`后面代码将不会执行。
+
+```swift
+let favoriteSnacks = [
 	"Alice": "Chips",
 	"Bob": "Licorice",
 	"Eve": "Pretzels",
-	]
-	func buyFavoriteSnack(person: String) throws {
+]
+func buyFavoriteSnack(person: String) throws {
 	let snackName = favoriteSnacks[person] ?? "Candy Bar"
 	try vend(itemNamed: snackName)
-	}
-buyFavoriteSnack(_:) 函数查找某个人的最喜欢的零食，然后尝试买给他。如果这个人在列表中没有喜欢的零食，就会购买Candy Bar。这个函数会调用vend函数，vend函数可能会抛出错误，所以在vend前面加上了try关键字。因为buyFavoriteSnack函数也是一个抛出函数，所以vend函数抛出的任何错误都会向上传递到buyFavoriteSnack被调用的地方。
+}
+```
+
+`buyFavoriteSnack(_:)` 函数查找某个人的最喜欢的零食，然后尝试买给他。如果这个人在列表中没有喜欢的零食，就会购买`Candy Bar`。这个函数会调用`vend`函数，`vend`函数可能会抛出错误，所以在`vend`前面加上了`try`关键字。因为`buyFavoriteSnack`函数也是一个抛出函数，所以`vend`函数抛出的任何错误都会向上传递到`buyFavoriteSnack`被调用的地方。
 
 ###捕捉和处理错误
 使用do-catch语句来就捕获和处理错误
 
-	do {
-	
-	    try function that throws
-	
-	    statements
-		
-	} catch pattern {
-	
-	    statements
+```swift
+do {
 
-	}
-如果一个错误被抛出了，这个错误会被传递到外部域，直到被一个catch分句处理。一个catch分句包含一个catch关键字，跟着一个pattern来匹配错误和相应的执行语句。
+    try function that throws
 
-类似switch语句，编译器会检查catch分句是否能够处理全部错误。如果能够处理所有错误情况，就认为这个错误被完全处理。否者，包含这个抛出函数的所在域就要处理这个错误，或者包含这个抛出函数的函数也用throws声明。为了保证错误被处理，用一个带pattern的catch分句来匹配所有错误。如果一个catch分句没有指定样式，这个分句会匹配并且绑定任何错误到一个本地error常量。更多关于pattern的信息，参见[Patterns](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/doc/uid/TP40014097-CH36-ID419)。
+    statements
+	
+} catch pattern {
 
-	do {	
+    statements
+
+}
+```
+
+如果一个错误被抛出了，这个错误会被传递到外部域，直到被一个`catch`分句处理。一个`catch`分句包含一个`catch`关键字，跟着一个`pattern`来匹配错误和相应的执行语句。
+
+类似`switch`语句，编译器会检查`catch`分句是否能够处理全部错误。如果能够处理所有错误情况，就认为这个错误被完全处理。否者，包含这个抛出函数的所在域就要处理这个错误，或者包含这个抛出函数的函数也用`throws`声明。为了保证错误被处理，用一个带`pattern`的`catch`分句来匹配所有错误。如果一个`catch`分句没有指定样式，这个分句会匹配并且绑定任何错误到一个本地`error`常量。更多关于`pattern`的信息，参见[模式](../chapter3/07_Patterns.html)。
+
+```swift
+do {	
 	try vend(itemNamed: "Candy Bar")	
 	// Enjoy delicious snack	
-	} catch VendingMachineError.InvalidSelectio {
+} catch VendingMachineError.InvalidSelectio {
 	print("Invalid Selection")
-	} catch VendingMachineError.OutOfStock {
+} catch VendingMachineError.OutOfStock {
 	print("Out of Stock.")
-	} catch VendingMachineError.InsufficientFunds(let 	amountRequired) {
+} catch VendingMachineError.InsufficientFunds(let 	amountRequired) {
 	print("Insufficient funds. Please insert an additional $\(amountRequired).")
-	}
+}
+```
 
-在上面的例子中，vend(itemNamed:) 函数在try表达式中被调用，因为这个函数会抛出错误。如果抛出了错误，程序执行流程马上转到catch分句，在catch分句中确定错误传递是否继续传送。如果没有抛出错误，将会执行在do语句中剩余的语句。
+在上面的例子中，`vend(itemNamed:)` 函数在`try`表达式中被调用，因为这个函数会抛出错误。如果抛出了错误，程序执行流程马上转到`catch`分句，在`catch`分句中确定错误传递是否继续传送。如果没有抛出错误，将会执行在`do`语句中剩余的语句。
 
-###禁止错误传送
-在运行时，有几种情况抛出函数事实上是不会抛出错误的。在这几种情况下，你可以用forced-try表达式来调用抛出函数或方法，即使用try!来代替try。
+> 注意：Swift中的错误处理和其他语言中的异常处理很像，使用了`try`、`catch`和`throw`关键字。但是和这些语言——包括Objective-C——不同的是，Swift不会展开调用堆栈，那会带来很大的性能损耗。因此，在Swift中`throw`语句的性能可以做到几乎和`return`语句一样。
 
-通过try!来调用抛出函数或方法禁止了错误传送，并且把调用包装在运行时断言，这样就不会抛出错误。如果错误真的抛出了，会触发运行时错误。
+###禁止错误传播
+在运行时，有几种情况抛出函数事实上是不会抛出错误的。在这几种情况下，你可以用`forced-try`表达式来调用抛出函数或方法，即使用`try!`来代替`try`。
 
-	func willOnlyThrowIfTrue(value: Bool) throws {
+通过`try!`来调用抛出函数或方法禁止了错误传送，并且把调用包装在运行时断言，这样就不会抛出错误。如果错误真的抛出了，会触发运行时错误。
+
+```swift
+func willOnlyThrowIfTrue(value: Bool) throws {
 	if value { throw someError }
-	}
-	do {
+}
+
+do {
 	try willOnlyThrowIfTrue(false)
-	} catch {
+} catch {
 	// Handle Error
-	}
-	try! willOnlyThrowIfTrue(false)
+}
+
+try! willOnlyThrowIfTrue(false)
+```
 
 ###收尾操作
 使用defer语句来在执行一系列的语句。这样不管有没有错误发生，都可以执行一些必要的收尾操作。包括关闭打开的文件描述符以及释放所有手动分配的内存。
 
-defer语句把执行推迟到退出当前域的时候。defer语句包括defer关键字以及后面要执行的语句。被推迟的语句可能不包含任何将执行流程转移到外部的代码，比如break或者return语句，或者通过抛出一个错误。被推迟的操作的执行的顺序和他们定义的顺序相反，也就是说，在第一个defer语句中的代码在第二个defer语句中的代码之后执行。
+`defer`语句把执行推迟到退出当前域的时候。`defer`语句包括`defer`关键字以及后面要执行的语句。被推迟的语句可能不包含任何将执行流程转移到外部的代码，比如`break`或者`return`语句，或者通过抛出一个错误。被推迟的操作的执行的顺序和他们定义的顺序相反，也就是说，在第一个`defer`语句中的代码在第二个`defer`语句中的代码之后执行。
 
-	func processFile(filename: String) throws {
+```swift
+func processFile(filename: String) throws {
 	if exists(filename) {
-	let file = open(filename)
-	defer {
-	close(file)
-	        }
-	while let line = try file.readline() {
-	/* Work with the file. */
-	        }
-	// close(file) is called here, at the end of the scope.
+		let file = open(filename)
+		defer {
+			close(file)
 	    }
-	}
-上面这个例子使用了defer语句来保证open有对应的close。这个调用不管是否有抛出都会执行。
\ No newline at end of file
+		while let line = try file.readline() {
+			// Work with the file.
+	    }
+		// close(file) is called here, at the end of the scope.
+    }
+}
+```
+
+上面这个例子使用了`defer`语句来保证`open`有对应的`close`。这个调用不管是否有抛出都会执行。
\ No newline at end of file
diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/19_Nested_Types.md
index 4c1a1bbb..fe0bf822 100755
--- a/source/chapter2/19_Nested_Types.md
+++ b/source/chapter2/19_Nested_Types.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[Lin-H](https://github.com/Lin-H)  
 > 校对：[shinyzhu](https://github.com/shinyzhu)
 
+> 2.0
+> 翻译+校对：[SergioChan](https://github.com/SergioChan)
+
 # 嵌套类型
 -----------------
 
@@ -72,7 +76,7 @@ struct BlackjackCard {
 
 `BlackjackCard`结构体自身有两个属性—`rank`与`suit`，也同样定义了一个计算属性`description`，`description`属性用`rank`和`suit`的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型`second`来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。
 
-因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[Memberwise Initializers for Structure Types](https://github.com/CocoaChina-editors/Welcome-to-Swift/blob/master/The%20Swift%20Programming%20Language/02Language%20Guide/14Initialization.md)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`:
+因为`BlackjackCard`是一个没有自定义构造函数的结构体，在[结构体的逐一成员构造器](./14_Initialization.html#memberwise_initializers_for_structure_types)中知道结构体有默认的成员构造函数，所以你可以用默认的`initializer`去初始化新的常量`theAceOfSpades`:
 
 ```swift
 let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades)
diff --git a/source/chapter2/20_Type_Casting.md b/source/chapter2/20_Type_Casting.md
index 83929634..8ecbbfb7 100644
--- a/source/chapter2/20_Type_Casting.md
+++ b/source/chapter2/20_Type_Casting.md
@@ -1,5 +1,9 @@
+> 1.0
 > 翻译：[xiehurricane](https://github.com/xiehurricane)
-> 校对：[happyming](https://github.com/happyming) [yangsiy](https://github.com/yangsiy)
+> 校对：[happyming](https://github.com/happyming)
+
+> 2.0
+> 翻译+校对：[yangsiy](https://github.com/yangsiy)
 
 # 类型转换（Type Casting）
 -----------------
@@ -16,7 +20,7 @@ _类型转换_可以判断实例的类型，也可以将实例看做是其父类
 
 类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
 
-你也可以用它来检查一个类是否实现了某个协议，就像在 [Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。
+你也可以用它来检查一个类是否实现了某个协议，就像在 [检验协议的一致性](./22_Protocols.html#checking_for_protocol_conformance)部分讲述的一样。
 
 <a name="defining_a_class_hierarchy_for_type_casting"></a>
 ## 定义一个类层次作为例子
@@ -155,6 +159,7 @@ Swift为不确定类型提供了两种特殊类型别名：
 > 注意：  
 > 只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
 
+<a name="anyobject"></a>
 ### `AnyObject`类型
 
 当在工作中使用 Cocoa APIs，我们一般会接收一个`[AnyObject]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以从 API 提供的信息中清晰地确定数组中对象的类型。
diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index a0f8da7b..7ff6ed0d 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[lyuka](https://github.com/lyuka)  
 > 校对：[Hawstein](https://github.com/Hawstein)
 
+> 2.0
+> 翻译+校对：[shanksyang](https://github.com/shanksyang)
+
 #扩展（Extensions）
 ----
 
@@ -25,7 +29,7 @@ Swift 中的扩展可以：
 - 使一个已有类型符合某个协议
 
 TODO：
-在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](#)获取更多的细节。
+在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./Protocols.html#protocol_extensions)获取更多的细节。
 
 >注意：  
 扩展可以对一个类型添加新的功能，但是不能重写已有的功能。
@@ -48,7 +52,7 @@ extension SomeType: SomeProtocol, AnotherProctocol {
 }
 ```
 
-按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](21_Protocols.html#adding_protocol_conformance_with_an_extension)
+按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](./21_Protocols.html#adding_protocol_conformance_with_an_extension)
 
 >注意：  
 如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
@@ -101,7 +105,7 @@ print("A marathon is \(aMarathon) meters long")
 > 注意：  
 如果你使用扩展向一个值类型添加一个构造器，在该值类型已经向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers）时，你可以在值类型的扩展构造器中调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。
 >
-正如在[值类型的构造器代理](14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
+正如在[值类型的构造器代理](./14_Initialization.html#initializer_delegation_for_value_types)中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
 
 下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值：
 
@@ -117,7 +121,7 @@ struct Rect {
     var size = Size()
 }
 ```
-因为结构体`Rect`提供了其所有属性的默认值，所以正如[默认构造器](14_Initialization.html#default_initializers)中描述的，它可以自动接受一个默认构造器和一个逐一成员构造器。这些构造器可以用于构造新的`Rect`实例：
+因为结构体`Rect`提供了其所有属性的默认值，所以正如[默认构造器](./14_Initialization.html#default_initializers)中描述的，它可以自动接受一个默认构造器和一个逐一成员构造器。这些构造器可以用于构造新的`Rect`实例：
 
 ```swift
 let defaultRect = Rect()
diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 96912982..f4c54666 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[geek5nan](https://github.com/geek5nan)
 > 校对：[dabing1022](https://github.com/dabing1022)
 
+> 2.0
+> 翻译+校对：[futantan](https://github.com/futantan)
+
 # 协议
 -----------------
 
@@ -170,7 +174,7 @@ print("And another one: \(generator.random())")
 <a name="mutating_method_requirements"></a>
 ## 对Mutating方法的规定
 
-有时需要在方法中改变它的实例。例如，值类型(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改它所属的实例及其实例属性的值。这一过程在[Modifyting Value Types from Within Instance Methods](TODO)章节中有详细描述。
+有时需要在方法中改变它的实例。例如，值类型(结构体，枚举)的实例方法中，将`mutating`关键字作为函数的前缀，写在`func`之前，表示可以在该方法中修改它所属的实例及其实例属性的值。这一过程在[在实例方法中修改值类型](./11_Methods.html#modifying_value_types_from_within_instance_methods)章节中有详细描述。
 
 如果你在协议中定义了一个方法旨在改变遵循该协议的实例，那么在协议定义时需要在方法前加`mutating`关键字。这使得结构和枚举遵循协议并满足此方法要求。
 
@@ -234,12 +238,10 @@ class SomeClass: SomeProtocol {
 
 使用`required`修饰符可以保证：所有的遵循该协议的子类，同样能为构造器规定提供一个显式的实现或继承实现。
 
-<!--TODO 参考链接-->
-关于`required`构造器的更多内容，请参考<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_454">`Required`构造器 </a>
+关于`required`构造器的更多内容，请参考[必要构造器](./14_Initialization.html#required_initializers)。
 
-<!--TODO 参考链接-->
 >注意  
->如果类已经被标记为`final`，那么不需要在协议构造器的实现中使用`required`修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_339">防止重写</a>
+>如果类已经被标记为`final`，那么不需要在协议构造器的实现中使用`required`修饰符。因为final类不能有子类。关于`final`修饰符的更多内容，请参见[防止重写](./13_Inheritance.html#preventing_overrides)。
 
 如果一个子类重写了父类的指定构造器，并且该构造器遵循了某个协议的规定，那么该构造器的实现需要被同时标示`required`和`override`修饰符
 
@@ -266,7 +268,7 @@ class SomeSubClass: SomeSuperClass, SomeProtocol {
 
 ### 可失败构造器的规定
 
-可以通过给协议`Protocols`中添加可失败构造器来使遵循该协议的类型必须实现该可失败构造器。
+可以通过给协议`Protocols`中添加[可失败构造器](./14_Initialization.html#failable_initializers)来使遵循该协议的类型必须实现该可失败构造器。
 
 如果在协议中定义一个可失败构造器，则在遵顼该协议的类型中必须添加同名同参数的可失败构造器或非可失败构造器。如果在协议中定义一个非可失败构造器，则在遵循该协议的类型中必须添加同名同参数的非可失败构造器或隐式解析类型的可失败构造器（`init!`）。
 
@@ -346,7 +348,7 @@ protocol DiceGameDelegate {
 
 `DiceGame`协议可以在任意含有骰子的游戏中实现。`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
 
-如下所示，`SnakesAndLadders`是`Snakes and Ladders`(译者注:[Control Flow](2)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程:
+如下所示，`SnakesAndLadders`是`Snakes and Ladders`([Control Flow](./05_Control_Flow.html)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议，后者用来记录游戏的过程:
 
 ```swift
 class SnakesAndLadders: DiceGame {
@@ -438,7 +440,7 @@ game.play()
 <a name="adding_protocol_conformance_with_an_extension"></a>
 ## 在扩展中添加协议成员
 
-即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(*译者注: 类，结构体，枚举等*)。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。详情请在[扩展](4)章节中查看。
+即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(*译者注: 类，结构体，枚举等*)。扩展可以为已存在的类型添加属性，方法，下标脚本，协议等成员。详情请在[扩展](./21_Extensions.html)章节中查看。
 
 > 注意  
 > 通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法
@@ -602,7 +604,7 @@ protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
 <!--TODO 链接-->
 
 >注意  
->当协议想要定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。关于引用语义，值语义的更多内容，请查看<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_145">结构体和枚举是值类型</a>和<a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_146">类是引用类型</a>
+>当协议想要定义的行为，要求（或假设）它的遵循类型必须是引用语义而非值语义时，应该采用类专属协议。关于引用语义，值语义的更多内容，请查看[结构体和枚举是值类型](./09_Classes_and_Structures.html#structures_and_enumerations_are_value_types)和[类是引用类型](./09_Classes_and_Structures.html#classes_are_reference_types)。
 
 
 <a name="protocol_composition"></a>
@@ -644,7 +646,7 @@ wishHappyBirthday(birthdayPerson)
 ## 检验协议的一致性
 
 <!--TODO 链接-->
-你可以使用`is`和`as`操作符来检查是否遵循某一协议或强制转化为某一类型。检查和转化的语法和之前相同(*详情查看[Typy Casting章节](5)*):
+你可以使用`is`和`as`操作符来检查是否遵循某一协议或强制转化为某一类型。检查和转化的语法和之前相同(*详情查看[类型转换](./20_Type_Casting.html)*):
 
 * `is`操作符用来检查实例是否`遵循`了某个`协议`
 * `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型;否则返回`nil`
@@ -721,7 +723,7 @@ for object in objects {
 协议可以含有可选成员，其`遵循者`可以选择是否实现这些成员。在协议中使用`optional`关键字作为前缀来定义可选成员。
 
 <!--TODO 链接-->
-可选协议在调用时使用`可选链`，因为协议的遵循者可能没有实现可选内容，详细内容在[Optional Chaning](7)章节中查看。
+可选协议在调用时使用`可选链`，因为协议的遵循者可能没有实现可选内容，详细内容在[可空链式调用](./17_Optional_Chaining.html)章节中查看。
 
 像`someOptionalMethod?(someArgument)`这样，你可以在可选方法名称后加上`?`来检查该方法是否被实现。可选方法和可选属性都会返回一个`可选值(optional value)`，当其不可访问时，`?`之后语句不会执行，并整体返回`nil`
 
@@ -876,7 +878,7 @@ extension PrettyTextRepresentable  {
 
 ### 为协议扩展添加限制条件
 
-在扩展协议的时候，可以指定一些限制，只有满足这些限制的协议遵循者，才能获得协议扩展提供的属性和方法。这些限制写在协议名之后，使用`where`关键字来描述限制情况。([Where 子句](TODO))。:
+在扩展协议的时候，可以指定一些限制，只有满足这些限制的协议遵循者，才能获得协议扩展提供的属性和方法。这些限制写在协议名之后，使用`where`关键字来描述限制情况。([Where语句](./23_Generics.html#where_clauses))。:
 
 例如，你可以扩展`CollectionType`协议，但是只适用于元素遵循`TextRepresentable`的情况:
 
diff --git a/source/chapter2/23_Generics.md b/source/chapter2/23_Generics.md
index 2fa90bc5..5efaf96a 100644
--- a/source/chapter2/23_Generics.md
+++ b/source/chapter2/23_Generics.md
@@ -1,7 +1,10 @@
-
-> 翻译：[takalard](https://github.com/takalard) [SergioChan](https://github.com/SergioChan)
+> 1.0
+> 翻译：[takalard](https://github.com/takalard)
 > 校对：[lifedim](https://github.com/lifedim)
 
+> 2.0
+> 翻译+校对： [SergioChan](https://github.com/SergioChan)
+
 # 泛型
 
 ------
@@ -35,7 +38,7 @@ func swapTwoInts(inout a: Int, inout _ b: Int) {
 }
 ```
 
-这个函数使用写入读出（in-out）参数来交换`a`和`b`的值，请参考[写入读出参数](../chapter2/06_Functions.html)。
+这个函数使用写入读出（in-out）参数来交换`a`和`b`的值，请参考[输入输出参数](./06_Functions.html#in_out_parameters)。
 
 `swapTwoInts(_:_:)`函数可以交换`b`的原始值到`a`，也可以交换a的原始值到`b`，你可以调用这个函数交换两个`Int`变量值：
 
@@ -260,7 +263,7 @@ if let topItem = stackOfStrings.topItem {
 
 `swapTwoValues(_:_:)`函数和`Stack`类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
 
-例如，Swift 的`Dictionary`类型对作用于其键的类型做了些限制。在[字典](../chapter2/04_Collection_Types.html)的描述中，字典的键类型必须是*可哈希*，也就是说，必须有一种方法可以使其被唯一的表示。`Dictionary`之所以需要其键是可哈希是为了以便于其检查其是否已经包含某个特定键的值。如无此需求，`Dictionary`既不会告诉是否插入或者替换了某个特定键的值，也不能查找到已经存储在字典里面的给定键值。
+例如，Swift 的`Dictionary`类型对作用于其键的类型做了些限制。在[字典](./04_Collection_Types.html#dictionaries)的描述中，字典的键类型必须是*可哈希*，也就是说，必须有一种方法可以使其被唯一的表示。`Dictionary`之所以需要其键是可哈希是为了以便于其检查其是否已经包含某个特定键的值。如无此需求，`Dictionary`既不会告诉是否插入或者替换了某个特定键的值，也不能查找到已经存储在字典里面的给定键值。
 
 这个需求强制加上一个类型约束作用于`Dictionary`的键上，当然其键类型必须遵循`Hashable`协议（Swift 标准库中定义的一个特定协议）。所有的 Swift 基本类型（如`String`，`Int`， `Double`和 `Bool`）默认都是可哈希。
 
@@ -443,9 +446,9 @@ struct Stack<T>: Container {
 
 ### 扩展一个存在的类型为一指定关联类型
 
-在[使用扩展来添加协议兼容性](../chapter2/21_Protocols.html)中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
+在[在扩展中添加协议成员](./21_Protocols.html#adding_protocol_conformance_with_an_extension)中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
 
-Swift的`Array`已经提供`append(_:)`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[使用扩展来声明协议的采纳](../chapter2/21_Protocols.html)中有描述这样一个实现一个空扩展的行为：
+Swift的`Array`已经提供`append(_:)`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[通过扩展补充协议声明](./21_Protocols.html#declaring_protocol_adoption_with_an_extension)中有描述这样一个实现一个空扩展的行为：
 
 ```swift
 extension Array: Container {}
diff --git a/source/chapter2/24_Access_Control.md b/source/chapter2/24_Access_Control.md
index 4be28249..7c6f1967 100644
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[JaceFu](http://www.devtalking.com/)  
 > 校对：[ChildhoodAndy](http://childhood.logdown.com)
 
+> 2.0
+> 翻译+校对：[mmoaay](https://github.com/mmoaay)
+
 # 访问控制
 ------------------
 
@@ -288,13 +292,13 @@ public struct TrackedString {
 
 <a name="initializers"></a>
 ## 初始化
-我们可以给自定义的初始化方法申明访问级别，但是要不高于它所属类的访问级别。但[必要构造器](TODO)例外，它的访问级别必须和所属类的访问级别相同。
+我们可以给自定义的初始化方法申明访问级别，但是要不高于它所属类的访问级别。但[必要构造器](./14_Initialization.html#required_initializers)例外，它的访问级别必须和所属类的访问级别相同。
 
 如同函数或方法参数，初始化方法参数的访问级别也不能低于初始化方法的访问级别。
 
 <a name="default_initializers"></a>
 ### 默认初始化方法
-Swift为结构体、类都提供了一个默认的无参初始化方法，用于给它们的所有属性提供赋值操作，但不会给出具体值。默认初始化方法可以参阅[Default Initializers](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_336)。默认初始化方法的访问级别与所属类型的访问级别相同。
+Swift为结构体、类都提供了一个默认的无参初始化方法，用于给它们的所有属性提供赋值操作，但不会给出具体值。默认初始化方法可以参阅[默认构造器](./14_Initialization.html#default_initializers)。默认初始化方法的访问级别与所属类型的访问级别相同。
 
 > 注意：如果一个类型被申明为`public`级别，那么默认的初始化方法的访问级别为`internal`。如果你想让无参的初始化方法在其他模块中可以被使用，那么你必须提供一个具有`public`访问级别的无参初始化方法。
 
diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index 4d54288a..cf750464 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[xielingwang](https://github.com/xielingwang)  
 > 校对：[numbbbbb](https://github.com/numbbbbb)
 
+> 2.0
+> 翻译+校对：[buginux](https://github.com/buginux)
+
 # 高级运算符
 -----------------
 
@@ -12,7 +16,7 @@
 - [运算符函数(Operator Functions)](#operator_functions)
 - [自定义运算符](#custom_operators)
 
-除了在之前介绍过的[基本运算符](02_Basic_Operators.html)，Swift 中还有许多可以对数值进行复杂操作的高级运算符。这些高级运算符包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。
+除了在之前介绍过的[基本运算符](./02_Basic_Operators.html)，Swift 中还有许多可以对数值进行复杂操作的高级运算符。这些高级运算符包含了在 C 和 Objective-C 中已经被大家所熟知的位运算符和移位运算符。
 
 与C语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符(`&+`)。所有的这些溢出运算符都是以 `&` 开头的。
 
@@ -393,7 +397,8 @@ let afterIncrement = ++toIncrement
 > 注意：
 > 不能对默认的赋值运算符(`=`)进行重载。只有组合赋值符可以被重载。同样地，也无法对三目条件运算符 `a ? b : c` 进行重载。
 
-### 等价运算符
+<a name="equivalence_operators"></a>
+### 等价操作符
 
 自定义的类和结构体没有对等价操作符(`equivalence operators`)进行默认实现，等价操作符通常被称为“相等”操作符(`==`)与“不等”操作符(`!=`)。对于自定义类型，Swift 无法判断其是否“相等”，因为“相等”的含义取决于这些自定义类型在你的代码中所扮演的角色。
 
@@ -421,6 +426,7 @@ if twoThree == anotherTwoThree {
 // prints "These two vectors are equivalent."
 ```
 
+<a name="custom_operators"></a>
 ### 自定义运算符
 
 除了实现标准运算符，在 Swift 当中还可以声明和实现自定义运算符(`custom operators`)。可以用来自定义运算符的字符列表请参考[操作符](../chapter3/02_Lexical_Structure.html#operators)
diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md
index f2f2ef11..67512914 100755
--- a/source/chapter3/01_About_the_Language_Reference.md
+++ b/source/chapter3/01_About_the_Language_Reference.md
@@ -1,5 +1,9 @@
+> 1.0
 > 翻译：[dabing1022](https://github.com/dabing1022)  
-> 校对：[numbbbbb](https://github.com/numbbbbb), [KYawn](https://github.com/KYawn)
+> 校对：[numbbbbb](https://github.com/numbbbbb)
+
+> 2.0
+> 翻译+校对：[KYawn](https://github.com/KYawn)
 
 
 # 关于语言附注
diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 3ac59140..8e913539 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[superkam](https://github.com/superkam)  
 > 校对：[numbbbbb](https://github.com/numbbbbb)
 
+> 2.0
+> 翻译+校对：[buginux]([KYawn](https://github.com/buginux)
+
 # 词法结构
 -----------------
 
@@ -202,14 +206,14 @@ true			   // 布尔型字面量
 let x = 3; "1 2 \(x)"
 ```
 
-字符串字面量的默认推导类型为 `String`。组成字符串的字符默认推导类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368)。
+字符串字面量的默认推导类型为 `String`。组成字符串的字符默认推导类型为 `Character`。更多有关 `String` 和 `Character` 的信息请参照 [字符串和字符](../chapter2/03_Strings_and_Characters.html)。
 
 > 字符型字面量语法  
 > *字符串字面量* → **"** [*引用文本*](#quoted_text)<sub>可选</sub> **"**  
 <a id="quoted_text"></a>
 > *引用文本* → [*引用文本条目*](#quoted_text_item) [*引用文本*](#quoted_text) <sub>可选</sub>  
 > *引用文本条目* → [*转义字符*](#escaped_character)  
-> *引用文本条目* → **\(** [*表达式*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/doc/uid/TP40014097-CH32-ID383) **)**  
+> *引用文本条目* → **\(** [*表达式*](./04_Expressions.html) **)**  
 > *引用文本条目* → **除了"­, \­, U+000A, 或者 U+000D的所有Unicode的字符**  
 > *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**     
 > *转义字符* → **\u {** [*unicode标量数字*](#unicode_scalar_digits) **}** 
@@ -218,7 +222,7 @@ let x = 3; "1 2 \(x)"
 <a id="operators"></a>
 ## 运算符
 
-Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-XID_70) 和 [高级运算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_28) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。
+Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基础运算符](../chapter2/02_Basic_Operators.html) 和 [高级运算符](../chapter2/25_Advanced_Operators.html) 中进行了阐述。这一小节将描述哪些字符能用于自定义运算符。
 
 自定义运算符可以由以下其中之一的 ASCII 字符 `/`、`=`、 `-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`?` 以及 `~`, 或者后面语法中规定的任一个 Unicode 字符开始。在第一个字符之后，允许使用组合型 Unicode 字符。也可以使用两个或者多个的点号来自定义运算符（比如, `....`）。虽然可以自定义包含问号`?`的运算符，但是这个运算符不能只包含单独的一个问号。
 
@@ -238,7 +242,7 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基
 
 在某些特定的构造中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary<String, Array<Int>>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 不会被视为单独的标记，因而不会被误解析为 `>>` 运算符的一部分。
 
-要学习如何自定义运算符，请参考 [自定义操作符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48) 和 [运算符声明](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644)。要学习如何重载运算符，请参考 [运算符方法](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43)。
+要学习如何自定义运算符，请参考 [自定义操作符](../chapter2/25_Advanced_Operators.html#custom_operators) 和 [运算符声明](./05_Declarations.html#operator_declaration)。要学习如何重载运算符，请参考 [运算符方法](../chapter2/25_Advanced_Operators.html#operator_functions)。
 
 > 运算符语法语法  
 > *运算符* → [*头部运算符*](#operator_head) [*运算符字符组*](#operator_characters)<sub>可选</sub>  
diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md
index 02224959..0d7c1ef3 100644
--- a/source/chapter3/03_Types.md
+++ b/source/chapter3/03_Types.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[lyuka](https://github.com/lyuka)  
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
+> 2.0
+> 翻译+校对：[EudeMorgen](https://github.com/EudeMorgen)
+
 # 类型（Types）
 -----------------
 
@@ -27,7 +31,7 @@ Swift 语言存在两种类型：命名型类型和复合型类型。命名型
 本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。
 
 > 类型语法  
-> *类型* → [*数组类型*](#array_type) | [*字典类型*](..\chapter3\03_Types.html#dictionary_type) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type)  
+> *类型* → [*数组类型*](#array_type) | [*字典类型*](../chapter3/03_Types.html#dictionary_type) | [*函数类型*](../chapter3/03_Types.html#function_type) | [*类型标识*](../chapter3/03_Types.html#type_identifier) | [*元组类型*](../chapter3/03_Types.html#tuple_type) | [*可选类型*](../chapter3/03_Types.html#optional_type) | [*隐式解析可选类型*](../chapter3/03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type) | [*元型类型*](../chapter3/03_Types.html#metatype_type)  
 
 <a name="type_annotation"></a>
 ##类型注解
@@ -43,7 +47,7 @@ func someFunction(a: Int){ /* ... */ }
 类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。
 
 > 类型注解语法  
-> *类型注解* → **:** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *类型注解* → **:** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)  
 
 <a name="type_identifier"></a>
 ##类型标识符
@@ -66,7 +70,7 @@ var someValue: ExampleModule.MyType
 ```
 
 > 类型标识语法  
-> *类型标识* → [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
+> *类型标识* → [*类型名称*](../chapter3/03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](../chapter3/03_Types.html#type_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
 > *类名* → [*标识符*](LexicalStructure.html#identifier)  
 
 <a name="tuple_type"></a>
@@ -79,10 +83,10 @@ var someValue: ExampleModule.MyType
 `void`是空元组类型`()`的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，`(Int)`的类型是`Int`而不是`(Int)`。所以，只有当元组类型包含的元素个数在两个及以上时才可以命名元组元素。
 
 > 元组类型语法  
-> *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)**  
-> *元组类型主体* → [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_  
-> *元组类型的元素列表* → [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元组类型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list)  
-> *元组类型的元素* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](..\chapter3\03_Types.html#type) | **inout** _可选_ [*元素名*](..\chapter3\03_Types.html#element_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation)  
+> *元组类型* → **(** [*元组类型主体*](../chapter3/03_Types.html#tuple_type_body) _可选_ **)**  
+> *元组类型主体* → [*元组类型的元素列表*](../chapter3/03_Types.html#tuple_type_element_list) **...** _可选_  
+> *元组类型的元素列表* → [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) | [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) **,** [*元组类型的元素列表*](../chapter3/03_Types.html#tuple_type_element_list)  
+> *元组类型的元素* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](../chapter3/03_Types.html#type) | **inout** _可选_ [*元素名*](../chapter3/03_Types.html#element_name) [*类型注解*](../chapter3/03_Types.html#type_annotation)  
 > *元素名* → [*标识符*](LexicalStructure.html#identifier)  
 
 <a name="function_type"></a>
@@ -115,8 +119,8 @@ simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.")
 函数类型若要抛出错误就必须使用`throws`关键字来标记，若要重抛错误则必须使用`rethrows`关键字来标记。`throws`关键字是函数类型的一部分，不抛出函数（nonthrowing function）是抛出函数（throwing function）函数的一个子类型。因此，在使用抛出函数的地方也可以使用不抛出函数。对于柯里化函数，`throws`关键字只应用于最里层的函数。抛出和重抛函数（rethrowing function）的相关描述见章节抛出函数与方法和重抛函数与方法。
 
 > 函数类型语法  
-> *函数类型* → [*类型*](..\chapter3\03_Types.html#type) _抛出_ _可选_ **->** [*类型*](..\chapter3\03_Types.html#type)  
-> *函数类型* → [*类型*](..\chapter3\03_Types.html#type)_重抛_ **->** [*类型*](..\chapter3\03_Types.html#type)  
+> *函数类型* → [*类型*](../chapter3/03_Types.html#type) _抛出_ _可选_ **->** [*类型*](../chapter3/03_Types.html#type)  
+> *函数类型* → [*类型*](../chapter3/03_Types.html#type)_重抛_ **->** [*类型*](../chapter3/03_Types.html#type)  
 
 <a name="array_type"></a>
 ##数组类型
@@ -140,7 +144,7 @@ var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
 关于Swift标准库中`Array`类型的细节讨论，见章节Arrays。
 
 > 数组类型语法  
-> *数组类型* → [*类型*](..\chapter3\03_Types.html#type)
+> *数组类型* → [*类型*](../chapter3/03_Types.html#type)
 
 <a name="dictionary_type"></a>
 ##字典类型
@@ -161,7 +165,7 @@ let someDictionary: Dictionary<String, Int> = ["Alex": 31, "Paul": 39]
 关于Swift标准库中`Dictionary`类型的更多细节可查看章节Dictionaries。
 
 > 字典类型语法  
-> *字典类型* → **[**[*类型*](..\chapter3\03_Types.html#type) **:** [*类型*](..\chapter3\03_Types.html#type) **]** 
+> *字典类型* → **[**[*类型*](../chapter3/03_Types.html#type) **:** [*类型*](../chapter3/03_Types.html#type) **]** 
 
 <a name="optional_type"></a>
 ##可选类型
@@ -191,7 +195,7 @@ optionalInteger!      // 42
 更多细节以及更多如何使用可选类型的例子，见章节Optionals。
 
 > 可选类型语法  
-> *可选类型* → [*类型*](..\chapter3\03_Types.html#type) **?**  
+> *可选类型* → [*类型*](../chapter3/03_Types.html#type) **?**  
 
 <a name="implicitly_unwrapped_optional_type"></a>
 ##隐式解析可选类型
@@ -215,7 +219,7 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
 关于隐式解析可选的更多细节，见章节Implicitly Unwrapped Optionals。
 
 > 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法  
-> *隐式解析可选类型* → [*类型*](..\chapter3\03_Types.html#type) **!**  
+> *隐式解析可选类型* → [*类型*](../chapter3/03_Types.html#type) **!**  
 
 <a name="protocol_composition_type"></a>
 ##协议合成类型
@@ -233,9 +237,9 @@ protocol<Protocol 1, Procotol 2>
 协议合成列表中的每项必须是协议名或协议合成类型的类型别名。如果列表为空，它就会指定一个空协议合成列表，这样每个类型都能遵循。
 
 > 协议合成类型语法  
-> *协议合成类型* → **protocol** **<** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>**  
-> *协议标识符列表* → [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) | [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*协议标识符列表*](..\chapter3\03_Types.html#protocol_identifier_list)  
-> *协议标识符* → [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
+> *协议合成类型* → **protocol** **<** [*协议标识符列表*](../chapter3/03_Types.html#protocol_identifier_list) _可选_ **>**  
+> *协议标识符列表* → [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) | [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) **,** [*协议标识符列表*](../chapter3/03_Types.html#protocol_identifier_list)  
+> *协议标识符* → [*类型标识*](../chapter3/03_Types.html#type_identifier)  
 
 <a name="metatype_type"></a>
 ##元类型
@@ -268,7 +272,7 @@ someInstance.dynamicType.printClassName()
 
 
 > 元(Metatype)类型语法  
-> *元类型* → [*类型*](..\chapter3\03_Types.html#type) **.** **Type** | [*类型*](..\chapter3\03_Types.html#type) **.** **Protocol** 
+> *元类型* → [*类型*](../chapter3/03_Types.html#type) **.** **Type** | [*类型*](../chapter3/03_Types.html#type) **.** **Protocol** 
 
 <a name="type_inheritance_clause"></a>
 ##类型继承子句
@@ -282,10 +286,10 @@ someInstance.dynamicType.printClassName()
 枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举——一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节Raw Values。
 
 > 类型继承子句语法  
-> *类型继承子句* → **:** [*类需求*](..\chapter3\03_Types.html#class_requirement) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list) 
-> *类型继承子句* → **:** [*类需求*](..\chapter3\03_Types.html#class_requirement)
-> *类型继承子句* → **:** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)
-> *类型继承列表* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) | [*类型标识*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承列表*](..\chapter3\03_Types.html#type_inheritance_list)
+> *类型继承子句* → **:** [*类需求*](../chapter3/03_Types.html#class_requirement) **,** [*类型继承列表*](../chapter3/03_Types.html#type_inheritance_list) 
+> *类型继承子句* → **:** [*类需求*](../chapter3/03_Types.html#class_requirement)
+> *类型继承子句* → **:** [*类型继承列表*](../chapter3/03_Types.html#type_inheritance_list)
+> *类型继承列表* → [*类型标识*](../chapter3/03_Types.html#type_identifier) | [*类型标识*](../chapter3/03_Types.html#type_identifier) **,** [*类型继承列表*](../chapter3/03_Types.html#type_inheritance_list)
 > *类需求* → **类**
 
 <a name="type_inference"></a>
diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md
index bdcb7ea9..8094c55d 100644
--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@@ -1,6 +1,10 @@
+> 1.0
 > 翻译：[sg552](https://github.com/sg552)  
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
+> 2.0
+> 翻译+校对：[EudeMorgen](https://github.com/EudeMorgen)
+
 # 表达式（Expressions）
 -----------------
 
@@ -19,8 +23,8 @@ Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary
 前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述。
 
 > 表达式语法  
-> *表达式* → [*试算子(try operator)*](..\chapter3\04_Expressions.html#*) _可选_ | [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) | [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
-> *表达式列表* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*表达式*](..\chapter3\04_Expressions.html#expression) **,** [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)  
+> *表达式* → [*试算子(try operator)*](../chapter3/04_Expressions.html#*) _可选_ | [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) | [*二元表达式列表*](../chapter3/04_Expressions.html#binary_expressions) _可选_  
+> *表达式列表* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*表达式*](../chapter3/04_Expressions.html#expression) **,** [*表达式列表*](../chapter3/04_Expressions.html#expression_list)  
 
 <a name="prefix_expressions"></a>
 ## 前缀表达式（Prefix Expressions）
@@ -32,8 +36,8 @@ Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary
 作为对上面标准库运算符的补充，你也可以对 某个函数的参数使用 '&'运算符。 更多信息，请参见： "In-Out parameters".
 
 > 前置表达式语法  
-> *前置表达式* → [*前置运算符*](LexicalStructure.html#prefix_operator) _可选_ [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression)  
-> *前置表达式* → [*写入写出(in-out)表达式*](..\chapter3\04_Expressions.html#in_out_expression)  
+> *前置表达式* → [*前置运算符*](LexicalStructure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression)  
+> *前置表达式* → [*写入写出(in-out)表达式*](../chapter3/04_Expressions.html#in_out_expression)  
 > *写入写出(in-out)表达式* → **&** [*标识符*](LexicalStructure.html#identifier)  
 
 <a name="try_operator"></a>
@@ -59,11 +63,11 @@ try表达式由紧跟在可能会出错的表达式后面的`try`操作符组成
 > 在解析时,  一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 * 5 首先被认为是：  2, + , `` 3``, *, 5. 随后它被转换成 tree （2 + （3 * 5））
 
 > 二元表达式语法  
-> *二元表达式* → [*二元运算符*](LexicalStructure.html#binary_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*赋值运算符*](..\chapter3\04_Expressions.html#assignment_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*条件运算符*](..\chapter3\04_Expressions.html#conditional_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*类型转换运算符*](..\chapter3\04_Expressions.html#type_casting_operator)  
-> *二元表达式列表* → [*二元表达式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表达式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
+> *二元表达式* → [*二元运算符*](LexicalStructure.html#binary_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*赋值运算符*](../chapter3/04_Expressions.html#assignment_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*条件运算符*](../chapter3/04_Expressions.html#conditional_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*类型转换运算符*](../chapter3/04_Expressions.html#type_casting_operator)  
+> *二元表达式列表* → [*二元表达式*](../chapter3/04_Expressions.html#binary_expression) [*二元表达式列表*](../chapter3/04_Expressions.html#binary_expressions) _可选_  
 > *赋值操作符*
 
 
@@ -98,7 +102,7 @@ try表达式由紧跟在可能会出错的表达式后面的`try`操作符组成
 想看三元条件运算符的例子，请参见： Ternary Conditional Operator.
 
 > 三元条件运算符语法  
-> *三元条件运算符* → **?** [*表达式*](..\chapter3\04_Expressions.html#expression) **:**  
+> *三元条件运算符* → **?** [*表达式*](../chapter3/04_Expressions.html#expression) **:**  
 
 <a name="type-casting_operators"></a>
 ## 类型转换运算符（Type-Casting Operators）
@@ -136,10 +140,10 @@ f(x as Any)
 关于类型转换的更多内容和例子，请参见： Type Casting.
 
 > 类型转换运算符(type-casting-operator)语法  
-> *类型转换运算符* → **is** [*类型*](..\chapter3\03_Types.html#type) 
-> *类型转换运算符* → **as** [*类型*](..\chapter3\03_Types.html#type) 
-> *类型转换运算符* → **is** **?** [*类型*](..\chapter3\03_Types.html#type) 
-> *类型转换运算符* → **as** **!** [*类型*](..\chapter3\03_Types.html#type)  
+> *类型转换运算符* → **is** [*类型*](../chapter3/03_Types.html#type) 
+> *类型转换运算符* → **as** [*类型*](../chapter3/03_Types.html#type) 
+> *类型转换运算符* → **is** **?** [*类型*](../chapter3/03_Types.html#type) 
+> *类型转换运算符* → **as** **!** [*类型*](../chapter3/03_Types.html#type)  
 
 <a name="primary_expressions"></a>
 ## 主表达式（Primary Expressions）
@@ -148,13 +152,13 @@ f(x as Any)
 
 > 主表达式语法  
 > *主表达式* → [*标识符*](LexicalStructure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
-> *主表达式* → [*字符型表达式*](..\chapter3\04_Expressions.html#literal_expression)  
-> *主表达式* → [*self表达式*](..\chapter3\04_Expressions.html#self_expression)  
-> *主表达式* → [*超类表达式*](..\chapter3\04_Expressions.html#superclass_expression)  
-> *主表达式* → [*闭包表达式*](..\chapter3\04_Expressions.html#closure_expression)  
-> *主表达式* → [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_expression)  
-> *主表达式* → [*隐式成员表达式*](..\chapter3\04_Expressions.html#implicit_member_expression)  
-> *主表达式* → [*通配符表达式*](..\chapter3\04_Expressions.html#wildcard_expression)  
+> *主表达式* → [*字符型表达式*](../chapter3/04_Expressions.html#literal_expression)  
+> *主表达式* → [*self表达式*](../chapter3/04_Expressions.html#self_expression)  
+> *主表达式* → [*超类表达式*](../chapter3/04_Expressions.html#superclass_expression)  
+> *主表达式* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression)  
+> *主表达式* → [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression)  
+> *主表达式* → [*隐式成员表达式*](../chapter3/04_Expressions.html#implicit_member_expression)  
+> *主表达式* → [*通配符表达式*](../chapter3/04_Expressions.html#wildcard_expression)  
 
 ### 字符型表达式（Literal Expression）
 
@@ -162,10 +166,10 @@ f(x as Any)
 
 字符（Literal） | 类型（Type） | 值（Value）
 ------------- | ---------- | ----------
-\__FILE__ | String | 所在的文件名
-\__LINE__ | Int | 所在的行数
-\__COLUMN__ | Int | 所在的列数
-\__FUNCTION__ | String | 所在的function 的名字
+/__FILE__ | String | 所在的文件名
+/__LINE__ | Int | 所在的行数
+/__COLUMN__ | Int | 所在的列数
+/__FUNCTION__ | String | 所在的function 的名字
 
 在某个函数（function）中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在特殊的成员如init/subscript中 会返回这个关键字的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。
 
@@ -201,14 +205,14 @@ var emptyDictionary: [String: Double]=[:]
 ```
 > 字面量表达式语法  
 > *字面量表达式* → [*字面量*](LexicalStructure.html#literal)  
-> *字面量表达式* → [*数组字面量*](..\chapter3\04_Expressions.html#array_literal) | [*字典字面量*](..\chapter3\04_Expressions.html#dictionary_literal)  
+> *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal)  
 > *字面量表达式* → **&#95;&#95;FILE&#95;&#95;** | **&#95;&#95;LINE&#95;&#95;** | **&#95;&#95;COLUMN&#95;&#95;** | **&#95;&#95;FUNCTION&#95;&#95;**  
-> *数组字面量* → **[** [*数组字面量项列表*](..\chapter3\04_Expressions.html#array_literal_items) _可选_ **]**  
-> *数组字面量项列表* → [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** [*数组字面量项列表*](..\chapter3\04_Expressions.html#array_literal_items)  
-> *数组字面量项* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
-> *字典字面量* → **[** [*字典字面量项列表*](..\chapter3\04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**  
-> *字典字面量项列表* → [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项列表*](..\chapter3\04_Expressions.html#dictionary_literal_items)  
-> *字典字面量项* → [*表达式*](..\chapter3\04_Expressions.html#expression) **:** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *数组字面量* → **[** [*数组字面量项列表*](../chapter3/04_Expressions.html#array_literal_items) _可选_ **]**  
+> *数组字面量项列表* → [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** [*数组字面量项列表*](../chapter3/04_Expressions.html#array_literal_items)  
+> *数组字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression)  
+> *字典字面量* → **[** [*字典字面量项列表*](../chapter3/04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**  
+> *字典字面量项列表* → [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项列表*](../chapter3/04_Expressions.html#dictionary_literal_items)  
+> *字典字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression) **:** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 ### self表达式（Self Expression）
 
@@ -217,8 +221,8 @@ self表达式是对 当前type 或者当前instance的引用。它的形式如
 > self  
 > self.`member name`  
 > self[`subscript index`]  
-> self（`initializer arguments`）  
-> self.init（`initializer arguments`）  
+> self(`initializer arguments`)
+> self.init(`initializer arguments`)
 
 如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法（static method）, 类方法（class method）中， self等同于当前的type.
 
@@ -228,7 +232,7 @@ self表达式是对 当前type 或者当前instance的引用。它的形式如
 ```swift
 class SomeClass {
     var greeting: String
-    init（greeting: String） {
+    init(greeting: String) {
         self.greeting = greeting
     }
 }
@@ -239,8 +243,8 @@ class SomeClass {
 ```swift
 struct Point {
     var x = 0.0, y = 0.0
-    mutating func moveByX（deltaX: Double, y deltaY: Double） {
-        self = Point（x: x + deltaX, y: y + deltaY）
+    mutating func moveByX(deltaX: Double, y deltaY: Double) {
+        self = Point(x: x + deltaX, y: y + deltaY)
     }
 }
 ```
@@ -248,7 +252,7 @@ struct Point {
 > Self 表达式语法  
 > *self表达式* → **self**  
 > *self表达式* → **self** **.** [*标识符*](LexicalStructure.html#identifier)  
-> *self表达式* → **self** **[** [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
+> *self表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
 > *self表达式* → **self** **.** **init**  
 
 ### 超类表达式（Superclass Expression）
@@ -257,16 +261,16 @@ struct Point {
 
 > super.`member name`  
 > super[`subscript index`]  
-> super.init（`initializer arguments`）  
+> super.init(`initializer arguments`)
 
 形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.
 
 子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。
 
 > 超类(superclass)表达式语法  
-> *超类表达式* → [*超类方法表达式*](..\chapter3\04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](..\chapter3\04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](..\chapter3\04_Expressions.html#superclass_initializer_expression)  
+> *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression)  
 > *超类方法表达式* → **super** **.** [*标识符*](LexicalStructure.html#identifier)  
-> *超类下标表达式* → **super** **[** [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
+> *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
 > *超类构造器表达式* → **super** **.** **init**  
 
 ### 闭包表达式（Closure Expression）
@@ -274,7 +278,7 @@ struct Point {
 闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下：
 
 ```swift
-{ （parameters） -> return type in
+{ (parameters) -> return type in
     statements
 }
 ```
@@ -291,12 +295,12 @@ struct Point {
 
 ```swift
 myFunction {
-    （x: Int, y: Int） -> Int in
+    (x: Int, y: Int) -> Int in
     return x + y
 }
 
 myFunction {
-    （x, y） in
+    (x, y) in
     return x + y
 }
 
@@ -312,28 +316,28 @@ myFunction { $0 + $1 }
 在闭包的参数列表（ capture list）中， 参数可以声明为 'weak' 或者 'unowned' .
 
 ```swift
-myFunction { print（self.title） }                    // strong capture
-myFunction { [weak self] in print（self!.title） }    // weak capture
-myFunction { [unowned self] in print（self.title） }  // unowned capture
+myFunction { print(self.title) }                    // strong capture
+myFunction { [weak self] in print(self!.title) }    // weak capture
+myFunction { [unowned self] in print(self.title) }  // unowned capture
 ```
 
 在参数列表中，也可以使用任意表达式来赋值. 该表达式会在 闭包被执行时赋值，然后按照不同的力度来获取（这句话请慎重理解）。（captured with the specified strength. ） 例如：
 
 ```swift
 // Weak capture of "self.parent" as "parent"
-myFunction { [weak parent = self.parent] in print（parent!.title） }
+myFunction { [weak parent = self.parent] in print(parent!.title) }
 ```
 
 关于闭包表达式的更多信息和例子，请参见： Closure Expressions.
 
 > 闭包表达式语法  
-> *闭包表达式* → **{** [*闭包签名(Signational)*](..\chapter3\04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) **}**  
-> *闭包签名(Signational)* → [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) **in**  
-> *捕获(Capature)列表* → **[** [*捕获(Capature)说明符*](..\chapter3\04_Expressions.html#capture_specifier) [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
+> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}**  
+> *闭包签名(Signational)* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) [*标识符列表*](LexicalStructure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)列表*](../chapter3/04_Expressions.html#capture_list) **in**  
+> *捕获(Capature)列表* → **[** [*捕获(Capature)说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
 > *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**  
 
 ### 隐式成员表达式（Implicit Member Expression）
@@ -350,7 +354,7 @@ x = .AnotherValue
 ```
 
 > 隐式成员表达式语法  
-> *隐式成员表达式* → **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
 
 ### 圆括号表达式（Parenthesized Expression）
 
@@ -361,16 +365,16 @@ x = .AnotherValue
 圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int）
 
 > 圆括号表达式(Parenthesized Expression)语法  
-> *圆括号表达式* → **(** [*表达式元素列表*](..\chapter3\04_Expressions.html#expression_element_list) _可选_ **)**  
-> *表达式元素列表* → [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) | [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) **,** [*表达式元素列表*](..\chapter3\04_Expressions.html#expression_element_list)  
-> *表达式元素* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **:** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *圆括号表达式* → **(** [*表达式元素列表*](../chapter3/04_Expressions.html#expression_element_list) _可选_ **)**  
+> *表达式元素列表* → [*表达式元素*](../chapter3/04_Expressions.html#expression_element) | [*表达式元素*](../chapter3/04_Expressions.html#expression_element) **,** [*表达式元素列表*](../chapter3/04_Expressions.html#expression_element_list)  
+> *表达式元素* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **:** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 ### 通配符表达式（Wildcard Expression）
 
 通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。）
 
 ```swift
-（x, _） = （10, 20）
+(x, _) = (10, 20)
 // x is 10, 20 is ignored
 ```
 
@@ -390,56 +394,53 @@ Swift 标准库提供了下列后缀表达式：
 对于这些操作符的使用，请参见： Basic Operators and Advanced Operators
 
 > 后置表达式语法  
-> *后置表达式* → [*主表达式*](..\chapter3\04_Expressions.html#primary_expression)  
-> *后置表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*后置运算符*](..\chapter3\02_Lexical_Structure.html#postfix_operator)  
-> *后置表达式* → [*函数调用表达式*](..\chapter3\04_Expressions.html#function_call_expression)  
-> *后置表达式* → [*构造器表达式*](..\chapter3\04_Expressions.html#initializer_expression)  
-> *后置表达式* → [*显示成员表达式*](..\chapter3\04_Expressions.html#explicit_member_expression)  
-> *后置表达式* → [*后置self表达式*](..\chapter3\04_Expressions.html#postfix_self_expression)  
-> *后置表达式* → [*动态类型表达式*](..\chapter3\04_Expressions.html#dynamic_type_expression)  
-> *后置表达式* → [*下标表达式*](..\chapter3\04_Expressions.html#subscript_expression)  
-> *后置表达式* → [*强制取值(Forced Value)表达式*](..\chapter3\04_Expressions.html#forced_value_expression)  
-> *后置表达式* → [*可选链(Optional Chaining)表达式*](..\chapter3\04_Expressions.html#optional_chaining_expression)  
+> *后置表达式* → [*主表达式*](../chapter3/04_Expressions.html#primary_expression)  
+> *后置表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*后置运算符*](../chapter3/02_Lexical_Structure.html#postfix_operator)  
+> *后置表达式* → [*函数调用表达式*](../chapter3/04_Expressions.html#function_call_expression)  
+> *后置表达式* → [*构造器表达式*](../chapter3/04_Expressions.html#initializer_expression)  
+> *后置表达式* → [*显示成员表达式*](../chapter3/04_Expressions.html#explicit_member_expression)  
+> *后置表达式* → [*后置self表达式*](../chapter3/04_Expressions.html#postfix_self_expression)  
+> *后置表达式* → [*动态类型表达式*](../chapter3/04_Expressions.html#dynamic_type_expression)  
+> *后置表达式* → [*下标表达式*](../chapter3/04_Expressions.html#subscript_expression)  
+> *后置表达式* → [*强制取值(Forced Value)表达式*](../chapter3/04_Expressions.html#forced_value_expression)  
+> *后置表达式* → [*可选链(Optional Chaining)表达式*](../chapter3/04_Expressions.html#optional_chaining_expression)  
 
 ### 函数调用表达式（Function Call Expression）
 
 函数调用表达式由函数名和参数列表组成。它的形式如下：
 
-> `function name`（`argument value 1`, `argument value 2`）
-
-The function name can be any expression whose value is of a function type.
-（不用翻译了, 太罗嗦）
+> `function name`(`argument value 1`, `argument value 2`)
 
 如果该function 的声明中指定了参数的名字，那么在调用的时候也必须得写出来. 例如：
 
-> `function name`（`argument name 1`: `argument value 1`, `argument name 2`: `argument value 2`）
+> `function name`(`argument name 1`: `argument value 1`, `argument name 2`: `argument value 2`)
 
 可以在 函数调用表达式的尾部（最后一个参数之后）加上 一个闭包（closure） ， 该闭包会被目标函数理解并执行。它具有如下两种写法：
 
 ```swift
 // someFunction takes an integer and a closure as its arguments
-someFunction（x, {$0 == 13}）
-someFunction（x） {$0 == 13}
+someFunction(x, {$0 == 13}+
+someFunction(x) {$0 == 13}
 ```
 
 如果闭包是该函数的唯一参数，那么圆括号可以省略。
 
 ```swift
 // someFunction takes a closure as its only argument
-myData.someMethod（） {$0 == 13}
+myData.someMethod() {$0 == 13}
 myData.someMethod {$0 == 13}
 ```
 
 > 函数调用表达式语法  
-> *函数调用表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_expression)  
-> *函数调用表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包(Trailing Closure)*](..\chapter3\04_Expressions.html#trailing_closure)  
-> *后置闭包(Trailing Closure)* → [*闭包表达式*](..\chapter3\04_Expressions.html#closure_expression)  
+> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression)  
+> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包(Trailing Closure)*](../chapter3/04_Expressions.html#trailing_closure)  
+> *后置闭包(Trailing Closure)* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression)  
 
 ### 初始化函数表达式（Initializer Expression）
 
 Initializer表达式用来给某个Type初始化。 它的形式如下：
 
-> `expression`.init（`initializer arguments`）
+> `expression`.init(`initializer arguments`)
 
 （Initializer表达式用来给某个Type初始化。） 跟函数（function）不同， initializer 不能返回值。
 
@@ -452,15 +453,15 @@ var y = SomeClass.init              // error
 
 ```swift
 class SomeSubClass: SomeSuperClass {
-    init（） {
+    init() {
         // subclass initialization goes here
-        super.init（）
+        super.init()
     }
 }
 ```
 
 > 构造器表达式语法  
-> *构造器表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **init**  
+> *构造器表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init**  
 
 ### 显式成员表达式（Explicit Member Expression）
 
@@ -474,23 +475,23 @@ class SomeSubClass: SomeSuperClass {
 class SomeClass {
     var someProperty = 42
 }
-let c = SomeClass（）
+let c = SomeClass()
 let y = c.someProperty  // Member access
 ```
 
 对于tuple, 要根据它们出现的顺序（0, 1, 2...）来使用:
 
 ```swift
-var t = （10, 20, 30）
+var t = (10, 20, 30)
 t.0 = t.1
-// Now t is （20, 20, 30）
+// Now t is (20, 20, 30)
 ```
 
 对于某个module的member的调用，只能调用在top-level声明中的member.
 
 > 显式成员表达式语法  
-> *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit)  
-> *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
+> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit)  
+> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数子句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
 
 ### 后缀self表达式（Postfix Self Expression）
 
@@ -504,7 +505,7 @@ t.0 = t.1
 形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。
 
 > 后置Self 表达式语法  
-> *后置self表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **self**  
+> *后置self表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self**  
 
 ### dynamic表达式（Dynamic Type Expression）
 
@@ -518,25 +519,25 @@ dynamicType 表达式由 某个表达式 + '.dynamicType' 组成。
 
 ```swift
 class SomeBaseClass {
-    class func printClassName（） {
-        println（"SomeBaseClass"）
+    class func printClassName() {
+        println("SomeBaseClass")
     }
 }
 class SomeSubClass: SomeBaseClass {
-    override class func printClassName（） {
-        println（"SomeSubClass"）
+    override class func printClassName() {
+        println("SomeSubClass")
     }
 }
-let someInstance: SomeBaseClass = SomeSubClass（）
+let someInstance: SomeBaseClass = SomeSubClass()
 
 // someInstance is of type SomeBaseClass at compile time, but
 // someInstance is of type SomeSubClass at runtime
-someInstance.dynamicType.printClassName（）
+someInstance.dynamicType.printClassName()
 // prints "SomeSubClass"
 ```
 
 > 动态类型表达式语法  
-> *动态类型表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **dynamicType**  
+> *动态类型表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType**  
 
 ### 下标脚本表达式（Subscript Expression）
 
@@ -549,7 +550,7 @@ someInstance.dynamicType.printClassName（）
 关于subscript的声明，请参见： Protocol Subscript Declaration.
 
 > 附属脚本表达式语法  
-> *附属脚本表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **[** [*表达式列表*](..\chapter3\04_Expressions.html#expression_list) **]**  
+> *附属脚本表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式列表*](../chapter3/04_Expressions.html#expression_list) **]**  
 
 ### 强制取值表达式（Forced-Value Expression）
 
@@ -570,7 +571,7 @@ someDictionary["a"]![0] = 100
 ```
 
 > 强制取值(Forced Value)语法  
-> *强制取值(Forced Value)表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **!**  
+> *强制取值(Forced Value)表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!**  
 
 ### 可选链表达式（Optional-Chaining Expression）
 
@@ -586,14 +587,14 @@ someDictionary["a"]![0] = 100
 
 ```swift
 var c: SomeClass?
-var result: Bool? = c?.property.performAction（）
+var result: Bool? = c?.property.performAction()
 ```
 
 如果不使用可选链表达式，那么 上面例子的代码跟下面例子等价：
 
 ```swift
 if let unwrappedC = c {
-    result = unwrappedC.property.performAction（）
+    result = unwrappedC.property.performAction()
 }
 ```
 后缀'?' 返回目标表达式的值可能会被修改，可能是由于出现了赋值，也有可能是出现异常而产生的修改。如果可选链表达式为`nil`，则表达式右边的复制操作不会被执行。比如：
@@ -614,4 +615,4 @@ someDictionary["a"]?[0] = someFunctionWithSideEffects()
 
 
 > 可选链表达式语法  
-> *可选链表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **?**  
+> *可选链表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **?**  
diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md
index cc141e17..39983123 100755
--- a/source/chapter3/05_Declarations.md
+++ b/source/chapter3/05_Declarations.md
@@ -1,8 +1,12 @@
+> 1.0
 > 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon)
-> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
-
+> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
+
+> 2.0
+> 翻译+校对：[Lenhoon](https://github.com/Lenhoon)
+
 <a name="declarations"></a>
-# 声明
+# 声明
 -----------------
 
 本页包含内容：
@@ -84,9 +88,9 @@ Swift的源文件中的顶级代码由零个或多个语句，声明和表达式
 
 <a name="grammer_of_an_import_declaration"></a>
 > 导入(Import)声明语法  
-> *导入声明* → [*特性(attributes)列表*](TODO) _可选_ **import** [*导入类型*](..\chapter3\05_Declarations.html#import_kind) _可选_ [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
+> *导入声明* → [*特性(attributes)列表*](TODO) _可选_ **import** [*导入类型*](../chapter3/05_Declarations.html#import_kind) _可选_ [*导入路径*](../chapter3/05_Declarations.html#import_path)  
 > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**  
-> *导入路径* → [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) | [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) **.** [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
+> *导入路径* → [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) | [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) **.** [*导入路径*](../chapter3/05_Declarations.html#import_path)  
 > *导入路径标识符* → [*标识符*](TODO) | [*运算符*](TODO)  
 
 <a name="constant_declaration"></a>
@@ -96,9 +100,9 @@ Swift的源文件中的顶级代码由零个或多个语句，声明和表达式
 
 > let `constant name`: `type` = `expression`
 
-当常量的值被给定后，常量就将*常量名称(constant name)*和*表达式(expression)*初始值不变的结合在了一起，而且不能更改。
+当常量的值被给定后，常量就将*常量名称(constant name)*和*表达式(expression)*初始值不变的结合在了一起，而且不能更改。
 
-这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
+这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
 
 当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，它被认为是一个*常量属性(constant property)*。常量并不是可计算的属性，因此不包含getters和setters。
 
@@ -111,9 +115,9 @@ let (firstNumber, secondNumber) = (10, 42)
 在上例中，`firstNumber`是一个值为`10`的常量，`secnodeName`是一个值为`42`的常量。所有常量都可以独立的使用：
 
 ```swift
-println("The first number is \(firstNumber).")
+println("The first number is /(firstNumber).")
 // prints "The first number is 10."
-println("The second number is \(secondNumber).")
+println("The second number is /(secondNumber).")
 // prints "The second number is 42."
 ```
 
@@ -122,26 +126,26 @@ println("The second number is \(secondNumber).")
 声明一个常量类型属性要使用关键字`static`声明修饰符。类型属性在[类型属性(Type Properties)](TODO)中有介绍。
 
 如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看[常量和变量(Constants and Variables)](TODO)和[存储属性(Stored Properties)](TODO)等节。
-
+
 <a name="grammer_of_a_constant_declaration"></a>
 > 常数声明语法  
-> *常量声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *模式构造器列表* → [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *模式构造器* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_  
-> *构造器* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *常量声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list)  
+> *模式构造器列表* → [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) | [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) **,** [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list)  
+> *模式构造器* → [*模式*](../chapter3/07_Patterns.html#pattern) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_  
+> *构造器* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <a name="variable_declaration"></a>
 ##变量声明
 
-*变量声明(variable declaration)*可以在程序里声明一个变量，它以关键字`var`来声明。
-
+*变量声明(variable declaration)*可以在程序里声明一个变量，它以关键字`var`来声明。
+
 变量声明有几种不同的形式声明不同种类的命名值和计算型值，如存储和计算变量和属性，存储变量和属性监视，和静态变量属性。所使用的声明形式取决于变量所声明的范围和打算声明的变量类型。
 
 >注意：  
->也可以在协议声明的上下文声明属性，详情参见[协议属性声明(Protocal Property Declaration)](TODO)。
-
+>也可以在协议声明的上下文声明属性，详情参见[协议属性声明(Protocal Property Declaration)](TODO)。
+
 可以重载一个子类中的属性，通过使用'override'声明修饰符来标记子类的属性声明，[重写(Overriding)](TODO)中有所介绍。
-
+
 <a name="stored_variables_and_stored_variable_properties"></a>
 ###存储型变量和存储型属性
 
@@ -157,7 +161,7 @@ println("The second number is \(secondNumber).")
 对于常量的定义，如果*变量名字（variable name）*是一个元组（tuple），元组中每一项的名称都要和初始化*表达式(expression)*中的相应值一致。
 
 正如名字一样，存储型变量的值或存储型变量属性存储在内存中。
-
+
 <a name="computed_variables_and_computed_properties"></a>
 ###计算型变量和计算型属性
 
@@ -182,7 +186,7 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
 不像存储型变量和存储型属性那样，计算型属性和计算型变量的值不存储在内存中。
 
 获得更多信息，查看更多关于计算型属性的例子，请查看[计算型属性(Computed Properties)](TODO)一节。
-
+
 <a name="stored_variable_observers_and_property_observers"></a>
 ###存储型变量监视器和属性监视器
 
@@ -215,8 +219,8 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
 当提供一个`willset`语句时，`didset`语句是可选的。同样的，在提供了一个`didset`语句时，`willset`语句是可选的。
 
 获得更多信息，查看如何使用属性监视器的例子，请查看[属性监视器(Property Observers)](TODO)一节。
-声明修饰符
-
+声明修饰符
+
 <a name="type_variable_properties"></a>
 ###类型变量属性
 
@@ -225,30 +229,30 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
 >>注意
 >>
 >在一个类声明中，关键字`static`与用声明修饰符`class`和`final`去标记一个声明的效果相同
-
+
 <a name="grammer_of_a_variable_declaration"></a>
 > 变量声明语法  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*模式构造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)   
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*构造器*](..\chapter3\05_Declarations.html#initializer) [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)   
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)  
-> *变量声明头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var**  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*模式构造器列表*](../chapter3/05_Declarations.html#pattern_initializer_list)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*getter-setter块*](../chapter3/05_Declarations.html#getter_setter_block)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)   
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*构造器*](../chapter3/05_Declarations.html#initializer) [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block)   
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block)  
+> *变量声明头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var**  
 > *变量名称* → [*标识符*](LexicalStructure.html#identifier)  
-> *getter-setter块* → **{** [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) _可选_ **}**  
-> *getter-setter块* → **{** [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) **}**  
-> *getter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **get** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *setter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **set** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *getter-setter块* → **{** [*getter子句*](../chapter3/05_Declarations.html#getter_clause) [*setter子句*](../chapter3/05_Declarations.html#setter_clause) _可选_ **}**  
+> *getter-setter块* → **{** [*setter子句*](../chapter3/05_Declarations.html#setter_clause) [*getter子句*](../chapter3/05_Declarations.html#getter_clause) **}**  
+> *getter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *setter子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
 > *setter名称* → **(** [*标识符*](LexicalStructure.html#identifier) **)**  
-> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可选_ **}**  
-> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) **}**  
-> *getter关键字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **get**  
-> *setter关键字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **set**  
-> *willSet-didSet代码块* → **{** [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) _可选_ **}**  
-> *willSet-didSet代码块* → **{** [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) **}**  
-> *willSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *didSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) _可选_ **}**  
+> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)子句*](../chapter3/05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)子句*](../chapter3/05_Declarations.html#getter_keyword_clause) **}**  
+> *getter关键字(Keyword)子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **get**  
+> *setter关键字(Keyword)子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **set**  
+> *willSet-didSet代码块* → **{** [*willSet子句*](../chapter3/05_Declarations.html#willSet_clause) [*didSet子句*](../chapter3/05_Declarations.html#didSet_clause) _可选_ **}**  
+> *willSet-didSet代码块* → **{** [*didSet子句*](../chapter3/05_Declarations.html#didSet_clause) [*willSet子句*](../chapter3/05_Declarations.html#willSet_clause) **}**  
+> *willSet子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *didSet子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
 
 <a name="type_alias_declaration"></a>
 ##类型的别名声明
@@ -260,13 +264,13 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
 当声明一个类型的别名后，可以在程序的任何地方使用别*名(name)*来代替*已存在的类型(existing type)*。已存在的类型可以是已经被命名的类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。
 
 查看更多[协议关联类型声明(Protocol Associated Type Declaration)](TODO).
-
+
 <a name="grammer_of_a_type_alias_declaration"></a>
 > 类型别名声明语法  
-> *类型别名声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment)  
-> *类型别名头(Head)* → [*属性列表*](todo) _可选_ [*访问级别修饰符*]((TODO) _可选_ **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name)  
+> *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment)  
+> *类型别名头(Head)* → [*属性列表*](todo) _可选_ [*访问级别修饰符*]((TODO) _可选_ **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name)  
 > *类型别名名称* → [*标识符*](LexicalStructure.html#identifier)  
-> *类型别名赋值* → **=** [*类型*](..\chapter3\03_Types.html#type)  
+> *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type)  
 
 <a name="function_declaration"></a>
 ##函数声明
@@ -289,7 +293,7 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
 函数可以使用元组类型作为返回值来返回多个变量。
 
 函数定义可以出现在另一个函数声明内。这种函数被称作nested函数。更多关于*嵌套函数(Nested Functions)*的讨论，参见[嵌套函数(Nested Functions)](TODO)。
-
+
 <a name="parameter_names"></a>
 ###参数名
 
@@ -301,7 +305,7 @@ setter的名字和圆括号内的语句是可选的。如果写了一个setter
 一个参数有一个内部名称，这个内部名称可以在函数体内被使用。同样也可以作为外部名称，当调用方法时这个外部名称被作为实参的标签来使用。默认情况下，第一个参数的外部名称省略不写，第二个和其之后的参数使用它们的内部名称作为它们的外部名称。
 
 ```swift
-func f(x: Int, y: Int) -> Int{ return x + y}
+func f(x: Int, y: Int) -> Int{ return x + y}
 f(1, y: 2) // y是有标记的，x没有
 ```
 
@@ -309,17 +313,17 @@ f(1, y: 2) // y是有标记的，x没有
 
 > `external parameter name` `local parameter name`: `parameter type`    
 > _ `local parameter name`: `parameter type`  
-
+
 在内部参数名前的名称赋予这个参数一个外部名称，这个名称可以和内部参数的名称不同。外部参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有外部名 。
 
-内部参数名前的强调字符下划线(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
-
-```swift
-func f(x x: Int, withY y: Int, _z: Int) -> Int{
-	return x + y + z }
-f(x: 1, withY: 2, 3) // x和y是有标记的，z没有
+内部参数名前的强调字符下划线(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
+
+```swift
+func f(x x: Int, withY y: Int, _z: Int) -> Int{
+	return x + y + z }
+f(x: 1, withY: 2, 3) // x和y是有标记的，z没有
 ```
-
+
 <a name="special_kinds_of_parameters"></a>
 ###特殊类型的参数
 
@@ -333,13 +337,13 @@ f(x: 1, withY: 2, 3) // x和y是有标记的，z没有
 
 一个以基础类型名的参数，如果紧跟着三个点(`...`)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数`Int...`被看做是`[Int]`。查看可变参数的使用例子，详见[可变参数(Variadic Parameters)](TODO)一节。
 
-在参数的类型后面有一个以等号(`=`)连接的表达式，这样的参数被看做有着给定表达式的初始值。当函数被调用时，给定的表达式被求值。如果参数在函数调用时被省略了，就会使用初始值。
-
-```swift
-func f(x: Int = 42) -> Int { return x}
-f()  // 有效的，使用默认值
-f(7) // 有效的，提供了值，没有提供值的名称
-f(x: 7) //无效的，值和值的名称都提供了
+在参数的类型后面有一个以等号(`=`)连接的表达式，这样的参数被看做有着给定表达式的初始值。当函数被调用时，给定的表达式被求值。如果参数在函数调用时被省略了，就会使用初始值。
+
+```swift
+func f(x: Int = 42) -> Int { return x}
+f()  // 有效的，使用默认值
+f(7) // 有效的，提供了值，没有提供值的名称
+f(x: 7) //无效的，值和值的名称都提供了
 ```
 <a name="special_kinds_of_methods"></a>
 ###特殊方法
@@ -347,9 +351,9 @@ f(x: 7) //无效的，值和值的名称都提供了
 枚举或结构体的方法来修改`self`属性，必须以`mutating`声明修饰符标记。
 
 子类方法重写超类中的方法必须以`override`声明修饰符标记。重写一个方法不使用`override`修饰符，或者使用了`override`修饰符却并没有重写超类方法都会产生一个编译时错误。
-
+
 枚举或者结构体中的类型方法而不是实例方法，要以`static`声明修饰符标记，而对于类中的类型方法，要使用`class`声明修饰符标记。
-
+
 <a name="curried_functions"></a>
 ###柯里化函数(Curried Functions)
 
@@ -383,7 +387,7 @@ func addTwoIntsCurried(a a: Int)(b: Int) -> Int {
     return a + b
 }
 
-func addTwoIntsCurried(a a: Int) -> (Int -> Int) 
+func addTwoIntsCurried(a a: Int) -> (Int -> Int) 
 			{
     func addTheOtherInt(b: Int) -> Int {
         return a + b
@@ -413,64 +417,64 @@ let plusOne = addTwoIntsCurried(a: 1)
 ```swift
 plusOne(10)
 // 返回值为11
-```
-
-<a name="throwing_functions_and_methods"></a>
-###抛出异常函数和抛出异常方法(Throwing Functions and Methods)
-
-可以抛出一个错误的函数或方法必需使用`throws`关键字标记。这些函数和方法被称为*抛出异常函数(throwing functions)*和*抛出异常方法(throwing methods)*。它们有着下面的形式:
-
->	func `function name`(`parameters`) throws ->
->		`return type`	{
->			`statements`
->		}
-
-调用一个抛出异常函数或抛出异常方法必需用一个`try`或者`try!`表达式来封装（也就是说，在一个范围内使用一个`try`或者`try!`运算符）。
-
-`throws`关键字是函数的类型的一部分，不抛出异常的函数是抛出异常函数的一个子类型。所以，可以在使用抛出异常函数的地方使用不抛出异常函数。对于柯里化函数，`throws`关键字仅运用于最内层的函数。
-
-不能重写一个仅基于是否能抛出错误的函数。也就是说，可以重载一个基于函数*参数(parameter)*能否抛出一个错误的函数。
-
-一个抛出异常的方法不能重写一个不能抛出异常的方法，而且一个异常抛出方法不能满足一个协议对于不抛出异常方法的需求。也就是说，一个不抛出异常的方法可以重写一个抛出异常的方法，而且一个不抛出异常的方法可以满足一个协议对于抛出异常的需求。
-
-<a name="rethrowing_functions_and_methods"></a>
-###重抛出异常函数和重抛出异常方法(Rethrowing Functions and Methods)
-
-一个函数或方法可以使用`rethrows`关键字来声明，从而表明仅当这个函数或方法的一个函数参数抛出错误时这个函数或方法才抛出错误。这些函数和方法被称为*重抛出异常函数(rethrowing functions)*和*重抛出异常方法(rethrowing methods)*。重抛出异常函数或方法必需有至少一个抛出异常函数参数。
-
-```
-	func functionWithCallback(callback: () throws -> Int) rethrows {
-		try callback()
-	}
-```
-一个抛出异常函数方法不能重写一个重抛出异常函数方法，一个抛出异常方法不能满足一个协议对于重抛出异常方法的需求。也就是说，一个重抛出异常方法可以重写一个抛出异常方法，而且一个重抛出异常方法可以满足一个协议对于抛出异常方法的需求。
-
+```
+
+<a name="throwing_functions_and_methods"></a>
+###抛出异常函数和抛出异常方法(Throwing Functions and Methods)
+
+可以抛出一个错误的函数或方法必需使用`throws`关键字标记。这些函数和方法被称为*抛出异常函数(throwing functions)*和*抛出异常方法(throwing methods)*。它们有着下面的形式:
+
+>	func `function name`(`parameters`) throws ->
+>		`return type`	{
+>			`statements`
+>		}
+
+调用一个抛出异常函数或抛出异常方法必需用一个`try`或者`try!`表达式来封装（也就是说，在一个范围内使用一个`try`或者`try!`运算符）。
+
+`throws`关键字是函数的类型的一部分，不抛出异常的函数是抛出异常函数的一个子类型。所以，可以在使用抛出异常函数的地方使用不抛出异常函数。对于柯里化函数，`throws`关键字仅运用于最内层的函数。
+
+不能重写一个仅基于是否能抛出错误的函数。也就是说，可以重载一个基于函数*参数(parameter)*能否抛出一个错误的函数。
+
+一个抛出异常的方法不能重写一个不能抛出异常的方法，而且一个异常抛出方法不能满足一个协议对于不抛出异常方法的需求。也就是说，一个不抛出异常的方法可以重写一个抛出异常的方法，而且一个不抛出异常的方法可以满足一个协议对于抛出异常的需求。
+
+<a name="rethrowing_functions_and_methods"></a>
+###重抛出异常函数和重抛出异常方法(Rethrowing Functions and Methods)
+
+一个函数或方法可以使用`rethrows`关键字来声明，从而表明仅当这个函数或方法的一个函数参数抛出错误时这个函数或方法才抛出错误。这些函数和方法被称为*重抛出异常函数(rethrowing functions)*和*重抛出异常方法(rethrowing methods)*。重抛出异常函数或方法必需有至少一个抛出异常函数参数。
+
+```
+	func functionWithCallback(callback: () throws -> Int) rethrows {
+		try callback()
+	}
+```
+一个抛出异常函数方法不能重写一个重抛出异常函数方法，一个抛出异常方法不能满足一个协议对于重抛出异常方法的需求。也就是说，一个重抛出异常方法可以重写一个抛出异常方法，而且一个重抛出异常方法可以满足一个协议对于抛出异常方法的需求。
+
 <a name="grammer_of_a_function_declaration"></a>
 > 函数声明语法  
-> *函数声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature) [*函数体*](..\chapter3\05_Declarations.html#function_body)  
-> *函数头* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **func**  
+> *函数声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature) [*函数体*](../chapter3/05_Declarations.html#function_body)  
+> *函数头* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符(Specifiers)列表*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **func**  
 > *函数名* → [*标识符*](LexicalStructure.html#identifier) | [*运算符*](LexicalStructure.html#operator)  
-> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **throws** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
-> *函数签名(signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
-> *函数结果* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
-> *函数体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *parameter-clauses* → [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可选_  
-> *参数子句* → **(** **)** | **(** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list) **...** _可选_ **)**  
-> *参数列表* → [*参数*](..\chapter3\05_Declarations.html#parameter) | [*参数*](..\chapter3\05_Declarations.html#parameter) **,** [*参数列表*](..\chapter3\05_Declarations.html#parameter_list)  
-> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name)_可选_ [*内部参数名*](..\chapter3\05_Declarations.html#local_parameter_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
-> *参数* → **inout** _可选_ **var** [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name) [*内部参数名*](..\chapter3\05_Declarations.html#local_parameter_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*默认参数子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
-> *参数* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_  
+> *函数签名(signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_  
+> *函数结果* → **->** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)  
+> *函数体* → [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *parameter-clauses* → [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) _可选_  
+> *参数子句* → **(** **)** | **(** [*参数列表*](../chapter3/05_Declarations.html#parameter_list) **...** _可选_ **)**  
+> *参数列表* → [*参数*](../chapter3/05_Declarations.html#parameter) | [*参数*](../chapter3/05_Declarations.html#parameter) **,** [*参数列表*](../chapter3/05_Declarations.html#parameter_list)  
+> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](../chapter3/05_Declarations.html#parameter_name)_可选_ [*内部参数名*](../chapter3/05_Declarations.html#local_parameter_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*默认参数子句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → **inout** _可选_ **var** [*外部参数名*](../chapter3/05_Declarations.html#parameter_name) [*内部参数名*](../chapter3/05_Declarations.html#local_parameter_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*默认参数子句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)  
 > *参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**  
 > *内部参数名* → [*标识符*](LexicalStructure.html#identifier) | **_**  
-> *默认参数子句* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *默认参数子句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <a name="enumeration_declaration"></a>
 ##枚举声明
 
 在程序里使用*枚举声明(enumeration)*来引入一个枚举类型。
 
-枚举声明有两种基本的形式，使用关键字`enum`来声明。枚举声明体使用从零开始的变量——叫做*枚举事件(enumeration cases)*，和任意数量的声明，包括计算型属性，实例方法，类型方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能包含析构器或者协议声明。
-
+枚举声明有两种基本的形式，使用关键字`enum`来声明。枚举声明体使用从零开始的变量——叫做*枚举事件(enumeration cases)*，和任意数量的声明，包括计算型属性，实例方法，类型方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能包含析构器或者协议声明。
+
 枚举类型可以采用任何数量的协议，但是这些协议不能从类，结构体和其他的枚举继承。
 
 不像类或者结构体。枚举类型并不提供隐式的初始构造器，所有构造器必须显式的声明。构造器可以委托枚举中的其他构造器，但是构造过程仅当构造器将一个枚事件指定给`self`才全部完成。
@@ -479,7 +483,7 @@ plusOne(10)
 更多关于值类型的信息，参见结构体和枚举都是[值类型(Structures and Enumerations Are Value Types)](TODO)一节。
 
 可以扩展枚举类型，正如在[扩展声明(Extension Declaration)](TODO)中讨论的一样。
-
+
 <a name="enumerations_with_cases_of_any_type"></a>
 ###任意事件类型的枚举
 
@@ -494,21 +498,21 @@ plusOne(10)
 
 这种形式中，每一个事件块由关键字`case`开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在*关联值类型(associated values types)*的元组里被指定，立即书写在事件
 名后。获得更多关于关联值类型的信息和例子，请查看[关联值(Associated Values)](TODO)一节。
-
-枚举有一个递归结构，就是说，枚举有着枚举类型自身实例的关联值的事件。然而，枚举类型的实例有值语义，意味着它们在内存中有着固定的位置。为了支持递归，编译器必需插入一个间接层。
-
-为间接使用特殊的枚举事件，使用`indirect`声明修饰符标记。
-
-> enum Tree<T> {
-> 		case Empty
-> 		indirect case Node(value: T, left: Tree, right:Tree)
-> }
-
-为了间接的使用一个枚举的所有事件，使用`indirect`修饰符标记整个枚举-当枚举有许多事件且每个事件都需要使用`indirect`修饰符标记的时候这将非常便利。
-
-一个被`indirect`修饰符标记的枚举事件必需有一个关联值。一个使用`indirect`修饰符标记的枚举包含有着关联值的事件和没有关联值的事件的混合。就是说，它不能包含任何也使用`indirect`修饰符标记的事件。
-
-
+
+枚举有一个递归结构，就是说，枚举有着枚举类型自身实例的关联值的事件。然而，枚举类型的实例有值语义，意味着它们在内存中有着固定的位置。为了支持递归，编译器必需插入一个间接层。
+
+为间接使用特殊的枚举事件，使用`indirect`声明修饰符标记。
+
+> enum Tree<T> {
+> 		case Empty
+> 		indirect case Node(value: T, left: Tree, right:Tree)
+> }
+
+为了间接的使用一个枚举的所有事件，使用`indirect`修饰符标记整个枚举-当枚举有许多事件且每个事件都需要使用`indirect`修饰符标记的时候这将非常便利。
+
+一个被`indirect`修饰符标记的枚举事件必需有一个关联值。一个使用`indirect`修饰符标记的枚举包含有着关联值的事件和没有关联值的事件的混合。就是说，它不能包含任何也使用`indirect`修饰符标记的事件。
+
+
 <a name="enumerations_with_cases_of_a_raw-value_type"></a>
 ###使用原始值类型事件的枚举(Enumerations with Cases of a Raw-Value Type)
 
@@ -519,8 +523,8 @@ plusOne(10)
 >		case `enumeration case 2` = `raw value 2`  
 > }  
 
-在这种形式中，每一个事件块由`case`关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做*原始值(raw value)*。这些值的类型在*原始值类型(raw-value type)*中被指定，必须表示一个整数，浮点数，字符串，或者一个字符。特别是*原始值类型(raw-value type)*必需遵守`Equatable`类型的协议和下列形式中的一种字面量构造协议(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮点行字面量有`FloatingPointLiteralConvertible`，包含任意数量字符的字符串型字面量有`StringLiteralConvertible`，仅包含一个单一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。每一个事件必须有唯一的名字，必须有一个唯一的初始值。
-
+在这种形式中，每一个事件块由`case`关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做*原始值(raw value)*。这些值的类型在*原始值类型(raw-value type)*中被指定，必须表示一个整数，浮点数，字符串，或者一个字符。特别是*原始值类型(raw-value type)*必需遵守`Equatable`类型的协议和下列形式中的一种字面量构造协议(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮点行字面量有`FloatingPointLiteralConvertible`，包含任意数量字符的字符串型字面量有`StringLiteralConvertible`，仅包含一个单一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。每一个事件必须有唯一的名字，必须有一个唯一的初始值。
+
 如果初始值类型被指定为`Int`，则不必为事件显式的指定值，它们会隐式的被标为值`0,1,2`等。每一个没有被赋值的`Int`类型时间会隐式的赋予一个初始值，它们是自动递增的。
 
 ```Swift
@@ -529,44 +533,44 @@ num ExampleEnum: Int {
 }
 ```
 
-在上面的例子中，`ExampleEnum.A`的值是`0`，`ExampleEnum.B`的值是`1`。因为`ExampleEnum.C`的值被显式的设定为`5`，因此`ExampleEnum.D`的值会自动增长为`6`。
-
-如果原始值类型被指定为`String`类型，你不用明确的为事件指定值，每一个没有指定的事件会隐式地用与事件名字相同的字符串指定。
-
-> enum WeekendDay: String {
-> 		case Saturday, Sunday
-> }
-
-在上面这个例子中，`WeekendDay.Saturday`的原始值是`"Saturday"`,`WeekendDay.Sunday`的原始值是`"Sunday"`。
-
+在上面的例子中，`ExampleEnum.A`的值是`0`，`ExampleEnum.B`的值是`1`。因为`ExampleEnum.C`的值被显式的设定为`5`，因此`ExampleEnum.D`的值会自动增长为`6`。
+
+如果原始值类型被指定为`String`类型，你不用明确的为事件指定值，每一个没有指定的事件会隐式地用与事件名字相同的字符串指定。
+
+> enum WeekendDay: String {
+> 		case Saturday, Sunday
+> }
+
+在上面这个例子中，`WeekendDay.Saturday`的原始值是`"Saturday"`,`WeekendDay.Sunday`的原始值是`"Sunday"`。
+
 拥有多种事件的原始值类型的枚举含蓄地遵循定义在Swift标准库中的`RawRepresentable`协议。所以，它们拥有一个原始值(`rawValue`)属性和一个有着`init?(rawValue: RawValue)`签名的可失败构造器(a failable initializer)。可以使用原始值属性去取的枚举事件的原始值，就像在`ExampleEnum.B.rawValue`中一样。如果有一个事件符合，也可以使用原始值去找到一个符合的事件，通过调用枚举的可失败构造器，如`ExampleEnum(rawValue: 5)`,这个可失败构造器返回一个可选的事件。想得到更多的信息和关于原始值类型查看更多信息和获取初始值类型事件的信息，参阅初始值[原始值(Raw Values)](TODO)。
-
+
 <a name="accessing_enumeration_cases"></a>
 ###获得枚举事件
 
 使用点(.)来引用枚举类型的事件，如`EnumerationType.EnumerationCase`。当枚举类型可以上下文推断出时，可以省略它(.仍然需要)，参照枚举语法[(Enumeration Syntax)](TODO)和[显式成员表达(Implicit Member Expression)](TODO)。
 
 使用`switch`语句来检验枚举事件的值，正如使用[switch语句匹配枚举值（Matching Enumeration Values with a Switch Statement)](TODO)一节描述的那样。枚举类型是模式匹配(pattern-matched)的，和其相反的是`switch`语句case块中枚举事件匹配，在[枚举事件类型(Enumeration Case Pattern)](TODO)中有描述。
-
+
 <a name="grammer_of_an_enumeration_declaration"></a>
-> 枚举声明语法 
-> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO) 
-> *枚举声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO)  _可选_ [*原始值式枚举*](..\chapter3\05_Declarations.html#raw_value_style_enum) 
-> *联合式枚举* → **indirect** _可选_ **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [类型继承子句](TODO)_可选_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
-> *union-style-enum-members* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_  
-> *union-style-enum-member* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case子句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)  
-> *联合式(Union Style)的枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **indirect** _可选_ **case** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
-> *联合式(Union Style)的枚举case列表* → [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
-> *联合式(Union Style)的case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组类型*](..\chapter3\03_Types.html#tuple_type) _可选_  
+> 枚举声明语法 
+> *枚举声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ [*联合式枚举*](TODO) 
+> *枚举声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO)  _可选_ [*原始值式枚举*](../chapter3/05_Declarations.html#raw_value_style_enum) 
+> *联合式枚举* → **indirect** _可选_ **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [类型继承子句](TODO)_可选_ **{** [*union-style-enum-members*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}**  
+> *union-style-enum-members* → [*union-style-enum-member*](../chapter3/05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_  
+> *union-style-enum-member* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case子句*](../chapter3/05_Declarations.html#union_style_enum_case_clause)  
+> *联合式(Union Style)的枚举case子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **indirect** _可选_ **case** [*联合式(Union Style)的枚举case列表*](../chapter3/05_Declarations.html#union_style_enum_case_list)  
+> *联合式(Union Style)的枚举case列表* → [*联合式(Union Style)的case*](../chapter3/05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的case*](../chapter3/05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举case列表*](../chapter3/05_Declarations.html#union_style_enum_case_list)  
+> *联合式(Union Style)的case* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组类型*](../chapter3/03_Types.html#tuple_type) _可选_  
 > *枚举名* → [*标识符*](LexicalStructure.html#identifier)  
 > *枚举的case名* → [*标识符*](LexicalStructure.html#identifier)  
-> *原始值式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](TODO) **{** [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) **}**  
-> *原始值式枚举成员列表* → [*原始值式枚举成员*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_  
-> *原始值式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚举case子句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)  
-> *原始值式枚举case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
-> *原始值式枚举case列表* → [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
-> *原始值式枚举case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*原始值赋值*](..\chapter3\05_Declarations.html#raw_value_assignment) _可选_  
-> *原始值赋值* → **=** [*原始值字面量*](TODO)  
+> *原始值式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](TODO) **{** [*原始值式枚举成员列表*](../chapter3/05_Declarations.html#raw_value_style_enum_members) **}**  
+> *原始值式枚举成员列表* → [*原始值式枚举成员*](../chapter3/05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员列表*](../chapter3/05_Declarations.html#raw_value_style_enum_members) _可选_  
+> *原始值式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*原始值式枚举case子句*](../chapter3/05_Declarations.html#raw_value_style_enum_case_clause)  
+> *原始值式枚举case子句* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case列表*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list)  
+> *原始值式枚举case列表* → [*原始值式枚举case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case列表*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list)  
+> *原始值式枚举case* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*原始值赋值*](../chapter3/05_Declarations.html#raw_value_assignment) _可选_  
+> *原始值赋值* → **=** [*原始值字面量*](TODO)  
 > *原始值字面量* → [数字型字面量](TODO)|[字符串型字面量](TODO)|[布尔型字面量](TODO)
 
 <a name="structure_declaration"></a>
@@ -598,12 +602,12 @@ num ExampleEnum: Int {
 [结构体和枚举是值类型(Structures and Enumerations Are Value Types)](TODO)一节。
 
 可以使用扩展声明来扩展结构体类型的行为，参见[扩展声明(Extension Declaration)](TODO)。
-
+
 <a name="grammer_of_a_structure_declaration"></a>
 > 结构体声明语法  
-> *结构体声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [访问级别修饰符](TODO )_可选_ **struct** [*结构体名称*](..\chapter3\05_Declarations.html#struct_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](..\chapter3\05_Declarations.html#struct_body)  
+> *结构体声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [访问级别修饰符](TODO )_可选_ **struct** [*结构体名称*](../chapter3/05_Declarations.html#struct_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](../chapter3/05_Declarations.html#struct_body)  
 > *结构体名称* → [*标识符*](LexicalStructure.html#identifier)  
-> *结构体主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *结构体主体* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**  
 
 <a name="class_declaration"></a>
 ##类声明
@@ -620,8 +624,8 @@ num ExampleEnum: Int {
 
 正如在[初始化声明(Initializer Declaration)](TODO)谈及的那样，类可以有指定构造器和方便构造器。类的指定构造器必须初始化类所有的已声明的属性，它必须在超类构造器调用前被执行。
 
-类可以重写属性，方法，下表脚本和它的超类构造器。重写的属性，方法，下标脚本，和指定构造器必须以`override`声明修饰符标记。
-
+类可以重写属性，方法，下表脚本和它的超类构造器。重写的属性，方法，下标脚本，和指定构造器必须以`override`声明修饰符标记。
+
 为了要求子类去实现超类的构造器，使用`required`声明修饰符去标记超类的构造器。在子类实现父类构造器时也必须使用`required`声明修饰符去标记。
 
 虽然*超类(superclass)*的属性和方法声明可以被当前类继承，但是*超类(superclass)*声明的指定构造器却不能。这意味着，如果当前类重写了超类的所有指定构造器，它就继承了超类的方便构造器。Swift的类并不是继承自一个全局基础类。
@@ -629,7 +633,7 @@ num ExampleEnum: Int {
 有两种方法来创建已声明的类的实例：
 
 * 调用类的一个构造器，参见[构造器(Initializers)](TODO)。
-
+
 * 如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见[默认构造器(Default Initializers)](TODO)。
 
 类实例属性可以用点(.)来获得，详情参见[获得属性(Accessing Properties)](TODO)一节。
@@ -637,12 +641,12 @@ num ExampleEnum: Int {
 类是引用类型；当被赋予常量或变量，函数调用时，类的实例是被引用，而不是复制。获得更多关于引用类型的信息，[结构体和枚举都是值类型(Structures and Enumerations Are Value Types)](TODO)一节。
 
 可以使用扩展声明来扩展类的行为，参见[扩展声明(Extension Declaration)](TODO)。
-
+
 <a name="grammer_of_a_class_declaration"></a>
 > 类声明语法  
-> *类声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [访问级别修饰符](TODO)**class** [*类名*](..\chapter3\05_Declarations.html#class_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类主体*](..\chapter3\05_Declarations.html#class_body)  
+> *类声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [访问级别修饰符](TODO)**class** [*类名*](../chapter3/05_Declarations.html#class_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承子句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类主体*](../chapter3/05_Declarations.html#class_body)  
 > *类名* → [*标识符*](LexicalStructure.html#identifier)  
-> *类主体* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *类主体* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**  
 
 <a name="protocol_declaration"></a>
 ##协议声明(translated by 小一)
@@ -664,14 +668,14 @@ num ExampleEnum: Int {
 
 默认地，符合某一个协议的类型必须实现所有声明在协议中的属性、方法和下标脚本。也就是说，可以用`optional`声明修饰符标注这些协议成员声明以指定它们的一致性类型实现是可选的。`optional`修饰符仅仅可以用于使用`objc`属性标记过的协议。这样的结果就是仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用`optional`属性的信息及如何访问可选协议成员的指导——比如当不能肯定是否一致性的类型实现了它们——参见[可选协议要求(Optional Protocol Requirements)](../chapter2/21_Protocols.html#optional_protocol_requirements)
 
-为了限制协议的采用仅仅针对类类型，需要强制使用`class`来标记协议，通过将`class`关键在写在冒号后面的*继承协议列表(inherited protocols)*的第一个位置。例如，下面的协议形式只能被类类型采用：
-
-```swift
-protocol SomeProtocol:class{
-	/* Protocol member go here */
-}
-```
-
+为了限制协议的采用仅仅针对类类型，需要强制使用`class`来标记协议，通过将`class`关键在写在冒号后面的*继承协议列表(inherited protocols)*的第一个位置。例如，下面的协议形式只能被类类型采用：
+
+```swift
+protocol SomeProtocol:class{
+	/* Protocol member go here */
+}
+```
+
 任意继承自需要标记有`class`协议的协议都可以智能地仅能被类类型采用。
 
 >注意：  
@@ -680,18 +684,18 @@ protocol SomeProtocol:class{
 协议是命名的类型，因此它们可以以另一个命名类型出现在代码的所有地方，就像[协议类型(Protocol as Types)](../chapter2/21_Protocols.html#protocols_as_types)里讨论的那样。然而不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。
 
 可以使用协议来声明一个类的代理的方法或者应该实现的结构，就像[委托(代理)模式(Delegation)](../chapter2/21_Protocols.html#delegation)描述的那样。
-
+
 <a name="grammer_of_a_protocol_declaration"></a>
 > 协议(Protocol)声明语法  
-> *协议声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ **protocol** [*协议名*](..\chapter3\05_Declarations.html#protocol_name) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](..\chapter3\05_Declarations.html#protocol_body)  
+> *协议声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修饰符*](TODO) _可选_ **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承子句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body)  
 > *协议名* → [*标识符*](LexicalStructure.html#identifier)  
-> *协议主体* → **{** [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_ **}**  
-> *协议成员声明* → [*协议属性声明*](..\chapter3\05_Declarations.html#protocol_property_declaration)  
-> *协议成员声明* → [*协议方法声明*](..\chapter3\05_Declarations.html#protocol_method_declaration)  
-> *协议成员声明* → [*协议构造器声明*](..\chapter3\05_Declarations.html#protocol_initializer_declaration)  
-> *协议成员声明* → [*协议附属脚本声明*](..\chapter3\05_Declarations.html#protocol_subscript_declaration)  
-> *协议成员声明* → [*协议关联类型声明*](..\chapter3\05_Declarations.html#protocol_associated_type_declaration)  
-> *协议成员声明(Declarations)列表* → [*协议成员声明*](..\chapter3\05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_  
+> *协议主体* → **{** [*协议成员声明(Declarations)列表*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ **}**  
+> *协议成员声明* → [*协议属性声明*](../chapter3/05_Declarations.html#protocol_property_declaration)  
+> *协议成员声明* → [*协议方法声明*](../chapter3/05_Declarations.html#protocol_method_declaration)  
+> *协议成员声明* → [*协议构造器声明*](../chapter3/05_Declarations.html#protocol_initializer_declaration)  
+> *协议成员声明* → [*协议附属脚本声明*](../chapter3/05_Declarations.html#protocol_subscript_declaration)  
+> *协议成员声明* → [*协议关联类型声明*](../chapter3/05_Declarations.html#protocol_associated_type_declaration)  
+> *协议成员声明(Declarations)列表* → [*协议成员声明*](../chapter3/05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)列表*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_  
 
 <a name="protocol_property_declaration"></a>
 ###协议属性声明
@@ -705,11 +709,11 @@ protocol SomeProtocol:class{
 `getter`和`setter`要求可以通过一致性类型以各种方式满足。如果属性声明包含`get`和`set`关键词，一致性类型就可以用可读写（实现了`getter`和`setter`）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含`get`关键词的话，它可以作为任意类型的属性被实现。比如说实现了协议的属性要求的一致性类型，参见[属性要求(Property Requirements)](../chapter2/21_Protocols.html#property_requirements)
 
 更多参见[变量声明(Variabel Declaration)](../chapter3/05_Declarations.html#variable_declaration)
-
+
 <a name="grammer_of_an_import_declaration"></a>
 > 协议属性声明语法  
-> *协议属性声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型标注*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-
+> *协议属性声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型标注*](../chapter3/03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)  
+
 <a name="protocol_method_declaration"></a>
 ###协议方法声明
 
@@ -718,27 +722,27 @@ protocol SomeProtocol:class{
 使用`static`声明修饰符可以在协议声明中声明一个类或必需的静态方法。执行这些方法的类用修饰符`class`声明。相反的，执行这些方法的结构体必须以`static`声明修饰符声明。如果想使用扩展方法，在扩展类时使用`class`修饰符，在扩展结构体时使用`static`修饰符。
 
 更多请参阅[函数声明(Function Declaration)](TODO)。
-
+
 <a name="grammer_of_a_protocol_declaration"></a>
 > 协议方法声明语法  
-> *协议方法声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature)  
-
+> *协议方法声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature)  
+
 <a name="protocol_initializer_declaration"></a>
 ###协议构造器声明
 
 协议声明了一致性类型必须在协议声明的主体里通过引入一个协议构造器声明来实现一个构造器。协议构造器声明
-除了不包含构造器体外，和构造器声明有着相同的形式。
-
-一个一致性类型可以通过实现一个非可失败构造器或者`init!`可失败构造器去满足一个非可失败协议构造器的需求。一个一致性类型通过实现任意类型的构造器可以满足一个可失败协议构造器的需求。
-
-当一个类去实现一个构造器去满足一个协议的构造器的需求，如果这个类还没有用`final`声明修饰符标记，这个构造器必需使用`required`声明修饰符去标记。
+除了不包含构造器体外，和构造器声明有着相同的形式。
+
+一个一致性类型可以通过实现一个非可失败构造器或者`init!`可失败构造器去满足一个非可失败协议构造器的需求。一个一致性类型通过实现任意类型的构造器可以满足一个可失败协议构造器的需求。
+
+当一个类去实现一个构造器去满足一个协议的构造器的需求，如果这个类还没有用`final`声明修饰符标记，这个构造器必需使用`required`声明修饰符去标记。
 
 更多请参阅[构造器声明(Initializer Declaration)](TODO)。
-
+
 <a name="grammer_of_a_protocol_initializer_declaration"></a>
 > 协议构造器声明语法  
-> *协议构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)  
-
+> *协议构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](../chapter3/05_Declarations.html#parameter_clause)  
+
 <a name="protocol_subscript_declaration"></a>
 ###协议下标脚本声明
 
@@ -749,19 +753,19 @@ protocol SomeProtocol:class{
 下标脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果下标脚本申明包含get和set关键字，一致的类型也必须有一个getter和setter语句。如果下标脚本声明值包含get关键字，一致的类型必须*至少(at least)*包含一个getter语句，可以选择是否包含setter语句。
 
 更多参阅[下标脚本声明(Subscript Declaration)](TODO)。
-
+
 <a name="grammer_of_a_protocol_subscript_declaration"></a>
 > 协议附属脚本声明语法  
-> *协议附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-
+> *协议附属脚本声明* → [*附属脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)  
+
 <a name="protocol_associated_type_declaration"></a>
 ###协议相关类型声明
 
 协议声明相关类型使用关键字`typealias`。相关类型为作为协议声明的一部分的类型提供了一个别名。相关类型和参数语句中的类型参数很相似，但是它们在声明的协议中包含`self`关键字。在这些语句中，`self`指代和协议一致的可能的类型。获得更多信息和例子，查看[关联类型(Associated Types)](TODO)一节或[类型别名声明(Type Alias Declaration)](TODO)一节。
-
+
 <a name="grammer_of_a_protocol_associated_type_declaration"></a>
 > 协议关联类型声明语法  
-> *协议关联类型声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment) _可选_  
+> *协议关联类型声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型继承子句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) _可选_  
 
 <a name="initializer_declaration"></a>
 ##构造器声明
@@ -791,64 +795,64 @@ protocol SomeProtocol:class{
 便利构造器可以将初始化过程委托给另一个便利构造器或类的一个指定构造器。这意味着，类的初始化过程必须
 以一个将所有类属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。
 
-可以使用required声明修饰符，将便利构造器和指定构造器标记为每个子类的构造器都必须实现的。一个子类的关于这个构造器的实现也必须使用`required`声明修饰符标记。
-
-默认情况下，声明在超类的构造器没有被子类继承。也就是说，如果一个子类使用默认的值去构造它所有的存储属性，而且没有定义任何自己的构造器，它将继承超类的构造器。如果子类重写所有超类的指定构造器，子类继承超类的便利构造器。
-
-和方法，属性和下表脚本一样，需要使用`override`声明修饰符标记重写了的制定构造器。
-
->注意
+可以使用required声明修饰符，将便利构造器和指定构造器标记为每个子类的构造器都必须实现的。一个子类的关于这个构造器的实现也必须使用`required`声明修饰符标记。
+
+默认情况下，声明在超类的构造器没有被子类继承。也就是说，如果一个子类使用默认的值去构造它所有的存储属性，而且没有定义任何自己的构造器，它将继承超类的构造器。如果子类重写所有超类的指定构造器，子类继承超类的便利构造器。
+
+和方法，属性和下表脚本一样，需要使用`override`声明修饰符标记重写了的制定构造器。
+
+>注意
 >如果使用`required`声明修饰符去标记一个构造器，当在子类中重写必要构造器时，也不要用`override`修饰符去标记构造器。
 
-查看更多关于不同声明方法的构造器的例子，参阅[构造过程(Initialization)](TODO)一节。
-
-<a name="failable_initializers"></a>
-###可失败构造器(Failable Initializers)
-
-*可失败构造器*是一种可以生成可选实例或者是一类构造器声明的隐式解析可选实例(an implicitly unwrapped optional instance)类型。所以，构造区通过返回`nil`来指明构造过程失败。
-
-声明可以生成可选实例的可失败构造器，在构造器声明的`init`关键字后加追加一个问号(`init?`)。声明可生成隐式解析可选实例的可失败构造器，在构造器声明后追加一个叹号(`init!`)。使用`init?`可失败构造器生成结构体的一个可选实例的例子如下。
-
-```swift
-struct SomeStruct {
-	let string: String
-	//生成一个'SomeStruct'的可选实例
-	init?(input: String) {
-		if input.isEmpty {
-			// 弃用'self' 返回 'nil'
-		}
-		string = input
-	}
-}
-```
-
-除非必需处理结果的可选性，可以使用调用非可失败构造器的方式调用`init?`可失败构造器。
-
-```swift
-if let actualInstance = SomeStruct(input: "Hello") {
-	//'SomeStruct'实例相关
-} else {
-	//'SomeStruct'实例构造过程失败，构造器返回'nil'
-}
-```
+查看更多关于不同声明方法的构造器的例子，参阅[构造过程(Initialization)](TODO)一节。
+
+<a name="failable_initializers"></a>
+###可失败构造器(Failable Initializers)
+
+*可失败构造器*是一种可以生成可选实例或者是一类构造器声明的隐式解析可选实例(an implicitly unwrapped optional instance)类型。所以，构造区通过返回`nil`来指明构造过程失败。
+
+声明可以生成可选实例的可失败构造器，在构造器声明的`init`关键字后加追加一个问号(`init?`)。声明可生成隐式解析可选实例的可失败构造器，在构造器声明后追加一个叹号(`init!`)。使用`init?`可失败构造器生成结构体的一个可选实例的例子如下。
+
+```swift
+struct SomeStruct {
+	let string: String
+	//生成一个'SomeStruct'的可选实例
+	init?(input: String) {
+		if input.isEmpty {
+			// 弃用'self' 返回 'nil'
+		}
+		string = input
+	}
+}
+```
+
+除非必需处理结果的可选性，可以使用调用非可失败构造器的方式调用`init?`可失败构造器。
+
+```swift
+if let actualInstance = SomeStruct(input: "Hello") {
+	//'SomeStruct'实例相关
+} else {
+	//'SomeStruct'实例构造过程失败，构造器返回'nil'
+}
+```
+
+在实现构造体的任何时间，结构体或者枚举的可失败构造器可以返回`nil`。然而，类的可失败构造器，仅在类的所有存储属性被构造之后且`self.init`或`super.init`被调用之后才返回`nil`（就是说，构造器的委托被执行）。
+
+可失败构造器可以委托任何种类的构造器。非可失败可以委托其它非可失败构造器或者`init!`可失败构造器。
+
+构造过程的失败由构造器的委托产生。特别的，如果可失败构造器代理一个构造器失败且返回`nil`，那么之后被委托的构造器也会失败且隐式的返回`nil`。如果非可失败构造器代理`init!`可失败构造器失败了且返回`nil`，那么后出现一个运行时错误（如同使用`!`操作符去解析一个有着`nil`值的可选项）。
+
+可失败指定构造器可以在子类中任何一种指定构造器重写。非可失败指定构造器在子类中仅能通过非可失败构造器被重写。
+
+得到更多的信息并且了解更多关于可失败构造器的例子，请参阅[可失败构造器(Failable Initializer)](TODO)
 
-在实现构造体的任何时间，结构体或者枚举的可失败构造器可以返回`nil`。然而，类的可失败构造器，仅在类的所有存储属性被构造之后且`self.init`或`super.init`被调用之后才返回`nil`（就是说，构造器的委托被执行）。
-
-可失败构造器可以委托任何种类的构造器。非可失败可以委托其它非可失败构造器或者`init!`可失败构造器。
-
-构造过程的失败由构造器的委托产生。特别的，如果可失败构造器代理一个构造器失败且返回`nil`，那么之后被委托的构造器也会失败且隐式的返回`nil`。如果非可失败构造器代理`init!`可失败构造器失败了且返回`nil`，那么后出现一个运行时错误（如同使用`!`操作符去解析一个有着`nil`值的可选项）。
-
-可失败指定构造器可以在子类中任何一种指定构造器重写。非可失败指定构造器在子类中仅能通过非可失败构造器被重写。
-
-得到更多的信息并且了解更多关于可失败构造器的例子，请参阅[可失败构造器(Failable Initializer)](TODO)
-
 <a name="grammer_of_an_initializer_declaration"></a>
 > 构造器声明语法  
-> *构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause) [*构造器主体*](..\chapter3\05_Declarations.html#initializer_body)  
-> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init**       
-> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init ?**           
-> *构造器头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init !** 
-> *构造器主体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数子句*](../chapter3/05_Declarations.html#parameter_clause) [*构造器主体*](../chapter3/05_Declarations.html#initializer_body)  
+> *构造器头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init**       
+> *构造器头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init ?**           
+> *构造器头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(modifiers)*](TODO) _可选_ **init !** 
+> *构造器主体* → [*代码块*](../chapter3/05_Declarations.html#code_block)  
 
 <a name="deinitializer_declaration"></a>
 ##析构声明
@@ -867,10 +871,10 @@ if let actualInstance = SomeStruct(input: "Hello") {
 析构器不会被直接调用。
 
 查看例子和如何在类的声明中使用析构器，参见[析构过程Deinitialization](TODO)一节。
-
+
 <a name="grammer_of_a_deinitializer_declaration"></a>
 > 析构器声明语法  
-> *析构器声明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *析构器声明* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](../chapter3/05_Declarations.html#code_block)  
 
 <a name="extension_declaration"></a>
 ##扩展声明
@@ -889,15 +893,15 @@ if let actualInstance = SomeStruct(input: "Hello") {
 
 扩展声明可以包含构造器声明，这意味着，如果扩展的类型在其他模块中定义，构造器声明必须委托另一个在
 那个模块里声明的构造器来恰当的初始化。
-
+
 <a name="grammer_of_an_extension_declaration"></a>
 > 扩展(Extension)声明语法  
-> *扩展声明* → [访问级别修饰符](TODO) _可选_ **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)  
-> *extension-body* → **{** [*声明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *扩展声明* → [访问级别修饰符](TODO) _可选_ **extension** [*类型标识*](../chapter3/03_Types.html#type_identifier) [*类型继承子句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](../chapter3/05_Declarations.html#extension_body)  
+> *extension-body* → **{** [*声明(Declarations)列表*](../chapter3/05_Declarations.html#declarations) _可选_ **}**  
 
 <a name="subscript_declaration"></a>
 ##下标脚本声明
-
+
 *下标脚本(subscript)*声明用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字`subscript`，声明形式如下：
 
 > subscript (`parameter`) -> (return type){  
@@ -922,22 +926,22 @@ if let actualInstance = SomeStruct(input: "Hello") {
 同样可以在协议声明的上下文中声明下标脚本，[协议下标脚本声明(Protocol Subscript Declaration)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_619)中有所描述。
 
 更多关于下标脚本和下标脚本声明的例子，请参考[下标脚本(Subscripts)](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Subscripts.html#//apple_ref/doc/uid/TP40014097-CH16-XID_393)。
-
+
 <a name="grammer_of_a_subscript_declaration"></a>
 > 附属脚本声明语法  
-> *附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
-> *附属脚本声明* → [*附属脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-> *附属脚本头(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修饰符列表(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数子句*](..\chapter3\05_Declarations.html#parameter_clause)  
-> *附属脚本结果(Result)* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)   
+> *附属脚本声明* → [*附属脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *附属脚本声明* → [*附属脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter块*](../chapter3/05_Declarations.html#getter_setter_block)  
+> *附属脚本声明* → [*附属脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*附属脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)  
+> *附属脚本头(Head)* → [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修饰符列表(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数子句*](../chapter3/05_Declarations.html#parameter_clause)  
+> *附属脚本结果(Result)* → **->** [*特性(Attributes)列表*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)   
 
 <a name="operator_declaration"></a>
 ##运算符声明(translated by 林)
 
 *运算符声明(operator declaration)*会向程序中引入中缀、前缀或后缀运算符，它使用关键字`operator`声明。
-
+
 可以声明三种不同的缀性：中缀、前缀和后缀。操作符的*缀性(fixity)*描述了操作符与它的操作数的相对位置。
-
+
 运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在`operator`关键字之前添加声明修饰符`infix`，`prefix`或`postfix`来指定。每种形式中，运算符的名字只能包含[运算符(Operators)](TODO)中定义的运算符字符。
 
 下面的这种形式声明了一个新的中缀运算符：
@@ -973,17 +977,17 @@ if let actualInstance = SomeStruct(input: "Hello") {
 和前缀运算符一样，后缀运算符的声明中不指定优先级。后缀运算符是非结合的。
 
 声明了一个新的运算符以后，需要声明一个跟这个运算符同名的函数来实现这个运算符。如果在实现一个前缀或者后缀操作符，也必须使用相符的`prefix`或者`postfix`声明修饰符标记函数声明。如果实现中缀操作符，不需要使用`infix`声明修饰符标记函数声明。如何实现一个新的运算符，请参考[Custom Operators](TODO)。
-
+
 <a name="grammer_of_an_operator_declaration"></a>
 > 运算符声明语法  
-> *运算符声明* → [*前置运算符声明*](..\chapter3\05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](..\chapter3\05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](..\chapter3\05_Declarations.html#infix_operator_declaration)  
+> *运算符声明* → [*前置运算符声明*](../chapter3/05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](../chapter3/05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](../chapter3/05_Declarations.html#infix_operator_declaration)  
 > *前置运算符声明* → **prefix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}**  
 > *后置运算符声明* → **postfix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** **}**  
-> *中置运算符声明* → **infix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}**  
-> *中置运算符属性* → [*优先级子句*](..\chapter3\05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](..\chapter3\05_Declarations.html#associativity_clause) _可选_  
-> *优先级子句* → **precedence** [*优先级水平*](..\chapter3\05_Declarations.html#precedence_level)  
+> *中置运算符声明* → **infix** **运算符** [*运算符*](LexicalStructure.html#operator) **{** [*中置运算符属性*](../chapter3/05_Declarations.html#infix_operator_attributes) _可选_ **}**  
+> *中置运算符属性* → [*优先级子句*](../chapter3/05_Declarations.html#precedence_clause) _可选_ [*结和性子句*](../chapter3/05_Declarations.html#associativity_clause) _可选_  
+> *优先级子句* → **precedence** [*优先级水平*](../chapter3/05_Declarations.html#precedence_level)  
 > *优先级水平* → 十进制整数 0 到 255  
-> *结和性子句* → **associativity** [*结和性*](..\chapter3\05_Declarations.html#associativity)  
+> *结和性子句* → **associativity** [*结和性*](../chapter3/05_Declarations.html#associativity)  
 > *结和性* → **left** | **right** | **none**  
 
 
@@ -1017,7 +1021,7 @@ if let actualInstance = SomeStruct(input: "Hello") {
 `weak`
 
 `weak`修饰符用于修饰一个变量或一个存储型变量属性，表示该变量或属性通过一个弱引用指向存储其值的对象。该变量或属性的类型必须是一个可选类类型。通过`weak`修饰符可避免强引用循环。关于`weak`修饰符的例子和更多信息，可以参见[弱引用(Weak References)](TODO)一章
-
+
 <a name="access_control_levels"></a>
 ### 访问控制级别
 
@@ -1038,7 +1042,7 @@ Swift提供了三个级别的权限控制：`public`, `internal`, 和 `private`
 
 
 以上的任意一个权限级别修饰符都可以有选择的带上一个参数，该参数由关键字`set`和一对括号组成（比如，`private(set)`）。当想要指明一个变量或下标脚注的setter的访问级别要低于或等于该变量或下标脚注的实际访问级别时，使用这种格式的权限级别修饰符，就像[Getters and Setters](TODO)一章中讨论的一样。
-
+
 <a name="grammer_of_a_declaration_modifier"></a>
 >声明修饰符的语法
 
@@ -1050,7 +1054,7 @@ Swift提供了三个级别的权限控制：`public`, `internal`, 和 `private`
 >
 >访问级别修饰符 → **private­** | **private­(­set­)­**
 >
->访问级别修饰符 → **public­** | **public­(­set­)­**
->
+>访问级别修饰符 → **public­** | **public­(­set­)­**
+>
 >访问级别修饰符 → [访问级别修饰符(access-level-modeifier)](TODO) [访问级别修饰符列表(access-level-modeifiers)](TODO) _可选_
 ­
\ No newline at end of file
diff --git a/source/chapter3/06_Attributes.md b/source/chapter3/06_Attributes.md
index 603f8cf2..abf128e1 100755
--- a/source/chapter3/06_Attributes.md
+++ b/source/chapter3/06_Attributes.md
@@ -1,5 +1,9 @@
+> 1.0
 > 翻译：[Hawstein](https://github.com/Hawstein)  
-> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai), [KYawn](https://github.com/KYawn)
+> 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
+
+> 2.0
+> 翻译+校对：[KYawn](https://github.com/KYawn)
 
 # 特性
 -----------------
@@ -25,7 +29,7 @@
 
 `autoclosure`
 
-这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以声明返回表达式自身类型的没有参数的方法类型，也可以用于函数参数的声明。含有`autoclosure`特性的声明同时也具有`noescape`的特性，除非传递可选参数`escaping`.关于怎样使用`autoclosure`特性的例子，参见[函数类型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/doc/uid/TP40014097-CH31-ID449).
+这个特性通过把表达式自动封装成无参数的闭包来延迟表达式的计算。它可以声明返回表达式自身类型的没有参数的方法类型，也可以用于函数参数的声明。含有`autoclosure`特性的声明同时也具有`noescape`的特性，除非传递可选参数`escaping`.关于怎样使用`autoclosure`特性的例子，参见[函数类型](./03_Types.html#function_type).
 
 `available`
 
diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index fb93956d..9985000c 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -1,6 +1,10 @@
-> 翻译：[honghaoz](https://github.com/honghaoz), [ray16897188](https://github.com/ray16897188)  
+> 1.0
+> 翻译：[honghaoz](https://github.com/honghaoz)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
+> 2.0
+> 翻译+校对：[ray16897188](https://github.com/ray16897188)  
+
 # 模式（Patterns）
 -----------------
 
@@ -24,14 +28,14 @@ swift语言中模式有2个基本的分类：一类能成功和任何值的类
 第二类模式用于全模式匹配，这种情况下你用来相比较的值在运行时可能还不存在。此类模式包括枚举用例模式（enumeration case patterns），可选模式（optional patterns），表达式模式（expression patterns）和类型转换模式（type-casting patterns）。你在`switch`语句的case标签中，`do`语句的`catch`从句中，或者在`if, while, guard`和`for-in`语句的case条件句中使用这类模式。
 
 > 模式(Patterns) 语法  
-> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_  
-> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可选_  
-> *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)  
-> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型标注*](..\chapter3\03_Types.html#type_annotation) _可选_  
-> *模式* → [*枚举用例模式*](..\chapter3\07_Patterns.html#enum_case_pattern)  
-> *模式* → [*可选模式*](..\chapter3\07_Patterns.html#optional_pattern)  
-> *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern)  
-> *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)  
+> *模式* → [*通配符模式*](../chapter3/07_Patterns.html#wildcard_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_  
+> *模式* → [*标识符模式*](../chapter3/07_Patterns.html#identifier_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotati(Value Binding)on) _可选_  
+> *模式* → [*值绑定模式*](../chapter3/07_Patterns.html#value_binding_pattern)  
+> *模式* → [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) [*类型标注*](../chapter3/03_Types.html#type_annotation) _可选_  
+> *模式* → [*枚举用例模式*](../chapter3/07_Patterns.html#enum_case_pattern)  
+> *模式* → [*可选模式*](../chapter3/07_Patterns.html#optional_pattern)  
+> *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern)  
+> *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern)  
 
 <a name="wildcard_pattern"></a>
 ## 通配符模式（Wildcard Pattern）
@@ -83,7 +87,7 @@ case let (x, y):
 在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。正是由于这么做，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配到的值是一样的。
 
 > 值绑定(Value Binding)模式语法  
-> *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern)  
+> *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../chapter3/07_Patterns.html#pattern)  
 
 <a name="tuple_pattern"></a>
 ## 元组模式（Tuple Pattern）
@@ -111,9 +115,9 @@ let (a): Int = 2 // a: Int = 2
 ```
 
 > 元组模式语法  
-> *元组模式* → **(** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可选_ **)**  
-> *元组模式元素列表* → [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)  
-> *元组模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern)  
+> *元组模式* → **(** [*元组模式元素列表*](../chapter3/07_Patterns.html#tuple_pattern_element_list) _可选_ **)**  
+> *元组模式元素列表* → [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素列表*](../chapter3/07_Patterns.html#tuple_pattern_element_list)  
+> *元组模式元素* → [*模式*](../chapter3/07_Patterns.html#pattern)  
 
 <a name="enumeration_case_pattern"></a>
 ## 枚举用例模式（Enumeration Case Pattern）
@@ -123,7 +127,7 @@ let (a): Int = 2 // a: Int = 2
 如果你准备匹配的枚举用例有任何关联的值，则相应的枚举用例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举用例的例子，请参阅`Associated Values`.
 
 > 枚举用例模式语法  
-> *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_  
+> *enum-case-pattern* → [*类型标识*](../chapter3/03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) _可选_  
 
 <a name="optional_pattern"></a>
 ## 可选模式（Optional Pattern）
@@ -158,7 +162,7 @@ for case let number? in arrayOfOptinalInts {
 
 ```
 > 可选模式语法  
-> *可选模式* → [*标识符模式*](..\chapter3\03_Types.html#type_identifier) ?
+> *可选模式* → [*标识符模式*](../chapter3/03_Types.html#type_identifier) ?
 
 <a name="type-casting_patterns"></a>
 ## 类型转换模式（Type-Casting Patterns）
@@ -175,9 +179,9 @@ for case let number? in arrayOfOptinalInts {
 关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。
 
 > 类型转换模式语法  
-> *type-casting-pattern* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern)  
-> *is模式* → **is** [*类型*](..\chapter3\03_Types.html#type)  
-> *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*类型*](..\chapter3\03_Types.html#type)  
+> *type-casting-pattern* → [*is模式*](../chapter3/07_Patterns.html#is_pattern) | [*as模式*](../chapter3/07_Patterns.html#as_pattern)  
+> *is模式* → **is** [*类型*](../chapter3/03_Types.html#type)  
+> *as模式* → [*模式*](../chapter3/07_Patterns.html#pattern) **as** [*类型*](../chapter3/03_Types.html#type)  
 
 <a name="expression_pattern"></a>
 ## 表达式模式（Expression Pattern）
@@ -216,4 +220,4 @@ default:
 ```
 
 > 表达式模式语法  
-> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *表达式模式* → [*表达式*](../chapter3/04_Expressions.html#expression)  
diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index 9bb891a4..901ebad2 100755
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -1,5 +1,9 @@
+> 1.0
 > 翻译：[fd5788](https://github.com/fd5788)  
-> 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai), [wardenNScaiyi](https:github.com/wardenNScaiyi)
+> 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
+
+> 2.0
+> 翻译+校对：[wardenNScaiyi](https:github.com/wardenNScaiyi)
 
 # 泛型参数
 ---------
@@ -67,15 +71,15 @@ simpleMax(3.14159, 2.71828) // T被推断出为Double类型
 > 泛型形参子句语法  
 > *泛型参数子句* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list) [*约束子句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**  
 > *泛型参数列表* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_parameter_list)  
-> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name)  
-> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
-> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)  
+> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name)  
+> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
+> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)  
 > *约束子句* → **where** [*约束列表*](GenericParametersAndArguments.html#requirement_list)  
 > *约束列表* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束列表*](GenericParametersAndArguments.html#requirement_list)  
 > *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement)  
-> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
-> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)  
-> *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
+> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
+> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)  
+> *同类型约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **==** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
 
 
 <a name="generic_argument"></a>
@@ -109,4 +113,4 @@ let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 > 泛型实参子句语法  
 > *(泛型参数子句Generic Argument Clause)* → **<** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list) **>**  
 > *泛型参数列表* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数列表*](GenericParametersAndArguments.html#generic_argument_list)  
-> *泛型参数* → [*类型*](..\chapter3\03_Types.html#type)  
+> *泛型参数* → [*类型*](../chapter3/03_Types.html#type)  
diff --git a/source/chapter3/09_Summary_of_the_Grammar.md b/source/chapter3/09_Summary_of_the_Grammar.md
index f6440c63..27d9e630 100755
--- a/source/chapter3/09_Summary_of_the_Grammar.md
+++ b/source/chapter3/09_Summary_of_the_Grammar.md
@@ -1,5 +1,9 @@
+> 1.0
 > 翻译：[stanzhai](https://github.com/stanzhai)  
-> 校对：[xielingwang](https://github.com/xielingwang), [miaosiqi](https://github.com/miaosiqi)
+> 校对：[xielingwang](https://github.com/xielingwang)
+
+> 2.0
+> 翻译+校对：[miaosiqi](https://github.com/miaosiqi)
 
 # 语法总结
 _________________
@@ -19,42 +23,42 @@ _________________
 ## 语句
 
 > 语句语法  
-> *语句* → [*表达式*](..\chapter3\04_Expressions.html#expression) **;** _可选_  
-> *语句* → [*声明*](..\chapter3\05_Declarations.html#declaration) **;** _可选_  
-> *语句* → [*循环语句*](..\chapter3\10_Statements.html#loop_statement) **;** _可选_  
-> *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_  
-> *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)  
-> *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_  
+> *语句* → [*表达式*](../chapter3/04_Expressions.html#expression) **;** _可选_  
+> *语句* → [*声明*](../chapter3/05_Declarations.html#declaration) **;** _可选_  
+> *语句* → [*循环语句*](../chapter3/10_Statements.html#loop_statement) **;** _可选_  
+> *语句* → [*分支语句*](../chapter3/10_Statements.html#branch_statement) **;** _可选_  
+> *语句* → [*标记语句(Labeled Statement)*](../chapter3/10_Statements.html#labeled_statement)  
+> *语句* → [*控制转移语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_  
 > *语句* → [*延迟语句*](TODO) **;** _可选_ 
 
 > *语句* → [*执行语句*](TODO) **;** _可选_ 
 
-> *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_  
+> *多条语句(Statements)* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_  
 
 <!-- -->
 
 > 循环语句语法  
-> *循环语句* → [*for语句*](..\chapter3\10_Statements.html#for_statement)  
-> *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement)  
-> *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement)  
-> *循环语句* → [*repeat-while语句*](..\chapter3\10_Statements.html#do_while_statement)  
+> *循环语句* → [*for语句*](../chapter3/10_Statements.html#for_statement)  
+> *循环语句* → [*for-in语句*](../chapter3/10_Statements.html#for_in_statement)  
+> *循环语句* → [*while语句*](../chapter3/10_Statements.html#wheetatype类型ile_statement)  
+> *循环语句* → [*repeat-while语句*](../chapter3/10_Statements.html#do_while_statement)  
 
 <!-- -->
 
 > For 循环语法  
-> *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *for语句* → **for** **(** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **)** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式集*](..\chapter3\04_Expressions.html#expression_list)  
+> *for语句* → **for** [*for初始条件*](../chapter3/10_Statements.html#for_init) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *for语句* → **for** **(** [*for初始条件*](../chapter3/10_Statements.html#for_init) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **)** [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *for初始条件* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration) | [*表达式集*](../chapter3/04_Expressions.html#expression_list)  
 
 <!-- -->
 
 > For-In 循环语法  
-> *for-in语句* → **for case** _可选_ [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*where从句*](TODO) _可选_
+> *for-in语句* → **for case** _可选_ [*模式*](../chapter3/07_Patterns.html#pattern) **in** [*表达式*](../chapter3/04_Expressions.html#expression) [*代码块*](../chapter3/05_Declarations.html#code_block) [*where从句*](TODO) _可选_
 
 <!-- -->
 
 > While 循环语法  
-> *while语句* → **while** [*条件从句*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *while语句* → **while** [*条件从句*](../chapter3/10_Statements.html#while_condition) [*代码块*](../chapter3/05_Declarations.html#code_block)  
 > *条件从句* → [*表达式*](TODO)
 
 > *条件从句* → [*表达式*](TODO) *,* [*表达式集*]()
@@ -84,18 +88,18 @@ _________________
 <!-- -->
 
 > 分支语句语法  
-> *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement) 
+> *分支语句* → [*if语句*](../chapter3/10_Statements.html#if_statement) 
 
 > *分支语句* → [*guard语句*](TODO)  
 
-> *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement)  
+> *分支语句* → [*switch语句*](../chapter3/10_Statements.html#switch_statement)  
 
 <!-- -->
 
 > If语句语法  
 > *if语句* → **if** [*条件从句*](TODO) [*代码块*](TODO) [*else从句(Clause)*](TODO) _可选_  
  
-> *else从句(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)  
+> *else从句(Clause)* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if语句*](../chapter3/10_Statements.html#if_statement)  
 
 
 <!-- -->
@@ -106,12 +110,12 @@ _________________
 <!-- -->
 
 > Switch语句语法  
-> *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}**  
-> *SwitchCase集* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase集*](..\chapter3\10_Statements.html#switch_cases) _可选_  
-> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default标签*](..\chapter3\10_Statements.html#default_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements)  
-> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) **;** | [*default标签*](..\chapter3\10_Statements.html#default_label) **;**  
-> *case标签* → **case** [*case项集*](..\chapter3\10_Statements.html#case_item_list) **:**  
-> *case项集* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*where-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*where-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项集*](..\chapter3\10_Statements.html#case_item_list)  
+> *switch语句* → **switch** [*表达式*](../chapter3/04_Expressions.html#expression) **{** [*SwitchCase*](../chapter3/10_Statements.html#switch_cases) _可选_ **}**  
+> *SwitchCase集* → [*SwitchCase*](../chapter3/10_Statements.html#switch_case) [*SwitchCase集*](../chapter3/10_Statements.html#switch_cases) _可选_  
+> *SwitchCase* → [*case标签*](../chapter3/10_Statements.html#case_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) | [*default标签*](../chapter3/10_Statements.html#default_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements)  
+> *SwitchCase* → [*case标签*](../chapter3/10_Statements.html#case_label) **;** | [*default标签*](../chapter3/10_Statements.html#default_label) **;**  
+> *case标签* → **case** [*case项集*](../chapter3/10_Statements.html#case_item_list) **:**  
+> *case项集* → [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ | [*模式*](../chapter3/07_Patterns.html#pattern) [*where-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ **,** [*case项集*](../chapter3/10_Statements.html#case_item_list)  
 > *default标签* → **default** **:**  
 > *where从句* → **where** [*where表达式*](TODO)  
 > *where表达式* → [*表达式*](TODO)  
@@ -119,28 +123,28 @@ _________________
 <!-- -->
 
 > 标记语句语法  
-> *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*if语句*](..\chapter3\10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch语句*](TODY) 
-> *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:**  
-> *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *标记语句(Labeled Statement)* → [*语句标签*](../chapter3/10_Statements.html#statement_label) [*循环语句*](../chapter3/10_Statements.html#loop_statement) | [*语句标签*](../chapter3/10_Statements.html#statement_label) [*if语句*](../chapter3/10_Statements.html#switch_statement) | [*语句标签*](TODY) [*switch语句*](TODY) 
+> *语句标签* → [*标签名称*](../chapter3/10_Statements.html#label_name) **:**  
+> *标签名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
 
 <!-- -->
 
 > 控制传递语句(Control Transfer Statement) 语法  
-> *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement)  
-> *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement)  
-> *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement)  
-> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement) 
+> *控制传递语句* → [*break语句*](../chapter3/10_Statements.html#break_statement)  
+> *控制传递语句* → [*continue语句*](../chapter3/10_Statements.html#continue_statement)  
+> *控制传递语句* → [*fallthrough语句*](../chapter3/10_Statements.html#fallthrough_statement)  
+> *控制传递语句* → [*return语句*](../chapter3/10_Statements.html#return_statement) 
 > *控制传递语句* → [*throw语句*](TODO) 
 
 <!-- -->
 
 > Break 语句语法  
-> *break语句* → **break** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_  
+> *break语句* → **break** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_  
 
 <!-- -->
 
 > Continue 语句语法  
-> *continue语句* → **continue** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_  
+> *continue语句* → **continue** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_  
 
 <!-- -->
 
@@ -150,7 +154,7 @@ _________________
 <!-- -->
 
 > Return 语句语法  
-> *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_  
+> *return语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_  
 
 <!-- -->
 >可用条件(Availability Condition)语法
@@ -202,244 +206,244 @@ _________________
 > 泛型形参从句(Generic Parameter Clause) 语法  
 > *泛型参数从句* → **<** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list) [*约束从句*](GenericParametersAndArguments.html#requirement_clause) _可选_ **>**  
 > *泛型参数集* → [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) | [*泛形参数*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型参数集*](GenericParametersAndArguments.html#generic_parameter_list)  
-> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name)  
-> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
-> *泛形参数* → [*类型名称*](..\chapter3\03_Types.html#type_name) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)  
+> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name)  
+> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
+> *泛形参数* → [*类型名称*](../chapter3/03_Types.html#type_name) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)  
 > *约束从句* → **where** [*约束集*](GenericParametersAndArguments.html#requirement_list)  
 > *约束集* → [*约束*](GenericParametersAndArguments.html#requirement) | [*约束*](GenericParametersAndArguments.html#requirement) **,** [*约束集*](GenericParametersAndArguments.html#requirement_list)  
 > *约束* → [*一致性约束*](GenericParametersAndArguments.html#conformance_requirement) | [*同类型约束*](GenericParametersAndArguments.html#same_type_requirement)  
-> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier)  
-> *一致性约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **:** [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type)  
-> *同类型约束* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) **==** [*类型*](..\chapter3\03_Types.html#type_identifier)  
+> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*类型标识*](../chapter3/03_Types.html#type_identifier)  
+> *一致性约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **:** [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type)  
+> *同类型约束* → [*类型标识*](../chapter3/03_Types.html#type_identifier) **==** [*类型*](../chapter3/03_Types.html#type_identifier)  
 
 <!-- -->
 
 > 泛型实参从句语法  
 > *(泛型参数从句Generic Argument Clause)* → **<** [*泛型参数集*](GenericParametersAndArguments.html#generic_argument_list) **>**  
 > *泛型参数集* → [*泛型参数*](GenericParametersAndArguments.html#generic_argument) | [*泛型参数*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型参数集*](GenericParametersAndArguments.html#generic_argument_list)  
-> *泛型参数* → [*类型*](..\chapter3\03_Types.html#type)  
+> *泛型参数* → [*类型*](../chapter3/03_Types.html#type)  
 
 <a name="declarations"></a>
 ## 声明 (Declarations) 
 
 > 声明语法  
-> *声明* → [*导入声明*](..\chapter3\05_Declarations.html#import_declaration)  
-> *声明* → [*常量声明*](..\chapter3\05_Declarations.html#constant_declaration)  
-> *声明* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration)  
-> *声明* → [*类型别名声明*](..\chapter3\05_Declarations.html#typealias_declaration)  
-> *声明* → [*函数声明*](..\chapter3\05_Declarations.html#function_declaration)  
-> *声明* → [*枚举声明*](..\chapter3\05_Declarations.html#enum_declaration)  
-> *声明* → [*结构体声明*](..\chapter3\05_Declarations.html#struct_declaration)  
-> *声明* → [*类声明*](..\chapter3\05_Declarations.html#class_declaration)  
-> *声明* → [*协议声明*](..\chapter3\05_Declarations.html#protocol_declaration)  
-> *声明* → [*构造器声明*](..\chapter3\05_Declarations.html#initializer_declaration)  
-> *声明* → [*析构器声明*](..\chapter3\05_Declarations.html#deinitializer_declaration)  
-> *声明* → [*扩展声明*](..\chapter3\05_Declarations.html#extension_declaration)  
-> *声明* → [*下标脚本声明*](..\chapter3\05_Declarations.html#subscript_declaration)  
-> *声明* → [*运算符声明*](..\chapter3\05_Declarations.html#operator_declaration)  
-> *声明(Declarations)集* → [*声明*](..\chapter3\05_Declarations.html#declaration) [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_  
+> *声明* → [*导入声明*](../chapter3/05_Declarations.html#import_declaration)  
+> *声明* → [*常量声明*](../chapter3/05_Declarations.html#constant_declaration)  
+> *声明* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration)  
+> *声明* → [*类型别名声明*](../chapter3/05_Declarations.html#typealias_declaration)  
+> *声明* → [*函数声明*](../chapter3/05_Declarations.html#function_declaration)  
+> *声明* → [*枚举声明*](../chapter3/05_Declarations.html#enum_declaration)  
+> *声明* → [*结构体声明*](../chapter3/05_Declarations.html#struct_declaration)  
+> *声明* → [*类声明*](../chapter3/05_Declarations.html#class_declaration)  
+> *声明* → [*协议声明*](../chapter3/05_Declarations.html#protocol_declaration)  
+> *声明* → [*构造器声明*](../chapter3/05_Declarations.html#initializer_declaration)  
+> *声明* → [*析构器声明*](../chapter3/05_Declarations.html#deinitializer_declaration)  
+> *声明* → [*扩展声明*](../chapter3/05_Declarations.html#extension_declaration)  
+> *声明* → [*下标脚本声明*](../chapter3/05_Declarations.html#subscript_declaration)  
+> *声明* → [*运算符声明*](../chapter3/05_Declarations.html#operator_declaration)  
+> *声明(Declarations)集* → [*声明*](../chapter3/05_Declarations.html#declaration) [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_  
  
 
 <!-- -->
 
 > 顶级(Top Level) 声明语法  
-> *顶级声明* → [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_  
+> *顶级声明* → [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_  
 
 <!-- -->
 
 > 代码块语法  
-> *代码块* → **{** [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_ **}**  
+> *代码块* → **{** [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_ **}**  
 
 <!-- -->
 
 > 导入(Import)声明语法  
-> *导入声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **import** [*导入类型*](..\chapter3\05_Declarations.html#import_kind) _可选_ [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
+> *导入声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **import** [*导入类型*](../chapter3/05_Declarations.html#import_kind) _可选_ [*导入路径*](../chapter3/05_Declarations.html#import_path)  
 > *导入类型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**  
-> *导入路径* → [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) | [*导入路径标识符*](..\chapter3\05_Declarations.html#import_path_identifier) **.** [*导入路径*](..\chapter3\05_Declarations.html#import_path)  
-> *导入路径标识符* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
+> *导入路径* → [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) | [*导入路径标识符*](../chapter3/05_Declarations.html#import_path_identifier) **.** [*导入路径*](../chapter3/05_Declarations.html#import_path)  
+> *导入路径标识符* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator)  
 
 <!-- -->
 
 > 常数声明语法  
-> *常量声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改符(Modifiers)集*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器集*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *模式构造器集* → [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式构造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式构造器集*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *模式构造器* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_  
-> *构造器* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *常量声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符(Modifiers)集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **let** [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list)  
+> *模式构造器集* → [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) | [*模式构造器*](../chapter3/05_Declarations.html#pattern_initializer) **,** [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list)  
+> *模式构造器* → [*模式*](../chapter3/07_Patterns.html#pattern) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_  
+> *构造器* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <!-- -->
 
 > 变量声明语法  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*模式构造器集*](..\chapter3\05_Declarations.html#pattern_initializer_list)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-> *变量声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*构造器*](..\chapter3\05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](..\chapter3\05_Declarations.html#willSet_didSet_block)  
-> *变量声明头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改符(Modifers)集*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **var**  
-> *变量名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *getter-setter块* → **{** [*getter从句*](..\chapter3\05_Declarations.html#getter_clause) [*setter从句*](..\chapter3\05_Declarations.html#setter_clause) _可选_ **}**  
-> *getter-setter块* → **{** [*setter从句*](..\chapter3\05_Declarations.html#setter_clause) [*getter从句*](..\chapter3\05_Declarations.html#getter_clause) **}**  
-> *getter从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **get** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *setter从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **set** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *setter名称* → **(** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **)**  
-> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可选_ **}**  
-> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)从句*](..\chapter3\05_Declarations.html#getter_keyword_clause) **}**  
-> *getter关键字(Keyword)从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **get**  
-> *setter关键字(Keyword)从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **set**  
-> *willSet-didSet代码块* → **{** [*willSet从句*](..\chapter3\05_Declarations.html#willSet_clause) [*didSet从句*](..\chapter3\05_Declarations.html#didSet_clause) _可选_ **}**  
-> *willSet-didSet代码块* → **{** [*didSet从句*](..\chapter3\05_Declarations.html#didSet_clause) [*willSet从句*](..\chapter3\05_Declarations.html#willSet_clause) **}**  
-> *willSet从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *didSet从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](..\chapter3\05_Declarations.html#setter_name) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*模式构造器集*](../chapter3/05_Declarations.html#pattern_initializer_list)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter块*](../chapter3/05_Declarations.html#getter_setter_block)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)  
+> *变量声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*构造器*](../chapter3/05_Declarations.html#initializer) _可选_ [*willSet-didSet代码块*](../chapter3/05_Declarations.html#willSet_didSet_block)  
+> *变量声明头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改符(Modifers)集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **var**  
+> *变量名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *getter-setter块* → **{** [*getter从句*](../chapter3/05_Declarations.html#getter_clause) [*setter从句*](../chapter3/05_Declarations.html#setter_clause) _可选_ **}**  
+> *getter-setter块* → **{** [*setter从句*](../chapter3/05_Declarations.html#setter_clause) [*getter从句*](../chapter3/05_Declarations.html#getter_clause) **}**  
+> *getter从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **get** [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *setter从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **set** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *setter名称* → **(** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **)**  
+> *getter-setter关键字(Keyword)块* → **{** [*getter关键字(Keyword)从句*](../chapter3/05_Declarations.html#getter_keyword_clause) [*setter关键字(Keyword)从句*](../chapter3/05_Declarations.html#setter_keyword_clause) _可选_ **}**  
+> *getter-setter关键字(Keyword)块* → **{** [*setter关键字(Keyword)从句*](../chapter3/05_Declarations.html#setter_keyword_clause) [*getter关键字(Keyword)从句*](../chapter3/05_Declarations.html#getter_keyword_clause) **}**  
+> *getter关键字(Keyword)从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **get**  
+> *setter关键字(Keyword)从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **set**  
+> *willSet-didSet代码块* → **{** [*willSet从句*](../chapter3/05_Declarations.html#willSet_clause) [*didSet从句*](../chapter3/05_Declarations.html#didSet_clause) _可选_ **}**  
+> *willSet-didSet代码块* → **{** [*didSet从句*](../chapter3/05_Declarations.html#didSet_clause) [*willSet从句*](../chapter3/05_Declarations.html#willSet_clause) **}**  
+> *willSet从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **willSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *didSet从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **didSet** [*setter名称*](../chapter3/05_Declarations.html#setter_name) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
 
 <!-- -->
 
 > 类型别名声明语法  
-> *类型别名声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment)  
-> *类型别名头(Head)* → [*属性*](TODO) _可选_ [*访问级别修改符(access-level-modifier)*](TODO) **typealias** [*类型别名名称*](..\chapter3\05_Declarations.html#typealias_name)  
-> *类型别名名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *类型别名赋值* → **=** [*类型*](..\chapter3\03_Types.html#type)  
+> *类型别名声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment)  
+> *类型别名头(Head)* → [*属性*](TODO) _可选_ [*访问级别修改符(access-level-modifier)*](TODO) **typealias** [*类型别名名称*](../chapter3/05_Declarations.html#typealias_name)  
+> *类型别名名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *类型别名赋值* → **=** [*类型*](../chapter3/03_Types.html#type)  
 
 <!-- -->
 
 > 函数声明语法  
-> *函数声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature) [*函数体*](..\chapter3\05_Declarations.html#function_body)  
-> *函数头* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)集*](..\chapter3\05_Declarations.html#declaration_specifiers) _可选_ **func**  
-> *函数名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
-> *函数签名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **throws** _可选_ [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ 
+> *函数声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature) [*函数体*](../chapter3/05_Declarations.html#function_body)  
+> *函数头* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明描述符(Specifiers)集*](../chapter3/05_Declarations.html#declaration_specifiers) _可选_ **func**  
+> *函数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*运算符*](../chapter3/02_Lexical_Structure.html#operator)  
+> *函数签名(Signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **throws** _可选_ [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ 
 
-> *函数签名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_  
-> *函数结果* → **->** [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
-> *函数体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *参数从句* → [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可选_  
-> *参数从句* → **(** **)** | **(** [*参数集*](..\chapter3\05_Declarations.html#parameter_list) **...** _可选_ **)**  
-> *参数集* → [*参数*](..\chapter3\05_Declarations.html#parameter) | [*参数*](..\chapter3\05_Declarations.html#parameter) **,** [*参数集*](..\chapter3\05_Declarations.html#parameter_list)  
-> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name) _可选_ [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数从句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
-> *参数* → **inout** _可选_ **var** [*外部参数名*](..\chapter3\05_Declarations.html#parameter_name) [*本地参数名*](..\chapter3\05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*默认参数从句*](..\chapter3\05_Declarations.html#default_argument_clause) _可选_  
-> *参数* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
-> *外部参数名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | **_**  
-> *本地参数名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | **_**  
-> *默认参数从句* → **=** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *函数签名(Signature)* → [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) **rethrows** [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_  
+> *函数结果* → **->** [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)  
+> *函数体* → [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *参数从句* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*parameter-clauses*](../chapter3/05_Declarations.html#parameter_clauses) _可选_  
+> *参数从句* → **(** **)** | **(** [*参数集*](../chapter3/05_Declarations.html#parameter_list) **...** _可选_ **)**  
+> *参数集* → [*参数*](../chapter3/05_Declarations.html#parameter) | [*参数*](../chapter3/05_Declarations.html#parameter) **,** [*参数集*](../chapter3/05_Declarations.html#parameter_list)  
+> *参数* → **inout** _可选_ **let** _可选_ [*外部参数名*](../chapter3/05_Declarations.html#parameter_name) _可选_ [*本地参数名*](../chapter3/05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](../chapter3/03_Types.html#type_annotation) [*默认参数从句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → **inout** _可选_ **var** [*外部参数名*](../chapter3/05_Declarations.html#parameter_name) [*本地参数名*](../chapter3/05_Declarations.html#local_parameter_name) _可选_ [*类型注解*](../chapter3/03_Types.html#type_annotation) [*默认参数从句*](../chapter3/05_Declarations.html#default_argument_clause) _可选_  
+> *参数* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)  
+> *外部参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_**  
+> *本地参数名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | **_**  
+> *默认参数从句* → **=** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <!-- -->
 
 > 枚举声明语法  
-> *枚举声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*联合式枚举*](..\chapter3\05_Declarations.html#union_style_enum) 
+> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*联合式枚举*](../chapter3/05_Declarations.html#union_style_enum) 
 
-> *枚举声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*原始值式枚举(raw-value-style-enum)*](TODO)
+> *枚举声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ [*原始值式枚举(raw-value-style-enum)*](TODO)
 
-> *联合式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句(type-inheritance-clause)*](TODO) _可选_ **{** [*联合样式枚举成员*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_ **}**  
+> *联合式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句(type-inheritance-clause)*](TODO) _可选_ **{** [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_ **}**  
 
-> *联合样式枚举成员* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*联合样式枚举成员*](..\chapter3\05_Declarations.html#union_style_enum_members) _可选_  
+> *联合样式枚举成员* → [*union-style-enum-member*](../chapter3/05_Declarations.html#union_style_enum_member) [*联合样式枚举成员*](../chapter3/05_Declarations.html#union_style_enum_members) _可选_  
 
-> *联合样式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case从句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)  
+> *联合样式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*联合式(Union Style)的枚举case从句*](../chapter3/05_Declarations.html#union_style_enum_case_clause)  
 
-> *联合式(Union Style)的枚举case从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*联合式(Union Style)的枚举case集*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
-> *联合式(Union Style)的枚举case集* → [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举case集*](..\chapter3\05_Declarations.html#union_style_enum_case_list)  
-> *联合式(Union Style)的枚举case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组类型*](..\chapter3\03_Types.html#tuple_type) _可选_  
-> *枚举名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *枚举的case名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *原始值式枚举* → **enum** [*枚举名*](..\chapter3\05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](..\chapter3\03_Types.html#type_identifier) **{** [*原始值式枚举成员集*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_ **}**  
-> *原始值式枚举成员集* → [*原始值式枚举成员*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员集*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可选_  
-> *原始值式枚举成员* → [*声明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚举case从句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)  
-> *原始值式枚举case从句* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case集*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
-> *原始值式枚举case集* → [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case集*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)  
-> *原始值式枚举case* → [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*原始值赋值*](..\chapter3\05_Declarations.html#raw_value_assignment) _可选_  
-> *原始值赋值* → **=** [*字面量*](..\chapter3\02_Lexical_Structure.html#literal) 
+> *联合式(Union Style)的枚举case从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*联合式(Union Style)的枚举case集*](../chapter3/05_Declarations.html#union_style_enum_case_list)  
+> *联合式(Union Style)的枚举case集* → [*联合式(Union Style)的case*](../chapter3/05_Declarations.html#union_style_enum_case) | [*联合式(Union Style)的case*](../chapter3/05_Declarations.html#union_style_enum_case) **,** [*联合式(Union Style)的枚举case集*](../chapter3/05_Declarations.html#union_style_enum_case_list)  
+> *联合式(Union Style)的枚举case* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组类型*](../chapter3/03_Types.html#tuple_type) _可选_  
+> *枚举名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *枚举的case名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *原始值式枚举* → **enum** [*枚举名*](../chapter3/05_Declarations.html#enum_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ **:** [*类型标识*](../chapter3/03_Types.html#type_identifier) **{** [*原始值式枚举成员集*](../chapter3/05_Declarations.html#raw_value_style_enum_members) _可选_ **}**  
+> *原始值式枚举成员集* → [*原始值式枚举成员*](../chapter3/05_Declarations.html#raw_value_style_enum_member) [*原始值式枚举成员集*](../chapter3/05_Declarations.html#raw_value_style_enum_members) _可选_  
+> *原始值式枚举成员* → [*声明*](../chapter3/05_Declarations.html#declaration) | [*原始值式枚举case从句*](../chapter3/05_Declarations.html#raw_value_style_enum_case_clause)  
+> *原始值式枚举case从句* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **case** [*原始值式枚举case集*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list)  
+> *原始值式枚举case集* → [*原始值式枚举case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚举case*](../chapter3/05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚举case集*](../chapter3/05_Declarations.html#raw_value_style_enum_case_list)  
+> *原始值式枚举case* → [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*原始值赋值*](../chapter3/05_Declarations.html#raw_value_assignment) _可选_  
+> *原始值赋值* → **=** [*字面量*](../chapter3/02_Lexical_Structure.html#literal) 
 > *原始值字面量(raw-value-literal)* → [*数值字面量*](TODO) | [*字符串字面量*](TODO) | [*布尔字面量*](TODO)
 
 <!-- -->
 
 > 结构体声明语法  
-> *结构体声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ **struct** [*结构体名称*](..\chapter3\05_Declarations.html#struct_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](..\chapter3\05_Declarations.html#struct_body)  
-> *结构体名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *结构体主体* → **{** [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *结构体声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) _可选_ **struct** [*结构体名称*](../chapter3/05_Declarations.html#struct_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*结构体主体*](../chapter3/05_Declarations.html#struct_body)  
+> *结构体名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *结构体主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}**  
 
 <!-- -->
 
 > 类声明语法  
-> *类声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) **class** [*类名*](..\chapter3\05_Declarations.html#class_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类主体*](..\chapter3\05_Declarations.html#class_body)  
-> *类名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *类主体* → **{** [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *类声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*访问级别修改器(access-level-modifier)*](TODO) **class** [*类名*](../chapter3/05_Declarations.html#class_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类主体*](../chapter3/05_Declarations.html#class_body)  
+> *类名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *类主体* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}**  
 
 <!-- -->
 
 > 协议(Protocol)声明语法  
-> *协议声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_[*访问级别修改器(access-level-modifier)*](TODO)  **protocol** [*协议名*](..\chapter3\05_Declarations.html#protocol_name) [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](..\chapter3\05_Declarations.html#protocol_body)  
-> *协议名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *协议主体* → **{** [*协议成员声明(Declarations)集*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_ **}**  
-> *协议成员声明* → [*协议属性声明*](..\chapter3\05_Declarations.html#protocol_property_declaration)  
-> *协议成员声明* → [*协议方法声明*](..\chapter3\05_Declarations.html#protocol_method_declaration)  
-> *协议成员声明* → [*协议构造器声明*](..\chapter3\05_Declarations.html#protocol_initializer_declaration)  
-> *协议成员声明* → [*协议下标脚本声明*](..\chapter3\05_Declarations.html#protocol_subscript_declaration)  
-> *协议成员声明* → [*协议关联类型声明*](..\chapter3\05_Declarations.html#protocol_associated_type_declaration)  
-> *协议成员声明(Declarations)集* → [*协议成员声明*](..\chapter3\05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)集*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可选_  
+> *协议声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_[*访问级别修改器(access-level-modifier)*](TODO)  **protocol** [*协议名*](../chapter3/05_Declarations.html#protocol_name) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*协议主体*](../chapter3/05_Declarations.html#protocol_body)  
+> *协议名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *协议主体* → **{** [*协议成员声明(Declarations)集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_ **}**  
+> *协议成员声明* → [*协议属性声明*](../chapter3/05_Declarations.html#protocol_property_declaration)  
+> *协议成员声明* → [*协议方法声明*](../chapter3/05_Declarations.html#protocol_method_declaration)  
+> *协议成员声明* → [*协议构造器声明*](../chapter3/05_Declarations.html#protocol_initializer_declaration)  
+> *协议成员声明* → [*协议下标脚本声明*](../chapter3/05_Declarations.html#protocol_subscript_declaration)  
+> *协议成员声明* → [*协议关联类型声明*](../chapter3/05_Declarations.html#protocol_associated_type_declaration)  
+> *协议成员声明(Declarations)集* → [*协议成员声明*](../chapter3/05_Declarations.html#protocol_member_declaration) [*协议成员声明(Declarations)集*](../chapter3/05_Declarations.html#protocol_member_declarations) _可选_  
 
 <!-- -->
 
 > 协议属性声明语法  
-> *协议属性声明* → [*变量声明头(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*变量名*](..\chapter3\05_Declarations.html#variable_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
+> *协议属性声明* → [*变量声明头(Head)*](../chapter3/05_Declarations.html#variable_declaration_head) [*变量名*](../chapter3/05_Declarations.html#variable_name) [*类型注解*](../chapter3/03_Types.html#type_annotation) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)  
 
 <!-- -->
 
 > 协议方法声明语法  
-> *协议方法声明* → [*函数头*](..\chapter3\05_Declarations.html#function_head) [*函数名*](..\chapter3\05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](..\chapter3\05_Declarations.html#function_signature)  
+> *协议方法声明* → [*函数头*](../chapter3/05_Declarations.html#function_head) [*函数名*](../chapter3/05_Declarations.html#function_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*函数签名(Signature)*](../chapter3/05_Declarations.html#function_signature)  
 
 <!-- -->
 
 > 协议构造器声明语法  
-> *协议构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause)  
+> *协议构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause)  
 
 <!-- -->
 
 > 协议下标脚本声明语法  
-> *协议下标脚本声明* → [*下标脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
+> *协议下标脚本声明* → [*下标脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)  
 
 <!-- -->
 
 > 协议关联类型声明语法  
-> *协议关联类型声明* → [*类型别名头(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](..\chapter3\05_Declarations.html#typealias_assignment) _可选_  
+> *协议关联类型声明* → [*类型别名头(Head)*](../chapter3/05_Declarations.html#typealias_head) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*类型别名赋值*](../chapter3/05_Declarations.html#typealias_assignment) _可选_  
 
 <!-- -->
 
 > 构造器声明语法  
-> *构造器声明* → [*构造器头(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*构造器主体*](..\chapter3\05_Declarations.html#initializer_body)  
-> *构造器头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init**  
-> *构造器头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init ?**
+> *构造器声明* → [*构造器头(Head)*](../chapter3/05_Declarations.html#initializer_head) [*泛型参数从句*](GenericParametersAndArguments.html#generic_parameter_clause) _可选_ [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*构造器主体*](../chapter3/05_Declarations.html#initializer_body)  
+> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init**  
+> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init ?**
 
-> *构造器头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init !**    
+> *构造器头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器集(declaration-modifiers)*](TODO) _可选_  **init !**    
 
-> *构造器主体* → [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *构造器主体* → [*代码块*](../chapter3/05_Declarations.html#code_block)  
 
 <!-- -->
 
 > 析构器声明语法  
-> *析构器声明* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
+> *析构器声明* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **deinit** [*代码块*](../chapter3/05_Declarations.html#code_block)  
 
 <!-- -->
 
 > 扩展(Extension)声明语法  
-> *扩展声明* → [*访问级别修改器*](TODO) _可选_ **extension** [*类型标识*](..\chapter3\03_Types.html#type_identifier) [*类型继承从句*](..\chapter3\03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)  
-> *extension-body* → **{** [*声明(Declarations)集*](..\chapter3\05_Declarations.html#declarations) _可选_ **}**  
+> *扩展声明* → [*访问级别修改器*](TODO) _可选_ **extension** [*类型标识*](../chapter3/03_Types.html#type_identifier) [*类型继承从句*](../chapter3/03_Types.html#type_inheritance_clause) _可选_ [*extension-body*](../chapter3/05_Declarations.html#extension_body)  
+> *extension-body* → **{** [*声明(Declarations)集*](../chapter3/05_Declarations.html#declarations) _可选_ **}**  
 
 <!-- -->
 
 > 下标脚本声明语法  
-> *下标脚本声明* → [*下标脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *下标脚本声明* → [*下标脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter块*](..\chapter3\05_Declarations.html#getter_setter_block)  
-> *下标脚本声明* → [*下标脚本头(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)  
-> *下标脚本头(Head)* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*声明修改器(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause)  
-> *下标脚本结果(Result)* → **->** [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *下标脚本声明* → [*下标脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *下标脚本声明* → [*下标脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter块*](../chapter3/05_Declarations.html#getter_setter_block)  
+> *下标脚本声明* → [*下标脚本头(Head)*](../chapter3/05_Declarations.html#subscript_head) [*下标脚本结果(Result)*](../chapter3/05_Declarations.html#subscript_result) [*getter-setter关键字(Keyword)块*](../chapter3/05_Declarations.html#getter_setter_keyword_block)  
+> *下标脚本头(Head)* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*声明修改器(declaration-modifiers)*](TODO) _可选_ **subscript** [*参数从句*](../chapter3/05_Declarations.html#parameter_clause)  
+> *下标脚本结果(Result)* → **->** [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)  
 
 <!-- -->
 
 > 运算符声明语法  
-> *运算符声明* → [*前置运算符声明*](..\chapter3\05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](..\chapter3\05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](..\chapter3\05_Declarations.html#infix_operator_declaration)  
-> *前置运算符声明* → **prefix** **运算符**  [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**  
-> *后置运算符声明* → **postfix** **运算符**  [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**  
-> *中置运算符声明* → **infix** **运算符**  [*运算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** [*中置运算符属性集*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可选_ **}**  
-> *中置运算符属性集* → [*优先级从句*](..\chapter3\05_Declarations.html#precedence_clause) _可选_ [*结和性从句*](..\chapter3\05_Declarations.html#associativity_clause) _可选_  
-> *优先级从句* → **precedence** [*优先级水平*](..\chapter3\05_Declarations.html#precedence_level)  
+> *运算符声明* → [*前置运算符声明*](../chapter3/05_Declarations.html#prefix_operator_declaration) | [*后置运算符声明*](../chapter3/05_Declarations.html#postfix_operator_declaration) | [*中置运算符声明*](../chapter3/05_Declarations.html#infix_operator_declaration)  
+> *前置运算符声明* → **prefix** **运算符**  [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}**  
+> *后置运算符声明* → **postfix** **运算符**  [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** **}**  
+> *中置运算符声明* → **infix** **运算符**  [*运算符*](../chapter3/02_Lexical_Structure.html#operator) **{** [*中置运算符属性集*](../chapter3/05_Declarations.html#infix_operator_attributes) _可选_ **}**  
+> *中置运算符属性集* → [*优先级从句*](../chapter3/05_Declarations.html#precedence_clause) _可选_ [*结和性从句*](../chapter3/05_Declarations.html#associativity_clause) _可选_  
+> *优先级从句* → **precedence** [*优先级水平*](../chapter3/05_Declarations.html#precedence_level)  
 > *优先级水平* → 数值 0 到 255，首末项包括在内 
-> *结和性从句* → **associativity** [*结和性*](..\chapter3\05_Declarations.html#associativity)  
+> *结和性从句* → **associativity** [*结和性*](../chapter3/05_Declarations.html#associativity)  
 > *结和性* → **left** | **right** | **none**  
 
 <!-- -->
@@ -463,15 +467,15 @@ _________________
 ## 模式
 
 > 模式(Patterns) 语法  
-> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
-> *模式* → [*标识符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotati Value Bindingon ) _可选_  
-> *模式* → [*值绑定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)  
-> *模式* → [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*类型注解*](..\chapter3\03_Types.html#type_annotation) _可选_  
+> *模式* → [*通配符模式*](../chapter3/07_Patterns.html#wildcard_pattern) [*类型注解*](../chapter3/03_Types.html#type_annotation) _可选_  
+> *模式* → [*标识符模式*](../chapter3/07_Patterns.html#identifier_pattern) [*类型注解*](../chapter3/03_Types.html#type_annotati Value Bindingon ) _可选_  
+> *模式* → [*值绑定模式*](../chapter3/07_Patterns.html#value_binding_pattern)  
+> *模式* → [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) [*类型注解*](../chapter3/03_Types.html#type_annotation) _可选_  
  
-> *模式* → [*枚举个例模式*](..\chapter3\07_Patterns.html#enum_case_pattern)  
+> *模式* → [*枚举个例模式*](../chapter3/07_Patterns.html#enum_case_pattern)  
 > *模式* → [*可选模式*](TODO) 
-> *模式* → [*类型转换模式*](..\chapter3\07_Patterns.html#type_casting_pattern)  
-> *模式* → [*表达式模式*](..\chapter3\07_Patterns.html#expression_pattern)  
+> *模式* → [*类型转换模式*](../chapter3/07_Patterns.html#type_casting_pattern)  
+> *模式* → [*表达式模式*](../chapter3/07_Patterns.html#expression_pattern)  
 
 <!-- -->
 
@@ -481,24 +485,24 @@ _________________
 <!-- -->
 
 > 标识符模式语法  
-> *标识符模式* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *标识符模式* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
 
 <!-- -->
 
 > 值绑定(Value Binding)模式语法  
-> *值绑定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern)  
+> *值绑定模式* → **var** [*模式*](../chapter3/07_Patterns.html#pattern) | **let** [*模式*](../chapter3/07_Patterns.html#pattern)  
 
 <!-- -->
 
 > 元组模式语法  
-> *元组模式* → **(** [*元组模式元素集*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可选_ **)**  
-> *元组模式元素集* → [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素集*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)  
-> *元组模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern)  
+> *元组模式* → **(** [*元组模式元素集*](../chapter3/07_Patterns.html#tuple_pattern_element_list) _可选_ **)**  
+> *元组模式元素集* → [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) | [*元组模式元素*](../chapter3/07_Patterns.html#tuple_pattern_element) **,** [*元组模式元素集*](../chapter3/07_Patterns.html#tuple_pattern_element_list)  
+> *元组模式元素* → [*模式*](../chapter3/07_Patterns.html#pattern)  
 
 <!-- -->
 
 > 枚举用例模式语法  
-> *enum-case-pattern* → [*类型标识*](..\chapter3\03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元组模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可选_ 
+> *enum-case-pattern* → [*类型标识*](../chapter3/03_Types.html#type_identifier) _可选_ **.** [*枚举的case名*](../chapter3/05_Declarations.html#enum_case_name) [*元组模式*](../chapter3/07_Patterns.html#tuple_pattern) _可选_ 
 
 <!-- -->
 > 可选模式语法
@@ -508,27 +512,27 @@ _________________
 <!-- -->
 
 > 类型转换模式语法  
-> *类型转换模式(type-casting-pattern)* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern)  
-> *is模式* → **is** [*类型*](..\chapter3\03_Types.html#type)  
-> *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*类型*](..\chapter3\03_Types.html#type)  
+> *类型转换模式(type-casting-pattern)* → [*is模式*](../chapter3/07_Patterns.html#is_pattern) | [*as模式*](../chapter3/07_Patterns.html#as_pattern)  
+> *is模式* → **is** [*类型*](../chapter3/03_Types.html#type)  
+> *as模式* → [*模式*](../chapter3/07_Patterns.html#pattern) **as** [*类型*](../chapter3/03_Types.html#type)  
 
 <!-- -->
 
 > 表达式模式语法  
-> *表达式模式* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *表达式模式* → [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <a name="attributes"></a>
 ## 属性
 
 > 属性语法  
-> *属性* → **@** [*属性名*](..\chapter3\06_Attributes.html#attribute_name) [*属性参数从句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可选_  
-> *属性名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *属性参数从句* → **(** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
-> *属性(Attributes)集* → [*属性*](..\chapter3\06_Attributes.html#attribute) [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_  
-> *平衡令牌集* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_  
-> *平衡令牌* → **(** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **)**  
-> *平衡令牌* → **[** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **]**  
-> *平衡令牌* → **{** [*平衡令牌集*](..\chapter3\06_Attributes.html#balanced_tokens) _可选_ **}**  
+> *属性* → **@** [*属性名*](../chapter3/06_Attributes.html#attribute_name) [*属性参数从句*](../chapter3/06_Attributes.html#attribute_argument_clause) _可选_  
+> *属性名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *属性参数从句* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)**  
+> *属性(Attributes)集* → [*属性*](../chapter3/06_Attributes.html#attribute) [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_  
+> *平衡令牌集* → [*平衡令牌*](../chapter3/06_Attributes.html#balanced_token) [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_  
+> *平衡令牌* → **(** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **)**  
+> *平衡令牌* → **[** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **]**  
+> *平衡令牌* → **{** [*平衡令牌集*](../chapter3/06_Attributes.html#balanced_tokens) _可选_ **}**  
 > *平衡令牌* → **任意标识符, 关键字, 字面量或运算符**  
 > *平衡令牌* → **任意标点除了(, ), [, ], {, 或 }**
 
@@ -536,15 +540,15 @@ _________________
 ## 表达式
 
 > 表达式语法  
-> *表达式* → [*try-operator*](TODO) _可选_ [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression) [*二元表达式集*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
-> *表达式集* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*表达式*](..\chapter3\04_Expressions.html#expression) **,** [*表达式集*](..\chapter3\04_Expressions.html#expression_list)  
+> *表达式* → [*try-operator*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression) [*二元表达式集*](../chapter3/04_Expressions.html#binary_expressions) _可选_  
+> *表达式集* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*表达式*](../chapter3/04_Expressions.html#expression) **,** [*表达式集*](../chapter3/04_Expressions.html#expression_list)  
 
 <!-- -->
 
 > 前置表达式语法  
-> *前置表达式* → [*前置运算符*](..\chapter3\02_Lexical_Structure.html#prefix_operator) _可选_ [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression)  
-> *前置表达式* → [*写入写出(in-out)表达式*](..\chapter3\04_Expressions.html#in_out_expression)  
-> *写入写出(in-out)表达式* → **&** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) 
+> *前置表达式* → [*前置运算符*](../chapter3/02_Lexical_Structure.html#prefix_operator) _可选_ [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression)  
+> *前置表达式* → [*写入写出(in-out)表达式*](../chapter3/04_Expressions.html#in_out_expression)  
+> *写入写出(in-out)表达式* → **&** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) 
 
 <!-- -->
 > try表达式语法
@@ -554,11 +558,11 @@ _________________
 <!-- -->
 
 > 二元表达式语法  
-> *二元表达式* → [*二元运算符*](..\chapter3\02_Lexical_Structure.html#binary_operator) [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*赋值运算符*](..\chapter3\04_Expressions.html#assignment_operator) [*try运算符*](TODO) _可选_ [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*条件运算符*](..\chapter3\04_Expressions.html#conditional_operator) [*try运算符*](TODO) _可选_ [*前置表达式*](..\chapter3\04_Expressions.html#prefix_expression)  
-> *二元表达式* → [*类型转换运算符*](..\chapter3\04_Expressions.html#type_casting_operator)  
-> *二元表达式集* → [*二元表达式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表达式集*](..\chapter3\04_Expressions.html#binary_expressions) _可选_  
+> *二元表达式* → [*二元运算符*](../chapter3/02_Lexical_Structure.html#binary_operator) [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*赋值运算符*](../chapter3/04_Expressions.html#assignment_operator) [*try运算符*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*条件运算符*](../chapter3/04_Expressions.html#conditional_operator) [*try运算符*](TODO) _可选_ [*前置表达式*](../chapter3/04_Expressions.html#prefix_expression)  
+> *二元表达式* → [*类型转换运算符*](../chapter3/04_Expressions.html#type_casting_operator)  
+> *二元表达式集* → [*二元表达式*](../chapter3/04_Expressions.html#binary_expression) [*二元表达式集*](../chapter3/04_Expressions.html#binary_expressions) _可选_  
 
 <!-- -->
 
@@ -568,85 +572,85 @@ _________________
 <!-- -->
 
 > 三元条件运算符语法  
-> *三元条件运算符* → **?** [*表达式*](..\chapter3\04_Expressions.html#expression) **:**  
+> *三元条件运算符* → **?** [*表达式*](../chapter3/04_Expressions.html#expression) **:**  
 
 <!-- -->
 
 > 类型转换运算符语法  
-> *类型转换运算符* → **is** [*类型*](..\chapter3\03_Types.html#type) 
+> *类型转换运算符* → **is** [*类型*](../chapter3/03_Types.html#type) 
 
-> *类型转换运算符* → **as** [*类型*](..\chapter3\03_Types.html#type) 
+> *类型转换运算符* → **as** [*类型*](../chapter3/03_Types.html#type) 
 
-> *类型转换运算符* → **as ?** [*类型*](..\chapter3\03_Types.html#type) 
+> *类型转换运算符* → **as ?** [*类型*](../chapter3/03_Types.html#type) 
 
-> *类型转换运算符* → **as !** [*类型*](..\chapter3\03_Types.html#type) 
+> *类型转换运算符* → **as !** [*类型*](../chapter3/03_Types.html#type) 
 
 
 
 <!-- -->
 
 > 主表达式语法  
-> *主表达式* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
-> *主表达式* → [*字面量表达式*](..\chapter3\04_Expressions.html#literal_expression)  
-> *主表达式* → [*self表达式*](..\chapter3\04_Expressions.html#self_expression)  
-> *主表达式* → [*超类表达式*](..\chapter3\04_Expressions.html#superclass_expression)  
-> *主表达式* → [*闭包表达式*](..\chapter3\04_Expressions.html#closure_expression)  
-> *主表达式* → [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_expression)  
-> *主表达式* → [*隐式成员表达式*](..\chapter3\04_Expressions.html#implicit_member_expression)  
-> *主表达式* → [*通配符表达式*](..\chapter3\04_Expressions.html#wildcard_expression)  
+> *主表达式* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
+> *主表达式* → [*字面量表达式*](../chapter3/04_Expressions.html#literal_expression)  
+> *主表达式* → [*self表达式*](../chapter3/04_Expressions.html#self_expression)  
+> *主表达式* → [*超类表达式*](../chapter3/04_Expressions.html#superclass_expression)  
+> *主表达式* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression)  
+> *主表达式* → [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression)  
+> *主表达式* → [*隐式成员表达式*](../chapter3/04_Expressions.html#implicit_member_expression)  
+> *主表达式* → [*通配符表达式*](../chapter3/04_Expressions.html#wildcard_expression)  
 
 <!-- -->
 
 > 字面量表达式语法  
-> *字面量表达式* → [*字面量*](..\chapter3\02_Lexical_Structure.html#literal)  
-> *字面量表达式* → [*数组字面量*](..\chapter3\04_Expressions.html#array_literal) | [*字典字面量*](..\chapter3\04_Expressions.html#dictionary_literal)  
+> *字面量表达式* → [*字面量*](../chapter3/02_Lexical_Structure.html#literal)  
+> *字面量表达式* → [*数组字面量*](../chapter3/04_Expressions.html#array_literal) | [*字典字面量*](../chapter3/04_Expressions.html#dictionary_literal)  
 > *字面量表达式* → **&#95;&#95;FILE&#95;&#95;** | **&#95;&#95;LINE&#95;&#95;** | **&#95;&#95;COLUMN&#95;&#95;** | **&#95;&#95;FUNCTION&#95;&#95;**  
-> *数组字面量* → **[** [*数组字面量项集*](..\chapter3\04_Expressions.html#array_literal_items) _可选_ **]**  
-> *数组字面量项集* → [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](..\chapter3\04_Expressions.html#array_literal_item) **,** [*数组字面量项集*](..\chapter3\04_Expressions.html#array_literal_items)  
-> *数组字面量项* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
-> *字典字面量* → **[** [*字典字面量项集*](..\chapter3\04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**  
-> *字典字面量项集* → [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项集*](..\chapter3\04_Expressions.html#dictionary_literal_items)  
-> *字典字面量项* → [*表达式*](..\chapter3\04_Expressions.html#expression) **:** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *数组字面量* → **[** [*数组字面量项集*](../chapter3/04_Expressions.html#array_literal_items) _可选_ **]**  
+> *数组字面量项集* → [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** _可选_ | [*数组字面量项*](../chapter3/04_Expressions.html#array_literal_item) **,** [*数组字面量项集*](../chapter3/04_Expressions.html#array_literal_items)  
+> *数组字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression)  
+> *字典字面量* → **[** [*字典字面量项集*](../chapter3/04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**  
+> *字典字面量项集* → [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** _可选_ | [*字典字面量项*](../chapter3/04_Expressions.html#dictionary_literal_item) **,** [*字典字面量项集*](../chapter3/04_Expressions.html#dictionary_literal_items)  
+> *字典字面量项* → [*表达式*](../chapter3/04_Expressions.html#expression) **:** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <!-- -->
 
 > Self 表达式语法  
 > *self表达式* → **self**  
-> *self表达式* → **self** **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *self表达式* → **self** **[** [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
+> *self表达式* → **self** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *self表达式* → **self** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
 > *self表达式* → **self** **.** **init**  
 
 <!-- -->
 
 > 超类表达式语法  
-> *超类表达式* → [*超类方法表达式*](..\chapter3\04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](..\chapter3\04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](..\chapter3\04_Expressions.html#superclass_initializer_expression)  
-> *超类方法表达式* → **super** **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-> *超类下标表达式* → **super** **[** [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
+> *超类表达式* → [*超类方法表达式*](../chapter3/04_Expressions.html#superclass_method_expression) | [*超类下标表达式*](../chapter3/04_Expressions.html#超类下标表达式) | [*超类构造器表达式*](../chapter3/04_Expressions.html#superclass_initializer_expression)  
+> *超类方法表达式* → **super** **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+> *超类下标表达式* → **super** **[** [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
 > *超类构造器表达式* → **super** **.** **init**  
 
 <!-- -->
 
 > 闭包表达式语法  
-> *闭包表达式* → **{** [*闭包签名(Signational)*](..\chapter3\04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) **}**  
-> *闭包签名(Signational)* → [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*标识符集*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)集*](..\chapter3\04_Expressions.html#capture_list) [*参数从句*](..\chapter3\05_Declarations.html#parameter_clause) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)集*](..\chapter3\04_Expressions.html#capture_list) [*标识符集*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函数结果*](..\chapter3\05_Declarations.html#function_result) _可选_ **in**  
-> *闭包签名(Signational)* → [*捕获(Capature)集*](..\chapter3\04_Expressions.html#capture_list) **in**  
-> *捕获(Capature)集* → **[** [*捕获(Capature)说明符*](..\chapter3\04_Expressions.html#capture_specifier) [*表达式*](..\chapter3\04_Expressions.html#expression) **]**  
+> *闭包表达式* → **{** [*闭包签名(Signational)*](../chapter3/04_Expressions.html#closure_signature) _可选_ [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) **}**  
+> *闭包签名(Signational)* → [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*参数从句*](../chapter3/05_Declarations.html#parameter_clause) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list) [*函数结果*](../chapter3/05_Declarations.html#function_result) _可选_ **in**  
+> *闭包签名(Signational)* → [*捕获(Capature)集*](../chapter3/04_Expressions.html#capture_list) **in**  
+> *捕获(Capature)集* → **[** [*捕获(Capature)说明符*](../chapter3/04_Expressions.html#capture_specifier) [*表达式*](../chapter3/04_Expressions.html#expression) **]**  
 > *捕获(Capature)说明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**  
 
 <!-- -->
 
 > 隐式成员表达式语法  
-> *隐式成员表达式* → **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *隐式成员表达式* → **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
 
 <!-- -->
 
 > 圆括号表达式(Parenthesized Expression)语法  
-> *圆括号表达式* → **(** [*表达式元素集*](..\chapter3\04_Expressions.html#expression_element_list) _可选_ **)**  
-> *表达式元素集* → [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) | [*表达式元素*](..\chapter3\04_Expressions.html#expression_element) **,** [*表达式元素集*](..\chapter3\04_Expressions.html#expression_element_list)  
-> *表达式元素* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **:** [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *圆括号表达式* → **(** [*表达式元素集*](../chapter3/04_Expressions.html#expression_element_list) _可选_ **)**  
+> *表达式元素集* → [*表达式元素*](../chapter3/04_Expressions.html#expression_element) | [*表达式元素*](../chapter3/04_Expressions.html#expression_element) **,** [*表达式元素集*](../chapter3/04_Expressions.html#expression_element_list)  
+> *表达式元素* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **:** [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <!-- -->
 
@@ -656,68 +660,68 @@ _________________
 <!-- -->
 
 > 后置表达式语法  
-> *后置表达式* → [*主表达式*](..\chapter3\04_Expressions.html#primary_expression)  
-> *后置表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*后置运算符*](..\chapter3\02_Lexical_Structure.html#postfix_operator)  
-> *后置表达式* → [*函数调用表达式*](..\chapter3\04_Expressions.html#function_call_expression)  
-> *后置表达式* → [*构造器表达式*](..\chapter3\04_Expressions.html#initializer_expression)  
-> *后置表达式* → [*显示成员表达式*](..\chapter3\04_Expressions.html#explicit_member_expression)  
-> *后置表达式* → [*后置self表达式*](..\chapter3\04_Expressions.html#postfix_self_expression)  
-> *后置表达式* → [*动态类型表达式*](..\chapter3\04_Expressions.html#dynamic_type_expression)  
-> *后置表达式* → [*下标表达式*](..\chapter3\04_Expressions.html#subscript_expression)  
-> *后置表达式* → [*强制取值(Forced Value)表达式*](..\chapter3\04_Expressions.html#forced_value_expression)  
-> *后置表达式* → [*可选链(Optional Chaining)表达式*](..\chapter3\04_Expressions.html#optional_chaining_expression)  
+> *后置表达式* → [*主表达式*](../chapter3/04_Expressions.html#primary_expression)  
+> *后置表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*后置运算符*](../chapter3/02_Lexical_Structure.html#postfix_operator)  
+> *后置表达式* → [*函数调用表达式*](../chapter3/04_Expressions.html#function_call_expression)  
+> *后置表达式* → [*构造器表达式*](../chapter3/04_Expressions.html#initializer_expression)  
+> *后置表达式* → [*显示成员表达式*](../chapter3/04_Expressions.html#explicit_member_expression)  
+> *后置表达式* → [*后置self表达式*](../chapter3/04_Expressions.html#postfix_self_expression)  
+> *后置表达式* → [*动态类型表达式*](../chapter3/04_Expressions.html#dynamic_type_expression)  
+> *后置表达式* → [*下标表达式*](../chapter3/04_Expressions.html#subscript_expression)  
+> *后置表达式* → [*强制取值(Forced Value)表达式*](../chapter3/04_Expressions.html#forced_value_expression)  
+> *后置表达式* → [*可选链(Optional Chaining)表达式*](../chapter3/04_Expressions.html#optional_chaining_expression)  
 
 <!-- -->
 
 > 函数调用表达式语法  
-> *函数调用表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_expression)  
-> *函数调用表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) [*圆括号表达式*](..\chapter3\04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包(Trailing Closure)*](..\chapter3\04_Expressions.html#trailing_closure)  
-> *后置闭包(Trailing Closure)* → [*闭包表达式*](..\chapter3\04_Expressions.html#closure_expression)  
+> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression)  
+> *函数调用表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) [*圆括号表达式*](../chapter3/04_Expressions.html#parenthesized_expression) _可选_ [*后置闭包(Trailing Closure)*](../chapter3/04_Expressions.html#trailing_closure)  
+> *后置闭包(Trailing Closure)* → [*闭包表达式*](../chapter3/04_Expressions.html#closure_expression)  
 
 <!-- -->
 
 > 构造器表达式语法  
-> *构造器表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **init**  
+> *构造器表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init**  
 
 <!-- -->
 
 > 显式成员表达式语法  
-> *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit)  
-> *显示成员表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
+> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit)  
+> *显示成员表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_  
 
 <!-- -->
 
 > 后置Self 表达式语法  
-> *后置self表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **self**  
+> *后置self表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **self**  
 
 <!-- -->
 
 > 动态类型表达式语法  
-> *动态类型表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **dynamicType**  
+> *动态类型表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **dynamicType**  
 
 <!-- -->
 
 > 附属脚本表达式语法  
-> *附属脚本表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **[** [*表达式集*](..\chapter3\04_Expressions.html#expression_list) **]**  
+> *附属脚本表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **[** [*表达式集*](../chapter3/04_Expressions.html#expression_list) **]**  
 
 <!-- -->
 
 > 强制取值(Forced Value)语法  
-> *强制取值(Forced Value)表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **!**  
+> *强制取值(Forced Value)表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **!**  
 
 <!-- -->
 
 > 可选链表达式语法  
-> *可选链表达式* → [*后置表达式*](..\chapter3\04_Expressions.html#postfix_expression) **?**  
+> *可选链表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **?**  
 
 <a name="lexical_structure"></a>
 ## 词法结构
 
 > 标识符语法  
-> *标识符* → [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*标识符字符集*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
-> *标识符* → [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*标识符字符集*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
-> *标识符* → [*隐式参数名*](..\chapter3\02_Lexical_Structure.html#implicit_parameter_name)  
-> *标识符集* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier) **,** [*标识符集*](..\chapter3\02_Lexical_Structure.html#identifier_list)  
+> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_  
+> *标识符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_  
+> *标识符* → [*隐式参数名*](../chapter3/02_Lexical_Structure.html#implicit_parameter_name)  
+> *标识符集* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) | [*标识符*](../chapter3/02_Lexical_Structure.html#identifier) **,** [*标识符集*](../chapter3/02_Lexical_Structure.html#identifier_list)  
 > *标识符头(Head)* → Upper- or lowercase letter A through Z
 
 > *标识符头(Head)* → _
@@ -738,14 +742,14 @@ _________________
 > *标识符头(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD  
 > *标识符字符* → 数值 0 到 9  
 > *标识符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F  
-> *标识符字符* → [*标识符头(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head)  
-> *标识符字符集* → [*标识符字符*](..\chapter3\02_Lexical_Structure.html#identifier_character) [*标识符字符集*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可选_  
-> *隐式参数名* → **$** [*十进制数字集*](..\chapter3\02_Lexical_Structure.html#decimal_digits)  
+> *标识符字符* → [*标识符头(Head)*](../chapter3/02_Lexical_Structure.html#identifier_head)  
+> *标识符字符集* → [*标识符字符*](../chapter3/02_Lexical_Structure.html#identifier_character) [*标识符字符集*](../chapter3/02_Lexical_Structure.html#identifier_characters) _可选_  
+> *隐式参数名* → **$** [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits)  
 
 <!-- -->
 
 > 字面量语法  
-> *字面量* → [*数值型字面量*](..\chapter3\02_Lexical_Structure.html#integer_literal) | [*字符串字面量*](..\chapter3\02_Lexical_Structure.html#floating_point_literal) | [*布尔字面量*](..\chapter3\02_Lexical_Structure.html#string_literal) | [*空字面量*](TODO) 
+> *字面量* → [*数值型字面量*](../chapter3/02_Lexical_Structure.html#integer_literal) | [*字符串字面量*](../chapter3/02_Lexical_Structure.html#floating_point_literal) | [*布尔字面量*](../chapter3/02_Lexical_Structure.html#string_literal) | [*空字面量*](TODO) 
 
 > *数值型字面量* → **-** _可选_ [*整形字面量*](TODO) | **-** _可选_ [*浮点型字面量*](TODO)
 
@@ -756,38 +760,38 @@ _________________
 <!-- -->
 
 > 整型字面量语法  
-> *整型字面量* → [*二进制字面量*](..\chapter3\02_Lexical_Structure.html#binary_literal)  
-> *整型字面量* → [*八进制字面量*](..\chapter3\02_Lexical_Structure.html#octal_literal)  
-> *整型字面量* → [*十进制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)  
-> *整型字面量* → [*十六进制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)  
-> *二进制字面量* → **0b** [*二进制数字*](..\chapter3\02_Lexical_Structure.html#binary_digit) [*二进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可选_  
+> *整型字面量* → [*二进制字面量*](../chapter3/02_Lexical_Structure.html#binary_literal)  
+> *整型字面量* → [*八进制字面量*](../chapter3/02_Lexical_Structure.html#octal_literal)  
+> *整型字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal)  
+> *整型字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal)  
+> *二进制字面量* → **0b** [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_  
 > *二进制数字* → 数值 0 到 1  
-> *二进制字面量字符* → [*二进制数字*](..\chapter3\02_Lexical_Structure.html#binary_digit) | **_**  
-> *二进制字面量字符集* → [*二进制字面量字符*](..\chapter3\02_Lexical_Structure.html#binary_literal_character) [*二进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可选_  
-> *八进制字面量* → **0o** [*八进制数字*](..\chapter3\02_Lexical_Structure.html#octal_digit) [*八进制字符集*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可选_  
+> *二进制字面量字符* → [*二进制数字*](../chapter3/02_Lexical_Structure.html#binary_digit) | **_**  
+> *二进制字面量字符集* → [*二进制字面量字符*](../chapter3/02_Lexical_Structure.html#binary_literal_character) [*二进制字面量字符集*](../chapter3/02_Lexical_Structure.html#binary_literal_characters) _可选_  
+> *八进制字面量* → **0o** [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_  
 > *八进字数字* → 数值 0 到 7  
-> *八进制字符* → [*八进制数字*](..\chapter3\02_Lexical_Structure.html#octal_digit) | **_**  
-> *八进制字符集* → [*八进制字符*](..\chapter3\02_Lexical_Structure.html#octal_literal_character) [*八进制字符集*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可选_  
-> *十进制字面量* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十进制字符集*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可选_  
+> *八进制字符* → [*八进制数字*](../chapter3/02_Lexical_Structure.html#octal_digit) | **_**  
+> *八进制字符集* → [*八进制字符*](../chapter3/02_Lexical_Structure.html#octal_literal_character) [*八进制字符集*](../chapter3/02_Lexical_Structure.html#octal_literal_characters) _可选_  
+> *十进制字面量* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_  
 > *十进制数字* → 数值 0 到 9  
-> *十进制数字集* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十进制数字集*](..\chapter3\02_Lexical_Structure.html#decimal_digits) _可选_  
-> *十进制字面量字符* → [*十进制数字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) | **_**  
-> *十进制字面量字符集* → [*十进制字面量字符*](..\chapter3\02_Lexical_Structure.html#decimal_literal_character) [*十进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可选_  
-> *十六进制字面量* → **0x** [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
+> *十进制数字集* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) [*十进制数字集*](../chapter3/02_Lexical_Structure.html#decimal_digits) _可选_  
+> *十进制字面量字符* → [*十进制数字*](../chapter3/02_Lexical_Structure.html#decimal_digit) | **_**  
+> *十进制字面量字符集* → [*十进制字面量字符*](../chapter3/02_Lexical_Structure.html#decimal_literal_character) [*十进制字面量字符集*](../chapter3/02_Lexical_Structure.html#decimal_literal_characters) _可选_  
+> *十六进制字面量* → **0x** [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
 > *十六进制数字* → 数值 0 到 9, a through f, or A through F  
-> *十六进制字符* → [*十六进制数字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) | **_**  
-> *十六进制字面量字符集* → [*十六进制字符*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_character) [*十六进制字面量字符集*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
+> *十六进制字符* → [*十六进制数字*](../chapter3/02_Lexical_Structure.html#hexadecimal_digit) | **_**  
+> *十六进制字面量字符集* → [*十六进制字符*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_character) [*十六进制字面量字符集*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal_characters) _可选_  
 
 <!-- -->
 
 > 浮点型字面量语法  
-> *浮点数字面量* → [*十进制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal) [*十进制分数*](..\chapter3\02_Lexical_Structure.html#decimal_fraction) _可选_ [*十进制指数*](..\chapter3\02_Lexical_Structure.html#decimal_exponent) _可选_  
-> *浮点数字面量* → [*十六进制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal) [*十六进制分数*](..\chapter3\02_Lexical_Structure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](..\chapter3\02_Lexical_Structure.html#hexadecimal_exponent)  
-> *十进制分数* → **.** [*十进制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)  
-> *十进制指数* → [*浮点数e*](..\chapter3\02_Lexical_Structure.html#floating_point_e) [*正负号*](..\chapter3\02_Lexical_Structure.html#sign) _可选_ [*十进制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)  
-> *十六进制分数* → **.** [*十六进制数*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)   
+> *浮点数字面量* → [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal) [*十进制分数*](../chapter3/02_Lexical_Structure.html#decimal_fraction) _可选_ [*十进制指数*](../chapter3/02_Lexical_Structure.html#decimal_exponent) _可选_  
+> *浮点数字面量* → [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal) [*十六进制分数*](../chapter3/02_Lexical_Structure.html#hexadecimal_fraction) _可选_ [*十六进制指数*](../chapter3/02_Lexical_Structure.html#hexadecimal_exponent)  
+> *十进制分数* → **.** [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal)  
+> *十进制指数* → [*浮点数e*](../chapter3/02_Lexical_Structure.html#floating_point_e) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十进制字面量*](../chapter3/02_Lexical_Structure.html#decimal_literal)  
+> *十六进制分数* → **.** [*十六进制数*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal)   
  [*十六进制字面量字符集*](TODO)_可选_  
-> *十六进制指数* → [*浮点数p*](..\chapter3\02_Lexical_Structure.html#floating_point_p) [*正负号*](..\chapter3\02_Lexical_Structure.html#sign) _可选_ [*十六进制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)  
+> *十六进制指数* → [*浮点数p*](../chapter3/02_Lexical_Structure.html#floating_point_p) [*正负号*](../chapter3/02_Lexical_Structure.html#sign) _可选_ [*十六进制字面量*](../chapter3/02_Lexical_Structure.html#hexadecimal_literal)  
 > *浮点数e* → **e** | **E**  
 > *浮点数p* → **p** | **P**  
 > *正负号* → **+** | **-**  
@@ -795,19 +799,19 @@ _________________
 <!-- -->
 
 > 字符串型字面量语法  
-> *字符串字面量* → **"** [*引用文本*](..\chapter3\02_Lexical_Structure.html#quoted_text) **"**  
-> *引用文本* → [*引用文本条目*](..\chapter3\02_Lexical_Structure.html#quoted_text_item) [*引用文本*](..\chapter3\02_Lexical_Structure.html#quoted_text) _可选_  
-> *引用文本条目* → [*转义字符*](..\chapter3\02_Lexical_Structure.html#escaped_character)  
-> *引用文本条目* → **(** [*表达式*](..\chapter3\04_Expressions.html#expression) **)**  
+> *字符串字面量* → **"** [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) **"**  
+> *引用文本* → [*引用文本条目*](../chapter3/02_Lexical_Structure.html#quoted_text_item) [*引用文本*](../chapter3/02_Lexical_Structure.html#quoted_text) _可选_  
+> *引用文本条目* → [*转义字符*](../chapter3/02_Lexical_Structure.html#escaped_character)  
+> *引用文本条目* → **(** [*表达式*](../chapter3/04_Expressions.html#expression) **)**  
 > *引用文本条目* → 除了"­, \­, U+000A, or U+000D的所有Unicode的字符  
-> *转义字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**  
+> *转义字符* → **/0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**  
 > *转义字符* → **\u** **{** [*十六进制标量数字集*](TODO) **}**   
 > *unicode标量数字集* → Between one and eight hexadecimal digits
 
 <!-- -->
 
 > 运算符语法语法  
-> *运算符* → [*运算符头*](..\chapter3\02_Lexical_Structure.html#operator_character) [*运算符字符集*](..\chapter3\02_Lexical_Structure.html#operator) _可选_
+> *运算符* → [*运算符头*](../chapter3/02_Lexical_Structure.html#operator_character) [*运算符字符集*](../chapter3/02_Lexical_Structure.html#operator) _可选_
 > *运算符* → [*点运算符头*](TODO) [*点运算符字符集*](TODO) _可选_  
 > *运算符字符* → **/** | **=** | **-** | **+** | **!** | **&#42;** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **?**  
 > *运算符头* → U+00A1–U+00A7
@@ -860,46 +864,46 @@ _________________
 
 > *点运算符字符集* → [*点运算符字符*](TODO) [*点运算符字符集*](TODO) _可选_
  
-> *二元运算符* → [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
-> *前置运算符* → [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
-> *后置运算符* → [*运算符*](..\chapter3\02_Lexical_Structure.html#operator)  
+> *二元运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator)  
+> *前置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator)  
+> *后置运算符* → [*运算符*](../chapter3/02_Lexical_Structure.html#operator)  
 
 <a name="types"></a>
 ## 类型
 
 > 类型语法  
-> *类型* → [*数组类型*](..\chapter3\03_Types.html#array_type) | [*字典类型*](TODO) | [*函数类型*](..\chapter3\03_Types.html#function_type) | [*类型标识符*](..\chapter3\03_Types.html#type_identifier) | [*元组类型*](..\chapter3\03_Types.html#tuple_type) | [*可选类型*](..\chapter3\03_Types.html#optional_type) | [*隐式解析可选类型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型类型*](..\chapter3\03_Types.html#metatype_type)  
+> *类型* → [*数组类型*](../chapter3/03_Types.html#array_type) | [*字典类型*](TODO) | [*函数类型*](../chapter3/03_Types.html#function_type) | [*类型标识符*](../chapter3/03_Types.html#type_identifier) | [*元组类型*](../chapter3/03_Types.html#tuple_type) | [*可选类型*](../chapter3/03_Types.html#optional_type) | [*隐式解析可选类型*](../chapter3/03_Types.html#implicitly_unwrapped_optional_type) | [*协议合成类型*](../chapter3/03_Types.html#protocol_composition_type) | [*元型类型*](../chapter3/03_Types.html#metatype_type)  
 
 <!-- -->
 
 > 类型注解语法  
-> *类型注解* → **:** [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ [*类型*](..\chapter3\03_Types.html#type)  
+> *类型注解* → **:** [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ [*类型*](../chapter3/03_Types.html#type)  
 
 <!-- -->
 
 > 类型标识语法  
-> *类型标识* → [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](..\chapter3\03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识符*](..\chapter3\03_Types.html#type_identifier)  
-> *类型名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *类型标识* → [*类型名称*](../chapter3/03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ | [*类型名称*](../chapter3/03_Types.html#type_name) [*泛型参数从句*](GenericParametersAndArguments.html#generic_argument_clause) _可选_ **.** [*类型标识符*](../chapter3/03_Types.html#type_identifier)  
+> *类型名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
 
 <!-- -->
 
 > 元组类型语法  
-> *元组类型* → **(** [*元组类型主体*](..\chapter3\03_Types.html#tuple_type_body) _可选_ **)**  
-> *元组类型主体* → [*元组类型的元素集*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可选_  
-> *元组类型的元素集* → [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元组类型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元组类型的元素集*](..\chapter3\03_Types.html#tuple_type_element_list)  
-> *元组类型的元素* → [*属性(Attributes)集*](..\chapter3\06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](..\chapter3\03_Types.html#type) | **inout** _可选_ [*元素名*](..\chapter3\03_Types.html#element_name) [*类型注解*](..\chapter3\03_Types.html#type_annotation)  
-> *元素名* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
+> *元组类型* → **(** [*元组类型主体*](../chapter3/03_Types.html#tuple_type_body) _可选_ **)**  
+> *元组类型主体* → [*元组类型的元素集*](../chapter3/03_Types.html#tuple_type_element_list) **...** _可选_  
+> *元组类型的元素集* → [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) | [*元组类型的元素*](../chapter3/03_Types.html#tuple_type_element) **,** [*元组类型的元素集*](../chapter3/03_Types.html#tuple_type_element_list)  
+> *元组类型的元素* → [*属性(Attributes)集*](../chapter3/06_Attributes.html#attributes) _可选_ **inout** _可选_ [*类型*](../chapter3/03_Types.html#type) | **inout** _可选_ [*元素名*](../chapter3/03_Types.html#element_name) [*类型注解*](../chapter3/03_Types.html#type_annotation)  
+> *元素名* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
 
 <!-- -->
 
 > 函数类型语法  
-> *函数类型* → [*类型*](..\chapter3\03_Types.html#type)  **throws** _可选_ **->** [*类型*](..\chapter3\03_Types.html#type)  
+> *函数类型* → [*类型*](../chapter3/03_Types.html#type)  **throws** _可选_ **->** [*类型*](../chapter3/03_Types.html#type)  
 > *函数类型* → [*类型*](TODO)  **rethrows** **->** [*类型*](TODO) 
 
 <!-- -->
 
 > 数组类型语法  
-> *数组类型* → **[** [*类型*](..\chapter3\03_Types.html#array_type) **]**  
+> *数组类型* → **[** [*类型*](../chapter3/03_Types.html#array_type) **]**  
 
 <!-- -->
 > 字典类型语法
@@ -908,35 +912,35 @@ _________________
 <!-- -->
 
 > 可选类型语法  
-> *可选类型* → [*类型*](..\chapter3\03_Types.html#type) **?**  
+> *可选类型* → [*类型*](../chapter3/03_Types.html#type) **?**  
 
 <!-- -->
 
 > 隐式解析可选类型(Implicitly Unwrapped Optional Type)语法  
-> *隐式解析可选类型* → [*类型*](..\chapter3\03_Types.html#type) **!**  
+> *隐式解析可选类型* → [*类型*](../chapter3/03_Types.html#type) **!**  
 
 <!-- -->
 
 > 协议合成类型语法  
-> *协议合成类型* → **protocol** **<** [*协议标识符集*](..\chapter3\03_Types.html#protocol_identifier_list) _可选_ **>**  
-> *协议标识符集* → [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) | [*协议标识符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*协议标识符集*](..\chapter3\03_Types.html#protocol_identifier_list)  
-> *协议标识符* → [*类型标识符*](..\chapter3\03_Types.html#type_identifier)  
+> *协议合成类型* → **protocol** **<** [*协议标识符集*](../chapter3/03_Types.html#protocol_identifier_list) _可选_ **>**  
+> *协议标识符集* → [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) | [*协议标识符*](../chapter3/03_Types.html#protocol_identifier) **,** [*协议标识符集*](../chapter3/03_Types.html#protocol_identifier_list)  
+> *协议标识符* → [*类型标识符*](../chapter3/03_Types.html#type_identifier)  
 
 <!-- -->
 
 > 元(Metatype)类型语法  
-> *元类型* → [*类型*](..\chapter3\03_Types.html#type) **.** **Type** | [*类型*](..\chapter3\03_Types.html#type) **.** **Protocol**  
+> *元类型* → [*类型*](../chapter3/03_Types.html#type) **.** **Type** | [*类型*](../chapter3/03_Types.html#type) **.** **Protocol**  
 
 <!-- -->
 
 > 类型继承从句语法  
 
-> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) **,** [*类型继承集*](..\chapter3\03_Types.html#type_inheritance_list) 
+> *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list) 
 
 > *类型继承从句* → **:** [*类条件(class-requirement))*](TODO) 
 
 > *类型继承从句* → **:** [*类型继承集*](TODO)  
 
-> *类型继承集* → [*类型标识符*](..\chapter3\03_Types.html#type_identifier) | [*类型标识符*](..\chapter3\03_Types.html#type_identifier) **,** [*类型继承集*](..\chapter3\03_Types.html#type_inheritance_list)
+> *类型继承集* → [*类型标识符*](../chapter3/03_Types.html#type_identifier) | [*类型标识符*](../chapter3/03_Types.html#type_identifier) **,** [*类型继承集*](../chapter3/03_Types.html#type_inheritance_list)
 
 > *类条件* → **class** 
diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index d4e49cde..5c2556ba 100755
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -1,6 +1,10 @@
-> 翻译：[coverxit](https://github.com/coverxit),[littledogboy](https://github.com/littledogboy)  
-> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),[littledogboy](https://github.com/littledogboy)
-
+> 1.0
+> 翻译：[coverxit](https://github.com/coverxit) 
+> 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),
+
+> 2.0
+> 翻译+校对：[littledogboy](https://github.com/littledogboy)
+
 <a name="statement_statements"></a>
 # 语句
 -----------------
@@ -19,14 +23,14 @@
 是否将分号（`;`）添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句，请务必使用分号。
 
 > 语句语法  
-> *语句* → [*表达式*](..\chapter3\04_Expressions.html#expression) **;** _可选_  
-> *语句* → [*声明*](..\chapter3\05_Declarations.html#declaration) **;** _可选_  
-> *语句* → [*循环语句*](..\chapter3\10_Statements.html#loop_statement) **;** _可选_  
-> *语句* → [*分支语句*](..\chapter3\10_Statements.html#branch_statement) **;** _可选_  
-> *语句* → [*标记语句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)  
-> *语句* → [*控制转移语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_  
-> *语句* → [*XXX语句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可选_     
-> *多条语句(Statements)* → [*语句*](..\chapter3\10_Statements.html#statement) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) _可选_  
+> *语句* → [*表达式*](../chapter3/04_Expressions.html#expression) **;** _可选_  
+> *语句* → [*声明*](../chapter3/05_Declarations.html#declaration) **;** _可选_  
+> *语句* → [*循环语句*](../chapter3/10_Statements.html#loop_statement) **;** _可选_  
+> *语句* → [*分支语句*](../chapter3/10_Statements.html#branch_statement) **;** _可选_  
+> *语句* → [*标记语句(Labeled Statement)*](../chapter3/10_Statements.html#labeled_statement)  
+> *语句* → [*控制转移语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_  
+> *语句* → [*XXX语句*](../chapter3/10_Statements.html#control_transfer_statement) **;** _可选_     
+> *多条语句(Statements)* → [*语句*](../chapter3/10_Statements.html#statement) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) _可选_  
 
 <a name="loop_statements"></a>
 ## 循环语句
@@ -36,11 +40,11 @@
 通过`break`语句和`continue`语句可以改变循环语句的控制流。有关这两条语句，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
 
 > 循环语句语法  
-> *循环语句* → [*for语句*](..\chapter3\10_Statements.html#for_statement)  
-> *循环语句* → [*for-in语句*](..\chapter3\10_Statements.html#for_in_statement)  
-> *循环语句* → [*while语句*](..\chapter3\10_Statements.html#wheetatype类型ile_statement)  
-> *循环语句* → [*do-while语句*](..\chapter3\10_Statements.html#do_while_statement)  
-
+> *循环语句* → [*for语句*](../chapter3/10_Statements.html#for_statement)  
+> *循环语句* → [*for-in语句*](../chapter3/10_Statements.html#for_in_statement)  
+> *循环语句* → [*while语句*](../chapter3/10_Statements.html#wheetatype类型ile_statement)  
+> *循环语句* → [*do-while语句*](../chapter3/10_Statements.html#do_while_statement)  
+
 <a name="for_statements"></a>
 ### For 语句
 
@@ -64,11 +68,11 @@
 在 *initialzation* 中定义的变量仅在`for`循环的作用域内有效。*condition* 表达式的值的类型必须遵循`BooleanType `协议。
 
 > For 循环语法  
-> *for语句* → **for** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *for语句* → **for** **(** [*for初始条件*](..\chapter3\10_Statements.html#for_init) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **;** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_ **)** [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *for初始条件* → [*变量声明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表达式列表*](..\chapter3\04_Expressions.html#expression_list)  
-
-
+> *for语句* → **for** [*for初始条件*](../chapter3/10_Statements.html#for_init) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *for语句* → **for** **(** [*for初始条件*](../chapter3/10_Statements.html#for_init) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **;** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_ **)** [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *for初始条件* → [*变量声明*](../chapter3/05_Declarations.html#variable_declaration) | [*表达式列表*](../chapter3/04_Expressions.html#expression_list)  
+
+
 <a name="for-in_statements"></a>
 ### For-In 语句
 
@@ -83,9 +87,9 @@
 `for-in`语句在循环开始前会调用 *collection* 表达式的`generate`方法来获取一个生成器类型（这是一个遵循`Generator`协议的类型）的值。接下来循环开始，调用 *collection* 表达式的`next`方法。如果其返回值不是`None`，它将会被赋给 *item*，然后执行 *statements*，执行完毕后回到循环开始处；否则，将不会赋值给 *item* 也不会执行 *statements*，`for-in`至此执行完毕。
 
 > For-In 循环语法  
-> *for-in语句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表达式*](..\chapter3\04_Expressions.html#expression) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-
-
+> *for-in语句* → **for** [*模式*](../chapter3/07_Patterns.html#pattern) **in** [*表达式*](../chapter3/04_Expressions.html#expression) [*代码块*](../chapter3/05_Declarations.html#code_block)  
+
+
 <a name="while_statements"></a>
 ### While 语句
 
@@ -108,21 +112,21 @@
 *condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
 
 > While 循环语法  
-> *while语句* → **while** [*while条件*](..\chapter3\10_Statements.html#while_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block)  
-> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)   
-> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression)   
-> *条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*条件列表*](TODO)    
-> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [*表达式*](..\chapter3\04_Expressions.html#expression)    
-> *条件列表* → [*条件条件*](TODO)  [*条件列表*](TODO)      
-> *条件* → [*可用条件*](..\chapter3\10_Statement.html#availability) [可选绑定条件](../chapter2/01_The_Basics.html#optional_binding)    
-> *case条件* → **case** [*模式*](..\chapter3\07_Patterns.html#pattern) [构造器](TODO) [where](DOTO)    
-> *可选绑定条件* → [可选绑定头](TODO) [持续可选绑定](TODO) [持续可选绑定列表](TODO)    
-> *可选绑定头* → **let** [*模式*](..\chapter3\07_Patterns.html#pattern)  [构造器](TODO)  **var**  [*模式*](..\chapter3\07_Patterns.html#pattern)  [构造器](TODO)    
->  *可持续绑定列表* →  [*模式*](..\chapter3\07_Patterns.html#pattern) |  [构造器](TODO) [可选绑定头](TODO)
-> 
-
-
-
+> *while语句* → **while** [*while条件*](../chapter3/10_Statements.html#while_condition) [*代码块*](../chapter3/05_Declarations.html#code_block)  
+> *条件* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*声明*](../chapter3/05_Declarations.html#declaration)   
+> *条件* → [*表达式*](../chapter3/04_Expressions.html#expression)   
+> *条件* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*条件列表*](TODO)    
+> *条件* → [*可用条件*](../chapter3/10_Statement.html#availability) [*表达式*](../chapter3/04_Expressions.html#expression)    
+> *条件列表* → [*条件条件*](TODO)  [*条件列表*](TODO)      
+> *条件* → [*可用条件*](../chapter3/10_Statement.html#availability) [可选绑定条件](../chapter2/01_The_Basics.html#optional_binding)    
+> *case条件* → **case** [*模式*](../chapter3/07_Patterns.html#pattern) [构造器](TODO) [where](DOTO)    
+> *可选绑定条件* → [可选绑定头](TODO) [持续可选绑定](TODO) [持续可选绑定列表](TODO)    
+> *可选绑定头* → **let** [*模式*](../chapter3/07_Patterns.html#pattern)  [构造器](TODO)  **var**  [*模式*](../chapter3/07_Patterns.html#pattern)  [构造器](TODO)    
+>  *可持续绑定列表* →  [*模式*](../chapter3/07_Patterns.html#pattern) |  [构造器](TODO) [可选绑定头](TODO)
+> 
+
+
+
 <a name="while-while_statements"></a>
 ### Repeat-While 语句
 
@@ -145,7 +149,7 @@
 *condition* 表达式的值的类型必须遵循`BooleanType `协议。同时，*condition* 表达式也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
 
 > Repeat-While 循环语法  
-> * repeat-while语句* → **repeat** [*代码块*](..\chapter3\05_Declarations.html#code_block) **while** [*while条件*](..\chapter3\10_Statements.html#while_condition)  
+> * repeat-while语句* → **repeat** [*代码块*](../chapter3/05_Declarations.html#code_block) **while** [*while条件*](../chapter3/10_Statements.html#while_condition)  
 
 <a name="branch_statements"></a>
 ## 分支语句
@@ -155,10 +159,10 @@
 `switch`语句中的控制流可以用`break`语句修改，详情请见[Break 语句](#break_statement)。
 
 > 分支语句语法  
-> *分支语句* → [*if语句*](..\chapter3\10_Statements.html#if_statement)  
-> *分支语句* → [*switch语句*](..\chapter3\10_Statements.html#switch_statement)  
-
-
+> *分支语句* → [*if语句*](../chapter3/10_Statements.html#if_statement)  
+> *分支语句* → [*switch语句*](../chapter3/10_Statements.html#switch_statement)  
+
+
 <a name="if_statements"></a>
 ### If 语句
 
@@ -194,34 +198,34 @@
 `if`语句中条件的值的类型必须遵循`LogicValue`协议。同时，条件也可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
 
 > If语句语法  
-> *if语句* → **if** [*if条件*](..\chapter3\10_Statements.html#if_condition) [*代码块*](..\chapter3\05_Declarations.html#code_block) [*else(Clause)*](..\chapter3\10_Statements.html#else_clause) _可选_  
-> *if条件* → [*表达式*](..\chapter3\04_Expressions.html#expression) | [*声明*](..\chapter3\05_Declarations.html#declaration)  
-> *else(Clause)* → **else** [*代码块*](..\chapter3\05_Declarations.html#code_block) | **else** [*if语句*](..\chapter3\10_Statements.html#if_statement)     
-
-
-<a name="guard_statements"></a>
-### Guard 语句    
-    
-`guard` 语句用来转移程序控制出其作用域，如果一个或者多个条件不成立。
- `guard` 语句的格式如下：    
- > guard `condition` else {    
-   `statements`    
- >}    
- 
- `guard`语句中条件值的类型必须遵循`LogicValue`协议。且条件可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
- 
- 在`guard`语句中声明的常量或者变量，可用范围从声明开始到作用域结束,常量和变量的值从可选绑定声明中分配。
- 
- `guard`语句需要有`else`子句，并且必须调用被`noreturn`属性标记的函数,或者使用下面的语句把程序执行转移到guard语句的作用域外。    
- 
- *  `return`
- *  `break`
- *  `continue`
- *  `throw`    
- 
-执行转移语句详情参见[控制传递语句](TODO)
-
-
+> *if语句* → **if** [*if条件*](../chapter3/10_Statements.html#if_condition) [*代码块*](../chapter3/05_Declarations.html#code_block) [*else(Clause)*](../chapter3/10_Statements.html#else_clause) _可选_  
+> *if条件* → [*表达式*](../chapter3/04_Expressions.html#expression) | [*声明*](../chapter3/05_Declarations.html#declaration)  
+> *else(Clause)* → **else** [*代码块*](../chapter3/05_Declarations.html#code_block) | **else** [*if语句*](../chapter3/10_Statements.html#if_statement)     
+
+
+<a name="guard_statements"></a>
+### Guard 语句    
+    
+`guard` 语句用来转移程序控制出其作用域，如果一个或者多个条件不成立。
+ `guard` 语句的格式如下：    
+ > guard `condition` else {    
+   `statements`    
+ >}    
+ 
+ `guard`语句中条件值的类型必须遵循`LogicValue`协议。且条件可以使用可选绑定，详情参见[可选绑定](../chapter2/01_The_Basics.html#optional_binding)。
+ 
+ 在`guard`语句中声明的常量或者变量，可用范围从声明开始到作用域结束,常量和变量的值从可选绑定声明中分配。
+ 
+ `guard`语句需要有`else`子句，并且必须调用被`noreturn`属性标记的函数,或者使用下面的语句把程序执行转移到guard语句的作用域外。    
+ 
+ *  `return`
+ *  `break`
+ *  `continue`
+ *  `throw`    
+ 
+执行转移语句详情参见[控制传递语句](TODO)
+
+
 <a name="switch_statements"></a>
 ### Switch 语句
 
@@ -266,18 +270,18 @@ case let (x, y) where x == y:
 当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这就意味着，如果你想执行下一个 case 分支，需要显式地在你需要的 case 分支里使用`fallthrough`语句。关于`fallthrough`语句的更多信息，详情参见 [Fallthrough 语句](#fallthrough_statement)。
 
 > Switch语句语法  
-> *switch语句* → **switch** [*表达式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_ **}**  
-> *SwitchCase列表* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可选_  
-> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default标签*](..\chapter3\10_Statements.html#default_label) [*多条语句(Statements)*](..\chapter3\10_Statements.html#statements)  
-> *SwitchCase* → [*case标签*](..\chapter3\10_Statements.html#case_label) **;** | [*default标签*](..\chapter3\10_Statements.html#default_label) **;**  
-> *case标签* → **case** [*case项列表*](..\chapter3\10_Statements.html#case_item_list) **:**  
-> *case项列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](..\chapter3\10_Statements.html#case_item_list)  
+> *switch语句* → **switch** [*表达式*](../chapter3/04_Expressions.html#expression) **{** [*SwitchCase列表*](../chapter3/10_Statements.html#switch_cases) _可选_ **}**  
+> *SwitchCase列表* → [*SwitchCase*](../chapter3/10_Statements.html#switch_case) [*SwitchCase列表*](../chapter3/10_Statements.html#switch_cases) _可选_  
+> *SwitchCase* → [*case标签*](../chapter3/10_Statements.html#case_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements) | [*default标签*](../chapter3/10_Statements.html#default_label) [*多条语句(Statements)*](../chapter3/10_Statements.html#statements)  
+> *SwitchCase* → [*case标签*](../chapter3/10_Statements.html#case_label) **;** | [*default标签*](../chapter3/10_Statements.html#default_label) **;**  
+> *case标签* → **case** [*case项列表*](../chapter3/10_Statements.html#case_item_list) **:**  
+> *case项列表* → [*模式*](../chapter3/07_Patterns.html#pattern) [*guard-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ | [*模式*](../chapter3/07_Patterns.html#pattern) [*guard-clause*](../chapter3/10_Statements.html#guard_clause) _可选_ **,** [*case项列表*](../chapter3/10_Statements.html#case_item_list)  
 > *default标签* → **default** **:**  
-> *where-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard)  
-> *where-expression* → [*表达式*](..\chapter3\04_Expressions.html#expression)  
+> *where-clause* → **where** [*guard-expression*](../chapter3/10_Statements.html#guard)  
+> *where-expression* → [*表达式*](../chapter3/04_Expressions.html#expression)  
 
 <a name="labeled_statements"></a>
-<a name="control_transfer_statements"></a>
+<a name="control_transfer_statements"></a>
 ## 带标签的语句
 
 你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，详情参见 [Break 语句](#break_statement)和 [Continue 语句](#continue_statement)。
@@ -287,21 +291,21 @@ case let (x, y) where x == y:
 关于使用带标签的语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
 
 > 标记语句语法  
-> *标记语句(Labeled Statement)* → [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*循环语句*](..\chapter3\10_Statements.html#loop_statement) | [*语句标签*](..\chapter3\10_Statements.html#statement_label) [*switch语句*](..\chapter3\10_Statements.html#switch_statement)  
-> *语句标签* → [*标签名称*](..\chapter3\10_Statements.html#label_name) **:**  
-> *标签名称* → [*标识符*](..\chapter3\02_Lexical_Structure.html#identifier)  
-
+> *标记语句(Labeled Statement)* → [*语句标签*](../chapter3/10_Statements.html#statement_label) [*循环语句*](../chapter3/10_Statements.html#loop_statement) | [*语句标签*](../chapter3/10_Statements.html#statement_label) [*switch语句*](../chapter3/10_Statements.html#switch_statement)  
+> *语句标签* → [*标签名称*](../chapter3/10_Statements.html#label_name) **:**  
+> *标签名称* → [*标识符*](../chapter3/02_Lexical_Structure.html#identifier)  
+
 <a name="control_transfer_statements"></a>
 ## 控制传递语句
 
 通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。
 
 > 控制传递语句(Control Transfer Statement) 语法  
-> *控制传递语句* → [*break语句*](..\chapter3\10_Statements.html#break_statement)  
-> *控制传递语句* → [*continue语句*](..\chapter3\10_Statements.html#continue_statement)  
-> *控制传递语句* → [*fallthrough语句*](..\chapter3\10_Statements.html#fallthrough_statement)  
-> *控制传递语句* → [*return语句*](..\chapter3\10_Statements.html#return_statement)     
-> *控制传递语句* → [*throw语句*](..\chapter3\10_Statements.html#throw_statement)  
+> *控制传递语句* → [*break语句*](../chapter3/10_Statements.html#break_statement)  
+> *控制传递语句* → [*continue语句*](../chapter3/10_Statements.html#continue_statement)  
+> *控制传递语句* → [*fallthrough语句*](../chapter3/10_Statements.html#fallthrough_statement)  
+> *控制传递语句* → [*return语句*](../chapter3/10_Statements.html#return_statement)     
+> *控制传递语句* → [*throw语句*](../chapter3/10_Statements.html#throw_statement)  
 
 <a name="break_statements"></a>
 ### Break 语句
@@ -320,7 +324,7 @@ case let (x, y) where x == y:
 关于使用`break`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Break](../chapter2/05_Control_Flow.html#break) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
 
 > Break 语句语法  
-> *break语句* → **break** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_  
+> *break语句* → **break** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_  
 
 <a name="continue_statements"></a>
 ### Continue 语句
@@ -341,7 +345,7 @@ case let (x, y) where x == y:
 关于使用`continue`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的 [Continue](../chapter2/05_Control_Flow.html#continue) 和[带标签的语句](../chapter2/05_Control_Flow.html#labeled_statements)。
 
 > Continue 语句语法  
-> *continue语句* → **continue** [*标签名称*](..\chapter3\10_Statements.html#label_name) _可选_  
+> *continue语句* → **continue** [*标签名称*](../chapter3/10_Statements.html#label_name) _可选_  
 
 <a name="fallthrough_statements"></a>
 ### Fallthrough 语句
@@ -353,7 +357,7 @@ case let (x, y) where x == y:
 关于在`switch`语句中使用`fallthrough`语句的例子，详情参见[控制流](../chapter2/05_Control_Flow.html)一章的[控制传递语句](../chapter2/05_Control_Flow.html#control_transfer_statements)。
 
 > Fallthrough 语句语法  
-> *fallthrough语句* → **fallthrough**  
+> *fallthrough语句* → **fallthrough**  
 
 <a name="return_statements"></a>
 ### Return 语句
@@ -370,125 +374,125 @@ case let (x, y) where x == y:
 而当只写`return`时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为`Void`或`()`）
 
 > Return 语句语法  
-> *return语句* → **return** [*表达式*](..\chapter3\04_Expressions.html#expression) _可选_     
-
-<a name="availability_statements"></a>
-### Availability 语句    
-
-可用性条件，被当做`if` ，`while` 语句的条件，并且 `guard` 语句在运行时会基于特定的语法格式查询接口的可用性。    
-
-avaliability 语句的形式如下：
-> if #available(`platform name version`,` ...`, *) {    
->   `statements to execute if the APIs are available`    
-> } else {    
->  `fallback statements to execute if the APIs are unavailable`   
-> }    
-
-可用性条件执行一个代码块时，取决于在运行时想要使用的接口是否可用。
-当编译器检查到代码块中的接口是可用的，则从可用性条件中获取相应信息。    
-
-可用性条件使用逗号分隔平台名称和版本列表。使用`iOS`，`OSX`，以及`watchOS`为平台名称，包括相应的版本号。*参数是必需的。在任何平台上代码块主体都被可用性条件保护起来，由满足最低部署条件的目标设备运行。        
-   
-与布尔类型条件不同，不能用逻辑运算符 **&&** 和 **||** 合并可用性条件。 
-
-> 可用性条件语法    
-> *可用性条件* → **#available** ( [availability-arguments­](TODO) )    
-> *可用性条件* → [availability-argument­](TODO) |  [availability-argument](TODO)­ ,­ [availability-arguments­](TODO)    
-> *可用性条件* → [平台名称](TODO)  [版本号](TODO)    
-> *可用性条件* →   **\***    
-> *平台名称* →  **iOS** |  **iOSApplicationExtension**  
-> *平台名称* → **OSX**  |  **OSXApplicationExtension­**   
-> *平台名称* → **watchOS**     
-> *版本号* → [十进制数字](TODO)     
-> *版本号* → [十进制数字](TODO)  **.** [十进制数字](TODO)  
-> *版本号* → [十进制数字](TODO)  **.** [十进制数字](TODO) **.** [十进制数字](TODO)
-    
-
-<a name="throw_statements"></a>
-### Throw 语句    
-`throw`语句出现在抛出函数或者抛出方法体内，或者类型被`throws`关键字标记的表达式体内。   
- 
-`throw`语句使程序结束执行当前的作用域，并在封闭作用域中传播错误。抛出的错误会一直传播，直到被`do`语句的`catch`子句处理掉。    
-
-`throw`语句由`throw`关键字 跟一个表达式组成 ，如下所示。    
-
-> throw `expression`    
-
-表达式值的类型必须遵循 `LogicValue`协议     
-
-关于如何使用`throw`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。    
-
-> throw 语句语法    
-> *抛出语句* → **throw**  *[表达式­](TODO)*    
-
-<a name="defer_statements"></a>
-### Defer 语句
-
- `defer` 语句用于转移程序控制出延迟语句作用域之前执行代码。    
- 
-在 `defer` 语句中的语句无论程序控制如何转移都会执行。这意味着 `defer` 语句可以被使用在以下这些情况，像手动得执行资源管理，关闭文件描述，或者即使抛出了错误也需要去实现执行一些动作。    
-
-如果多个 `defer` 语句出现在同一范围内，那么它们执行的顺序与出现的顺序相反。给定作用域中的第一个`defer` 语句，会在最后执行，这意味着最后执行的延迟语句中的语句涉及的资源可以被其他 `defer`语句清理掉。    
-
-> 1  func f( ) {    
-> 2  defer { print("First") }    
-> 3  defer { print("Second") }    
-> 4  defer { print("Third") }    
-> 5  }    
-> 6  f()    
-> 7  // prints "Third"    
-> 8  // prints "Second"    
-> 9  // prints "First"    
-
-
-`defer` 语句中的语句无法转移程序控制出延迟语句。    
-
-> defer 语句语法        
-> *延迟语句*  → **defer** *[代码块](TODO)*    
-
-
-<a name="do_statements"></a>
-### Do 语句    
-
-`do` 语句用于引入一个新的作用域,该作用域中可以含有一个或多个`catch`子句,catch子句中定义了一些匹配错误情况的模式。`do` 语句作用域内定义的常量和变量，只能在do语句作用域内访问。    
-
-swift 中的 do 语句与C 中限定代码块界限的大括号 （{}）很相似，并且在程序运行的时候并不会造成系统开销。    
-
-> do {    
->    try `expression`    
->    `statements`    
-> } catch `pattern 1` {    
-    `statements`    
-> } catch `pattern 2` where condition {    
-    `statements`    
-> }    
-
-
-如同`switch`语句,编译器会判断`catch`子句是否被遗漏。如果catch没有被遗漏，则认为错误被处理。否则，错误会自动传播出包含作用域,被一个封闭的`catch`语句或抛出函数处理掉，包含函数必须以`throws`关键字声明。    
-
-    
-
-为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，`catch`子句会匹配和约束任何局部变量命名的`error`。有关在`catch`子句中使用模式的更多信息，详见[模式](TODO)。    
-
-关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。       
-
-> do 语句语法  → **do** *[*代码块*](..\chapter3\05_Declarations.html#code_block) [catch](TODO)*    
-> catch  → *[catch子句](TODO) [catch子句](TODO)*    
-> catch  → **catch** *[*模式*](..\chapter3\07_Patterns.html#pattern)** *可选的* [*where*]() *可选的*  [*代码块*](..\chapter3\05_Declarations.html#code_block)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- 
+> *return语句* → **return** [*表达式*](../chapter3/04_Expressions.html#expression) _可选_     
+
+<a name="availability_statements"></a>
+### Availability 语句    
+
+可用性条件，被当做`if` ，`while` 语句的条件，并且 `guard` 语句在运行时会基于特定的语法格式查询接口的可用性。    
+
+avaliability 语句的形式如下：
+> if #available(`platform name version`,` ...`, *) {    
+>   `statements to execute if the APIs are available`    
+> } else {    
+>  `fallback statements to execute if the APIs are unavailable`   
+> }    
+
+可用性条件执行一个代码块时，取决于在运行时想要使用的接口是否可用。
+当编译器检查到代码块中的接口是可用的，则从可用性条件中获取相应信息。    
+
+可用性条件使用逗号分隔平台名称和版本列表。使用`iOS`，`OSX`，以及`watchOS`为平台名称，包括相应的版本号。*参数是必需的。在任何平台上代码块主体都被可用性条件保护起来，由满足最低部署条件的目标设备运行。        
+   
+与布尔类型条件不同，不能用逻辑运算符 **&&** 和 **||** 合并可用性条件。 
+
+> 可用性条件语法    
+> *可用性条件* → **#available** ( [availability-arguments­](TODO) )    
+> *可用性条件* → [availability-argument­](TODO) |  [availability-argument](TODO)­ ,­ [availability-arguments­](TODO)    
+> *可用性条件* → [平台名称](TODO)  [版本号](TODO)    
+> *可用性条件* →   **\***    
+> *平台名称* →  **iOS** |  **iOSApplicationExtension**  
+> *平台名称* → **OSX**  |  **OSXApplicationExtension­**   
+> *平台名称* → **watchOS**     
+> *版本号* → [十进制数字](TODO)     
+> *版本号* → [十进制数字](TODO)  **.** [十进制数字](TODO)  
+> *版本号* → [十进制数字](TODO)  **.** [十进制数字](TODO) **.** [十进制数字](TODO)
+    
+
+<a name="throw_statements"></a>
+### Throw 语句    
+`throw`语句出现在抛出函数或者抛出方法体内，或者类型被`throws`关键字标记的表达式体内。   
+ 
+`throw`语句使程序结束执行当前的作用域，并在封闭作用域中传播错误。抛出的错误会一直传播，直到被`do`语句的`catch`子句处理掉。    
+
+`throw`语句由`throw`关键字 跟一个表达式组成 ，如下所示。    
+
+> throw `expression`    
+
+表达式值的类型必须遵循 `LogicValue`协议     
+
+关于如何使用`throw`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。    
+
+> throw 语句语法    
+> *抛出语句* → **throw**  *[表达式­](TODO)*    
+
+<a name="defer_statements"></a>
+### Defer 语句
+
+ `defer` 语句用于转移程序控制出延迟语句作用域之前执行代码。    
+ 
+在 `defer` 语句中的语句无论程序控制如何转移都会执行。这意味着 `defer` 语句可以被使用在以下这些情况，像手动得执行资源管理，关闭文件描述，或者即使抛出了错误也需要去实现执行一些动作。    
+
+如果多个 `defer` 语句出现在同一范围内，那么它们执行的顺序与出现的顺序相反。给定作用域中的第一个`defer` 语句，会在最后执行，这意味着最后执行的延迟语句中的语句涉及的资源可以被其他 `defer`语句清理掉。    
+
+> 1  func f( ) {    
+> 2  defer { print("First") }    
+> 3  defer { print("Second") }    
+> 4  defer { print("Third") }    
+> 5  }    
+> 6  f()    
+> 7  // prints "Third"    
+> 8  // prints "Second"    
+> 9  // prints "First"    
+
+
+`defer` 语句中的语句无法转移程序控制出延迟语句。    
+
+> defer 语句语法        
+> *延迟语句*  → **defer** *[代码块](TODO)*    
+
+
+<a name="do_statements"></a>
+### Do 语句    
+
+`do` 语句用于引入一个新的作用域,该作用域中可以含有一个或多个`catch`子句,catch子句中定义了一些匹配错误情况的模式。`do` 语句作用域内定义的常量和变量，只能在do语句作用域内访问。    
+
+swift 中的 do 语句与C 中限定代码块界限的大括号 （{}）很相似，并且在程序运行的时候并不会造成系统开销。    
+
+> do {    
+>    try `expression`    
+>    `statements`    
+> } catch `pattern 1` {    
+    `statements`    
+> } catch `pattern 2` where condition {    
+    `statements`    
+> }    
+
+
+如同`switch`语句,编译器会判断`catch`子句是否被遗漏。如果catch没有被遗漏，则认为错误被处理。否则，错误会自动传播出包含作用域,被一个封闭的`catch`语句或抛出函数处理掉，包含函数必须以`throws`关键字声明。    
+
+    
+
+为了确保错误已经被处理，使用一个匹配所有错误的`catch`子句，如通配符模式（_）。如果一个`catch`子句不指定一种模式，`catch`子句会匹配和约束任何局部变量命名的`error`。有关在`catch`子句中使用模式的更多信息，详见[模式](TODO)。    
+
+关于在一些`catch`子句中如何使用` do`语句的例子，详情参见[错误处理](TODO)一章的[抛出错误](TODO)。       
+
+> do 语句语法  → **do** *[*代码块*](../chapter3/05_Declarations.html#code_block) [catch](TODO)*    
+> catch  → *[catch子句](TODO) [catch子句](TODO)*    
+> catch  → **catch** *[*模式*](../chapter3/07_Patterns.html#pattern)** *可选的* [*where*]() *可选的*  [*代码块*](../chapter3/05_Declarations.html#code_block)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
 

From f939e079b1b81aebd0a8e6e4f7bbc2fc3911e1e8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Mon, 3 Aug 2015 14:44:29 +0800
Subject: [PATCH 144/228] Update README.md

---
 README.md | 51 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 42 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 352c17a8..9ee64c12 100755
--- a/README.md
+++ b/README.md
@@ -11,18 +11,51 @@
 
 使用Gitbook制作，可以直接[在线阅读](http://numbbbbb.github.io/the-swift-programming-language-in-chinese/)。
 
-# 电子书下载
-
-CocoaChina精校PDF→[点我下载](http://vdisk.weibo.com/s/EhsPPzRRQ5CZ/1402621206)
-
-其他格式可以通过PDF转换
-
 # 当前阶段
 
-文章已经全部翻译完成，当前阶段为自由校对阶段，可以随意提issue和pr。
+已经更新到Swift 2.0，对应苹果官方文档7.23的更新。
 
+# 2.0译者记录
 
-# 译者记录
+- About Swift （**完成** By：@xtymichael）
+- A Swift Tour（**完成** By：@xtymichael）
+- The Basics（**完成** By：@xtymichael）
+- Basic Operators（**完成** By：@AlanMelody）
+- Strings and Characters（**完成** By：@DianQK）
+- Collection Types（**完成** By：@AlanMelody）
+- Control Flow（**完成** By：@AlanMelody）
+- Functions（**完成** By：@dreamkidd）
+- Closures（**完成** By：@100mango）
+- Enumerations（**完成** By：@futantan）
+- Classes and Structures（**完成** By：@SkyJean）
+- Properties（**完成** By：@yangsiy）
+- Methods（**完成** By：@DianQK）
+- Subscripts（**完成** By：@shanksyang）
+- Inheritance（**完成** By：@shanksyang）
+- Initialization（**完成** By：@chenmingbiao）
+- Deinitialization（**完成** By：@chenmingbiao）
+- Automatic Reference Counting（**完成** By：@Channe）
+- Optional Chaining（**完成** By：@lyojo）
+- Error Handling（**完成** By：@lyojo）
+- Type Casting（**完成** By：@yangsiy）
+- Nested Types（**完成** By：@SergioChan）
+- Extensions（**完成** By；@shanksyang）
+- Protocols（**完成** By：@futantan）
+- Generics（**完成** By：@SergioChan）
+- Access Control（**完成** By：@mmoaay）
+- Advanced Operators（**完成** By：@buginux）
+- About the Language Reference（**完成** By：@KYawn）
+- Lexical Structure（**完成** By：@buginux）
+- Types（**完成** By：@EudeMorgen）
+- Expressions（**完成** By：@EudeMorgen）
+- Statements（**完成** By：@littledogboy）
+- Declarations（**完成** By：@Lenhoon）
+- Attributes（**完成** By：@KYawn）
+- Patterns（**完成** By：@ray16897188）
+- Generic Parameters and Arguments（**完成** By：@wardenNScaiyi）
+- Summary of the Grammar（**完成** By：@miaosiqi）
+
+# 1.0译者记录
 
 * 欢迎使用 Swift
    * 关于 Swift ([numbbbbb])
@@ -171,4 +204,4 @@ CocoaChina精校PDF→[点我下载](http://vdisk.weibo.com/s/EhsPPzRRQ5CZ/14026
 [Lin-H]:https://github.com/Lin-H
 [takalard]:https://github.com/takalard
 [dabing1022]:https://github.com/dabing1022
-[marsprince]:https://github.com/marsprince
\ No newline at end of file
+[marsprince]:https://github.com/marsprince

From 97ebc48e3b49da4f5a869f9e6a05e19a746a9152 Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Mon, 3 Aug 2015 14:45:31 +0800
Subject: [PATCH 145/228] Create config.json

---
 .../SUMMARY.md-readme-source/config.json                 | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json

diff --git a/name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json b/name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json
new file mode 100644
index 00000000..38e5dc02
--- /dev/null
+++ b/name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json
@@ -0,0 +1,9 @@
+{
+	"name": "The Swift Programming Language 中文版",
+	"introduction": "自己加下...",
+	"path": {
+		"content": "source",
+		"toc": "source/SUMMARY.md",
+		"readme": "source/README.md"
+	}	
+}

From aa4342c066e86f6870d25d136d4ef04608cbd287 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Mon, 3 Aug 2015 14:46:27 +0800
Subject: [PATCH 146/228] Update README.md

---
 README.md | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 9ee64c12..647ca8bb 100755
--- a/README.md
+++ b/README.md
@@ -3,13 +3,11 @@
 
 中文版Apple官方Swift教程《The Swift Programming Language》
 
-中文Swift社区[Swiftist](http://swiftist.org/)，新社区，正在建设中，感兴趣的朋友可以一起参与进来。
-
-**如果想帮忙翻译或者校对，请加QQ群：364279588，谢谢！**
+**如果想帮忙翻译或者校对，请加QQ群：480616051，谢谢！**
 
 # 在线阅读
 
-使用Gitbook制作，可以直接[在线阅读](http://numbbbbb.github.io/the-swift-programming-language-in-chinese/)。
+使用Gitbook制作，可以直接[在线阅读](http://swiftguide.cn/)。
 
 # 当前阶段
 

From 4d63e49c3501fc6cd841540e0fe24db12134ac7c Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Mon, 3 Aug 2015 14:58:47 +0800
Subject: [PATCH 147/228] Create config.json

---
 config.json | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 config.json

diff --git a/config.json b/config.json
new file mode 100644
index 00000000..38e5dc02
--- /dev/null
+++ b/config.json
@@ -0,0 +1,9 @@
+{
+	"name": "The Swift Programming Language 中文版",
+	"introduction": "自己加下...",
+	"path": {
+		"content": "source",
+		"toc": "source/SUMMARY.md",
+		"readme": "source/README.md"
+	}	
+}

From d5c19e9d81ac1901df0a004c8a1b8009176c1bec Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Mon, 3 Aug 2015 15:13:54 +0800
Subject: [PATCH 148/228] add cover

---
 cover/background.jpg                            | Bin 0 -> 30473 bytes
 cover/logo.png                                  | Bin 0 -> 4394 bytes
 .../SUMMARY.md-readme-source/config.json        |   9 ---------
 3 files changed, 9 deletions(-)
 create mode 100755 cover/background.jpg
 create mode 100644 cover/logo.png
 delete mode 100644 name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json

diff --git a/cover/background.jpg b/cover/background.jpg
new file mode 100755
index 0000000000000000000000000000000000000000..7726503e47bb55f9397fdeaac84f7f8d666aa71d
GIT binary patch
literal 30473
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

literal 0
HcmV?d00001

diff --git a/cover/logo.png b/cover/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..c350c1656a031191a7d42f905bbe3eba355d4f5a
GIT binary patch
literal 4394
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

literal 0
HcmV?d00001

diff --git a/name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json b/name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json
deleted file mode 100644
index 38e5dc02..00000000
--- a/name-The-Swift-Programming-Language-introduction-...-path-content-source-toc-source/SUMMARY.md-readme-source/config.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-	"name": "The Swift Programming Language 中文版",
-	"introduction": "自己加下...",
-	"path": {
-		"content": "source",
-		"toc": "source/SUMMARY.md",
-		"readme": "source/README.md"
-	}	
-}

From 40b9a642fcaefce0e4466207b6c694034cb27a22 Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Mon, 3 Aug 2015 15:51:42 +0800
Subject: [PATCH 149/228] =?UTF-8?q?=E7=9B=AE=E5=BD=95=EF=BC=9A=E7=BA=A0?=
 =?UTF-8?q?=E6=AD=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/{20_Type_Casting.md => 19_Type_Casting.md} | 0
 source/chapter2/{19_Nested_Types.md => 20_Nested_Types.md} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename source/chapter2/{20_Type_Casting.md => 19_Type_Casting.md} (100%)
 rename source/chapter2/{19_Nested_Types.md => 20_Nested_Types.md} (100%)

diff --git a/source/chapter2/20_Type_Casting.md b/source/chapter2/19_Type_Casting.md
similarity index 100%
rename from source/chapter2/20_Type_Casting.md
rename to source/chapter2/19_Type_Casting.md
diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/20_Nested_Types.md
similarity index 100%
rename from source/chapter2/19_Nested_Types.md
rename to source/chapter2/20_Nested_Types.md

From b58c7bb03bd450e7f094f884e8f2c77fc5c58880 Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Mon, 3 Aug 2015 16:12:56 +0800
Subject: [PATCH 150/228] Update 03_Strings_and_Characters.md

delete body tag
---
 source/chapter2/03_Strings_and_Characters.md | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index c8a1c31a..48657b40 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -495,8 +495,6 @@ let dogString = "Dog‼🐶"
 您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
 其为`String.UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
 
-<body>
-<center>
 <table style='text-align:center'>
  <tr height=77>
   <td>Character</td>
@@ -533,8 +531,7 @@ let dogString = "Dog‼🐶"
   <td>9</td>
  </tr>
 </table>
-</center>
-</body>
+
 
 ```swift
 for codeUnit in dogString.utf8 {
@@ -554,8 +551,7 @@ print("")
 
 您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
 其为`String.UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
-<body>
-<center>
+
 <table style='text-align:center'>
  <tr height=77>
   <td>Character</td>
@@ -584,8 +580,6 @@ print("")
   <td>5</td>
  </tr>
 </table>
-</center>
-</body>
 
 
 ```swift
@@ -610,8 +604,7 @@ print("")
 
 每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示：
 
-<body>
-<center>
+
 <table style='text-align:center'>
  <tr height=77>
   <td>Character</td>
@@ -638,8 +631,6 @@ print("")
   <td>4</td>
  </tr>
 </table>
-</center>
-</body>
 
 
 ```swift

From 44619dee2826a344074c33f91fdf59e0dced406b Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Mon, 3 Aug 2015 16:14:08 +0800
Subject: [PATCH 151/228] Update 08_Generic_Parameters_and_Arguments.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改第 18 行 泛型 的链接
---
 source/chapter3/08_Generic_Parameters_and_Arguments.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index 901ebad2..a68cf590 100755
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -15,7 +15,7 @@
 
 本节涉及泛型类型、泛型函数以及泛型初始化器（**initializer**）的参数，包括形参和实参。声明泛型类型、函数或初始化器时，须指定相应的类型参数。类型参数相当于一个占位符，当实例化泛型类型、调用泛型函数或泛型初始化器时，就用具体的类型实参替代之。
 
-关于 Swift 语言的泛型概述，见[泛型](../charpter2/22_Generics.md)(第二部分第22章)。
+关于 Swift 语言的泛型概述，见[泛型](../chapter2/23_Generics.md)(第二部分第23章)。
 
 <a name="generic_parameter"></a>
 ## 泛型形参子句

From 9c2de90ee6d739f0ac37cfe7fb22f0f4e7b4a10b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:29:56 +0800
Subject: [PATCH 152/228] new readme

---
 source/README.md  | 126 ++++++++++++++++++++--------------------------
 source/SUMMARY.md |   1 +
 source/v1.0.md    |  89 ++++++++++++++++++++++++++++++++
 3 files changed, 145 insertions(+), 71 deletions(-)
 create mode 100644 source/v1.0.md

diff --git a/source/README.md b/source/README.md
index ee97b3f0..092c36a4 100755
--- a/source/README.md
+++ b/source/README.md
@@ -1,89 +1,73 @@
-> Swift 兴趣交流群：`305014012`，307017261（已满）
+> Swift 兴趣交流群：`131595168`, `146932759`, `151336833`, `153549217`. **加入一个群即可，请勿重复添加**
 > [Swift 开发者社区](http://swiftist.org)
+> [Swift 资源汇总](https://github.com/ipader/SwiftGuide)
+> [Swift 优秀newsletter](http://swiftsandbox.io)
 
 <!-- -->
 > 如果你觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持是我们最大的动力。
 
-<!-- -->
-> 关于文档中翻译错误，逻辑错误以及疑难问题答疑，请关注["@老码团队"](http://weibo.com/u/5241713117
-)官方微博，会有技术人员统一收集答疑
+# The Swift Programming Language 中文版
 
+### 2.0 新的开始
 
-# The Swift Programming Language 中文版####
+#### 1
 
-###这一次，让中国和世界同步
+开源项目完成难，维护更难。
 
-现在是6月12日凌晨4:38，我用了整整一晚上的时间来进行最后的校对，终于可以在12日拿出一个可以发布的版本。
+大家看到的是发布时的瞩目和荣耀，却没有看到项目本身质量不高、错误频出。这并不是翻译者和校对者的问题，他们已经付出了足够的努力。真正的问题在我，没有建立起长期的维护团队，因此后期的校对和更新都难以实施。
 
-9天时间，1317个 Star，310个 Fork，超过30人参与翻译和校对工作，项目最高排名GitHub总榜第4。
+1.0发布之后，我们就再也没能和苹果的文档同步。语法错误、编译不通过、语言不通顺，阅读量直线下降，最低时每天只有不到1000人访问。
 
-设想过很多遍校对完成时的场景，仰天大笑还是泪流满面？真正到了这一刻才发现，疲倦已经不允许我有任何情绪。
+6月9日，calvingit发了一个issue“准备翻译2.0版本吗”，我没有回复，应该已经没人关注这个项目了吧，我想。
 
-说实话，刚开始发起项目的时候完全没想到会发展成今天这样，我一度计划自己一个人翻译完整本书。万万没想到，会有这么多的人愿意加入并贡献出自己的力量。
+#### 2
 
-coverxit发给我最后一份文档的时候说，我要去背单词了，我问他，周末要考六级？他说是的。
+我错了。
 
-pp-prog告诉我，这几天太累了，校对到一半睡着了，醒来又继续做。2点17分，发给我校对完成的文档。
+![](https://img.bi/#/TmFvPpk!BZO2eAzmXBRQaHN80Qukey5wTVrvFgxt2IAA5cQe)
+![](https://img.bi/#/DtL1E8F!yE5pOw7a4qyQSz_rPwGbfUGQumi3wQjY_XtQYi2W)
+![](https://img.bi/#/2FqhxS4!Bvkahw_U9kewHHHmeQw533Ewfm3nLAbrFMGAEpLs)
+![](https://img.bi/#/x8OFU6s!879WQwHIovTw7FqA-gTrwgqw-6qU6A4m22sgbK8F)
+![](https://img.bi/#/7nKCb0l!fLsVQAIuAzRQ2Xx4qwcSrIvQiou4sgl5tKfQajOK)
 
-lifedim说他平时12点就会睡，1点47分，发给我校对后的文档。
+在我没有任何回复的情况下，不到一天时间，有五位朋友报名。看到这些回复的时候我真的很惊讶，也很感动，无论这个项目存在多少问题，只要有人关注，有人愿意为它付出，那我还有什么理由放弃呢？
 
-团队里每个人都有自己的事情，上班、上学、创业，但是我们只用了9天就完成整本书的翻译。我不知道大家付出了多少，牺牲了多少，但是我知道，他们的付出必将被这些文字记录下来，即使再过10年，20年，依然熠熠生辉，永不被人遗忘。
+6月28日8点55分，Swift 2.0翻译正式启动。按下发送按钮后，我不停的刷新页面，半个小时过去了，一个回复都没有。“还是不行啊”“如果再过一个小时没人回复我就把issue删掉”，类似的念头不断出现，又不断消失。
 
-全体人员名单（排名不分先后）：
+9:35，xtymichael第一个回复，而且一下就认领了三篇！接下来就是不断的回复认领，到中午已经有超过一半章节被认领。
 
-- [numbbbbb](https://github.com/numbbbbb)
-- [stanzhai](https://github.com/stanzhai)
-- [coverxit](https://github.com/coverxit)
-- [wh1100717](https://github.com/wh1100717)
-- [TimothyYe](https://github.com/TimothyYe)
-- [honghaoz](https://github.com/honghaoz)
-- [lyuka](https://github.com/lyuka)
-- [JaySurplus](https://github.com/JaySurplus)
-- [Hawstein](https://github.com/Hawstein)
-- [geek5nan](https://github.com/geek5nan)
-- [yankuangshi](https://github.com/yankuangshi)
-- [xielingwang](https://github.com/xielingwang)
-- [yulingtianxia](https://github.com/yulingtianxia)
-- [twlkyao](https://github.com/twlkyao)
-- [dabing1022](https://github.com/dabing1022)
-- [vclwei](https://github.com/vclwei)
-- [fd5788](https://github.com/fd5788)
-- [siemenliu](https://github.com/siemenliu)
-- [youkugems](https://github.com/youkugems)
-- [haolloyin](https://github.com/haolloyin)
-- [wxstars](https://github.com/wxstars)
-- [IceskYsl](https://github.com/IceskYsl)
-- [sg552](https://github.com/sg552)
-- [superkam](https://github.com/superkam)
-- [zac1st1k](https://github.com/zac1st1k)
-- [bzsy](https://github.com/bzsy)
-- [pyanfield](https://github.com/pyanfield)
-- [ericzyh](https://github.com/ericzyh)
-- [peiyucn](https://github.com/peiyucn)
-- [sunfiled](https://github.com/sunfiled)
-- [lzw120](https://github.com/lzw120)
-- [viztor](https://github.com/viztor)
-- [wongzigii](https://github.com/wongzigii)
-- [umcsdon](https://github.com/umcsdon)
-- [zq54zquan](https://github.com/zq54zquan)
-- [xiehurricane](https://github.com/xiehurricane)
-- [Jasonbroker](https://github.com/Jasonbroker)
-- [tualatrix](https://github.com/tualatrix)
-- [pp-prog](https://github.com/pp-prog)
-- [088haizi](https://github.com/088haizi)
-- [baocaixiong](https://github.com/baocaixiong)
-- [yeahdongcn](https://github.com/yeahdongcn)
-- [shinyzhu](https://github.com/shinyzhu)
-- [lslxdx](https://github.com/lslxdx)
-- [Evilcome](https://github.com/Evilcome)
-- [zqp](https://github.com/zqp)
-- [NicePiao](https://github.com/NicePiao)
-- [LunaticM](https://github.com/LunaticM)
-- [menlongsheng](https://github.com/menlongsheng)
-- [lifedim](https://github.com/lifedim)
-- [happyming](https://github.com/happyming)
-- [bruce0505](https://github.com/bruce0505)
-- [Lin-H](https://github.com/Lin-H)
-- [takalard](https://github.com/takalard)
-- [dabing1022](https://github.com/dabing1022)
-- [marsprince](https://github.com/marsprince)
+第二天早晨，37个章节全部认领完毕。
+
+#### 3
+
+经过一个多月的努力，我们终于完成了文档的更新。听起来似乎没什么，确实，从1到n总是没有从0到1那么振奋人心。不过真正参与了才知道，修改往往比创造更麻烦，一个需要耐心，一个需要激情，前者往往得不到应有的重视。
+
+但是我还是想尽最大可能去感谢他们，这个项目能走到今天，靠的不是我，是那个issue，是那些回复，是这几十个兄弟在工作学习的空闲敲下的每一个字符。而我能做的，只是在每篇文章的开头，那个所有人都会忽略的地方，加上他们的ID。
+
+下次你再打开这篇文档，可以多看看那些列在最上方的ID，哪怕不去follow和star，只是看一眼就好。他们的所有努力和付出，就存在于这短暂的一瞥中。
+
+Swift 2.0 参与者名单（按照章节顺序）：
+- [xtymichael](https://github.com/xtymichael)
+- [AlanMelody](https://github.com/AlanMelody)
+- [DianQK](https://github.com/DianQK)
+- [dreamkidd](https://github.com/dreamkidd)
+- [100mango](https://github.com/100mango)
+- [futantan](https://github.com/futantan)
+- [SkyJean](https://github.com/SkyJean)
+- [yangsiy](https://github.com/yangsiy)
+- [shanksyang](https://github.com/shanksyang)
+- [chenmingbiao](https://github.com/chenmingbiao)
+- [Channe](https://github.com/Channe)
+- [lyojo](https://github.com/lyojo)
+- [SergioChan](https://github.com/SergioChan)
+- [mmoaay](https://github.com/mmoaay)
+- [buginux](https://github.com/buginux)
+- [KYawn](https://github.com/KYawn)
+- [EudeMorgen](https://github.com/EudeMorgen)
+- [littledogboy](https://github.com/littledogboy)
+- [Lenhoon](https://github.com/Lenhoon)
+- [ray16897188](https://github.com/ray16897188)
+- [wardenNScaiyi](https://github.com/wardenNScaiyi)
+- [miaosiqi](https://github.com/miaosiqi)
+
+最后，感谢[极客学院](www.jikexueyuan.com)提供的wiki系统，在国内访问起来速度很快，优化后的样式看起来也更舒服。
\ No newline at end of file
diff --git a/source/SUMMARY.md b/source/SUMMARY.md
index d9e426c6..10e9dc32 100755
--- a/source/SUMMARY.md
+++ b/source/SUMMARY.md
@@ -4,6 +4,7 @@
    * [关于 Swift](chapter1/01_swift.md)
    * [Swift 初见](chapter1/02_a_swift_tour.md)
    * [Swift 版本历史记录](chapter1/03_revision_history.md)
+   * [Swift 1.0 发布内容](v1.0.md)
 * [Swift 教程](chapter2/chapter2.md)
    * [基础部分](chapter2/01_The_Basics.md)
    * [基本运算符](chapter2/02_Basic_Operators.md)
diff --git a/source/v1.0.md b/source/v1.0.md
new file mode 100644
index 00000000..ee97b3f0
--- /dev/null
+++ b/source/v1.0.md
@@ -0,0 +1,89 @@
+> Swift 兴趣交流群：`305014012`，307017261（已满）
+> [Swift 开发者社区](http://swiftist.org)
+
+<!-- -->
+> 如果你觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持是我们最大的动力。
+
+<!-- -->
+> 关于文档中翻译错误，逻辑错误以及疑难问题答疑，请关注["@老码团队"](http://weibo.com/u/5241713117
+)官方微博，会有技术人员统一收集答疑
+
+
+# The Swift Programming Language 中文版####
+
+###这一次，让中国和世界同步
+
+现在是6月12日凌晨4:38，我用了整整一晚上的时间来进行最后的校对，终于可以在12日拿出一个可以发布的版本。
+
+9天时间，1317个 Star，310个 Fork，超过30人参与翻译和校对工作，项目最高排名GitHub总榜第4。
+
+设想过很多遍校对完成时的场景，仰天大笑还是泪流满面？真正到了这一刻才发现，疲倦已经不允许我有任何情绪。
+
+说实话，刚开始发起项目的时候完全没想到会发展成今天这样，我一度计划自己一个人翻译完整本书。万万没想到，会有这么多的人愿意加入并贡献出自己的力量。
+
+coverxit发给我最后一份文档的时候说，我要去背单词了，我问他，周末要考六级？他说是的。
+
+pp-prog告诉我，这几天太累了，校对到一半睡着了，醒来又继续做。2点17分，发给我校对完成的文档。
+
+lifedim说他平时12点就会睡，1点47分，发给我校对后的文档。
+
+团队里每个人都有自己的事情，上班、上学、创业，但是我们只用了9天就完成整本书的翻译。我不知道大家付出了多少，牺牲了多少，但是我知道，他们的付出必将被这些文字记录下来，即使再过10年，20年，依然熠熠生辉，永不被人遗忘。
+
+全体人员名单（排名不分先后）：
+
+- [numbbbbb](https://github.com/numbbbbb)
+- [stanzhai](https://github.com/stanzhai)
+- [coverxit](https://github.com/coverxit)
+- [wh1100717](https://github.com/wh1100717)
+- [TimothyYe](https://github.com/TimothyYe)
+- [honghaoz](https://github.com/honghaoz)
+- [lyuka](https://github.com/lyuka)
+- [JaySurplus](https://github.com/JaySurplus)
+- [Hawstein](https://github.com/Hawstein)
+- [geek5nan](https://github.com/geek5nan)
+- [yankuangshi](https://github.com/yankuangshi)
+- [xielingwang](https://github.com/xielingwang)
+- [yulingtianxia](https://github.com/yulingtianxia)
+- [twlkyao](https://github.com/twlkyao)
+- [dabing1022](https://github.com/dabing1022)
+- [vclwei](https://github.com/vclwei)
+- [fd5788](https://github.com/fd5788)
+- [siemenliu](https://github.com/siemenliu)
+- [youkugems](https://github.com/youkugems)
+- [haolloyin](https://github.com/haolloyin)
+- [wxstars](https://github.com/wxstars)
+- [IceskYsl](https://github.com/IceskYsl)
+- [sg552](https://github.com/sg552)
+- [superkam](https://github.com/superkam)
+- [zac1st1k](https://github.com/zac1st1k)
+- [bzsy](https://github.com/bzsy)
+- [pyanfield](https://github.com/pyanfield)
+- [ericzyh](https://github.com/ericzyh)
+- [peiyucn](https://github.com/peiyucn)
+- [sunfiled](https://github.com/sunfiled)
+- [lzw120](https://github.com/lzw120)
+- [viztor](https://github.com/viztor)
+- [wongzigii](https://github.com/wongzigii)
+- [umcsdon](https://github.com/umcsdon)
+- [zq54zquan](https://github.com/zq54zquan)
+- [xiehurricane](https://github.com/xiehurricane)
+- [Jasonbroker](https://github.com/Jasonbroker)
+- [tualatrix](https://github.com/tualatrix)
+- [pp-prog](https://github.com/pp-prog)
+- [088haizi](https://github.com/088haizi)
+- [baocaixiong](https://github.com/baocaixiong)
+- [yeahdongcn](https://github.com/yeahdongcn)
+- [shinyzhu](https://github.com/shinyzhu)
+- [lslxdx](https://github.com/lslxdx)
+- [Evilcome](https://github.com/Evilcome)
+- [zqp](https://github.com/zqp)
+- [NicePiao](https://github.com/NicePiao)
+- [LunaticM](https://github.com/LunaticM)
+- [menlongsheng](https://github.com/menlongsheng)
+- [lifedim](https://github.com/lifedim)
+- [happyming](https://github.com/happyming)
+- [bruce0505](https://github.com/bruce0505)
+- [Lin-H](https://github.com/Lin-H)
+- [takalard](https://github.com/takalard)
+- [dabing1022](https://github.com/dabing1022)
+- [marsprince](https://github.com/marsprince)

From 8954689aa523a456944479c50736b1b3b14ddf85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:32:31 +0800
Subject: [PATCH 153/228] new version

---
 source/README.md | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/source/README.md b/source/README.md
index 092c36a4..09823f60 100755
--- a/source/README.md
+++ b/source/README.md
@@ -1,6 +1,9 @@
 > Swift 兴趣交流群：`131595168`, `146932759`, `151336833`, `153549217`. **加入一个群即可，请勿重复添加**
+
 > [Swift 开发者社区](http://swiftist.org)
+
 > [Swift 资源汇总](https://github.com/ipader/SwiftGuide)
+
 > [Swift 优秀newsletter](http://swiftsandbox.io)
 
 <!-- -->
@@ -24,11 +27,11 @@
 
 我错了。
 
-![](https://img.bi/#/TmFvPpk!BZO2eAzmXBRQaHN80Qukey5wTVrvFgxt2IAA5cQe)
-![](https://img.bi/#/DtL1E8F!yE5pOw7a4qyQSz_rPwGbfUGQumi3wQjY_XtQYi2W)
-![](https://img.bi/#/2FqhxS4!Bvkahw_U9kewHHHmeQw533Ewfm3nLAbrFMGAEpLs)
-![](https://img.bi/#/x8OFU6s!879WQwHIovTw7FqA-gTrwgqw-6qU6A4m22sgbK8F)
-![](https://img.bi/#/7nKCb0l!fLsVQAIuAzRQ2Xx4qwcSrIvQiou4sgl5tKfQajOK)
+![图1](https://img.bi/#/TmFvPpk!BZO2eAzmXBRQaHN80Qukey5wTVrvFgxt2IAA5cQe)
+![图2](https://img.bi/#/DtL1E8F!yE5pOw7a4qyQSz_rPwGbfUGQumi3wQjY_XtQYi2W)
+![图3](https://img.bi/#/2FqhxS4!Bvkahw_U9kewHHHmeQw533Ewfm3nLAbrFMGAEpLs)
+![图4](https://img.bi/#/x8OFU6s!879WQwHIovTw7FqA-gTrwgqw-6qU6A4m22sgbK8F)
+![图5](https://img.bi/#/7nKCb0l!fLsVQAIuAzRQ2Xx4qwcSrIvQiou4sgl5tKfQajOK)
 
 在我没有任何回复的情况下，不到一天时间，有五位朋友报名。看到这些回复的时候我真的很惊讶，也很感动，无论这个项目存在多少问题，只要有人关注，有人愿意为它付出，那我还有什么理由放弃呢？
 

From 55fa8da4b603897c3a98e0e1a52baa5f915b11f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:36:47 +0800
Subject: [PATCH 154/228] add images

---
 source/README.md        |   6 +++---
 swift 2.0引用图片/1.png | Bin 0 -> 10462 bytes
 swift 2.0引用图片/2.png | Bin 0 -> 11136 bytes
 swift 2.0引用图片/3.png | Bin 0 -> 8141 bytes
 swift 2.0引用图片/4.png | Bin 0 -> 6790 bytes
 swift 2.0引用图片/5.png | Bin 0 -> 10524 bytes
 swift 2.0引用图片/6.png | Bin 0 -> 27189 bytes
 7 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 swift 2.0引用图片/1.png
 create mode 100644 swift 2.0引用图片/2.png
 create mode 100644 swift 2.0引用图片/3.png
 create mode 100644 swift 2.0引用图片/4.png
 create mode 100644 swift 2.0引用图片/5.png
 create mode 100644 swift 2.0引用图片/6.png

diff --git a/source/README.md b/source/README.md
index 09823f60..626edb69 100755
--- a/source/README.md
+++ b/source/README.md
@@ -1,10 +1,10 @@
 > Swift 兴趣交流群：`131595168`, `146932759`, `151336833`, `153549217`. **加入一个群即可，请勿重复添加**
 
-> [Swift 开发者社区](http://swiftist.org)
+> <a target='_blank' href="http://swiftist.org">Swift 开发者社区</a>
 
-> [Swift 资源汇总](https://github.com/ipader/SwiftGuide)
+> <a target='_blank' href="https://github.com/ipader/SwiftGuide">Swift 资源汇总</a>
 
-> [Swift 优秀newsletter](http://swiftsandbox.io)
+> <a target='_blank' href="http://swiftsandbox.io">Swift 优秀newsletter</a>
 
 <!-- -->
 > 如果你觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持是我们最大的动力。
diff --git a/swift 2.0引用图片/1.png b/swift 2.0引用图片/1.png
new file mode 100644
index 0000000000000000000000000000000000000000..20374e2d78a2eac2878161d073d549802c003ac9
GIT binary patch
literal 10462
zcmd72Wk4I>6E=#|qNO+#X(`2u6%WOVdvGhzLh<5+;93Yykpjh~Kqyw+g1cLAcL?qp
zxcU7*-tYIm?}yzzXLrx;?97}qGtaZ(Ks9+nJQ_SSG&Dj*1sP2=G;|QEZT$=fwI}NM
zB7!=gyK2gRLMt12wTJ3pSxKo%p`lg8;y--FM)jXNDHyn-ZteVUL+^EjenUfJbybv+
z()KVp%y^zcK2>wP=jq_}?K=)NS(nTk54tm%A6T*q>j83vyL=HQ(O$>+VcW)+$|?#l
zyyRl6+|$3$p<!>?S>MF>{?d?=kxG;zYs}fZy;vLzcsMp}^13eitF@E<SG;i4&N<__
z_}Fb`P5@~)<5+I!eOS{ZCC;mrT~R>->ysyYfh`j_qM2=Eb*O(u3k{Gowhdur#B-~~
zz_=XIovro{^djg^k`BjM(Zt3=@WM_pE~z3oAuq98^6{R*%{?}-5xitZM9g?T%H%Jg
zy(c~RaC6q$S4w0zN$iZkr=(?%hVL4ZWWr*ot67=XI%P_zH=@RRgx-advYecB66Zmo
z&z2fNcBbp=>pxRc!iI)a-m<V5`SB%hv?j#IW7MiDC|H|PGB6OEc+hcgKiyKnnoX=E
zaK(w6)f`86?pA||gGR+BMvJrxSI=*OpFc-&w?1f6j7uT{;DKB^xF4mFIS~3!etzP3
zcz9%8)T>2BMScDK8vD3JufpP(<jsascyIdE{en>PtXB?lb(R=ZofMlQ@yvT;x>wtS
zdEIt_7kiVv6VG^{lM@pif_RqJe5=DhNBjCDM>EC9FB(28DdC-+o&8Kpi(Ek-f#W_H
zqa#n&I)%M1SYzl!3tB8l2>%c%(CxB=+W6o*L%)OfCJQ$Z#pOM}^h}BZ#2gldKZB-p
z>L2g+Pj~ZT&4yD2^jrPJ1i#M)EH#1is;jj*Yieq4E+*A0oHyiP*UR4e)z&1Lp4-&#
zKi9w5=#7<c^+S#|fgM#+c+itg{Tgi13RKf@92DxMRyUU27wqeAx6`I7<YVbelg>va
z7<Mwfxwz_AF=_~f-U%%_VIING)rK;~Xt`T%-kA6!LEo2QB4*I4kYyc*%ydYA3`&pa
z-gGAfmk5Nd&%<f2ev><At^Gp5D)MT<(R^#*mwt<nh;E5~plX`n*WMU9#IHY<l`qN3
z$!*y<IHYxS$PxSd8hUz#jHX&z!SV4geJ;l3Q$)dBCLU|pHOGewb;Vn4fta>N;#|r1
zn+fXLb3!XVr1%u?+gwM*Ak4~1t0*<KBc_U{&gSjP*HB;3i?SNLgK@iOtGK)+f(qfI
zYL+t?{FdhzU`%H}zzWJ2MoU9828aLH-nOi+u4Wz7@#p(T-LbW`g|~W8_Jz@|o^N)}
zxBZ{RzA<Lj;OS!wgGAZY=o8<`<uQzSnZf_uOFYIsWcPgR-`10e&(G^TS|V}rEUiBb
zp<a5;zg<i)Xo@g3aRFE$LZwi4?uXV#%h|JzeGlHJ^1-yajSus-Gb>*HG^+&8CKq@2
zM@{MtUuQ9PaDqym_%1F_J?WmxR){=&|1bnLe&okcE5bBxAabKZ(5%x85PT!FsPgW9
zsKaTdUf({1w;%}XqNpEW#5jE1;3bfrw;TTbQkL(P!B(LaM@FgZdCT0u4)S03h%zCP
zZcjd&i`Y%iFMDh8kDpg)BX!5!@s||>O+paTzP1MxoLzbwiql%2F=+FzYT*axk(l=t
zG>n=^XOoqh4x8`$EKiAHjnc1ihgXmHV>!}?z2(IMG?5At7$8q;taMG>Mi-O|fJFb)
zT-w*p4qNd58(ty!ZY&pUBt&po6Adl5dxKU*TZj(Ax*I^S!>6^r-{b`EPURH_dHQ^Y
z;rYT&duW}ze~~(GZ7S+NPNxZL+twS^pVwZDeT8f5<Tb_vtb8}|a+xP$C5`EK%N`^L
z8x)Zj1fZrTBd~Sls8Q3mpa#7Iisoi1V8%ZzH&eoPSd1~-<$#`vhCxh0lAO=&lwXh+
zG4^GbhxxyWQU6ERl7)ZtX?3vJVWYa$DU0%TZvWfJh%OO1x_WZ*EojN#AF-VNhHsG1
z;9EH)PD*sU10Y5-=mK)(Dn^|J9KA%I#|d_yfloPi;WgRQ=*SFHnjSFMDLq$P6ApQM
zB<<i1?qX9GQzPVIfB(LV)OF{@Ki}D!d)M#xPP7d+SAU_uz2;3t3~uuU$aLp`k!Nxh
z@Fo|FL|0OMCAu&ekw<7_f@t?XfY7-qEmRa>*AH;C<_UQ0?`2pUM0)qvi-$C4`9~Nz
zK2mFvCj1<W4j93g5^H5-82xx}1&2?qpEr90O>|?nd)`g48LI9N^xJD0ng&l47$)*-
z%iBVWXYZ}`VC%6nt8oUgUxs@>{9~J+A9#EN`C)xCJTb-x2kjI-3K}gv5~(xI%RD)P
zn`URyL{;qA?n0QpAolGvlql|!RQH{GOY5>7zqarmWVyD#7`t^GInSL$e>h(Pe|-up
z@AH-BqCLygiwiN)F$!jCVSi<Fvi3~MSN%4J3->Y~pFxX_?BZ;;BVWUje>3O7QY_J>
zb<<B)6SX2Q5jcpZA5t`lebx{{19XioezgtA$Tg)x5MqH`k`Lx9==9X6Al3B_3bDtb
z4;N&A-o34r&S)Qr;|WiEVvZ@fVtEoay<J^dd1#5S+aa1}cNx_FSz|J%59w?f2+JP1
z-)4T<?zteKoLL*NNB}xtQRg-wJ*{{nrZ;DT#speT`!6gQWBx`jeG>Fv$orgL;wI0L
z`H4u!AV`F}2Bc#xHXkG*cFWMGtSa}_lBV+IdYl>wx8i0{IG@43qP@XuNQT&}^5(}>
zC8oAKrMdEvXjuXDmQ-9N*)fg3@;!2SL45E|^aWMw{f2|y3F?`(#{KQD(uwg=ho*qw
ztKNGU5ns~L@g~l@yB&sT@2Q%r3c^UM;qJfdYN0Bp>_bzIv95YKv#P$D3-5abg)H(_
z3dNP_f*KRJ7YW=$tEd;Z$Mb2<qW@~apV^l%uhf|wGd+RnK-SYY1J0E-*jnXHh6acb
zYBp9CWjPA;j~O4h-^F#88S^|(<oxiuKP+_ZeRRS*)sAUSBcM7VHiYl)uT5698~>lU
zz!4jqH~wvrrx(Wz8oB^!W1|DLfSFdYv-`p&F>U!g!fwKpUdgNqvU~Hh7jpLxqSQWg
zQ*YngbYmcVq6|`+26k82Oav&aC>-%kubCRlxV*{%Ua?OSjx(>JX-I^--O~4>{XVM5
zrVz=6MR<wN3dp_)D{(MnbtEI>a+9lw+4N>SPc?CNpYB^B%NrJEqGrDMF^RPH%pZ&V
zL0(3-OAbq{-43tNGuEf)S~F#GVnPxv!E^C?V+wR-I#}naG`9Rcn>*J6Uhb_j#Jjq6
zk+jOjO=cax1ZdK%rFo}O`N+pvl6Gz!AhEDSa&OdbV+-@OxZJ;M0#Km>Wz&84Gu7`^
z9Sbi5D!A|7s%nnUF9xk+;*Kj|Mj}AA=xT(Lk+GD&N+LP0X<o74zSN6i2v(_tL$)o<
z6x?Y7#mIe|tX}^TRixftnl%#wsF9Kq+94^yDtaeec~qBwQ*9%%3X!B^`*tuXu~f;r
z`-$PC#sr3?128e(B~qC;Z&=J_36>vtM0tMvcah-zlA~XMoAj4@{f9Ezd#~jYB2S21
zmk*5koM&{M2(PX=Qm+4ig3-?9RB*CJ-;b|}HKM|n>sLNW?;#g<?Z@G*1x^iai`&^y
z9lJ$|g#8>sr{dWG`}?JTKEqqXJ5=8!2m<XRkx1@HN{D+a)+FQZt#BJZ4Y2OG^Px4_
zHJk*C$shCBFgo4}DtZeC$;ng=hJ<Loj<BB=wldvJgq>%m1dA4~1kTfBbt5}~<r*5?
za#ylPto8+Azc_mQ7{oMR^1kIDl%7c7{U|{xZQcJC>S~>b0gy6nFk9c?vAwuH>4}&*
z(dpM?<r0-4;USw>Nb<5LZ1~Y<2)+*&920<NnViWr;al#BW&v8J{q9CIFBz-$x1zHj
z!L)A|0{{9V>{~|{#@q=+wHF>8uiF=LX#V&#iM~_0B|QI5DEkK})HXxpf-n5NmF<OX
zA5C`V)Df)%CiKztP#$yI+rU?RK=tcf;Y!HYfQCaKjO@ATpVb1uBxJP!Mv^(!Wf5d7
zoA7Er-%KP6&B^dOZ=`oQ0MI^-zIga}8L$#$&Gdr!c-ti>&I*cK1s9kVVdf4_cTKKh
zNF8(?64?>SQjxyJrMT?urZo9sEJ~PNqyc4L4_V?q2<44;si;~0M8Ywn+Ja%_Hrmx7
zhR4It{M-sW+5<GigI4kDgb4S%7G)x53wO2!POO+3DQO(CXlNJ(P9Q!c&H%aG8SW>G
z%<FoLlX^zb8W|9BGRi#ujlRBPM3aKnccMJO28~iBrvZok^Z!cDpI!djA$<*}j%o)S
zelkqfwWb%NLHH9}NYhPD0DqP_1QyckCp0mwrb^d;0(gl_q1(d(hm326Jtlcu$z=&Z
zlSUEs_PH1?=L>ROK%rQiDH2`+_slV~nKEN`Vtk{$bf^7kBggJku<k}?lYiiFnxIk6
zvI3K$&b-M;@CZdqY_4f)g;j5_@YB$1s+7!#wYfQACT41@m+*THh&9*ksP{L^Y*Q&N
zyh+lZGC<Q4_^VfT_Ma>`2|oeGqwXvbVfjDh7#jR(`Up3+N%5h@YODgg))a2v8%e4h
z=zfq9AOIgMmT`~>$}Sg&*v}P)+kp%6IG~vwQuqY%p<jjJzuK84w42{+2k7wEfup_r
zhlAUA9~R%+|8rUM`)643=#00G#4>Sx28B#8!f$`nJOEa;u6>X%1xQsXf1+G}%W-_1
z>tQ(O2LZTtk@^Tw+Z4jCZfD1Fb-V;&O0+J{O%FZQ5_!xhb=%U~f&RXGcUF_|lx8KL
zOQeMt*q%yWZZ4z2K&FAa7od&c$!ARoG%(neb<HCxxRr-&TI8v}>8>D!XWez?34=<W
z7pl>BFBI#3xyz8~Wg$CWhRYOzZGiC$>Q(_uMAn2LyYxm;s8OjcBxXWzaE{nFE&qLz
zS6T?X9fvV7gqjm7JEci{aodC^LExT2*W43ElTx<T6!R`DuYr3MSl49gM&xFnzyHmo
zu?jBV;_BY&ba2y2ED>cRwDhC1o7p-y=Yha)B)BZcM1I;!nseAtyO$8t%KEKD6Ah2s
zt0!-S`Y&cbIW@qYRe>2$jl#EZV<`Q*4@<eI+;+i6dWm+Fn3eGM(~-uaS0~xU{sR8*
z>Z5$-NT+of4%v3?28%{^O8b9lIS$~e6S6=xhu^EGh>@QT#|LonL&2;@iS5O0SMZ@$
zoxw!A&&~Wx;*%oCg7|0oq6Bs0)*i@p(ftyxhD+;gsaG8rMU&k-xL+<p3ycpcwrH{E
zZI%@d<p<m>+aoEaTLKt;@z(wJ07sNn-DQ&M(}GQ^7r7s}UjFgjl(TuWpW&KAObsAQ
zc&DbVdvj`DYP+3V^VF=%y!m(MIoGqz=$3cCisF`dYG9-9-235UUGQY~EYIViZx@3~
z@~>}a&Y|XRFK#DC2ajV0?<iK!{KTAz8Z5mgStrTV?qrom=|gVzb9Z!-djBHu)Pb>r
zvxJiJ#d(P(Nj&4+wA*`73Z_bnA{v!%F#*phkR23p(hBCHP#b@>aX}I!JrQDF=n$;q
z5#eWZ{ahX&akZQL!p{u9ejZ@XnGxHbYgRJzG5K@KYg~qqa6jjRdN-HW6efpHgyJ8P
zs|Y_%(3OOmW{w(V)2rHjgtq{`71`Ord}sZQmd|nS9Ln;b$#;2Jo<Seb=j1WNm8`iY
z%GJ?Zk%!;Y#U4cYJ+W1Be4$uRfc<1Do=t)XeUU7H8aOXMyu>}i+|l|wZK=||-JAOR
zzqUL+eFkKQ@d59Zp8r&*@REDErNv@RY4LU=S6u8QArR?&7!W92{twNHoGe@2GAY97
zX_%>1*C7jmP!dq8Val>LIC$jgKIv~7Dx(HFBa9EH;MjjU?_8Va1^REh@KjvVV`gfI
zq?XdVip4hG7)=qZHB#KYyMEsLS7<zJ1dz$oh|`-IYu-DZ;c<GK4AeR5TzPy1w16Ky
z>-Un<cy8q-I<})3R`v0vGH@Ad4kK|{1vEBJ9{igFhN@L)^kt}N*mNX6%EG#|xTtEo
znkKJBu$N9d+c9}+p_E=My_1sp1Qt`SDI3M*kA$XLk(#QWUl4nr0e9hYsc3Z~rUwmQ
zT1bGzw3>6LO6<h-)-0elU%K5F@Zs?KYTD4kT&*(70Z17RxkgvGp$ET}1zpT-%vwXk
z=*Cuv@|fmS(EOR<!Gi}b@0H!b;_Y+sh0EVczm4RpNcV~kW+_{bBYpL6F0y{cWrY9u
zM)NsQ@?QaSc+z`3^P$(2Dql5)1m@lJS3W-+AUIAl_;5GYBe}Yed{%3cr>|+oWLz^R
z82>cR#~2_QUx(>_Dxa(gN_Fkl$K`7%|5;cp=whsiYo_yG-Fp9RGHEE9f2cL){d(h_
zZDl>1czVFR=2TQcr)ml>2&X_bB~&a8yrDfg(-xj^vl<-ju|0}!-IL4Ak4SK-egTh`
zQh_TP8b!-;b9Tg*BYERl#Ux)z!D!Jxie)_PZE78>Q{0ZFAML7=@Gi04F>`RDk4oH=
zp{HAl=FY_%8pcj8e5yK|y6@90&+Gs22I(dzeyP9oT_h$z7SXn6`acofKzJS1{7w)y
zspibk8$S4yrt0bTxBR-Ky7kaOzle&?Ub8hv%ItzaGz)bOoh7)It3-IB>7vKZG*a^l
zB)qD^E}PF9zOz?2uFx-Dm$yp#y&iU#NfP0HzNyLfN3jssVrzBi;(L19N^r+3t?`5p
zA_Z|Amg_&1ovMF#FcnEbvtisin|ascK7}Co7k(M*BG+I>pahZu4?Syf!|{K`aMgZy
zyrmv`21O>1;g(wty2OFs>%n^ua}E>VN1cb=c!rGvMTyRIQwelagJ_z7i-Cz`Hu&kv
z2}I%n-AH0K;unYBxHTMe7Us!!ly&MqR%jKtCd#t^G2vm0n&46<B0zDlje5_3Dm^YF
zlmA%}t5}B5ULx%~3H$}YGHE;f-agkx<4pS45lF5R0vn-0oOSn3&rbv#c)h3pUyYUS
zUME%(mt8cm^Ky*V2W2ni7H4{WnVc{IEce=$Yu`s~!N*qB*?M<U@wr;9Qc<T}M)9TQ
z$oDoFPZi~-?FFU6`Y!tUc=f2tT}R#uJ%pR+ATIb(#D;Z1NtZ4!eU&2vpsdwTH<|JN
zqGdB^FDoNB@b}VqhM)J{sef<L2Fo~5H8|Cpj4g{Y7Fb$JdOf(OAHJ1}HKK|8@E;I1
zTt=BuQk+!cjEMk|S&aZ4bzP&UftqFPSLGbnDonbq=fsP?GtK&Sexxz<j@?Ffy6XpV
zRvWSSl(`K#<iF%?Ssn3D&f@cT)!5MEp`;f_Mg?X=VSK!~Jh)ch3K-L}Go>iJ0r~5y
z1<Wx%dqrg1vk3v>|Gdj+bi8_NX3$<KN^1yxl#(M90v!0|pm2wJQ!GY|7ypA}P}R9o
z+f<Tg+>>D8tj->Wwvw^CClEEEeXI*ulP>pXHXH_SU8Z!jP9nXJWetW&U@f-PII&a#
zv<{DKL=&u&UNmlSC7w*RBG);kETJ7<pUNu+D%FY|%8S14v1*TR<9Dz`tcy3<=V*T(
zv<FH@!kgn?YDiMtGgclzfUoZH&*?i)NiS-ha)~TBH}%T@c7~rNDg5RV2ZeJ|QYN8b
zO=FaSGj<-orJQ&8^T9xkpRqmg>^J+!>5}>^g!xZVVZE!1gT-w2q{{hHX9hUk1$eky
zp>KyC$8^=`nMPhO8$skEv~#juhSG19|7c*8(<o)!pTQb#=q+qu)sC-6hLxqoK}lB%
z(ehc^XL*y>6D<b6`>Y4^G8On3$qVxH^pt44CJz)`>F>zdTNWXBG`pL{1vZC$grs}&
z??Dw4jg`ON?Yz6>GlSaM8DpBrcKqCzg@~OU!^&W=R~*Zq14W*089a6lr-bJ`UNV$D
zycpc(?wp@_G9py_`{r5!KhSq{c`1cw?ZbDU9nOz#gZxo{o)@wZ>;{ixC+5dJAeyx{
z#v*a4$L})t_`x=nyft*(28zFT=bF(xpDW&Q$@VTjwfY74`g>y*_8Ce{cnE72MCNnp
z8Yb6HU?DI-|I3Fip5}vQ=!$3%Fq8YWv{be?`GJePpk6eZ#RmI5cUaYl@p})C*8@uI
z8q#doe_8D|DyH*htL#LRB%b)W4kz)=tqbzPG4I!34jiJg&yN?XF?p}{si`FQy@6fI
zL>7+P3E#%z(|*SIob~RIJjhReo8lXx3X&x)>)ILRZkzelgp$M}uo50P+4vtIbX90~
z9gzvqZbB{gv4?a;2SzNB87#%Dd5Ro{My#!Org|Ga{;3fQJ!-u-u6_a6Gmf&8rxX#K
zg*PrV!dNK#9hp8w;oEfVIrFDpK$`KKNzi?@M?YQ^Di(-{ZlJjgl4*qYd<+u86pJJE
z7*|p7v~lhmjqMC+j^}M=Bz?MEBJsFKgx{PMt)MWmK=D!r>k4?cCaN~3>#+`PqCNoB
zHO`qiLPT#D2iYp7Pd8ZpdCfK5oI7T9ldq(OiTdA-LW|xqhz+}GtDThR#$_FFd2Ut6
zpGqrLczf#N^lZ8JhTMt>#{#4wnp7K-F3n^>hz+^{VlL4%1DDwX=-$)9c3PcTDPjrk
zOv(NBu)R)_B5KA%5#4}xyyTZ4X`IakOa?d^&Y+J1h2&dOCb3gqm+$aSIiT`9lj1k#
zeLHHN)07fVdJn#PA07t9uGeDEDS=*#=B$M$o$MG-{f&4Z#WqY-7?qKs%gww+dg@U*
zTe(4>$O*M%ro9Ba|5$03czJ22S5ELfyAm-7-%V3<{iS);qbTy*WA}b%qu-9j{Iq$p
z0tM1xBhDnVrirWd5oSf+p^de05N?r3dE*h8fV!GJc#>z#mu%8xjid8Xx@pa>sB8Z6
zsV#}PP7`9wH!x7_^b?1<Mw_lfnRvK^6M46u)Y9zClt0~^>&T!&&;Lw<N;n`pGwfBw
z55+v@-)2*ua2xgzA<NB4sAg*R-9+MhmEq%9J1>f_?MS{ceb2B7VjpsH=>9Iltzd5U
zxBr+1w+z54HDa42pJw@?w6J2Mb?(ECLG;CU1uu%X^kpj!d&M`G?^5TWsg}$DwY4aI
z5gdbKezWHgYhizo9iOhaIPvJ`5A?)Wd(r;XW3<-<Gyw~tgx!gJqirIIzj%{z-sHa+
z6Jb#ix)c3fDSY*A(C-B(-47D)tNP02T@R4yq<1d%rN@AVrpYUEs632xE)c~hg<)j;
zK_T;wbCuZp)1_JoO6M!-c^3CqhwMbYs1u0e3{h}Uq18Q#%+dah;t`6D=|tV3D;(@m
zw~C%`+2wn+Cl_-bjOARD{T|yPvs#)_m6oaBHa0T!eY#`+S#NrJm>=kW1fO0zAD^t%
zf9;cu%9WCn<=2o?PkpXvu)i6hm`?%~d$x<YSBFl95Dxk*z&)H5n?NRdoM#aGH!tyB
zcEVA}f$sm<urP8I*D)}l^h-9bb#P$7>E`4sdGN@7I>lr3;Hgk&I;Cr`t&YyG`Iy0z
z%H)FPg}Ns+_UCt{WNhcLxW~QT5-<!SuBKQ1)R*e@`$JXF5Yjwldc*|p27O+H2)L+S
zsziA8XETSmbU2x$RNY;)XZbxHqcynEaIj(X2r%j-YKct{6N|^k{!eShIw)_qV&(gx
zY!d;vO0EhS-lrOQ82%zCZD_D*Z-YI{oJWhv)q5}OagxpM5B-Cce_<@e2DY=d{4;T;
zbXKRA_qA8<d&(6mM)c=<AlC7nn1)@wJT)Xf3ua4L*r?>om>BfEg<5rWGesv6L?n8;
zJo>M<wQvJXrPkuQ;a|pF>NlS$?TVscc`;3F3vU#ax2uBvQQ8+p`wR?s;5X^d5}wal
zWfg_zQ;(qtHQ=-;=6znQcn6BFsjwWTfn7`}*FQbpJCBN8f9a2B9$-Fyyg%NE<Zb~H
zVt}hpz_)Q9ZmbzKbwG4ix(T!e9-_;BH_0giE>s0EAMraq$21Jt?|=~jnRC>;D|IZx
zL1eL5F0ChMe_Tgs6<f}k5|s<6x^b0(4?4U`$^%X(ZC?)-ycx|nu@NN7tfK#Mn`+vq
zTqBv&D3qK-cQu?PvyHQEG03j0AvE+tz3q=;0;|D{4#IoB+9m}6V(*D(@Hts+rxI~_
z%LP06w7I#-$jwcRi9^s<@4Ug|bz!ZN`O%==@9JRA!}-+g;PD%7%Z(ecZ0A8+({Xuk
ze5(Y+t|zv~6Y1*Qze`eo^WdrhFGdr?a{&Ss45)1+HDAg$brn(-VNBRaP6Wq3n7%hT
zdt>5r%M81`VuxML)9S;lpHIV@1kKp~Umw8W|KLnOD@cI6zm~^i9#+aT2zzNgM$8R(
zQu6VEq3fsCzxid!y#9fjEV|=qf5puJIow}=cfAiOerFQcuV)(k7z|lkBw6Y1tAb2u
zyYp|5<m2=W4$E>yGY<DD<-wb56bjx)FZF#=&vrDqaf}HHFAPgjap`=kwdiGe{hjRc
z7{Z4`*q$!p%9Ny;O<(b&67xS-kU_ZuvMZdFUu(RRm7U!d;_>;_FrCs1t1l>y?N0*h
zXan`~18wr!<sEp55o+Hrbi}Q`C47|*dD4>Wd8>r~GfgAl+q_^Y=L~+bYW9eR8cDWG
z>kBxk4TIvxWVWZ#oS2K@|1rFpyPM%*`D9S}_c;fWs96foK+TKeF4tSR1H<gc=z3L`
z_}sQSUG%`lUL$VcHERkPCCc_GC<^+TwN7#=?~CSV)F`vR0jTyO1}HX2(HSLwSP=%Q
z?Sc;%!+X~)i>|>~fa0{p1~~tJe}FtLB5UnVV`hUdw%0`X+$)Mkfc?M)ITRvw{khSc
zxd*&DJ56_X8yhs~9EF5P$Zr68%(r4R=Rs`rDIdfSK)=g<9};n`Ii4Ujo?jjZ0`|8r
z@slCCcU4>Xm}Shfk5QN>m;0{Q3?BgV^W5!Y^TWP%wlw<K7tPLjkhG1t<G|ano(c>B
zypJ5$Gn5`M{bfk4s5+>7ud$)!hu6^s2&_g|@s}NV{cPG=GQ;tJj5d(~h$Rl&#^red
z42%vY%^pgwcX`C*V$UM4+#ayS30{c!{yD8qZpf$9M>PlS<*VxU7+M3Smj^!jMunl>
z=Hyl6U>v>r`=Qn*^eQfM@nffZ-C@HvG3Rod8}GdUKM3H(!u^-@gqjMWvfo)6b<ru3
zVwHtCTD37a@QikvXN;m<%|?i$Qbq~1*~a;C6N6!5VTP4Q$+Ma$Tin`vTq6ec<8pHf
zzmxq9WSJ|LQTF9-w<fp|7w1LBXm|7_MPu$=4m~|wEvdp;9b>dp*p#JM>?O3x6F&?G
zZtl;p>pO9kGzePp;p{;^w}%PSx{b^J(nru=Mqwdv&@fA#Hv(O8LHp7h!<t}6#XHUy
zd<qm?rbj1&y!4St+?rg;A%inDLO8kx8Jw0?`4;|Pf{YM84qEezf;o<vm#Q5|_na$R
zN9&pbwIdoKCjwJs36Pjb=IPSYjuGU0A@ppGme`zjzu{(I1#0JVJx#u>8H@D&XSmn?
z-gSfe+K&3*H`p)IWupww)Eo=3CQz9ehK1;fDRDXto~DB@!8An;AP)4}PaO5+h!I^A
z*2pf~3fk!QOMR=;I-|N+EQDY7U8y>upoGWJo%=&{$Mbhu&^YJHF#ska=eU&|&jAf_
zF->&<lWyu-w4>ovUi!Xz0&?5-9lH$AigPMU0{T+6ABR_^4KrnGI|nw(PrV6gL|zU)
zW!DFLp^|^X3*e(kF*(Dt%abw&M{(DtgXI$CV&-p-ZWj$B=^|BhwYp2q28Y}B!3JSh
zJ*nlR#!s^Kc-H>2$`#Teu6yLXXrHm=5&yKe+vHDIrmr*Hv$V#$a=9BxUN?>8H<n{@
z_p7?Z-kmm7%p1I}D3;u+QlXhm?fG~G!vHpUNqba5xp6lA(eFwmJsZ4~IEs36E$8S&
zlcp9^Qz9%fsNQdgTv$_ii8cl40BwUXrZCL@MPoR=`d!6&L{&`N<=6m;vE;ql?-3(k
zOfKfJJJo8MGrd9VKpK&U(wH6P-fr(f5<JoOUj%W2_Nl1h&3EhOo(%dcbKi1smq*)h
z^uXyjP37%~ACh7Z31c?QDBYAreGV^8`pgOi|LL4`0`Ib>IR!koD#G1=MnEaIgOfy8
zm+c14%^_~}69sRkcCsv_f1&@xEiKC^BC*?Jq%1tVq@#)X>N_<mK&1uRf${67rfiFF
z8_}yxXUAT@xUi3CBvJ<9$rIv&nsnPaFR!i>-Gf;G*RN0faDs$CcTzlDTf1jR<R2aN
z+j5h$!K3MH6w)|39FrQq@($~fgIgkj03kX-cV%Ov({_LhlDMj2V?r5|Y`60HRRn{0
zC8It+q(a<>ETT$%k`1H(XpnGwIs!-KqVs6eYz<^0t~RcGb%;C)loUhiHli0=gA(Tj
zi2PKih067paalIHL`wKPSX#skdwen+?j#nM?E)K(^5+L+DG`?V6NGSNhK5|om1ADc
zl15v76+Gi%+x@AUJZ2kdhzwUF;muleudP)j`4mc=fcq}wIHftmXBSqwWSmV~2%OFq
z(3I1QkX-Thz#liw>1goj0M*<4bPE0x*!DFQM}@HMw1%d!l6K&j{ZuGOcb{jh(C%^R
z71;h}?=sEeWCXmAR_R1hM+$>UEeV_O9|s#@VKu59zRqbE6+P78ZKu_$vm%A1qhdyA
z+$ZDKm-_?9{{LpM>3qnBtPo^4dv$%Kk5f*%=E7(V;8qz7P~_puY={>8hX{LM-Bs&L
z+Of%nS<s9;-Vzl+sQM~~e<zfGvABK`Ei*vAd05`@N4!f$#it6gLAEHktrTri?$TeP
zX~#8ik%~r6QDE?Tl<Ncl+ka!v<3jnS(JDRo)}FIkeW}F!=6;m|eOjTWtxm$KwSJn}
zjWMuFW9@3FWD5&H4~oP><QPA5cn>OsEE~haN#Uj9GfupfYDqO6P)>)Bui%7{6ZAW;
zZhqpJBsV+bJM7(+>JM%#ZOaSwE-VCommn@&32wex@SR=zblo9PJ>sX!a-F2*VSS^&
z=d`nPVT}ce74-lZAWQ(WHCH+BLFL!&oER5K7eo}8=65mS>q0q+F*?MNh`VbU21tng
z_W(*Uv5@%n!WxX_4itI9wz;1Bzc`%!e_tH_Kc5Nwe=5O=L=sME)8~m~GSokbXo|9G
KGG(8>1pPn6CYD?P

literal 0
HcmV?d00001

diff --git a/swift 2.0引用图片/2.png b/swift 2.0引用图片/2.png
new file mode 100644
index 0000000000000000000000000000000000000000..8a90b39c7735f9be325393b2c6b1de265163d331
GIT binary patch
literal 11136
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

literal 0
HcmV?d00001

diff --git a/swift 2.0引用图片/3.png b/swift 2.0引用图片/3.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ea56387ff0ef9a47085e3aeff9c28f7a60c9415
GIT binary patch
literal 8141
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
HrilLmR(l{8

literal 0
HcmV?d00001

diff --git a/swift 2.0引用图片/4.png b/swift 2.0引用图片/4.png
new file mode 100644
index 0000000000000000000000000000000000000000..134628c49767bcd06f2d2cc60553575c9c47b6c2
GIT binary patch
literal 6790
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

literal 0
HcmV?d00001

diff --git a/swift 2.0引用图片/5.png b/swift 2.0引用图片/5.png
new file mode 100644
index 0000000000000000000000000000000000000000..a0a2db6bbb11341406871f0cdac182f4149c4ef1
GIT binary patch
literal 10524
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

literal 0
HcmV?d00001

diff --git a/swift 2.0引用图片/6.png b/swift 2.0引用图片/6.png
new file mode 100644
index 0000000000000000000000000000000000000000..4ad5a41edb8ea3088f3f19b40e6541a2fd120ccb
GIT binary patch
literal 27189
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
a;ju4~_uR{Du2=q#@};46O*Id7*Z2PzQ|x{K

literal 0
HcmV?d00001


From f2017153d02f327ad436bc6bcf583c77502b8c0b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:38:52 +0800
Subject: [PATCH 155/228] update image link

---
 source/README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/source/README.md b/source/README.md
index 626edb69..4f31161f 100755
--- a/source/README.md
+++ b/source/README.md
@@ -27,11 +27,11 @@
 
 我错了。
 
-![图1](https://img.bi/#/TmFvPpk!BZO2eAzmXBRQaHN80Qukey5wTVrvFgxt2IAA5cQe)
-![图2](https://img.bi/#/DtL1E8F!yE5pOw7a4qyQSz_rPwGbfUGQumi3wQjY_XtQYi2W)
-![图3](https://img.bi/#/2FqhxS4!Bvkahw_U9kewHHHmeQw533Ewfm3nLAbrFMGAEpLs)
-![图4](https://img.bi/#/x8OFU6s!879WQwHIovTw7FqA-gTrwgqw-6qU6A4m22sgbK8F)
-![图5](https://img.bi/#/7nKCb0l!fLsVQAIuAzRQ2Xx4qwcSrIvQiou4sgl5tKfQajOK)
+![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/1.png)
+![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/2.png)
+![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/3.png)
+![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/4.png)
+![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/5.png)
 
 在我没有任何回复的情况下，不到一天时间，有五位朋友报名。看到这些回复的时候我真的很惊讶，也很感动，无论这个项目存在多少问题，只要有人关注，有人愿意为它付出，那我还有什么理由放弃呢？
 

From ee0da87628bcb2b351ea975be1e110f4a91204fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:39:56 +0800
Subject: [PATCH 156/228] break line

---
 source/README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/source/README.md b/source/README.md
index 4f31161f..1c3d27da 100755
--- a/source/README.md
+++ b/source/README.md
@@ -28,9 +28,13 @@
 我错了。
 
 ![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/1.png)
+
 ![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/2.png)
+
 ![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/3.png)
+
 ![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/4.png)
+
 ![](https://raw.githubusercontent.com/numbbbbb/the-swift-programming-language-in-chinese/gh-pages/swift%202.0%E5%BC%95%E7%94%A8%E5%9B%BE%E7%89%87/5.png)
 
 在我没有任何回复的情况下，不到一天时间，有五位朋友报名。看到这些回复的时候我真的很惊讶，也很感动，无论这个项目存在多少问题，只要有人关注，有人愿意为它付出，那我还有什么理由放弃呢？

From ea6aeb9016f94cc960374c810fdc103596ec3677 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:41:02 +0800
Subject: [PATCH 157/228] nin

---
 source/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/README.md b/source/README.md
index 1c3d27da..b3d9c608 100755
--- a/source/README.md
+++ b/source/README.md
@@ -7,7 +7,7 @@
 > <a target='_blank' href="http://swiftsandbox.io">Swift 优秀newsletter</a>
 
 <!-- -->
-> 如果你觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持是我们最大的动力。
+> 如果您觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持是我们最大的动力。
 
 # The Swift Programming Language 中文版
 

From 8db47153c72d62f8e2d3002f5c5f3ab63d43d3c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:41:58 +0800
Subject: [PATCH 158/228] add line

---
 source/README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/source/README.md b/source/README.md
index b3d9c608..765db2c1 100755
--- a/source/README.md
+++ b/source/README.md
@@ -11,9 +11,11 @@
 
 # The Swift Programming Language 中文版
 
-### 2.0 新的开始
+### 2.0 新的开始	
+-------
 
 #### 1
+-------
 
 开源项目完成难，维护更难。
 
@@ -24,6 +26,7 @@
 6月9日，calvingit发了一个issue“准备翻译2.0版本吗”，我没有回复，应该已经没人关注这个项目了吧，我想。
 
 #### 2
+-------
 
 我错了。
 
@@ -46,6 +49,7 @@
 第二天早晨，37个章节全部认领完毕。
 
 #### 3
+-------
 
 经过一个多月的努力，我们终于完成了文档的更新。听起来似乎没什么，确实，从1到n总是没有从0到1那么振奋人心。不过真正参与了才知道，修改往往比创造更麻烦，一个需要耐心，一个需要激情，前者往往得不到应有的重视。
 

From f38960a975d55930928e90c4c1cacebc2bfb3e2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:44:07 +0800
Subject: [PATCH 159/228] update titles

---
 source/README.md | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/source/README.md b/source/README.md
index 765db2c1..44ba3557 100755
--- a/source/README.md
+++ b/source/README.md
@@ -9,12 +9,9 @@
 <!-- -->
 > 如果您觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持是我们最大的动力。
 
-# The Swift Programming Language 中文版
+# 2.0 新的开始	
 
-### 2.0 新的开始	
--------
-
-#### 1
+## 1
 -------
 
 开源项目完成难，维护更难。
@@ -25,7 +22,7 @@
 
 6月9日，calvingit发了一个issue“准备翻译2.0版本吗”，我没有回复，应该已经没人关注这个项目了吧，我想。
 
-#### 2
+## 2
 -------
 
 我错了。
@@ -48,7 +45,7 @@
 
 第二天早晨，37个章节全部认领完毕。
 
-#### 3
+## 3
 -------
 
 经过一个多月的努力，我们终于完成了文档的更新。听起来似乎没什么，确实，从1到n总是没有从0到1那么振奋人心。不过真正参与了才知道，修改往往比创造更麻烦，一个需要耐心，一个需要激情，前者往往得不到应有的重视。

From 4579bf67a35cdc9b00b24b8beb4be6ac047e6352 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:46:22 +0800
Subject: [PATCH 160/228] remove line

---
 source/README.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/source/README.md b/source/README.md
index 44ba3557..993067ba 100755
--- a/source/README.md
+++ b/source/README.md
@@ -12,7 +12,6 @@
 # 2.0 新的开始	
 
 ## 1
--------
 
 开源项目完成难，维护更难。
 
@@ -23,7 +22,6 @@
 6月9日，calvingit发了一个issue“准备翻译2.0版本吗”，我没有回复，应该已经没人关注这个项目了吧，我想。
 
 ## 2
--------
 
 我错了。
 
@@ -46,7 +44,6 @@
 第二天早晨，37个章节全部认领完毕。
 
 ## 3
--------
 
 经过一个多月的努力，我们终于完成了文档的更新。听起来似乎没什么，确实，从1到n总是没有从0到1那么振奋人心。不过真正参与了才知道，修改往往比创造更麻烦，一个需要耐心，一个需要激情，前者往往得不到应有的重视。
 

From 92faa8a757d51c1b940a41bc74d239c695fb7779 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 09:54:02 +0800
Subject: [PATCH 161/228] add translators link

---
 README.md | 74 +++++++++++++++++++++++++++----------------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/README.md b/README.md
index 647ca8bb..9c3be274 100755
--- a/README.md
+++ b/README.md
@@ -15,43 +15,43 @@
 
 # 2.0译者记录
 
-- About Swift （**完成** By：@xtymichael）
-- A Swift Tour（**完成** By：@xtymichael）
-- The Basics（**完成** By：@xtymichael）
-- Basic Operators（**完成** By：@AlanMelody）
-- Strings and Characters（**完成** By：@DianQK）
-- Collection Types（**完成** By：@AlanMelody）
-- Control Flow（**完成** By：@AlanMelody）
-- Functions（**完成** By：@dreamkidd）
-- Closures（**完成** By：@100mango）
-- Enumerations（**完成** By：@futantan）
-- Classes and Structures（**完成** By：@SkyJean）
-- Properties（**完成** By：@yangsiy）
-- Methods（**完成** By：@DianQK）
-- Subscripts（**完成** By：@shanksyang）
-- Inheritance（**完成** By：@shanksyang）
-- Initialization（**完成** By：@chenmingbiao）
-- Deinitialization（**完成** By：@chenmingbiao）
-- Automatic Reference Counting（**完成** By：@Channe）
-- Optional Chaining（**完成** By：@lyojo）
-- Error Handling（**完成** By：@lyojo）
-- Type Casting（**完成** By：@yangsiy）
-- Nested Types（**完成** By：@SergioChan）
-- Extensions（**完成** By；@shanksyang）
-- Protocols（**完成** By：@futantan）
-- Generics（**完成** By：@SergioChan）
-- Access Control（**完成** By：@mmoaay）
-- Advanced Operators（**完成** By：@buginux）
-- About the Language Reference（**完成** By：@KYawn）
-- Lexical Structure（**完成** By：@buginux）
-- Types（**完成** By：@EudeMorgen）
-- Expressions（**完成** By：@EudeMorgen）
-- Statements（**完成** By：@littledogboy）
-- Declarations（**完成** By：@Lenhoon）
-- Attributes（**完成** By：@KYawn）
-- Patterns（**完成** By：@ray16897188）
-- Generic Parameters and Arguments（**完成** By：@wardenNScaiyi）
-- Summary of the Grammar（**完成** By：@miaosiqi）
+- About Swift （[xtymichael](https://github.com/xtymichael)）
+- A Swift Tour（[xtymichael](https://github.com/xtymichael)）
+- The Basics（[xtymichael](https://github.com/xtymichael)）
+- Basic Operators（[AlanMelody](https://github.com/AlanMelody)）
+- Strings and Characters（[DianQK](https://github.com/DianQK)）
+- Collection Types（[AlanMelody](https://github.com/AlanMelody)）
+- Control Flow（[AlanMelody](https://github.com/AlanMelody)）
+- Functions（[dreamkidd](https://github.com/dreamkidd)）
+- Closures（[100mango](https://github.com/100mango)）
+- Enumerations（[futantan](https://github.com/futantan)）
+- Classes and Structures（[SkyJean](https://github.com/SkyJean)）
+- Properties（[yangsiy](https://github.com/yangsiy)）
+- Methods（[DianQK](https://github.com/DianQK)）
+- Subscripts（[shanksyang](https://github.com/shanksyang)）
+- Inheritance（[shanksyang](https://github.com/shanksyang)）
+- Initialization（[chenmingbiao](https://github.com/chenmingbiao)）
+- Deinitialization（[chenmingbiao](https://github.com/chenmingbiao)）
+- Automatic Reference Counting（[Channe](https://github.com/Channe)）
+- Optional Chaining（[lyojo](https://github.com/lyojo)）
+- Error Handling（[lyojo](https://github.com/lyojo)）
+- Type Casting（[yangsiy](https://github.com/yangsiy)）
+- Nested Types（[SergioChan](https://github.com/SergioChan)）
+- Extensions（[shanksyang](https://github.com/shanksyang)）
+- Protocols（[futantan](https://github.com/futantan)）
+- Generics（[SergioChan](https://github.com/SergioChan)）
+- Access Control（[mmoaay](https://github.com/mmoaay)）
+- Advanced Operators（[buginux](https://github.com/buginux)）
+- About the Language Reference（[KYawn](https://github.com/KYawn)）
+- Lexical Structure（[buginux](https://github.com/buginux)）
+- Types（[EudeMorgen](https://github.com/EudeMorgen)）
+- Expressions（[EudeMorgen](https://github.com/EudeMorgen)）
+- Statements（[littledogboy](https://github.com/littledogboy)）
+- Declarations（[Lenhoon](https://github.com/Lenhoon)）
+- Attributes（[KYawn](https://github.com/KYawn)）
+- Patterns（[ray16897188](https://github.com/ray16897188)）
+- Generic Parameters and Arguments（[wardenNScaiyi](https://github.com/wardenNScaiyi)）
+- Summary of the Grammar（[miaosiqi](https://github.com/miaosiqi)）
 
 # 1.0译者记录
 

From dd1c99634e9b4e7d7b72166faa1f76797ae026d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 14:02:43 +0800
Subject: [PATCH 162/228] change style

---
 source/chapter2/01_The_Basics.md             | 2 +-
 source/chapter2/03_Strings_and_Characters.md | 2 +-
 source/chapter2/04_Collection_Types.md       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 35e84613..dce1b483 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -3,7 +3,7 @@
 > 校对：[lslxdx](https://github.com/lslxdx)
 
 > 2.0
-> [xtymichael](https://github.com/xtymichael)
+> 翻译+校对：[xtymichael](https://github.com/xtymichael)
 
 # 基础部分
 -----------------
diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 48657b40..d3ae7bc2 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[wh1100717](https://github.com/wh1100717)  
+> 翻译：[wh1100717](https://github.com/wh1100717)
 > 校对：[Hawstein](https://github.com/Hawstein)
 
 > 2.0
diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index 94636cdc..287a4caf 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[zqp](https://github.com/zqp), 
+> 翻译：[zqp](https://github.com/zqp)
 > 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin)
 
 > 2.0

From eab367788ccdf51f8eb4088b301f74900fd1ead1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 14:08:07 +0800
Subject: [PATCH 163/228] unify style

---
 config.json                                            | 2 +-
 source/chapter2/08_Enumerations.md                     | 2 +-
 source/chapter2/10_Properties.md                       | 2 +-
 source/chapter2/11_Methods.md                          | 2 +-
 source/chapter2/12_Subscripts.md                       | 2 +-
 source/chapter2/13_Inheritance.md                      | 2 +-
 source/chapter2/16_Automatic_Reference_Counting.md     | 2 +-
 source/chapter2/17_Optional_Chaining.md                | 2 +-
 source/chapter2/20_Nested_Types.md                     | 2 +-
 source/chapter2/21_Extensions.md                       | 2 +-
 source/chapter2/24_Access_Control.md                   | 2 +-
 source/chapter2/25_Advanced_Operators.md               | 2 +-
 source/chapter3/01_About_the_Language_Reference.md     | 2 +-
 source/chapter3/02_Lexical_Structure.md                | 2 +-
 source/chapter3/03_Types.md                            | 2 +-
 source/chapter3/04_Expressions.md                      | 2 +-
 source/chapter3/06_Attributes.md                       | 2 +-
 source/chapter3/08_Generic_Parameters_and_Arguments.md | 2 +-
 source/chapter3/09_Summary_of_the_Grammar.md           | 2 +-
 source/chapter3/10_Statements.md                       | 2 +-
 20 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/config.json b/config.json
index 38e5dc02..b4f3ff0e 100644
--- a/config.json
+++ b/config.json
@@ -1,6 +1,6 @@
 {
 	"name": "The Swift Programming Language 中文版",
-	"introduction": "自己加下...",
+	"introduction": "中文版《The Swift Programming Language》",
 	"path": {
 		"content": "source",
 		"toc": "source/SUMMARY.md",
diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 506f9612..e94f8e1f 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[yankuangshi](https://github.com/yankuangshi)  
+> 翻译：[yankuangshi](https://github.com/yankuangshi)
 > 校对：[shinyzhu](https://github.com/shinyzhu)
 
 > 2.0
diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index b14c7579..89c9c196 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[shinyzhu](https://github.com/shinyzhu)  
+> 翻译：[shinyzhu](https://github.com/shinyzhu)
 > 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
 
 > 2.0
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index a119bf00..1366f6e3 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[pp-prog](https://github.com/pp-prog)  
+> 翻译：[pp-prog](https://github.com/pp-prog)
 > 校对：[zqp](https://github.com/zqp)
 
 > 2.0
diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index 2eba7640..f1d2b5bd 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[siemenliu](https://github.com/siemenliu)  
+> 翻译：[siemenliu](https://github.com/siemenliu)
 > 校对：[zq54zquan](https://github.com/zq54zquan)
 
 > 2.0
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index d393f7fe..8ed3e432 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[Hawstein](https://github.com/Hawstein)  
+> 翻译：[Hawstein](https://github.com/Hawstein)
 > 校对：[menlongsheng](https://github.com/menlongsheng)
 
 > 2.0
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index 3bb443c9..ad672397 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[TimothyYe](https://github.com/TimothyYe)  
+> 翻译：[TimothyYe](https://github.com/TimothyYe)
 > 校对：[Hawstein](https://github.com/Hawstein)
 
 > 2.0
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index 13b0c87b..aa032d1b 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,7 +1,7 @@
 # 可空链式调用
 
 > 1.0
-> 翻译：[Jasonbroker](https://github.com/Jasonbroker)  
+> 翻译：[Jasonbroker](https://github.com/Jasonbroker)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
 > 2.0
diff --git a/source/chapter2/20_Nested_Types.md b/source/chapter2/20_Nested_Types.md
index fe0bf822..ea3f8bb8 100755
--- a/source/chapter2/20_Nested_Types.md
+++ b/source/chapter2/20_Nested_Types.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[Lin-H](https://github.com/Lin-H)  
+> 翻译：[Lin-H](https://github.com/Lin-H)
 > 校对：[shinyzhu](https://github.com/shinyzhu)
 
 > 2.0
diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index 7ff6ed0d..5bb404d5 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[lyuka](https://github.com/lyuka)  
+> 翻译：[lyuka](https://github.com/lyuka)
 > 校对：[Hawstein](https://github.com/Hawstein)
 
 > 2.0
diff --git a/source/chapter2/24_Access_Control.md b/source/chapter2/24_Access_Control.md
index 7c6f1967..ee77c9c8 100644
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[JaceFu](http://www.devtalking.com/)  
+> 翻译：[JaceFu](http://www.devtalking.com/)
 > 校对：[ChildhoodAndy](http://childhood.logdown.com)
 
 > 2.0
diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index cf750464..76b47c0b 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[xielingwang](https://github.com/xielingwang)  
+> 翻译：[xielingwang](https://github.com/xielingwang)
 > 校对：[numbbbbb](https://github.com/numbbbbb)
 
 > 2.0
diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md
index 67512914..802e571d 100755
--- a/source/chapter3/01_About_the_Language_Reference.md
+++ b/source/chapter3/01_About_the_Language_Reference.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[dabing1022](https://github.com/dabing1022)  
+> 翻译：[dabing1022](https://github.com/dabing1022)
 > 校对：[numbbbbb](https://github.com/numbbbbb)
 
 > 2.0
diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 8e913539..5bd5feb9 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[superkam](https://github.com/superkam)  
+> 翻译：[superkam](https://github.com/superkam)
 > 校对：[numbbbbb](https://github.com/numbbbbb)
 
 > 2.0
diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md
index 0d7c1ef3..80a42571 100644
--- a/source/chapter3/03_Types.md
+++ b/source/chapter3/03_Types.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[lyuka](https://github.com/lyuka)  
+> 翻译：[lyuka](https://github.com/lyuka)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
 > 2.0
diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md
index 8094c55d..7ef45764 100644
--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[sg552](https://github.com/sg552)  
+> 翻译：[sg552](https://github.com/sg552)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
 > 2.0
diff --git a/source/chapter3/06_Attributes.md b/source/chapter3/06_Attributes.md
index abf128e1..ab0db9d5 100755
--- a/source/chapter3/06_Attributes.md
+++ b/source/chapter3/06_Attributes.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[Hawstein](https://github.com/Hawstein)  
+> 翻译：[Hawstein](https://github.com/Hawstein)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
 
 > 2.0
diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index a68cf590..4d55719a 100755
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[fd5788](https://github.com/fd5788)  
+> 翻译：[fd5788](https://github.com/fd5788)
 > 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
 
 > 2.0
diff --git a/source/chapter3/09_Summary_of_the_Grammar.md b/source/chapter3/09_Summary_of_the_Grammar.md
index 27d9e630..c6d16483 100755
--- a/source/chapter3/09_Summary_of_the_Grammar.md
+++ b/source/chapter3/09_Summary_of_the_Grammar.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[stanzhai](https://github.com/stanzhai)  
+> 翻译：[stanzhai](https://github.com/stanzhai)
 > 校对：[xielingwang](https://github.com/xielingwang)
 
 > 2.0
diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index 5c2556ba..6fd60db7 100755
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -1,5 +1,5 @@
 > 1.0
-> 翻译：[coverxit](https://github.com/coverxit) 
+> 翻译：[coverxit](https://github.com/coverxit)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),
 
 > 2.0

From 0c4f593f9917c27071e4017f2690a8cfcf352fc2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 14:10:29 +0800
Subject: [PATCH 164/228] add <a> with blank target

---
 source/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/README.md b/source/README.md
index 993067ba..e9fe71b4 100755
--- a/source/README.md
+++ b/source/README.md
@@ -7,7 +7,7 @@
 > <a target='_blank' href="http://swiftsandbox.io">Swift 优秀newsletter</a>
 
 <!-- -->
-> 如果您觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持是我们最大的动力。
+> 如果您觉得这个项目不错，请<a target='_blank' href="https://github.com/numbbbbb/the-swift-programming-language-in-chinese">点击Star一下</a>，您的支持是我们最大的动力。
 
 # 2.0 新的开始	
 

From 96669aa6eb3c7e0333125a816b6707a0efd72139 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 14:28:25 +0800
Subject: [PATCH 165/228] change url

---
 index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/index.html b/index.html
index c4ca2b39..380bd5fd 100644
--- a/index.html
+++ b/index.html
@@ -3,7 +3,7 @@
     
     <head>
         
-        <meta http-equiv="refresh" content="0; url=http://numbbbbb.gitbooks.io/-the-swift-programming-language-/content/" />
+        <meta http-equiv="refresh" content="0; url=http://wiki.jikexueyuan.com/project/swift/" />
     
 
         

From 18bd85b0da01ab772562eb7e75817b0a4b997917 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 14:34:06 +0800
Subject: [PATCH 166/228] change jkxy link

---
 source/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/README.md b/source/README.md
index e9fe71b4..5504a0ec 100755
--- a/source/README.md
+++ b/source/README.md
@@ -75,4 +75,4 @@ Swift 2.0 参与者名单（按照章节顺序）：
 - [wardenNScaiyi](https://github.com/wardenNScaiyi)
 - [miaosiqi](https://github.com/miaosiqi)
 
-最后，感谢[极客学院](www.jikexueyuan.com)提供的wiki系统，在国内访问起来速度很快，优化后的样式看起来也更舒服。
\ No newline at end of file
+最后，感谢<a target='_blank' href="http://wiki.jikexueyuan.com/">极客学院</a>提供的wiki系统，在国内访问起来速度很快，优化后的样式看起来也更舒服。
\ No newline at end of file

From b3219fd071a27698b7ff79269560201061b63e60 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 4 Aug 2015 20:21:42 +0800
Subject: [PATCH 167/228] typo

---
 source/chapter2/21_Extensions.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index 5bb404d5..ed9aa047 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -29,7 +29,7 @@ Swift 中的扩展可以：
 - 使一个已有类型符合某个协议
 
 TODO：
-在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./Protocols.html#protocol_extensions)获取更多的细节。
+在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./22_Protocols.html#protocol_extensions)获取更多的细节。
 
 >注意：  
 扩展可以对一个类型添加新的功能，但是不能重写已有的功能。
@@ -52,7 +52,7 @@ extension SomeType: SomeProtocol, AnotherProctocol {
 }
 ```
 
-按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](./21_Protocols.html#adding_protocol_conformance_with_an_extension)
+按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](./22_Protocols.html#adding_protocol_conformance_with_an_extension)
 
 >注意：  
 如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。

From 387a4658cdd3efd96607cc4519fa651147dde2c4 Mon Sep 17 00:00:00 2001
From: Cmb <BillChan@CMB-2.local>
Date: Wed, 5 Aug 2015 01:00:54 +0800
Subject: [PATCH 168/228] =?UTF-8?q?=E6=9E=84=E9=80=A0=E8=BF=87=E7=A8=8B?=
 =?UTF-8?q?=EF=BC=8C=E9=87=8D=E5=86=99=E4=B8=8E=E9=87=8D=E8=BD=BD=E9=97=AE?=
 =?UTF-8?q?=E9=A2=98=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/14_Initialization.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 7cdf3179..9815c427 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -149,7 +149,7 @@ let veryGreen = Color(0.0, 1.0, 0.0)
 
 ### 不带外部名的构造器参数
 
-如果你不希望为构造器的某个参数提供外部名字，你可以使用下划线(_)来显示描述它的外部名，以此覆盖上面所说的默认行为。
+如果你不希望为构造器的某个参数提供外部名字，你可以使用下划线(_)来显示描述它的外部名，以此重写上面所说的默认行为。
 
 下面是之前`Celsius`例子的扩展，跟之前相比添加了一个带有`Double`类型参数名为`celsius`的构造器，其外部名用`_`代替。
 
@@ -472,21 +472,21 @@ Swift 编译器将执行 4 种有效的安全检查，以确保两段式构造
 最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。
 
 <a name="initializer_inheritance_and_overriding"></a>
-### 构造器的继承和重载
+### 构造器的继承和重写
 
 跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。
 
 >注意：
 父类的构造器仅在确定和安全的情况下被继承。具体内容请参考后续章节[自动构造器的继承](#automatic_initializer_inheritance)。
 
-假如你希望自定义的子类中能实现一个或多个跟父类相同的构造器，也许是为了完成一些定制的构造过程，你可以在你定制的子类中提供和重载与父类相同的构造器。
+假如你希望自定义的子类中能实现一个或多个跟父类相同的构造器，也许是为了完成一些定制的构造过程，你可以在你定制的子类中提供和重写与父类相同的构造器。
 
-当你写一个父类中带有指定构造器的子类构造器时，你需要重载这个指定的构造器。因此，你必须在定义子类构造器时带上`override`修饰符。即使你重载系统提供的默认构造器也需要带上`override`修饰符，具体内容请参考[默认构造器](#default_initializers)。
+当你写一个父类中带有指定构造器的子类构造器时，你需要重写这个指定的构造器。因此，你必须在定义子类构造器时带上`override`修饰符。即使你重写系统提供的默认构造器也需要带上`override`修饰符，具体内容请参考[默认构造器](#default_initializers)。
 
-无论是重载属性，方法或者是下标脚本，只要含有`override`修饰符就会去检查父类是否有相匹配的重载指定构造器和验证重载构造器参数。
+无论是重写属性，方法或者是下标脚本，只要含有`override`修饰符就会去检查父类是否有相匹配的重写指定构造器和验证重写构造器参数。
 
 >注意：  
-当你重载一个父类指定构造器时，你需要写`override`修饰符，甚至你的子类构造器继承的是父类的便利构造器。
+当你重写一个父类指定构造器时，你需要写`override`修饰符，甚至你的子类构造器继承的是父类的便利构造器。
 
 相反地，如果你写了一个和父类便利构造器相匹配的子类构造器，子类都不能直接调用父类的便利构造器，每个规则都在上文[构造器链](#initialization_chain)有所描述。
 
@@ -538,7 +538,7 @@ print("Bicycle: \(bicycle.description)")
 <a name="automatic_initializer_inheritance"></a>
 ### 自动构造器的继承
 
-如上所述，子类不会默认继承父类的构造器。但是如果特定条件可以满足，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重载父类的构造器，并且在尽可能安全的情况下以最小的代价来继承父类的构造器。
+如上所述，子类不会默认继承父类的构造器。但是如果特定条件可以满足，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重写父类的构造器，并且在尽可能安全的情况下以最小的代价来继承父类的构造器。
 
 假设要为子类中引入的任意新属性提供默认值，请遵守以下2个规则：
 
@@ -616,7 +616,7 @@ class RecipeIngredient: Food {
 
 `RecipeIngredient`也定义了一个便利构造器`init(name: String)`，它只通过`name`来创建`RecipeIngredient`的实例。这个便利构造器假设任意`RecipeIngredient`实例的`quantity`为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个`quantity`为 1 的`RecipeIngredient`实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。
 
-注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识（参见[构造器的继承和重载](#initializer_inheritance_and_overriding)）。
+注意，`RecipeIngredient`的便利构造器`init(name: String)`使用了跟`Food`中指定构造器`init(name: String)`相同的参数。因为这个便利构造器重写要父类的指定构造器`init(name: String)`，必须在前面使用使用`override`标识（参见[构造器的继承和重写](#initializer_inheritance_and_overriding)）。
 
 在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
 

From 36afcb5c127a3a2ed2c4d1c7210cee0b5c620901 Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Wed, 5 Aug 2015 15:46:38 +0800
Subject: [PATCH 169/228] add cover

---
 cover/cover.jpg | Bin 0 -> 1381956 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 cover/cover.jpg

diff --git a/cover/cover.jpg b/cover/cover.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..e247cc81dedbbac86d49cbd2a3a52de5e22f9354
GIT binary patch
literal 1381956
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%0AN95
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%0A4sdmrC}1E}nvCp;0ti02u&O-OP|dwFnrK>D(}a
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
z%0A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
I|K_iM0S|;$%K!iX

literal 0
HcmV?d00001


From 8036fbd6e153148b9bf7166eba274e0a19a7653a Mon Sep 17 00:00:00 2001
From: Yongzheng Lai <sdrzlyz@126.com>
Date: Wed, 5 Aug 2015 17:24:03 +0800
Subject: [PATCH 170/228] Update 01_The_Basics.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1、fix toInt issue
2、output issue
3、missing unwrapping `!`
---
 source/chapter2/01_The_Basics.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index dce1b483..0e04b550 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -557,7 +557,7 @@ C 和 Objective-C 中并没有可选类型这个概念。最接近的是 Objecti
 
 ```swift
 let possibleNumber = "123"
-let convertedNumber = Int(possibleNumber)
+let convertedNumber = possibleNumber.toInt()
 // convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
 ```
 
@@ -599,15 +599,15 @@ Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`n
 if convertedNumber != nil {
     print("convertedNumber contains some integer value.")
 }
-// 输出 "转换的数字包含整数值。"
+// 输出 "convertedNumber contains some integer value."
 ```
 当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（`!`）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的_强制解析（forced unwrapping）：
 
 ```swift
 if convertedNumber != nil {
-    print("convertedNumber has an integer value of \(convertedNumber).")
+    print("convertedNumber has an integer value of \(convertedNumber!).")
 }
-// 输出 "转换的数字有整数值123。"
+// 输出 "convertedNumber has an integer value of 123."
 ```
 
 更多关于`if`语句的内容，请参考[控制流](05_Control_Flow.html)。

From 2e5a211a89447797f8aec234740e86aee4c8e646 Mon Sep 17 00:00:00 2001
From: Yongzheng Lai <sdrzlyz@126.com>
Date: Wed, 5 Aug 2015 17:42:28 +0800
Subject: [PATCH 171/228] Update 01_The_Basics.md

missing type and equal `=`
---
 source/chapter2/01_The_Basics.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 0e04b550..4c866bc0 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -670,7 +670,7 @@ if let constantName = someOptional, anotherConstantName = someOtherOptional {
 
 ```swift
 let possibleString: String? = "An optional string."
-let forcedString: possibleString! // 需要惊叹号来获取值
+let forcedString:String = possibleString! // 需要惊叹号来获取值
 
 let assumedString: String! = "An implicitly unwrapped optional string."
 let implicitString: String = assumedString  // 不需要感叹号

From cf29167b64cc3b34fec01fd56560e7f2535a9cb9 Mon Sep 17 00:00:00 2001
From: Yongzheng Lai <sdrzlyz@126.com>
Date: Wed, 5 Aug 2015 17:43:43 +0800
Subject: [PATCH 172/228] Update 01_The_Basics.md

adding space
---
 source/chapter2/01_The_Basics.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 4c866bc0..4138b68c 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -670,7 +670,7 @@ if let constantName = someOptional, anotherConstantName = someOtherOptional {
 
 ```swift
 let possibleString: String? = "An optional string."
-let forcedString:String = possibleString! // 需要惊叹号来获取值
+let forcedString: String = possibleString! // 需要惊叹号来获取值
 
 let assumedString: String! = "An implicitly unwrapped optional string."
 let implicitString: String = assumedString  // 不需要感叹号

From fd4a0ce9683678415c41551b8ea748b0797ab857 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Thu, 6 Aug 2015 10:08:46 +0800
Subject: [PATCH 173/228] correct style

---
 source/chapter2/08_Enumerations.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index e94f8e1f..2fce4114 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -263,7 +263,6 @@ let possiblePlanet = Planet(rawValue: 7)
 
 然而，并非所有可能的`Int`值都可以找到一个匹配的行星。正因为如此，构造函数可以返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或“可选的`Planet`”。
 
-<!-- TODO 连接 -->  
 >注意：  
 >原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[可失败构造器](../chapter3/05_Declarations#failable_initializers)
 

From 621a8ac79d5f083114036e03b9bab2ca08c933ad Mon Sep 17 00:00:00 2001
From: evenluo <yiwenhuster@gmail.com>
Date: Thu, 6 Aug 2015 12:39:47 +0800
Subject: [PATCH 174/228] =?UTF-8?q?=E4=BF=AE=E6=AD=A3indices=E5=87=BD?=
 =?UTF-8?q?=E6=95=B0=E7=9A=84=E9=83=A8=E5=88=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/03_Strings_and_Characters.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index d3ae7bc2..17b06e9a 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -324,13 +324,15 @@ greeting[greeting.endIndex] // 错误
 greeting.endIndex.successor() // 错误
 ```
 
-使用`characters`属性的`indices`会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问分立的字符。  
+使用全局函数`indices`会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问分立的字符。  
 
 ```swift
-for index in greeting.characters.indices {
-    print("\(greeting[index]) ", appendNewline: false)
+for index in indices(greeting) {
+    print("\(greeting[index]) ")
 }
-// 打印输出 "G u t e n   T a g !"
+println("\n")
+// prints "G u t e n   T a g"
+
 ```
 
 <a name="inserting_and_removing"></a>

From b11931297264557a9ba3d5043c52842b0d0182c6 Mon Sep 17 00:00:00 2001
From: evenluo <yiwenhuster@gmail.com>
Date: Thu, 6 Aug 2015 15:07:59 +0800
Subject: [PATCH 175/228] =?UTF-8?q?=E4=B8=8EApple=E6=9C=80=E6=96=B0?=
 =?UTF-8?q?=E6=96=87=E6=A1=A3=E5=90=8C=E6=AD=A5=E4=BB=A5=E5=8F=8A=E9=83=A8?=
 =?UTF-8?q?=E5=88=86=E6=A0=BC=E5=BC=8F=E4=BF=AE=E6=AD=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/03_Strings_and_Characters.md | 61 +++++++++++++++-----
 1 file changed, 46 insertions(+), 15 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 17b06e9a..9aba0405 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -44,7 +44,11 @@ Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 
 
 您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
 字符串字面量可以用于为常量和变量提供初始值：
-```let someString = "Some string literal value"```
+
+```swift
+let someString = "Some string literal value"
+```
+
 注意`someString`常量通过字符串字面量进行初始化，Swift 会推断该常量为`String`类型。
 > 注意：
 > 更多关于在字面量的特殊字符，请查看 [Special Characters in String Literals](#special_characters_in_string_literals) 。
@@ -62,6 +66,7 @@ var anotherEmptyString = String()  // 初始化方法
 ```
 
 您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：
+
 ```swift
 if emptyString.isEmpty {
     print("Nothing to see here")
@@ -109,7 +114,7 @@ Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字
 您可通过`for-in`循环来遍历字符串中的`characters`属性来获取每一个字符的值：
 
 ```swift
-for character in "Dog!🐶".characters {
+for character in "Dog!🐶" {
     print(character)
 }
 // D
@@ -271,30 +276,34 @@ let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
 <a name="counting_characters"></a>
 ## 计算字符数量 (Counting Characters)
 
-调用字符串的`count`属性，就可以获取一个字符串的字符数量：
+如果想要获得一个字符串中字符的数量，可以调用全局函数`count(_:)`，把字符串作为参数传进去：
 
 
 ```swift
 let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
-print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
+println("unusualMenagerie has \(count(unusualMenagerie)) characters")
 // 打印输出："unusualMenagerie has 40 characters"
 ```
 
 注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。
+
 例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 `COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是 é ，而不是 e ：
 
 ```swift
 var word = "cafe"
-print("the number of characters in \(word) is \(word.characters.count)")
+println("the number of characters in \(word) is \(count(word))")
 // 打印输出 "the number of characters in cafe is 4"
+
 word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301
-print("the number of characters in \(word) is \(word.characters.count)")
+ 
+println("the number of characters in \(word) is \(count(word))")
 // 打印输出 "the number of characters in café is 4"
 ```
 
 > 注意：  
-> 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`characters`属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
-> 另外需要注意的是通过`characters`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。
+> 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`count(_:)`函数必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
+> 
+> 另外需要注意的是通过`count(_:)`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。作为佐证，当一个`NSString`的`length`属性被一个Swift的`String`值访问时，实际上是调用了`utf16Count`。
 
 
 <a name="accessing_and_modifying_a_string"></a>
@@ -304,8 +313,26 @@ print("the number of characters in \(word) is \(word.characters.count)")
 <a name="string_indices"></a>
 ### 字符串索引 (String Indices)
 每一个字符串都有一个关联的索引(*index*)类型，`String.index`，它对应着字符串中的每一个字符的位置。
+
 前面提到，不同的字符可能会占用不同的内存空间数量，所以要知道字符的确定位置，就必须从字符串开头遍历每一个 Unicode 标量到字符串结尾。因此，Swift 的字符串不能用整数(integer)做索引。
-使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后一个字符的末尾位置。如果字符串是空值，`startIndex`和`endIndex`是相等的。
+
+使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后一个字符的位置。如果字符串是空值，`startIndex`和`endIndex`是相等的。
+
+```swift
+let greeting = "Guten Tag"
+println(greeting.startIndex)
+// 0
+println(greeting.endIndex)
+// 9
+```
+
+你可以通过下表来获得`String`对应位置的`Character`：
+
+```swift
+greeting[greeting.startIndex]
+// G
+```
+
 通过调用`String.Index`的`predecessor()`方法，可以立即得到前面一个索引，调用`successor()`方法可以立即得到后面一个索引。任何一个字符串的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用`advance(start:n:)`函数来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误。
 你可以使用下标语法来访问字符在字符串的确切索引。尝试获取出界的字符串索引，仍然抛出一个运行时错误。
 
@@ -388,6 +415,7 @@ if quotation == sameQuotation {
 ```
 
 如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。
+
 例如，`LATIN SMALL LETTER E WITH ACUTE`(`U+00E9`)就是标准相等于`LATIN SMALL LETTER E`(`U+0065`)后面加上`COMBINING ACUTE ACCENT`(`U+0301`)。这两个字符群集都有效的表示字符 é ，所以它们被认为是标准相等的：
 
 ```swift
@@ -537,9 +565,9 @@ let dogString = "Dog‼🐶"
 
 ```swift
 for codeUnit in dogString.utf8 {
-    print("\(codeUnit) ", appendNewline: false)
+    print("\(codeUnit) ")
 }
-print("")
+print("\n")
 // 68 111 103 226 128 188 240 159 144 182
 ```
 
@@ -586,14 +614,16 @@ print("")
 
 ```swift
 for codeUnit in dogString.utf16 {
-    print("\(codeUnit) ", appendNewline: false)
+    print("\(codeUnit) ")
 }
-print("")
+print("\n")
 // 68 111 103 8252 55357 56374
 ```
 
 同样，前三个代码单元值 (68, 111, 103) 代表了字符`D`、`o`和`g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。
+
 第四个代码单元值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量值`U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。
+
 第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
 第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
 
@@ -637,14 +667,15 @@ print("")
 
 ```swift
 for scalar in dogString.unicodeScalars {
-    print("\(scalar.value) ", appendNewline: false)
+    print("\(scalar.value) ")
 }
-print("")
+print("\n")
 // 68 111 103 8252 128054
 ```
 
 前三个代码单元值 (68, 111, 103) 仍然代表字符`D`、`o`和`g`。
 第四个代码单元值 (8252) 仍然是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量`U+203C`。
+
 第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于`DOG FACE`的Unicode 标量`U+1F436`。
 
 作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：

From cc69eb779a99c15f75bf250207e0e624e3d8f40c Mon Sep 17 00:00:00 2001
From: even <yiwenhuster@gmail.com>
Date: Thu, 6 Aug 2015 15:19:09 +0800
Subject: [PATCH 176/228] Update 03_Strings_and_Characters.md

---
 source/chapter2/03_Strings_and_Characters.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 9aba0405..efb2fff3 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -229,7 +229,7 @@ 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 sparklingHeart = "\u{1F496}"      // 💖, Unicode 标量 U+1F496
 ```
 
 <a name="extended_grapheme_clusters"></a>  
@@ -316,7 +316,7 @@ println("the number of characters in \(word) is \(count(word))")
 
 前面提到，不同的字符可能会占用不同的内存空间数量，所以要知道字符的确定位置，就必须从字符串开头遍历每一个 Unicode 标量到字符串结尾。因此，Swift 的字符串不能用整数(integer)做索引。
 
-使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后一个字符的位置。如果字符串是空值，`startIndex`和`endIndex`是相等的。
+使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后的位置（译者注：其实endIndex在值上与字符串的长度相等）。如果字符串是空值，`startIndex`和`endIndex`是相等的。
 
 ```swift
 let greeting = "Guten Tag"

From c126f4fd88e4a11349e3bbb8d446ad6481b99e26 Mon Sep 17 00:00:00 2001
From: wan jerry <wanjerry.weibo@gmail.com>
Date: Thu, 6 Aug 2015 17:25:27 +0800
Subject: [PATCH 177/228] update 03_Strings_and_Characters.md

---
 source/chapter2/03_Strings_and_Characters.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index efb2fff3..0ec0ee94 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -34,7 +34,7 @@ Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 
 你也可以在常量、变量、字面量和表达式中进行字符串插值操作，这可以帮助你轻松创建用于展示、存储和打印的自定义字符串。
 
 > 注意：  
-> Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。就像 [`AnyObject`类型](./20_Type_Casting.html#anyobject) 中提到的一样，在使用 Cocoa 中的 Foundation 框架时，您可以将创建的任何字符串的值转换成`NSString`，并调用任意的`NSString` API。您也可以在任意要求传入`NSString`实例作为参数的 API 中用`String`类型的值代替。
+> Swift 的`String`类型与 Foundation `NSString`类进行了无缝桥接。就像 [`AnyObject`类型](./19_Type_Casting.html#anyobject) 中提到的一样，在使用 Cocoa 中的 Foundation 框架时，您可以将创建的任何字符串的值转换成`NSString`，并调用任意的`NSString` API。您也可以在任意要求传入`NSString`实例作为参数的 API 中用`String`类型的值代替。
 > 更多关于在 Foundation 和 Cocoa 中使用`String`的信息请查看 *[Using Swift with Cocoa and Objective-C](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)*。  
 
 
@@ -129,9 +129,9 @@ for-in 循环在 [For Loops](./05_Control_Flow.html#for_loops) 中进行了详
 另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量：
 
 ```swift
-let exclamationMark: Charater = "!"
+let exclamationMark: Character = "!"
 ```
-字符串可以通过传递一个值类型为`Charater`的数组作为自变量来初始化：
+字符串可以通过传递一个值类型为`Character`的数组作为自变量来初始化：
 
 ```swift
 let catCharacters: [Character] = ["C", "a", "t", "!", "🐱"]
@@ -429,7 +429,7 @@ if eAcuteQuestion == combinedEAcuteQuestion {
 // 打印输出 "These two strings are considered equal"
 ```
 
-相反，英语中的`LATIN CAPITAL LETTER A`(`U+0401`，或者`A`)不等于俄语中的`CYRILLIC CAPITAL LETTER A`(`U+0410`，或者`A`)。两个字符看着是一样的，但却有不同的语言意义：
+相反，英语中的`LATIN CAPITAL LETTER A`(`U+0041`，或者`A`)不等于俄语中的`CYRILLIC CAPITAL LETTER A`(`U+0410`，或者`A`)。两个字符看着是一样的，但却有不同的语言意义：
 
 ```swift
 let latinCapitalLetterA: Character = "\u{41}"
@@ -531,7 +531,7 @@ let dogString = "Dog‼🐶"
   <td>D<br>U+0044</td>
   <td>o<br>U+006F</td>
   <td>g<br>U+0067</td>
-  <td colspan=3>‼<br>U+1F436</td>
+  <td colspan=3>‼<br>U+203C</td>
   <td colspan=4>🐶<br>U+1F436</td>
  </tr>
  <tr height=77>
@@ -588,7 +588,7 @@ print("\n")
   <td>D<br>U+0044</td>
   <td>o<br>U+006F</td>
   <td>g<br>U+0067</td>
-  <td>‼<br>U+1F436</td>
+  <td>‼<br>U+203C</td>
   <td colspan=2>🐶<br>U+1F436</td>
  </tr>
  <tr height=77>
@@ -643,7 +643,7 @@ print("\n")
   <td>D<br>U+0044</td>
   <td>o<br>U+006F</td>
   <td>g<br>U+0067</td>
-  <td>‼<br>U+1F436</td>
+  <td>‼<br>U+203C</td>
   <td>🐶<br>U+1F436</td>
  </tr>
  <tr height=77>

From e06d67cda49971d4842b239c7a315b819f95f32e Mon Sep 17 00:00:00 2001
From: Bohan Zhang <bohanzhang@foxmail.com>
Date: Thu, 6 Aug 2015 21:44:43 +0800
Subject: [PATCH 178/228] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E5=87=BD=E6=95=B0?=
 =?UTF-8?q?=E8=B0=83=E7=94=A8=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter1/02_a_swift_tour.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index b2649081..f4f7f643 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -323,7 +323,7 @@ func lessThanTen(number: Int) -> Bool {
     return number < 10
 }
 var numbers = [20, 19, 7, 12]
-hasAnyMatches(numbers, condition: lessThanTen)
+hasAnyMatches(numbers, lessThanTen)
 ```
 
 函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用`{}`来创建一个匿名闭包。使用`in`将参数和返回值类型声明与闭包函数体进行分离。

From a8ba984b5397bae22d6ad30172a2510014130083 Mon Sep 17 00:00:00 2001
From: Honghao Zhang <zhh358@gmail.com>
Date: Fri, 7 Aug 2015 00:34:12 -0400
Subject: [PATCH 179/228] Fixed a translation mistake in Functions

in External Parameter Names
---
 source/chapter2/06_Functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 6b5030bb..6104efc2 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -250,7 +250,7 @@ someFunction(1, secondParameterName: 2)
 <a name="specifying_external_parameter_names"></a>
 ### 指定外部参数名(Specifying External Parameter Names)
 
-你可以在本地参数名前指定外部参数名,中间以逗号分隔.
+你可以在本地参数名前指定外部参数名,中间以空格分隔.
 
 ```swift
 func someFunction(externalParameterName localParameterName: Int) {

From 826ac435afb0d891b342982fd802ccc9e7e95e0b Mon Sep 17 00:00:00 2001
From: stevenlordiam <stevenlordiam@gmail.com>
Date: Fri, 7 Aug 2015 17:21:39 -0400
Subject: [PATCH 180/228] update 04_Expressions.md as Apple updated the
 document in Apr 6th

---
 source/chapter3/04_Expressions.md | 35 +++++++++++++++++++++++--------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md
index 7ef45764..762c0f77 100644
--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@@ -440,16 +440,10 @@ myData.someMethod {$0 == 13}
 
 Initializer表达式用来给某个Type初始化。 它的形式如下：
 
-> `expression`.init(`initializer arguments`)
+> `expression`.init(`initializer arguments`)
+
+初始化函数表达式在调用函数时用来初始某个Type。 也可以使用初始化函数表达式来委托调用（delegate to ）到superclass的initializers.
 
-（Initializer表达式用来给某个Type初始化。） 跟函数（function）不同， initializer 不能返回值。
-
-```swift
-var x = SomeClass.someClassFunction // ok
-var y = SomeClass.init              // error
-```
-
-可以通过 initializer 表达式来委托调用（delegate to ）到superclass的initializers.
 
 ```swift
 class SomeSubClass: SomeSuperClass {
@@ -459,6 +453,29 @@ class SomeSubClass: SomeSuperClass {
     }
 }
 ```
+
+和函数类似， 初始化表达式可以用作数值。 举例来说：
+
+```swift
+// Type annotation is required because String has multiple initializers.
+let initializer: Int -> String = String.init
+let oneTwoThree = [1, 2, 3].map(initializer).reduce("", combine: +)
+print(oneTwoThree)
+// prints "123"
+```
+
+如果要用名字来指定某个type， 可以不用初始化函数表达式直接使用type的initializer。在其他情况下， 你必须使用初始化函数表达式。
+
+
+```swift
+let s1 = SomeType.init(data: 3)  // Valid
+let s2 = SomeType(data: 1)       // Also valid
+
+let s4 = someValue.dynamicType(data: 5)       // Error
+let s3 = someValue.dynamicType.init(data: 7)  // Valid
+```
+
+
 
 > 构造器表达式语法  
 > *构造器表达式* → [*后置表达式*](../chapter3/04_Expressions.html#postfix_expression) **.** **init**  

From 38df437fe466de7d781fb64907131ccdd7c9d16a Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Tue, 11 Aug 2015 16:57:26 +0800
Subject: [PATCH 181/228] =?UTF-8?q?=E5=B0=86=E7=BF=BB=E8=AF=91=E4=BA=BA?=
 =?UTF-8?q?=E5=91=98=E5=A3=B0=E6=98=8E=E7=A7=BB=E5=88=B0=20h1=20=E4=B9=8B?=
 =?UTF-8?q?=E5=90=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/README.md                              | 50 +++++++++----------
 source/chapter1/01_swift.md                   |  7 ++-
 source/chapter1/02_a_swift_tour.md            |  8 +--
 source/chapter1/03_revision_history.md        |  6 +--
 source/chapter2/01_The_Basics.md              |  6 +--
 source/chapter2/02_Basic_Operators.md         |  6 +--
 source/chapter2/03_Strings_and_Characters.md  |  6 +--
 source/chapter2/04_Collection_Types.md        |  6 +--
 source/chapter2/05_Control_Flow.md            |  6 +--
 source/chapter2/06_Functions.md               |  6 +--
 source/chapter2/07_Closures.md                |  6 +--
 source/chapter2/08_Enumerations.md            |  6 +--
 source/chapter2/09_Classes_and_Structures.md  |  4 +-
 source/chapter2/10_Properties.md              |  6 +--
 source/chapter2/11_Methods.md                 |  6 +--
 source/chapter2/12_Subscripts.md              |  7 ++-
 source/chapter2/13_Inheritance.md             |  6 +--
 source/chapter2/14_Initialization.md          |  7 ++-
 source/chapter2/15_Deinitialization.md        |  6 +--
 .../16_Automatic_Reference_Counting.md        |  6 +--
 source/chapter2/17_Optional_Chaining.md       |  4 +-
 source/chapter2/18_Error_Handling.md          |  6 ++-
 source/chapter2/19_Type_Casting.md            |  6 +--
 source/chapter2/20_Nested_Types.md            |  6 +--
 source/chapter2/21_Extensions.md              |  6 +--
 source/chapter2/22_Protocols.md               |  6 +--
 source/chapter2/23_Generics.md                |  8 +--
 source/chapter2/24_Access_Control.md          |  6 +--
 source/chapter2/25_Advanced_Operators.md      |  6 +--
 .../01_About_the_Language_Reference.md        |  7 ++-
 source/chapter3/02_Lexical_Structure.md       |  5 +-
 source/chapter3/03_Types.md                   |  6 +--
 source/chapter3/04_Expressions.md             |  6 +--
 source/chapter3/05_Declarations.md            |  8 +--
 source/chapter3/06_Attributes.md              |  6 +--
 source/chapter3/07_Patterns.md                |  6 +--
 .../08_Generic_Parameters_and_Arguments.md    |  6 +--
 source/chapter3/09_Summary_of_the_Grammar.md  |  6 +--
 source/chapter3/10_Statements.md              |  8 +--
 source/chapter4/01_Access_Control.md          |  4 +-
 source/chapter4/02_Type_Custom.md             |  6 +--
 source/chapter4/03_Ballons.md                 |  4 +-
 .../04_Interacting_with_C_Pointers.md         |  6 +--
 .../chapter4/05_Value_and_Reference_Types.md  |  6 +--
 .../06_Access_Control_and_Protected.md        |  5 +-
 source/chapter4/07_Optional_Case_Study.md     |  6 +--
 46 files changed, 161 insertions(+), 161 deletions(-)

diff --git a/source/README.md b/source/README.md
index 5504a0ec..9b5da07a 100755
--- a/source/README.md
+++ b/source/README.md
@@ -1,3 +1,5 @@
+# 2.0 新的开始	
+
 > Swift 兴趣交流群：`131595168`, `146932759`, `151336833`, `153549217`. **加入一个群即可，请勿重复添加**
 
 > <a target='_blank' href="http://swiftist.org">Swift 开发者社区</a>
@@ -9,8 +11,6 @@
 <!-- -->
 > 如果您觉得这个项目不错，请<a target='_blank' href="https://github.com/numbbbbb/the-swift-programming-language-in-chinese">点击Star一下</a>，您的支持是我们最大的动力。
 
-# 2.0 新的开始	
-
 ## 1
 
 开源项目完成难，维护更难。
@@ -51,28 +51,28 @@
 
 下次你再打开这篇文档，可以多看看那些列在最上方的ID，哪怕不去follow和star，只是看一眼就好。他们的所有努力和付出，就存在于这短暂的一瞥中。
 
-Swift 2.0 参与者名单（按照章节顺序）：
-- [xtymichael](https://github.com/xtymichael)
-- [AlanMelody](https://github.com/AlanMelody)
-- [DianQK](https://github.com/DianQK)
-- [dreamkidd](https://github.com/dreamkidd)
-- [100mango](https://github.com/100mango)
-- [futantan](https://github.com/futantan)
-- [SkyJean](https://github.com/SkyJean)
-- [yangsiy](https://github.com/yangsiy)
-- [shanksyang](https://github.com/shanksyang)
-- [chenmingbiao](https://github.com/chenmingbiao)
-- [Channe](https://github.com/Channe)
-- [lyojo](https://github.com/lyojo)
-- [SergioChan](https://github.com/SergioChan)
-- [mmoaay](https://github.com/mmoaay)
-- [buginux](https://github.com/buginux)
-- [KYawn](https://github.com/KYawn)
-- [EudeMorgen](https://github.com/EudeMorgen)
-- [littledogboy](https://github.com/littledogboy)
-- [Lenhoon](https://github.com/Lenhoon)
-- [ray16897188](https://github.com/ray16897188)
-- [wardenNScaiyi](https://github.com/wardenNScaiyi)
-- [miaosiqi](https://github.com/miaosiqi)
+Swift 2.0 参与者名单（按照章节顺序）：  
+- [xtymichael](https://github.com/xtymichael)     
+- [AlanMelody](https://github.com/AlanMelody)    
+- [DianQK](https://github.com/DianQK)  
+- [dreamkidd](https://github.com/dreamkidd)  
+- [100mango](https://github.com/100mango)  
+- [futantan](https://github.com/futantan)  
+- [SkyJean](https://github.com/SkyJean)  
+- [yangsiy](https://github.com/yangsiy)  
+- [shanksyang](https://github.com/shanksyang)  
+- [chenmingbiao](https://github.com/chenmingbiao)  
+- [Channe](https://github.com/Channe)  
+- [lyojo](https://github.com/lyojo)  
+- [SergioChan](https://github.com/SergioChan)  
+- [mmoaay](https://github.com/mmoaay)  
+- [buginux](https://github.com/buginux)  
+- [KYawn](https://github.com/KYawn)  
+- [EudeMorgen](https://github.com/EudeMorgen)  
+- [littledogboy](https://github.com/littledogboy)   
+- [Lenhoon](https://github.com/Lenhoon)   
+- [ray16897188](https://github.com/ray16897188)   
+- [wardenNScaiyi](https://github.com/wardenNScaiyi)  
+- [miaosiqi](https://github.com/miaosiqi)  
 
 最后，感谢<a target='_blank' href="http://wiki.jikexueyuan.com/">极客学院</a>提供的wiki系统，在国内访问起来速度很快，优化后的样式看起来也更舒服。
\ No newline at end of file
diff --git a/source/chapter1/01_swift.md b/source/chapter1/01_swift.md
index f1c13a38..16313cbc 100755
--- a/source/chapter1/01_swift.md
+++ b/source/chapter1/01_swift.md
@@ -1,3 +1,6 @@
+# 关于 Swift
+-----------------
+
 > 1.0
 > 翻译：[numbbbbb](https://github.com/numbbbbb)  
 > 校对：[yeahdongcn](https://github.com/yeahdongcn)
@@ -5,10 +8,6 @@
 > 2.0
 > 翻译+校对：[xtymichael](https://github.com/xtymichael)
 
-
-# 关于 Swift
------------------
-
 Swift 是一种新的编程语言，用于编写 iOS，OS X 和 watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架，它的降临将重新定义软件开发。
 
 Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa 的基础上构建框架栈使其完全现代化和标准化。
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index f4f7f643..3fcc5d15 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -1,3 +1,7 @@
+# Swift 初见
+
+---
+
 > 1.0
 > 翻译：[numbbbbb](https://github.com/numbbbbb)
 > 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai)
@@ -5,10 +9,6 @@
 > 2.0
 > 翻译+校对：[xtymichael](https://github.com/xtymichael)
 
-# Swift 初见
-
----
-
 本页内容包括：
 
 -   [简单值（Simple Values）](#simple_values)
diff --git a/source/chapter1/03_revision_history.md b/source/chapter1/03_revision_history.md
index b4d57afd..d6bdfea0 100644
--- a/source/chapter1/03_revision_history.md
+++ b/source/chapter1/03_revision_history.md
@@ -1,10 +1,10 @@
-> 翻译：[成都老码团队翻译组-Arya](http://weibo.com/littlekok/)  
-> 校对：[成都老码团队翻译组-Oberyn](http://weibo.com/u/5241713117)
-
 # Swift 版本历史记录
 
 ---
 
+> 翻译：[成都老码团队翻译组-Arya](http://weibo.com/littlekok/)  
+> 校对：[成都老码团队翻译组-Oberyn](http://weibo.com/u/5241713117)
+
 本页内容包括：
 
 -   [XCode6.4 Beta Swift语法文档更新](#xcode6_4_Beta)
diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 4138b68c..5b458c8b 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -1,3 +1,6 @@
+# 基础部分
+-----------------
+
 > 1.0
 > 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus)
 > 校对：[lslxdx](https://github.com/lslxdx)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[xtymichael](https://github.com/xtymichael)
 
-# 基础部分
------------------
-
 本页包含内容：
 
 - [常量和变量](#constants_and_variables)
diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 89beb3c1..28874ae3 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -1,3 +1,6 @@
+# 基本运算符
+-----------------
+
 > 1.0
 > 翻译：[XieLingWang](https://github.com/xielingwang)
 > 校对：[EvilCome](https://github.com/Evilcome)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[JackAlan](https://github.com/AlanMelody)
 
-# 基本运算符
------------------
-
 本页包含内容：
 
 - [术语](#terminology)
diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 0ec0ee94..0084d44a 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -1,3 +1,6 @@
+# 字符串和字符（Strings and Characters）
+---
+
 > 1.0
 > 翻译：[wh1100717](https://github.com/wh1100717)
 > 校对：[Hawstein](https://github.com/Hawstein)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[DianQK](https://github.com/DianQK)
 
-# 字符串和字符（Strings and Characters）
----
-
 本页包含内容：
 
 - [字符串字面量](#string_literals)
diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index 287a4caf..c93fa22e 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -1,3 +1,6 @@
+# 集合类型 (Collection Types)
+-----------------
+
 > 1.0
 > 翻译：[zqp](https://github.com/zqp)
 > 校对：[shinyzhu](https://github.com/shinyzhu), [stanzhai](https://github.com/stanzhai), [feiin](https://github.com/feiin)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[JackAlan](https://github.com/AlanMelody)
 
-# 集合类型 (Collection Types)
------------------
-
 本页包含内容：
 
 - [集合的可变性（Mutability of Collections）](#mutability_of_collections)
diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index 6070ef8b..d3a31cf2 100755
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -1,3 +1,6 @@
+# 控制流
+-----------------
+
 > 1.0
 > 翻译：[vclwei](https://github.com/vclwei), [coverxit](https://github.com/coverxit), [NicePiao](https://github.com/NicePiao)
 > 校对：[coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[JackAlan](https://github.com/AlanMelody)
 
-# 控制流
------------------
-
 本页包含内容：
 
 - [For 循环](#for_loops)
diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 6104efc2..a43ebab2 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -1,3 +1,6 @@
+# 函数（Functions）
+-----------------
+
 > 1.0
 > 翻译：[honghaoz](https://github.com/honghaoz)
 > 校对：[LunaticM](https://github.com/LunaticM)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[dreamkidd](https://github.com/dreamkidd)
 
-# 函数（Functions）
------------------
-
 本页包含内容：
 
 - [函数定义与调用（Defining and Calling Functions）](#Defining_and_Calling_Functions)
diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 5f22445b..c93792e6 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -1,3 +1,6 @@
+# 闭包（Closures）
+-----------------
+
 > 1.0
 > 翻译：[wh1100717](https://github.com/wh1100717)
 > 校对：[lyuka](https://github.com/lyuka)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[100mango](https://github.com/100mango)
 
-# 闭包（Closures）
------------------
-
 本页包含内容：
 
 - [闭包表达式（Closure Expressions）](#closure_expressions)
diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index 2fce4114..89160fc9 100755
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -1,3 +1,6 @@
+# 枚举（Enumerations）
+---
+
 > 1.0
 > 翻译：[yankuangshi](https://github.com/yankuangshi)
 > 校对：[shinyzhu](https://github.com/shinyzhu)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[futantan](https://github.com/futantan)
 
-# 枚举（Enumerations）
----
-
 本页内容包含：
 
 - [枚举语法（Enumeration Syntax）](#enumeration_syntax)
diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index df922f29..e330c7c9 100755
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -1,3 +1,5 @@
+# 类和结构体
+
 > 1.0
 > 翻译：[JaySurplus](https://github.com/JaySurplus)
 > 校对：[sg552](https://github.com/sg552)
@@ -5,8 +7,6 @@
 > 2.0
 > 翻译+校对：[SkyJean](https://github.com/SkyJean)
 
-# 类和结构体
-
 本页包含内容：
 
 - [类和结构体对比](#comparing_classes_and_structures)
diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 89c9c196..1a341cc0 100755
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -1,3 +1,6 @@
+# 属性 (Properties)
+---
+
 > 1.0
 > 翻译：[shinyzhu](https://github.com/shinyzhu)
 > 校对：[pp-prog](https://github.com/pp-prog) [yangsiy](https://github.com/yangsiy)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[yangsiy](https://github.com/yangsiy)
 
-# 属性 (Properties)
----
-
 本页包含内容：
 
 - [存储属性（Stored Properties）](#stored_properties)
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index 1366f6e3..1c310af7 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -1,3 +1,6 @@
+# 方法（Methods）
+-----------------
+
 > 1.0
 > 翻译：[pp-prog](https://github.com/pp-prog)
 > 校对：[zqp](https://github.com/zqp)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[DianQK](https://github.com/DianQK)
 
-# 方法（Methods）
------------------
-
 本页包含内容：
 
 - [实例方法(Instance Methods)](#instance_methods)
diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index f1d2b5bd..8b33727f 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -1,3 +1,6 @@
+# 下标脚本（Subscripts）
+-----------------
+
 > 1.0
 > 翻译：[siemenliu](https://github.com/siemenliu)
 > 校对：[zq54zquan](https://github.com/zq54zquan)
@@ -5,10 +8,6 @@
 > 2.0
 > 翻译+校对：[shanksyang](https://github.com/shanksyang)
 
-
-# 下标脚本（Subscripts）
------------------
-
 本页包含内容：
 
 - [下标脚本语法](#subscript_syntax)
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index 8ed3e432..b4d94657 100755
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -1,3 +1,6 @@
+# 继承（Inheritance）
+-------------------
+
 > 1.0
 > 翻译：[Hawstein](https://github.com/Hawstein)
 > 校对：[menlongsheng](https://github.com/menlongsheng)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[shanksyang](https://github.com/shanksyang)
 
-# 继承（Inheritance）
--------------------
-
 本页包含内容：
 
 - [定义一个基类（Base class）](#defining_a_base_class)
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index 9815c427..0d99214f 100755
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -1,3 +1,6 @@
+# 构造过程（Initialization）
+-----------------
+
 > 1.0
 > 翻译：[lifedim](https://github.com/lifedim)
 > 校对：[lifedim](https://github.com/lifedim)
@@ -5,10 +8,6 @@
 > 2.0
 > 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
 
-# 构造过程（Initialization）
-
------------------
-
 本页包含内容：
 
 - [存储型属性的初始赋值](#setting_initial_values_for_stored_properties)
diff --git a/source/chapter2/15_Deinitialization.md b/source/chapter2/15_Deinitialization.md
index 6fd6cead..d93844be 100755
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -1,3 +1,6 @@
+# 析构过程（Deinitialization）
+---------------------------
+
 > 1.0
 > 翻译：[bruce0505](https://github.com/bruce0505)
 > 校对：[fd5788](https://github.com/fd5788)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[chenmingbiao](https://github.com/chenmingbiao)
 
-# 析构过程（Deinitialization）
----------------------------
-
 本页包含内容：
 
 - [析构过程原理](#how_deinitialization_works)
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index ad672397..8af3ee7e 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -1,3 +1,6 @@
+# 自动引用计数
+-----------------
+
 > 1.0
 > 翻译：[TimothyYe](https://github.com/TimothyYe)
 > 校对：[Hawstein](https://github.com/Hawstein)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[Channe](https://github.com/Channe)
 
-# 自动引用计数
------------------
-
 本页包含内容：
 
 - [自动引用计数的工作机制](#how_arc_works)
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index aa032d1b..2fb32213 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,4 +1,6 @@
 # 可空链式调用
+
+-----------------
 
 > 1.0
 > 翻译：[Jasonbroker](https://github.com/Jasonbroker)
@@ -7,7 +9,7 @@
 > 2.0
 > 翻译+校对：[lyojo](https://github.com/lyojo)
 
------------------
+
 可空链式调用（Optional Chaining）是一种可以请求和调用属性、方法及下标的过程，它的可空性体现于请求或调用的目标当前可能为空（nil）。如果可空的目标有值，那么调用就会成功；如果选择的目标为空（nil），那么这种调用将返回空（nil）。多个连续的调用可以被链接在一起形成一个调用链，如果其中任何一个节点为空（nil）将导致整个链调用失败。
 
 >
diff --git a/source/chapter2/18_Error_Handling.md b/source/chapter2/18_Error_Handling.md
index 6fc497f3..02c61bde 100644
--- a/source/chapter2/18_Error_Handling.md
+++ b/source/chapter2/18_Error_Handling.md
@@ -1,8 +1,10 @@
-> 2.0
-> 翻译+校对：[lyojo](https://github.com/lyojo)
 
 # 错误处理
 -----------------
+
+> 2.0
+> 翻译+校对：[lyojo](https://github.com/lyojo)
+
 错误处理是响应错误以及从错误中返回的过程。swift提供第一类错误支持，包括在运行时抛出，捕获，传送和控制可回收错误。
 
 一些函数和方法不能总保证能够执行所有代码或产生有用的输出。可空类型用来表示值可能为空，但是当函数执行失败的事后，可空通常可以用来确定执行失败的原因，因此代码可以正确地响应失败。在Swift中，这叫做抛出函数或者抛出方法。
diff --git a/source/chapter2/19_Type_Casting.md b/source/chapter2/19_Type_Casting.md
index 8ecbbfb7..969aac86 100644
--- a/source/chapter2/19_Type_Casting.md
+++ b/source/chapter2/19_Type_Casting.md
@@ -1,3 +1,6 @@
+# 类型转换（Type Casting）
+-----------------
+
 > 1.0
 > 翻译：[xiehurricane](https://github.com/xiehurricane)
 > 校对：[happyming](https://github.com/happyming)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[yangsiy](https://github.com/yangsiy)
 
-# 类型转换（Type Casting）
------------------
-
 本页包含内容：
 
 - [定义一个类层次作为例子](#defining_a_class_hierarchy_for_type_casting)
diff --git a/source/chapter2/20_Nested_Types.md b/source/chapter2/20_Nested_Types.md
index ea3f8bb8..33f72c5d 100755
--- a/source/chapter2/20_Nested_Types.md
+++ b/source/chapter2/20_Nested_Types.md
@@ -1,3 +1,6 @@
+# 嵌套类型
+-----------------
+
 > 1.0
 > 翻译：[Lin-H](https://github.com/Lin-H)
 > 校对：[shinyzhu](https://github.com/shinyzhu)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[SergioChan](https://github.com/SergioChan)
 
-# 嵌套类型
------------------
-
 本页包含内容：
 
 - [嵌套类型实例](#nested_types_in_action)
diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index ed9aa047..837b46ae 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -1,3 +1,6 @@
+# 扩展（Extensions）
+----
+
 > 1.0
 > 翻译：[lyuka](https://github.com/lyuka)
 > 校对：[Hawstein](https://github.com/Hawstein)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[shanksyang](https://github.com/shanksyang)
 
-#扩展（Extensions）
-----
-
 本页包含内容：
 
 - [扩展语法](#extension_syntax)
diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index f4c54666..7ead37b1 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -1,3 +1,6 @@
+# 协议
+-----------------
+
 > 1.0
 > 翻译：[geek5nan](https://github.com/geek5nan)
 > 校对：[dabing1022](https://github.com/dabing1022)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[futantan](https://github.com/futantan)
 
-# 协议
------------------
-
 本页包含内容：
 
 - [协议的语法（Protocol Syntax）](#protocol_syntax)
diff --git a/source/chapter2/23_Generics.md b/source/chapter2/23_Generics.md
index 5efaf96a..c462abc5 100644
--- a/source/chapter2/23_Generics.md
+++ b/source/chapter2/23_Generics.md
@@ -1,3 +1,7 @@
+# 泛型
+
+------
+
 > 1.0
 > 翻译：[takalard](https://github.com/takalard)
 > 校对：[lifedim](https://github.com/lifedim)
@@ -5,10 +9,6 @@
 > 2.0
 > 翻译+校对： [SergioChan](https://github.com/SergioChan)
 
-# 泛型
-
-------
-
 本页包含内容：
 
 - [泛型所解决的问题](#the_problem_that_generics_solve)
diff --git a/source/chapter2/24_Access_Control.md b/source/chapter2/24_Access_Control.md
index ee77c9c8..98a3d12e 100644
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@@ -1,3 +1,6 @@
+# 访问控制
+------------------
+
 > 1.0
 > 翻译：[JaceFu](http://www.devtalking.com/)
 > 校对：[ChildhoodAndy](http://childhood.logdown.com)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[mmoaay](https://github.com/mmoaay)
 
-# 访问控制
-------------------
-
 本页内容包括：
 
 - [模块和源文件](#modules_and_source_files)
diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index 76b47c0b..798e32a3 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -1,3 +1,6 @@
+# 高级运算符
+-----------------
+
 > 1.0
 > 翻译：[xielingwang](https://github.com/xielingwang)
 > 校对：[numbbbbb](https://github.com/numbbbbb)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[buginux](https://github.com/buginux)
 
-# 高级运算符
------------------
-
 本页内容包括：
 
 - [位运算符](#bitwise_operators)
diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md
index 802e571d..2cab43d6 100755
--- a/source/chapter3/01_About_the_Language_Reference.md
+++ b/source/chapter3/01_About_the_Language_Reference.md
@@ -1,3 +1,6 @@
+# 关于语言附注
+-----------------
+
 > 1.0
 > 翻译：[dabing1022](https://github.com/dabing1022)
 > 校对：[numbbbbb](https://github.com/numbbbbb)
@@ -5,10 +8,6 @@
 > 2.0
 > 翻译+校对：[KYawn](https://github.com/KYawn)
 
-
-# 关于语言附注
------------------
-
 本页内容包括：
 
 - [如何阅读语法](#how_to_read_the_grammar)
diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 5bd5feb9..178a17fa 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -1,3 +1,6 @@
+# 词法结构
+-----------------
+
 > 1.0
 > 翻译：[superkam](https://github.com/superkam)
 > 校对：[numbbbbb](https://github.com/numbbbbb)
@@ -5,8 +8,6 @@
 > 2.0
 > 翻译+校对：[buginux]([KYawn](https://github.com/buginux)
 
-# 词法结构
------------------
 
 本页包含内容：
 
diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md
index 80a42571..2ba926c2 100644
--- a/source/chapter3/03_Types.md
+++ b/source/chapter3/03_Types.md
@@ -1,3 +1,6 @@
+# 类型（Types）
+-----------------
+
 > 1.0
 > 翻译：[lyuka](https://github.com/lyuka)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[EudeMorgen](https://github.com/EudeMorgen)
 
-# 类型（Types）
------------------
-
 本页包含内容：
 
 - [类型注解（Type Annotation）](#type_annotation)
diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md
index 762c0f77..27b0b8fa 100644
--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@@ -1,3 +1,6 @@
+# 表达式（Expressions）
+-----------------
+
 > 1.0
 > 翻译：[sg552](https://github.com/sg552)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[EudeMorgen](https://github.com/EudeMorgen)
 
-# 表达式（Expressions）
------------------
-
 本页包含内容：
 
 - [前缀表达式（Prefix Expressions）](#prefix_expressions)
diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md
index 39983123..a2ee9325 100755
--- a/source/chapter3/05_Declarations.md
+++ b/source/chapter3/05_Declarations.md
@@ -1,3 +1,7 @@
+<a name="declarations"></a>
+# 声明
+-----------------
+
 > 1.0
 > 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
@@ -5,10 +9,6 @@
 > 2.0
 > 翻译+校对：[Lenhoon](https://github.com/Lenhoon)
 
-<a name="declarations"></a>
-# 声明
------------------
-
 本页包含内容：
 
 - [顶级代码](#top-level_code)
diff --git a/source/chapter3/06_Attributes.md b/source/chapter3/06_Attributes.md
index ab0db9d5..48688dc4 100755
--- a/source/chapter3/06_Attributes.md
+++ b/source/chapter3/06_Attributes.md
@@ -1,3 +1,6 @@
+# 特性
+-----------------
+
 > 1.0
 > 翻译：[Hawstein](https://github.com/Hawstein)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[KYawn](https://github.com/KYawn)
 
-# 特性
------------------
-
 本页内容包括：
 
 - [声明特性](#declaration_attributes)
diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 9985000c..056cdd22 100755
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -1,3 +1,6 @@
+# 模式（Patterns）
+-----------------
+
 > 1.0
 > 翻译：[honghaoz](https://github.com/honghaoz)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[ray16897188](https://github.com/ray16897188)  
 
-# 模式（Patterns）
------------------
-
 本页内容包括：
 
 - [通配符模式（Wildcard Pattern）](#wildcard_pattern)
diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index 4d55719a..3cb794df 100755
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -1,3 +1,6 @@
+# 泛型参数
+---------
+
 > 1.0
 > 翻译：[fd5788](https://github.com/fd5788)
 > 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[wardenNScaiyi](https:github.com/wardenNScaiyi)
 
-# 泛型参数
----------
-
 本页包含内容：
 
 - [泛型形参子句](#generic_parameter)
diff --git a/source/chapter3/09_Summary_of_the_Grammar.md b/source/chapter3/09_Summary_of_the_Grammar.md
index c6d16483..5af7d45d 100755
--- a/source/chapter3/09_Summary_of_the_Grammar.md
+++ b/source/chapter3/09_Summary_of_the_Grammar.md
@@ -1,3 +1,6 @@
+# 语法总结
+-----
+
 > 1.0
 > 翻译：[stanzhai](https://github.com/stanzhai)
 > 校对：[xielingwang](https://github.com/xielingwang)
@@ -5,9 +8,6 @@
 > 2.0
 > 翻译+校对：[miaosiqi](https://github.com/miaosiqi)
 
-# 语法总结
-_________________
-
 本页包含内容：
 
 * [语句（Statements）](#statements)
diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index 6fd60db7..c2f1e00f 100755
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -1,3 +1,7 @@
+<a name="statement_statements"></a>
+# 语句
+-----------------
+
 > 1.0
 > 翻译：[coverxit](https://github.com/coverxit)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),
@@ -5,10 +9,6 @@
 > 2.0
 > 翻译+校对：[littledogboy](https://github.com/littledogboy)
 
-<a name="statement_statements"></a>
-# 语句
------------------
-
 本页包含内容：
 
 - [循环语句](#loop_statements)
diff --git a/source/chapter4/01_Access_Control.md b/source/chapter4/01_Access_Control.md
index 9d058b52..60893521 100644
--- a/source/chapter4/01_Access_Control.md
+++ b/source/chapter4/01_Access_Control.md
@@ -1,8 +1,8 @@
+# Access Control 权限控制的黑与白
+
 > 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)
 > 校对：[老码团队翻译组-Oberyn](http://weibo.com/u/5241713117)
 
-# Access Control 权限控制的黑与白
-
 如果您之前没有接触过权限控制，先来听一个小故事：
 
 >  小明是五道口工业学院的一个大一新生，最近他有点烦恼，因为同屋经常用他的热水壶，好像那是自己家的一样，可是碍于同学情面，又不好意思说。直到有一天，他和学姐小K吐槽。
diff --git a/source/chapter4/02_Type_Custom.md b/source/chapter4/02_Type_Custom.md
index 20ab4542..56ab7f12 100644
--- a/source/chapter4/02_Type_Custom.md
+++ b/source/chapter4/02_Type_Custom.md
@@ -1,9 +1,9 @@
-> 翻译：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)
-> 校对：[老码团队翻译组-Oberyn](http://weibo.com/u/5241713117)
-
 # 造个类型不是梦-白话Swift类型创建
 -----------------
 
+> 翻译：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)
+> 校对：[老码团队翻译组-Oberyn](http://weibo.com/u/5241713117)
+
 本页包含内容：
 
 - [自定义原型](#prototype)
diff --git a/source/chapter4/03_Ballons.md b/source/chapter4/03_Ballons.md
index 999bf0fc..1c749ebe 100644
--- a/source/chapter4/03_Ballons.md
+++ b/source/chapter4/03_Ballons.md
@@ -1,8 +1,8 @@
+# WWDC里面的那个“大炮打气球”
+
 > 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)  
 > 校对：[老码团队翻译组-](Jame)
 
-# WWDC里面的那个“大炮打气球”
-
 ![Ballon playground](https://devimages.apple.com.edgekey.net/swift/images/swift-screenshot.jpg)
 
 
diff --git a/source/chapter4/04_Interacting_with_C_Pointers.md b/source/chapter4/04_Interacting_with_C_Pointers.md
index ac41306b..79a09b2e 100644
--- a/source/chapter4/04_Interacting_with_C_Pointers.md
+++ b/source/chapter4/04_Interacting_with_C_Pointers.md
@@ -1,9 +1,9 @@
-> 翻译：[老码团队翻译组-Relly](http://weibo.com/penguinliong/)  
-> 校对：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117) 
-
 # Swift与C语言指针友好合作
 -----------------
 
+> 翻译：[老码团队翻译组-Relly](http://weibo.com/penguinliong/)  
+> 校对：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117) 
+
 本页包含内容：
 
 - [用以输入/输出的参数指针](#inout-para-pointer)
diff --git a/source/chapter4/05_Value_and_Reference_Types.md b/source/chapter4/05_Value_and_Reference_Types.md
index 3a387d7f..f8b3ef96 100644
--- a/source/chapter4/05_Value_and_Reference_Types.md
+++ b/source/chapter4/05_Value_and_Reference_Types.md
@@ -1,9 +1,9 @@
-> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)  
-> 校对：[老码团队翻译组-Jame](http://weibo.com/u/5241713117)
-
 # Swift里的值类型与引用类型
 -----------------
 
+> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)  
+> 校对：[老码团队翻译组-Jame](http://weibo.com/u/5241713117)
+
 本页包含内容：
 
 - [值类型与引用类型的区别](#difference-two)
diff --git a/source/chapter4/06_Access_Control_and_Protected.md b/source/chapter4/06_Access_Control_and_Protected.md
index 55f3d19b..8bbcf292 100644
--- a/source/chapter4/06_Access_Control_and_Protected.md
+++ b/source/chapter4/06_Access_Control_and_Protected.md
@@ -1,9 +1,8 @@
-> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)  
-> 校对：[老码团队翻译组-Jame](http://weibo.com/u/5241713117)
-
 # 访问控制和protected
 -----------------
 
+> 翻译：[老码团队翻译组-Arya](http://weibo.com/littlekok/)  
+> 校对：[老码团队翻译组-Jame](http://weibo.com/u/5241713117)
 
 原文再续，书折第一回。
 
diff --git a/source/chapter4/07_Optional_Case_Study.md b/source/chapter4/07_Optional_Case_Study.md
index 486f409a..40c78cff 100644
--- a/source/chapter4/07_Optional_Case_Study.md
+++ b/source/chapter4/07_Optional_Case_Study.md
@@ -1,9 +1,9 @@
-> 翻译：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)  
-> 校对：[老码团队翻译组-Ayra](http://weibo.com/littlekok/)
-
 # 可选类型完美解决占位问题
 -----------------
 
+> 翻译：[老码团队翻译组-Tyrion](http://weibo.com/u/5241713117)  
+> 校对：[老码团队翻译组-Ayra](http://weibo.com/littlekok/)
+
 本页包含内容：
 
 - [为Dictionary增加objectsForKeys函数](#add-function)

From 397fcc065ed7db879497ebfd2f1eda807c3dfb6e Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Tue, 11 Aug 2015 17:02:25 +0800
Subject: [PATCH 182/228] =?UTF-8?q?=E4=BB=8E=E7=9B=AE=E5=BD=95=E4=B8=AD?=
 =?UTF-8?q?=E7=A7=BB=E9=99=A4=E7=A9=BA=E7=99=BD=E9=A1=B5=E9=9D=A2=E7=9A=84?=
 =?UTF-8?q?=E9=93=BE=E6=8E=A5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/SUMMARY.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/SUMMARY.md b/source/SUMMARY.md
index 10e9dc32..36344074 100755
--- a/source/SUMMARY.md
+++ b/source/SUMMARY.md
@@ -31,7 +31,7 @@
    * [泛型](chapter2/23_Generics.md)
    * [权限控制](chapter2/24_Access_Control.md)
    * [高级操作符](chapter2/25_Advanced_Operators.md)
-* [语言参考](chapter3/chapter3.md)
+* 语言参考
    * [关于语言参考](chapter3/01_About_the_Language_Reference.md)
    * [词法结构](chapter3/02_Lexical_Structure.md)
    * [类型](chapter3/03_Types.md)
@@ -42,7 +42,7 @@
    * [模式](chapter3/07_Patterns.md)
    * [泛型参数](chapter3/08_Generic_Parameters_and_Arguments.md)
    * [语法总结](chapter3/09_Summary_of_the_Grammar.md)
-* [苹果官方Blog官方翻译](chapter4/chapter4.md)
+* 苹果官方Blog官方翻译
    * [Access Control 权限控制的黑与白](chapter4/01_Access_Control.md)
    * [造个类型不是梦-白话Swift类型创建](chapter4/02_Type_Custom.md)
    * [WWDC里面的那个“大炮打气球”](chapter4/03_Ballons.md)

From 5da5b39f6e65028f609df4cef29bf7997fe6f007 Mon Sep 17 00:00:00 2001
From: Xwoder <xwoder@vip.qq.com>
Date: Tue, 11 Aug 2015 18:37:50 +0800
Subject: [PATCH 183/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0Swift=20=E5=88=9D?=
 =?UTF-8?q?=E8=A7=81=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter1/02_a_swift_tour.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index 3fcc5d15..93a58f5a 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -342,8 +342,8 @@ numbers.map({
 有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
 
 ```swift
-let mappedNumbers = numbers.map({ number in 3 * number })
-print(mappedNumbers)
+let sortedNumbers = numbers.sort { $0 > $1 }
+print(sortedNumbers)
 ```
 
 你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。

From d1309d55224d70ce661f839cb72c3dd16b1d6b1f Mon Sep 17 00:00:00 2001
From: Xwoder <xwoder@vip.qq.com>
Date: Wed, 12 Aug 2015 00:19:08 +0800
Subject: [PATCH 184/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=9F=BA=E7=A1=80?=
 =?UTF-8?q?=E9=83=A8=E5=88=86=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/01_The_Basics.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 5b458c8b..8d5a2ee7 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -631,12 +631,12 @@ if let constantName = someOptional {
 你可以像上面这样使用可选绑定来重写`possibleNumber`这个例子：
 
 ```swift
-if let actualNumber = possibleNumber.toInt() {
-    print("\(possibleNumber) has an integer value of \(actualNumber)")
-} else {
-    print("\(possibleNumber) could not be converted to an integer")
-}
-// 输出 "123 has an integer value of 123"
+if let actualNumber = Int(possibleNumber) {
+    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
+} else {
+    print("\'\(possibleNumber)\' could not be converted to an integer")
+}
+// 输出 "'123' has an integer value of 123"
 ```
 
 这段代码可以被理解为：

From ca36e6a9a0cc07c13c3ef57c17ee12187a47c625 Mon Sep 17 00:00:00 2001
From: Xwoder <xwoder@vip.qq.com>
Date: Thu, 13 Aug 2015 08:31:15 +0800
Subject: [PATCH 185/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=AD=97=E7=AC=A6?=
 =?UTF-8?q?=E4=B8=B2=E5=92=8C=E5=AD=97=E7=AC=A6=E9=83=A8=E5=88=86=E4=BB=A3?=
 =?UTF-8?q?=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/03_Strings_and_Characters.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 0084d44a..abf9ab8a 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -114,7 +114,7 @@ Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字
 您可通过`for-in`循环来遍历字符串中的`characters`属性来获取每一个字符的值：
 
 ```swift
-for character in "Dog!🐶" {
+for character in "Dog!🐶".characters {
     print(character)
 }
 // D

From 32d7b22943efbbd952508c31d7494689f41dd923 Mon Sep 17 00:00:00 2001
From: Vincent 4J <vincent4j@gmail.com>
Date: Thu, 13 Aug 2015 11:57:33 +0800
Subject: [PATCH 186/228] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97=EF=BC=9A?=
 =?UTF-8?q?=E5=B8=A6=E5=9F=8B=E3=80=8B=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/24_Access_Control.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/24_Access_Control.md b/source/chapter2/24_Access_Control.md
index 98a3d12e..e27bcfc9 100644
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@@ -150,7 +150,7 @@ private class SomePrivateClass {        // 显式的 private 类
 ### 函数类型
 函数的访问级别需要根据该函数的参数类型和返回类型的访问级别得出。如果根据参数类型和返回类型得出的函数访问级别不符合默认上下文，那么就需要明确地申明该函数的访问级别。
 
-下面的例子定义了一个名为`someFunction`全局函数，并且没有明确地申明其访问级别。也许你会认为该函数应该拥有默认的访问级别`internal`，但事实并非如此。事实上，如果按下面这种写法，带埋是无法编译通过的：
+下面的例子定义了一个名为`someFunction`全局函数，并且没有明确地申明其访问级别。也许你会认为该函数应该拥有默认的访问级别`internal`，但事实并非如此。事实上，如果按下面这种写法，代码是无法编译通过的：
 
 ```swift
 func someFunction() -> (SomeInternalClass, SomePrivateClass) {

From 9e730a4a4208321dc9e7d44b8cdaa829a889c44a Mon Sep 17 00:00:00 2001
From: Xwoder <xwoder@vip.qq.com>
Date: Thu, 13 Aug 2015 21:03:42 +0800
Subject: [PATCH 187/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E9=83=A8=E5=88=86?=
 =?UTF-8?q?=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/03_Strings_and_Characters.md | 29 +++++++++-----------
 source/chapter2/04_Collection_Types.md       |  2 +-
 2 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index abf9ab8a..7b780c20 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -276,13 +276,12 @@ let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
 <a name="counting_characters"></a>
 ## 计算字符数量 (Counting Characters)
 
-如果想要获得一个字符串中字符的数量，可以调用全局函数`count(_:)`，把字符串作为参数传进去：
-
+如果想要获得一个字符串中字符的数量，可以使用字符串的characters属性的count属性：
 
 ```swift
 let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
-println("unusualMenagerie has \(count(unusualMenagerie)) characters")
-// 打印输出："unusualMenagerie has 40 characters"
+print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
+// 打印输出 "unusualMenagerie has 40 characters"
 ```
 
 注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。
@@ -291,13 +290,13 @@ println("unusualMenagerie has \(count(unusualMenagerie)) characters")
 
 ```swift
 var word = "cafe"
-println("the number of characters in \(word) is \(count(word))")
+print("the number of characters in \(word) is \(word.characters.count)")
 // 打印输出 "the number of characters in cafe is 4"
-
+     
 word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301
- 
-println("the number of characters in \(word) is \(count(word))")
-// 打印输出 "the number of characters in café is 4"
+     
+print("the number of characters in \(word) is \(word.characters.count)")
+// 打印输出 "the number of characters in café is 4"
 ```
 
 > 注意：  
@@ -354,12 +353,10 @@ greeting.endIndex.successor() // 错误
 使用全局函数`indices`会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问分立的字符。  
 
 ```swift
-for index in indices(greeting) {
-    print("\(greeting[index]) ")
+for index in greeting.characters.indices {
+   print("\(greeting[index]) ", appendNewline: false)
 }
-println("\n")
-// prints "G u t e n   T a g"
-
+// prints "G u t e n   T a g !"
 ```
 
 <a name="inserting_and_removing"></a>
@@ -565,9 +562,9 @@ let dogString = "Dog‼🐶"
 
 ```swift
 for codeUnit in dogString.utf8 {
-    print("\(codeUnit) ")
+   print("\(codeUnit) ", appendNewline: false)
 }
-print("\n")
+print("")
 // 68 111 103 226 128 188 240 159 144 182
 ```
 
diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index c93fa22e..f26b2ccb 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -181,7 +181,7 @@ shoppingList[4...6] = ["Bananas", "Apples"]
 ```
 
 > 注意：
-> 不可以用下表访问的形式去在数组尾部添加新项。
+> 不可以用下标访问的形式去在数组尾部添加新项。
 
 
 调用数组的`insert(_:atIndex:)`方法来在某个具体索引值之前添加数据项：

From b3403c2bf88bc79c7a1b9e3e8d665ad0b7ae7719 Mon Sep 17 00:00:00 2001
From: Xwoder <xwoder@vip.qq.com>
Date: Sat, 15 Aug 2015 10:10:59 +0800
Subject: [PATCH 188/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E9=83=A8=E5=88=86?=
 =?UTF-8?q?=E6=96=87=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/05_Control_Flow.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index d3a31cf2..c189334b 100755
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -144,7 +144,7 @@ print("The loop statements were executed \(index) times")
 `while`循环运行一系列语句直到条件变成`false`。这类循环适合使用在第一次迭代前迭代次数未知的情况下。Swift 提供两种`while`循环形式：
 
 * `while`循环，每次在循环开始时计算条件是否符合；
-* `do-while`循环，每次在循环结束时计算条件是否符合。
+* `repeat-while`循环，每次在循环结束时计算条件是否符合。
 
 <a name="while"></a>
 ###While

From cd833dbd5fe231561ba6badd23acdc89ee2607be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Tue, 18 Aug 2015 11:24:34 +0800
Subject: [PATCH 189/228] add english version link

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 9c3be274..24b42d6a 100755
--- a/README.md
+++ b/README.md
@@ -3,6 +3,8 @@
 
 中文版Apple官方Swift教程《The Swift Programming Language》
 
+[英文原版](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/index.html#//apple_ref/doc/uid/TP40014097-CH3-ID0)
+
 **如果想帮忙翻译或者校对，请加QQ群：480616051，谢谢！**
 
 # 在线阅读

From 0058431009e16c9343b0774a6951d3206e072b63 Mon Sep 17 00:00:00 2001
From: Xwoder <xwoder@vip.qq.com>
Date: Thu, 20 Aug 2015 11:46:54 +0800
Subject: [PATCH 190/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E9=83=A8=E5=88=86?=
 =?UTF-8?q?=E6=96=87=E5=AD=97=E5=92=8C=E4=BB=A3=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/11_Methods.md            | 2 +-
 source/chapter2/25_Advanced_Operators.md | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index 1c310af7..d933eeeb 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -213,7 +213,7 @@ ovenLight.next()
 <a name="type_methods"></a>
 ## 类型方法 (Type Methods)
 
-实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。类可能会用关键字`Class`来允许子类重写父类的实现方法。
+实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。类可能会用关键字`class`来允许子类重写父类的实现方法。
 
 > 注意：  
 > 在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。  
diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index 798e32a3..cabbcb71 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -20,7 +20,7 @@
 
 与C语言中的算术运算符不同，Swift 中的算术运算符默认是不会溢出的。所有溢出行为都会被捕获并报告为错误。如果想让系统允许溢出行为，可以选择使用 Swift 中另一套默认支持溢出的运算符，比如溢出加法运算符(`&+`)。所有的这些溢出运算符都是以 `&` 开头的。
 
-在定义自有的结构体、类和枚举时，最好也同时为它们提供标准swift运算符的实现。Swift简化了运算符的自定义实现，也使判断不同类型所对应的行为更为简单。
+在定义自有的结构体、类和枚举时，最好也同时为它们提供标准Swift运算符的实现。Swift简化了运算符的自定义实现，也使判断不同类型所对应的行为更为简单。
 
 我们不用被预定义的运算符所限制。在 Swift 当中可以自由地定义中缀、前缀、后缀和赋值运算符，以及相应的优先级与结合性。这些运算符在代码中可以像预设的运算符一样使用，我们甚至可以扩展已有的类型以支持自定义的运算符。
 
@@ -434,7 +434,7 @@ if twoThree == anotherTwoThree {
 新的运算符要在全局作用域内，使用 `operator` 关键字进行声明，同时还要指定 `prefix`、`infix` 或者 `postfix` 限定符：
 
 ```swift
-operator prefix +++ {}
+prefix operator +++ {}
 ```
 
 上面的代码定义了一个新的名为 `+++` 的前缀运算符。对于这个运算符，在 Swift 中并没有意义，因为我们针对 `Vector2D` 的实例来定义它的意义。对这个示例来讲，`+++` 被实现为“前缀双自增”运算符。它使用了前面定义的复合加法操作符来让矩阵对自身进行相加，从而让 `Vector2D` 实例的 `x` 属性和 `y`属性的值翻倍：

From edb95b342b30923acf1cb5b2bbf2df28b1db8ba1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A2=81=E6=9D=B0?= <lj925184928@gmail.com>
Date: Fri, 21 Aug 2015 13:27:06 +0800
Subject: [PATCH 191/228] correct translator

---
 source/chapter3/02_Lexical_Structure.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 178a17fa..4e1fa307 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -6,7 +6,7 @@
 > 校对：[numbbbbb](https://github.com/numbbbbb)
 
 > 2.0
-> 翻译+校对：[buginux]([KYawn](https://github.com/buginux)
+> 翻译+校对：[buginux](https://github.com/buginux)
 
 
 本页包含内容：

From e189b558f75b7f5a78a124ce67bff8d500e84c48 Mon Sep 17 00:00:00 2001
From: Bing Cheung <BingCheung@users.noreply.github.com>
Date: Fri, 28 Aug 2015 07:05:30 +0800
Subject: [PATCH 192/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=A0=87=E9=A2=98?=
 =?UTF-8?q?=E5=85=B3=E4=BA=8E=E8=AF=AD=E8=A8=80=E9=99=84=E6=B3=A8=E4=B8=BA?=
 =?UTF-8?q?=E5=85=B3=E4=BA=8E=E8=AF=AD=E8=A8=80=E5=8F=82=E8=80=83,=20?=
 =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E8=8B=B1=E6=96=87=E6=A0=87=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter3/01_About_the_Language_Reference.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md
index 2cab43d6..0a6e6bfd 100755
--- a/source/chapter3/01_About_the_Language_Reference.md
+++ b/source/chapter3/01_About_the_Language_Reference.md
@@ -1,4 +1,4 @@
-# 关于语言附注
+# 关于语言参考（About the Language Reference）
 -----------------
 
 > 1.0

From 16be13f3bc998214e1bc408638376ed88ee66a0b Mon Sep 17 00:00:00 2001
From: Bing Cheung <BingCheung@users.noreply.github.com>
Date: Fri, 28 Aug 2015 07:11:41 +0800
Subject: [PATCH 193/228] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E8=8B=B1=E6=96=87?=
 =?UTF-8?q?=E6=A0=87=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter1/01_swift.md                      |  6 +++---
 source/chapter1/02_a_swift_tour.md               |  2 +-
 source/chapter2/01_The_Basics.md                 | 16 ++++++++--------
 source/chapter2/02_Basic_Operators.md            |  6 +++---
 source/chapter2/05_Control_Flow.md               |  2 +-
 source/chapter2/09_Classes_and_Structures.md     |  2 +-
 .../chapter2/16_Automatic_Reference_Counting.md  |  6 +++---
 source/chapter2/17_Optional_Chaining.md          |  6 +++---
 source/chapter2/18_Error_Handling.md             |  3 +--
 source/chapter2/20_Nested_Types.md               |  6 +++---
 source/chapter2/22_Protocols.md                  |  2 +-
 source/chapter2/23_Generics.md                   |  2 +-
 source/chapter2/24_Access_Control.md             |  2 +-
 source/chapter2/25_Advanced_Operators.md         |  2 +-
 source/chapter3/02_Lexical_Structure.md          |  2 +-
 source/chapter3/05_Declarations.md               |  6 +++---
 source/chapter3/06_Attributes.md                 |  6 +++---
 .../08_Generic_Parameters_and_Arguments.md       |  6 +++---
 source/chapter3/09_Summary_of_the_Grammar.md     |  6 +++---
 source/chapter3/10_Statements.md                 |  6 +++---
 20 files changed, 47 insertions(+), 48 deletions(-)

diff --git a/source/chapter1/01_swift.md b/source/chapter1/01_swift.md
index 16313cbc..1b5d9928 100755
--- a/source/chapter1/01_swift.md
+++ b/source/chapter1/01_swift.md
@@ -1,6 +1,6 @@
-# 关于 Swift
------------------
-
+# 关于 Swift（About Swift）
+-----------------
+
 > 1.0
 > 翻译：[numbbbbb](https://github.com/numbbbbb)  
 > 校对：[yeahdongcn](https://github.com/yeahdongcn)
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index 93a58f5a..4d5362ae 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -1,4 +1,4 @@
-# Swift 初见
+# Swift 初见（A Swift Tour）
 
 ---
 
diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 8d5a2ee7..e834b49c 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -1,6 +1,6 @@
-# 基础部分
------------------
-
+# 基础部分（The Basics）
+-----------------
+
 > 1.0
 > 翻译：[numbbbbb](https://github.com/numbbbbb), [lyuka](https://github.com/lyuka), [JaySurplus](https://github.com/JaySurplus)
 > 校对：[lslxdx](https://github.com/lslxdx)
@@ -631,11 +631,11 @@ if let constantName = someOptional {
 你可以像上面这样使用可选绑定来重写`possibleNumber`这个例子：
 
 ```swift
-if let actualNumber = Int(possibleNumber) {
-    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
-} else {
-    print("\'\(possibleNumber)\' could not be converted to an integer")
-}
+if let actualNumber = Int(possibleNumber) {
+    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
+} else {
+    print("\'\(possibleNumber)\' could not be converted to an integer")
+}
 // 输出 "'123' has an integer value of 123"
 ```
 
diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 28874ae3..9e0f872e 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -1,6 +1,6 @@
-# 基本运算符
------------------
-
+# 基本运算符（Basic Operators）
+-----------------
+
 > 1.0
 > 翻译：[XieLingWang](https://github.com/xielingwang)
 > 校对：[EvilCome](https://github.com/Evilcome)
diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index c189334b..3a368de0 100755
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -1,4 +1,4 @@
-# 控制流
+# 控制流（Control Flow）
 -----------------
 
 > 1.0
diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index e330c7c9..74257884 100755
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -1,4 +1,4 @@
-# 类和结构体
+# 类和结构体（Classes and Structures）
 
 > 1.0
 > 翻译：[JaySurplus](https://github.com/JaySurplus)
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index 8af3ee7e..bb697029 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -1,6 +1,6 @@
-# 自动引用计数
------------------
-
+# 自动引用计数（Automatic Reference Counting）
+-----------------
+
 > 1.0
 > 翻译：[TimothyYe](https://github.com/TimothyYe)
 > 校对：[Hawstein](https://github.com/Hawstein)
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index 2fb32213..43ee5426 100755
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,6 +1,6 @@
-# 可空链式调用
-
------------------
+# 可空链式调用（Optional Chaining）
+
+-----------------
 
 > 1.0
 > 翻译：[Jasonbroker](https://github.com/Jasonbroker)
diff --git a/source/chapter2/18_Error_Handling.md b/source/chapter2/18_Error_Handling.md
index 02c61bde..f2c7c768 100644
--- a/source/chapter2/18_Error_Handling.md
+++ b/source/chapter2/18_Error_Handling.md
@@ -1,5 +1,4 @@
-
-# 错误处理
+# 错误处理（Error Handling）
 -----------------
 
 > 2.0
diff --git a/source/chapter2/20_Nested_Types.md b/source/chapter2/20_Nested_Types.md
index 33f72c5d..cec975a3 100755
--- a/source/chapter2/20_Nested_Types.md
+++ b/source/chapter2/20_Nested_Types.md
@@ -1,6 +1,6 @@
-# 嵌套类型
------------------
-
+# 嵌套类型（Nested Types）
+-----------------
+
 > 1.0
 > 翻译：[Lin-H](https://github.com/Lin-H)
 > 校对：[shinyzhu](https://github.com/shinyzhu)
diff --git a/source/chapter2/22_Protocols.md b/source/chapter2/22_Protocols.md
index 7ead37b1..ae8f74b0 100644
--- a/source/chapter2/22_Protocols.md
+++ b/source/chapter2/22_Protocols.md
@@ -1,4 +1,4 @@
-# 协议
+# 协议（Protocols）
 -----------------
 
 > 1.0
diff --git a/source/chapter2/23_Generics.md b/source/chapter2/23_Generics.md
index c462abc5..2d34fe26 100644
--- a/source/chapter2/23_Generics.md
+++ b/source/chapter2/23_Generics.md
@@ -1,4 +1,4 @@
-# 泛型
+# 泛型（Generics）
 
 ------
 
diff --git a/source/chapter2/24_Access_Control.md b/source/chapter2/24_Access_Control.md
index e27bcfc9..0e13cec3 100644
--- a/source/chapter2/24_Access_Control.md
+++ b/source/chapter2/24_Access_Control.md
@@ -1,4 +1,4 @@
-# 访问控制
+# 访问控制（Access Control）
 ------------------
 
 > 1.0
diff --git a/source/chapter2/25_Advanced_Operators.md b/source/chapter2/25_Advanced_Operators.md
index cabbcb71..e556b045 100644
--- a/source/chapter2/25_Advanced_Operators.md
+++ b/source/chapter2/25_Advanced_Operators.md
@@ -1,4 +1,4 @@
-# 高级运算符
+# 高级运算符（Advanced Operators）
 -----------------
 
 > 1.0
diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 4e1fa307..c2acd335 100755
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -1,4 +1,4 @@
-# 词法结构
+# 词法结构（Lexical Structure）
 -----------------
 
 > 1.0
diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md
index a2ee9325..541dbef4 100755
--- a/source/chapter3/05_Declarations.md
+++ b/source/chapter3/05_Declarations.md
@@ -1,7 +1,7 @@
 <a name="declarations"></a>
-# 声明
------------------
-
+# 声明（Declarations）
+-----------------
+
 > 1.0
 > 翻译：[marsprince](https://github.com/marsprince) [Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
diff --git a/source/chapter3/06_Attributes.md b/source/chapter3/06_Attributes.md
index 48688dc4..aa81dcd4 100755
--- a/source/chapter3/06_Attributes.md
+++ b/source/chapter3/06_Attributes.md
@@ -1,6 +1,6 @@
-# 特性
------------------
-
+# 特性（Attributes）
+-----------------
+
 > 1.0
 > 翻译：[Hawstein](https://github.com/Hawstein)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index 3cb794df..fc4657f8 100755
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -1,6 +1,6 @@
-# 泛型参数
----------
-
+# 泛型参数（Generic Parameters and Arguments）
+---------
+
 > 1.0
 > 翻译：[fd5788](https://github.com/fd5788)
 > 校对：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
diff --git a/source/chapter3/09_Summary_of_the_Grammar.md b/source/chapter3/09_Summary_of_the_Grammar.md
index 5af7d45d..79988361 100755
--- a/source/chapter3/09_Summary_of_the_Grammar.md
+++ b/source/chapter3/09_Summary_of_the_Grammar.md
@@ -1,6 +1,6 @@
-# 语法总结
------
-
+# 语法总结（Summary of the Grammar）
+-----
+
 > 1.0
 > 翻译：[stanzhai](https://github.com/stanzhai)
 > 校对：[xielingwang](https://github.com/xielingwang)
diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index c2f1e00f..5aff0508 100755
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -1,7 +1,7 @@
 <a name="statement_statements"></a>
-# 语句
------------------
-
+# 语句（Statements）
+-----------------
+
 > 1.0
 > 翻译：[coverxit](https://github.com/coverxit)
 > 校对：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai),

From 8c0733ebc3e9c8188abcd42c97926a603b4f8163 Mon Sep 17 00:00:00 2001
From: yonggang_liu <liuyonggang@syberos.com>
Date: Mon, 31 Aug 2015 18:12:22 +0800
Subject: [PATCH 194/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=80=E4=B8=AA?=
 =?UTF-8?q?=E7=BF=BB=E8=AF=91=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/03_Strings_and_Characters.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 7b780c20..6a46bb8b 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -184,7 +184,7 @@ let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
 // message 是 "3 times 2.5 is 7.5"
 ```
 
-在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串字面量中。
+在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串常量量中。
 当创建字符串执行插值计算时此占位符会被替换为`multiplier`实际的值。
 
 `multiplier`的值也作为字符串中后面表达式的一部分。

From a8af7f4b8146901e3ac84c819f05505c0e774216 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com>
Date: Sun, 6 Sep 2015 04:05:45 +0800
Subject: [PATCH 195/228] =?UTF-8?q?=E4=B8=BA=20=E2=80=9C=E9=BB=98=E8=AE=A4?=
 =?UTF-8?q?=E5=8F=82=E6=95=B0=E5=80=BC=EF=BC=88Default=20Parameter=20Value?=
 =?UTF-8?q?s=EF=BC=89=E2=80=9D=20=E6=B7=BB=E5=8A=A0=E8=B7=B3=E8=BD=AC?=
 =?UTF-8?q?=E9=93=BE=E6=8E=A5=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/06_Functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index a43ebab2..72d7f47c 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -292,7 +292,7 @@ someFunction(1, 2)
 > 注意:
 > 因为第一个参数默认忽略其外部参数名称，明确写下划线是多余的。
 
-
+<a name="default_Parameter_values"></a>
 ### 默认参数值（Default Parameter Values）
 
 你可以在函数体中为每个参数定义`默认值(Deafult Values)`。当默认值被定义后，调用这个函数时可以忽略这个参数。

From 22a4ce0d0410a7e478ca53cb68c5bd8e67ba6753 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com>
Date: Sun, 6 Sep 2015 04:17:39 +0800
Subject: [PATCH 196/228] Update 06_Functions.md

---
 source/chapter2/06_Functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 72d7f47c..29356027 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -292,7 +292,7 @@ someFunction(1, 2)
 > 注意:
 > 因为第一个参数默认忽略其外部参数名称，明确写下划线是多余的。
 
-<a name="default_Parameter_values"></a>
+<a name="default_parameter_values"></a>
 ### 默认参数值（Default Parameter Values）
 
 你可以在函数体中为每个参数定义`默认值(Deafult Values)`。当默认值被定义后，调用这个函数时可以忽略这个参数。

From 8cf7178bf8f76ce626ffd288b7c610cba98c6022 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com>
Date: Sun, 6 Sep 2015 04:28:27 +0800
Subject: [PATCH 197/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20=E2=80=9C=E8=BE=93?=
 =?UTF-8?q?=E5=87=BA=E5=B8=B8=E9=87=8F=E5=92=8C=E5=8F=98=E9=87=8F=E2=80=9D?=
 =?UTF-8?q?=20=E4=B8=AD=E2=80=9Cprint(=5F:separator:terminator:)=E2=80=9D?=
 =?UTF-8?q?=E5=87=BD=E6=95=B0=E6=8F=8F=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

涉及到跳转链接 “默认参数值”，也在函数章节对应部分新加了链接。我参考别的链接照着弄的，不知道行不。。。- -！
---
 source/chapter2/01_The_Basics.md | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index e834b49c..bbd0d086 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -149,23 +149,14 @@ languageName = "Swift++"
 <a name="printing"></a>
 ### 输出常量和变量
 
-你可以用`print(_:)`函数来输出当前常量或变量的值:
+你可以用`print(_:separator:terminator:)`函数来输出当前常量或变量的值:
 
 ```swift
 print(friendlyWelcome)
 // 输出 "Bonjour!"
 ```
 
-`print(_:)`是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，`print(_:)`将会输出内容到“console”面板上。(另一种函数叫`print(_:appendNewline:)`，唯一区别是在输出内容最后不会换行。)
-
-`print(_:)`函数输出传入的`String`值：
-
-```swift
-print("This is a string")
-// 输出 "This is a string"
-```
-
-`print(_:)`函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。
+`print(_:separator:terminator:)`是一个用来输出一个或多个值到适当输出区的全局函数。如果你用 Xcode，`print(_:separator:terminator:)`将会输出内容到“console”面板上。`separator`和`terminator`参数具有默认值，因此你调用这个函数的时候可以忽略它们。默认情况下，该函数通过添加换行符来结束当前行。如果不想换行，可以传递一个空字符串给`terminator`参数--例如，`print(someValue, terminator:"")`。关于参数默认值的更多信息，请参考[默认参数值](./06_Functions.html#default_parameter_values)。
 
 Swift 用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：
 

From e7b468c1acfb866ab7d3af7d3979e8dd9a1f88c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com>
Date: Sun, 6 Sep 2015 06:04:43 +0800
Subject: [PATCH 198/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=B8=80=E4=BA=9B?=
 =?UTF-8?q?=E4=B8=8D=E5=90=8C=E6=AD=A5=E7=9A=84=E5=B0=8F=E7=BB=86=E8=8A=82?=
 =?UTF-8?q?=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/01_The_Basics.md | 64 ++++++++++++++++----------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index bbd0d086..c4f7d6f6 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -214,7 +214,7 @@ Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些
 <a name="integer_bounds"></a>
 ### 整数范围
 
-你可以访问不同整数类型的`min`和`max`属性来获取对应类型的最大值和最小值：
+你可以访问不同整数类型的`min`和`max`属性来获取对应类型的最小值和最大值：
 
 ```swift
 let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型
@@ -230,7 +230,7 @@ let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型
 * 在32位平台上，`Int`和`Int32`长度相同。
 * 在64位平台上，`Int`和`Int64`长度相同。
 
-除非你需要特定长度的整数，一般来说使用`Int`就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，`Int`可以存储的整数范围也可以达到`-2147483648`~`2147483647`，大多数时候这已经足够大了。
+除非你需要特定长度的整数，一般来说使用`Int`就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，`Int`可以存储的整数范围也可以达到`-2,147,483,648`~`2,147,483,647`，大多数时候这已经足够大了。
 
 <a name="UInt"></a>
 ### UInt
@@ -263,7 +263,7 @@ Swift 是一个类型安全（type safe）的语言。类型安全的语言可
 
 由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
 
-当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用_类型推断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。
+当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用_类型推断_（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。
 
 因为有类型推断，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
 
@@ -421,7 +421,7 @@ var maxAmplitudeFound = AudioSample.min
 <a name="booleans"></a>
 ## 布尔值
 
-Swift 有一个基本的布尔（Boolean）类型，叫做`Bool`。布尔值指逻辑上的（logical，因为它们只能是真或者假。Swift 有两个布尔常量，`true`和`false`：
+Swift 有一个基本的布尔（Boolean）类型，叫做`Bool`。布尔值指逻辑上的值，因为它们只能是真或者假。Swift 有两个布尔常量，`true`和`false`：
 
 ```swift
 let orangesAreOrange = true
@@ -542,17 +542,17 @@ print("The status message is \(http200Status.description)")
 > 注意：  
 C 和 Objective-C 中并没有可选类型这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回`nil`，`nil`表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如`NSNotFound`）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选类型可以让你暗示_任意类型_的值缺失，并不需要一个特殊值。
 
-来看一个例子。Swift 的`String`类型有一个叫做`toInt`的方法，作用是将一个`String`值转换成一个`Int`值。然而，并不是所有的字符串都可以转换成一个整数。字符串`"123"`可以被转换成数字`123`，但是字符串`"hello, world"`不行。
+来看一个例子。Swift 的`String`类型有一种构造器，作用是将一个`String`值转换成一个`Int`值。然而，并不是所有的字符串都可以转换成一个整数。字符串`"123"`可以被转换成数字`123`，但是字符串`"hello, world"`不行。
 
-下面的例子使用`toInt`方法来尝试将一个`String`转换成`Int`：
+下面的例子使用这种构造器来尝试将一个`String`转换成`Int`：
 
 ```swift
 let possibleNumber = "123"
-let convertedNumber = possibleNumber.toInt()
+let convertedNumber = Int(possibleNumber)
 // convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
 ```
 
-因为`toInt`方法可能会失败，所以它返回一个_可选类型（optional）`Int`，而不是一个`Int`。一个可选的`Int`被写作`Int?`而不是`Int`。问号暗示包含的值是可选类型，也就是说可能包含`Int`值也可能不包含值。（不能包含其他任何值比如`Bool`值或者`String`值。只能是`Int`或者什么都没有。）
+因为该构造器可能会失败，所以它返回一个_可选类型_（optional）`Int`，而不是一个`Int`。一个可选的`Int`被写作`Int?`而不是`Int`。问号暗示包含的值是可选类型，也就是说可能包含`Int`值也可能不包含值。（不能包含其他任何值比如`Bool`值或者`String`值。只能是`Int`或者什么都没有。）
 
 <a name="nil"></a>
 ### nil
@@ -582,9 +582,9 @@ Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`n
 <a name="if"></a>
 ### if 语句以及强制解析
 
-你可以使用`if`语句和nil比较来判断一个可选值是否包含值。你可以使用“相等”(==)或“不等”(!=)来执行比较。
+你可以使用`if`语句和`nil`比较来判断一个可选值是否包含值。你可以使用“相等”(`==`)或“不等”(`!=`)来执行比较。
 
-如果可选类型有值，它将不等于nil:
+如果可选类型有值，它将不等于`nil`:
 
 ```swift
 if convertedNumber != nil {
@@ -592,7 +592,7 @@ if convertedNumber != nil {
 }
 // 输出 "convertedNumber contains some integer value."
 ```
-当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（`!`）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的_强制解析（forced unwrapping）：
+当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（`!`）来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的_强制解析_（forced unwrapping）：
 
 ```swift
 if convertedNumber != nil {
@@ -632,13 +632,13 @@ if let actualNumber = Int(possibleNumber) {
 
 这段代码可以被理解为：
 
-“如果`possibleNumber.toInt`返回的可选`Int`包含一个值，创建一个叫做`actualNumber`的新常量并将可选包含的值赋给它。”
+“如果`Int(possibleNumber)`返回的可选`Int`包含一个值，创建一个叫做`actualNumber`的新常量并将可选包含的值赋给它。”
 
 如果转换成功，`actualNumber`常量可以在`if`语句的第一个分支中使用。它已经被可选类型_包含的_值初始化过，所以不需要再使用`!`后缀来获取它的值。在这个例子中，`actualNumber`只被用来输出转换结果。
 
 你可以在可选绑定中使用常量和变量。如果你想在`if`语句的第一个分支中操作`actualNumber`的值，你可以改成`if var actualNumber`，这样可选类型包含的值就会被赋给一个变量而非常量。
 
-多个可选绑定可以用逗号区分成一列表达式出现在一个`if`语句中。
+多个可选绑定可以用逗号分隔，作为一列表达式出现在一个`if`语句中。
 
 ```swift
 if let constantName = someOptional, anotherConstantName = someOtherOptional {
@@ -695,15 +695,15 @@ if let definiteString = assumedString {
 
 <a name="error_handling"></a>
 ## 错误处理
-你可以使用错误处理(error handling)来应对程序执行中出错的条件。
+你可以使用错误处理(error handling)来应对程序执行中可能会遇到的错误条件。
 
-相对于可选中运用值得存在与缺失来表达函数的成功与失败，错误处理可以推断失败的原因，并传送至程序的其他部分。
+相对于可选中运用值的存在与缺失来表达函数的成功与失败，错误处理可以推断失败的原因，并传播至程序的其他部分。
 
 当一个函数遇到错误条件，它能报错。调用函数的地方能抛出错误消息并合理处理。
 
 ```swift
-func canThrowAnErrow() throws{
-  //this function may or may not throw an error
+func canThrowAnErrow() throws {
+    // 这个函数有可能抛出错误
 }
 ```
 
@@ -718,30 +718,30 @@ do {
 }
 ```
 
-一个`do`的声明创建了一个新的包含作用域,使得错误能被传播到一个或更多`catch`从句。
+一个`do`语句创建了一个新的包含作用域,使得错误能被传播到一个或多个`catch`从句。
 
-这里有一个错误处理用来应对不同错误条件的例子。
+这里有一个错误处理如何用来应对不同错误条件的例子。
 
 ```swift
 func makeASandwich() throws {
-  // ...
+    // ...
 }
 
 do {
-  try makeASandwich()
-  eatASandwich()
-} catch Error.OutOfCleanDishes{
-  washDishes()
+    try makeASandwich()
+    eatASandwich()
+} catch Error.OutOfCleanDishes {
+    washDishes()
 } catch Error.MissingIngredients(let ingredients) {
-  buyGroceries(ingredients)
+    buyGroceries(ingredients)
 }
 ```
 
-在此例中，`makeASandwich()`（做一个三明治）函数会抛出一个错误消息如果没有干净的盘子或者某个原料缺失。因为`makeASandwich()`抛出错误，调用函数会被包裹在`try`表达式中。将函数包裹在一个`do`声明中,任何被抛出的错误会被传送到提供的`catch`从句中。
+在此例中，`makeASandwich()`（做一个三明治）函数会抛出一个错误消息如果没有干净的盘子或者某个原料缺失。因为`makeASandwich()`抛出错误，函数调用被包裹在`try`表达式中。将函数包裹在一个`do`语句中,任何被抛出的错误会被传播到提供的`catch`从句中。
 
-如果没有错误被抛出, `eatASandwich()`函数会被调用。如果一个符合`Error.OutOfCleanDishes`的错误被抛出,`washDishes`函数会被调用。如果一个符合`Error.MissingIngredients`的错误被抛出，`buyGroceries(_:)`函数会被调用并传递相关被`catch`所捕捉到的`[String]`值。
+如果没有错误被抛出, `eatASandwich()`函数会被调用。如果一个匹配`Error.OutOfCleanDishes`的错误被抛出,`washDishes`函数会被调用。如果一个匹配`Error.MissingIngredients`的错误被抛出，`buyGroceries(_:)`函数会随着被`catch`所捕捉到的关联值`[String]`被调用。
 
-抛出，捕捉，传递错误会在[错误处理](./18_Error_Handling.html)章节详细说明。
+抛出，捕捉，以及传播错误会在[错误处理](./18_Error_Handling.html)章节详细说明。
 
 <a name="assertions"></a>
 ## 断言
@@ -750,11 +750,11 @@ do {
 
 ### 使用断言进行调试
 
-断言会在运行时判断一个逻辑条件是否为`true`。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为`true`，代码运行会继续进行；如果条件判断为`false`，代码运行停止，你的应用被终止。
+断言会在运行时判断一个逻辑条件是否为`true`。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为`true`，代码运行会继续进行；如果条件判断为`false`，代码执行结束，你的应用被终止。
 
 如果你的代码在调试环境下触发了一个断言，比如你在 Xcode 中构建并运行一个应用，你可以清楚地看到不合法的状态发生在哪里并检查断言被触发时你的应用的状态。此外，断言允许你附加一条调试信息。
 
-你可以使用全局`assert`函数来写一个断言。向`assert`函数传入一个结果为`true`或者`false`的表达式以及一条信息，当表达式为`false`的时候这条信息会被显示：
+你可以使用全局`assert(_:_:)`函数来写一个断言。向`assert(_:_:)`函数传入一个结果为`true`或者`false`的表达式以及一条信息，当表达式的结果为`false`的时候这条信息会被显示：
 
 ```swift
 let age = -3
@@ -762,9 +762,9 @@ assert(age >= 0, "A person's age cannot be less than zero")
 // 因为 age < 0，所以断言会触发
 ```
 
-在这个例子中，只有`age >= 0`为`true`的时候，即`age`的值非负的时候，代码运行才会继续。如果`age`的值是负数，就像代码中那样，`age >= 0`为`false`，断言被触发，结束应用。
+在这个例子中，只有`age >= 0`为`true`的时候，即`age`的值非负的时候，代码才会继续执行。如果`age`的值是负数，就像代码中那样，`age >= 0`为`false`，断言被触发，终止应用。
 
-断言信息如果不需要，可以被省略，就像这样：
+如果不需要断言信息，可以省略，就像这样：
 
 ```swift
 assert(age >= 0)

From 360bc654fc61dc54f8a6612cdc6190c6aa988898 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com>
Date: Sun, 6 Sep 2015 07:25:58 +0800
Subject: [PATCH 199/228] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BB=A3=E7=A0=81?=
 =?UTF-8?q?=E9=AB=98=E4=BA=AE=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/02_Basic_Operators.md | 343 ++++++++++++++------------
 1 file changed, 188 insertions(+), 155 deletions(-)

diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 9e0f872e..a850368b 100755
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -44,22 +44,27 @@ Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减
 
 赋值运算（`a = b`），表示用`b`的值来初始化或更新`a`的值：
 
-	let b = 10
-	var a = 5
-	a = b
-	// a 现在等于 10
+```swift
+let b = 10
+var a = 5
+a = b
+// a 现在等于 10
+```
 
 如果赋值的右边是一个多元组，它的元素可以马上被分解成多个常量或变量：
 
-	let (x, y) = (1, 2)
-	// 现在 x 等于 1, y 等于 2
+```swift
+let (x, y) = (1, 2)
+// 现在 x 等于 1, y 等于 2
+```
 
 与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以以下代码是错误的：
 
-	if x = y {
-	    // 此句错误, 因为 x = y 并不返回任何值
-	}
-
+```swift
+if x = y {
+	// 此句错误, 因为 x = y 并不返回任何值
+}
+```
 
 这个特性使你无法把（`==`）错写成（`=`），由于`if x = y`是错误代码，Swift帮你避免此类错误的的发生。
 
@@ -73,18 +78,20 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 - 乘法（`*`）
 - 除法（`/`）
 
-		1 + 2       // 等于 3
-		5 - 3       // 等于 2
-		2 * 3       // 等于 6
-		10.0 / 2.5  // 等于 4.0
-
-
+```swift
+1 + 2       // 等于 3
+5 - 3       // 等于 2
+2 * 3       // 等于 6
+10.0 / 2.5  // 等于 4.0
+```
 
 与 C 语言和 Objective-C 不同的是，Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算（如`a &+ b`）。详情参见[溢出运算符](./24_Advanced_Operators.html#overflow_operators)。
 
 加法运算符也可用于`String`的拼接：
 
-	"hello, " + "world"  // 等于 "hello, world"
+```swift
+"hello, " + "world"  // 等于 "hello, world"
+```
 
 ### 求余运算符
 
@@ -101,8 +108,9 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 
 在 Swift 中可以表达为：
 
-	9 % 4    // 等于 1
-
+```swift
+9 % 4    // 等于 1
+```
 
 为了得到`a % b`的结果，`%`计算了以下等式，并输出`余数`作为结果：
 
@@ -114,10 +122,11 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 
 	9 = (4 × 2) + 1
 
+同样的方法，我们来计算 `-9 % 4`：
 
-同样的方法，我来们计算 `-9 % 4`：
-
-	-9 % 4   // 等于 -1
+```swift
+-9 % 4   // 等于 -1
+```
 
 把`-9`和`4`代入等式，`-2`是取到的最大整数：
 
@@ -131,7 +140,9 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 
 不同于 C 语言和 Objective-C，Swift 中是可以对浮点数进行求余的。
 
-	8 % 2.5 // 等于 0.5
+```swift
+8 % 2.5   // 等于 0.5
+```
 
 这个例子中，`8`除于`2.5`等于`3`余`0.5`，所以结果是一个`Double`值`0.5`。
 
@@ -140,11 +151,11 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 ### 自增和自减运算
 
 和 C 语言一样，Swift 也提供了对变量本身加1或减1的自增（`++`）和自减（`--`）的缩略算符。其操作对象可以是整形和浮点型。
-‌
-
-	var i = 0
-	++i      // 现在 i = 1
 
+```swift
+var i = 0
+++i      // 现在 i = 1
+```
 
 每调用一次`++i`，`i`的值就会加1。实际上，`++i`是`i = i + 1`的简写，而`--i`是`i = i - 1`的简写。
 
@@ -157,9 +168,11 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 
 例如：
 
-	var a = 0
-	let b = ++a // a 和 b 现在都是 1
-	let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1
+```swift
+var a = 0
+let b = ++a // a 和 b 现在都是 1
+let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1
+```
 
 上述例子，`let b = ++a`先把`a`加1了再返回`a`的值。所以`a`和`b`都是新值`1`。
 
@@ -172,19 +185,22 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 
 数值的正负号可以使用前缀`-`（即一元负号）来切换：
 
-	let three = 3
-	let minusThree = -three       // minusThree 等于 -3
-	let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"
-
+```swift
+let three = 3
+let minusThree = -three       // minusThree 等于 -3
+let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"
+```
 
 一元负号（`-`）写在操作数之前，中间没有空格。
 
 ### 一元正号运算符
 
-一元正号（`+`）不做任何改变地返回操作数的值。
+一元正号（`+`）不做任何改变地返回操作数的值：
 
-	let minusSix = -6
-	let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6
+```swift
+let minusSix = -6
+let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6
+```
 
 虽然一元`+`什么都不会改变，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数，如此你的代码会具有对称美。
 
@@ -194,9 +210,10 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 
 如同 C 语言，Swift 也提供把其他运算符和赋值运算（`=`）组合的复合赋值运算符，组合加运算（`+=`）是其中一个例子：
 
-	var a = 1
-	a += 2 // a 现在是 3
-
+```swift
+var a = 1
+a += 2 // a 现在是 3
+```
 
 表达式`a += 2`是`a = a + 2`的简写，一个组合加运算就是把加法运算和赋值运算组合成进一个运算符里，同时完成两个运算任务。
 
@@ -208,7 +225,7 @@ Swift 中所有数值类型都支持了基本的四则算术运算：
 <a name="comparison_operators"></a>
 ## 比较运算符
 
-所有标准 C 语言中的比较运算都可以在 Swift 中使用。
+所有标准 C 语言中的比较运算都可以在 Swift 中使用：
 
 - 等于（`a == b`）
 - 不等于（`a != b`）
@@ -222,26 +239,26 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 
 每个比较运算都返回了一个标识表达式是否成立的布尔值：
 
-
-	1 == 1   // true, 因为 1 等于 1
-	2 != 1   // true, 因为 2 不等于 1
-	2 > 1    // true, 因为 2 大于 1
-	1 < 2    // true, 因为 1 小于2
-	1 >= 1   // true, 因为 1 大于等于 1
-	2 <= 1   // false, 因为 2 并不小于等于 1
-
+```swift
+1 == 1   // true, 因为 1 等于 1
+2 != 1   // true, 因为 2 不等于 1
+2 > 1    // true, 因为 2 大于 1
+1 < 2    // true, 因为 1 小于2
+1 >= 1   // true, 因为 1 大于等于 1
+2 <= 1   // false, 因为 2 并不小于等于 1
+```
 
 比较运算多用于条件语句，如`if`条件：
 
-
-	let name = "world"
-	if name == "world" {
-		print("hello, world")
-	} else {
-	    print("I'm sorry \(name), but I don't recognize you")
-	}
-	// 输出 "hello, world", 因为 `name` 就是等于 "world"
-
+```swift
+let name = "world"
+if name == "world" {
+	print("hello, world")
+} else {
+	print("I'm sorry \(name), but I don't recognize you")
+}
+// 输出 "hello, world", 因为 `name` 就是等于 "world"
+```
 
 关于`if`语句，请看[控制流](./05_Control_Flow.html)。
 
@@ -252,32 +269,36 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 
 三目运算符是以下代码的缩写形式：
 
-	if question {
-		answer1
-	} else {
-		answer2
-	}
+```swift
+if question {
+	answer1
+} else {
+	answer2
+}
+```
 
-这里有个计算表格行高的例子。如果有表头，那行高应比内容高度要高出50像素; 如果没有表头，只需高出20像素。
+这里有个计算表格行高的例子。如果有表头，那行高应比内容高度要高出50点；如果没有表头，只需高出20点：
 
-	let contentHeight = 40
-	let hasHeader = true
-	let rowHeight = contentHeight + (hasHeader ? 50 : 20)
-	// rowHeight 现在是 90
+```swift
+let contentHeight = 40
+let hasHeader = true
+let rowHeight = contentHeight + (hasHeader ? 50 : 20)
+// rowHeight 现在是 90
+```
 
+上面的写法比下面的代码更简洁：
 
-这样写会比下面的代码简洁：
-
-	let contentHeight = 40
-	let hasHeader = true
-	var rowHeight = contentHeight
-	if hasHeader {
-	    rowHeight = rowHeight + 50
-	} else {
-	    rowHeight = rowHeight + 20
-	}
-	// rowHeight 现在是 90
-
+```swift
+let contentHeight = 40
+let hasHeader = true
+var rowHeight = contentHeight
+if hasHeader {
+	rowHeight = rowHeight + 50
+} else {
+	rowHeight = rowHeight + 20
+}
+// rowHeight 现在是 90
+```
 
 第一段代码例子使用了三目运算，所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多，无需将`rowHeight`定义成变量，因为它的值无需在`if`语句中改变。
 
@@ -293,7 +314,9 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 
 空合并运算符是对以下代码的简短表达方法
 
-	a != nil ? a! : b
+```swift
+a != nil ? a! : b
+```
 
 上述代码使用了三目运算符。当可选类型`a`的值不为空时，进行强制解封(`a!`)访问`a`中值，反之当`a`中值为空时，返回默认值b。无疑空合运算符(`??`)提供了一种更为优雅的方式去封装条件判断和解封两种行为，显得简洁以及更具可读性。
 
@@ -302,21 +325,24 @@ Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对
 
 下文例子采用空合并运算符，实现了在默认颜色名和可选自定义颜色名之间抉择：
 
+```swift
+let defaultColorName = "red"
+var userDefinedColorName: String?   //默认值为 nil
 
-	let defaultColorName = "red"
-	var userDefinedColorName:String?   //默认值为nil
-	var colorNameToUse = userDefinedColorName ?? defaultColorName
-	//userDefinedColorName的值为空 ，所以colorNameToUse的值为`red`
-
+var colorNameToUse = userDefinedColorName ?? defaultColorName
+// userDefinedColorName 的值为空，所以 colorNameToUse 的值为 "red"
+```
 
 `userDefinedColorName`变量被定义为一个可选`String`类型，默认值为`nil`。由于`userDefinedColorName`是一个可选类型，我们可以使用空合运算符去判断其值。在上一个例子中，通过空合运算符为一个名为`colorNameToUse`的变量赋予一个字符串类型初始值。
-由于`userDefinedColorName`值为空，因此表达式` userDefinedColorName ?? defaultColorName `返回`defaultColorName`的值，即`red`。
+由于`userDefinedColorName`值为空，因此表达式`userDefinedColorName ?? defaultColorName`返回`defaultColorName`的值，即`red`。
 
-另一种情况，分配一个非空值(`non-nil`)给 `userDefinedColorName`，再次执行空合运算，运算结果为封包在`userDefaultColorName`中的值，而非默认值。
+另一种情况，分配一个非空值(`non-nil`)给`userDefinedColorName`，再次执行空合运算，运算结果为封包在`userDefaultColorName`中的值，而非默认值。
 
-	userDefinedColorName = "green"
-	colorNameToUse = userDefinedColorName ?? defaultColorName
-	//userDefinedColorName非空，因此colorNameToUsede的值为绿色
+```swift
+userDefinedColorName = "green"
+colorNameToUse = userDefinedColorName ?? defaultColorName
+// userDefinedColorName 非空，因此 colorNameToUse 的值为 "green"
+```
 
 <a name="range_operators"></a>
 ## 区间运算符
@@ -328,15 +354,16 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 ‌
 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在`for-in`循环中：
 
-	for index in 1...5 {
-	    print("\(index) * 5 = \(index * 5)")
-	}
-	// 1 * 5 = 5
-	// 2 * 5 = 10
-	// 3 * 5 = 15
-	// 4 * 5 = 20
-	// 5 * 5 = 25
-
+```swift
+for index in 1...5 {
+	print("\(index) * 5 = \(index * 5)")
+}
+// 1 * 5 = 5
+// 2 * 5 = 10
+// 3 * 5 = 15
+// 4 * 5 = 20
+// 5 * 5 = 25
+```
 
 关于`for-in`，请看[控制流](./05_Control_Flow.html)。
 
@@ -345,19 +372,19 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 半开区间（`a..<b`）定义一个从`a`到`b`但不包括`b`的区间。
 之所以称为半开区间，是因为该区间包含第一个值而不包括最后的值。
 
-半开区间的实用性在于当你使用一个0始的列表(如数组)时，非常方便地从0数到列表的长度。
-
-
-	let names = ["Anna", "Alex", "Brian", "Jack"]
-	let count = names.count
-	for i in 0..<count {
-	    print("第 \(i + 1) 个人叫 \(names[i])")
-	}
-	// 第 1 个人叫 Anna
-	// 第 2 个人叫 Alex
-	// 第 3 个人叫 Brian
-	// 第 4 个人叫 Jack
+半开区间的实用性在于当你使用一个从0开始的列表(如数组)时，非常方便地从0数到列表的长度。
 
+```swift
+let names = ["Anna", "Alex", "Brian", "Jack"]
+let count = names.count
+for i in 0..<count {
+	print("第 \(i + 1) 个人叫 \(names[i])")
+}
+// 第 1 个人叫 Anna
+// 第 2 个人叫 Alex
+// 第 3 个人叫 Brian
+// 第 4 个人叫 Jack
+```
 
 数组有4个元素，但`0..<count`只数到3(最后一个元素的下标)，因为它是半开区间。关于数组，请查阅[数组](./04_Collection_Types.html#arrays)。
 
@@ -376,14 +403,15 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 
 它是一个前置运算符，需紧跟在操作数之前，且不加空格。读作`非 a`，例子如下：
 
-	let allowedEntry = false
-	if !allowedEntry {
-	    print("ACCESS DENIED")
-	}
-	// 输出 "ACCESS DENIED"
+```swift
+let allowedEntry = false
+if !allowedEntry {
+	print("ACCESS DENIED")
+}
+// 输出 "ACCESS DENIED"
+```
 
-
-`if !allowedEntry`语句可以读作 "如果 非 alowed entry。"，接下一行代码只有在如果 "非 allow entry" 为`true`，即`allowEntry`为`false`时被执行。
+`if !allowedEntry`语句可以读作“如果非 allowedEntry。”，接下一行代码只有在“非 allowedEntry”为`true`，即`allowEntry`为`false`时被执行。
 
 在示例代码中，小心地选择布尔常量或变量有助于代码的可读性，并且避免使用双重逻辑非运算，或混乱的逻辑语句。
 
@@ -391,51 +419,56 @@ Swift 提供了两个方便表达一个区间的值的运算符。
 
 逻辑与（`a && b`）表达了只有`a`和`b`的值都为`true`时，整个表达式的值才会是`true`。
 
-只要任意一个值为`false`，整个表达式的值就为`false`。事实上，如果第一个值为`false`，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算（short-circuit evaluation）"。
+只要任意一个值为`false`，整个表达式的值就为`false`。事实上，如果第一个值为`false`，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做“短路计算（short-circuit evaluation）”。
 
 以下例子，只有两个`Bool`值都为`true`的时候才允许进入：
 
-	let enteredDoorCode = true
-	let passedRetinaScan = false
-	if enteredDoorCode && passedRetinaScan {
-	    print("Welcome!")
-	} else {
-	    print("ACCESS DENIED")
-	}
-	// 输出 "ACCESS DENIED"
-
+```swift
+let enteredDoorCode = true
+let passedRetinaScan = false
+if enteredDoorCode && passedRetinaScan {
+	print("Welcome!")
+} else {
+	print("ACCESS DENIED")
+}
+// 输出 "ACCESS DENIED"
+```
 
 ### 逻辑或
 
 逻辑或（`a || b`）是一个由两个连续的`|`组成的中置运算符。它表示了两个逻辑表达式的其中一个为`true`，整个表达式就为`true`。
 
-同逻辑与运算类似，逻辑或也是"短路计算"的，当左端的表达式为`true`时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。
+同逻辑与运算类似，逻辑或也是“短路计算”的，当左端的表达式为`true`时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。
 
 以下示例代码中，第一个布尔值（`hasDoorKey`）为`false`，但第二个值（`knowsOverridePassword`）为`true`，所以整个表达是`true`，于是允许进入：
 
-	let hasDoorKey = false
-	let knowsOverridePassword = true
-	if hasDoorKey || knowsOverridePassword {
-	    print("Welcome!")
-	} else {
-	    print("ACCESS DENIED")
-	}
-	// 输出 "Welcome!"
+```swift
+let hasDoorKey = false
+let knowsOverridePassword = true
+if hasDoorKey || knowsOverridePassword {
+	print("Welcome!")
+} else {
+	print("ACCESS DENIED")
+}
+// 输出 "Welcome!"
+```
 
 ### 逻辑运算符组合计算
 
 我们可以组合多个逻辑运算来表达一个复合逻辑：
 
-	if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
-	    print("Welcome!")
-	} else {
-	    print("ACCESS DENIED")
-	}
-	// 输出 "Welcome!"
+```swift
+if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
+	print("Welcome!")
+} else {
+	print("ACCESS DENIED")
+}
+// 输出 "Welcome!"
+```
 
 这个例子使用了含多个`&&`和`||`的复合逻辑。但无论怎样，`&&`和`||`始终只能操作两个值。所以这实际是三个简单逻辑连续操作的结果。我们来解读一下：
 
-如果我们输入了正确的密码并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。
+如果我们输入了正确的密码并通过了视网膜扫描，或者我们有一把有效的钥匙，又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。
 
 前两种情况，我们都不满足，所以前两个简单逻辑的结果是`false`，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是`true`。
 
@@ -444,15 +477,15 @@ Swift 逻辑操作符`&&`和`||`是左结合的，这意味着拥有多元逻辑
 
 ### 使用括号来明确优先级
 
-为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确：
+为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使它看起来逻辑更明确：
 
+```swift
+if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
+	print("Welcome!")
+} else {
+	print("ACCESS DENIED")
+}
+// 输出 "Welcome!"
+```
 
-	if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
-	    print("Welcome!")
-	} else {
-	    print("ACCESS DENIED")
-	}
-	// 输出 "Welcome!"
-
-
-这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰地地方加个括号吧！
+这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰的地方加个括号吧！

From 17a05e6d856bab3d852c32799eee75392656196e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com>
Date: Sun, 6 Sep 2015 19:14:21 +0800
Subject: [PATCH 200/228] =?UTF-8?q?=E5=AE=8C=E5=96=84=E4=B8=80=E4=BA=9B?=
 =?UTF-8?q?=E6=8E=92=E7=89=88=E9=81=97=E6=BC=8F=EF=BC=8C=E6=9B=B4=E6=96=B0?=
 =?UTF-8?q?=E4=BA=86=E9=83=A8=E5=88=86=E5=A4=B1=E6=95=88=E4=BF=A1=E6=81=AF?=
 =?UTF-8?q?=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/03_Strings_and_Characters.md | 188 ++++++++++---------
 1 file changed, 97 insertions(+), 91 deletions(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 6a46bb8b..72fe4da5 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -42,7 +42,7 @@ Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 
 <a name="string_literals"></a>
 ## 字符串字面量（String Literals）
 
-您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
+您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 (`""`) 包裹着的具有固定顺序的文本字符集。
 字符串字面量可以用于为常量和变量提供初始值：
 
 ```swift
@@ -50,8 +50,9 @@ let someString = "Some string literal value"
 ```
 
 注意`someString`常量通过字符串字面量进行初始化，Swift 会推断该常量为`String`类型。
-> 注意：
-> 更多关于在字面量的特殊字符，请查看 [Special Characters in String Literals](#special_characters_in_string_literals) 。
+
+> 注意：  
+更多关于在字符串字面量中使用特殊字符的信息，请查看 [字符串字面量的特殊字符](#special_characters_in_string_literals) 。
 
 
 <a name="initializing_an_empty_string"></a>
@@ -83,13 +84,14 @@ if emptyString.isEmpty {
 var variableString = "Horse"
 variableString += " and carriage"
 // variableString 现在为 "Horse and carriage"
+
 let constantString = "Highlander"
 constantString += " and another Highlander"
-// 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。
+// 这会报告一个编译错误 (compile-time error) - 常量字符串不可以被修改。
 ```
 
-> 注意：
-> 在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改。
+> 注意：  
+在 Objective-C 和 Cocoa 中，您需要通过选择两个不同的类(`NSString`和`NSMutableString`)来指定字符串是否可以被修改。
 
 <a name="strings_are_value_types"></a>
 ## 字符串是值类型（Strings Are Value Types）
@@ -100,11 +102,11 @@ Swift 的`String`类型是值类型。
 值类型在 [结构体和枚举是值类型](./09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了详细描述。
 
 > 注意：  
-> 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
+与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
 
 Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。
 很明显无论该值来自于哪里，都是您独自拥有的。
-您可以放心您传递的字符串本身不会被更改。
+您可以确信传递的字符串不会被修改，除非你自己去修改它。
 
 在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。
 
@@ -124,7 +126,7 @@ for character in "Dog!🐶".characters {
 // 🐶
 ```
 
-for-in 循环在 [For Loops](./05_Control_Flow.html#for_loops) 中进行了详细描述。
+`for-in`循环在 [For Loops](./05_Control_Flow.html#for_loops) 中进行了详细描述。
 
 另外，通过标明一个`Character`类型并用字符字面量进行赋值，可以建立一个独立的字符常量或变量：
 
@@ -148,7 +150,7 @@ print(catString)
 ```swift
 let string1 = "hello"
 let string2 = " there"
-var welcome = string1 +　string2
+var welcome = string1 + string2
 // welcome 现在等于 "hello there"
 ```
 
@@ -157,10 +159,10 @@ var welcome = string1 +　string2
 ```swift
 var instruction = "look over"
 instruction += string2
-// instruction 现在等于　"look over there"
+// instruction 现在等于 "look over there"
 ```
 
-您可以用`append`方法将一个字符附加到一个字符串变量的尾部：
+您可以用`append()`方法将一个字符附加到一个字符串变量的尾部：
 
 ```swift
 let exclamationMark: Character = "!"
@@ -169,7 +171,7 @@ welcome.append(exclamationMark)
 ```
 
 > 注意：  
-> 您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
+您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
 
 
 <a name="string_interpolation"></a>
@@ -181,14 +183,14 @@ welcome.append(exclamationMark)
 ```swift
 let multiplier = 3
 let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
-// message 是 "3 times 2.5 is 7.5"
+// message is "3 times 2.5 is 7.5"
 ```
 
 在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串常量量中。
 当创建字符串执行插值计算时此占位符会被替换为`multiplier`实际的值。
 
 `multiplier`的值也作为字符串中后面表达式的一部分。
-该表达式计算`Double(multiplier) * 2.5`的值并将结果 (7.5) 插入到字符串中。
+该表达式计算`Double(multiplier) * 2.5`的值并将结果 (`7.5`) 插入到字符串中。
 在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
 
 > 注意：  
@@ -200,17 +202,18 @@ let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
 
 Unicode 是一个国际标准，用于文本的编码和表示。
 它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
-Swift 的字符串和字符类型是完全兼容 Unicode 标准的。  
+Swift 的`String`和`Character`类型是完全兼容 Unicode 标准的。  
 
 <a name="unicode_scalars"></a>
 ### Unicode 标量（Unicode Scalars）
 
 Swift 的`String`类型是基于 *Unicode 标量* 建立的。
-Unicode 标量是对应字符的唯一21位数字或者修饰符，例如`U+0061`表示小写的拉丁字母(`LATIN SMALL LETTER A`)("`a`")，`U+1F425`表示小鸡表情(`FRONT-FACING BABY CHICK`) ("`🐥`")
+Unicode 标量是对应字符或者修饰符的唯一的21位数字，例如`U+0061`表示小写的拉丁字母(`LATIN SMALL LETTER A`)("`a`")，`U+1F425`表示小鸡表情(`FRONT-FACING BABY CHICK`) ("`🐥`")。
+
 > 注意：
 > Unicode *码位(code poing)* 的范围是`U+0000`到`U+D7FF`或者`U+E000`到`U+10FFFF`。Unicode 标量不包括 Unicode *代理项(surrogate pair)* 码位，其码位范围是`U+D800`到`U+DFFF`。
 
-注意不是所有的21位 Unicode 标量都代表一个字符，因为有一些标量是保留给未来分配的。已经代表一个典型字符的标量都有自己的名字，例如上面例子中的`LATIN SMALL LETTER A`和`FRONT-FACING BABY CHICK`。
+注意不是所有的21位 Unicode 标量都代表一个字符，因为有一些标量是留作未来分配的。已经代表一个典型字符的标量都有自己的名字，例如上面例子中的`LATIN SMALL LETTER A`和`FRONT-FACING BABY CHICK`。
 
 <a name="special_characters_in_string_literals"></a>
 ### 字符串字面量的特殊字符 (Special Characters in String Literals)
@@ -221,7 +224,7 @@ Unicode 标量是对应字符的唯一21位数字或者修饰符，例如`U+0061
 * Unicode 标量，写成`\u{n}`(u为小写)，其中`n`为任意一到八位十六进制数且可用的 Unicode 位码。
 
 下面的代码为各种特殊字符的使用示例。
-`wiseWords`常量包含了两个双引号；
+`wiseWords`常量包含了两个双引号。
 `dollarSign`、`blackHeart`和`sparklingHeart`常量演示了三种不同格式的 Unicode 标量：
 
 ```swift
@@ -234,11 +237,13 @@ let sparklingHeart = "\u{1F496}"      // 💖, Unicode 标量 U+1F496
 
 <a name="extended_grapheme_clusters"></a>  
 ### 可扩展的字形群集(Extended Grapheme Clusters)
+
 每一个 Swift 的`Character`类型代表一个可扩展的字形群。
-一个可扩展的字形群是一个或者更多可生成人类可读的字符 Unicode 标量的有序排列。
-举个例子，字母 é 可以用单一的 Unicode 标量 é (`LATIN SMALL LETTER E WITH ACUTE`, 或者`U+00E9`)来表示。然而一个标准的字母 e (`LATIN SMALL LETTER E`或者`U+0065`) 加上一个急促重音(`COMBINING ACTUE ACCENT`)的标量(`U+0301`)，这样一对标量就表示了同样的字母 é。
-这个急促重音的标量形象的将 e 转换成了 é。
-在这两种情况中，字母 é 代表了一个单一的 Swift 的字符串，同时代表了一个可扩展的字形群。
+一个可扩展的字形群是一个或多个可生成人类可读的字符 Unicode 标量的有序排列。
+举个例子，字母`é`可以用单一的 Unicode 标量`é`(`LATIN SMALL LETTER E WITH ACUTE`, 或者`U+00E9`)来表示。然而一个标准的字母`e`(`LATIN SMALL LETTER E`或者`U+0065`) 加上一个急促重音(`COMBINING ACTUE ACCENT`)的标量(`U+0301`)，这样一对标量就表示了同样的字母`é`。
+这个急促重音的标量形象的将`e`转换成了`é`。
+
+在这两种情况中，字母`é`代表了一个单一的 Swift 的`Character`值，同时代表了一个可扩展的字形群。
 在第一种情况，这个字形群包含一个单一标量；而在第二种情况，它是包含两个标量的字形群：
 
 ```swift
@@ -247,9 +252,9 @@ let combinedEAcute: Character = "\u{65}\u{301}"          // e 后面加上  ́
 // eAcute 是 é, combinedEAcute 是 é
 ```
 
-可扩展的字符群集是一个灵活的方法，用许多复杂的脚本字符表示单一字符。
+可扩展的字符群集是一个灵活的方法，用许多复杂的脚本字符表示单一的`Character`值。
 例如，来自朝鲜语字母表的韩语音节能表示为组合或分解的有序排列。
-在 Swift 都会表示为同一个单一的字符：
+在 Swift 都会表示为同一个单一的`Character`值：
 
 
 ```swift
@@ -258,14 +263,14 @@ let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
 // precomposed 是 한, decomposed 是 한
 ```
 
-可拓展的字符群集可以使包围记号(例如`COMBINING ENCLOSING CIRCLE`或者`U+20DD`)的标量包围其他 Unicode 标量，作为一个单一的字符：
+可拓展的字符群集可以使包围记号(例如`COMBINING ENCLOSING CIRCLE`或者`U+20DD`)的标量包围其他 Unicode 标量，作为一个单一的`Character`值：
 
 ```swift
 let enclosedEAcute: Character = "\u{E9}\u{20DD}"
 // enclosedEAcute 是 é⃝
 ```  
 
-局部的指示符号的 Unicode 标量可以组合成一个单一的字符，例如 `REGIONAL INDICATOR SYMBOL LETTER U`(`U+1F1FA`)和`REGIONAL INDICATOR SYMBOL LETTER S`(`U+1F1F8`)：
+局部的指示符号的 Unicode 标量可以组合成一个单一的`Character`值，例如`REGIONAL INDICATOR SYMBOL LETTER U`(`U+1F1FA`)和`REGIONAL INDICATOR SYMBOL LETTER S`(`U+1F1F8`)：
 
 
 ```swift
@@ -276,7 +281,7 @@ let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
 <a name="counting_characters"></a>
 ## 计算字符数量 (Counting Characters)
 
-如果想要获得一个字符串中字符的数量，可以使用字符串的characters属性的count属性：
+如果想要获得一个字符串中`Character`值的数量，可以使用字符串的`characters`属性的`count`属性：
 
 ```swift
 let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
@@ -284,9 +289,9 @@ print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
 // 打印输出 "unusualMenagerie has 40 characters"
 ```
 
-注意在 Swift 中，使用可拓展的字符群集作为字符来连接或改变字符串时，并不一定会更改字符串的字符数量。
+注意在 Swift 中，使用可拓展的字符群集作为`Character`值来连接或改变字符串时，并不一定会更改字符串的字符数量。
 
-例如，如果你用四个字符的单词 cafe 初始化一个新的字符串，然后添加一个 `COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是4，因为第四个字符是 é ，而不是 e ：
+例如，如果你用四个字符的单词`cafe`初始化一个新的字符串，然后添加一个`COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是`4`，因为第四个字符是`e`，而不是`e`：
 
 ```swift
 var word = "cafe"
@@ -300,67 +305,61 @@ print("the number of characters in \(word) is \(word.characters.count)")
 ```
 
 > 注意：  
-> 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`count(_:)`函数必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
+> 可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候，就不能计算出字符串的字符数量。如果您正在处理一个长字符串，需要注意`characters`属性必须遍历全部的 Unicode 标量，来确定字符串的字符数量。
 > 
-> 另外需要注意的是通过`count(_:)`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。作为佐证，当一个`NSString`的`length`属性被一个Swift的`String`值访问时，实际上是调用了`utf16Count`。
+> 另外需要注意的是通过`characters`属性返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是利用 UTF-16 表示的十六位代码单元数字，而不是 Unicode 可扩展的字符群集。作为佐证，当一个`NSString`的`length`属性被一个Swift的`String`值访问时，实际上是调用了`utf16Count`。
 
 
 <a name="accessing_and_modifying_a_string"></a>
 ## 访问和修改字符串 (Accessing and Modifying a String)
-你可以通字符串的属性和方法来访问和读取一个它，当然也可以用下标语法完成。
+
+你可以通字符串的属性和方法来访问和读取它，当然也可以用下标语法完成。
 
 <a name="string_indices"></a>
 ### 字符串索引 (String Indices)
-每一个字符串都有一个关联的索引(*index*)类型，`String.index`，它对应着字符串中的每一个字符的位置。
 
-前面提到，不同的字符可能会占用不同的内存空间数量，所以要知道字符的确定位置，就必须从字符串开头遍历每一个 Unicode 标量到字符串结尾。因此，Swift 的字符串不能用整数(integer)做索引。
+每一个`String`值都有一个关联的索引(*index*)类型，`String.Index`，它对应着字符串中的每一个`Character`的位置。
 
-使用`startIndex`属性可以获取字符串的第一个字符。使用`endIndex`属性可以获取最后的位置（译者注：其实endIndex在值上与字符串的长度相等）。如果字符串是空值，`startIndex`和`endIndex`是相等的。
+前面提到，不同的字符可能会占用不同数量的内存空间，所以要知道`Character`的确定位置，就必须从`String`开头遍历每一个 Unicode 标量直到结尾。因此，Swift 的字符串不能用整数(integer)做索引。
+
+使用`startIndex`属性可以获取一个`String`的第一个`Character`的索引。使用`endIndex`属性可以获取最后一个`Character`的后一个位置的索引。因此，`endIndex`属性不能作为一个字符串的有效下标。如果`String`是空串，`startIndex`和`endIndex`是相等的。
+
+通过调用`String.Index`的`predecessor()`方法，可以立即得到前面一个索引，调用`successor()`方法可以立即得到后面一个索引。任何一个`String`的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用`advancedBy(_:)`方法来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误。
+
+你可以使用下标语法来访问`String`特定索引的`Character`。
 
 ```swift
-let greeting = "Guten Tag"
-println(greeting.startIndex)
-// 0
-println(greeting.endIndex)
-// 9
-```
-
-你可以通过下表来获得`String`对应位置的`Character`：
-
-```swift
-greeting[greeting.startIndex]
-// G
-```
-
-通过调用`String.Index`的`predecessor()`方法，可以立即得到前面一个索引，调用`successor()`方法可以立即得到后面一个索引。任何一个字符串的索引都可以通过锁链作用的这些方法来获取另一个索引，也可以调用`advance(start:n:)`函数来获取。但如果尝试获取出界的字符串索引，就会抛出一个运行时错误。
-你可以使用下标语法来访问字符在字符串的确切索引。尝试获取出界的字符串索引，仍然抛出一个运行时错误。
-
-```swift
-let greeting = "Guten Tag"
+let greeting = "Guten Tag!"
 greeting[greeting.startIndex]
 // G
 greeting[greeting.endIndex.predecessor()]
-// g
+// !
 greeting[greeting.startIndex.successor()]
 // u
-let index = advance(greeting.startIndex, 7)
+let index = greeting.startIndex.advancedBy(7)
 greeting[index]
 // a
-greeting[greeting.endIndex] // 错误
-greeting.endIndex.successor() // 错误
 ```
 
-使用全局函数`indices`会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问分立的字符。  
+试图获取越界索引对应的`Character`，将引发一个运行时错误。
+
+```swift
+greeting[greeting.endIndex] // error
+greeting.endIndex.successor() // error
+```
+
+使用`characters`属性的`indices`属性会创建一个包含全部索引的范围(`Range`)，用来在一个字符串中访问单个字符。  
 
 ```swift
 for index in greeting.characters.indices {
-   print("\(greeting[index]) ", appendNewline: false)
+   print("\(greeting[index]) ", terminator: "")
 }
-// prints "G u t e n   T a g !"
+// 打印输出 "G u t e n   T a g !"
 ```
 
 <a name="inserting_and_removing"></a>
 ### 插入和删除 (Inserting and Removing)
+
 调用`insert(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符。
 
 ```swift
@@ -369,10 +368,10 @@ welcome.insert("!", atIndex: welcome.endIndex)
 // welcome now 现在等于 "hello!"
 ```
 
-调用`splice(_:atIndex:)`方法可以在一个字符串的指定索引插入一个字符串。
+调用`insertContentsOf(_:at:)`方法可以在一个字符串的指定索引插入一个字符串。
 
 ```swift
-welcome.splice(" there".characters, atIndex: welcome.endIndex.predecessor())
+welcome.insertContentsOf(" there".characters, at: welcome.endIndex.predecessor())
 // welcome 现在等于 "hello there!"
 ```
 
@@ -381,13 +380,12 @@ welcome.splice(" there".characters, atIndex: welcome.endIndex.predecessor())
 ```swift
 welcome.removeAtIndex(welcome.endIndex.predecessor())
 // welcome 现在等于 "hello there"
-// 翻译的人解释：最后还有一个换行符，所以这里删除的是 !
 ```
 
 调用`removeRange(_:)`方法可以在一个字符串的指定索引删除一个子字符串。
 
 ```swift
-let range = advance(welcome.endIndex, -6)..<welcome.endIndex
+let range = welcome.endIndex.advancedBy(-6)..<welcome.endIndex
 welcome.removeRange(range)
 // welcome 现在等于 "hello"
 ```
@@ -400,6 +398,7 @@ Swift 提供了三种方式来比较文本值：字符串字符相等、前缀
 
 <a name="string_and_character_equality"></a>
 ### 字符串/字符相等 (String and Character Equality)
+
 字符串/字符可以用等于操作符(`==`)和不等于操作符(`!=`)，详细描述在[比较运算符](./02_Basic_Operators.html#comparison_operators)：
 
 ```swift
@@ -413,13 +412,15 @@ if quotation == sameQuotation {
 
 如果两个字符串（或者两个字符）的可扩展的字形群集是标准相等的，那就认为它们是相等的。在这个情况下，即使可扩展的字形群集是有不同的 Unicode 标量构成的，只要它们有同样的语言意义和外观，就认为它们标准相等。
 
-例如，`LATIN SMALL LETTER E WITH ACUTE`(`U+00E9`)就是标准相等于`LATIN SMALL LETTER E`(`U+0065`)后面加上`COMBINING ACUTE ACCENT`(`U+0301`)。这两个字符群集都有效的表示字符 é ，所以它们被认为是标准相等的：
+例如，`LATIN SMALL LETTER E WITH ACUTE`(`U+00E9`)就是标准相等于`LATIN SMALL LETTER E`(`U+0065`)后面加上`COMBINING ACUTE ACCENT`(`U+0301`)。这两个字符群集都是表示字符`é`的有效方式，所以它们被认为是标准相等的：
 
 ```swift
 // "Voulez-vous un café?" 使用 LATIN SMALL LETTER E WITH ACUTE
 let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
+
 // "Voulez-vous un café?" 使用 LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
 let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"
+
 if eAcuteQuestion == combinedEAcuteQuestion {
     print("These two strings are considered equal")
 }
@@ -430,7 +431,9 @@ if eAcuteQuestion == combinedEAcuteQuestion {
 
 ```swift
 let latinCapitalLetterA: Character = "\u{41}"
+
 let cyrillicCapitalLetterA: Character = "\u{0410}"
+
 if latinCapitalLetterA != cyrillicCapitalLetterA {
     print("These two characters are not equivalent")
 }
@@ -444,7 +447,8 @@ if latinCapitalLetterA != cyrillicCapitalLetterA {
 <a name="prefix_and_suffix_equality"></a>
 ### 前缀/后缀相等 (Prefix and Suffix Equality)
 
-通过调用字符串的`hasPrefix(_:)`/`hasSuffix(_:)`方法来检查字符串是否拥有特定前缀/后缀，两个方法均需要以字符串作为参数传入并传出`Boolean`值。
+通过调用字符串的`hasPrefix(_:)`/`hasSuffix(_:)`方法来检查字符串是否拥有特定前缀/后缀，两个方法均接收一个`String`类型的参数，并返回一个布尔值。
+
 下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
 
 ```swift
@@ -493,15 +497,16 @@ print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
 ```
 
 > 注意：
-> `hasPrefix(_:)`和`hasSuffix(_:)`方法都是在每个字符串中一个一个字符的比较其可扩展的字符群集是否标准相等，详细描述在[字符串/字符相等](#string_and_character_equality)。
+> `hasPrefix(_:)`和`hasSuffix(_:)`方法都是在每个字符串中逐字符比较其可扩展的字符群集是否标准相等，详细描述在[字符串/字符相等](#string_and_character_equality)。
 
 
 <a name="unicode_representations_of_strings"></a>
 ## 字符串的 Unicode 表示形式（Unicode Representations of Strings）
+
 当一个 Unicode 字符串被写进文本文件或者其他储存时，字符串中的 Unicode 标量会用 Unicode 定义的几种编码格式编码。每一个字符串中的小块编码都被称为代码单元。这些包括 UTF-8 编码格式（编码字符串为8位的代码单元）， UTF-16 编码格式（编码字符串位16位的代码单元），以及 UTF-32 编码格式（编码字符串32位的代码单元）。
 
 Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。
-您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 可扩展的字符群集的方式访问每一个字符值。
+您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 可扩展的字符群集的方式访问每一个`Character`值。
 该过程在 [使用字符](#working_with_characters) 中进行了描述。
 
 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
@@ -519,7 +524,8 @@ let dogString = "Dog‼🐶"
 
 <a name="UTF-8_representation"></a>
 ### UTF-8 表示
-您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
+
+您可以通过遍历`String`的`utf8`属性来访问它的`UTF-8`表示。
 其为`String.UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
 
 <table style='text-align:center'>
@@ -562,21 +568,21 @@ let dogString = "Dog‼🐶"
 
 ```swift
 for codeUnit in dogString.utf8 {
-   print("\(codeUnit) ", appendNewline: false)
+    print("\(codeUnit) ", terminator: "")
 }
 print("")
 // 68 111 103 226 128 188 240 159 144 182
 ```
 
-上面的例子中，前三个10进制代码单元值 (68, 111, 103) 代表了字符`D`、`o`和 `g`，它们的 UTF-8 表示与 ASCII 表示相同。
-接下来的三个10进制代码单元值 (226, 128, 188) 是`DOUBLE EXCLAMATION MARK`的3字节 UTF-8 表示。
-最后的四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。
+上面的例子中，前三个10进制`codeUnit`值 (`68`, `111`, `103`) 代表了字符`D`、`o`和 `g`，它们的 UTF-8 表示与 ASCII 表示相同。
+接下来的三个10进制`codeUnit`值 (`226`, `128`, `188`) 是`DOUBLE EXCLAMATION MARK`的3字节 UTF-8 表示。
+最后的四个`codeUnit`值 (`240`, `159`, `144`, `182`) 是`DOG FACE`的4字节 UTF-8 表示。
 
 
 <a name="UTF-16_representation"></a>
 ### UTF-16 表示
 
-您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
+您可以通过遍历`String`的`utf16`属性来访问它的`UTF-16`表示。
 其为`String.UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
 
 <table style='text-align:center'>
@@ -611,27 +617,27 @@ print("")
 
 ```swift
 for codeUnit in dogString.utf16 {
-    print("\(codeUnit) ")
+    print("\(codeUnit) ", terminator: "")
 }
-print("\n")
+print("")
 // 68 111 103 8252 55357 56374
 ```
 
-同样，前三个代码单元值 (68, 111, 103) 代表了字符`D`、`o`和`g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。
+同样，前三个`codeUnit`值 (`68`, `111`, `103`) 代表了字符`D`、`o`和`g`，它们的 UTF-16 代码单元和 UTF-8 完全相同（因为这些 Unicode 标量表示 ASCII 字符）。
 
-第四个代码单元值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量值`U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。
+第四个`codeUnit`值 (`8252`) 是一个等于十六进制`203C`的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量值`U+203C`。这个字符在 UTF-16 中可以用一个代码单元表示。
 
-第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
-第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
+第五和第六个`codeUnit`值 (`55357`和`56374`) 是`DOG FACE`字符的 UTF-16 表示。
+第一个值为`U+D83D`(十进制值为`55357`)，第二个值为`U+DC36`(十进制值为`56374`)。
 
 <a name="unicode_scalars_representation"></a>
 ### Unicode 标量表示 (Unicode Scalars Representation)
 
-您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。
-其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。
+您可以通过遍历`String`值的`unicodeScalars`属性来访问它的 Unicode 标量表示。
+其为`UnicodeScalarView`类型的属性，`UnicodeScalarView`是`UnicodeScalar`的集合。
 `UnicodeScalar`是21位的 Unicode 代码点。
 
-每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示：
+每一个`UnicodeScalar`拥有一个`value`属性，可以返回对应的21位数值，用`UInt32`来表示：
 
 
 <table style='text-align:center'>
@@ -664,18 +670,18 @@ print("\n")
 
 ```swift
 for scalar in dogString.unicodeScalars {
-    print("\(scalar.value) ")
+    print("\(scalar.value) ", terminator: "")
 }
-print("\n")
+print("")
 // 68 111 103 8252 128054
 ```
 
-前三个代码单元值 (68, 111, 103) 仍然代表字符`D`、`o`和`g`。
-第四个代码单元值 (8252) 仍然是一个等于十六进制203C的的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量`U+203C`。
+前三个`UnicodeScalar`值(`68`, `111`, `103`)的`value`属性仍然代表字符`D`、`o`和`g`。
+第四个`codeUnit`值(`8252`)仍然是一个等于十六进制`203C`的十进制值。这个代表了`DOUBLE EXCLAMATION MARK`字符的 Unicode 标量`U+203C`。
 
-第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于`DOG FACE`的Unicode 标量`U+1F436`。
+第五个`UnicodeScalar`值的`value`属性，`128054`，是一个十六进制`1F436`的十进制表示。其等同于`DOG FACE`的 Unicode 标量`U+1F436`。
 
-作为查询字符值属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
+作为查询它们的`value`属性的一种替代方法，每个`UnicodeScalar`值也可以用来构建一个新的`String`值，比如在字符串插值中使用：
 
 ```swift
 for scalar in dogString.unicodeScalars {

From 96bfe290a7d098b0dfa3836fbe0198d9c411cd5e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=BB=8E=E4=BB=8A=E4=BB=A5=E5=90=8E?= <949478479@qq.com>
Date: Tue, 8 Sep 2015 22:37:28 +0800
Subject: [PATCH 201/228] =?UTF-8?q?=E5=AE=8C=E5=96=84=E6=8E=92=E7=89=88?=
 =?UTF-8?q?=EF=BC=8C=E5=90=8C=E6=AD=A5=E9=83=A8=E5=88=86=E8=BF=87=E6=9C=9F?=
 =?UTF-8?q?=E4=BF=A1=E6=81=AF=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/04_Collection_Types.md | 233 ++++++++++++-------------
 1 file changed, 115 insertions(+), 118 deletions(-)

diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index f26b2ccb..a6e9c5fd 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -21,7 +21,7 @@ Swift 语言提供`Arrays`、`Sets`和`Dictionaries`三种基本的集合类型
 
 Swift 语言中的`Arrays`、`Sets`和`Dictionaries`中存储的数据值类型必须明确。这意味着我们不能把不正确的数据类型插入其中。同时这也说明我们完全可以对取回值的类型非常自信。
 
-> 注意：
+> 注意：  
 Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更多关于泛型类型和集合，参见 [泛型](./23_Generics.html)章节。
 
 <a name="mutability_of_collections"></a>
@@ -29,8 +29,8 @@ Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更
 
 如果创建一个`Arrays`、`Sets`或`Dictionaries`并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项来改变这个集合的大小。如果我们把`Arrays`、`Sets`或`Dictionaries`分配成常量，那么它就是不可变的，它的大小不能被改变。
 
-> 注意：
- 在我们不需要改变集合大小的时候创建不可变集合是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。
+> 注意：  
+在我们不需要改变集合大小的时候创建不可变集合是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。
 
 <a name="arrays"></a>
 ## 数组(Arrays)
@@ -44,57 +44,58 @@ Swift 的`Arrays`、`Sets`和`Dictionaries`类型被实现为泛型集合。更
 <a name="array_type_shorthand_syntax"></a>
 ### 数组的简单语法
 
-写 Swift 数组应该遵循像`Array<T>`这样的形式，其中`T`是这个数组中唯一允许存在的数据类型。我们也可以使用像`[T]`这样的简单语法。尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
+写 Swift 数组应该遵循像`Array<Element>`这样的形式，其中`Element`是这个数组中唯一允许存在的数据类型。我们也可以使用像`[Element]`这样的简单语法。尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
 
 <a name="creating_an_empty_array"></a>
-###创建一个空数组
+### 创建一个空数组
 
 我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
 
 ```swift
 var someInts = [Int]()
-print("someInts is of type [Int] with \(someInts.count) items。")
-// 打印 "someInts is of type [Int] with 0 items。"
+print("someInts is of type [Int] with \(someInts.count) items.")
+// 打印 "someInts is of type [Int] with 0 items."
 ```
 
-注意 通过构造函数的类型，`someInts`的值类型被推断为`[Int]`。
+注意，通过构造函数的类型，`someInts`的值类型被推断为`[Int]`。
 
 或者，如果代码上下文中已经提供了类型信息，例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：`[]`（一对空方括号）：
 
 ```swift
 someInts.append(3)
-// someInts 现在包含一个Int值
+// someInts 现在包含一个 Int 值
 someInts = []
-// someInts 现在是空数组，但是仍然是[Int]类型的。
+// someInts 现在是空数组，但是仍然是 [Int] 类型的。
 ```
 
 <a name="creating_an_array_with_a_default_value"></a>
-###创建一个带有默认值的数组
+### 创建一个带有默认值的数组
 
 Swift 中的`Array`类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（`count`）和适当类型的初始值（`repeatedValue`）传入数组构造函数：
 
 ```swift
 var threeDoubles = [Double](count: 3, repeatedValue:0.0)
-// threeDoubles 是一种 [Double]数组, 等于 [0.0, 0.0, 0.0]
+// threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]
 ```
 
 <a name="creating_an_array_by_adding_two_arrays_together"></a>
-###通过两个数组相加创建一个数组
+### 通过两个数组相加创建一个数组
 
 我们可以使用加法操作符（`+`）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：
 
 ```swift
 var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
-// anotherThreeDoubles is inferred as [Double], and equals [2.5, 2.5, 2.5]
+// anotherThreeDoubles 被推断为 [Double]，等价于 [2.5, 2.5, 2.5]
 
 var sixDoubles = threeDoubles + anotherThreeDoubles
-// sixDoubles 被推断为 [Double], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
+// sixDoubles 被推断为 [Double]，等价于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
 ```
 
 <a name="creating_an_array_with_an_array_literals"></a>
 ### 用字面量构造数组
 
-我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值。
+我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值：
+
 `[value 1, value 2, value 3]`。
 
 下面这个例子创建了一个叫做`shoppingList`并且存储`String`的数组：
@@ -106,10 +107,10 @@ var shoppingList: [String] = ["Eggs", "Milk"]
 
 `shoppingList`变量被声明为“字符串值类型的数组“，记作`[String]`。 因为这个数组被规定只有`String`一种数据结构，所以只有`String`类型可以在其中被存取。 在这里，`shoppinglist`数组由两个`String`值（`"Eggs"` 和`"Milk"`）构造，并且由字面量定义。
 
-> 注意：
-> `Shoppinglist`数组被声明为变量（`var`关键字创建）而不是常量（`let`创建）是因为以后可能会有更多的数据项被插入其中。
+> 注意：  
+`Shoppinglist`数组被声明为变量（`var`关键字创建）而不是常量（`let`创建）是因为以后可能会有更多的数据项被插入其中。
 
-在这个例子中，字面量仅仅包含两个`String`值。匹配了该数组的变量声明（只能包含`String`的数组），所以这个字面量的分配过程就是允许用两个初始项来构造`shoppinglist`。
+在这个例子中，字面量仅仅包含两个`String`值。匹配了该数组的变量声明（只能包含`String`的数组），所以这个字面量的分配过程可以作为用两个初始项来构造`shoppinglist`的一种方式。
 
 由于 Swift 的类型推断机制，当我们用字面量构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 `shoppinglist`的构造也可以这样写：
 
@@ -122,15 +123,16 @@ var shoppingList = ["Eggs", "Milk"]
 <a name="accessing_and_modifying_an_array"></a>
 ### 访问和修改数组
 
-我们可以通过数组的方法和属性来访问和修改数组，或者下标语法。
-还可以使用数组的只读属性`count`来获取数组中的数据项数量。
+我们可以通过数组的方法和属性来访问和修改数组，或者使用下标语法。
+
+可以使用数组的只读属性`count`来获取数组中的数据项数量：
 
 ```swift
 print("The shopping list contains \(shoppingList.count) items.")
-// 输出"The shopping list contains 2 items."（这个数组有2个项）
+// 输出 "The shopping list contains 2 items."（这个数组有2个项）
 ```
 
-使用布尔项`isEmpty`来作为检查`count`属性的值是否为 0 的捷径。
+使用布尔值属性`isEmpty`作为检查`count`属性的值是否为 0 的捷径：
 
 ```swift
 if shoppingList.isEmpty {
@@ -138,10 +140,10 @@ if shoppingList.isEmpty {
 } else {
     print("The shopping list is not empty.")
 }
-// 打印 "The shopping list is not empty."（shoppinglist不是空的）
+// 打印 "The shopping list is not empty."（shoppinglist 不是空的）
 ```
 
-也可以使用`append`方法在数组后面添加新的数据项：
+也可以使用`append(_:)`方法在数组后面添加新的数据项：
 
 ```swift
 shoppingList.append("Flour")
@@ -153,7 +155,7 @@ shoppingList.append("Flour")
 ```swift
 shoppingList += ["Baking Powder"]
 // shoppingList 现在有四项了
-shoppingList += ["Chocolate Spread","Cheese","Butter"]
+shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
 // shoppingList 现在有七项了
 ```
 
@@ -164,7 +166,8 @@ var firstItem = shoppingList[0]
 // 第一项是 "Eggs"
 ```
 
-注意第一项在数组中的索引值是`0`而不是`1`。 Swift 中的数组索引总是从零开始。
+> 注意：  
+第一项在数组中的索引值是`0`而不是`1`。 Swift 中的数组索引总是从零开始。
 
 我们也可以用下标来改变某个已有索引值对应的数据值：
 
@@ -177,11 +180,11 @@ shoppingList[0] = "Six eggs"
 
 ```swift
 shoppingList[4...6] = ["Bananas", "Apples"]
-// shoppingList 现在有六项
+// shoppingList 现在有6项
 ```
 
-> 注意：
-> 不可以用下标访问的形式去在数组尾部添加新项。
+> 注意：  
+不可以用下标访问的形式去在数组尾部添加新项。
 
 
 调用数组的`insert(_:atIndex:)`方法来在某个具体索引值之前添加数据项：
@@ -192,33 +195,33 @@ shoppingList.insert("Maple Syrup", atIndex: 0)
 // "Maple Syrup" 现在是这个列表中的第一项
 ```
 
-这次`insert`函数调用把值为`"Maple Syrup"`的新数据项插入列表的最开始位置，并且使用`0`作为索引值。
+这次`insert(_:atIndex:)`方法调用把值为`"Maple Syrup"`的新数据项插入列表的最开始位置，并且使用`0`作为索引值。
 
-类似的我们可以使用`removeAtIndex`方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）:
+类似的我们可以使用`removeAtIndex(_:)`方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）：
 
 ```swift
 let mapleSyrup = shoppingList.removeAtIndex(0)
 // 索引值为0的数据项被移除
-// shoppingList 现在只有6项，而且不包括Maple Syrup
-// mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup"
+// shoppingList 现在只有6项，而且不包括 Maple Syrup
+// mapleSyrup 常量的值等于被移除数据项的值 "Maple Syrup"
 ```
-> 注意：
-> 如果我们试着对索引越界的数据进行检索或者设置新值的操作，会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于 0 时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。
+> 注意：  
+如果我们试着对索引越界的数据进行检索或者设置新值的操作，会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于 0 时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。
 
-数据项被移除后数组中的空出项会被自动填补，所以现在索引值为`0`的数据项的值再次等于`"Six eggs"`:
+数据项被移除后数组中的空出项会被自动填补，所以现在索引值为`0`的数据项的值再次等于`"Six eggs"`：
 
 ```swift
 firstItem = shoppingList[0]
 // firstItem 现在等于 "Six eggs"
 ```
 
-如果我们只想把数组中的最后一项移除，可以使用`removeLast`方法而不是`removeAtIndex(_:)`方法来避免我们需要获取数组的`count`属性。就像后者一样，前者也会返回被移除的数据项：
+如果我们只想把数组中的最后一项移除，可以使用`removeLast()`方法而不是`removeAtIndex(_:)`方法来避免我们需要获取数组的`count`属性。就像后者一样，前者也会返回被移除的数据项：
 
 ```swift
 let apples = shoppingList.removeLast()
 // 数组的最后一项被移除了
-// shoppingList现在只有5项，不包括cheese
-// apples 常量的值现在等于"Apples" 字符串
+// shoppingList 现在只有5项，不包括 cheese
+// apples 常量的值现在等于 "Apples" 字符串
 ```
 
 <a name="iterating_over_an_array"></a>
@@ -255,36 +258,37 @@ for (index, value) in shoppingList.enumerate() {
 <a name="sets"></a>
 ## 集合
 
-集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以把集合当做是数组另一形式。
+集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。
 
-> 注意：
-> Swift的`Set`类型被桥接到`Fundation`中的`NSSet`类。
+> 注意：  
+> Swift的`Set`类型被桥接到`Fundation`中的`NSSet`类。  
 > 关于使用`Fundation`和`Cocoa`中`Set`的知识，请看 [*Using Swift with Cocoa and Objective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216)。
 
 <a name="hash_values_for_set_types"></a>
-#### Set类型的哈希值
+#### 集合类型的哈希值
 
-为了存储在集合中，该类型必须是可哈希化的-也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是```Int```类型的，它和其他的对象相同，其被用来比较相等与否，比如```a==b```,它遵循的是```a.hashValue == b.hashValue```。
+一个类型为了存储在集合中，该类型必须是可哈希化的--也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是`Int`类型的，相等的对象哈希值必须相同，比如`a==b`,因此必须`a.hashValue == b.hashValue`。
 
-Swift 的所有基本类型(比如```String```,```Int```,```Double```和```Bool```)默认都是可哈希化的，它可以作为集合的值或者字典的键值类型。没有关联值的枚举成员值(在[枚举](./08_Enumerations.html)有讲述)默认也是可哈希化的。
+Swift 的所有基本类型(比如`String`,`Int`,`Double`和`Bool`)默认都是可哈希化的，可以作为集合的值的类型或者字典的键的类型。没有关联值的枚举成员值(在[枚举](./08_Enumerations.html)有讲述)默认也是可哈希化的。
 
-> 注意：
-> 你可以使用你自定义的类型作为集合的值或者是字典的键值类型，但你需要使你的自定义类型服从Swift标准库中的`Hashable`协议。服从`Hashable`协议的类型需要提供一个类型为`Int`的取值访问器属性`hashValue`。这个由类型的`hashValue`返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。
-> 因为`hashable`协议服从于`Equatable`协议，所以遵循该协议的类型也必须提供一个"是否等"运算符(`==`)的实现。这个`Equatable`协议需要任何遵循的`==`的实现都是一种相等的关系。也就是说，对于`a,b,c`三个值来说，`==`的实现必须满足下面三种情况：
+> 注意：  
+> 你可以使用你自定义的类型作为集合的值的类型或者是字典的键的类型，但你需要使你的自定义类型符合 Swift 标准库中的`Hashable`协议。符合`Hashable`协议的类型需要提供一个类型为`Int`的可读属性`hashValue`。由类型的`hashValue`属性返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。  
 
-* ```a==a```(自反性)
-* ```a==b```意味着```b==a```(对称性)
-* ```a==b&&b==c```意味着```a==c```(传递性)
+> 因为`hashable`协议符合`Equatable`协议，所以符合该协议的类型也必须提供一个"是否相等"运算符(`==`)的实现。这个`Equatable`协议要求任何符合`==`实现的实例间都是一种相等的关系。也就是说，对于`a,b,c`三个值来说，`==`的实现必须满足下面三种情况：
 
-关于协议遵循的更多信息，请看[协议](./22_Protocols.html)
+> * `a == a`(自反性)
+> * `a == b`意味着`b == a`(对称性)
+> * `a == b && b == c`意味着`a == c`(传递性)
+
+关于符合协议的更多信息，请看[协议](./22_Protocols.html)。
 
 <a name="set_type_syntax"></a>
-### Set类型语法
+### 集合类型语法
 
-Swift中的`Set`类型被写为`Set<T>`, 这里的`T`表示`Set`中允许存储的类型，和数组不同的是，集合没有等价的简化形式。
+Swift 中的`Set`类型被写为`Set<Element>`，这里的`Element`表示`Set`中允许存储的类型，和数组不同的是，集合没有等价的简化形式。
 
 <a name="creating_and_initalizing_an_empty_set"></a>
-### 创建和构造一个空的Set
+### 创建和构造一个空的集合
 
 你可以通过构造器语法创建一个特定类型的空集合：
 
@@ -294,16 +298,16 @@ print("letters is of type Set<Character> with \(letters.count) items.")
 // 打印 "letters is of type Set<Character> with 0 items."
 ```
 
-> 注意：
+> 注意：  
 > 通过构造器，这里的`letters`变量的类型被推断为`Set<Character>`。
 
 此外，如果上下文提供了类型信息，比如作为函数的参数或者已知类型的变量或常量，我们可以通过一个空的数组字面量创建一个空的`Set`：
 
 ```swift
 letters.insert("a")
-// letters 现在含有1个Character类型的值
+// letters 现在含有1个 Character 类型的值
 letters = []
-// letters 现在是一个空的Set, 但是它依然是 Set<Character> 类型
+// letters 现在是一个空的 Set, 但是它依然是 Set<Character> 类型
 ```
 
 <a name="creating_a_set_with_an_array_literal"></a>
@@ -315,35 +319,35 @@ letters = []
 
 ```swift
 var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
-// favoriteGenres被构造成含有三个初始值的集合
+// favoriteGenres 被构造成含有三个初始值的集合
 ```
 
-这个`favoriteGenres`变量被声明为“一个`String`值的集合”，写为`Set<String>`。由于这个特定的集合含有指定`String`类型的值，所以它只允许存储`String`类型值。这里的`favoriteGenres`变量有三个`String`类型的初始值("`Rock`","`Classical`"和"`Hip hop`")，并以数组字面量的方式出现。
+这个`favoriteGenres`变量被声明为“一个`String`值的集合”，写为`Set<String>`。由于这个特定的集合含有指定`String`类型的值，所以它只允许存储`String`类型值。这里的`favoriteGenres`变量有三个`String`类型的初始值(`"Rock"`，`"Classical"`和`"Hip hop"`)，并以数组字面量的方式出现。
 
-> 注意：
+> 注意：  
 > `favoriteGenres`被声明为一个变量(拥有`var`标示符)而不是一个常量(拥有`let`标示符),因为它里面的元素将会在下面的例子中被增加或者移除。
 
-一个`Set`类型不能从数组中字面量中独立地被推断出来，因此`Set`类型必须显式声明。然而，由于Swift的类型推导功能，如果你想使用一个数组字面量构造一个Set并且该数组字面量中的所有元素类型相同，那么你无须写出`Set`的具体类型。`favoriteGenres`的构造形式可以采用简化的方式代替：
+一个`Set`类型不能从数组字面量中被单独推断出来，因此`Set`类型必须显式声明。然而，由于 Swift 的类型推断功能，如果你想使用一个数组字面量构造一个`Set`并且该数组字面量中的所有元素类型相同，那么你无须写出`Set`的具体类型。`favoriteGenres`的构造形式可以采用简化的方式代替：
 
 ```swift
 var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
 ```
 
-由于数组字面量中的所有元素类型相同，Swift可以推断出`Set<String>`作为`favoriteGenres`变量的正确类型。
+由于数组字面量中的所有元素类型相同，Swift 可以推断出`Set<String>`作为`favoriteGenres`变量的正确类型。
 
 <a name="accesing_and_modifying_a_set"></a>
-### 访问和修改一个Set
+### 访问和修改一个集合
 
-你可以通过`Set`的属性和方法来访问和修改一个`Set`.
+你可以通过`Set`的属性和方法来访问和修改一个`Set`。
 
-为了找出一个`Set`中元素的数量，可以使用其只读属性`count`:
+为了找出一个`Set`中元素的数量，可以使用其只读属性`count`：
 
 ```swift
 print("I have \(favoriteGenres.count) favorite music genres.")
 // 打印 "I have 3 favorite music genres."
 ```
 
-使用布尔属性`isEmpty`作为一个缩写形式去检查`count`属性是否为`0`:
+使用布尔属性`isEmpty`作为一个缩写形式去检查`count`属性是否为`0`：
 
 ```swift
 if favoriteGenres.isEmpty {
@@ -354,14 +358,14 @@ if favoriteGenres.isEmpty {
 // 打印 "I have particular music preferences."
 ```
 
-你可以通过调用`Set`的` insert(_:) `方法来添加一个新元素：
+你可以通过调用`Set`的`insert(_:)`方法来添加一个新元素：
 
 ```swift
 favoriteGenres.insert("Jazz")
 // favoriteGenres 现在包含4个元素
 ```
 
-你可以通过调用`Set`的`remove(_:)`方法去删除一个元素，如果该值是该`Set`的一个元素则删除该元素并且返回被删除的元素值，否认如果该`Set`不包含该值，则返回`nil`。另外，`Set`中的所有元素可以通过它的`removeAll()`方法删除。
+你可以通过调用`Set`的`remove(_:)`方法去删除一个元素，如果该值是该`Set`的一个元素则删除该元素并且返回被删除的元素值，否则如果该`Set`不包含该值，则返回`nil`。另外，`Set`中的所有元素可以通过它的`removeAll()`方法删除。
 
 ```swift
 if let removedGenre = favoriteGenres.remove("Rock") {
@@ -372,7 +376,7 @@ if let removedGenre = favoriteGenres.remove("Rock") {
 // 打印 "Rock? I'm over it."
 ```
 
-使用```contains(_:)```方法去检查```Set```中是否包含一个特定的值。
+使用`contains(_:)`方法去检查`Set`中是否包含一个特定的值：
 
 ```swift
 if favoriteGenres.contains("Funk") {
@@ -384,9 +388,9 @@ if favoriteGenres.contains("Funk") {
 ```
 
 <a name="iterating_over_a_set"></a>
-### 遍历一个Set
+### 遍历一个集合
 
-你可以在一个```for-in```循环中遍历一个```Set```中的所有值。
+你可以在一个`for-in`循环中遍历一个`Set`中的所有值。
 
 ```swift
 for genre in favoriteGenres {
@@ -397,9 +401,9 @@ for genre in favoriteGenres {
 // Hip hop
 ```
 
-更多关于`for-in`循环信息，参见[For循环](./05_Control_Flow.html#for_loops)。
+更多关于`for-in`循环的信息，参见[For 循环](./05_Control_Flow.html#for_loops)。
 
-Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中值可以使用`sort()`方法，它将根据提供的序列返回一个排序的集合.
+Swift 的`Set`类型没有确定的顺序，为了按照特定顺序来遍历一个`Set`中的值可以使用`sort()`方法，它将根据提供的序列返回一个有序集合.
 
 ```swift
 for genre in favoriteGenres.sort() {
@@ -413,7 +417,7 @@ for genre in favoriteGenres.sort() {
 <a name="performing_set_operations"></a>
 ### 完成集合操作
 
-你可以高效的完成`Set`的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。
+你可以高效地完成`Set`的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。
 
 <a name="fundamental_set_operations"></a>
 #### 基本集合操作
@@ -423,7 +427,7 @@ for genre in favoriteGenres.sort() {
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/setVennDiagram_2x.png)
 
 * 使用`intersect(_:)`方法根据两个集合中都包含的值创建的一个新的集合。
-* 使用`exclusiveOr(_:)`方法根据值在一个集合中但不在两个集合中的值创建一个新的集合。
+* 使用`exclusiveOr(_:)`方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
 * 使用`union(_:)`方法根据两个集合的值创建一个新的集合。
 * 使用`subtract(_:)`方法根据不在该集合中的值创建一个新的集合。
 
@@ -431,6 +435,7 @@ for genre in favoriteGenres.sort() {
 let oddDigits: Set = [1, 3, 5, 7, 9]
 let evenDigits: Set = [0, 2, 4, 6, 8]
 let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
+
 oddDigits.union(evenDigits).sort()
 // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 oddDigits.intersect(evenDigits).sort()
@@ -444,20 +449,21 @@ oddDigits.exclusiveOr(singleDigitPrimeNumbers).sort()
 <a name="set_membership_and_equality"></a>
 #### 集合成员关系和相等
 
-下面的插图描述了三个集合-`a`,`b`和`c`,以及通过悬浮区域表述集合间共享的元素。Set `a`是Set`b`的父集合，因为`a`包含了`b`中所有的元素，相反的，Set `b`是`a`的子集合，因为属于`b`的元素也被`a`包含。Set `b`和Set `c`彼此不关联，因为它们之间没有共同的元素。
+下面的插图描述了三个集合-`a`,`b`和`c`,以及通过重叠区域表述集合间共享的元素。集合`a`是集合`b`的父集合，因为`a`包含了`b`中所有的元素，相反的，集合`b`是集合`a`的子集合，因为属于`b`的元素也被`a`包含。集合`b`和集合`c`彼此不关联，因为它们之间没有共同的元素。
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/setEulerDiagram_2x.png)
 
-* 使用“是否等”运算符(`==`)来判断两个集合是否包含全部相同的值。
+* 使用“是否相等”运算符(`==`)来判断两个集合是否包含全部相同的值。
 * 使用`isSubsetOf(_:)`方法来判断一个集合中的值是否也被包含在另外一个集合中。
-* 使用`isSupersetOf(_:)`方法来判断一个集合中包含的值是另一个集合中所有的值。
-* 使用`isStrictSubsetOf(_:)`或者`isStrictSupersetOf(_:)`方法来判断一个集合是否是另外一个集合的子集合或者父集合并且和特定集合不相等。
-* 使用`isDisjointWith(_:)`方法来判断两个结合是否不含有相同的值。
+* 使用`isSupersetOf(_:)`方法来判断一个集合中包含另一个集合中所有的值。
+* 使用`isStrictSubsetOf(_:)`或者`isStrictSupersetOf(_:)`方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。
+* 使用`isDisjointWith(_:)`方法来判断两个集合是否不含有相同的值。
 
 ```swift
 let houseAnimals: Set = ["🐶", "🐱"]
 let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
 let cityAnimals: Set = ["🐦", "🐭"]
+
 houseAnimals.isSubsetOf(farmAnimals)
 // true
 farmAnimals.isSupersetOf(houseAnimals)
@@ -466,32 +472,24 @@ farmAnimals.isDisjointWith(cityAnimals)
 // true
 ```
 
-
-
 <a name="dictionaries"></a>
 ## 字典
 
 字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。
 
-> 注意：
-> Swiftly 的`Dictionary` 类型被桥接到Foundation的`NSDictionary`类。
+> 注意：  
+> Swift 的`Dictionary`类型被桥接到`Foundation`的`NSDictionary`类。  
 > 更多关于在`Foundation`和`Cocoa`中使用`Dictionary`类型的信息，参见 [*Using Swift with Cocoa and Obejective-C*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216) 一书。
 
 <a name="dictionary_type_shorthand_syntax"></a>
 ## 字典类型快捷语法
-<!--more
-Swift 的字典使用时需要具体规定可以存储键和值类型。不同于 Objective-C 的`NSDictionary`和`NSMutableDictionary` 类可以使用任何类型的对象来作键和值并且不提供任何关于这些对象的本质信息。在 Swift 中，在某个特定字典中可以存储的键和值必须提前定义清楚，方法是通过显性类型标注或者类型推断。
--->
+
 Swift 的字典使用`Dictionary<Key, Value>`定义，其中`Key`是字典中键的数据类型，`Value`是字典中对应于这些键所存储值的数据类型。
 
-> 注意：
+> 注意：  
 > 一个字典的`Key`类型必须遵循`Hashable`协议，就像`Set`的值类型。
 
-我们也可以用`[Key: Value]`这样快捷的形式去创建一个字典类型。虽然这俩种形式功能上相同，但是后者是首选，并且这本指导书涉及到字典类型时通篇采用后者。
-
-<!--more
-`KeyType`的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如`String`，`Int`， `Double`和`Bool`）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见[枚举](08_Enumerations.html)）也是默认可哈希的。
--->
+我们也可以用`[Key: Value]`这样快捷的形式去创建一个字典类型。虽然这两种形式功能上相同，但是后者是首选，并且这本指导书涉及到字典类型时通篇采用后者。
 
 <a name="creating_an_empty_dictionary"></a>
 ### 创建一个空字典
@@ -503,22 +501,21 @@ var namesOfIntegers = [Int: String]()
 // namesOfIntegers 是一个空的 [Int: String] 字典
 ```
 
-这个例子创建了一个`[Int: String]`类型的空字典来储存英语对整数的命名。它的键是`Int`型，值是`String`型。
+这个例子创建了一个`[Int: String]`类型的空字典来储存整数的英语命名。它的键是`Int`型，值是`String`型。
 
-如果上下文已经提供了信息类型，我们可以使用空字典字面量来创建一个空字典，记作`[:]`（中括号中放一个冒号）：
+如果上下文已经提供了类型信息，我们可以使用空字典字面量来创建一个空字典，记作`[:]`（中括号中放一个冒号）：
 
 ```swift
 namesOfIntegers[16] = "sixteen"
 // namesOfIntegers 现在包含一个键值对
 namesOfIntegers = [:]
-// namesOfIntegers 又成为了一个 Int, String类型的空字典
+// namesOfIntegers 又成为了一个 [Int: String] 类型的空字典
 ```
 
 <a name="creating_a_dictionary_with_a_dictionary_literal"></a>
+## 用字典字面量创建字典
 
-## 字典字面量
-
-我们可以使用字典字面量来构造字典，这和我们刚才介绍过的数组字面量拥有相似语法。字典字面量是一种将写一个或多个键值对作`Dictionary`集合的快捷途径。
+我们可以使用字典字面量来构造字典，这和我们刚才介绍过的数组字面量拥有相似语法。字典字面量是一种将一个或多个键值对写作`Dictionary`集合的快捷途径。
 
 一个键值对是一个`key`和一个`value`的结合体。在字典字面量中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含、由逗号分割：
 
@@ -532,9 +529,9 @@ namesOfIntegers = [:]
 var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
 ```
 
-`airports`字典被声明为一种 `[String: String]`类型，这意味着这个字典的键和值都是`String`类型。
+`airports`字典被声明为一种`[String: String]`类型，这意味着这个字典的键和值都是`String`类型。
 
-> 注意：
+> 注意：  
 > `airports`字典被声明为变量（用`var`关键字）而不是常量（`let`关键字）因为后来更多的机场信息会被添加到这个示例字典中。
 
 `airports`字典使用字典字面量初始化，包含两个键值对。第一对的键是`YYZ`，值是`Toronto Pearson`。第二对的键是`DUB`，值是`Dublin`。
@@ -542,7 +539,7 @@ var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
 这个字典语句包含了两个`String: String`类型的键值对。它们对应`airports`变量声明的类型（一个只有`String`键和`String`值的字典）所以这个字典字面量的任务是构造拥有两个初始数据项的`airport`字典。
 
 和数组一样，我们在用字典字面量构造字典时，如果它的键和值都有各自一致的类型，那么就不必写出字典的类型。
-`airports`的也可以用这种方法简短定义：
+`airports`字典也可以用这种简短方式定义：
 
 ```swift
 var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
@@ -551,9 +548,9 @@ var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
 因为这个语句中所有的键和值都各自拥有相同的数据类型，Swift 可以推断出`Dictionary<String, String>`是`airports`字典的正确类型。
 
 <a name="accessing_and_modifying_a_dictionary"></a>
-### 读取和修改字典
+### 访问和修改字典
 
-我们可以通过字典的方法和属性来读取和修改字典，或者通过使用下标语法。
+我们可以通过字典的方法和属性来访问和修改字典，或者通过使用下标语法。
 
 和数组一样，我们可以通过字典的只读属性`count`来获取某个字典的数据项数量：
 
@@ -562,7 +559,7 @@ print("The dictionary of airports contains \(airports.count) items.")
 // 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项）
 ```
 
-使用布尔属性`isEmpty`来快捷的检查字典的`count`属性是否等于0。
+使用布尔属性`isEmpty`来快捷地检查字典的`count`属性是否等于0：
 
 ```swift
 if airports.isEmpty {
@@ -573,7 +570,7 @@ if airports.isEmpty {
 // 打印 "The airports dictionary is not empty."
 ```
 
-我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的键值作为下标索引，并且分配新的合适类型的值：
+我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个恰当类型的键作为下标索引，并且分配恰当类型的新值：
 
 ```swift
 airports["LHR"] = "London"
@@ -589,7 +586,7 @@ airports["LHR"] = "London Heathrow"
 
 作为另一种下标方法，字典的`updateValue(_:forKey:)`方法可以设置或者更新特定键对应的值。就像上面所示的下标示例，`updateValue(_:forKey:)`方法在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值。和上面的下标方法不同的，`updateValue(_:forKey:)`这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。
 
-`updateValue(_:forKey:)`函数会返回包含一个字典值类型的可选值。举例来说：对于存储`String`值的字典，这个函数会返回一个`String?`或者“可选 `String`”类型的值。
+`updateValue(_:forKey:)`方法会返回对应值的类型的可选值。举例来说：对于存储`String`值的字典，这个函数会返回一个`String?`或者“可选 `String`”类型的值。
 
 如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是`nil`。
 
@@ -600,7 +597,7 @@ if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
 // 输出 "The old value for DUB was Dublin."
 ```
 
-我们也可以使用下标语法来在字典中检索特定键对应的值。因为有可能请求的键没有对应的值存在，字典的下标访问会返回一个字典值类型的可选值。如果这个字典包含请求键所对应的值，下标会返回一个包含这个存在值的可选值，否则将返回`nil`：
+我们也可以使用下标语法来在字典中检索特定键对应的值。因为有可能请求的键没有对应的值存在，字典的下标访问会返回对应值的类型的可选值。如果这个字典包含请求键所对应的值，下标会返回一个包含这个存在值的可选值，否则将返回`nil`：
 
 ```swift
 if let airportName = airports["DUB"] {
@@ -615,9 +612,9 @@ if let airportName = airports["DUB"] {
 
 ```swift
 airports["APL"] = "Apple Internation"
-// "Apple Internation"不是真的 APL机场, 删除它
+// "Apple Internation" 不是真的 APL 机场, 删除它
 airports["APL"] = nil
-// APL现在被移除了
+// APL 现在被移除了
 ```
 
 此外，`removeValueForKey(_:)`方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回`nil`：
@@ -646,7 +643,7 @@ for (airportCode, airportName) in airports {
 
 更多关于`for-in`循环的信息，参见[For 循环](./05_Control_Flow.html#for_loops)。
 
-通过访问`keys`或者`values`属性，我们也可以遍历字典的键或者值。
+通过访问`keys`或者`values`属性，我们也可以遍历字典的键或者值：
 
 ```swift
 for airportCode in airports.keys {
@@ -662,14 +659,14 @@ for airportName in airports.values {
 // Airport name: London Heathrow
 ```
 
-如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受`Array`实例 API 的参数，可以直接使用`keys`或者`values`属性直接构造一个新数组：
+如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受`Array`实例的 API 的参数，可以直接使用`keys`或者`values`属性构造一个新数组：
 
 ```swift
-let airportCodes = Array(airports.keys)
-// airportCodes is ["YYZ", "LHR"]
+let airportCodes = [String](airports.keys)
+// airportCodes 是 ["YYZ", "LHR"]
 
-let airportNames = Array(airports.values)
-// airportNames is ["Toronto Pearson", "London Heathrow"]
+let airportNames = [String](airports.values)
+// airportNames 是 ["Toronto Pearson", "London Heathrow"]
 ```
 
 Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的`keys`或`values`属性使用`sort()`方法。

From 30cbc4bac60d405d93706db058c1b90f2c683d9f Mon Sep 17 00:00:00 2001
From: MagicHu <mynightelfplayer@hotmail.com>
Date: Wed, 16 Sep 2015 14:43:55 +0800
Subject: [PATCH 202/228] Update 07_Closures.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

lambdas = lambda 的复数形式 不是一个单次
---
 source/chapter2/07_Closures.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index c93792e6..6c07f830 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -16,7 +16,7 @@
 - [闭包是引用类型（Closures Are Reference Types）](#closures_are_reference_types)
 
 闭包是自包含的函数代码块，可以在代码中被传递和使用。
-Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 lambdas 函数比较相似。
+Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 匿名函数比较相似。
 
 闭包可以捕获和存储其所在上下文中任意常量和变量的引用。
 这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在捕获过程中涉及到的所有内存操作。

From 789d05a9e6d14dc88b3ed490dd9b9a92b3da846a Mon Sep 17 00:00:00 2001
From: semper_idem <semper_idem@126.com>
Date: Thu, 17 Sep 2015 19:40:57 +0800
Subject: [PATCH 203/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=20Swift=20Tour=20?=
 =?UTF-8?q?=E4=B8=80=E7=AB=A0=E6=9F=90=E4=BA=9B=E6=9C=AA=E5=92=8C2.0?=
 =?UTF-8?q?=E7=89=88=E6=9C=AC=E5=90=8C=E6=AD=A5=E7=9A=84=E5=9C=B0=E6=96=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

更新 Swift Tour 一章某些未和2.0版本同步的地方
---
 source/chapter1/02_a_swift_tour.md | 130 +++++++++++++----------------
 1 file changed, 58 insertions(+), 72 deletions(-)

diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index 65f172e7..511a5d39 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -18,10 +18,10 @@
 通常来说，编程语言教程中的第一个程序应该在屏幕上打印“Hello, world”。在 Swift 中，可以用一行代码实现：
 
 ```swift
-println("Hello, world")
+print("Hello, world!")
 ```
 
-如果你写过 C 或者 Objective-C 代码，那你应该很熟悉这种形式——在 Swift 中，这行代码就是一个完整的程序。你不需要为了输入输出或者字符串处理导入一个单独的库。全局作用域中的代码会被自动当做程序的入口点，所以你也不需要`main`函数。你同样不需要在每个语句结尾写上分号。
+如果你写过 C 或者 Objective-C 代码，那你应该很熟悉这种形式——在 Swift 中，这行代码就是一个完整的程序。你不需要为了输入输出或者字符串处理导入一个单独的库。全局作用域中的代码会被自动当做程序的入口点，所以你也不需要`main()`函数。你同样不需要在每个语句结尾写上分号。
 
 这个教程会通过一系列编程例子来让你对 Swift 有初步了解，如果你有什么不理解的地方也不用担心——任何本章介绍的内容都会在后面的章节中详细讲解。
 
@@ -80,9 +80,7 @@ let fruitSummary = "I have \(apples + oranges) pieces of fruit."
 ```swift
 var shoppingList = ["catfish", "water", "tulips", "blue paint"]
 shoppingList[1] = "bottle of water"
-```
 
-```swift
 var occupations = [
     "Malcolm": "Captain",
     "Kaylee": "Mechanic",
@@ -107,7 +105,7 @@ occupations = [:]
 <a name="control_flow"></a>
 ## 控制流
 
-使用`if`和`switch`来进行条件操作，使用`for-in`、`for`、`while`和`do-while`来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的。
+使用`if`和`switch`来进行条件操作，使用`for-in`、`for`、`while`和`repeat-while`来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的。
 
 ```swift
 let individualScores = [75, 43, 103, 87, 12]
@@ -119,7 +117,7 @@ for score in individualScores {
         teamScore += 1
     }
 }
-teamScore
+print(teamScore)
 ```
 
 在`if`语句中，条件必须是一个布尔表达式——这意味着像`if score { ... }`这样的代码将报错，而不会隐形地与 0 做对比。
@@ -128,8 +126,8 @@ teamScore
 
 ```swift
 var optionalString: String? = "Hello"
-optionalString == nil
-
+print(optionalString == nil)
+ 
 var optionalName: String? = "John Appleseed"
 var greeting = "Hello!"
 if let name = optionalName {
@@ -148,19 +146,21 @@ if let name = optionalName {
 let vegetable = "red pepper"
 switch vegetable {
 case "celery":
-    let vegetableComment = "Add some raisins and make ants on a log."
+    print("Add some raisins and make ants on a log.")
 case "cucumber", "watercress":
-    let vegetableComment = "That would make a good tea sandwich."
+    print("That would make a good tea sandwich.")
 case let x where x.hasSuffix("pepper"):
-    let vegetableComment = "Is it a spicy \(x)?"
+    print("Is it a spicy \(x)?")
 default:
-    let vegetableComment = "Everything tastes good in soup."
+    print("Everything tastes good in soup.")
 }
 ```
 
 > 练习：  
 > 删除`default`语句，看看会有什么错误？
 
+注意`let`在上述例子的等式中是如何使用的，它将匹配等式的值赋给常量`x`。
+
 运行`switch`中匹配到的子句之后，程序会退出`switch`语句，并不会继续向下运行，所以不需要在每个子句结尾写`break`。
 
 你可以使用`for-in`来遍历字典，需要两个变量来表示每个键值对。字典是一个无序的集合，所以他们的键和值以任意顺序迭代结束。
@@ -179,7 +179,7 @@ for (kind, numbers) in interestingNumbers {
         }
     }
 }
-largest
+print(largest)
 ```
 
 > 练习：  
@@ -192,13 +192,13 @@ var n = 2
 while n < 100 {
     n = n * 2
 }
-n
+print(n)
 
 var m = 2
-do {
+repeat {
     m = m * 2
 } while m < 100
-m
+print(m)
 ```
 
 你可以在循环中使用`..<`来表示范围，也可以使用传统的写法，两者是等价的：
@@ -208,13 +208,13 @@ var firstForLoop = 0
 for i in 0..<4 {
     firstForLoop += i
 }
-firstForLoop
+print(firstForLoop)
 
 var secondForLoop = 0
 for var i = 0; i < 4; ++i {
     secondForLoop += i
 }
-secondForLoop
+print(secondForLoop)
 ```
 
 使用`..<`创建的范围不包含上界，如果想包含的话需要使用`...`。
@@ -254,8 +254,8 @@ func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
     return (min, max, sum)
 }
 let statistics = calculateStatistics([5, 3, 100, 3, 9])
-statistics.sum
-statistics.2
+print(statistics.sum)
+print(statistics.2)
 ```
 
 函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式：
@@ -337,14 +337,14 @@ numbers.map({
 
 ```swift
 let mappedNumbers = numbers.map({ number in 3 * number })
-mappedNumbers
+print(mappedNumbers)
 ```
 
 你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。
 
 ```swift
 let sortedNumbers = sorted(numbers) { $0 > $1 }
-sortedNumbers
+print(sortedNumbers)
 ```
 
 <a name="objects_and_classes"></a>
@@ -436,12 +436,12 @@ class EquilateralTriangle: NamedShape {
     }
 
     var perimeter: Double {
-    get {
-        return 3.0 * sideLength
-    }
-    set {
-        sideLength = newValue / 3.0
-    }
+        get {
+            return 3.0 * sideLength
+        }
+        set {
+            sideLength = newValue / 3.0
+        }
     }
 
     override func simpleDescription() -> String {
@@ -449,9 +449,9 @@ class EquilateralTriangle: NamedShape {
     }
 }
 var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
-triangle.perimeter
+print(triangle.perimeter)
 triangle.perimeter = 9.9
-triangle.sideLength
+print(triangle.sideLength)
 ```
 
 在`perimeter`的 setter 中，新值的名字是`newValue`。你可以在`set`之后显式的设置一个名字。
@@ -469,14 +469,14 @@ triangle.sideLength
 ```swift
 class TriangleAndSquare {
     var triangle: EquilateralTriangle {
-    willSet {
-        square.sideLength = newValue.sideLength
-    }
+        willSet {
+            square.sideLength = newValue.sideLength
+        }
     }
     var square: Square {
-    willSet {
-        triangle.sideLength = newValue.sideLength
-    }
+        willSet {
+            triangle.sideLength = newValue.sideLength
+        }
     }
     init(size: Double, name: String) {
         square = Square(sideLength: size, name: name)
@@ -484,23 +484,10 @@ class TriangleAndSquare {
     }
 }
 var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
-triangleAndSquare.square.sideLength
-triangleAndSquare.triangle.sideLength
+print(triangleAndSquare.square.sideLength)
+print(triangleAndSquare.triangle.sideLength)
 triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
-triangleAndSquare.triangle.sideLength
-```
-
-类中的方法和一般的函数有一个重要的区别，函数的参数名只在函数内部使用，但是方法的参数名需要在调用的时候显式说明（除了第一个参数）。默认情况下，方法的参数名和它在方法内部的名字一样，不过你也可以定义第二个名字，这个名字被用在方法内部。
-
-```swift
-class Counter {
-    var count: Int = 0
-    func incrementBy(amount: Int, numberOfTimes times: Int) {
-        count += amount * times
-    }
-}
-var counter = Counter()
-counter.incrementBy(2, numberOfTimes: 7)
+print(triangleAndSquare.triangle.sideLength)
 ```
 
 处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加`?`。如果`?`之前的值是`nil`，`?`后面的东西都会被忽略，并且整个表达式返回`nil`。否则，`?`之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。
@@ -531,20 +518,20 @@ enum Rank: Int {
         case .King:
             return "king"
         default:
-            return String(self.rawValue())
+            return String(self.rawValue)
         }
     }
 }
 let ace = Rank.Ace
-let aceRawValue = ace.rawValue()
+let aceRawValue = ace.rawValue
 ```
 
 > 练习：  
 > 写一个函数，通过比较它们的原始值来比较两个`Rank`值。
 
-在上面的例子中，枚举原始值的类型是`Int`，所以你只需要设置第一个原始值。剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。
+在上面的例子中，枚举原始值的类型是`Int`，所以你只需要设置第一个原始值。剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。使用`rawValue`属性来访问一个枚举成员的原始值。
 
-使用'rawValue'在原始值和枚举值之间进行转换。
+使用`init?(rawValue:)`初始化构造器在原始值和枚举值之间进行转换。
 
 ```swift
 if let convertedRank = Rank(rawValue: 3) {
@@ -569,7 +556,6 @@ enum Suit {
             return "clubs"
         }
     }
-
 }
 let hearts = Suit.Hearts
 let heartsDescription = hearts.simpleDescription()
@@ -607,10 +593,10 @@ enum ServerResponse {
     case Result(String, String)
     case Error(String)
 }
-
+ 
 let success = ServerResponse.Result("6:00 am", "8:09 pm")
 let failure = ServerResponse.Error("Out of cheese.")
-
+ 
 switch success {
 case let .Result(sunrise, sunset):
     let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
@@ -671,13 +657,13 @@ let bDescription = b.simpleDescription
 ```swift
 extension Int: ExampleProtocol {
     var simpleDescription: String {
-    return "The number \(self)"
+        return "The number \(self)"
     }
     mutating func adjust() {
         self += 42
     }
 }
-7.simpleDescription
+print(7.simpleDescription)
 ```
 
 > 练习：  
@@ -687,8 +673,8 @@ extension Int: ExampleProtocol {
 
 ```swift
 let protocolValue: ExampleProtocol = a
-protocolValue.simpleDescription
-// protocolValue.anotherProperty  // Uncomment to see the error
+print(protocolValue.simpleDescription)
+// print(protocolValue.anotherProperty)  // Uncomment to see the error
 ```
 
 即使`protocolValue`变量运行时的类型是`simpleClass`，编译器会把它的类型当做`ExampleProtocol`。这表示你不能调用类在它实现的协议之外实现的方法或者属性。
@@ -699,32 +685,32 @@ protocolValue.simpleDescription
 在尖括号里写一个名字来创建一个泛型函数或者类型。
 
 ```swift
-func repeat<ItemType>(item: ItemType, times: Int) -> [ItemType] {
-    var result = [ItemType]()
-    for i in 0..<times {
+func repeatItem<Item>(item: Item, numberOfTimes: Int) -> [Item] {
+    var result = [Item]()
+    for _ in 0..<numberOfTimes {
         result.append(item)
     }
     return result
 }
-repeat("knock", 4)
+repeatItem("knock", numberOfTimes:4)
 ```
 
 你也可以创建泛型类、枚举和结构体。
 
 ```swift
 // Reimplement the Swift standard library's optional type
-enum OptionalValue<T> {
+enum OptionalValue<Wrapped> {
     case None
-    case Some(T)
+    case Some(Wrapped)
 }
 var possibleInteger: OptionalValue<Int> = .None
 possibleInteger = .Some(100)
 ```
 
-在类型名后面使用`where`来指定对类型的需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者限定某个类必须有一个特定的父类
+在类型名后面使用`where`来指定对类型的需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者限定某个类必须有一个特定的父类。
 
 ```swift
-func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> Bool {
+func anyCommonElements <T: SequenceType, U: SequenceType where T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, _ rhs: U) -> Bool {
     for lhsItem in lhs {
         for rhsItem in rhs {
             if lhsItem == rhsItem {
@@ -740,4 +726,4 @@ anyCommonElements([1, 2, 3], [3])
 > 练习：  
 > 修改`anyCommonElements`函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。
 
-简单起见，你可以忽略`where`，只在冒号后面写协议或者类名。` <T: Equatable>`和`<T where T: Equatable>`是等价的。
+` <T: Equatable>`和`<T where T: Equatable>`是等价的。

From 333e5eb33ac92ba8b85a3348e0fb7c653e312bee Mon Sep 17 00:00:00 2001
From: nswbmw <gxqzk@126.com>
Date: Tue, 22 Sep 2015 12:34:57 +0800
Subject: [PATCH 204/228] fix typo

---
 source-tw/chapter2/11_Methods.md | 2 +-
 source/chapter2/11_Methods.md    | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/source-tw/chapter2/11_Methods.md b/source-tw/chapter2/11_Methods.md
index 9e35a555..47c3a802 100644
--- a/source-tw/chapter2/11_Methods.md
+++ b/source-tw/chapter2/11_Methods.md
@@ -225,7 +225,7 @@ ovenLight.next()
 
 ```swift
 class SomeClass {
-  class func someTypeMethod() {
+  static func someTypeMethod() {
     // type method implementation goes here
   }
 }
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index d933eeeb..ff1db826 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -1,6 +1,6 @@
 # 方法（Methods）
------------------
-
+-----------------
+
 > 1.0
 > 翻译：[pp-prog](https://github.com/pp-prog)
 > 校对：[zqp](https://github.com/zqp)
@@ -222,7 +222,7 @@ ovenLight.next()
 
 ```swift
 class SomeClass {
-  class func someTypeMethod() {
+  static func someTypeMethod() {
     // type method implementation goes here
   }
 }

From 2e1138f3e045eb75a8a9f07489e220f8298b66a4 Mon Sep 17 00:00:00 2001
From: senique <jcluo@live.cn>
Date: Tue, 22 Sep 2015 21:24:10 +0800
Subject: [PATCH 205/228] =?UTF-8?q?=E8=A1=A5=E4=B8=8A=E5=92=8C=E6=9B=B4?=
 =?UTF-8?q?=E6=96=B0=E7=BF=BB=E8=AF=91?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

82行漏掉一句。
657行更新翻译，便于理解。
---
 source/chapter1/02_a_swift_tour.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index 3d3af3e9..6c2e1768 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -79,7 +79,7 @@ let fruitSummary = "I have \(apples + oranges) pieces of fruit."
 > 练习：
 > 使用`\()`来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。
 
-使用方括号`[]`来创建数组和字典，并使用下标或者键（key）来访问元素。
+使用方括号`[]`来创建数组和字典，并使用下标或者键（key）来访问元素。最后一个元素后面允许有个逗号。
 
 ```swift
 var shoppingList = ["catfish", "water", "tulips", "blue paint"]
@@ -654,7 +654,7 @@ let bDescription = b.simpleDescription
 > 练习：
 > 写一个实现这个协议的枚举。
 
-注意声明`SimpleStructure`时候`mutating`关键字用来标记一个会修改结构体的方法。`SimpleClass`的声明不需要标记任何方法因为类中的方法经常会修改类。
+注意声明`SimpleStructure`时候`mutating`关键字用来标记一个会修改结构体的方法。`SimpleClass`的声明不需要标记任何方法，因为类中的方法通常可以修改类属性（类的性质）。
 
 使用`extension`来为现有的类型添加功能，比如新的方法和参数。你可以使用扩展在别处修改定义，甚至是从外部库或者框架引入的一个类型，使得这个类型遵循某个协议。
 

From aacf13094576a4f5a1236e3e3670e1ef551d39f6 Mon Sep 17 00:00:00 2001
From: sunorry <sunorry@gmail.com>
Date: Wed, 23 Sep 2015 18:52:06 +0800
Subject: [PATCH 206/228] =?UTF-8?q?=E5=90=8C=E6=AD=A5=202.0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source-tw/chapter1/02_a_swift_tour.md | 2 +-
 source/chapter1/02_a_swift_tour.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source-tw/chapter1/02_a_swift_tour.md b/source-tw/chapter1/02_a_swift_tour.md
index aec9e0de..20985905 100644
--- a/source-tw/chapter1/02_a_swift_tour.md
+++ b/source-tw/chapter1/02_a_swift_tour.md
@@ -301,7 +301,7 @@ func lessThanTen(number: Int) -> Bool {
     return number < 10
 }
 var numbers = [20, 19, 7, 12]
-hasAnyMatches(numbers, lessThanTen)
+hasAnyMatches(numbers, condition: lessThanTen)
 ```
 
 函數實際上是一種特殊的閉包，你可以使用`{}`來創建一個匿名閉包。使用`in`將參數和返回值類型聲明與閉包涵數體進行分離。
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index 6c2e1768..b80f70c1 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -322,7 +322,7 @@ func lessThanTen(number: Int) -> Bool {
     return number < 10
 }
 var numbers = [20, 19, 7, 12]
-hasAnyMatches(numbers, lessThanTen)
+hasAnyMatches(numbers, condition: lessThanTen)
 ```
 
 函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用`{}`来创建一个匿名闭包。使用`in`将参数和返回值类型声明与闭包函数体进行分离。

From 2dab6ab5530aa041a280db7feebbdac7e8caed41 Mon Sep 17 00:00:00 2001
From: sunorry <sunorry@gmail.com>
Date: Thu, 24 Sep 2015 00:47:26 +0800
Subject: [PATCH 207/228] =?UTF-8?q?=E6=9B=B4=E6=AD=A3=E7=BF=BB=E8=AF=91?=
 =?UTF-8?q?=E5=86=85=E5=AE=B9=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source-tw/chapter1/02_a_swift_tour.md | 2 +-
 source/chapter1/02_a_swift_tour.md    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source-tw/chapter1/02_a_swift_tour.md b/source-tw/chapter1/02_a_swift_tour.md
index 20985905..891d7bfa 100644
--- a/source-tw/chapter1/02_a_swift_tour.md
+++ b/source-tw/chapter1/02_a_swift_tour.md
@@ -649,7 +649,7 @@ let bDescription = b.simpleDescription
 
 注意聲明`SimpleStructure`時候`mutating`關鍵字用來標記一個會修改結構體的方法。`SimpleClass`的聲明不需要標記任何方法因為類中的方法經常會修改類。
 
-使用`extension`來為現有的類型添加功能，比如新的方法和參數。你可以使用擴展來改造定義在別處，甚至是從外部庫或者框架引入的一個類型，使得這個類型遵循某個協議。
+使用`extension`來為現有的類型添加功能，比如新的方法和計算屬性。你可以使用擴展來改造定義在別處，甚至是從外部庫或者框架引入的一個類型，使得這個類型遵循某個協議。
 
 ```swift
 extension Int: ExampleProtocol {
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index b80f70c1..e81cece8 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -656,7 +656,7 @@ let bDescription = b.simpleDescription
 
 注意声明`SimpleStructure`时候`mutating`关键字用来标记一个会修改结构体的方法。`SimpleClass`的声明不需要标记任何方法，因为类中的方法通常可以修改类属性（类的性质）。
 
-使用`extension`来为现有的类型添加功能，比如新的方法和参数。你可以使用扩展在别处修改定义，甚至是从外部库或者框架引入的一个类型，使得这个类型遵循某个协议。
+使用`extension`来为现有的类型添加功能，比如新的方法和计算属性。你可以使用扩展在别处修改定义，甚至是从外部库或者框架引入的一个类型，使得这个类型遵循某个协议。
 
 ```swift
 extension Int: ExampleProtocol {

From 6e991575b71a86227f0a8f4e79e912586b65d992 Mon Sep 17 00:00:00 2001
From: MagicHu <mynightelfplayer@hotmail.com>
Date: Thu, 24 Sep 2015 10:53:14 +0800
Subject: [PATCH 208/228] Update 16_Automatic_Reference_Counting.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Apartment 类的定义和实例名称发送变化
Number73 -> Unit4A
---
 .../16_Automatic_Reference_Counting.md        | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index bb697029..ca246151 100755
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -121,10 +121,10 @@ class Person {
 
 ```swift
 class Apartment {
-    let number: Int
-    init(number: Int) { self.number = number }
+    let unit: String
+    init(unit: String) { self.unit = unit }
     var tenant: Person?
-    deinit { print("Apartment #\(number) is being deinitialized") }
+    deinit { print("Apartment \(unit) is being deinitialized") }
 }
 ```
 
@@ -134,45 +134,45 @@ class Apartment {
 
 这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓`Person`和`Apartment`的实例是否像预期的那样被销毁。
 
-接下来的代码片段定义了两个可选类型的变量`john`和`number73`，并分别被设定为下面的`Apartment`和`Person`的实例。这两个变量都被初始化为`nil`，这正是可选的优点：
+接下来的代码片段定义了两个可选类型的变量`john`和`unit4A`，并分别被设定为下面的`Apartment`和`Person`的实例。这两个变量都被初始化为`nil`，这正是可选的优点：
 
 ```swift
 var john: Person?
-var number73: Apartment?
+var unit4A: Apartment?
 ```
 
-现在你可以创建特定的`Person`和`Apartment`实例并将赋值给`john`和`number73`变量：
+现在你可以创建特定的`Person`和`Apartment`实例并将赋值给`john`和`unit4A`变量：
 
 ```swift
 john = Person(name: "John Appleseed")
-number73 = Apartment(number: 73)
+unit4A = Apartment(unit: "4A")
 ```
 
-在两个实例被创建和赋值后，下图表现了强引用的关系。变量`john`现在有一个指向`Person`实例的强引用，而变量`number73`有一个指向`Apartment`实例的强引用：
+在两个实例被创建和赋值后，下图表现了强引用的关系。变量`john`现在有一个指向`Person`实例的强引用，而变量`unit4A`有一个指向`Apartment`实例的强引用：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle01_2x.png)
 
-现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量`john`和`number73`中的实例，这样实例的属性才能被赋值：
+现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量`john`和`unit4A`中的实例，这样实例的属性才能被赋值：
 
 ```swift
-john!.apartment = number73
-number73!.tenant = john
+john!.apartment = unit4A
+unit4A!.tenant = john
 ```
 
 在将两个实例联系在一起之后，强引用的关系如图所示：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle02_2x.png)
 
-不幸的是，这两个实例关联后会产生一个循环强引用。`Person`实例现在有了一个指向`Apartment`实例的强引用，而`Apartment`实例也有了一个指向`Person`实例的强引用。因此，当你断开`john`和`number73`变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
+不幸的是，这两个实例关联后会产生一个循环强引用。`Person`实例现在有了一个指向`Apartment`实例的强引用，而`Apartment`实例也有了一个指向`Person`实例的强引用。因此，当你断开`john`和`unit4A`变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：
 
 ```swift
 john = nil
-number73 = nil
+unit4A = nil
 ```
 
 注意，当你把这两个变量设为`nil`时，没有任何一个析构函数被调用。循环强引用会一直阻止`Person`和`Apartment`类实例的销毁，这就在你的应用程序中造成了内存泄漏。
 
-在你将`john`和`number73`赋值为`nil`后，强引用关系如下图：
+在你将`john`和`unit4A`赋值为`nil`后，强引用关系如下图：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle03_2x.png)
 
@@ -213,24 +213,24 @@ class Person {
 
 ```swift
 class Apartment {
-    let number: Int
-    init(number: Int) { self.number = number }
+    let unit: String
+    init(unit: String) { self.unit = unit }
     weak var tenant: Person?
-    deinit { print("Apartment #\(number) is being deinitialized") }
+    deinit { print("Apartment \(unit) is being deinitialized") }
 }
 ```
 
-然后跟之前一样，建立两个变量（`john`和`number73`）之间的强引用，并关联两个实例：
+然后跟之前一样，建立两个变量（`john`和`unit4A`）之间的强引用，并关联两个实例：
 
 ```swift
 var john: Person?
-var number73: Apartment?
+var unit4A: Apartment?
 
 john = Person(name: "John Appleseed")
-number73 = Apartment(number: 73)
+unit4A = Apartment(unit: "4A")
 
-john!.apartment = number73
-number73!.tenant = john
+john!.apartment = unit4A
+unit4A!.tenant = john
 ```
 
 现在，两个关联在一起的实例的引用关系如下图所示：
@@ -248,18 +248,18 @@ john = nil
 // prints "John Appleseed is being deinitialized"
 ```
 
-唯一剩下的指向`Apartment`实例的强引用来自于变量`number73`。如果你断开这个强引用，再也没有指向`Apartment`实例的强引用了：
+唯一剩下的指向`Apartment`实例的强引用来自于变量`unit4A`。如果你断开这个强引用，再也没有指向`Apartment`实例的强引用了：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/weakReference03_2x.png)
 
 由于再也没有指向`Apartment`实例的强引用，该实例也会被销毁：
 
 ```swift
-number73 = nil
-// prints "Apartment #73 is being deinitialized"
+unit4A = nil
+// prints "Apartment 4A is being deinitialized"
 ```
 
-上面的两段代码展示了变量`john`和`number73`在被赋值为`nil`后，`Person`实例和`Apartment`实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。
+上面的两段代码展示了变量`john`和`unit4A`在被赋值为`nil`后，`Person`实例和`Apartment`实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。
 
 <a name="2"></a>
 ### 无主引用

From cc04466239affe08305bb2de1cca48667a53169d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Thu, 24 Sep 2015 17:33:15 +0800
Subject: [PATCH 209/228] Typo.

---
 source/chapter2/03_Strings_and_Characters.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 72fe4da5..54f8116b 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -352,7 +352,7 @@ greeting.endIndex.successor() // error
 
 ```swift
 for index in greeting.characters.indices {
-   print("\(greeting[index]) ", terminator: "")
+   print("\(greeting[index]) ", terminator: " ")
 }
 // 打印输出 "G u t e n   T a g !"
 ```

From 4e148ea15a08167d809658fc729c1341ae3664f5 Mon Sep 17 00:00:00 2001
From: 187j3x1 <187j3x1@gmail.com>
Date: Thu, 24 Sep 2015 18:55:56 +0800
Subject: [PATCH 210/228] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=86=85=E5=AE=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter1/02_a_swift_tour.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index e81cece8..6d91a479 100755
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -341,14 +341,14 @@ numbers.map({
 有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
 
 ```swift
-let sortedNumbers = numbers.sort { $0 > $1 }
-print(sortedNumbers)
+let mappedNumbers = numbers.map({ number in 3 * number })
+print(mappedNumbers)
 ```
 
 你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。当一个闭包是传给函数的唯一参数，你可以完全忽略括号。
 
 ```swift
-let sortedNumbers = sorted(numbers) { $0 > $1 }
+let sortedNumbers = numbers.sort { $0 > $1 }
 print(sortedNumbers)
 ```
 

From 5ed3bc64a86cab71f429f02699ef6e1dea23371f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Thu, 24 Sep 2015 20:11:01 +0800
Subject: [PATCH 211/228] =?UTF-8?q?=E4=BF=9D=E8=AF=81=E5=8D=8F=E8=AE=AE?=
 =?UTF-8?q?=E5=90=8D=E7=A7=B0=E4=B8=80=E8=87=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/04_Collection_Types.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index a6e9c5fd..280a44a1 100755
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -274,7 +274,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`(对称性)

From 25a9f98a926158ede23396d936dfdf8a40b48d27 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Thu, 24 Sep 2015 22:10:27 +0800
Subject: [PATCH 212/228] =?UTF-8?q?=E4=B8=8D=E8=83=BD=E7=9B=B4=E6=8E=A5?=
 =?UTF-8?q?=E9=81=8D=E5=8E=86=E5=AD=97=E7=AC=A6=E4=B8=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/05_Control_Flow.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index 3a368de0..0788e176 100755
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -550,7 +550,7 @@ case let (x, y):
 ```swift
 let puzzleInput = "great minds think alike"
 var puzzleOutput = ""
-for character in puzzleInput {
+for character in puzzleInput.characters {
     switch character {
     case "a", "e", "i", "o", "u", " ":
         continue

From 29633131782d631ad54396d115b7ad1795aafb58 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Thu, 24 Sep 2015 22:29:02 +0800
Subject: [PATCH 213/228] =?UTF-8?q?=E8=A1=A8=E8=BE=BE=E5=BB=BA=E8=AE=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

感觉这里应该  `结果是什么类型` 会比较合适些 :smile:
---
 source/chapter2/06_Functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 29356027..4147d1d5 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -40,7 +40,7 @@ func sayHello(personName: String) -> String {
 
 所有的这些信息汇总起来成为函数的定义，并以 `func` 作为前缀。指定函数返回类型时，用返回箭头 `->`（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。
 
-该定义描述了函数做什么，它期望接收什么和执行结束时它返回的结果是什么。这样的定义使得函数可以在别的地方以一种清晰的方式被调用：
+该定义描述了函数做什么，它期望接收什么和执行结束时它返回的结果是什么类型。这样的定义使得函数可以在别的地方以一种清晰的方式被调用：
 
 ```swift
 print(sayHello("Anna"))

From e4d1cdf4dfff5b3739ddb89e2021091b682d62e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Thu, 24 Sep 2015 22:53:01 +0800
Subject: [PATCH 214/228] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97=E5=8F=8A?=
 =?UTF-8?q?=E4=B8=80=E4=BA=9B=E6=A0=87=E7=82=B9=E4=BF=AE=E6=AD=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/06_Functions.md | 52 ++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 29356027..855b06cd 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -100,9 +100,9 @@ print(sayHelloWorld())
 
 ### 多参量函数 (Functions With Multiple Parameters)
 
-函数可以有多种输入参数,这写参数被包含在函数的括号之中,以逗号分隔.
+函数可以有多种输入参数，这些参数被包含在函数的括号之中，以逗号分隔。
 
-这个函数取得一个人的名字和是否被招呼作为输入,并对那个人返回适当地问候语:
+这个函数取得一个人的名字和是否被招呼作为输入，并对那个人返回适当的问候语:
 
 ```swift
 func sayHello(personName: String, alreadyGreeted: Bool) -> String {
@@ -116,9 +116,9 @@ print(sayHello("Tim", alreadyGreeted: true))
 // prints "Hello again, Tim!"
 ```
 
-你通过在括号内传递一个`String`参数值和一个标识为`alreadyGreeted`的`Bool`值,使用逗号分隔来调用`sayHello(_:alreadyGreeted:)`函数.
+你通过在括号内传递一个`String`参数值和一个标识为`alreadyGreeted`的`Bool`值，使用逗号分隔来调用`sayHello(_:alreadyGreeted:)`函数。
 
-当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记,函数参数命名在[函数参数名称（Function Parameter Names）](#Function_Parameter_Names)有更详细的描述.
+当调用超过一个参数的函数时，第一个参数后的参数根据其对应的参数名称标记，函数参数命名在[函数参数名称（Function Parameter Names）](#Function_Parameter_Names)有更详细的描述。
 
 <a name="functions_without_return_values"></a>
 ### 无返回值函数（Functions Without Return Values）
@@ -164,7 +164,7 @@ printWithoutCounting("hello, world")
 
 你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。
 
-下面的这个例子中，定义了一个名为`minMax(_:)`的函数,作用是在一个`Int`数组中找出最小值与最大值.
+下面的这个例子中，定义了一个名为`minMax(_:)`的函数，作用是在一个`Int`数组中找出最小值与最大值。
 
 ```swift
 func minMax(array: [Int]) -> (min: Int, max: Int) {
@@ -181,9 +181,9 @@ func minMax(array: [Int]) -> (min: Int, max: Int) {
 }
 ```
 
-`minMax(_:)`函数返回一个包含两个`Int`值的元组,这些值被标记为`min`和`max`,一遍查询函数的返回值时他们可以被访问.
+`minMax(_:)`函数返回一个包含两个`Int`值的元组，这些值被标记为`min`和`max`，一遍查询函数的返回值时他们可以被访问。
 
-`minMax(_:)`的函数体中,在开始的时候设置两个工作变量`currentMin`和`currentMax`作为数组中的第一个`Int`值.然后函数会遍历数组中剩余的值并检查该值是否比`currentMin`和`currentMax`更小或更大.最后数组中的最小值与最大值返回两个`Int`值最为一个元组.
+`minMax(_:)`的函数体中，在开始的时候设置两个工作变量`currentMin`和`currentMax`作为数组中的第一个`Int`值。然后函数会遍历数组中剩余的值并检查该值是否比`currentMin`和`currentMax`更小或更大。最后数组中的最小值与最大值返回两个`Int`值最为一个元组。
 
 因为元组的成员值被命名为函数的返回类型的一部分​​，可以通过点语法来访问与取回发现的最小值与最小值:
 
@@ -197,14 +197,14 @@ print("min is \(bounds.min) and max is \(bounds.max)")
 
 可选元组返回类型(Optional Tuple Return Types)
 
-如果函数返回的元组类型中有可能在整个元组中含有“没有值”，你可以使用*可选的(Optional)* 元组返回类型反映整个元组可以是`nil`的事实.你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组,例如`(Int,Int)?`或`(String,Int,Bool)?`
+如果函数返回的元组类型中有可能在整个元组中含有“没有值”，你可以使用*可选的(Optional)* 元组返回类型反映整个元组可以是`nil`的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如`(Int,Int)?`或`(String,Int,Bool)?`
 
 > 注意:
-> 可选元组类型如`(Int,Int)?`与元组包含可选属性如`(Int?,Int?)`是不同的.可选的元组类型，整个数组是可选的，而不只是元组中的每个元素值.
+> 可选元组类型如`(Int,Int)?`与元组包含可选属性如`(Int?,Int?)`是不同的.可选的元组类型，整个数组是可选的，而不只是元组中的每个元素值。
 
-前面的`minMax(_:)`函数返回了一个包含两个`Int`值的元组.但是函数不会在数组中执行任何安全检查,如果`array`参数有一个空数组,如上定义的`minMax(_:)`在试图访问`array[0]`时会触发一个运行时错误.
+前面的`minMax(_:)`函数返回了一个包含两个`Int`值的元组。但是函数不会在数组中执行任何安全检查，如果`array`参数有一个空数组，如上定义的`minMax(_:)`在试图访问`array[0]`时会触发一个运行时错误。
 
-为了安全的处理这个"空数组"问题,写一个`minMax(_:)`函数使用可选元组返回类型,并且当数组为空时返回`nil`:
+为了安全的处理这个"空数组"问题，写一个`minMax(_:)`函数使用可选元组返回类型，并且当数组为空时返回`nil`:
 
 ```swift
 func minMax(array: [Int]) -> (min: Int, max: Int)? {
@@ -234,7 +234,7 @@ if let bounds = minMax([8, -6, 2, 109, 3, 71]) {
 <a name="Function_Parameter_Names"></a>
 ## 函数参数名称（Function Parameter Names）
 
-函数参数都有一个*外部参数名(external parameter name)*和一个*本地参数名(local parameter name)*.外部参数名用来标记传递给函数调用的参数,本地参数名在实现函数的时候使用.
+函数参数都有一个*外部参数名(external parameter name)*和一个*本地参数名(local parameter name)*。外部参数名用来标记传递给函数调用的参数，本地参数名在实现函数的时候使用。
 
 ```swift
 func someFunction(firstParameterName: Int, secondParameterName: Int) {
@@ -245,12 +245,12 @@ func someFunction(firstParameterName: Int, secondParameterName: Int) {
 someFunction(1, secondParameterName: 2)
 ```
 
-一般情况下,第一个参数省略其外部参数名,第二个以后的参数使用其本地参数名作为自己的外部参数名.所有参数需要有不同的本地参数名,但可以共享相同的外部参数名.
+一般情况下，第一个参数省略其外部参数名，第二个以后的参数使用其本地参数名作为自己的外部参数名。所有参数需要有不同的本地参数名，但可以共享相同的外部参数名。
 
 <a name="specifying_external_parameter_names"></a>
 ### 指定外部参数名(Specifying External Parameter Names)
 
-你可以在本地参数名前指定外部参数名,中间以空格分隔.
+你可以在本地参数名前指定外部参数名，中间以空格分隔。
 
 ```swift
 func someFunction(externalParameterName localParameterName: Int) {
@@ -259,10 +259,10 @@ func someFunction(externalParameterName localParameterName: Int) {
 }
 ```
 
-> 注意:
+> 注意：
 > 如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。
 
-这个版本的`sayHello(_:)`函数,得到了两个人的名字,会同时返回对他俩的问候:
+这个版本的`sayHello(_:)`函数，得到了两个人的名字，会同时返回对他俩的问候：
 
 ```swift
 func sayHello(to person: String, and anotherPerson: String) -> String {
@@ -272,13 +272,13 @@ print(sayHello(to: "Bill", and: "Ted"))
 // prints "Hello Bill and Ted!"
 ```
 
-为每个参数指定外部参数名,在你调用函数`sayHello(to:and:)`函数时时两个参数都必须被标记出来.
+为每个参数指定外部参数名，在你调用函数`sayHello(to:and:)`函数时时两个参数都必须被标记出来。
 
-使用外部函数名可以使得函数可以用一句话表达清楚,并且使得函数体内部可读,能表达出函数的明确意图.
+使用外部函数名可以使得函数可以用一句话表达清楚，并且使得函数体内部可读，能表达出函数的明确意图。
 
 ### 忽略外部参数名(Omitting External Parameter Names)
 
-如果你不想为第二个及后续的参数设置参数名,用一个下划线(_)代替一个明确地参数名.
+如果你不想为第二个及后续的参数设置参数名，用一个下划线(`_`)代替一个明确地参数名。
 
 ```swift
 func someFunction(firstParameterName: Int, _ secondParameterName: Int) {
@@ -314,7 +314,7 @@ someFunction() // parameterWithDefault is 12
 
 一个`可变参数（variadic parameter）`可以接受零个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入`（...）`的方式来定义可变参数。
 
-传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做 `numbers` 的 `Double...` 型可变参数，在函数体内可以当做一个叫 `numbers` 的 `Double[]` 型的数组常量。
+可变参数的传入值在函数体为此类型的一个数组。例如，一个叫做 `numbers` 的 `Double...` 型可变参数，在函数体内可以当做一个叫 `numbers` 的 `Double[]` 型的数组常量。
 
 下面的这个函数用来计算一组任意长度数字的`算术平均数(arithmetic mean)`：
 
@@ -333,8 +333,8 @@ arithmeticMean(3, 8.25, 18.75)
 ```
 
 > 注意：
-> 最多可以有一个可变参数函数,和它必须出现在参数列表中,为了避免歧义在调用函数有多个参数。
-> 如果你的函数有一个或多个参数有默认值,还有一个可变的参数,将可变参写在参数列表的最后。
+> 最多可以有一个可变参数函数，和它必须出现在参数列表中，为了避免歧义在调用函数有多个参数。
+> 如果你的函数有一个或多个参数有默认值，还有一个可变的参数，将可变参写在参数列表的最后。
 
 如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后。
 
@@ -370,11 +370,11 @@ let paddedString = alignRight(originalString, totalLength: 10, pad: "-")
 
 　函数首先找出有多少字符需要被添加到左边的字符串以右对齐在整个字符串。这个值是存储在一个本地常数称为amountToPad。如果不需要填充(也就是说,如果amountToPad小于1),该函数返回字符串没有填充的输入值。
 　　
-　　否则,该函数创建一个新的临时字符串常量称为padString,初始化填充字符,并将amountToPad padString副本添加到现有的左边的字符串。(一个字符串值不能被添加到一个字符值,所以padString常数用于确保双方+操作符的字符串值)。
+　　否则,该函数创建一个新的临时字符串常量称为padString，初始化填充字符，并将amountToPad padString副本添加到现有的左边的字符串。(一个字符串值不能被添加到一个字符值，所以padString常数用于确保双方+操作符的字符串值)。
 
-该函数首先计算出多少个字符需要被添加到 `string` 的左边，以右对齐到总的字符串中。这个值存在局部常量 `amountToPad` 中。如果不需要填充(即,如果`amountToPad`小于`1`),该函数返回没有填充输入的`string`.
+该函数首先计算出多少个字符需要被添加到 `string` 的左边，以右对齐到总的字符串中。这个值存在局部常量 `amountToPad` 中。如果不需要填充(即，如果`amountToPad`小于`1`)，该函数返回没有填充输入的`string`。
 
-否则,该函数会建立一个临时的String常量称为`padString`,初始化`pad`字符,并将`amountToPad`作为`padString`的副本添加到现有的字符串左边.(一个`Character`后不能直接添加一个`String`值,所以`padString`经常用于确保`+`号两边都是`String`值.)
+否则，该函数会建立一个临时的String常量称为`padString`，初始化`pad`字符,并将`amountToPad`作为`padString`的副本添加到现有的字符串左边。(一个`Character`后不能直接添加一个`String`值，所以`padString`经常用于确保`+`号两边都是`String`值。)
 
 > 注意：
 > 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。
@@ -436,7 +436,7 @@ func multiplyTwoInts(a: Int, _ b: Int) -> Int {
 
 这个例子中定义了两个简单的数学函数：`addTwoInts` 和 `multiplyTwoInts`。这两个函数都传入两个 `Int` 类型， 返回一个合适的`Int`值。
 
-这两个函数的类型是 `(Int, Int) -> Int`，可以读作“这个函数类型，它有两个 `Int` 型的参数并返回一个 `Int` 型的值。”。
+这两个函数的类型是 `(Int, Int) -> Int`，可以读作”这个函数类型，它有两个 `Int` 型的参数并返回一个 `Int` 型的值。”。
 
 下面是另一个例子，一个没有参数，也没有返回值的函数：
 

From acc04c60ffe034f007bb61840373d9228c2bff13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Fri, 25 Sep 2015 11:06:58 +0800
Subject: [PATCH 215/228] Typo.

---
 source/chapter2/07_Closures.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 6c07f830..ae7d5235 100755
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -67,7 +67,7 @@ let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 
 该例子对一个`String`类型的数组进行排序，因此排序闭包函数类型需为`(String, String) -> Bool`。
 
-提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`ssort(_:)`方法的参数传入：
+提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`sort(_:)`方法的参数传入：
 
 ```swift
 func backwards(s1: String, s2: String) -> Bool {

From a6622014688a07e18f9c3ff7924c6d872a3a2e9a Mon Sep 17 00:00:00 2001
From: sunorry <sunorry@gmail.com>
Date: Fri, 25 Sep 2015 22:41:57 +0800
Subject: [PATCH 216/228] =?UTF-8?q?=E6=9B=B4=E6=96=B02.0=E6=94=B9=E5=8A=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/01_The_Basics.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index c4f7d6f6..0a21b78b 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -638,12 +638,13 @@ if let actualNumber = Int(possibleNumber) {
 
 你可以在可选绑定中使用常量和变量。如果你想在`if`语句的第一个分支中操作`actualNumber`的值，你可以改成`if var actualNumber`，这样可选类型包含的值就会被赋给一个变量而非常量。
 
-多个可选绑定可以用逗号分隔，作为一列表达式出现在一个`if`语句中。
+你可以包含多个可选绑定在`if`语句中，并使用`where`子句做布尔值判断。
 
 ```swift
-if let constantName = someOptional, anotherConstantName = someOtherOptional {
-    statements
+if let firstNumber = Int("4"), secondNumber = Int("42") where firstNumber < secondNumber {
+    print("\(firstNumber) < \(secondNumber)")
 }
+// prints "4 < 42"
 ```
 
 <a name="implicityly_unwrapped_optionals"></a>

From 3e6d27f20cb242359d4a227e5103b12d9dd5430d Mon Sep 17 00:00:00 2001
From: sunorry <sunorry@gmail.com>
Date: Sat, 26 Sep 2015 00:34:28 +0800
Subject: [PATCH 217/228] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/03_Strings_and_Characters.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 54f8116b..2313f2bb 100755
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -291,7 +291,7 @@ print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
 
 注意在 Swift 中，使用可拓展的字符群集作为`Character`值来连接或改变字符串时，并不一定会更改字符串的字符数量。
 
-例如，如果你用四个字符的单词`cafe`初始化一个新的字符串，然后添加一个`COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是`4`，因为第四个字符是`e`，而不是`e`：
+例如，如果你用四个字符的单词`cafe`初始化一个新的字符串，然后添加一个`COMBINING ACTUE ACCENT`(`U+0301`)作为字符串的结尾。最终这个字符串的字符数量仍然是`4`，因为第四个字符是`é`，而不是`e`：
 
 ```swift
 var word = "cafe"

From 0bd071860e422d394416fd8bde6b34cd9642e67f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Sun, 27 Sep 2015 00:10:28 +0800
Subject: [PATCH 218/228] Typo.

---
 source/chapter2/06_Functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 5057346b..d4054682 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -181,7 +181,7 @@ func minMax(array: [Int]) -> (min: Int, max: Int) {
 }
 ```
 
-`minMax(_:)`函数返回一个包含两个`Int`值的元组，这些值被标记为`min`和`max`，一遍查询函数的返回值时他们可以被访问。
+`minMax(_:)`函数返回一个包含两个`Int`值的元组，这些值被标记为`min`和`max`，以便查询函数的返回值时他们可以被访问。
 
 `minMax(_:)`的函数体中，在开始的时候设置两个工作变量`currentMin`和`currentMax`作为数组中的第一个`Int`值。然后函数会遍历数组中剩余的值并检查该值是否比`currentMin`和`currentMax`更小或更大。最后数组中的最小值与最大值返回两个`Int`值最为一个元组。
 

From e48f50857ec9e0347a2595e8b2e99e0b3b7f599f Mon Sep 17 00:00:00 2001
From: Zee Ma <ericma96@outlook.com>
Date: Sun, 27 Sep 2015 15:19:46 +0800
Subject: [PATCH 219/228] Wrong Number

---
 source/chapter2/06_Functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 5057346b..3d7c8c10 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -301,7 +301,7 @@ someFunction(1, 2)
 func someFunction(parameterWithDefault: Int = 12) {
     // function body goes here
     // if no arguments are passed to the function call,
-    // value of parameterWithDefault is 42
+    // value of parameterWithDefault is 12
 }
 someFunction(6) // parameterWithDefault is 6
 someFunction() // parameterWithDefault is 12

From 822af8110c21b3e9ea45984b487d68a509e641d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Mon, 28 Sep 2015 16:19:49 +0800
Subject: [PATCH 220/228] =?UTF-8?q?`#`=20=E5=8F=B7=E5=9C=A82.0=E4=B8=AD?=
 =?UTF-8?q?=E5=B7=B2=E7=BB=8F=E7=A7=BB=E9=99=A4=E4=BA=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 source/chapter2/11_Methods.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index ff1db826..79cbd413 100755
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -96,7 +96,7 @@ counter.incrementBy(5, numberOfTimes: 3)
 <a name="modifying_external_parameter_name_behavior_for_methods"></a>
 ### 修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)
 
-有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（`#`）作为第一个参数的前缀来把这个局部名称当作外部名称使用。
+有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称作为第一个参数的前缀来把这个局部名称当作外部名称使用。
 
 相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（`_`）作为该参数的显式外部名称，这样做将覆盖默认行为。
 

From cb8c5ce951fb2b93c2883ae44762ab321a301b9f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Mon, 28 Sep 2015 16:41:52 +0800
Subject: [PATCH 221/228] Typo.

---
 source/chapter2/12_Subscripts.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index 8b33727f..a09466c4 100755
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -1,6 +1,6 @@
 # 下标脚本（Subscripts）
------------------
-
+-----------------
+
 > 1.0
 > 翻译：[siemenliu](https://github.com/siemenliu)
 > 校对：[zq54zquan](https://github.com/zq54zquan)
@@ -92,7 +92,7 @@ numberOfLegs["bird"] = 2
 
 下标脚本允许任意数量的入参索引，并且每个入参类型也没有限制。下标脚本的返回值也可以是任何类型。下标脚本可以使用变量参数和可变参数，但使用写入读出（in-out）参数或给参数设置默认值都是不允许的。
 
-一个类或结构体可以根据自身需要提供多个下标脚本实现，在定义下标脚本时通过入参个类型进行区分，使用下标脚本时会自动匹配合适的下标脚本实现运行，这就是*下标脚本的重载*。
+一个类或结构体可以根据自身需要提供多个下标脚本实现，在定义下标脚本时通过入参的类型进行区分，使用下标脚本时会自动匹配合适的下标脚本实现运行，这就是*下标脚本的重载*。
 
 一个下标脚本入参是最常见的情况，但只要有合适的场景也可以定义多个下标脚本入参。如下例定义了一个`Matrix`结构体，将呈现一个`Double`类型的二维矩阵。`Matrix`结构体的下标脚本需要两个整型参数：
 

From 49db0dac2f53b5f1fc168df0e3f5d79acfc188ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Mon, 28 Sep 2015 18:33:18 +0800
Subject: [PATCH 222/228] Typo.

---
 source/chapter2/18_Error_Handling.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/chapter2/18_Error_Handling.md b/source/chapter2/18_Error_Handling.md
index f2c7c768..33d29562 100644
--- a/source/chapter2/18_Error_Handling.md
+++ b/source/chapter2/18_Error_Handling.md
@@ -6,7 +6,7 @@
 
 错误处理是响应错误以及从错误中返回的过程。swift提供第一类错误支持，包括在运行时抛出，捕获，传送和控制可回收错误。
 
-一些函数和方法不能总保证能够执行所有代码或产生有用的输出。可空类型用来表示值可能为空，但是当函数执行失败的事后，可空通常可以用来确定执行失败的原因，因此代码可以正确地响应失败。在Swift中，这叫做抛出函数或者抛出方法。
+一些函数和方法不能总保证能够执行所有代码或产生有用的输出。可空类型用来表示值可能为空，但是当函数执行失败的时候，可空通常可以用来确定执行失败的原因，因此代码可以正确地响应失败。在Swift中，这叫做抛出函数或者抛出方法。
 
 举个例子，考虑到一个从磁盘上的一个文件读取以及处理数据的任务，有几种情况可能会导致这个任务失败，包括指定路径的文件不存在，文件不具有可读属性，或者文件没有被编码成合适的格式。区分这些错误可以让程序解决并且修复这些错误，并且，如果可能的话，把这些错误报告给用户。
 
@@ -35,7 +35,7 @@ enum VendingMachineError: ErrorType {
 
 <a name="throwing_errors"></a>
 错误抛出
-通过在函数或方法声明的参数后面加上`throws`关键字，表明这个函数或方法可以抛出错误。如果指定一个返回值，可以把`throws`关键字放在返回箭头(->)的前面。除非明确地指出，一个函数，方法或者就闭包不能抛出错误。
+通过在函数或方法声明的参数后面加上`throws`关键字，表明这个函数或方法可以抛出错误。如果指定一个返回值，可以把`throws`关键字放在返回箭头(->)的前面。除非明确地指出，一个函数，方法或者闭包就不能抛出错误。
 
 ```swift
 func canThrowErrors() throws -> String
@@ -174,4 +174,4 @@ func processFile(filename: String) throws {
 }
 ```
 
-上面这个例子使用了`defer`语句来保证`open`有对应的`close`。这个调用不管是否有抛出都会执行。
\ No newline at end of file
+上面这个例子使用了`defer`语句来保证`open`有对应的`close`。这个调用不管是否有抛出都会执行。

From bde321c188fa3dea531918bc250e2ac8dd6d40bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Mon, 28 Sep 2015 18:45:14 +0800
Subject: [PATCH 223/228] Style.

---
 source/chapter2/19_Type_Casting.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/19_Type_Casting.md b/source/chapter2/19_Type_Casting.md
index 969aac86..538a53ad 100644
--- a/source/chapter2/19_Type_Casting.md
+++ b/source/chapter2/19_Type_Casting.md
@@ -16,7 +16,7 @@
 - [`Any`和`AnyObject`的类型转换](#type_casting_for_any_and_anyobject)
 
 
-_类型转换_可以判断实例的类型，也可以将实例看做是其父类或者子类的实例。
+_类型转换_ 可以判断实例的类型，也可以将实例看做是其父类或者子类的实例。
 
 类型转换在 Swift 中使用 `is` 和 `as` 操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
 

From a8f2162d5be031d08e4beeeb6f8f5ba173d9cba0 Mon Sep 17 00:00:00 2001
From: Ya Zhuang <zhuangya@users.noreply.github.com>
Date: Mon, 28 Sep 2015 20:17:10 +0800
Subject: [PATCH 224/228] typo: errow => error

---
 source/chapter2/01_The_Basics.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 0a21b78b..5dd92c6d 100755
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -703,7 +703,7 @@ if let definiteString = assumedString {
 当一个函数遇到错误条件，它能报错。调用函数的地方能抛出错误消息并合理处理。
 
 ```swift
-func canThrowAnErrow() throws {
+func canThrowAnError() throws {
     // 这个函数有可能抛出错误
 }
 ```
@@ -712,7 +712,7 @@ func canThrowAnErrow() throws {
 
 ```swift
 do {
-    try canThrowAnErrow()
+    try canThrowAnError()
     // 没有错误消息抛出
 } catch {
     // 有一个错误消息抛出

From 1f162f2703e0be040f41821431809db13f073e7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Mon, 28 Sep 2015 21:50:43 +0800
Subject: [PATCH 225/228] Style.

---
 source/chapter2/20_Nested_Types.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/chapter2/20_Nested_Types.md b/source/chapter2/20_Nested_Types.md
index cec975a3..18dfc46d 100755
--- a/source/chapter2/20_Nested_Types.md
+++ b/source/chapter2/20_Nested_Types.md
@@ -69,8 +69,8 @@ struct BlackjackCard {
 
 如上文所提到的，枚举型`Rank`在自己内部定义了一个嵌套结构体`Values`。在这个结构体中，只有`Ace`有两个数值，其余牌都只有一个数值。结构体`Values`中定义的两个属性：
 
-`first`, 为` Int`
-`second`, 为 `Int?`, 或 “optional `Int`”
+- `first`为` Int`
+- `second`为 `Int?` 或 “optional `Int`”
 
 `Rank`定义了一个计算属性`values`，它将会返回一个结构体`Values`的实例。这个计算属性会根据牌的面值，用适当的数值去初始化`Values`实例，并赋值给`values`。对于`J`,`Q`,`K`,`Ace`会使用特殊数值，对于数字面值的牌使用`Int`类型的值。
 

From 0d0a9e863793f9bf788a30bf0bb2f64e214ca511 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Mon, 28 Sep 2015 22:07:47 +0800
Subject: [PATCH 226/228] Remove `TODO`

---
 source/chapter2/21_Extensions.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index 837b46ae..ce4d73f9 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -28,7 +28,6 @@ Swift 中的扩展可以：
 - 定义和使用新的嵌套类型
 - 使一个已有类型符合某个协议
 
-TODO：
 在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./22_Protocols.html#protocol_extensions)获取更多的细节。
 
 >注意：  

From 99d396bc784c5aef6887b0ae3d1ff9ff364a29de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Mon, 28 Sep 2015 23:07:37 +0800
Subject: [PATCH 227/228] Update 21_Extensions.md

---
 source/chapter2/21_Extensions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/21_Extensions.md b/source/chapter2/21_Extensions.md
index ce4d73f9..47770030 100644
--- a/source/chapter2/21_Extensions.md
+++ b/source/chapter2/21_Extensions.md
@@ -28,7 +28,7 @@ Swift 中的扩展可以：
 - 定义和使用新的嵌套类型
 - 使一个已有类型符合某个协议
 
-在 Swift 中，你甚至可以对一个协议(Procotol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./22_Protocols.html#protocol_extensions)获取更多的细节。
+在 Swift 中，你甚至可以对一个协议(Protocol)进行扩展，提供协议需要的实现，或者添加额外的功能能够对合适的类型带来额外的好处。你可以从[协议扩展](./22_Protocols.html#protocol_extensions)获取更多的细节。
 
 >注意：  
 扩展可以对一个类型添加新的功能，但是不能重写已有的功能。

From 5769c284678514c00c5bc726dc3322bb79a1b346 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=AE=89=E6=AD=A3=E8=B6=85?= <anzhengchao@gmail.com>
Date: Thu, 1 Oct 2015 00:39:13 +0800
Subject: [PATCH 228/228] Typo.

For #491
---
 source/chapter2/06_Functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index 310c1100..e19c202d 100755
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -314,7 +314,7 @@ someFunction() // parameterWithDefault is 12
 
 一个`可变参数（variadic parameter）`可以接受零个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入`（...）`的方式来定义可变参数。
 
-可变参数的传入值在函数体为此类型的一个数组。例如，一个叫做 `numbers` 的 `Double...` 型可变参数，在函数体内可以当做一个叫 `numbers` 的 `Double[]` 型的数组常量。
+可变参数的传入值在函数体为此类型的一个数组。例如，一个叫做 `numbers` 的 `Double...` 型可变参数，在函数体内可以当做一个叫 `numbers` 的 `[Double]` 型的数组常量。
 
 下面的这个函数用来计算一组任意长度数字的`算术平均数(arithmetic mean)`：