Merge pull request #87 from wh1100717/develop

Refine: Closures && Strings and Characters

source/chapter2/03_Strings_and_Characters.md

@@ -1,5 +1,7 @@
 # 字符串和字符 (Strings and Characters)
 
+----
+
 本页包含内容：
 
 -   字符串字面量
@@ -14,8 +16,6 @@
 -   字符串大小写
 -   Unicode
 
----
-
 **String** 是例如 "hello, world", "海贼王" 这样的有序的 **Character** (字符) 类型的值的集合，通过 **String** 类型来表示。
 
 Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
@@ -29,19 +29,19 @@ Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 U
 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)。
+>更多关于在 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)(**章节信息url需要替换**)。
+
+<a name="string_literals"></a>
+### 字符串字面量 (String Literals)
 
 ---
 
-### 字符串字面量
-
 您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。
 字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
 
@@ -52,7 +52,6 @@ let someString = "Some string literal value"
 ```
 
 > 注意：
->
 > `someString`变量通过字符串字面量进行初始化，Swift 因此推断该变量为 **String** 类型。
 
 字符串字面量可以包含以下特殊字符：
@@ -74,9 +73,10 @@ let blackHeart = "\u2665"      		// ♥,  Unicode 标量 U+2665
 let sparklingHeart = "\U0001F496"	// 💖, Unicode 标量 U+1F496
 ```
 
----
+<a name="initializing_an_empty_string"></a>
+### 初始化空字符串 (Initializing an Empty String)
 
-### 初始化空字符串
+---
 
 为了构造一个很长的字符串，可以创建一个空字符串作为初始值。
 可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
@@ -96,9 +96,10 @@ if emptyString.isEmpty {
 // 输出 "什么都没有"
 ```
 
----
+<a name="string_mutability"></a>
+### 字符串可变性 (String Mutability)
 
-### 字符串可变性
+---
 
 您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
 
@@ -112,21 +113,20 @@ constantString += " and another Highlander"
 ```
 
 > 注意：
->
 > 在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。
 
----
+<a name="strings_are_value_types"></a>
+### 字符串是值类型 (Strings Are Value Types)
 
-### 字符串是值类型
+---
 
 Swift 的 **String** 类型是值类型。
 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。
 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。
-值类型在 [Structures and Enumerations Are Value Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_104) 中进行了说明。
+值类型在 [Structures and Enumerations Are Value Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_104)(**章节信息URL需要替换**) 中进行了说明。
 
 > 注意：
->
+> 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
-> 与 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该 NSString 实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
 
 Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。
 很明显无论该值来自于哪里，都是您独自拥有的。
@@ -134,13 +134,14 @@ Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字
 
 在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。
 
----
+<a name="working_with_characters"></a>
+### 使用字符 (Working with Characters)
 
-### 使用字符(Characters)
+---
 
 Swift 的 **String** 类型表示特定序列的 **Character** (字符) 类型值的集合。
 每一个字符值代表一个 Unicode 字符。
-您可利用 for-in 循环来遍历字符串中的每一个字符：
+您可利用`for-in`循环来遍历字符串中的每一个字符：
 
 ```
 for character in "Dog!🐶" {
@@ -153,7 +154,7 @@ for character in "Dog!🐶" {
 // 🐶
 ```
 
-for-in 循环在[For Loops](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ControlFlow.html#//apple_ref/doc/uid/TP40014097-CH9-XID_154)中进行了详细描述。
+for-in 循环在[For Loops](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ControlFlow.html#//apple_ref/doc/uid/TP40014097-CH9-XID_154)(**章节信息URL需要替换**)中进行了详细描述。
 
 另外，通过标明一个 **Character** 类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量：
 
@@ -161,9 +162,10 @@ for-in 循环在[For Loops](https://developer.apple.com/library/prerelease/ios/d
 let yenSign: Character = "¥"
 ```
 
----
+<a name="counting_characters"></a>
+### 计算字符数量 (Counting Characters)
 
-### 计算字符数量
+---
 
 通过调用全局`countElements`函数，并将字符串作为参数进行传递，可以获取该字符串的字符数量。
 
@@ -174,20 +176,20 @@ println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
 ```
 
 > 注意：
->
 > 不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。
 > 所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。
 > 因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。
 > 如果您正在处理一个长字符串，需要注意`countElements`函数必须遍历字符串中的字符以精准计算字符串的长度。
 >
-> 另外需要注意的是通过 `countElements` 返回的字符数量并不总是与包含相同字符的 NSString 的 `length` 属性相同。
+> 另外需要注意的是通过`countElements`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。
-> NSString 的 `length` 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。
+> `NSString`的`length`属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。
-> 为了解决这个问题，NSString 的 `length` 属性在被 Swift的 **String** 访问时会成为 `utf16count`。
+> 为了解决这个问题，`NSString`的`length`属性在被 Swift 的 **String** 访问时会成为`utf16count`。
+
+<a name="concatenating_strings_and_characters"></a>
+### 连接字符串和字符 (Concatenating Strings and Characters)
 
 ---
 
-### 连接字符串和字符
-
 字符串和字符的值可以通过加法运算符 (`+`) 相加在一起并创建一个新的字符串值：
 
 ```
@@ -202,7 +204,7 @@ let characterPlusString = character1 + string1        // 等于 "!hello"
 let characterPlusCharacter = character1 + character2  // 等于 "!?"
 ```
 
-您也可以通过加法赋值运算符 (+=) 将一个字符串或者字符添加到一个已经存在字符串变量上：
+您也可以通过加法赋值运算符 (`+=`) 将一个字符串或者字符添加到一个已经存在字符串变量上：
 
 ```
 var instruction = "look over"
@@ -215,12 +217,12 @@ welcome += character1
 ```
 
 >注意：
->
 >您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
 
----
+<a name="string_interpolation"></a>
+### 字符串插值 (String Interpolation)
 
-### 字符串插值
+---
 
 字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。
 您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
@@ -239,16 +241,17 @@ let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"
 在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
 
 >注意：
->
 >您插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。
 
+<a name="comparing_strings"></a>
+### 比较字符串 (Comparing Strings)
+
 ---
 
-### 比较字符串
+Swift 提供了三种方式来比较字符串的值：字符串相等、前缀相等和后缀相等。
 
-Swift 提供了三种方式来比较字符串的值：字符串相等，前缀相等和后缀相等。
+<a name="string_equality"></a>
-
+##### 字符串相等 (String Equality)
-##### 字符串相等
 
 如果两个字符串以同一顺序包含完全相同的字符，则认为两者字符串相等：
 
@@ -261,13 +264,14 @@ if quotation == sameQuotation {
 // prints "这两个字符串被认为是相同的"
 ```
 
-##### 前缀/后缀相等
+<a name="prefix_and_suffix_equality"></a>
+##### 前缀/后缀相等 (Prefix and Suffix Equality)
 
 通过调用字符串的`hasPrefix`/`hasSuffix`方法来检查字符串是否拥有特定前缀/后缀。
 两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。
 两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
 
-下面的例子以一个字符串数组表示莎士比亚话剧 `罗密欧与朱丽叶` 中前两场的场景位置：
+下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
 
 ```
 let romeoAndJuliet = [
@@ -298,7 +302,8 @@ println("There are \(act1SceneCount) scenes in Act 1")
 // prints "There are 5 scenes in Act 1"
 ```
 
-##### 大写和小写字符串
+<a name="uppercase_and_lowercase_strings"></a>
+##### 大写和小写字符串 (Uppercase and Lowercase Strings)
 
 您可以通过字符串的`uppercaseString`和`lowercaseString`属性来访问大写/小写版本的字符串。
 
@@ -310,28 +315,31 @@ let whispered = normal.lowercaseString
 // whispered 值为 "could you help me, please?"
 ```
 
----
+<a name="unicode"></a>
-
 ### Unicode
 
+---
+
 Unicode 是一个国际标准，用于文本的编码和表示。
 它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
 
 Swift 的字符串和字符类型是完全兼容 Unicode 标准的，它支持如下所述的一系列不同的 Unicode 编码。
 
-###### Unicode 术语(Terminology)
+<a name="unicode_terminology"></a>
+###### Unicode 术语 (Unicode Terminology)
 
 Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
 字符的 unicode 标量是一个唯一的21位数字(和名称)，例如`U+0061`表示小写的拉丁字母A ("a")，`U+1F425`表示小幺鸡表情 ("🐥")
 
 当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括`UTF-8`(以8位代码单元进行编码) 和`UTF-16`(以16位代码单元进行编码)。
 
-##### 字符串的 Unicode 表示
+<a name="unicode_representations_of_strings"></a>
+##### 字符串的 Unicode 表示 (Unicode Representations of Strings)
 
 Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。
 
 您可以利用`for-in`来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。
-该过程在 [Working with Characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_376) 中进行了描述。
+该过程在 [Working with Characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_376)(**章节信息URL需要替换**) 中进行了描述。
 
 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
 
@@ -345,6 +353,7 @@ Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。
 let dogString = "Dog!🐶"
 ```
 
+<a name="UTF-8"></a>
 ##### UTF-8
 
 您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
@@ -361,6 +370,7 @@ print("\n")
 上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，他们的 UTF-8 表示与 ASCII 表示相同。
 后四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4位 UTF-8 表示。
 
+<a name="UTF-16"></a>
 ##### UTF-16
 
 您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
@@ -379,7 +389,8 @@ print("\n")
 第五和第六个代码单元值 (55357 and 56374) 是`DOG FACE`字符的UTF-16 表示。
 第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
 
-##### Unicode 标量 (Scalars)
+<a name="unicode_scalars"></a>
+##### Unicode 标量 (Unicode Scalars)
 
 您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。
 其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是`UnicodeScalar`的集合。
@@ -412,4 +423,3 @@ for scalar in dogString.unicodeScalars {
 // 🐶
 ```
 
-

source/chapter2/07_Closures.md

@@ -1,38 +1,42 @@
 # 闭包
 
+----
+
 本页内容包含：
 
 -   闭包表达式
--   Trailing闭包
+-   尾随闭包
 -   值捕获
 -   闭包是引用类型
 
-闭包是功能性自包含模块，可以在代码中被传递和使用。
+闭包是自包含的函数代码块，可以在代码中被传递和使用。
-Swift 中的闭包与 C 和 Objective-C 中的 `blocks` 以及其他一些编程语言中的 `lambdas` 比较相似。
+Swift 中的闭包与 C 和 Objective-C 中的`blocks` (代码块) 以及其他一些编程语言中的`lambdas` (匿名函数) 比较相似。
 
 闭包可以**捕获**和存储其所在上下文中任意常量和变量的引用。
-这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在 **捕获** 过程中涉及到的内存操作。
+这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在**捕获**过程中涉及到的所有内存操作。
 
 > 注意：
->
+> 如果您不熟悉**捕获** (capturing) 这个概念也不用担心，您可以在 [捕获值](#capturing_values) 章节对其进行详细了解。
-> 如果您不熟悉 **捕获** (capturing) 这个概念也不用担心，后面会详细对其进行介绍。
 
-在 `函数` 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
+在`函数` (**这里需要函数章节提供相应链接进行配合**) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
 
 *	全局函数是一个有名字但不会捕获任何值的闭包
 *	嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
-*	闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包
+*	闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包
 
 Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
 
 *	利用上下文推断参数和返回值类型
-*	单表达式闭包可以省略 `return` 关键字
+*	隐式返回单表达式闭包，即单表达式闭包可以省略`return`关键字
 *	参数名称缩写
-*	Trailing 闭包语法
+*	尾随 (Trailing) 闭包语法
 
-### 闭包表达式
+<a name="closure_expressions"></a>
+### 闭包表达式 (Closure Expressions)
 
-嵌套函数是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
+---
+
+嵌套函数 (**这里需要函数章节提供相应链接及锚点进行配合**) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
 当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
 
 闭包表达式是一种利用简洁语法构建内联闭包的方式。
@@ -40,9 +44,10 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
 下面闭包表达式的例子通过使用几次迭代展示了`sort`函数定义和语法优化的方式。
 每一次迭代都用更简洁的方式描述了相同的功能。
 
-##### `sort` 函数
+<a name="the_sort_function"></a>
+##### sort 函数 (The Sort Function)
 
-Swift 标准库提供了 `sort` 函数，会根据您提供的排序闭包将已知类型数组中的值进行排序。
+Swift 标准库提供了`sort`函数，会根据您提供的基于输出类型排序的闭包函数将已知类型数组中的值进行排序。
 一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
 
 下面的闭包表达式示例使用`sort`函数对一个 **String** 类型的数组进行字母逆序排序，以下是初始数组值：
@@ -51,27 +56,33 @@ Swift 标准库提供了 `sort` 函数，会根据您提供的排序闭包将已
 let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 ```
 
-该例子对一个 **String** 类型的数组进行排序，因此排序闭包需为 `(String, String) -> Bool` 类型的函数。
+`sort`函数需要传入两个参数：
 
-提供排序闭包的一种方式是撰写一个符合其类型要求的普通函数，并将其作为 `sort` 函数的第二个参数传入：
+*	已知类型的数组
+*	闭包函数，该闭包函数需要传入与数组类型相同的两个值，并返回一个布尔类型值来告诉`sort`函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回`true`，反之返回`false`。
+
+该例子对一个 **String** 类型的数组进行排序，因此排序闭包函数类型需为`(String, String) -> Bool`。
+
+提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`sort`函数的第二个参数传入：
 
 ```
 func backwards(s1: String, s2: String) -> Bool {
     return s1 > s2
 }
 var reversed = sort(names, backwards)
-// reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
+// reversed 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
 ```
 
-如果第一个字符串 (s1) 大于第二个字符串 (s2)，`backwards` 函数则返回 `true`，表示在新的数组中 s1 应该出现在 s2 前。
+如果第一个字符串 (`s1`) 大于第二个字符串 (`s2`)，`backwards`函数返回`true`，表示在新的数组中`s1`应该出现在`s2`前。
-字符中的 "大于" 表示 "按照字母顺序后出现"。
+对于字符串中的字符来说，"大于" 表示 "按照字母顺序较晚出现"。
-这意味着字母 "B" 大于字母 "A", 字符串 "Tom" 大于字符串 "Tim"。
+这意味着字母`"B"`大于字母`"A"`，字符串`"Tom"`大于字符串`"Tim"`。
-其将进行字母逆序排序，"Barry" 将会排在 "Alex" 之后。
+其将进行字母逆序排序，`"Barry"`将会排在`"Alex"`之后。
 
 然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。
 在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
 
-##### 闭包表达式语法
+<a name="closure_expression_syntax"></a>
+##### 闭包表达式语法 (Closure Expression Syntax)
 
 闭包表达式语法有如下一般形式：
 
@@ -81,8 +92,9 @@ var reversed = sort(names, backwards)
 }
 ```
 
-闭包表达式语法可以使用常量、变量和 `inout` 类型作为参数，不提供默认值。
+闭包表达式语法可以使用常量、变量和`inout` (**这里也需要函数章节提供相应链接和锚点进行配合**) 类型作为参数，不提供默认值。
-也可以在参数列表的最后使用可变参数。元组也可以作为参数和返回值。
+也可以在参数列表的最后使用可变参数。
+元组也可以作为参数和返回值。
 
 下面的例子展示了之前`backwards`函数对应的闭包表达式版本的代码：
 
@@ -93,7 +105,7 @@ reversed = sort(names, { (s1: String, s2: String) -> Bool in
 ```
 
 需要注意的是内联闭包参数和返回值类型声明与`backwards`函数类型声明相同。
-在这两种方式中，都写成了 (s1: String, s2: String) -> Bool。
+在这两种方式中，都写成了`(s1: String, s2: String) -> Bool`。
 然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。
 
 闭包的函数体部分由关键字`in`引入。
@@ -107,11 +119,12 @@ reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
 
 这说明`sort`函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于`backwards`版本的代码)。
 
-##### 根据上下文推断类型
+<a name="inferring_type_from_context"></a>
+##### 根据上下文推断类型 (Inferring Type From Context)
 
-因为排序闭包是作为函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
+因为排序闭包函数是作为`sort`函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
 `sort`期望第二个参数是类型为`(String, String) -> Bool`的函数，因此实际上`String`,`String`和`Bool`类型并不需要作为闭包表达式定义中的一部分。
-因为所有的类型都可以被正确推断，返回箭头 (->) 和 围绕在参数周围的括号也可以被省略：
+因为所有的类型都可以被正确推断，返回箭头 (`->`) 和围绕在参数周围的括号也可以被省略：
 
 ```
 reversed = sort(names, { s1, s2 in return s1 > s2 } )
@@ -119,7 +132,8 @@ reversed = sort(names, { s1, s2 in return s1 > s2 } )
 
 实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
 
-##### 单行表达式闭包可以省略 `return`
+<a name="implicit_returns_from_single_expression_closures"></a>
+##### 单表达式闭包隐式返回 (Implicit Return From Single-Expression Clossures)
 
 单行表达式闭包可以通过隐藏`return`关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
 
@@ -128,9 +142,10 @@ reversed = sort(names, { s1, s2 in s1 > s2 } )
 ```
 
 在这个例子中，`sort`函数的第二个参数函数类型明确了闭包必须返回一个 **Bool** 类型值。
-因为闭包函数体只包含了一个单一表达式 (s1 > s2)，该表达式返回 **Bool** 类型值，因此这里没有歧义，`return`关键字可以省略。
+因为闭包函数体只包含了一个单一表达式 (`s1 > s2`)，该表达式返回 **Bool** 类型值，因此这里没有歧义，`return`关键字可以省略。
 
-##### 参数名称缩写
+<a name="shorthand_argument_names"></a>
+##### 参数名称缩写 (Shorthand Argument Names)
 
 Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过`$0`,`$1`,`$2`来顺序调用闭包的参数。
 
@@ -143,10 +158,11 @@ reversed = sort(names, { $0 > $1 } )
 
 在这个例子中，`$0`和`$1`表示闭包中第一个和第二个 **String** 类型的参数。
 
-##### 运算符函数
+<a name="operator_functions"></a>
+##### 运算符函数 (Operator Functions)
 
 实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。
-Swift 的 **String** 类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个 **String** 类型的参数并返回 **Bool** 类型的值。
+Swift 的 **String** 类型定义了关于大于号 (`>`) 的字符串实现，其作为一个函数接受两个 **String** 类型的参数并返回 **Bool** 类型的值。
 而这正好与`sort`函数的第二个参数需要的函数类型相符合。
 因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
 
@@ -154,33 +170,35 @@ Swift 的 **String** 类型定义了关于大于号 (>) 的字符串实现，其
 reversed = sort(names, >)
 ```
 
-更多关于运算符表达式的内容请查看 [Operator Functions](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43) 。
+更多关于运算符表达式的内容请查看 [Operator Functions]() (**这里需要 Operator Functions 进行配合**)。
 
-### Trailing 闭包
+<a name="trailing_closures"></a>
+### 尾随闭包 (Trailing Closures)
 
-如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用 trailing 闭包来增强函数的可读性。
+---
-Trailing 闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。
+
+如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。
+尾随闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。
 
 ```
 func someFunctionThatTakesAClosure(closure: () -> ()) {
     // 函数体部分
 }
  
-// 以下是不使用 trailing 闭包进行函数调用
+// 以下是不使用尾随闭包进行函数调用
  
 someFunctionThatTakesAClosure({
     // 闭包主体部分
     })
  
-// 以下是使用 trailing 闭包进行函数调用
+// 以下是使用尾随闭包进行函数调用
 
 someFunctionThatTakesAClosure() {
 	// 闭包主体部分
 }
 ```
 > 注意：
->
+> 如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把 () 省略掉。
-> 如果函数只需要闭包表达式一个参数，当您使用 trailing 闭包时，您甚至可以把 () 省略掉。
 NOTE
 
 在上例中作为`sort`函数参数的字符串排序闭包可以改写为：
@@ -189,14 +207,14 @@ NOTE
 reversed = sort(names) { $0 > $1 }
 ```
 
-当闭包非常长以至于不能在一行中进行书写时，Trailing 闭包变得非常有用。
+当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。
 举例来说，Swift 的 **Array** 类型有一个`map`方法，其获取一个闭包表达式作为其唯一参数。
 数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。
 具体的映射方式和返回值类型由闭包来指定。
 
 当提供给数组闭包函数后，`map`方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
 
-下例介绍了如何在 `map` 方法中使用 trailing 闭包将 **Int** 类型数组 `[16,58,510]` 转换为包含对应 **String** 类型的数组 `["OneSix", "FiveEight", "FiveOneZero"]`:
+下例介绍了如何在`map`方法中使用尾随闭包将 **Int** 类型数组`[16,58,510]`转换为包含对应 **String** 类型的数组`["OneSix", "FiveEight", "FiveOneZero"]`:
 
 ```
 let digitNames = [
@@ -209,8 +227,8 @@ let numbers = [16, 58, 510]
 如上代码创建了一个数字位和他们名字映射的英文版本字典。
 同时定义了一个准备转换为字符串的整型数组。
 
-您现在可以通过传递一个 trailing 闭包给 `numbers` 的 `map` 方法来创建对应的字符串版本数组。
+您现在可以通过传递一个尾随闭包给`numbers`的`map`方法来创建对应的字符串版本数组。
-需要注意的时调用 `numbers.map` 不需要在 `map` 后面包含任何括号，因为其只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过 trailing 方式进行撰写：
+需要注意的时调用`numbers.map`不需要在`map`后面包含任何括号，因为其只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过尾随方式进行撰写：
 
 ```
 let strings = numbers.map {
@@ -229,17 +247,16 @@ let strings = numbers.map {
 `map`在数组中为每一个元素调用了闭包表达式。
 您不需要指定闭包的输入参数`number`的类型，因为可以通过要映射的数组类型进行推断。
 
-闭包 `number` 参数被声明为一个变量参数 (变量的具体描述请参看[Constant and Variable Parameters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-XID_224))，因此可以在闭包函数体内对其进行修改。
+闭包`number`参数被声明为一个变量参数 (变量的具体描述请参看[Constant and Variable Parameters]()(**这里需要Closure Expression Syntax进行配合**))，因此可以在闭包函数体内对其进行修改。
 闭包表达式制定了返回类型为 **String**，以表明存储映射值的新数组类型为 **String**。
 
 闭包表达式在每次被调用的时候创建了一个字符串并返回。
 其使用求余运算符 (number % 10) 计算最后一位数字并利用`digitNames`字典获取所映射的字符串。
 
 > 注意：
->
 > 字典`digitNames`下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。
 > 在上例中，它保证了`number % 10`可以总是作为一个`digitNames`字典的有效下标 key。
-> 因此叹号可以用于强制展开 (force-unwrap) 存储在可选下标项中的 **String** 类型值。
+> 因此叹号可以用于强制解析 (force-unwrap) 存储在可选下标项中的 **String** 类型值。
 
 从`digitNames`字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。
 (在表达式`number % 10`中，如果number为16，则返回6，58返回8，510返回0)。
@@ -248,11 +265,14 @@ let strings = numbers.map {
 因为其是整数，在计算过程中未除尽部分被忽略。
 因此 16变成了1，58变成了5，510变成了51。
 
-整个过程重复进行，直到 `number /= 10` 为0，这时闭包会将字符串输出，而map函数则会将字符串添加到所映射的数组中。
+整个过程重复进行，直到`number /= 10`为0，这时闭包会将字符串输出，而`map`函数则会将字符串添加到所映射的数组中。
 
-上例中 trailing 闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在 `map` 函数的括号内。
+上例中尾随闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在`map`函数的括号内。
 
-### 捕获 (Caputure)
+<a name="capturing_values"></a>
+### 捕获值 (Capturing Values)
+
+---
 
 闭包可以在其定义的上下文中捕获常量或变量。
 即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
@@ -279,7 +299,7 @@ func makeIncrementor(forIncrement amount: Int) -> () -> Int {
 `makeIncrementor`返回类型为`() -> Int`。
 这意味着其返回的是一个函数，而不是一个简单类型值。
 该函数在每次调用时不接受参数只返回一个 **Int** 类型的值。
-关于函数返回其他函数的内容，请查看[Function Types as Return Types](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-XID_232)。
+关于函数返回其他函数的内容，请查看[Function Types as Return Types]()(**需要函数章节进行配合**)。
 
 `makeIncrementor`函数定义了一个整型变量`runningTotal`(初始为0) 用来存储当前跑步总数。
 该值通过`incrementor`返回。
@@ -305,12 +325,11 @@ func incrementor() -> Int {
 然而，因为每次调用该函数的时候都会修改`runningTotal`的值，`incrementor`捕获了当前`runningTotal`变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当`makeIncrementor`结束时候并不会消失，也保证了当下一次执行`incrementor`函数时，`runningTotal`可以继续增加。
 
 > 注意：
->
 > Swift 会决定捕获引用还是拷贝值。
 > 您不需要标注`amount`或者`runningTotal`来声明在嵌入的`incrementor`函数中的使用方式。
 > Swift 同时也处理`runingTotal`变量的内存管理操作，如果不再被`incrementor`函数使用，则会被清除。
 
-下面为一个使用 `makeIncrementor` 的例子：
+下面代码为一个使用`makeIncrementor`的例子：
 
 ```
 let incrementByTen = makeIncrementor(forIncrement: 10)
@@ -340,12 +359,14 @@ incrementByTen()
 ```
 
 > 注意：
->
 > 如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
-> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [Strong Reference Cycles for Closures](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-XID_61)。
+> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [Strong Reference Cycles for Closures]()(**需要ARC章节进行配合**)。
 
+<a name="closures_are_reference_types"></a>
 ### 闭包是引用类型
 
+---
+
 上面的例子中，`incrementBySeven`和`incrementByTen`是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。
 这是因为函数和闭包都是引用类型。