Merge branch 'wh1100717-gh-pages' into gh-pages

README.md

@@ -12,7 +12,7 @@
 
 # 翻译进度
 
-> 说明：翻译中表示只完成了一部分，你可以接着翻译剩下的部分。认领表示有人认领了整章，如果你要进行认领的话请先pr并说明章节，谢谢。
+> 说明：翻译之前请先到PR列表中查看别人认领的内容，尽量不要重复，谢谢！
 
 * 欢迎使用 Swift
    * 关于 Swift(完成)
@@ -28,8 +28,8 @@
    * 枚举
    * 类和结构体(@JaySurplus 认领)
    * 属性(@shinyzhu 认领)
-   * 方法
+   * 方法(@pp-prog 认领)
-   * 下标
+   * 下标(@siemenliu 认领)
    * 继承
    * 构造过程(@lifedim 认领)
    * 析构过程(认领)

chapter1/02_a_swift_tour.html

@@ -743,7 +743,7 @@ sumOf(42, 597, 12)
 <p>函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。</p>
 <pre><code>func returnFifteen() -&gt; Int {
     var y = 10
-        func add() {
+    func add() {
         y += 5
     }
     add()
@@ -867,7 +867,7 @@ var triangle = EquilateralTriangle(sideLength: 3.1, name: &quot;a triangle&quot;
 triangle.perimeter
 triangle.perimeter = 9.9
 triangle.sideLength
-</code></pre><p>在<code>perimeter</code>的 setter 中，新值的名字是<code>newValue</code>。你可以在<code>set</code>之后显示的设置一个名字。</p>
+</code></pre><p>在<code>perimeter</code>的 setter 中，新值的名字是<code>newValue</code>。你可以在<code>set</code>之后显式的设置一个名字。</p>
 <p>注意<code>EquilateralTriangle</code>类的构造器执行了三步：</p>
 <ol>
 <li>设置子类声明的属性值</li>

chapter2/03_Strings_and_Characters.html

@@ -636,7 +636,7 @@ constantString += " and another Highlander"
 <p>Swift 的 <strong>String</strong> 类型是值类型。如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值。值类型在 <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/ClassesAndStructures.html#//apple_ref/doc/uid/TP40014097-CH13-XID_104" target="_blank">Structures and Enumerations Are Value Types</a> 中进行了说明。</p>
 <blockquote>
 <p>注意：</p>
-<p>其 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用。除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。</p>
+<p>与 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用。除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。</p>
 </blockquote>
 <p>Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值，其明确了无论该值来自于哪里，都是您独自拥有的。您可以放心您传递的字符串本身不会被更改。</p>
 <p>在实际编译时，Swift编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您始终可以将字符串作为值类型的同时获得极高的性能。</p>
@@ -743,7 +743,7 @@ let whispered = normal.lowercaseString
 <p>Unicode 是文本编码和表示的国际标准。它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。</p>
 <p>Swift 的字符串和字符类型是完全兼容 Unicode 的，它支持如下所述的一系列不同的 Unicode 编码。</p>
 <h6 id="unicode-terminology-">Unicode 术语(Terminology)</h6>
-<p>Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 <code>U+0061</code> 表示小写的拉丁字母A (&quot;a&quot;)，<code>U+1F425</code> 表示正面站立的鸡宝宝 (&quot;🐥&quot;)</p>
+<p>Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 <code>U+0061</code> 表示小写的拉丁字母A (&quot;a&quot;)，<code>U+1F425</code> 表示 (&quot;🐥&quot;)</p>
 <p>当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括 <code>UTF-8</code> (以8位代码单元进行编码) 和 <code>UTF-16</code> (以16位代码单元进行编码)。</p>
 <h5 id="-unicode-">字符串的 Unicode 表示</h5>
 <p>Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。</p>

source/chapter1/02_a_swift_tour.md

@@ -200,7 +200,7 @@
 
     func returnFifteen() -> Int {
         var y = 10
-            func add() {
+        func add() {
             y += 5
         }
         add()
@@ -345,7 +345,7 @@
     triangle.perimeter = 9.9
     triangle.sideLength
 
-在`perimeter`的 setter 中，新值的名字是`newValue`。你可以在`set`之后显示的设置一个名字。
+在`perimeter`的 setter 中，新值的名字是`newValue`。你可以在`set`之后显式的设置一个名字。
 
 注意`EquilateralTriangle`类的构造器执行了三步：
 

source/chapter2/03_Strings_and_Characters.md

@@ -1,22 +1,30 @@
 # 字符串和字符 (Strings and Characters)
 
-**String** 是一个有序的字符集合，例如 "hello, world", "albatross"。Swift 字符串通过 **String** 类型来表示，也可以表示为 **Character** 类型值的集合。
+**String** 是一个有序的字符集合，例如 "hello, world", "albatross"。
+Swift 字符串通过 **String** 类型来表示，也可以表示为 **Character** 类型值的集合。
 
-Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。创建和操作字符串的语法与 C的操作方式相似，轻量并且易读。字符串连接操作只需要简单地通过 `+` 号将两个字符串相连即可。与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
+Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
+创建和操作字符串的语法与 C的操作方式相似，轻量并且易读。
+字符串连接操作只需要简单地通过 `+` 号将两个字符串相连即可。
+与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
 
-尽管语法简易，但 **String** 类型是一种快速、现代化的字符串实现。每一个字符串都是由独立编码的 Unicode 字符组成，并提供了用于访问这些字符在不同的Unicode表示的支持。
+尽管语法简易，但 **String** 类型是一种快速、现代化的字符串实现。
+每一个字符串都是由独立编码的 Unicode 字符组成，并提供了用于访问这些字符在不同的Unicode表示的支持。
 
 **String** 也可以用于在常量、变量、字面量和表达式中进行字符串插值，这使得创建用于展示、存储和打印的字符串变得轻松自如。
 
 > 注意：
 > 
-> Swift 的 **String** 类型与 Foundation NSString 类进行了无缝桥接。如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作，整个 NSString API 都可以调用您创建的任意 String 类型的值，您额外还可以在任意 API 中使用本章介绍的 **String** 特性。您也可以在任意要求传入NSString 实例作为参数的 API 中使用 **String** 类型的值进行替换。
+> Swift 的 **String** 类型与 Foundation NSString 类进行了无缝桥接。
+> 如果您利用 Cocoa 或 Cocoa Touch 中的 Foundation 框架进行工作，整个 NSString API 都可以调用您创建的任意 String 类型的值，您额外还可以在任意 API 中使用本章介绍的 **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)。
 
 ### 字符串字面量
 
-您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号包裹着的具有固定顺序的文本字符集。
+您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。
+字符串字面量是由双引号包裹着的具有固定顺序的文本字符集。
 
 字符串字面量可以用于为常量和变量提供初始值。
 
@@ -49,7 +57,8 @@ let sparklingHeart = "\U0001F496"  // 💖, Unicode scalar U+1F496
 
 ### 初始化空字符串
 
-为了构造一个很长的字符串，可以创建一个空字符串作为初始值。可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
+为了构造一个很长的字符串，可以创建一个空字符串作为初始值。
+可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
 
 ```
 var emptyString = ""               // empty string literal
@@ -85,19 +94,25 @@ constantString += " and another Highlander"
 
 ### 字符串是值类型
 
-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) 中进行了说明。
+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) 中进行了说明。
 
 > 注意：
 >
-> 其 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用。除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。
+> 与 Cocoa 中的 NSString 不同，当您在 Cocoa 中创建了一个 NSString 实例，并将其传递给一个函数/方法，或者赋值给一个变量，您永远都是传递或赋值同一个 NSString 实例的一个引用，除非您特别要求其进行值拷贝，否则字符串不会进行赋值新副本操作。
 
-Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值，其明确了无论该值来自于哪里，都是您独自拥有的。您可以放心您传递的字符串本身不会被更改。
+Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值，其明确了无论该值来自于哪里，都是您独自拥有的。
+您可以放心您传递的字符串本身不会被更改。
 
 在实际编译时，Swift编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您始终可以将字符串作为值类型的同时获得极高的性能。
 
 #### 使用字符(Characters)
 
-Swift 的 **String** 类型表示特定序列的字符值的集合。每一个字符值代表一个 Unicode 字符。您可利用 for-in 循环来遍历字符串中的每一个字符：
+Swift 的 **String** 类型表示特定序列的字符值的集合。
+每一个字符值代表一个 Unicode 字符。
+您可利用 for-in 循环来遍历字符串中的每一个字符：
 
 ```
 for character in "Dog!🐶" {
@@ -128,11 +143,16 @@ println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
 // prints "unusualMenagerie has 40 characters"
 ```
 
->注意：
+> 注意：
 >
->不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储，所以Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此，字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意 `countElements` 函数必须遍历字符串中的字符以精准计算字符串的长度。
+> 不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。
+> 所以Swift 中的字符在一个字符串中并不一定占用相同的内存空间。
+> 因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。
+> 如果您正在处理一个长字符串，需要注意 `countElements` 函数必须遍历字符串中的字符以精准计算字符串的长度。
 >
->另外需要注意的是通过 `countElements` 返回的字符数量并不总是与包含相同字符的 NSString 的 `length` 属性相同。NSString 的 `length` 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，NSString 的 `length` 属性在被 Swift的 **String** 访问时会成为 `utf16count`。
+> 另外需要注意的是通过 `countElements` 返回的字符数量并不总是与包含相同字符的 NSString 的 `length` 属性相同。
+> NSString 的 `length` 属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。
+> 为了解决这个问题，NSString 的 `length` 属性在被 Swift的 **String** 访问时会成为 `utf16count`。
 
 ### 连接字符串和字符
 
@@ -168,7 +188,8 @@ welcome += character1
 
 ### 字符串插值
 
-字符串插值是一种全新的构建字符串的方式，可以在其中包含常量、变量、字面量和表达式。您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
+字符串插值是一种全新的构建字符串的方式，可以在其中包含常量、变量、字面量和表达式。
+您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
 
 ```
 let multiplier = 3
@@ -176,9 +197,12 @@ let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
 // message is "3 times 2.5 is 7.5"
 ```
 
-在上面的例子中，`multiplier` 作为 `\(multiplier)` 被插入到一个字符串字面量中。当创建字符串执行插值计算时此占位符会被替换为 `multiplier` 实际的值。
+在上面的例子中，`multiplier` 作为 `\(multiplier)` 被插入到一个字符串字面量中。
+当创建字符串执行插值计算时此占位符会被替换为 `multiplier` 实际的值。
 
-`multiplier` 的值也作为字符串中后面表达式的一部分。该表达式计算 `Double(multiplier) * 2.5` 的值并将结果 (7.5) 插入到字符串中。在这个例子中，表达式写为 `\(Double(multiplier) * 2.5)` 并包含在字符串字面量中。
+`multiplier` 的值也作为字符串中后面表达式的一部分。
+该表达式计算 `Double(multiplier) * 2.5` 的值并将结果 (7.5) 插入到字符串中。
+在这个例子中，表达式写为 `\(Double(multiplier) * 2.5)` 并包含在字符串字面量中。
 
 >注意：
 >
@@ -203,7 +227,9 @@ if quotation == sameQuotation {
 
 ##### 前缀/后缀相等
 
-通过调用字符串的 `hasPrefix`/`hasSuffix` 方法来检查字符串是否拥有特定前缀/后缀。两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
+通过调用字符串的 `hasPrefix`/`hasSuffix` 方法来检查字符串是否拥有特定前缀/后缀。
+两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。
+两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
 
 下面的例子以一个字符串数组表示莎士比亚话剧 `罗密欧与朱丽叶` 中前两场的场景位置：
 
@@ -250,13 +276,15 @@ let whispered = normal.lowercaseString
 
 ### Unicode
 
-Unicode 是文本编码和表示的国际标准。它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
+Unicode 是文本编码和表示的国际标准。
+它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
 
 Swift 的字符串和字符类型是完全兼容 Unicode 的，它支持如下所述的一系列不同的 Unicode 编码。
 
 ###### Unicode 术语(Terminology)
 
-Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 `U+0061` 表示小写的拉丁字母A ("a")，`U+1F425` 表示正面站立的鸡宝宝 ("🐥")
+Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
+字符的 unicode 标量是一个唯一的21位数字(和名称)，例如 `U+0061` 表示小写的拉丁字母A ("a")，`U+1F425` 表示小幺鸡表情 ("🐥")
 
 当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括 `UTF-8` (以8位代码单元进行编码) 和 `UTF-16` (以16位代码单元进行编码)。
 
@@ -264,7 +292,8 @@ Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
 
 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) 中进行了描述。
+您可以利用 `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) 中进行了描述。
 
 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
 
@@ -280,7 +309,8 @@ let dogString = "Dog!🐶"
 
 ##### UTF-8
 
-您可以通过遍历字符串的 `utf8` 属性来访问它的 `UTF-8` 表示。其为 **UTF8View** 类型的属性，**UTF8View** 是无符号8位 (`UInt8`) 值的集合，每一个 `UIn8` 都是一个字符的 UTF-8 表示：
+您可以通过遍历字符串的 `utf8` 属性来访问它的 `UTF-8` 表示。
+其为 **UTF8View** 类型的属性，**UTF8View** 是无符号8位 (`UInt8`) 值的集合，每一个 `UIn8` 都是一个字符的 UTF-8 表示：
 
 ```
 for codeUnit in dogString.utf8 {
@@ -290,11 +320,13 @@ print("\n")
 // 68 111 103 33 240 159 144 182
 ```
 
-上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-8 表示与 ASCII 表示相同。后四个代码单元值 (240, 159, 144, 182) 是 `狗脸表情` 的4位 UTF-8 表示。
+上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-8 表示与 ASCII 表示相同。
+后四个代码单元值 (240, 159, 144, 182) 是 `狗脸表情` 的4位 UTF-8 表示。
 
 ##### UTF-16
 
-您可以通过遍历字符串的 `utf16` 属性来访问它的 `UTF-16` 表示。其为 **UTF16View** 类型的属性，**UTF16View** 是无符号16位 (`UInt16`) 值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示：
+您可以通过遍历字符串的 `utf16` 属性来访问它的 `UTF-16` 表示。
+其为 **UTF16View** 类型的属性，**UTF16View** 是无符号16位 (`UInt16`) 值的集合，每一个 `UInt16` 都是一个字符的 UTF-16 表示：
 
 ```
 for codeUnit in dogString.utf16 {
@@ -306,11 +338,14 @@ print("\n")
 
 同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` ，他们的 UTF-16 代码单元和 UTF-8 完全相同。
 
-第五和第六个代码单元值 (55357 and 56374) 是 `狗脸表情` 字符的UTF-16 表示。第一个值为 `U+D83D` (十进制值为 55357)，第二个值为 `U+DC36` (十进制值为 56374)。
+第五和第六个代码单元值 (55357 and 56374) 是 `狗脸表情` 字符的UTF-16 表示。
+第一个值为 `U+D83D` (十进制值为 55357)，第二个值为 `U+DC36` (十进制值为 56374)。
 
 ##### Unicode 标量 (Scalars)
 
-您可以通过遍历字符串的 `unicodeScalars` 属性来访问它的 Unicode 标量表示。其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是 `UnicodeScalar` 的集合。`UnicodeScalar` 是21位的 Unicode 代码点。
+您可以通过遍历字符串的 `unicodeScalars` 属性来访问它的 Unicode 标量表示。
+其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是 `UnicodeScalar` 的集合。
+`UnicodeScalar` 是21位的 Unicode 代码点。
 
 每一个 `UnicodeScalar` 拥有一个值属性，可以返回对应的21位数值，用 `UInt32` 来表示。
 
@@ -322,7 +357,9 @@ print("\n")
 // 68 111 103 33 128054
 ```
 
-同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` 。第五位数值，128054，是一个十六进制1F436的十进制表示。其等同于 `狗脸表情` 的Unicode 标量 U+1F436。
+同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符 `D` `o` `g` 和 `!` 。
+第五位数值，128054，是一个十六进制1F436的十进制表示。
+其等同于 `狗脸表情` 的Unicode 标量 U+1F436。
 
 作为查询字符值属性的一种替代方法，每个 `UnicodeScalar` 值也可以用来构建一个新的字符串值，比如在字符串插值中使用：
 

source/chapter2/07_Closures.md

@@ -0,0 +1,358 @@
+# 闭包
+
+闭包是功能性自包含模块，可以在代码中被传递和使用。
+Swift 中的闭包与 C 和 Objective-C 中的 `blocks` 以及其他一些编程语言中的 `lambdas` 比较相似。
+
+闭包可以 **捕获** 和存储其所在上下文中任意常量和变量的引用。
+这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在 **捕获** 过程中涉及到的内存操作。
+
+> 注意：
+>
+> 如果您不熟悉 **捕获** (capturing) 这个概念也不用担心，后面会详细对其进行介绍。
+
+在 `函数` 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
+
+*	全局函数是一个有名字但不会捕获任何值的闭包
+*	嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
+*	闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包
+
+Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
+
+*	利用上下文推断参数和返回值类型
+*	单表达式闭包可以省略 `return` 关键字
+*	参数名称缩写
+*	Trailing 闭包语法
+
+### 闭包表达式
+
+嵌套函数是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
+当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
+
+闭包表达式是一种利用简洁语法构建内联闭包的方式。
+闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
+下面闭包表达式的例子通过使用几次迭代展示了 `sort` 函数定义和语法优化的方式。
+每一次迭代都用更简洁的方式描述了相同的功能。
+
+##### `sort` 函数
+
+Swift 标准库提供了 `sort` 函数，会根据您提供的排序闭包将已知类型数组中的值进行排序。
+一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
+
+下面的闭包表达式示例使用 `sort` 函数对一个 **String** 类型的数组进行字母逆序排序，以下是初始数组值：
+
+```
+let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
+```
+
+该例子对一个 **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"]
+```
+
+如果第一个字符串 (s1) 大于第二个字符串 (s2)，`backwards` 函数则返回 `true`，表示在新的数组中 s1 应该出现在 s2 前。
+字符中的 "大于" 表示 "按照字母顺序后出现"。
+这意味着字母 "B" 大于字母 "A", 字符串 "Tom" 大于字符串 "Tim"。
+其将进行字母逆序排序，"Barry" 将会排在 "Alex" 之后。
+
+然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。
+在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
+
+##### 闭包表达式语法
+
+闭包表达式语法有如下一般形式：
+
+```
+{ (parameters) -> returnType in
+    statements
+}
+```
+
+闭包表达式语法可以使用常量、变量和 `inout` 类型作为参数，不提供默认值。
+也可以在参数列表的最后使用可变参数。元组也可以作为参数和返回值。
+
+下面的例子展示了之前 `backwards` 函数对应的闭包表达式版本的代码：
+
+```
+reversed = sort(names, { (s1: String, s2: String) -> Bool in
+    return s1 > s2
+    })
+```
+
+需要注意的是内联闭包参数和返回值类型声明与 `backwards` 函数类型声明相同。
+在这两种方式中，都写成了 (s1: String, s2: String) -> Bool。
+然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。
+
+闭包的函数体部分由关键字 `in` 引入。
+该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。
+
+因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：
+
+```
+reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
+```
+
+这说明 `sort` 函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于 `backwards` 版本的代码)。
+
+##### 根据上下文推断类型
+
+因为排序闭包是作为函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
+`sort` 期望第二个参数是类型为 `(String, String) -> Bool` 的函数，因此实际上 `String`, `String` 和 `Bool` 类型并不需要作为闭包表达式定义中的一部分。
+因为所有的类型都可以被正确推断，返回箭头 (->) 和 围绕在参数周围的括号也可以被省略：
+
+```
+reversed = sort(names, { s1, s2 in return s1 > s2 } )
+```
+
+实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
+
+##### 单行表达式闭包可以省略 `return`
+
+单行表达式闭包可以通过隐藏 `return` 关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
+
+```
+reversed = sort(names, { s1, s2 in s1 > s2 } )
+```
+
+在这个例子中，`sort` 函数的第二个参数函数类型明确了闭包必须返回一个 **Bool** 类型值。
+因为闭包函数体只包含了一个单一表达式 (s1 > s2)，该表达式返回 **Bool** 类型值，因此这里没有歧义，`return`关键字可以省略。
+
+##### 参数名称缩写
+
+Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过 `$0`,`$1`,`$2` 来顺序调用闭包的参数。
+
+如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。
+`in` 关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：
+
+```
+reversed = sort(names, { $0 > $1 } )
+```
+
+在这个例子中，`$0` 和 `$1` 表示闭包中第一个和第二个 **String** 类型的参数。
+
+##### 运算符函数
+
+实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。
+Swift 的 **String** 类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个 **String** 类型的参数并返回 **Bool** 类型的值。
+而这正好与 `sort` 函数的第二个参数需要的函数类型相符合。
+因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
+
+```
+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) 。
+
+### Trailing 闭包
+
+如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用 trailing 闭包来增强函数的可读性。
+Trailing 闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。
+
+```
+func someFunctionThatTakesAClosure(closure: () -> ()) {
+    // 函数体部分
+}
+ 
+// 以下是不使用 trailing 闭包进行函数调用
+ 
+someFunctionThatTakesAClosure({
+    // 闭包主体部分
+    })
+ 
+// 以下是使用 trailing 闭包进行函数调用
+
+someFunctionThatTakesAClosure() {
+	// 闭包主体部分
+}
+```
+> 注意：
+>
+> 如果函数只需要闭包表达式一个参数，当您使用 trailing 闭包时，您甚至可以把 () 省略掉。
+NOTE
+
+在上例中作为 `sort` 函数参数的字符串排序闭包可以改写为：
+
+```
+reversed = sort(names) { $0 > $1 }
+```
+
+当闭包非常长以至于不能在一行中进行书写时，Trailing 闭包变得非常有用。
+举例来说，Swift 的 **Array** 类型有一个 `map` 方法，其获取一个闭包表达式作为其唯一参数。
+数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。
+具体的映射方式和返回值类型由闭包来指定。
+
+当提供给数组闭包函数后，`map` 方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
+
+下例介绍了如何在 `map` 方法中使用 trailing 闭包将 **Int** 类型数组 `[16,58,510]` 转换为包含对应 **String** 类型的数组 `["OneSix", "FiveEight", "FiveOneZero"]`:
+
+```
+let digitNames = [
+    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
+    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
+]
+let numbers = [16, 58, 510]
+```
+
+如上代码创建了一个数字位和他们名字映射的英文版本字典。
+同时定义了一个准备转换为字符串的整型数组。
+
+您现在可以通过传递一个 trailing 闭包给 `numbers` 的 `map` 方法来创建对应的字符串版本数组。
+需要注意的时调用 `numbers.map` 不需要在 `map` 后面包含任何括号，因为其只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过 trailing 方式进行撰写：
+
+```
+let strings = numbers.map {
+    (var number) -> String in
+    var output = ""
+    while number > 0 {
+        output = digitNames[number % 10]! + output
+        number /= 10
+    }
+    return output
+}
+// strings 常量被推断为字符串类型数组，即 String[]
+// 其值为 ["OneSix", "FiveEight", "FiveOneZero"]
+```
+
+`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))，因此可以在闭包函数体内对其进行修改。
+闭包表达式制定了返回类型为 **String**，以表明存储映射值的新数组类型为 **String**。
+
+闭包表达式在每次被调用的时候创建了一个字符串并返回。
+其使用求余运算符 (number % 10) 计算最后一位数字并利用 `digitNames` 字典获取所映射的字符串。
+
+> 注意：
+>
+> 字典 `digitNames` 下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。
+> 在上例中，它保证了 `number % 10` 可以总是作为一个 `digitNames` 字典的有效下标 key。
+> 因此叹号可以用于强制展开 (force-unwrap) 存储在可选下标项中的 **String** 类型值。
+
+从 `digitNames` 字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。
+(在表达式 `number % 10`中，如果number为16，则返回6，58返回8，510返回0)。
+
+`number` 变量之后除以10。
+因为其是整数，在计算过程中未除尽部分被忽略。
+因此 16变成了1，58变成了5，510变成了51。
+
+整个过程重复进行，直到 `number /= 10` 为0，这时闭包会将字符串输出，而map函数则会将字符串添加到所映射的数组中。
+
+上例中 trailing 闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在 `map` 函数的括号内。
+
+### 捕获 (Caputure)
+
+闭包可以在其定义的上下文中捕获常量或变量。
+即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
+
+Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。
+嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
+
+下例为一个叫做 `makeIncrementor` 的函数，其包含了一个叫做 `incrementor` 嵌套函数。
+嵌套函数 `incrementor` 从上下文中捕获了两个值，`runningTotal` 和 `amount`。
+之后 `makeIncrementor` 将 `incrementor` 作为闭包返回。
+每次调用 `incrementor` 时，其会以 `amount` 作为增量增加 `runningTotal` 的值。
+
+```
+func makeIncrementor(forIncrement amount: Int) -> () -> Int {
+    var runningTotal = 0
+    func incrementor() -> Int {
+        runningTotal += amount
+        return runningTotal
+    }
+    return incrementor
+}
+```
+
+`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)。
+
+`makeIncrementor` 函数定义了一个整型变量 `runningTotal` (初始为0) 用来存储当前跑步总数。
+该值通过 `incrementor` 返回。
+
+`makeIncrementor` 有一个 **Int** 类型的参数，其外部命名为 `forIncrement`， 内部命名为 `amount`，表示每次 `incrementor` 被调用时 `runningTotal` 将要增加的量。
+
+`incrementor` 函数用来执行实际的增加操作。
+该函数简单地使 `runningTotal` 增加 `amount`，并将其返回。
+
+如果我们单独看这个函数，会发现看上去不同寻常：
+
+```
+func incrementor() -> Int {
+    runningTotal += amount
+    return runningTotal
+}
+```
+
+`incrementor` 函数并没有获取任何参数，但是在函数体内访问了 `runningTotal` 和 `amount` 变量。这是因为其通过捕获在包含它的函数体内已经存在的 `runningTotal` 和 `amount` 变量而实现。
+
+由于没有修改 `amount` 变量，`incrementor` 实际上捕获并存储了该变量的一个副本，而该副本随着 `incrementor` 一同被存储。
+
+然而，因为每次调用该函数的时候都会修改 `runningTotal` 的值，`incrementor` 捕获了当前 `runningTotal` 变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当 `makeIncrementor` 结束时候并不会消失，也保证了当下一次执行 `incrementor` 函数时，`runningTotal` 可以继续增加。
+
+> 注意：
+>
+> Swift 会决定捕获引用还是拷贝值。
+> 您不需要标注 `amount` 或者 `runningTotal` 来声明在嵌入的 `incrementor` 函数中的使用方式。
+> Swift 同时也处理 `runingTotal` 变量的内存管理操作，如果不再被 `incrementor` 函数使用，则会被清除。
+
+下面为一个使用 `makeIncrementor` 的例子：
+
+```
+let incrementByTen = makeIncrementor(forIncrement: 10)
+```
+
+该例子定义了一个叫做 `incrementByTen` 的常量，该常量指向一个每次调用会加10的 `incrementor` 函数。
+调用这个函数多次可以得到以下结果：
+
+```
+incrementByTen()
+// 返回的值为10
+incrementByTen()
+// 返回的值为20
+incrementByTen()
+// 返回的值为30
+```
+
+如果您创建了另一个 `incrementor`，其会有一个属于自己的独立的 `runningTotal` 变量的引用。
+下面的例子中，`incrementBySevne` 捕获了一个新的 `runningTotal` 变量，该变量和 `incrementByTen` 中捕获的变量没有任何联系：
+
+```
+let incrementBySeven = makeIncrementor(forIncrement: 7)
+incrementBySeven()
+// 返回的值为7
+incrementByTen()
+// 返回的值为40
+```
+
+> 注意：
+>
+> 如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
+> 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)。
+
+### 闭包是引用类型
+
+上面的例子中，`incrementBySeven` 和 `incrementByTen` 是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。
+这是因为函数和闭包都是引用类型。
+
+无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。
+上面的例子中，`incrementByTen` 指向闭包的引用是一个常量，而并非闭包内容本身。
+
+这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：
+
+```
+let alsoIncrementByTen = incrementByTen
+alsoIncrementByTen()
+// 返回的值为50
+```
+
+
+
+